@relay-baton/cli 1.0.0

package/dist/commands/project.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectAddCommand = projectAddCommand;
+exports.projectListCommand = projectListCommand;
+exports.projectSwitchCommand = projectSwitchCommand;
+exports.projectCurrentCommand = projectCurrentCommand;
+exports.projectRemoveCommand = projectRemoveCommand;
+exports.projectDoctorCommand = projectDoctorCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_1 = require("@relay-baton/core");
+const diets = new Set(["off", "lite", "balanced", "caveman", "ultra"]);
+const agents = new Set(["codex", "claude", "opencode", "gemini", "aider"]);
+function assertDiet(value) {
+    if (!value)
+        return undefined;
+    if (!diets.has(value)) {
+        console.error(`unknown diet profile: ${value}`);
+        process.exit(2);
+    }
+    return value;
+}
+function assertAgent(value, label = "agent") {
+    if (!value)
+        return undefined;
+    if (!agents.has(value)) {
+        console.error(`unknown ${label}: ${value}`);
+        process.exit(2);
+    }
+    return value;
+}
+async function projectAddCommand(projectPath, opts) {
+    const resolved = path.resolve(projectPath);
+    if (!fs.existsSync(resolved)) {
+        console.error(`[relay-baton] path does not exist: ${resolved}`);
+        process.exit(2);
+    }
+    if (!fs.statSync(resolved).isDirectory()) {
+        console.error(`[relay-baton] path is not a directory: ${resolved}`);
+        process.exit(2);
+    }
+    const manager = new core_1.ProjectManager();
+    const result = manager.addProject({
+        path: resolved,
+        name: opts.name,
+        defaultDiet: assertDiet(opts.diet),
+        primaryAgent: assertAgent(opts.primary, "primary agent"),
+        fallbackAgent: assertAgent(opts.fallback, "fallback agent"),
+    });
+    if (!result.added) {
+        if (opts.json) {
+            console.log(JSON.stringify({ added: false, project: result.project }, null, 2));
+            return;
+        }
+        console.log("[relay-baton] project already registered:");
+        printProject(result.project, true);
+        return;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ added: true, project: result.project }, null, 2));
+        return;
+    }
+    console.log("[relay-baton] project added:");
+    printProject(result.project, true);
+}
+async function projectListCommand(opts = {}) {
+    const manager = new core_1.ProjectManager();
+    const data = manager.getRegistry();
+    if (opts.json) {
+        console.log(JSON.stringify({
+            activeProjectId: data.activeProjectId ?? null,
+            projects: data.projects,
+        }, null, 2));
+        return;
+    }
+    if (data.projects.length === 0) {
+        console.log("[relay-baton] no registered projects.");
+        return;
+    }
+    for (const p of data.projects)
+        printProject(p, data.activeProjectId === p.id);
+}
+async function projectSwitchCommand(nameOrId) {
+    const project = new core_1.ProjectManager().switchProject(nameOrId);
+    if (!project) {
+        console.error(`[relay-baton] project not found: ${nameOrId}`);
+        process.exit(2);
+    }
+    console.log(`[relay-baton] active project: ${project.name} (${project.path})`);
+}
+async function projectCurrentCommand(opts = {}) {
+    const active = new core_1.ProjectManager().getActiveProject();
+    if (opts.json) {
+        console.log(JSON.stringify({ active: active ?? null, cwd: process.cwd() }, null, 2));
+        return;
+    }
+    if (!active) {
+        console.log(`[relay-baton] no active project. Using cwd: ${process.cwd()}`);
+        return;
+    }
+    printProject(active, true);
+}
+async function projectRemoveCommand(nameOrId, opts = {}) {
+    const removed = new core_1.ProjectManager().removeProject(nameOrId);
+    if (!removed) {
+        console.error(`[relay-baton] project not found: ${nameOrId}`);
+        process.exit(2);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ removed }, null, 2));
+        return;
+    }
+    console.log(`[relay-baton] project removed: ${removed.name}`);
+}
+async function projectDoctorCommand() {
+    const manager = new core_1.ProjectManager();
+    const data = manager.getRegistry();
+    if (data.projects.length === 0) {
+        console.log("[relay-baton] no registered projects.");
+        return;
+    }
+    for (const p of data.projects) {
+        const exists = fs.existsSync(p.path);
+        console.log(`${data.activeProjectId === p.id ? "*" : " "} ${p.name} (${p.id})`);
+        console.log(`  path: ${p.path}`);
+        console.log(`  exists: ${exists ? "yes" : "no"}`);
+        console.log(`  git repo: ${exists && new core_1.GitService(p.path).isGitRepo() ? "yes" : "no"}`);
+        console.log(`  .ai-session: ${fs.existsSync(path.join(p.path, ".ai-session")) ? "yes" : "no"}`);
+        console.log(`  AGENTS.md: ${fs.existsSync(path.join(p.path, "AGENTS.md")) ? "yes" : "no"}`);
+        console.log(`  CLAUDE.md: ${fs.existsSync(path.join(p.path, "CLAUDE.md")) ? "yes" : "no"}`);
+    }
+}
+function printProject(project, active) {
+    const marker = active ? "*" : " ";
+    console.log(`${marker} ${project.name} (${project.id})`);
+    console.log(`  path: ${project.path}`);
+    console.log(`  defaultDiet: ${project.defaultDiet ?? "-"}`);
+    console.log(`  agents: ${project.primaryAgent ?? "-"} -> ${project.fallbackAgent ?? "-"}`);
+    console.log(`  lastUsedAt: ${project.lastUsedAt ?? "-"}`);
+}

