@developerz.ai/aitm 0.0.0

package/dist/credentials/credentials.js

@@ -0,0 +1,58 @@
+// docs/auth.md, docs/runtime.md, docs/config.md
+// Maps subagent role → capability tier → OpenRouter model handle.
+// Never reads config files or env directly — that's ConfigLoader's job.
+// SDK reference: docs/vendor/ai-sdk/chunk-09.md §"Subagents", chunk-04.md §"ToolLoopAgent".
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { DEFAULT_MODELS } from "./defaults.js";
+export const ROLE_CAPABILITY = {
+    planner: 'smart',
+    worker: 'coding',
+    reviewer: 'smart',
+    orchestrator: 'fast',
+};
+export class Credentials {
+    resolved;
+    // Lazy: provider creation also asserts the API key is present, so callers that
+    // only inspect role/capability mapping (tests, dry-run) don't need a real key.
+    providerInstance;
+    constructor(resolved) {
+        this.resolved = resolved;
+    }
+    // Build a handle per role using ROLE_CAPABILITY. Capability fallback chain:
+    //   models[capability] → models.generic → built-in default.
+    handles() {
+        return {
+            planner: this.modelFor('planner'),
+            worker: this.modelFor('worker'),
+            reviewer: this.modelFor('reviewer'),
+            orchestrator: this.modelFor('orchestrator'),
+        };
+    }
+    modelFor(role) {
+        return this.modelForCapability(ROLE_CAPABILITY[role]);
+    }
+    modelForCapability(capability) {
+        const modelId = this.resolved.models[capability] ||
+            this.resolved.models.generic ||
+            DEFAULT_MODELS[capability];
+        // Subagents lean on structured output (Output.object). OpenRouter may route a model to a
+        // provider — notably Amazon Bedrock — that rejects the AI SDK's structured-output request
+        // (`output_config.format`), failing the Planner/Worker/Reviewer at random. Skip Bedrock so
+        // those calls land on a provider that accepts the parameter.
+        return this.provider().chat(modelId, { provider: { ignore: ['amazon-bedrock'] } });
+    }
+    // Lets CLI fail fast before any LLM call (docs/commands/start.md §Preconditions step 2).
+    static assertApiKeyPresent(resolved) {
+        if (!resolved.openrouterApiKey || resolved.openrouterApiKey.trim() === '') {
+            throw new Error('OPENROUTER_API_KEY is missing. Set OPENROUTER_API_KEY in the environment, or run `aitm config set openrouterApiKey <key>` (get one at https://openrouter.ai/keys).');
+        }
+    }
+    provider() {
+        if (!this.providerInstance) {
+            Credentials.assertApiKeyPresent(this.resolved);
+            this.providerInstance = createOpenRouter({ apiKey: this.resolved.openrouterApiKey });
+        }
+        return this.providerInstance;
+    }
+}
+//# sourceMappingURL=credentials.js.map

package/dist/credentials/credentials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.js","sourceRoot":"","sources":["../../src/credentials/credentials.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,kEAAkE;AAClE,wEAAwE;AACxE,4FAA4F;AAE5F,OAAO,EAAE,gBAAgB,EAA2B,MAAM,6BAA6B,CAAC;AAGxF,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAI/C,MAAM,CAAC,MAAM,eAAe,GAAuC;IACjE,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,OAAO;IACjB,YAAY,EAAE,MAAM;CACrB,CAAC;AAIF,MAAM,OAAO,WAAW;IAKO;IAJ7B,+EAA+E;IAC/E,+EAA+E;IACvE,gBAAgB,CAAiC;IAEzD,YAA6B,QAAwB;QAAxB,aAAQ,GAAR,QAAQ,CAAgB;IAAG,CAAC;IAEzD,4EAA4E;IAC5E,4DAA4D;IAC5D,OAAO;QACL,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;YACjC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC/B,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC;YACnC,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;SAC5C,CAAC;IACJ,CAAC;IAED,QAAQ,CAAC,IAAU;QACjB,OAAO,IAAI,CAAC,kBAAkB,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,kBAAkB,CAAC,UAAsB;QACvC,MAAM,OAAO,GACX,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC;YAChC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO;YAC5B,cAAc,CAAC,UAAU,CAAC,CAAC;QAC7B,yFAAyF;QACzF,0FAA0F;QAC1F,2FAA2F;QAC3F,6DAA6D;QAC7D,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,CAAC,gBAAgB,CAAC,EAAE,EAAE,CAAC,CAAC;IACrF,CAAC;IAED,yFAAyF;IACzF,MAAM,CAAC,mBAAmB,CAAC,QAAwB;QACjD,IAAI,CAAC,QAAQ,CAAC,gBAAgB,IAAI,QAAQ,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC1E,MAAM,IAAI,KAAK,CACb,oKAAoK,CACrK,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,QAAQ;QACd,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC3B,WAAW,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC/C,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,CAAC;QACvF,CAAC;QACD,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;CACF"}

