chapterhouse 0.5.1 → 0.6.0

package/dist/setup.js

@@ -1,7 +1,8 @@
-import * as readline from "readline";
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import * as readline from "node:readline";
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { CopilotClient } from "@github/copilot-sdk";
-import { ensureChapterhouseHome, ENV_PATH, CHAPTERHOUSE_HOME } from "./paths.js";
+import { CHAPTERHOUSE_HOME, ensureChapterhouseHome, ENV_PATH, WIKI_DIR } from "./paths.js";
 import { getExampleProjectPath } from "./home-path.js";
 const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";
@@ -21,11 +22,11 @@ async function fetchModels() {
         await client.start();
         const models = await client.listModels();
         return models
-            .filter((m) => m.policy?.state === "enabled" && !m.name.includes("(Internal only)"))
-            .map((m) => {
-            const mult = m.billing?.multiplier;
+            .filter((model) => model.policy?.state === "enabled" && !model.name.includes("(Internal only)"))
+            .map((model) => {
+            const mult = model.billing?.multiplier;
             const desc = mult === 0 || mult === undefined ? "Included with Copilot" : `Premium (${mult}x)`;
-            return { id: m.id, label: m.name, desc };
+            return { id: model.id, label: model.name, desc };
         });
     }
     catch {
@@ -35,7 +36,9 @@ async function fetchModels() {
         try {
             await client?.stop();
         }
-        catch { /* best-effort */ }
+        catch {
+            // best-effort cleanup
+        }
     }
 }
 function ask(rl, question) {
@@ -43,107 +46,171 @@ function ask(rl, question) {
 }
 async function askPicker(rl, label, options, defaultId) {
     console.log(`${BOLD}${label}${RESET}\n`);
-    const defaultIdx = Math.max(0, options.findIndex((o) => o.id === defaultId));
-    for (let i = 0; i < options.length; i++) {
-        const marker = i === defaultIdx ? `${GREEN}▸${RESET}` : " ";
-        const tag = i === defaultIdx ? ` ${DIM}(default)${RESET}` : "";
-        console.log(`  ${marker} ${CYAN}${i + 1}${RESET}  ${options[i].label}${tag}`);
-        console.log(`       ${DIM}${options[i].desc}${RESET}`);
+    const defaultIdx = Math.max(0, options.findIndex((option) => option.id === defaultId));
+    for (let index = 0; index < options.length; index++) {
+        const option = options[index];
+        const marker = index === defaultIdx ? `${GREEN}▸${RESET}` : " ";
+        const tag = index === defaultIdx ? ` ${DIM}(default)${RESET}` : "";
+        console.log(`  ${marker} ${CYAN}${index + 1}${RESET}  ${option.label}${tag}`);
+        console.log(`       ${DIM}${option.desc}${RESET}`);
     }
     console.log();
     const input = await ask(rl, `  Pick a number ${DIM}(1-${options.length}, Enter for default)${RESET}: `);
-    const num = parseInt(input.trim(), 10);
-    if (num >= 1 && num <= options.length)
+    const num = Number.parseInt(input.trim(), 10);
+    if (num >= 1 && num <= options.length) {
         return options[num - 1].id;
+    }
     return options[defaultIdx].id;
 }
-async function main() {
+function readExistingEnv() {
+    const lines = existsSync(ENV_PATH)
+        ? readFileSync(ENV_PATH, "utf-8").split("\n").filter((line) => line.length > 0)
+        : [];
+    const values = {};
+    for (const line of lines) {
+        const match = line.match(/^([A-Z_]+)=(.*)$/);
+        if (match) {
+            values[match[1]] = match[2];
+        }
+    }
+    return { lines, values };
+}
+function resolveSetupMode(existing) {
+    const configured = process.env.CHAPTERHOUSE_MODE?.trim() || existing.CHAPTERHOUSE_MODE?.trim() || "personal";
+    return configured === "team" ? "team" : "personal";
+}
+function upsertEnvLines(lines, updates) {
+    const pending = new Map(Object.entries(updates)
+        .filter(([, value]) => value.trim().length > 0));
+    const nextLines = lines.map((line) => {
+        const match = line.match(/^([A-Z_]+)=(.*)$/);
+        if (!match) {
+            return line;
+        }
+        const key = match[1];
+        const replacement = pending.get(key);
+        if (replacement === undefined) {
+            return line;
+        }
+        pending.delete(key);
+        return `${key}=${replacement}`;
+    });
+    for (const [key, value] of pending) {
+        nextLines.push(`${key}=${value}`);
+    }
+    return nextLines;
+}
+function hasTokenEnv() {
+    return Boolean(process.env.GITHUB_TOKEN?.trim() || process.env.COPILOT_TOKEN?.trim());
+}
+function getGhAuthStatus() {
+    try {
+        const output = execFileSync("gh", ["auth", "status"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return output.trim();
+    }
+    catch {
+        return null;
+    }
+}
+async function showWikiLocation(rl) {
+    console.log(`${BOLD}Personal wiki location${RESET}`);
+    console.log(`  ${CYAN}${WIKI_DIR}${RESET}`);
+    console.log(`${DIM}  Chapterhouse stores your local wiki here.${RESET}\n`);
+    await ask(rl, `${DIM}Press Enter to continue...${RESET}`);
+    console.log();
+}
+export async function runSetup() {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    console.log(`
+    try {
+        console.log(`
 ${BOLD}╔══════════════════════════════════════════╗
 ║           🤖  Chapterhouse Setup                  ║
 ╚══════════════════════════════════════════╝${RESET}
 `);
-    console.log(`${DIM}Config directory: ${CHAPTERHOUSE_HOME}${RESET}\n`);
-    ensureChapterhouseHome();
-    // Load existing values if any
-    const existing = {};
-    if (existsSync(ENV_PATH)) {
-        for (const line of readFileSync(ENV_PATH, "utf-8").split("\n")) {
-            const match = line.match(/^([A-Z_]+)=(.*)$/);
-            if (match)
-                existing[match[1]] = match[2];
+        console.log(`${DIM}Config directory: ${CHAPTERHOUSE_HOME}${RESET}\n`);
+        ensureChapterhouseHome();
+        const existing = readExistingEnv();
+        const mode = resolveSetupMode(existing.values);
+        console.log(`${BOLD}${mode === "personal" ? "Personal setup" : "Team setup"}${RESET}`);
+        if (mode === "personal") {
+            console.log("We'll get your GitHub/Copilot auth, preferred model, and personal wiki location dialed in.");
+            console.log(`${DIM}Team-only integrations stay out of the way in personal mode.${RESET}`);
         }
-    }
-    // ── What is Chapterhouse ──────────────────────────────────────────
-    console.log(`${BOLD}Meet Chapterhouse${RESET}`);
-    console.log(`Chapterhouse is your team-level AI assistant — an always-on daemon that runs on`);
-    console.log(`your machine. Open the web UI in your browser and talk in plain English;`);
-    console.log(`Chapterhouse handles the rest.`);
-    console.log();
-    console.log(`${CYAN}What Chapterhouse can do out of the box:${RESET}`);
-    console.log(`  • Have conversations and answer questions`);
-    console.log(`  • Spin up Copilot CLI sessions to code, debug, and run commands`);
-    console.log(`  • Manage multiple background tasks simultaneously`);
-    console.log(`  • Maintain a shared engineering wiki of everything it learns about your team`);
-    console.log();
-    console.log(`${CYAN}Skills — teach Chapterhouse anything:${RESET}`);
-    console.log(`  Chapterhouse has a skill system that lets it learn new capabilities. There's`);
-    console.log(`  an open source library of community skills it can install, or it can`);
-    console.log(`  write its own from scratch.`);
-    console.log();
-    await ask(rl, `${DIM}Press Enter to continue...${RESET}`);
-    console.log();
-    // ── Model picker ─────────────────────────────────────────
-    console.log(`\n${BOLD}━━━ Default Model ━━━${RESET}\n`);
-    console.log(`${DIM}Fetching available models from Copilot...${RESET}`);
-    let models = await fetchModels();
-    if (models.length === 0) {
-        console.log(`${YELLOW}  Could not fetch models (Copilot CLI may not be authenticated yet).${RESET}`);
-        console.log(`${DIM}  Showing a curated list — you can switch anytime after setup.${RESET}\n`);
-        models = FALLBACK_MODELS;
-    }
-    else {
-        console.log(`${GREEN}  ✓ Found ${models.length} models${RESET}\n`);
-    }
-    console.log(`${DIM}You can switch models anytime in the web UI's Settings page.${RESET}\n`);
-    const currentModel = existing.COPILOT_MODEL || "claude-sonnet-4.6";
-    const model = await askPicker(rl, "Choose a default model:", models, currentModel);
-    const modelLabel = models.find((m) => m.id === model)?.label || model;
-    console.log(`\n${GREEN}  ✓ Using ${modelLabel}${RESET}\n`);
-    // ── Write config ─────────────────────────────────────────
-    const apiPort = existing.API_PORT || "7788";
-    const lines = [];
-    lines.push(`API_PORT=${apiPort}`);
-    lines.push(`COPILOT_MODEL=${model}`);
-    writeFileSync(ENV_PATH, lines.join("\n") + "\n");
-    // ── Done ─────────────────────────────────────────────────
-    console.log(`
+        else {
+            console.log("We'll keep the shared team configuration intact and confirm your local defaults.");
+        }
+        console.log();
+        await ask(rl, `${DIM}Press Enter to continue...${RESET}`);
+        console.log();
+        if (mode === "personal") {
+            const ghAuthStatus = hasTokenEnv() ? null : getGhAuthStatus();
+            if (!hasTokenEnv() && !ghAuthStatus) {
+                console.log(`${YELLOW}GitHub authentication is required before setup can continue.${RESET}`);
+                console.log("Run `gh auth login` to authenticate with GitHub, then re-run setup.");
+                console.log(`${DIM}If you already manage credentials via environment, set GITHUB_TOKEN or COPILOT_TOKEN before running setup.${RESET}`);
+                return;
+            }
+            if (ghAuthStatus) {
+                console.log(`${BOLD}GitHub CLI auth status${RESET}`);
+                console.log(`${DIM}Verified with gh auth status:${RESET}`);
+                console.log(ghAuthStatus);
+                console.log();
+            }
+            console.log();
+            await showWikiLocation(rl);
+        }
+        console.log(`\n${BOLD}━━━ Default Model ━━━${RESET}\n`);
+        console.log(`${DIM}Fetching available models from Copilot...${RESET}`);
+        let models = await fetchModels();
+        if (models.length === 0) {
+            console.log(`${YELLOW}  Could not fetch models (Copilot CLI may not be authenticated yet).${RESET}`);
+            console.log(`${DIM}  Showing a curated list — you can switch anytime after setup.${RESET}\n`);
+            models = FALLBACK_MODELS;
+        }
+        else {
+            console.log(`${GREEN}  ✓ Found ${models.length} models${RESET}\n`);
+        }
+        console.log(`${DIM}You can switch models anytime in the web UI's Settings page.${RESET}\n`);
+        const currentModel = existing.values.COPILOT_MODEL || "claude-sonnet-4.6";
+        const model = await askPicker(rl, "Choose a default model:", models, currentModel);
+        const modelLabel = models.find((entry) => entry.id === model)?.label || model;
+        console.log(`\n${GREEN}  ✓ Using ${modelLabel}${RESET}\n`);
+        const apiPort = existing.values.API_PORT || "7788";
+        const nextEnv = upsertEnvLines(existing.lines, {
+            API_PORT: apiPort,
+            CHAPTERHOUSE_MODE: mode,
+            COPILOT_MODEL: model,
+        });
+        writeFileSync(ENV_PATH, `${nextEnv.join("\n")}\n`);
+        console.log(`
 ${GREEN}${BOLD}✅ Chapterhouse is ready!${RESET}
 ${DIM}Config saved to ${ENV_PATH}${RESET}
-
-${BOLD}Get started:${RESET}
-
-  ${CYAN}1.${RESET} Make sure Copilot CLI is authenticated:
-     ${BOLD}copilot login${RESET}
-
-  ${CYAN}2.${RESET} Start Chapterhouse:
-     ${BOLD}chapterhouse start${RESET}
-
-  ${CYAN}3.${RESET} Open the web UI:
-     ${BOLD}http://localhost:${apiPort}${RESET}
-
-${BOLD}Things to try:${RESET}
-
-  ${DIM}"Start working on the auth bug in ${getExampleProjectPath()}"${RESET}
-  ${DIM}"What sessions are running?"${RESET}
-  ${DIM}"Find me a skill for checking Gmail"${RESET}
-  ${DIM}"Switch to gpt-4.1"${RESET}
 `);
-    rl.close();
+        if (mode === "personal") {
+            console.log(`${BOLD}Your personal wiki lives at:${RESET}`);
+            console.log(`  ${CYAN}${WIKI_DIR}${RESET}\n`);
+        }
+        console.log(`${BOLD}Get started:${RESET}
+`);
+        console.log(`  ${CYAN}1.${RESET} If needed, authenticate GitHub CLI:`);
+        console.log(`     ${BOLD}gh auth login${RESET}\n`);
+        console.log(`  ${CYAN}2.${RESET} Make sure Copilot CLI is authenticated:`);
+        console.log(`     ${BOLD}copilot login${RESET}\n`);
+        console.log(`  ${CYAN}3.${RESET} Start Chapterhouse:`);
+        console.log(`     ${BOLD}chapterhouse start${RESET}\n`);
+        console.log(`  ${CYAN}4.${RESET} Open the web UI:`);
+        console.log(`     ${BOLD}http://localhost:${apiPort}${RESET}\n`);
+        console.log(`${BOLD}Things to try:${RESET}\n`);
+        console.log(`  ${DIM}"Start working on the auth bug in ${getExampleProjectPath()}"${RESET}`);
+        console.log(`  ${DIM}"What sessions are running?"${RESET}`);
+        console.log(`  ${DIM}"Find me a skill for checking Gmail"${RESET}`);
+        console.log(`  ${DIM}"Switch to gpt-4.1"${RESET}`);
+    }
+    finally {
+        rl.close();
+    }
 }
-main().catch((err) => {
-    console.error("Setup failed:", err);
-    process.exit(1);
-});
 //# sourceMappingURL=setup.js.map

package/dist/setup.test.js

@@ -0,0 +1,139 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+async function runSetupScript(t, options = {}) {
+    const output = [];
+    const prompts = [];
+    const ghAuthInvocations = [];
+    let writtenConfig = "";
+    const answers = [...(options.answers ?? [])];
+    t.mock.module("node:readline", {
+        namedExports: {
+            createInterface: () => ({
+                question: (prompt, callback) => {
+                    prompts.push(prompt);
+                    callback(answers.shift() ?? "");
+                },
+                close: () => { },
+            }),
+        },
+    });
+    t.mock.module("fs", {
+        namedExports: {
+            existsSync: () => options.existingEnv !== undefined,
+            readFileSync: () => options.existingEnv ?? "",
+            writeFileSync: (_path, content) => {
+                writtenConfig = content;
+            },
+        },
+    });
+    t.mock.module("./paths.js", {
+        namedExports: {
+            ensureChapterhouseHome: () => { },
+            ENV_PATH: "/workspace/.chapterhouse/.env",
+            CHAPTERHOUSE_HOME: "/workspace/.chapterhouse",
+            WIKI_DIR: "/workspace/.chapterhouse/wiki",
+        },
+    });
+    t.mock.module("./home-path.js", {
+        namedExports: {
+            getExampleProjectPath: () => "/workspace/example-project",
+        },
+    });
+    t.mock.module("node:child_process", {
+        namedExports: {
+            execFileSync: (command, args) => {
+                ghAuthInvocations.push({ command, args });
+                if (options.ghAuthStatus === "unauthenticated") {
+                    throw new Error("gh auth status failed");
+                }
+                return "github.com\n  ✓ Logged in";
+            },
+        },
+    });
+    t.mock.module("@github/copilot-sdk", {
+        namedExports: {
+            CopilotClient: class {
+                async start() { }
+                async stop() { }
+                async listModels() {
+                    return (options.modelIds ?? ["claude-sonnet-4.6"]).map((id) => ({
+                        id,
+                        name: id,
+                        policy: { state: "enabled" },
+                    }));
+                }
+            },
+        },
+    });
+    t.mock.method(console, "log", (...args) => {
+        output.push(args.join(" "));
+    });
+    t.mock.method(console, "error", (...args) => {
+        output.push(args.join(" "));
+    });
+    const priorEnv = process.env;
+    process.env = {
+        ...priorEnv,
+        ...options.env,
+    };
+    try {
+        const setupModule = await import(new URL(`./setup.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+        const { runSetup } = setupModule;
+        assert.equal(typeof runSetup, "function", "setup.ts should export runSetup");
+        await runSetup?.();
+    }
+    finally {
+        process.env = priorEnv;
+    }
+    return { output, prompts, writtenConfig, ghAuthInvocations };
+}
+test("personal setup uses existing gh auth and never prompts for tokens", async (t) => {
+    // Security: the wizard must not ask users to paste long-lived credentials into an interactive prompt.
+    const result = await runSetupScript(t, {
+        env: { CHAPTERHOUSE_MODE: "personal" },
+        answers: ["", "", "1"],
+        ghAuthStatus: "authenticated",
+    });
+    assert.doesNotMatch(result.prompts.join("\n"), /token/i);
+    assert.match(result.output.join("\n"), /wiki location/i);
+    assert.doesNotMatch(result.output.join("\n"), /ADO|Teams webhook|Entra/i);
+    assert.match(result.writtenConfig, /^CHAPTERHOUSE_MODE=personal$/m);
+    assert.match(result.writtenConfig, /^COPILOT_MODEL=claude-sonnet-4\.6$/m);
+    assert.doesNotMatch(result.writtenConfig, /^GITHUB_TOKEN=/m);
+});
+test("personal setup checks gh auth status and surfaces the authenticated result", async (t) => {
+    // Security: showing CLI auth state keeps credentials in GitHub CLI instead of training users to paste tokens into Chapterhouse.
+    const result = await runSetupScript(t, {
+        env: { CHAPTERHOUSE_MODE: "personal" },
+        answers: ["", "", "1"],
+        ghAuthStatus: "authenticated",
+    });
+    assert.deepEqual(result.ghAuthInvocations, [{ command: "gh", args: ["auth", "status"] }]);
+    assert.match(result.output.join("\n"), /gh auth status/i);
+    assert.match(result.output.join("\n"), /Logged in/i);
+    assert.doesNotMatch(result.prompts.join("\n"), /token/i);
+});
+test("personal setup accepts env var tokens silently without prompting", async (t) => {
+    // Security: pre-configured environment credentials should be honored without re-exposing them through setup prompts.
+    const result = await runSetupScript(t, {
+        env: { CHAPTERHOUSE_MODE: "personal", GITHUB_TOKEN: "ghp_env_token" },
+        answers: ["", "", "1"],
+        ghAuthStatus: "unauthenticated",
+    });
+    assert.doesNotMatch(result.prompts.join("\n"), /token/i);
+    assert.match(result.writtenConfig, /^CHAPTERHOUSE_MODE=personal$/m);
+    assert.match(result.writtenConfig, /^COPILOT_MODEL=claude-sonnet-4\.6$/m);
+    assert.doesNotMatch(result.writtenConfig, /^GITHUB_TOKEN=/m);
+});
+test("personal setup instructs users to run gh auth login when not authenticated", async (t) => {
+    // Security: failed auth should route users to GitHub CLI login flow, not to an unsafe token entry screen.
+    const result = await runSetupScript(t, {
+        env: { CHAPTERHOUSE_MODE: "personal" },
+        answers: [""],
+        ghAuthStatus: "unauthenticated",
+    });
+    assert.doesNotMatch(result.prompts.join("\n"), /token/i);
+    assert.match(result.output.join("\n"), /Run `gh auth login` to authenticate with GitHub, then re-run setup/i);
+    assert.equal(result.writtenConfig, "");
+});
+//# sourceMappingURL=setup.test.js.map

package/dist/sprint-merge.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+export const USAGE = `Usage:\n  ./scripts/merge-sprint.sh [--dry-run|-n] <pr> [pr...]\n\nExamples:\n  ./scripts/merge-sprint.sh 264 265 266\n  ./scripts/merge-sprint.sh --dry-run 264 265 266\n  ./scripts/merge-sprint.sh -n 264 265 266`;
+function isHelpFlag(arg) {
+    return arg === "--help" || arg === "-h";
+}
+function isDryRunFlag(arg) {
+    return arg === "--dry-run" || arg === "-n";
+}
+function formatDryRunLine(description, command, args) {
+    return `[DRY RUN] ${description}: ${commandText(command, args)}`;
+}
+function defaultRunner(command, args) {
+    return execFileSync(command, args, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+}
+function commandText(command, args) {
+    return [command, ...args].join(" ");
+}
+function parsePrNumber(value) {
+    const pr = Number.parseInt(value, 10);
+    if (!Number.isInteger(pr) || pr <= 0) {
+        throw new Error(`Invalid PR number: ${value}\n${USAGE}`);
+    }
+    return pr;
+}
+export function parseSprintMergeArgs(argv) {
+    let dryRun = false;
+    const prArgs = [];
+    for (const arg of argv) {
+        if (isHelpFlag(arg)) {
+            throw new Error(USAGE);
+        }
+        if (isDryRunFlag(arg)) {
+            dryRun = true;
+            continue;
+        }
+        prArgs.push(arg);
+    }
+    if (prArgs.length === 0) {
+        throw new Error(USAGE);
+    }
+    return {
+        dryRun,
+        prs: prArgs.map(parsePrNumber),
+    };
+}
+function parsePrStatus(raw) {
+    const parsed = JSON.parse(raw);
+    return {
+        state: parsed.state ?? "UNKNOWN",
+        mergeable: parsed.mergeable ?? "UNKNOWN",
+        reviewDecision: parsed.reviewDecision ?? null,
+    };
+}
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+export async function runSprintMerge(prs, options = {}) {
+    const runner = options.runner ?? defaultRunner;
+    const dryRun = options.dryRun ?? false;
+    const lines = [];
+    if (dryRun) {
+        lines.push(`[DRY RUN] Merge order: ${prs.map((pr) => `#${pr}`).join(" -> ")}`);
+        for (let index = 0; index < prs.length; index += 1) {
+            const pr = prs[index];
+            const remaining = prs.slice(index + 1);
+            let status;
+            try {
+                const raw = runner("gh", ["pr", "view", String(pr), "--json", "state,mergeable,reviewDecision"]);
+                status = parsePrStatus(raw);
+            }
+            catch (error) {
+                lines.push(`[DRY RUN] PR #${pr}: fetch failed ❌ — ${formatError(error)}`);
+                continue;
+            }
+            const ok = status.state === "OPEN" && status.mergeable === "MERGEABLE";
+            const statePart = status.state === "OPEN"
+                ? `OPEN, mergeable: ${status.mergeable}`
+                : status.state;
+            const reviewPart = status.reviewDecision ? `, reviewDecision: ${status.reviewDecision}` : "";
+            const suffix = ok ? " ✅" : " ❌ — would be skipped";
+            lines.push(`[DRY RUN] PR #${pr}: ${statePart}${reviewPart}${suffix}`);
+            if (!ok)
+                continue;
+            lines.push(formatDryRunLine(`Would merge #${pr} with`, "gh", ["pr", "merge", String(pr), "--squash"]));
+            lines.push(formatDryRunLine("Would fetch origin/main with", "git", ["fetch", "origin", "main"]));
+            for (const nextPr of remaining) {
+                lines.push(formatDryRunLine(`Would refresh #${nextPr} with`, "gh", ["pr", "update-branch", String(nextPr)]));
+            }
+        }
+        return lines;
+    }
+    for (let index = 0; index < prs.length; index += 1) {
+        const pr = prs[index];
+        const remaining = prs.slice(index + 1);
+        lines.push(`Processing #${pr}...`);
+        try {
+            const status = parsePrStatus(runner("gh", ["pr", "view", String(pr), "--json", "state,mergeable,reviewDecision"]));
+            lines.push(`  Status #${pr}: state=${status.state}, mergeable=${status.mergeable}, reviewDecision=${status.reviewDecision ?? "NONE"}`);
+            if (status.state !== "OPEN" || status.mergeable !== "MERGEABLE") {
+                lines.push(`Skipped #${pr}: mergeable=${status.mergeable}, state=${status.state}`);
+                continue;
+            }
+            runner("gh", ["pr", "merge", String(pr), "--squash"]);
+            lines.push(`Merged #${pr}.`);
+        }
+        catch (error) {
+            lines.push(`Failed #${pr}: ${formatError(error)}`);
+            continue;
+        }
+        try {
+            runner("git", ["fetch", "origin", "main"]);
+            lines.push("  Fetched origin/main (remote tracking ref updated, local branch untouched).");
+        }
+        catch (error) {
+            lines.push(`  Failed to sync local main after #${pr}: ${formatError(error)}`);
+        }
+        for (const nextPr of remaining) {
+            try {
+                runner("gh", ["pr", "update-branch", String(nextPr)]);
+                lines.push(`  Refreshed #${nextPr}.`);
+            }
+            catch (error) {
+                lines.push(`  Failed to refresh #${nextPr}: ${formatError(error)}`);
+            }
+        }
+        lines.push(`Done #${pr}.`);
+    }
+    return lines;
+}
+export async function main(argv = process.argv.slice(2)) {
+    if (argv.some(isHelpFlag)) {
+        console.log(USAGE);
+        return 0;
+    }
+    let args;
+    try {
+        args = parseSprintMergeArgs(argv);
+    }
+    catch (error) {
+        console.error(formatError(error));
+        return 1;
+    }
+    const lines = await runSprintMerge(args.prs, { dryRun: args.dryRun });
+    for (const line of lines) {
+        console.log(line);
+    }
+    return 0;
+}
+const invokedPath = process.argv[1] ? resolve(process.argv[1]) : "";
+const modulePath = fileURLToPath(import.meta.url);
+if (invokedPath === modulePath) {
+    main().then((code) => {
+        process.exitCode = code;
+    }).catch((error) => {
+        console.error(formatError(error));
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=sprint-merge.js.map