package/dist/commands/projectOptions.d.ts

@@ -0,0 +1,7 @@
+import { ProjectResolveResult } from "@relay-baton/core";
+export interface ProjectOpts {
+    project?: string;
+    path?: string;
+}
+export declare function resolveRepoRoot(opts?: ProjectOpts): string;
+export declare function resolveProjectContext(opts?: ProjectOpts, touch?: boolean): ProjectResolveResult;

package/dist/commands/projectOptions.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRepoRoot = resolveRepoRoot;
+exports.resolveProjectContext = resolveProjectContext;
+const core_1 = require("@relay-baton/core");
+function resolveRepoRoot(opts = {}) {
+    return resolveProjectContext(opts).repoRoot;
+}
+function resolveProjectContext(opts = {}, touch = false) {
+    try {
+        const resolver = new core_1.ProjectResolver();
+        const result = resolver.resolve(opts);
+        if (touch)
+            resolver.touch(result);
+        return result;
+    }
+    catch (e) {
+        console.error(`[relay-baton] ${e?.message ?? e}`);
+        process.exit(2);
+    }
+}

package/dist/commands/receipt.d.ts

@@ -0,0 +1,8 @@
+import { ProjectOpts } from "./projectOptions";
+export interface ReceiptOpts extends ProjectOpts {
+    note?: string;
+    json?: boolean;
+}
+export declare function receiptDoneCommand(step: string, opts?: ReceiptOpts): Promise<void>;
+export declare function receiptSkipCommand(step: string, opts?: ReceiptOpts): Promise<void>;
+export declare function receiptListCommand(opts?: ReceiptOpts): Promise<void>;

package/dist/commands/receipt.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.receiptDoneCommand = receiptDoneCommand;
+exports.receiptSkipCommand = receiptSkipCommand;
+exports.receiptListCommand = receiptListCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function record(status, step, opts) {
+    const n = Number(step);
+    if (!Number.isInteger(n) || n < 1) {
+        console.error(`[relay-baton] step must be a positive integer, got: ${step}`);
+        process.exit(2);
+    }
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const meta = new core_1.SessionManager(repoRoot, config).getMeta();
+    const receipt = new core_1.PlanReceipts(repoRoot).append(n, status, opts.note ?? "");
+    new core_1.ConversationLog(repoRoot).append({
+        role: "relay-baton",
+        kind: "execute",
+        text: `receipt: step ${n} ${status}${receipt.note ? " — " + receipt.note : ""}`,
+        sessionId: meta?.id,
+        refs: { plan: "plan.md" },
+        meta: { stepRefs: [`step-${n}`], confirmed: true },
+    });
+    console.log(`[relay-baton] recorded [${status}] for step ${n}.`);
+}
+async function receiptDoneCommand(step, opts = {}) {
+    return record("done", step, opts);
+}
+async function receiptSkipCommand(step, opts = {}) {
+    return record("skipped", step, opts);
+}
+async function receiptListCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const receipts = new core_1.PlanReceipts(repoRoot).list();
+    if (opts.json) {
+        console.log(JSON.stringify(receipts, null, 2));
+        return;
+    }
+    if (receipts.length === 0) {
+        console.log("[relay-baton] no execution receipts recorded.");
+        return;
+    }
+    for (const r of receipts) {
+        console.log(`[${r.status}] step ${r.step}${r.note ? " — " + r.note : ""} (${r.ts})`);
+    }
+}