package/dist/credentials/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { Capability } from '../config/schema.ts';
+export declare const DEFAULT_MODELS: Record<Capability, string>;

package/dist/credentials/defaults.js

@@ -0,0 +1,21 @@
+// Canonical capability defaults — all OpenRouter routes (docs/auth.md §"LLM provider").
+// User-set models.{generic,smart,coding,fast} always wins; these only fill gaps.
+//
+// We don't fork defaults by AgentConfigFlavor (CLAUDE.md vs AGENTS.md). Flavor is a
+// *style* signal, not a *vendor* signal — every model goes through OpenRouter, so a
+// project's convention file does not constrain which model serves a request. The
+// flavor only affects which markdown is fed to subagent system prompts.
+//
+// docs/agent-config-detection.md, docs/config.md, docs/runtime.md
+// Tier mapping rationale (Claude family via OpenRouter — the most flexible coding stack today):
+//   haiku  → fast    : routing, orchestration, summarization (toModelOutput compaction)
+//   sonnet → generic : default fallback for any unspecified tier
+//   opus   → smart   : Planner, Reviewer (architectural reasoning, critique)
+//   opus   → coding  : Worker (best-in-class code generation)
+export const DEFAULT_MODELS = {
+    fast: 'anthropic/claude-haiku-4.5',
+    generic: 'anthropic/claude-sonnet-4.6',
+    smart: 'anthropic/claude-opus-4.7',
+    coding: 'anthropic/claude-opus-4.7',
+};
+//# sourceMappingURL=defaults.js.map

package/dist/credentials/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../src/credentials/defaults.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,iFAAiF;AACjF,EAAE;AACF,oFAAoF;AACpF,oFAAoF;AACpF,iFAAiF;AACjF,wEAAwE;AACxE,EAAE;AACF,kEAAkE;AAIlE,gGAAgG;AAChG,wFAAwF;AACxF,iEAAiE;AACjE,6EAA6E;AAC7E,8DAA8D;AAC9D,MAAM,CAAC,MAAM,cAAc,GAA+B;IACxD,IAAI,EAAE,4BAA4B;IAClC,OAAO,EAAE,6BAA6B;IACtC,KAAK,EAAE,2BAA2B;IAClC,MAAM,EAAE,2BAA2B;CACpC,CAAC"}

package/dist/fs/atomic-write.d.ts

@@ -0,0 +1 @@
+export declare function atomicWrite(path: string, contents: string): Promise<void>;

package/dist/fs/atomic-write.js

@@ -0,0 +1,27 @@
+// Shared atomic-file primitive. Temp file + fsync + rename so readers never see
+// a half-written file. Used by ConfigLoader.writeSnapshot, ConfigWriter, StateStore.
+//
+// Temp name carries a random suffix so concurrent writes to the same path don't
+// clobber each other's in-flight temp file. Mode 0o600 keeps secret-bearing
+// config files owner-readable only on POSIX.
+import { randomUUID } from 'node:crypto';
+import { open, rename, rm } from 'node:fs/promises';
+export async function atomicWrite(path, contents) {
+    const tmp = `${path}.${randomUUID()}.tmp`;
+    const fh = await open(tmp, 'wx', 0o600);
+    try {
+        await fh.writeFile(contents);
+        await fh.sync();
+    }
+    finally {
+        await fh.close();
+    }
+    try {
+        await rename(tmp, path);
+    }
+    catch (err) {
+        await rm(tmp, { force: true });
+        throw err;
+    }
+}
+//# sourceMappingURL=atomic-write.js.map

