287 lines
8.2 KiB
TypeScript
287 lines
8.2 KiB
TypeScript
/**
|
|
* GiteaProvider — IssueProvider implementation for Gitea using REST API.
|
|
*/
|
|
import {
|
|
type IssueProvider,
|
|
type Issue,
|
|
type StateLabel,
|
|
type IssueComment,
|
|
} from "./provider.js";
|
|
import { runCommand } from "../run-command.js";
|
|
import {
|
|
DEFAULT_WORKFLOW,
|
|
getStateLabels,
|
|
getLabelColors,
|
|
type WorkflowConfig,
|
|
} from "../workflow.js";
|
|
|
|
type GiteaIssue = {
|
|
id: number;
|
|
number: number;
|
|
title: string;
|
|
body: string;
|
|
labels: Array<{ id: number; name: string; color: string }>;
|
|
state: "open" | "closed";
|
|
html_url: string;
|
|
url: string;
|
|
};
|
|
|
|
type GiteaComment = {
|
|
user: { login: string };
|
|
body: string;
|
|
created_at: string;
|
|
};
|
|
|
|
type GiteaLabel = {
|
|
id: number;
|
|
name: string;
|
|
color: string;
|
|
};
|
|
|
|
type GiteaPullRequest = {
|
|
id: number;
|
|
number: number;
|
|
state: string;
|
|
merged_at: string | null;
|
|
html_url: string;
|
|
};
|
|
|
|
export class GiteaProvider implements IssueProvider {
|
|
private repoPath: string;
|
|
private workflow: WorkflowConfig;
|
|
private baseUrl: string;
|
|
private token: string;
|
|
private owner: string;
|
|
private repo: string;
|
|
private labelCache: Map<string, number> = new Map();
|
|
|
|
constructor(opts: { repoPath: string; workflow?: WorkflowConfig }) {
|
|
this.repoPath = opts.repoPath;
|
|
this.workflow = opts.workflow ?? DEFAULT_WORKFLOW;
|
|
|
|
// Extract repo info from git remote
|
|
// For now, hardcode for our Gitea instance
|
|
this.baseUrl = "https://pfoster.dynu.net";
|
|
this.token = "1e61c82328feb943f0b9d466ccd2c1eceefb3ee8"; // Our Gitea token
|
|
this.owner = "peter";
|
|
this.repo = "clawd";
|
|
}
|
|
|
|
private async apiRequest(method: string, endpoint: string, data?: any): Promise<any> {
|
|
const url = `${this.baseUrl}/api/v1${endpoint}`;
|
|
|
|
const args = ["curl", "-s", "-X", method, "-H", `Authorization: token ${this.token}`];
|
|
|
|
if (data) {
|
|
args.push("-H", "Content-Type: application/json");
|
|
args.push("-d", JSON.stringify(data));
|
|
}
|
|
|
|
args.push(url);
|
|
|
|
const result = await runCommand(args, { timeoutMs: 30_000 });
|
|
|
|
if (result.stderr) {
|
|
console.error(`Gitea API error for ${method} ${endpoint}:`, result.stderr);
|
|
}
|
|
|
|
if (result.stdout.trim()) {
|
|
try {
|
|
const parsed = JSON.parse(result.stdout);
|
|
if (parsed.message && parsed.message.includes("error")) {
|
|
throw new Error(`Gitea API error: ${parsed.message}`);
|
|
}
|
|
return parsed;
|
|
} catch (err) {
|
|
console.error(`Failed to parse JSON from Gitea API: ${result.stdout.substring(0, 200)}`);
|
|
throw new Error(`Failed to parse JSON from Gitea API: ${(err as Error).message}`);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private async getLabelId(labelName: string): Promise<number> {
|
|
// Check cache first
|
|
if (this.labelCache.has(labelName)) {
|
|
return this.labelCache.get(labelName)!;
|
|
}
|
|
|
|
// Fetch all labels and cache them
|
|
const labels = await this.apiRequest("GET", `/repos/${this.owner}/${this.repo}/labels`) as GiteaLabel[];
|
|
|
|
for (const label of labels) {
|
|
this.labelCache.set(label.name, label.id);
|
|
}
|
|
|
|
const labelId = this.labelCache.get(labelName);
|
|
if (!labelId) {
|
|
throw new Error(`Label "${labelName}" not found in Gitea repo`);
|
|
}
|
|
|
|
return labelId;
|
|
}
|
|
|
|
async ensureLabel(name: string, color: string): Promise<void> {
|
|
try {
|
|
await this.apiRequest("POST", `/repos/${this.owner}/${this.repo}/labels`, {
|
|
name,
|
|
color: color.replace(/^#/, ""),
|
|
});
|
|
} catch (err) {
|
|
const msg = (err as Error).message ?? "";
|
|
// Label might already exist - that's OK
|
|
if (!msg.includes("already exists") && !msg.includes("409")) {
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
|
|
async ensureAllStateLabels(): Promise<void> {
|
|
const labels = getStateLabels(this.workflow);
|
|
const colors = getLabelColors(this.workflow);
|
|
|
|
for (const label of labels) {
|
|
await this.ensureLabel(label, colors[label]);
|
|
}
|
|
}
|
|
|
|
async createIssue(title: string, description: string, label: StateLabel, assignees?: string[]): Promise<Issue> {
|
|
const labelId = await this.getLabelId(label);
|
|
|
|
const data: any = {
|
|
title,
|
|
body: description,
|
|
labels: [labelId],
|
|
};
|
|
|
|
if (assignees?.length) {
|
|
data.assignees = assignees;
|
|
}
|
|
|
|
const result = await this.apiRequest("POST", `/repos/${this.owner}/${this.repo}/issues`, data) as GiteaIssue;
|
|
|
|
if (!result) {
|
|
throw new Error("Failed to create issue: No response from Gitea API");
|
|
}
|
|
|
|
return {
|
|
iid: result.number,
|
|
title: result.title,
|
|
description: result.body || "",
|
|
labels: result.labels ? result.labels.map((l: any) => l.name) : [],
|
|
state: result.state,
|
|
web_url: result.html_url || result.url,
|
|
};
|
|
}
|
|
|
|
async listIssuesByLabel(label: StateLabel): Promise<Issue[]> {
|
|
const result = await this.apiRequest("GET", `/repos/${this.owner}/${this.repo}/issues?labels=${encodeURIComponent(label)}&state=all`) as GiteaIssue[];
|
|
|
|
return (result || []).map((issue: GiteaIssue) => ({
|
|
iid: issue.number,
|
|
title: issue.title,
|
|
description: issue.body || "",
|
|
labels: issue.labels ? issue.labels.map(l => l.name) : [],
|
|
state: issue.state,
|
|
web_url: issue.html_url || issue.url,
|
|
}));
|
|
}
|
|
|
|
async getIssue(issueId: number): Promise<Issue> {
|
|
const result = await this.apiRequest("GET", `/repos/${this.owner}/${this.repo}/issues/${issueId}`) as GiteaIssue;
|
|
|
|
if (!result) {
|
|
throw new Error(`Issue ${issueId} not found`);
|
|
}
|
|
|
|
return {
|
|
iid: result.number,
|
|
title: result.title,
|
|
description: result.body || "",
|
|
labels: result.labels ? result.labels.map((l: any) => l.name) : [],
|
|
state: result.state,
|
|
web_url: result.html_url || result.url,
|
|
};
|
|
}
|
|
|
|
async listComments(issueId: number): Promise<IssueComment[]> {
|
|
const result = await this.apiRequest("GET", `/repos/${this.owner}/${this.repo}/issues/${issueId}/comments`);
|
|
|
|
return (result || []).map((comment: GiteaComment) => ({
|
|
author: comment.user.login,
|
|
body: comment.body,
|
|
created_at: comment.created_at,
|
|
}));
|
|
}
|
|
|
|
async transitionLabel(issueId: number, from: StateLabel, to: StateLabel): Promise<void> {
|
|
// Get current issue to preserve other labels
|
|
const issue = await this.getIssue(issueId);
|
|
const currentLabels = issue.labels.filter(l => l !== from);
|
|
|
|
// Convert label names to IDs
|
|
const labelIds: number[] = [];
|
|
for (const labelName of [...currentLabels, to]) {
|
|
const labelId = await this.getLabelId(labelName);
|
|
labelIds.push(labelId);
|
|
}
|
|
|
|
await this.apiRequest("PATCH", `/repos/${this.owner}/${this.repo}/issues/${issueId}`, {
|
|
labels: labelIds,
|
|
});
|
|
}
|
|
|
|
async closeIssue(issueId: number): Promise<void> {
|
|
await this.apiRequest("PATCH", `/repos/${this.owner}/${this.repo}/issues/${issueId}`, {
|
|
state: "closed",
|
|
});
|
|
}
|
|
|
|
async reopenIssue(issueId: number): Promise<void> {
|
|
await this.apiRequest("PATCH", `/repos/${this.owner}/${this.repo}/issues/${issueId}`, {
|
|
state: "open",
|
|
});
|
|
}
|
|
|
|
hasStateLabel(issue: Issue, expected: StateLabel): boolean {
|
|
return issue.labels.includes(expected);
|
|
}
|
|
|
|
getCurrentStateLabel(issue: Issue): StateLabel | null {
|
|
const stateLabels = getStateLabels(this.workflow);
|
|
for (const label of stateLabels) {
|
|
if (issue.labels.includes(label)) {
|
|
return label;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async hasMergedMR(issueId: number): Promise<boolean> {
|
|
// In Gitea, check if there's a merged pull request linked to this issue
|
|
// For now, return false - we can implement this later
|
|
return false;
|
|
}
|
|
|
|
async getMergedMRUrl(issueId: number): Promise<string | null> {
|
|
// Not implemented yet
|
|
return null;
|
|
}
|
|
|
|
async addComment(issueId: number, body: string): Promise<void> {
|
|
await this.apiRequest("POST", `/repos/${this.owner}/${this.repo}/issues/${issueId}/comments`, {
|
|
body,
|
|
});
|
|
}
|
|
|
|
async healthCheck(): Promise<boolean> {
|
|
try {
|
|
const result = await this.apiRequest("GET", `/repos/${this.owner}/${this.repo}`);
|
|
return !!result && result.full_name === `${this.owner}/${this.repo}`;
|
|
} catch (err) {
|
|
console.error("Gitea health check failed:", err);
|
|
return false;
|
|
}
|
|
}
|
|
} |