package/dist/commands/replay.d.ts

@@ -0,0 +1,8 @@
+import { ProjectOpts } from "./projectOptions";
+export interface ReplayOpts extends ProjectOpts {
+    json?: boolean;
+    session?: string;
+    kind?: string;
+    limit?: string;
+}
+export declare function replayCommand(opts?: ReplayOpts): Promise<void>;

package/dist/commands/replay.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replayCommand = replayCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function replayCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const replay = new core_1.ConversationReplay(repoRoot);
+    const kinds = opts.kind
+        ? opts.kind.split(",").map((k) => k.trim()).filter(Boolean)
+        : undefined;
+    const limit = opts.limit !== undefined ? Number(opts.limit) : undefined;
+    const result = replay.build({
+        sessionId: opts.session,
+        kinds,
+        limit: limit !== undefined && Number.isFinite(limit) ? limit : undefined,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.entries.length === 0) {
+        console.log("[relay-baton] no conversation events. (nothing recorded yet)");
+        return;
+    }
+    for (const line of replay.renderLines({
+        sessionId: opts.session,
+        kinds,
+        limit: limit !== undefined && Number.isFinite(limit) ? limit : undefined,
+    })) {
+        console.log(line);
+    }
+    const s = result.summary;
+    console.log(`\n${s.total} events; roles ${JSON.stringify(s.byRole)}; kinds ${JSON.stringify(s.byKind)}`);
+}

package/dist/commands/report.d.ts

@@ -0,0 +1,6 @@
+import { ProjectOpts } from "./projectOptions";
+export interface ReportOpts extends ProjectOpts {
+    out?: string;
+    json?: boolean;
+}
+export declare function reportCommand(opts?: ReportOpts): Promise<void>;

package/dist/commands/report.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportCommand = reportCommand;
+const fs = __importStar(require("fs"));
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function reportCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const markdown = new core_1.HandoffReport(repoRoot, config).generate();
+    if (opts.out) {
+        fs.writeFileSync(opts.out, markdown, "utf8");
+        console.log(`[relay-baton] report written to ${opts.out}`);
+        return;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ markdown }, null, 2));
+        return;
+    }
+    console.log(markdown);
+}

package/dist/commands/review.d.ts

@@ -0,0 +1,8 @@
+import type { ReviewResult } from "@relay-baton/core";
+import { ProjectOpts } from "./projectOptions";
+export interface ReviewOpts extends ProjectOpts {
+    json?: boolean;
+}
+/** Build the one-line summary persisted to the conversation event log. */
+export declare function reviewSummaryLine(r: ReviewResult): string;
+export declare function reviewCommand(opts?: ReviewOpts): Promise<void>;