package/dist/fs/atomic-write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-write.js","sourceRoot":"","sources":["../../src/fs/atomic-write.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,qFAAqF;AACrF,EAAE;AACF,gFAAgF;AAChF,4EAA4E;AAC5E,6CAA6C;AAE7C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,IAAY,EAAE,QAAgB;IAC9D,MAAM,GAAG,GAAG,GAAG,IAAI,IAAI,UAAU,EAAE,MAAM,CAAC;IAC1C,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IACxC,IAAI,CAAC;QACH,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC7B,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC;IAClB,CAAC;YAAS,CAAC;QACT,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC;IACnB,CAAC;IACD,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAC1B,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/B,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC"}

package/dist/github/errors.d.ts

@@ -0,0 +1,18 @@
+export declare class PrNotFound extends Error {
+    readonly name = "PrNotFound";
+}
+export declare class ReviewThreadStale extends Error {
+    readonly name = "ReviewThreadStale";
+}
+export declare class CiFailed extends Error {
+    readonly name = "CiFailed";
+}
+export declare class GhCliMissing extends Error {
+    readonly name = "GhCliMissing";
+}
+export declare class GhAuthRequired extends Error {
+    readonly name = "GhAuthRequired";
+}
+export declare class MergeConflict extends Error {
+    readonly name = "MergeConflict";
+}

package/dist/github/errors.js

@@ -0,0 +1,20 @@
+// docs/github-integration.md §"Result typing" — never raw stderr; always domain errors.
+export class PrNotFound extends Error {
+    name = 'PrNotFound';
+}
+export class ReviewThreadStale extends Error {
+    name = 'ReviewThreadStale';
+}
+export class CiFailed extends Error {
+    name = 'CiFailed';
+}
+export class GhCliMissing extends Error {
+    name = 'GhCliMissing';
+}
+export class GhAuthRequired extends Error {
+    name = 'GhAuthRequired';
+}
+export class MergeConflict extends Error {
+    name = 'MergeConflict';
+}
+//# sourceMappingURL=errors.js.map

package/dist/github/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/github/errors.ts"],"names":[],"mappings":"AAAA,wFAAwF;AAExF,MAAM,OAAO,UAAW,SAAQ,KAAK;IACjB,IAAI,GAAG,YAAY,CAAC;CACvC;AAED,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IACxB,IAAI,GAAG,mBAAmB,CAAC;CAC9C;AAED,MAAM,OAAO,QAAS,SAAQ,KAAK;IACf,IAAI,GAAG,UAAU,CAAC;CACrC;AAED,MAAM,OAAO,YAAa,SAAQ,KAAK;IACnB,IAAI,GAAG,cAAc,CAAC;CACzC;AAED,MAAM,OAAO,cAAe,SAAQ,KAAK;IACrB,IAAI,GAAG,gBAAgB,CAAC;CAC3C;AAED,MAAM,OAAO,aAAc,SAAQ,KAAK;IACpB,IAAI,GAAG,eAAe,CAAC;CAC1C"}

package/dist/github/github-client.d.ts

@@ -0,0 +1,47 @@
+import { type CheckStatus, type PullRequest, type ReviewThread } from './schema.ts';
+export type CreatePrInput = {
+    title: string;
+    body: string;
+    base: string;
+    head: string;
+    draft?: boolean;
+    labels?: string[];
+};
+export declare const DEFAULT_PR_LABEL = "ai-task-master";
+export type MergeMethod = 'squash' | 'merge' | 'rebase';
+export type RunCmdOptions = {
+    cwd?: string;
+};
+export type RunCmdResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+};
+export type RunCmd = (file: string, args: readonly string[], options?: RunCmdOptions) => Promise<RunCmdResult>;
+export declare const defaultRunCmd: RunCmd;
+export type Sleep = (ms: number) => Promise<void>;
+export declare const defaultSleep: Sleep;
+export declare const CHECKS_INITIAL_DELAY_MS = 1000;
+export declare const CHECKS_MAX_DELAY_MS = 60000;
+export declare class GitHubClient {
+    private readonly cwd;
+    private readonly runCmd;
+    private readonly sleep;
+    constructor(cwd: string, runCmd?: RunCmd, sleep?: Sleep);
+    currentBranch(): Promise<string>;
+    defaultBranch(): Promise<string>;
+    getPrForBranch(branch: string): Promise<PullRequest | null>;
+    createPr(input: CreatePrInput): Promise<PullRequest>;
+    waitForChecks(pr: number): Promise<CheckStatus>;
+    listUnresolvedThreads(pr: number): Promise<ReviewThread[]>;
+    private paginateReviewThreads;
+    private paginateThreadComments;
+    replyToThread(threadId: string, body: string): Promise<void>;
+    resolveThread(threadId: string): Promise<void>;
+    private repoMeta;
+    mergePr(pr: number, method: MergeMethod): Promise<void>;
+    authStatus(): Promise<{
+        ok: boolean;
+        scopes: string[];
+    }>;
+}

