@backburner/cli 0.1.0

package/dist/src/github/gateway.js

@@ -0,0 +1,478 @@
+import { SecurityFilteredGitHubGateway } from "./security.js";
+export class UnsecuredGhCliGitHubGateway {
+    commandRunner;
+    constructor(commandRunner) {
+        this.commandRunner = commandRunner;
+    }
+    async getRepositoryMetadata(owner, name) {
+        const data = await this.runGhJson([
+            "repo",
+            "view",
+            `${owner}/${name}`,
+            "--json",
+            "id,name,nameWithOwner,url,defaultBranchRef,owner"
+        ]);
+        const defaultBranch = data.defaultBranchRef?.name?.trim();
+        if (!defaultBranch) {
+            throw new Error(`gh did not return a default branch for ${owner}/${name}`);
+        }
+        return {
+            id: data.id,
+            owner: data.owner?.login?.trim() || owner,
+            name: data.name,
+            nameWithOwner: data.nameWithOwner,
+            url: data.url,
+            defaultBranch
+        };
+    }
+    async getRepositoryDefaultBranch(owner, name) {
+        const metadata = await this.getRepositoryMetadata(owner, name);
+        return metadata.defaultBranch;
+    }
+    async getIssue(owner, name, issueNumber) {
+        return this.runGhJson([
+            "issue",
+            "view",
+            String(issueNumber),
+            "--repo",
+            `${owner}/${name}`,
+            "--json",
+            "id,number,title,body,url,state,createdAt,updatedAt,author,labels"
+        ]);
+    }
+    async getPullRequest(owner, name, prNumber) {
+        const data = await this.runGhJson([
+            "pr",
+            "view",
+            String(prNumber),
+            "--repo",
+            `${owner}/${name}`,
+            "--json",
+            "id,number,title,body,url,state,createdAt,updatedAt,author,labels,headRefName,headRefOid,baseRefName,isDraft"
+        ]);
+        return { ...data, headSha: data.headRefOid || "" };
+    }
+    async findOpenPullRequestByHeadBranch(owner, name, headBranch) {
+        const prs = await this.listOpenPullRequests(owner, name);
+        return prs.find((pr) => pr.headRefName === headBranch) ?? null;
+    }
+    async createPullRequest(input) {
+        const result = await this.commandRunner.run("gh", [
+            "pr",
+            "create",
+            "--repo",
+            `${input.owner}/${input.name}`,
+            "--head",
+            input.headBranch,
+            "--base",
+            input.baseBranch,
+            "--title",
+            input.title,
+            "--body",
+            input.body
+        ]);
+        const created = await this.findOpenPullRequestByHeadBranch(input.owner, input.name, input.headBranch);
+        if (created) {
+            return created;
+        }
+        const createdUrl = extractFirstUrl(result.stdout);
+        if (createdUrl) {
+            return buildFallbackPullRequestSummary(input, createdUrl);
+        }
+        throw new Error(`gh pr create succeeded but the new pull request could not be resolved for branch ${input.headBranch}`);
+    }
+    async listOpenIssues(owner, name) {
+        return this.runGhJson([
+            "issue",
+            "list",
+            "--repo",
+            `${owner}/${name}`,
+            "--state",
+            "open",
+            "--limit",
+            "1000",
+            "--json",
+            "id,number,title,body,url,state,createdAt,updatedAt,author,labels"
+        ]);
+    }
+    async listOpenPullRequests(owner, name) {
+        const data = await this.runGhJson([
+            "pr",
+            "list",
+            "--repo",
+            `${owner}/${name}`,
+            "--state",
+            "open",
+            "--limit",
+            "1000",
+            "--json",
+            "id,number,title,body,url,state,createdAt,updatedAt,author,labels,headRefName,headRefOid,baseRefName,isDraft"
+        ]);
+        return data.map((pr) => ({ ...pr, headSha: pr.headRefOid || "" }));
+    }
+    async listIssueComments(owner, name, issueNumber) {
+        const data = await this.runGhJson([
+            "issue",
+            "view",
+            String(issueNumber),
+            "--repo",
+            `${owner}/${name}`,
+            "--json",
+            "comments"
+        ]);
+        return data.comments ?? [];
+    }
+    async listPullRequestComments(owner, name, prNumber) {
+        const data = await this.runGhJson([
+            "api",
+            "--paginate",
+            "--slurp",
+            `repos/${owner}/${name}/issues/${prNumber}/comments?per_page=100`
+        ]);
+        if (!Array.isArray(data)) {
+            return [];
+        }
+        const flat = (Array.isArray(data[0]) ? data.flat() : data);
+        return flat.map((c) => ({
+            id: String(c.id),
+            url: c.html_url,
+            body: c.body,
+            createdAt: c.created_at,
+            updatedAt: c.updated_at,
+            author: { login: c.user.login }
+        }));
+    }
+    async listPullRequestReviews(owner, name, prNumber) {
+        const data = await this.runGhJson([
+            "pr",
+            "view",
+            String(prNumber),
+            "--repo",
+            `${owner}/${name}`,
+            "--json",
+            "reviews"
+        ]);
+        return data.reviews ?? [];
+    }
+    async listPullRequestReviewComments(owner, name, prNumber) {
+        const data = await this.runGhJson([
+            "api",
+            "--paginate",
+            "--slurp",
+            `repos/${owner}/${name}/pulls/${prNumber}/comments?per_page=100`
+        ]);
+        if (!Array.isArray(data)) {
+            return [];
+        }
+        if (data.length === 0) {
+            return [];
+        }
+        if (Array.isArray(data[0])) {
+            return data.flat();
+        }
+        return data;
+    }
+    async listPullRequestChangedFiles(owner, name, prNumber) {
+        const data = await this.runGhJson([
+            "api",
+            "--paginate",
+            "--slurp",
+            `repos/${owner}/${name}/pulls/${prNumber}/files?per_page=100`
+        ]);
+        if (!Array.isArray(data)) {
+            return [];
+        }
+        const flat = (data.length > 0 && Array.isArray(data[0]) ? data.flat() : data);
+        return flat.map((file) => {
+            const { rightChangedLines, leftChangedLines, rightCommentableLines, leftCommentableLines } = parsePullRequestFilePatch(file.patch ?? "");
+            return {
+                path: file.filename ?? "",
+                rightChangedLines,
+                leftChangedLines,
+                rightCommentableLines,
+                leftCommentableLines
+            };
+        });
+    }
+    async listIssueEvents(owner, name, issueNumber) {
+        const data = await this.runGhJson([
+            "api",
+            "--paginate",
+            "--slurp",
+            `repos/${owner}/${name}/issues/${issueNumber}/events?per_page=100`
+        ]);
+        if (!Array.isArray(data)) {
+            return [];
+        }
+        const flat = (data.length > 0 && Array.isArray(data[0]) ? data.flat() : data);
+        return flat.map((item) => {
+            const eventObj = {
+                event: item.event,
+                createdAt: item.created_at,
+                actor: item.actor ? { login: item.actor.login } : null
+            };
+            if (item.label) {
+                eventObj.label = { name: item.label.name };
+            }
+            return eventObj;
+        });
+    }
+    async listPullRequestCheckRuns(owner, name, headSha) {
+        const data = await this.runGhJson([
+            "api",
+            "--paginate",
+            "--slurp",
+            `repos/${owner}/${name}/commits/${headSha}/check-runs?per_page=100`
+        ]);
+        if (!Array.isArray(data)) {
+            return [];
+        }
+        const checkRuns = data.flatMap((page) => page.check_runs ?? []);
+        return checkRuns.map((run) => ({
+            id: run.id,
+            name: run.name,
+            status: run.status,
+            conclusion: run.conclusion,
+            url: run.html_url,
+            startedAt: run.started_at,
+            completedAt: run.completed_at
+        }));
+    }
+    async searchCode(input) {
+        const searchTerms = [`repo:${input.owner}/${input.name}`, input.query.trim()];
+        if (input.pathPrefix) {
+            searchTerms.push(`path:${input.pathPrefix}`);
+        }
+        const search = new URLSearchParams({
+            q: searchTerms.join(" "),
+            per_page: String(input.limit)
+        });
+        const data = await this.runGhJson(["api", `search/code?${search.toString()}`]);
+        return {
+            totalCount: data.total_count ?? 0,
+            incompleteResults: data.incomplete_results ?? false,
+            items: (data.items ?? []).map((item) => ({
+                name: item.name ?? "",
+                path: item.path ?? "",
+                sha: item.sha ?? "",
+                url: item.url ?? "",
+                gitUrl: item.git_url ?? "",
+                htmlUrl: item.html_url ?? "",
+                repository: {
+                    id: item.repository?.id ?? 0,
+                    fullName: item.repository?.full_name ?? `${input.owner}/${input.name}`,
+                    htmlUrl: item.repository?.html_url ?? `https://github.com/${input.owner}/${input.name}`
+                }
+            }))
+        };
+    }
+    async postIssueComment(input) {
+        const data = await this.runGhJson([
+            "api",
+            `repos/${input.owner}/${input.name}/issues/${input.issueNumber}/comments`,
+            "--method",
+            "POST",
+            "--field",
+            `body=${input.body}`
+        ]);
+        return {
+            id: data.id ?? 0,
+            url: data.html_url ?? "",
+            body: data.body ?? input.body,
+            createdAt: data.created_at ?? "",
+            updatedAt: data.updated_at ?? "",
+            author: data.user?.login ? { login: data.user.login } : null
+        };
+    }
+    async updateIssueComment(input) {
+        const data = await this.runGhJson([
+            "api",
+            `repos/${input.owner}/${input.name}/issues/comments/${input.commentId}`,
+            "--method",
+            "PATCH",
+            "--field",
+            `body=${input.body}`
+        ]);
+        return {
+            id: data.id ?? 0,
+            url: data.html_url ?? "",
+            body: data.body ?? input.body,
+            createdAt: data.created_at ?? "",
+            updatedAt: data.updated_at ?? "",
+            author: data.user?.login ? { login: data.user.login } : null
+        };
+    }
+    async addReaction(input) {
+        const slug = `${input.owner}/${input.name}`;
+        if (input.commentId !== undefined) {
+            const commentPath = input.commentKind === "pull_request_review_comment"
+                ? `/repos/${slug}/pulls/comments/${input.commentId}/reactions`
+                : `/repos/${slug}/issues/comments/${input.commentId}/reactions`;
+            await this.commandRunner.run("gh", [
+                "api",
+                "-X", "POST",
+                commentPath,
+                "-f", `content=${input.content}`
+            ]);
+        }
+        else if (input.issueNumber !== undefined) {
+            await this.commandRunner.run("gh", [
+                "api",
+                "-X", "POST",
+                `/repos/${slug}/issues/${input.issueNumber}/reactions`,
+                "-f", `content=${input.content}`
+            ]);
+        }
+        else {
+            throw new Error(`addReaction requires either issueNumber or commentId`);
+        }
+    }
+    async postPullRequestReviewCommentReply(input) {
+        const data = await this.runGhJson([
+            "api",
+            `repos/${input.owner}/${input.name}/pulls/${input.pullRequestNumber}/comments/${input.commentId}/replies`,
+            "--method",
+            "POST",
+            "--field",
+            `body=${input.body}`
+        ]);
+        return {
+            id: data.id ?? 0,
+            url: data.html_url ?? "",
+            body: data.body ?? input.body,
+            createdAt: data.created_at ?? "",
+            updatedAt: data.updated_at ?? "",
+            author: data.user?.login ? { login: data.user.login } : null
+        };
+    }
+    async submitPullRequestReview(input) {
+        const payload = {
+            event: input.event,
+            ...(input.body ? { body: input.body } : {}),
+            ...(input.commitId ? { commit_id: input.commitId } : {}),
+            ...(input.comments?.length
+                ? {
+                    comments: input.comments.map((comment) => ({
+                        path: comment.path,
+                        line: comment.line,
+                        side: comment.side ?? "RIGHT",
+                        ...(comment.startLine ? { start_line: comment.startLine } : {}),
+                        ...(comment.startSide ? { start_side: comment.startSide } : {}),
+                        body: comment.body
+                    }))
+                }
+                : {})
+        };
+        const data = await this.runGhJson([
+            "api",
+            `repos/${input.owner}/${input.name}/pulls/${input.pullRequestNumber}/reviews`,
+            "--method",
+            "POST",
+            "--input",
+            "-"
+        ], JSON.stringify(payload));
+        return {
+            id: data.id ?? 0,
+            url: data.html_url ?? "",
+            body: data.body ?? input.body ?? "",
+            state: data.state ?? input.event,
+            submittedAt: data.submitted_at ?? "",
+            author: data.user?.login ? { login: data.user.login } : null
+        };
+    }
+    async runGhJson(args, input) {
+        const result = await this.commandRunner.run("gh", args, input === undefined ? undefined : { input });
+        try {
+            return JSON.parse(result.stdout);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`gh ${args.join(" ")}: invalid JSON (${message})`);
+        }
+    }
+}
+function parsePullRequestFilePatch(patch) {
+    const rightChangedLines = [];
+    const leftChangedLines = [];
+    const rightCommentableLines = [];
+    const leftCommentableLines = [];
+    if (!patch) {
+        return {
+            rightChangedLines,
+            leftChangedLines,
+            rightCommentableLines,
+            leftCommentableLines
+        };
+    }
+    const lines = patch.split(/\r?\n/);
+    let currentOldLine = 0;
+    let currentNewLine = 0;
+    let inHunk = false;
+    for (const line of lines) {
+        if (line.startsWith("@@ ")) {
+            const headerMatch = line.match(/@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+            if (headerMatch && headerMatch[1] && headerMatch[2]) {
+                currentOldLine = parseInt(headerMatch[1], 10);
+                currentNewLine = parseInt(headerMatch[2], 10);
+                inHunk = true;
+            }
+            continue;
+        }
+        if (!inHunk) {
+            continue;
+        }
+        if (line.startsWith("+")) {
+            rightChangedLines.push(currentNewLine);
+            rightCommentableLines.push(currentNewLine);
+            currentNewLine++;
+        }
+        else if (line.startsWith("-")) {
+            leftChangedLines.push(currentOldLine);
+            leftCommentableLines.push(currentOldLine);
+            currentOldLine++;
+        }
+        else if (line.startsWith(" ")) {
+            leftCommentableLines.push(currentOldLine);
+            rightCommentableLines.push(currentNewLine);
+            currentOldLine++;
+            currentNewLine++;
+        }
+        else if (line.startsWith("\\")) {
+            // No newline at end of file, ignore
+        }
+    }
+    return {
+        rightChangedLines,
+        leftChangedLines,
+        rightCommentableLines,
+        leftCommentableLines
+    };
+}
+function extractFirstUrl(value) {
+    const match = value.match(/https:\/\/github\.com\/[^\s]+/);
+    return match?.[0];
+}
+function buildFallbackPullRequestSummary(input, url) {
+    const numberMatch = url.match(/\/pull\/(\d+)(?:\/?|$)/);
+    return {
+        id: `pull_request:${input.owner}/${input.name}:${numberMatch?.[1] ?? "unknown"}`,
+        number: numberMatch?.[1] ? Number(numberMatch[1]) : 0,
+        title: input.title,
+        body: input.body,
+        url,
+        state: "OPEN",
+        createdAt: "",
+        updatedAt: "",
+        author: null,
+        labels: [],
+        headRefName: input.headBranch,
+        headSha: "",
+        baseRefName: input.baseBranch,
+        isDraft: false
+    };
+}
+export class GhCliGitHubGateway extends SecurityFilteredGitHubGateway {
+    constructor(commandRunner, allowedUsers) {
+        super(new UnsecuredGhCliGitHubGateway(commandRunner), allowedUsers);
+    }
+}

package/dist/src/github/normalize.js

@@ -0,0 +1,222 @@
+import { classifyPullRequestBase } from "./pr-classification.js";
+export function normalizeIssue(issue, comments, context) {
+    const id = createEntityId("issue", context.repoMetadata.nameWithOwner, issue.number);
+    const previous = context.previousIssues.get(id);
+    return {
+        kind: "issue",
+        id,
+        repoId: context.repo.id,
+        repoKey: context.repoMetadata.nameWithOwner,
+        repoOwner: context.repoMetadata.owner,
+        repoName: context.repoMetadata.name,
+        repoSlug: context.repoMetadata.nameWithOwner,
+        number: issue.number,
+        key: createEntityKey("issue", context.repoMetadata.nameWithOwner, issue.number),
+        sourceId: String(issue.id),
+        url: issue.url,
+        title: issue.title,
+        body: issue.body ?? "",
+        labels: normalizeLabels(issue.labels),
+        author: normalizeActor(issue.author?.login),
+        createdAt: issue.createdAt,
+        updatedAt: issue.updatedAt,
+        ...withOptionalTimestamps(findLastCommentAt(comments), context.seenAt, previous?.lastHandledAt),
+        state: normalizeIssueState(issue.state)
+    };
+}
+export function normalizePullRequest(pr, comments, context) {
+    const id = createEntityId("pull_request", context.repoMetadata.nameWithOwner, pr.number);
+    const previous = context.previousPullRequests.get(id);
+    return {
+        kind: "pull_request",
+        id,
+        repoId: context.repo.id,
+        repoKey: context.repoMetadata.nameWithOwner,
+        repoOwner: context.repoMetadata.owner,
+        repoName: context.repoMetadata.name,
+        repoSlug: context.repoMetadata.nameWithOwner,
+        number: pr.number,
+        key: createEntityKey("pull_request", context.repoMetadata.nameWithOwner, pr.number),
+        sourceId: String(pr.id),
+        url: pr.url,
+        title: pr.title,
+        body: pr.body ?? "",
+        labels: normalizeLabels(pr.labels),
+        author: normalizeActor(pr.author?.login),
+        createdAt: pr.createdAt,
+        updatedAt: pr.updatedAt,
+        ...withOptionalTimestamps(findLastCommentAt(comments), context.seenAt, previous?.lastHandledAt),
+        state: normalizePullRequestState(pr.state),
+        headBranch: pr.headRefName,
+        headSha: pr.headSha ?? "",
+        baseBranch: pr.baseRefName,
+        defaultBranch: context.repoMetadata.defaultBranch,
+        baseClassification: classifyPullRequestBase({
+            pullRequestNumber: pr.number,
+            repoSlug: context.repoMetadata.nameWithOwner,
+            baseBranch: pr.baseRefName,
+            defaultBranch: context.repoMetadata.defaultBranch
+        }).kind,
+        isDraft: pr.isDraft
+    };
+}
+export function normalizeIssueComments(comments, parentNumber, parentType, commentKind, context) {
+    return comments.map((comment) => normalizeComment({
+        sourceId: String(comment.id),
+        url: comment.url,
+        body: comment.body ?? "",
+        createdAt: comment.createdAt,
+        updatedAt: comment.updatedAt,
+        author: normalizeActor(comment.author?.login),
+        parentNumber,
+        parentType,
+        commentKind,
+        context,
+        reactionTargetId: String(comment.id)
+    }));
+}
+export function normalizePullRequestReviews(reviews, parentNumber, context) {
+    return reviews
+        .filter((review) => (review.body ?? "").trim() !== "")
+        .map((review) => {
+        const createdAt = review.submittedAt ?? review.updatedAt;
+        const updatedAt = review.updatedAt ?? review.submittedAt;
+        if (!createdAt || !updatedAt) {
+            throw new Error(`PR review ${review.id} in ${context.repoMetadata.nameWithOwner} is missing timestamps`);
+        }
+        return normalizeComment({
+            sourceId: String(review.id),
+            url: review.url ?? "",
+            body: review.body ?? "",
+            createdAt,
+            updatedAt,
+            author: normalizeActor(review.author?.login),
+            parentNumber,
+            parentType: "pull_request",
+            commentKind: "pull_request_review",
+            context,
+            reactionTargetId: String(review.id)
+        });
+    });
+}
+export function normalizePullRequestReviewComments(comments, parentNumber, context) {
+    return comments.map((comment) => normalizeComment({
+        sourceId: String(comment.id),
+        url: comment.html_url ?? "",
+        body: comment.body ?? "",
+        createdAt: comment.created_at,
+        updatedAt: comment.updated_at,
+        author: normalizeActor(comment.user?.login),
+        parentNumber,
+        parentType: "pull_request",
+        commentKind: "pull_request_review_comment",
+        context,
+        reactionTargetId: String(comment.id),
+        pullRequestReviewLocation: buildPullRequestReviewLocation(comment)
+    }));
+}
+export function buildPullRequestReviewLocation(comment) {
+    const location = {
+        path: comment.path ?? undefined,
+        line: comment.line ?? undefined,
+        side: comment.side ?? undefined,
+        startLine: comment.start_line ?? undefined,
+        startSide: comment.start_side ?? undefined,
+        originalLine: comment.original_line ?? undefined,
+        originalStartLine: comment.original_start_line ?? undefined,
+        commitId: comment.commit_id ?? undefined,
+        originalCommitId: comment.original_commit_id ?? undefined,
+        diffHunk: comment.diff_hunk ?? undefined,
+        inReplyToId: comment.in_reply_to_id ?? undefined
+    };
+    function hasMeaningfulLocationValue(value) {
+        if (typeof value === "string") {
+            return value.trim().length > 0;
+        }
+        if (typeof value === "number") {
+            return true;
+        }
+        return false;
+    }
+    const hasMeaningfulField = [
+        comment.path,
+        comment.line,
+        comment.start_line,
+        comment.original_line,
+        comment.original_start_line,
+        comment.diff_hunk,
+        comment.commit_id,
+        comment.original_commit_id,
+        comment.in_reply_to_id,
+        comment.side,
+        comment.start_side
+    ].some(hasMeaningfulLocationValue);
+    return hasMeaningfulField ? location : undefined;
+}
+export function createEntityId(kind, repoSlug, number) {
+    return `${kind}:${repoSlug}:${number}`;
+}
+export function createEntityKey(kind, repoSlug, number) {
+    return `${repoSlug}:${kind}:${number}`;
+}
+export function createCommentId(repoSlug, commentKind, sourceId) {
+    return `comment:${repoSlug}:${commentKind}:${sourceId}`;
+}
+export function normalizeComment(input) {
+    const id = createCommentId(input.context.repoMetadata.nameWithOwner, input.commentKind, input.sourceId);
+    const previous = input.context.previousComments.get(id);
+    return {
+        ...previous,
+        kind: "comment",
+        commentKind: input.commentKind,
+        id,
+        sourceId: input.sourceId,
+        repoId: input.context.repo.id,
+        repoKey: input.context.repoMetadata.nameWithOwner,
+        repoOwner: input.context.repoMetadata.owner,
+        repoName: input.context.repoMetadata.name,
+        repoSlug: input.context.repoMetadata.nameWithOwner,
+        parentType: input.parentType,
+        parentNumber: input.parentNumber,
+        parentKey: createEntityKey(input.parentType === "issue" ? "issue" : "pull_request", input.context.repoMetadata.nameWithOwner, input.parentNumber),
+        url: input.url,
+        body: input.body,
+        author: input.author,
+        createdAt: input.createdAt,
+        updatedAt: input.updatedAt,
+        reactionTargetId: input.reactionTargetId,
+        lastSeenAt: input.context.seenAt,
+        ...(previous?.lastHandledAt ? { lastHandledAt: previous.lastHandledAt } : {}),
+        ...(input.pullRequestReviewLocation ? { pullRequestReviewLocation: input.pullRequestReviewLocation } : {}),
+    };
+}
+function normalizeActor(login) {
+    return login?.trim() || "unknown";
+}
+function normalizeLabels(labels) {
+    return (labels ?? []).map((label) => label.name).sort((left, right) => left.localeCompare(right));
+}
+function normalizeIssueState(state) {
+    return state === "OPEN" ? "open" : "closed";
+}
+function normalizePullRequestState(state) {
+    if (state === "MERGED") {
+        return "merged";
+    }
+    return state === "OPEN" ? "open" : "closed";
+}
+function findLastCommentAt(comments) {
+    return comments.reduce((latest, comment) => {
+        if (!latest) {
+            return comment.updatedAt;
+        }
+        return comment.updatedAt > latest ? comment.updatedAt : latest;
+    }, undefined);
+}
+function withOptionalTimestamps(lastCommentAt, lastSeenAt, lastHandledAt) {
+    return {
+        ...(lastCommentAt ? { lastCommentAt } : {}),
+        ...(lastSeenAt ? { lastSeenAt } : {}),
+        ...(lastHandledAt ? { lastHandledAt } : {})
+    };
+}