package/dist/commands/review.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewSummaryLine = reviewSummaryLine;
+exports.reviewCommand = reviewCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+/** Build the one-line summary persisted to the conversation event log. */
+function reviewSummaryLine(r) {
+    return (`plan ${r.planPresent ? "present" : "missing"}; ` +
+        `${r.steps.length} steps (${r.touchedSteps} touched, ${r.untouchedSteps} untouched, ` +
+        `${r.uncorrelatedSteps} uncorrelated); ` +
+        `${r.changedFiles.length} changed, ${r.unplannedFiles.length} unplanned`);
+}
+async function reviewCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const sm = new core_1.SessionManager(repoRoot, config);
+    const meta = sm.getMeta();
+    const result = new core_1.PlanReview(repoRoot, config).run();
+    // Persist as an append-only conversation event (best-effort, summary only).
+    new core_1.ConversationLog(repoRoot).append({
+        role: "relay-baton",
+        kind: "review",
+        text: reviewSummaryLine(result),
+        sessionId: meta?.id,
+        refs: { plan: "plan.md", changedFiles: "changed-files.md" },
+        meta: {
+            stepRefs: result.steps.filter(s => s.touched).map(s => `step-${s.index}`),
+        },
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log("=== relay-baton review (deterministic, no model call) ===");
+    console.log("plan.md present:", result.planPresent);
+    if (!result.planPresent) {
+        console.log("No plan.md found. Run `relay-baton plan <task>` first.");
+    }
+    console.log("");
+    console.log(`steps: ${result.steps.length}  ` +
+        `(touched ${result.touchedSteps}, untouched ${result.untouchedSteps}, uncorrelated ${result.uncorrelatedSteps})`);
+    for (const s of result.steps) {
+        const mark = s.touched ? "[done?]" : s.referencedPaths.length === 0 ? "[----]" : "[todo?]";
+        console.log(`  ${mark} ${s.index}. ${s.text}`);
+        if (s.matchedFiles.length) {
+            console.log(`         matched: ${s.matchedFiles.join(", ")}`);
+        }
+    }
+    console.log("");
+    console.log(`changed files: ${result.changedFiles.length}`);
+    if (result.unplannedFiles.length) {
+        console.log(`unplanned changes (${result.unplannedFiles.length}):`);
+        for (const f of result.unplannedFiles)
+            console.log(`  - ${f}`);
+    }
+    else {
+        console.log("unplanned changes: none");
+    }
+    console.log("");
+    console.log("test-results summary:", result.testResultsSummary ?? "(none)");
+    console.log("handoff.md present:", result.handoffPresent);
+}

package/dist/commands/risk.d.ts

@@ -0,0 +1,5 @@
+import { ProjectOpts } from "./projectOptions";
+export interface RiskOpts extends ProjectOpts {
+    json?: boolean;
+}
+export declare function riskCommand(opts?: RiskOpts): Promise<void>;

package/dist/commands/risk.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.riskCommand = riskCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function riskCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const report = new core_1.RiskClassifier(repoRoot).evaluate();
+    if (opts.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    if (!report.available) {
+        console.log("[relay-baton] risk: not a git repository.");
+        return;
+    }
+    if (!report.risky) {
+        console.log("[relay-baton] risk: no risky surfaces in the working tree.");
+        return;
+    }
+    console.log(`[relay-baton] risk: ${report.findings.length} finding(s) · ${report.bySeverity.high} high · ${report.bySeverity.medium} medium`);
+    for (const f of report.findings) {
+        console.log(`- [${f.severity}] ${f.category}: ${f.code} ${f.path} (${f.reason})`);
+    }
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,31 @@
+import type { AgentId } from "@relay-baton/shared";
+import { ProjectOpts } from "./projectOptions";
+export interface RunOpts extends ProjectOpts {
+    diet?: string;
+    force?: boolean;
+    allowApiKeyEnv?: boolean;
+    /** Override the first agent in the relay chain. */
+    primary?: string;
+    /** Override the second agent (single-fallback shorthand). */
+    fallback?: string;
+    /** Explicit N-way chain, comma-separated (e.g. "claude,codex,gemini"). */
+    chain?: string;
+    /** v2.5: bounded auto-orchestration — max extra continue-steps after the first pass. */
+    until?: string;
+    /** Pre-approve bounded continue steps (still capped + guardrail-gated). */
+    yes?: boolean;
+}
+/**
+ * Deterministic "who's next" policy (v2.3): the relay chain is an ordered list
+ * of agents. `--chain` wins; otherwise it is [primary, fallback] resolved from
+ * flags > project overrides > config. Supports reverse (claude->codex) and
+ * longer chains, not just codex->claude.
+ */
+export declare function resolveChain(opts: RunOpts, project: {
+    primaryAgent?: AgentId;
+    fallbackAgent?: AgentId;
+} | undefined, config: {
+    primaryAgent: AgentId;
+    fallbackAgent: AgentId;
+}, assignedAgent?: AgentId): AgentId[];
+export declare function runCommand(task: string, opts: RunOpts): Promise<void>;