@geminixiang/mikan 1.0.0-beta.20 → 1.0.0-beta.21

package/dist/adapters/github/bot.js

@@ -5,12 +5,12 @@ import * as log from "../../log.js";
 import { ensureDirExists, readJsonSchemaFileIfExists } from "../../utils/file-guards.js";
 import { atomicWritePrivateFile } from "../../utils/fs-atomic.js";
 import { resolveChatSessionKey } from "../../sessions/policy.js";
-import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, splitText, withRetry, } from "../shared.js";
+import { appendBotResponseLog, appendChannelLog, MessagingEventQueue, splitText, } from "../shared.js";
 import { processMessageIntake } from "../intake.js";
-import { GithubApiError, GithubClient, githubIsRateLimited } from "./client.js";
-import { CLOUD_BUILD_APP_SLUG, CloudBuildLogUnavailableError, fetchCloudBuildLog, isCloudBuildId, projectFromDetailsUrl, } from "./cloudbuild.js";
+import { GithubClient, GITHUB_MAX_COMMENT_LENGTH, githubRetry } from "./client.js";
 import { createGithubAdapters } from "./context.js";
-import { cloneRepo, GITHUB_PUSH_BRANCH_PATTERN, pushBranch, syncRepo } from "./repo.js";
+import { fetchIsPr, fetchPrHeadBranch, GithubOps } from "./github-ops.js";
+import { cloneRepo, conversationRepoDir } from "./repo.js";
 import { buildGithubConversationId, GITHUB_ISSUE_BODY_TS, githubReviewCommentTs, parseGithubConversationId, parseReviewCommentTs, } from "./ids.js";
 const SyncStateSchema = Type.Object({
     repos: Type.Record(Type.String(), Type.Object({
@@ -47,9 +47,6 @@ const PERMISSION_RANK = {
 const REQUIRED_TRIGGER_RANK = PERMISSION_RANK.write;
 /** Permission lookups are cached this long per repo+user. */
 const PERMISSION_CACHE_TTL_MS = 5 * 60 * 1000;
-const githubRetry = (fn) => withRetry(fn, { isRateLimited: githubIsRateLimited });
-/** GitHub comment bodies cap at 65536 chars; leave headroom for markup. */
-export const GITHUB_MAX_COMMENT_LENGTH = 60000;
 export const formatGithubContinuation = (partNum) => `*(continued ${partNum})*`;
 /** Slack-style emoji short names → GitHub reaction content values. */
 const GITHUB_REACTIONS = {
@@ -117,8 +114,6 @@ export class GithubMessagingBot {
         this.queues = new Map();
         this.repoState = new Map();
         this.permissionCache = new Map();
-        /** Cloud Build ids seen in getChecks summaries → their GCP project. */
-        this.buildRef = new Map();
         this.pollInFlight = false;
         this.handler = handler;
         this.config = config;
@@ -129,6 +124,10 @@ export class GithubMessagingBot {
                     privateKey: config.privateKey,
                     installationId: config.installationId,
                 });
+        this.ops = new GithubOps(this.client, {
+            workingDir: config.workingDir,
+            cloudBuild: config.cloudBuild,
+        });
     }
     // ==========================================================================
     // Public API (implements MessagingBot)
@@ -301,65 +300,30 @@ export class GithubMessagingBot {
         // list mostly echoes the comments list; only issues *created* since the
         // baseline are new conversations (their body is the first message).
         const issues = (await this.client.listIssuesSince(repo.owner, repo.repo, since)) ?? [];
-        for (const issue of issues) {
-            if (issue.updated_at > state.cursor) {
-                state.cursor = issue.updated_at;
-                changed = true;
-            }
-            // Edits re-surface old items with a fresh updated_at; the id watermark
-            // plus the creation baseline decide what actually triggers.
-            if (issue.created_at < state.baseline || state.seenIssues.has(issue.id))
-                continue;
-            state.seenIssues.add(issue.id);
-            changed = true;
-            if (issue.user.type === "Bot")
-                continue;
-            await this.handleIncoming({
+        changed =
+            (await this.advanceFeed(state, state.seenIssues, issues, (issue) => ({
                 ref: { ...repo, number: issue.number },
                 ts: GITHUB_ISSUE_BODY_TS,
                 user: issue.user.login,
                 text: `# ${issue.title}\n\n${issue.body ?? ""}`.trim(),
                 createdAt: issue.created_at,
                 isPr: Boolean(issue.pull_request),
-            });
-        }
+            }))) || changed;
         const comments = (await this.client.listIssueCommentsSince(repo.owner, repo.repo, since)) ?? [];
-        for (const comment of comments) {
-            if (comment.updated_at > state.cursor) {
-                state.cursor = comment.updated_at;
-                changed = true;
-            }
-            if (comment.created_at < state.baseline || state.seenComments.has(comment.id))
-                continue;
-            state.seenComments.add(comment.id);
-            changed = true;
-            if (comment.user.type === "Bot")
-                continue;
-            await this.handleIncoming({
+        changed =
+            (await this.advanceFeed(state, state.seenComments, comments, (comment) => ({
                 ref: { ...repo, number: issueNumberFromUrl(comment.issue_url) },
                 ts: String(comment.id),
                 user: comment.user.login,
                 text: comment.body,
                 createdAt: comment.created_at,
-            });
-        }
+            }))) || changed;
         // Inline PR review comments live in their own endpoint and id space; the
         // same watermark discipline applies. The bot's own thread replies (the
         // github_review_reply tool) re-surface here and are dropped as Bot-authored.
         const reviewComments = (await this.client.listPullReviewCommentsSince(repo.owner, repo.repo, since)) ?? [];
-        for (const comment of reviewComments) {
-            if (comment.updated_at > state.cursor) {
-                state.cursor = comment.updated_at;
-                changed = true;
-            }
-            if (comment.created_at < state.baseline || state.seenReviewComments.has(comment.id)) {
-                continue;
-            }
-            state.seenReviewComments.add(comment.id);
-            changed = true;
-            if (comment.user.type === "Bot")
-                continue;
-            await this.handleIncoming({
+        changed =
+            (await this.advanceFeed(state, state.seenReviewComments, reviewComments, (comment) => ({
                 ref: { ...repo, number: prNumberFromUrl(comment.pull_request_url) },
                 ts: githubReviewCommentTs(comment.id),
                 user: comment.user.login,
@@ -373,13 +337,36 @@ export class GithubMessagingBot {
                     diffHunk: comment.diff_hunk,
                     inReplyToId: comment.in_reply_to_id,
                 },
-            });
-        }
+            }))) || changed;
         pruneSeen(state.seenComments);
         pruneSeen(state.seenIssues);
         pruneSeen(state.seenReviewComments);
         return changed;
     }
+    /**
+     * One feed's watermark advance — the same discipline for all three feeds:
+     * bump the cursor on any fresher updated_at, then let the id watermark plus
+     * the creation baseline decide what actually triggers (edits re-surface old
+     * items with a fresh updated_at). Bot-authored items advance the watermark
+     * without triggering.
+     */
+    async advanceFeed(state, seen, items, toIncoming) {
+        let changed = false;
+        for (const item of items) {
+            if (item.updated_at > state.cursor) {
+                state.cursor = item.updated_at;
+                changed = true;
+            }
+            if (item.created_at < state.baseline || seen.has(item.id))
+                continue;
+            seen.add(item.id);
+            changed = true;
+            if (item.user.type === "Bot")
+                continue;
+            await this.handleIncoming(toIncoming(item));
+        }
+        return changed;
+    }
     // ==========================================================================
     // Private - watermark persistence
     // ==========================================================================
@@ -394,7 +381,8 @@ export class GithubMessagingBot {
             return undefined;
         }
     }
-    persistSyncState() {
+    /** The persisted form of the current watermarks; the test/inspection surface. */
+    syncStateSnapshot() {
         const state = { repos: {} };
         for (const [repoKey, watermark] of this.repoState) {
             state.repos[repoKey] = {
@@ -405,8 +393,11 @@ export class GithubMessagingBot {
                 seenReviewComments: [...watermark.seenReviewComments],
             };
         }
+        return state;
+    }
+    persistSyncState() {
         ensureDirExists(dirname(this.config.syncStatePath));
-        atomicWritePrivateFile(this.config.syncStatePath, JSON.stringify(state));
+        atomicWritePrivateFile(this.config.syncStatePath, JSON.stringify(this.syncStateSnapshot()));
     }
     // ==========================================================================
     // Private - triggering
@@ -535,8 +526,8 @@ export class GithubMessagingBot {
             if (issue && isPrHint === undefined)
                 isPrHint = Boolean(issue.pull_request);
         }
-        if (!existsSync(this.repoDir(conversationId))) {
-            const isPr = isPrHint ?? (await this.fetchIsPr(item.ref));
+        if (!existsSync(conversationRepoDir(this.config.workingDir, conversationId))) {
+            const isPr = isPrHint ?? (await fetchIsPr(this.client, item.ref));
             await this.ensureRepoClone(item.ref, conversationId, isPr);
         }
     }
@@ -614,53 +605,22 @@ export class GithubMessagingBot {
         return issue;
     }
     // ==========================================================================
-    // Repo clone + pull requests
+    // Repo clone
     // ==========================================================================
-    repoDir(conversationId) {
-        return join(this.config.workingDir, conversationId, "repo");
-    }
-    /** Whether the conversation's issue is a PR, for clone retries where the
-     *  triggering item didn't carry that knowledge. Errs toward plain issue. */
-    async fetchIsPr(ref) {
-        try {
-            const issue = await githubRetry(() => this.client.getIssue(ref.owner, ref.repo, ref.number));
-            return Boolean(issue.pull_request);
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * The PR's head branch name when it lives in this repo — that is the name
-     * the local checkout should carry, so committing on it and calling
-     * github_pr pushes back to the PR itself instead of opening a new one.
-     * Fork heads (unpushable with the repo-scoped token) and failed lookups
-     * return undefined; callers then fall back to the synthetic pr-<n>.
-     */
-    async fetchPrHeadBranch(ref) {
-        try {
-            const pr = await githubRetry(() => this.client.getPullRequest(ref.owner, ref.repo, ref.number));
-            const sameRepo = pr.head?.repo?.full_name?.toLowerCase() === `${ref.owner}/${ref.repo}`.toLowerCase();
-            return sameRepo ? pr.head?.ref : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
     /**
      * Clone the conversation's repo into its dir (bind-mounted into the
      * sandbox) using an ephemeral contents:read token that never leaves the
      * host. Non-fatal: a failed clone degrades to the pre-clone experience.
      */
     async ensureRepoClone(ref, conversationId, isPr) {
-        const dir = this.repoDir(conversationId);
+        const dir = conversationRepoDir(this.config.workingDir, conversationId);
         if (existsSync(dir))
             return;
         try {
             const token = await this.client.createScopedInstallationToken(ref.repo, {
                 contents: "read",
             });
-            const prHeadBranch = isPr ? await this.fetchPrHeadBranch(ref) : undefined;
+            const prHeadBranch = isPr ? await fetchPrHeadBranch(this.client, ref) : undefined;
             await cloneRepo({
                 url: `https://github.com/${ref.owner}/${ref.repo}.git`,
                 dir,
@@ -676,356 +636,5 @@ export class GithubMessagingBot {
             log.logWarning(`GitHub: repo clone failed for ${conversationId}`, err instanceof Error ? err.message : String(err));
         }
     }
-    /**
-     * Backs the `github_pr` tool: push a `pi/*` branch the agent prepared in
-     * the conversation's clone, then open a pull request as the App. The write
-     * token is minted per call, scoped to this one repo, and never enters the
-     * sandbox.
-     */
-    async pushAndCreatePr(conversationId, request) {
-        const ref = parseGithubConversationId(conversationId);
-        const dir = this.repoDir(conversationId);
-        if (!existsSync(dir)) {
-            throw new Error("This conversation has no ./repo clone to push from.");
-        }
-        if (!GITHUB_PUSH_BRANCH_PATTERN.test(request.branch)) {
-            throw new Error(`Branch '${request.branch}' is not pushable: name it pi/<something> (e.g. pi/fix-${ref.number}).`);
-        }
-        const repository = await githubRetry(() => this.client.getRepository(ref.owner, ref.repo));
-        const base = request.base ?? repository.default_branch;
-        const token = await this.client.createScopedInstallationToken(ref.repo, {
-            contents: "write",
-            pull_requests: "write",
-        });
-        await pushBranch({ dir, branch: request.branch, token });
-        try {
-            const pr = await githubRetry(() => this.client.createPullRequest(ref.owner, ref.repo, {
-                title: request.title,
-                head: request.branch,
-                base,
-                body: request.body,
-                draft: request.draft,
-            }));
-            log.logInfo(`[${conversationId}] Opened PR #${pr.number}: ${pr.html_url}`);
-            return { number: pr.number, url: pr.html_url };
-        }
-        catch (err) {
-            // Idempotency: pushing more commits to a branch that already has an
-            // open PR updates that PR; the create call then 422s. Surface the
-            // existing PR instead of failing the fix-CI-push-again loop.
-            if (err instanceof GithubApiError &&
-                err.status === 422 &&
-                /already exists/i.test(err.message)) {
-                const existing = await this.client.findOpenPullRequestByBranch(ref.owner, ref.repo, request.branch);
-                if (existing) {
-                    log.logInfo(`[${conversationId}] Pushed to existing PR #${existing.number}: ${existing.html_url}`);
-                    return { number: existing.number, url: existing.html_url, updatedExisting: true };
-                }
-            }
-            throw err;
-        }
-    }
-    /**
-     * Backs the `github_checks` tool: CI check runs for a branch the agent
-     * pushed, or for the conversation's PR head when no branch is given.
-     */
-    async getChecks(conversationId, branch) {
-        const ref = parseGithubConversationId(conversationId);
-        let target = branch;
-        if (!target) {
-            let pr;
-            try {
-                pr = await githubRetry(() => this.client.getPullRequest(ref.owner, ref.repo, ref.number));
-            }
-            catch {
-                pr = null;
-            }
-            if (!pr?.head) {
-                throw new Error("This conversation is not a pull request — pass the branch whose checks you want.");
-            }
-            target = pr.head.sha;
-        }
-        const runs = await githubRetry(() => this.client.listCheckRuns(ref.owner, ref.repo, target));
-        return runs.map((run) => {
-            const externalId = run.external_id?.trim() || null;
-            let buildLogAvailable = false;
-            // Cloud Build runs carry their build UUID in external_id and the GCP
-            // project in details_url. Remember project-by-build so getBuildLog only
-            // serves builds the agent actually saw on this repo's checks.
-            if (this.config.cloudBuild &&
-                run.app?.slug === CLOUD_BUILD_APP_SLUG &&
-                externalId &&
-                isCloudBuildId(externalId)) {
-                const project = projectFromDetailsUrl(run.details_url) ?? this.config.cloudBuild.projectFallback;
-                if (project) {
-                    this.rememberBuild(externalId, project);
-                    buildLogAvailable = true;
-                }
-            }
-            return {
-                id: run.id,
-                name: run.name,
-                status: run.status,
-                conclusion: run.conclusion,
-                url: run.html_url,
-                appSlug: run.app?.slug ?? null,
-                outputSummary: run.output?.summary?.trim() ? run.output.summary.slice(0, 500) : null,
-                externalId,
-                buildLogAvailable,
-            };
-        });
-    }
-    rememberBuild(buildId, project) {
-        // Insertion-ordered Map as a small LRU: re-insert on touch, prune oldest.
-        this.buildRef.delete(buildId);
-        this.buildRef.set(buildId, { project });
-        if (this.buildRef.size > 200) {
-            const oldest = this.buildRef.keys().next().value;
-            if (oldest !== undefined)
-                this.buildRef.delete(oldest);
-        }
-    }
-    /**
-     * Backs the Cloud Build log mode of `github_checks`. GCP credentials stay
-     * host-side (ADC via GOOGLE_APPLICATION_CREDENTIALS — e.g. a Workload
-     * Identity Federation external_account file); the build must have appeared
-     * in a github_checks summary first, which is also where its project is
-     * learned. Unreadable logs degrade to the console url, never a dead end.
-     */
-    async getBuildLog(conversationId, buildId) {
-        if (!this.config.cloudBuild) {
-            throw new Error("Cloud Build log access is not configured on this host (no GCP credentials).");
-        }
-        const known = this.buildRef.get(buildId);
-        if (!known) {
-            throw new Error(`Unknown build id ${buildId}: run github_checks first and take a [build …] id from ` +
-                `the summary.`);
-        }
-        let logText;
-        try {
-            logText = await fetchCloudBuildLog({
-                tokenProvider: this.config.cloudBuild.tokenProvider,
-                project: known.project,
-                buildId,
-            });
-        }
-        catch (err) {
-            if (err instanceof CloudBuildLogUnavailableError) {
-                throw new Error(`${err.message}${err.consoleUrl ? ` Console: ${err.consoleUrl}` : ""} Use the check's ` +
-                    `summary/url from github_checks, or reproduce the failure locally in ./repo.`, { cause: err });
-            }
-            throw err;
-        }
-        const MAX_LOG_CHARS = 20000;
-        return logText.length > MAX_LOG_CHARS
-            ? `…(truncated to the last ${MAX_LOG_CHARS} chars)\n${logText.slice(-MAX_LOG_CHARS)}`
-            : logText;
-    }
-    /**
-     * Backs the `github_sync` tool: refresh the conversation's ./repo clone
-     * from origin with an ephemeral read token. Fetch-only when moving the
-     * checkout could lose agent work; the formatted report tells the agent
-     * what happened and what to do next.
-     */
-    async syncRepo(conversationId, branch) {
-        const ref = parseGithubConversationId(conversationId);
-        const dir = this.repoDir(conversationId);
-        if (!existsSync(dir)) {
-            throw new Error("This conversation has no ./repo clone to sync.");
-        }
-        const token = await this.client.createScopedInstallationToken(ref.repo, {
-            contents: "read",
-        });
-        let prNumber;
-        let prHeadBranch;
-        let defaultBranch;
-        if (!branch) {
-            if (await this.fetchIsPr(ref)) {
-                prNumber = ref.number;
-                prHeadBranch = await this.fetchPrHeadBranch(ref);
-            }
-            else {
-                const repository = await githubRetry(() => this.client.getRepository(ref.owner, ref.repo));
-                defaultBranch = repository.default_branch;
-            }
-        }
-        const result = await syncRepo({ dir, token, branch, prNumber, prHeadBranch, defaultBranch });
-        if (result.updatedCheckout) {
-            return `Updated ./repo: branch ${result.target} is now at ${result.fetchedSha.slice(0, 12)}.`;
-        }
-        const reasons = [];
-        if (result.currentBranch !== result.target) {
-            reasons.push(`the checkout is on '${result.currentBranch}', not '${result.target}'`);
-        }
-        if (result.dirty) {
-            reasons.push("the working tree has uncommitted changes");
-        }
-        if (result.localCommits > 0) {
-            reasons.push(`'${result.target}' has ${result.localCommits} local commit(s) not on origin`);
-        }
-        return (`Fetched ${result.target} to FETCH_HEAD (${result.fetchedSha.slice(0, 12)}) but left the ` +
-            `checkout alone: ${reasons.join("; ")}. Merge or rebase FETCH_HEAD yourself ` +
-            `(e.g. git merge FETCH_HEAD), or commit your work to a pi/* branch first.`);
-    }
-    /**
-     * Backs the `github_read` tool: PR/issue metadata the ./repo clone cannot
-     * provide (diff stats, review state, other issues in the repo). Owner/repo
-     * always come from the conversation id, so reads never leave this repo.
-     */
-    async readGithub(conversationId, request) {
-        const ref = parseGithubConversationId(conversationId);
-        const number = request.number ?? ref.number;
-        switch (request.action) {
-            case "pr": {
-                const pr = await githubRetry(() => this.client.getPullRequest(ref.owner, ref.repo, number));
-                return { kind: "pr", pr };
-            }
-            case "pr_files": {
-                const files = await githubRetry(() => this.client.listPullRequestFiles(ref.owner, ref.repo, number));
-                return { kind: "pr_files", files };
-            }
-            case "pr_reviews": {
-                const [reviews, threads] = await Promise.all([
-                    githubRetry(() => this.client.listPullRequestReviews(ref.owner, ref.repo, number)),
-                    githubRetry(() => this.client.listPullReviewComments(ref.owner, ref.repo, number)),
-                ]);
-                return { kind: "pr_reviews", reviews, threads };
-            }
-            case "issue": {
-                const issue = await githubRetry(() => this.client.getIssue(ref.owner, ref.repo, number));
-                return { kind: "issue", issue };
-            }
-            case "comments": {
-                const comments = await githubRetry(() => this.client.listIssueComments(ref.owner, ref.repo, number));
-                return { kind: "comments", comments };
-            }
-            case "list": {
-                const issues = await githubRetry(() => this.client.listIssues(ref.owner, ref.repo, {
-                    state: request.state,
-                    labels: request.labels,
-                    creator: request.creator,
-                }));
-                return { kind: "list", issues };
-            }
-            default:
-                throw new Error(`Unknown github_read action: ${String(request.action)}`);
-        }
-    }
-    /**
-     * Backs the `github_issue` tool: labels, assignees, and open/closed state
-     * on any issue of this conversation's repo (triage). Same-repo by
-     * construction — owner/repo come from the conversation id; the action enum
-     * is closed, so lock/delete/transfer cannot be expressed at all.
-     */
-    async manageIssue(conversationId, request) {
-        const ref = parseGithubConversationId(conversationId);
-        const number = request.number ?? ref.number;
-        try {
-            switch (request.action) {
-                case "add_labels": {
-                    if (!request.labels?.length) {
-                        throw new Error("add_labels requires a non-empty labels array.");
-                    }
-                    await githubRetry(() => this.client.addIssueLabels(ref.owner, ref.repo, number, request.labels));
-                    return `Added label(s) ${request.labels.join(", ")} to #${number}.`;
-                }
-                case "remove_label": {
-                    if (!request.label) {
-                        throw new Error("remove_label requires a label name.");
-                    }
-                    await githubRetry(() => this.client.removeIssueLabel(ref.owner, ref.repo, number, request.label));
-                    return `Removed label ${request.label} from #${number}.`;
-                }
-                case "add_assignees": {
-                    if (!request.assignees?.length) {
-                        throw new Error("add_assignees requires a non-empty assignees array.");
-                    }
-                    await githubRetry(() => this.client.addIssueAssignees(ref.owner, ref.repo, number, request.assignees));
-                    return `Assigned ${request.assignees.map((login) => `@${login}`).join(", ")} to #${number}.`;
-                }
-                case "remove_assignees": {
-                    if (!request.assignees?.length) {
-                        throw new Error("remove_assignees requires a non-empty assignees array.");
-                    }
-                    await githubRetry(() => this.client.removeIssueAssignees(ref.owner, ref.repo, number, request.assignees));
-                    return `Unassigned ${request.assignees.map((login) => `@${login}`).join(", ")} from #${number}.`;
-                }
-                case "close": {
-                    await githubRetry(() => this.client.updateIssueState(ref.owner, ref.repo, number, "closed", request.state_reason));
-                    return `Closed #${number}${request.state_reason ? ` as ${request.state_reason}` : ""}.`;
-                }
-                case "reopen": {
-                    await githubRetry(() => this.client.updateIssueState(ref.owner, ref.repo, number, "open"));
-                    return `Reopened #${number}.`;
-                }
-                default:
-                    throw new Error(`Unknown github_issue action: ${String(request.action)}`);
-            }
-        }
-        catch (err) {
-            if (err instanceof GithubApiError && err.status === 404) {
-                throw new Error(`Issue #${number} not found in ${ref.owner}/${ref.repo}.`, { cause: err });
-            }
-            throw err;
-        }
-    }
-    /**
-     * Backs the `github_review_reply` tool: answer inside one inline review
-     * thread of this conversation's PR. The comment id comes from an
-     * `[PR review comment rc-<id> …]` message; GitHub validates it belongs to
-     * this PR (404 otherwise, translated into agent-actionable guidance).
-     */
-    async replyToReviewThread(conversationId, commentId, body) {
-        if (!Number.isInteger(commentId) || commentId <= 0) {
-            throw new Error("comment_id must be the numeric id from an [PR review comment rc-<id> …] message.");
-        }
-        const ref = parseGithubConversationId(conversationId);
-        const text = body.length > GITHUB_MAX_COMMENT_LENGTH
-            ? `${body.slice(0, GITHUB_MAX_COMMENT_LENGTH)}\n…(truncated)`
-            : body;
-        try {
-            const reply = await githubRetry(() => this.client.replyToReviewComment(ref.owner, ref.repo, ref.number, commentId, text));
-            return {
-                url: `https://github.com/${ref.owner}/${ref.repo}/pull/${ref.number}#discussion_r${reply.id}`,
-            };
-        }
-        catch (err) {
-            if (err instanceof GithubApiError && err.status === 404) {
-                throw new Error(`Comment ${commentId} is not a review comment on this PR. Take the id from an ` +
-                    `[PR review comment rc-<id> …] message in this conversation; do not guess ids.`, { cause: err });
-            }
-            throw err;
-        }
-    }
-    /**
-     * Backs the log mode of `github_checks`: the tail of one CI job's log so
-     * the agent can diagnose a failing check without sandbox credentials. Only
-     * GitHub Actions checks have logs on GitHub — external CI apps (e.g. Cloud
-     * Build) keep theirs on their own service, so a 404 here is translated
-     * into guidance instead of a dead end.
-     */
-    async getJobLog(conversationId, jobId) {
-        if (!Number.isInteger(jobId) || jobId <= 0) {
-            throw new Error("job_id must be a positive Actions job id taken from a [job …] entry in the github_checks summary.");
-        }
-        const ref = parseGithubConversationId(conversationId);
-        let logText;
-        try {
-            logText = await githubRetry(() => this.client.getJobLog(ref.owner, ref.repo, jobId));
-        }
-        catch (err) {
-            if (err instanceof GithubApiError && err.status === 404) {
-                throw new Error(`No GitHub Actions log for job ${jobId}. Logs are only available for checks reported ` +
-                    `by github-actions; external CI (e.g. Cloud Build) keeps logs on its own service — ` +
-                    `use that check's summary/url from github_checks, or reproduce the failure locally ` +
-                    `in ./repo instead. Do not retry with other ids.`, { cause: err });
-            }
-            throw err;
-        }
-        const MAX_LOG_CHARS = 20000;
-        return logText.length > MAX_LOG_CHARS
-            ? `…(truncated to the last ${MAX_LOG_CHARS} chars)\n${logText.slice(-MAX_LOG_CHARS)}`
-            : logText;
-    }
 }
 //# sourceMappingURL=bot.js.map