package/dist/github/github-client.js

@@ -0,0 +1,417 @@
+// docs/github-integration.md, docs/auth.md §"GitHub"
+// Only module allowed to shell out to gh. Uses execa (docs/runtime.md — Bun.$ forbidden in src/).
+import { ExecaError, execa } from 'execa';
+import { z } from 'zod';
+import { CiFailed, MergeConflict } from "./errors.js";
+import { PullRequestSchema, } from "./schema.js";
+export const DEFAULT_PR_LABEL = 'ai-task-master';
+export const defaultRunCmd = async (file, args, options) => {
+    try {
+        const r = await execa(file, [...args], options?.cwd ? { cwd: options.cwd } : {});
+        return {
+            stdout: typeof r.stdout === 'string' ? r.stdout : '',
+            stderr: typeof r.stderr === 'string' ? r.stderr : '',
+            exitCode: r.exitCode ?? 0,
+        };
+    }
+    catch (err) {
+        if (err instanceof ExecaError) {
+            return {
+                stdout: typeof err.stdout === 'string' ? err.stdout : '',
+                stderr: typeof err.stderr === 'string' ? err.stderr : '',
+                exitCode: err.exitCode ?? 1,
+            };
+        }
+        throw err;
+    }
+};
+export const defaultSleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+export const CHECKS_INITIAL_DELAY_MS = 1000;
+export const CHECKS_MAX_DELAY_MS = 60_000;
+export class GitHubClient {
+    cwd;
+    runCmd;
+    sleep;
+    // Capability matrix — docs/github-integration.md §"Capabilities".
+    // Backoff — docs/github-integration.md §"Rate limits" (1s, doubling, 60s cap).
+    constructor(cwd, runCmd = defaultRunCmd, sleep = defaultSleep) {
+        this.cwd = cwd;
+        this.runCmd = runCmd;
+        this.sleep = sleep;
+    }
+    async currentBranch() {
+        const r = await this.runCmd('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: this.cwd });
+        if (r.exitCode !== 0) {
+            throw new Error(`git rev-parse failed: ${r.stderr.trim() || r.stdout.trim()}`);
+        }
+        return r.stdout.trim();
+    }
+    async defaultBranch() {
+        const r = await this.runCmd('gh', ['repo', 'view', '--json', 'defaultBranchRef'], {
+            cwd: this.cwd,
+        });
+        if (r.exitCode !== 0) {
+            throw new Error(`gh repo view failed: ${r.stderr.trim() || r.stdout.trim()}`);
+        }
+        const parsed = JSON.parse(r.stdout);
+        if (typeof parsed === 'object' &&
+            parsed !== null &&
+            'defaultBranchRef' in parsed &&
+            typeof parsed.defaultBranchRef === 'object' &&
+            parsed.defaultBranchRef !== null &&
+            'name' in parsed.defaultBranchRef &&
+            typeof parsed.defaultBranchRef.name === 'string') {
+            return parsed.defaultBranchRef.name;
+        }
+        throw new Error(`gh repo view: unexpected JSON shape: ${r.stdout}`);
+    }
+    async getPrForBranch(branch) {
+        const r = await this.runCmd('gh', ['pr', 'view', branch, '--json', 'number,state,url,headRefName,baseRefName'], { cwd: this.cwd });
+        if (r.exitCode !== 0) {
+            if (isPrNotFoundStderr(r.stderr))
+                return null;
+            throw new Error(`gh pr view failed: ${r.stderr.trim() || r.stdout.trim()}`);
+        }
+        return PullRequestSchema.parse(JSON.parse(r.stdout));
+    }
+    async createPr(input) {
+        const labels = input.labels ?? [DEFAULT_PR_LABEL];
+        const args = [
+            'pr',
+            'create',
+            '--title',
+            input.title,
+            '--body',
+            input.body,
+            '--base',
+            input.base,
+            '--head',
+            input.head,
+        ];
+        if (input.draft)
+            args.push('--draft');
+        for (const label of labels)
+            args.push('--label', label);
+        // `gh pr create --label X` fails if X doesn't exist yet — which it won't on a fresh repo the
+        // first time aitm opens a PR. Ensure each label exists first (idempotent via --force; the
+        // result is intentionally not checked so a labels-permission gap doesn't block PR creation).
+        for (const label of labels) {
+            await this.runCmd('gh', ['label', 'create', label, '--force'], { cwd: this.cwd });
+        }
+        const r = await this.runCmd('gh', args, { cwd: this.cwd });
+        if (r.exitCode !== 0) {
+            throw new Error(`gh pr create failed: ${r.stderr.trim() || r.stdout.trim()}`);
+        }
+        // gh prints the PR URL to stdout; we re-fetch to get the full typed shape.
+        const pr = await this.getPrForBranch(input.head);
+        if (!pr) {
+            throw new Error(`gh pr create succeeded for ${input.head} but PR lookup returned null (stdout: ${r.stdout.trim()})`);
+        }
+        return pr;
+    }
+    async waitForChecks(pr) {
+        let delay = CHECKS_INITIAL_DELAY_MS;
+        while (true) {
+            const r = await this.runCmd('gh', ['pr', 'checks', String(pr), '--json', 'bucket,name,state'], { cwd: this.cwd });
+            // `gh pr checks` exits 8 when any check fails but still emits JSON on stdout. Treat any
+            // exit code as "command ran" if stdout parses; otherwise propagate the failure.
+            const rows = tryParseChecks(r.stdout);
+            if (!rows) {
+                throw new Error(`gh pr checks failed: ${r.stderr.trim() || r.stdout.trim()}`);
+            }
+            const status = aggregateChecks(rows);
+            if (status === 'failure' || status === 'cancelled') {
+                throw new CiFailed(`PR #${pr} ${status}: ${summarizeFailures(rows)}`);
+            }
+            if (status !== 'pending')
+                return status;
+            await this.sleep(delay);
+            delay = Math.min(delay * 2, CHECKS_MAX_DELAY_MS);
+        }
+    }
+    async listUnresolvedThreads(pr) {
+        const { owner, name } = await this.repoMeta();
+        // GitHub caps connections at 100 nodes per page — page through threads and
+        // their comments to avoid silently dropping data on large PRs.
+        const threads = await this.paginateReviewThreads(owner, name, pr);
+        const unresolved = threads.filter((t) => !t.isResolved);
+        for (const thread of unresolved) {
+            if (thread.comments.pageInfo.hasNextPage && thread.comments.pageInfo.endCursor) {
+                const rest = await this.paginateThreadComments(thread.id, thread.comments.pageInfo.endCursor);
+                thread.comments.nodes.push(...rest);
+            }
+        }
+        return unresolved.map((node) => ({
+            id: node.id,
+            isResolved: node.isResolved,
+            path: node.path,
+            comments: node.comments.nodes.map((c) => ({
+                id: c.id,
+                body: c.body,
+                author: c.author?.login ?? 'ghost',
+            })),
+        }));
+    }
+    async paginateReviewThreads(owner, repo, pr) {
+        const collected = [];
+        let cursor = null;
+        while (true) {
+            const args = [
+                'api',
+                'graphql',
+                '-f',
+                `owner=${owner}`,
+                '-f',
+                `repo=${repo}`,
+                '-F',
+                `pr=${pr}`,
+                '-f',
+                `query=${REVIEW_THREADS_QUERY}`,
+            ];
+            if (cursor)
+                args.push('-f', `threadsCursor=${cursor}`);
+            const r = await this.runCmd('gh', args, { cwd: this.cwd });
+            if (r.exitCode !== 0) {
+                throw new Error(`gh api graphql (reviewThreads) failed: ${r.stderr.trim() || r.stdout.trim()}`);
+            }
+            const parsed = GqlReviewThreadsResponseSchema.parse(JSON.parse(r.stdout));
+            const conn = parsed.data.repository.pullRequest.reviewThreads;
+            collected.push(...conn.nodes);
+            if (!conn.pageInfo.hasNextPage || !conn.pageInfo.endCursor)
+                return collected;
+            cursor = conn.pageInfo.endCursor;
+        }
+    }
+    async paginateThreadComments(threadId, startCursor) {
+        const collected = [];
+        let cursor = startCursor;
+        while (cursor) {
+            const r = await this.runCmd('gh', [
+                'api',
+                'graphql',
+                '-f',
+                `threadId=${threadId}`,
+                '-f',
+                `commentsCursor=${cursor}`,
+                '-f',
+                `query=${THREAD_COMMENTS_QUERY}`,
+            ], { cwd: this.cwd });
+            if (r.exitCode !== 0) {
+                throw new Error(`gh api graphql (threadComments) failed: ${r.stderr.trim() || r.stdout.trim()}`);
+            }
+            const parsed = GqlThreadCommentsResponseSchema.parse(JSON.parse(r.stdout));
+            const conn = parsed.data.node.comments;
+            collected.push(...conn.nodes);
+            cursor =
+                conn.pageInfo.hasNextPage && conn.pageInfo.endCursor ? conn.pageInfo.endCursor : null;
+        }
+        return collected;
+    }
+    async replyToThread(threadId, body) {
+        const r = await this.runCmd('gh', [
+            'api',
+            'graphql',
+            '-f',
+            `threadId=${threadId}`,
+            '-f',
+            `body=${body}`,
+            '-f',
+            `query=${REPLY_THREAD_MUTATION}`,
+        ], { cwd: this.cwd });
+        if (r.exitCode !== 0) {
+            throw new Error(`gh api graphql (replyToThread) failed: ${r.stderr.trim() || r.stdout.trim()}`);
+        }
+    }
+    async resolveThread(threadId) {
+        const r = await this.runCmd('gh', ['api', 'graphql', '-f', `threadId=${threadId}`, '-f', `query=${RESOLVE_THREAD_MUTATION}`], { cwd: this.cwd });
+        if (r.exitCode !== 0) {
+            throw new Error(`gh api graphql (resolveThread) failed: ${r.stderr.trim() || r.stdout.trim()}`);
+        }
+    }
+    async repoMeta() {
+        const r = await this.runCmd('gh', ['repo', 'view', '--json', 'owner,name'], {
+            cwd: this.cwd,
+        });
+        if (r.exitCode !== 0) {
+            throw new Error(`gh repo view failed: ${r.stderr.trim() || r.stdout.trim()}`);
+        }
+        const parsed = RepoOwnerNameSchema.parse(JSON.parse(r.stdout));
+        return { owner: parsed.owner.login, name: parsed.name };
+    }
+    async mergePr(pr, method) {
+        const r = await this.runCmd('gh', ['pr', 'merge', String(pr), `--${method}`], {
+            cwd: this.cwd,
+        });
+        if (r.exitCode === 0)
+            return;
+        const combined = `${r.stderr}\n${r.stdout}`;
+        if (/merge conflict|not mergeable|conflict/i.test(combined)) {
+            throw new MergeConflict(`Merge conflict on PR #${pr}: ${r.stderr.trim() || r.stdout.trim()}`);
+        }
+        throw new Error(`gh pr merge failed: ${r.stderr.trim() || r.stdout.trim()}`);
+    }
+    async authStatus() {
+        const r = await this.runCmd('gh', ['auth', 'status', '--hostname', 'github.com'], {
+            cwd: this.cwd,
+        });
+        // `gh auth status` writes its human-readable summary to stderr; stdout is usually empty.
+        const text = `${r.stderr}\n${r.stdout}`;
+        const scopes = parseScopes(text);
+        return { ok: r.exitCode === 0, scopes };
+    }
+}
+// `gh pr view` exits non-zero with messages like:
+//   "no pull requests found for branch <name>"
+//   "GraphQL: Could not resolve to a PullRequest..."
+function isPrNotFoundStderr(stderr) {
+    return /no pull requests? found|could not resolve to a pullrequest|no open pull requests/i.test(stderr);
+}
+// `gh auth status` line shape: "  - Token scopes: 'repo', 'workflow', 'read:org'"
+function parseScopes(text) {
+    const match = text.match(/Token scopes:\s*([^\n]+)/i);
+    if (!match?.[1])
+        return [];
+    const scopes = [];
+    for (const raw of match[1].split(',')) {
+        const cleaned = raw.replace(/['"`]/g, '').trim();
+        if (cleaned)
+            scopes.push(cleaned);
+    }
+    return scopes;
+}
+// Wire shapes for `gh pr checks --json bucket,name,state`. The bucket field is the gh CLI's
+// normalized status across providers (Actions, Circle, etc.); CheckStatus is our domain.
+const CheckBucketSchema = z.enum(['pass', 'fail', 'pending', 'cancel', 'skipping']);
+const CheckRowSchema = z.object({
+    bucket: CheckBucketSchema,
+    name: z.string(),
+    state: z.string(),
+});
+const ChecksResponseSchema = z.array(CheckRowSchema);
+function tryParseChecks(stdout) {
+    if (!stdout.trim())
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    const parsed = ChecksResponseSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+}
+const BUCKET_TO_STATUS = {
+    pass: 'success',
+    fail: 'failure',
+    pending: 'pending',
+    cancel: 'cancelled',
+    skipping: 'skipped',
+};
+function aggregateChecks(rows) {
+    if (rows.length === 0)
+        return 'success';
+    let pending = false;
+    for (const row of rows) {
+        const status = BUCKET_TO_STATUS[row.bucket];
+        if (status === 'failure')
+            return 'failure';
+        if (status === 'cancelled')
+            return 'cancelled';
+        if (status === 'pending')
+            pending = true;
+    }
+    return pending ? 'pending' : 'success';
+}
+function summarizeFailures(rows) {
+    const bad = rows.filter((r) => r.bucket === 'fail' || r.bucket === 'cancel');
+    if (bad.length === 0)
+        return 'unknown';
+    return bad.map((r) => `${r.name}=${r.bucket}`).join(', ');
+}
+// `gh repo view --json owner,name` returns `{ owner: { login }, name }`.
+const RepoOwnerNameSchema = z.object({
+    owner: z.object({ login: z.string() }),
+    name: z.string(),
+});
+const REVIEW_THREADS_QUERY = `query($owner: String!, $repo: String!, $pr: Int!, $threadsCursor: String) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      reviewThreads(first: 100, after: $threadsCursor) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id
+          isResolved
+          path
+          comments(first: 100) {
+            pageInfo { hasNextPage endCursor }
+            nodes { id body author { login } }
+          }
+        }
+      }
+    }
+  }
+}`;
+const THREAD_COMMENTS_QUERY = `query($threadId: ID!, $commentsCursor: String) {
+  node(id: $threadId) {
+    ... on PullRequestReviewThread {
+      comments(first: 100, after: $commentsCursor) {
+        pageInfo { hasNextPage endCursor }
+        nodes { id body author { login } }
+      }
+    }
+  }
+}`;
+const REPLY_THREAD_MUTATION = `mutation($threadId: ID!, $body: String!) {
+  addPullRequestReviewThreadReply(input: {pullRequestReviewThreadId: $threadId, body: $body}) {
+    comment { id }
+  }
+}`;
+const RESOLVE_THREAD_MUTATION = `mutation($threadId: ID!) {
+  resolveReviewThread(input: {threadId: $threadId}) {
+    thread { id isResolved }
+  }
+}`;
+const GqlPageInfoSchema = z.object({
+    hasNextPage: z.boolean(),
+    endCursor: z.string().nullable(),
+});
+const GqlReviewCommentSchema = z.object({
+    id: z.string(),
+    body: z.string(),
+    author: z.object({ login: z.string() }).nullable(),
+});
+const GqlReviewThreadSchema = z.object({
+    id: z.string(),
+    isResolved: z.boolean(),
+    path: z.string().nullable(),
+    comments: z.object({
+        pageInfo: GqlPageInfoSchema,
+        nodes: z.array(GqlReviewCommentSchema),
+    }),
+});
+const GqlReviewThreadsResponseSchema = z.object({
+    data: z.object({
+        repository: z.object({
+            pullRequest: z.object({
+                reviewThreads: z.object({
+                    pageInfo: GqlPageInfoSchema,
+                    nodes: z.array(GqlReviewThreadSchema),
+                }),
+            }),
+        }),
+    }),
+});
+const GqlThreadCommentsResponseSchema = z.object({
+    data: z.object({
+        node: z.object({
+            comments: z.object({
+                pageInfo: GqlPageInfoSchema,
+                nodes: z.array(GqlReviewCommentSchema),
+            }),
+        }),
+    }),
+});
+//# sourceMappingURL=github-client.js.map