@relay-baton/cli 1.0.0

package/dist/commands/conversation.d.ts

@@ -0,0 +1,8 @@
+import type { ConversationEventKind, ConversationRole } from "@relay-baton/shared";
+import { ProjectOpts } from "./projectOptions";
+export interface ConversationAppendOpts extends ProjectOpts {
+    json?: boolean;
+    role?: ConversationRole;
+    kind?: ConversationEventKind;
+}
+export declare function conversationAppendCommand(text: string, opts?: ConversationAppendOpts): Promise<void>;

package/dist/commands/conversation.js

@@ -0,0 +1,90 @@
+"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.conversationAppendCommand = conversationAppendCommand;
+const fs = __importStar(require("fs"));
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+const ROLES = ["user", "relay-baton", "codex", "claude"];
+const KINDS = [
+    "message",
+    "command",
+    "prompt_preview",
+    "agent_run",
+    "plan",
+    "execute",
+    "review",
+    "diagnose",
+    "handoff",
+    "status",
+    "budget",
+];
+function parseRole(value) {
+    const role = (value ?? "user");
+    if (!ROLES.includes(role)) {
+        console.error(`[relay-baton] invalid conversation role: ${value}`);
+        process.exit(2);
+    }
+    return role;
+}
+function parseKind(value) {
+    const kind = (value ?? "message");
+    if (!KINDS.includes(kind)) {
+        console.error(`[relay-baton] invalid conversation kind: ${value}`);
+        process.exit(2);
+    }
+    return kind;
+}
+async function conversationAppendCommand(text, 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();
+    if (!meta || !fs.existsSync(sm.files.dir)) {
+        console.error("[relay-baton] no session. Run `relay-baton init`.");
+        process.exit(2);
+    }
+    const event = new core_1.ConversationLog(repoRoot).append({
+        role: parseRole(opts.role),
+        kind: parseKind(opts.kind),
+        text,
+        sessionId: meta.id,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(event, null, 2));
+        return;
+    }
+    console.log(`[relay-baton] appended ${event.kind} event ${event.id}`);
+}

package/dist/commands/diagnostics.d.ts

@@ -0,0 +1,23 @@
+import type { RelayBatonConfig } from "@relay-baton/shared";
+export type CheckStatus = "ok" | "warn" | "fail" | "info";
+export interface Check {
+    status: CheckStatus;
+    label: string;
+    value: string;
+}
+/** Arguments that relay-baton must never pass to an agent (security / policy). */
+export declare const DEPRECATED_AGENT_ARGS: string[];
+/** Expected default adapter args (sanity baseline), derived from the registry. */
+export declare const EXPECTED_AGENT_ARGS: Record<string, string[]>;
+/**
+ * Core checks shared by `doctor` and `verify`. Environment + agents + auth
+ * presence, never printing secret values.
+ */
+export declare function coreChecks(repoRoot: string, cfg: RelayBatonConfig): Check[];
+/** Extended diagnostics for `doctor --deep`. */
+export declare function deepChecks(repoRoot: string, cfg: RelayBatonConfig): Check[];
+export declare function loadConfig(repoRoot: string): {
+    config: RelayBatonConfig;
+    source: "default" | "file";
+    error?: string;
+};

package/dist/commands/diagnostics.js

@@ -0,0 +1,254 @@
+"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.EXPECTED_AGENT_ARGS = exports.DEPRECATED_AGENT_ARGS = void 0;
+exports.coreChecks = coreChecks;
+exports.deepChecks = deepChecks;
+exports.loadConfig = loadConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const core_1 = require("@relay-baton/core");
+const core_2 = require("@relay-baton/core");
+const core_3 = require("@relay-baton/core");
+const core_4 = require("@relay-baton/core");
+const core_5 = require("@relay-baton/core");
+const handoffHistory_1 = require("./handoffHistory");
+/** Arguments that relay-baton must never pass to an agent (security / policy). */
+exports.DEPRECATED_AGENT_ARGS = [
+    "--full-auto",
+    "--ask-for-approval",
+    "--dangerously-bypass-approvals-and-sandbox",
+    "bypassPermissions",
+];
+/** Expected default adapter args (sanity baseline), derived from the registry. */
+exports.EXPECTED_AGENT_ARGS = Object.fromEntries(core_5.ALL_AGENT_IDS.map((id) => [id, core_5.AGENT_REGISTRY[id].defaultArgs]));
+function toolVersion(cmd) {
+    const r = (0, core_1.safeSpawnSync)(cmd, ["--version"], { encoding: "utf8" });
+    if (r.error != null)
+        return null;
+    const out = `${r.stdout ?? ""}${r.stderr ?? ""}`.trim();
+    return out.split(/\r?\n/)[0] || "available";
+}
+function readSafe(p) {
+    try {
+        return fs.readFileSync(p, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Core checks shared by `doctor` and `verify`. Environment + agents + auth
+ * presence, never printing secret values.
+ */
+function coreChecks(repoRoot, cfg) {
+    const checks = [];
+    const gitOk = fs.existsSync(path.join(repoRoot, ".git"));
+    checks.push({ status: gitOk ? "ok" : "fail", label: "git repository", value: gitOk ? "yes" : "no (run inside a git repo)" });
+    const gitV = toolVersion("git");
+    checks.push({ status: gitV ? "ok" : "fail", label: "git command", value: gitV ?? "MISSING" });
+    // Agent availability (v2.3): first-class agents warn when missing (they are the
+    // default relay); supported agents are info-only (optional, opt-in).
+    for (const id of core_5.ALL_AGENT_IDS) {
+        const desc = core_5.AGENT_REGISTRY[id];
+        const cmd = cfg.agents[id]?.command ?? desc.command;
+        const v = toolVersion(cmd);
+        const missingStatus = desc.tier === "first-class" ? "warn" : "info";
+        checks.push({
+            status: v ? "ok" : missingStatus,
+            label: `${id} command`,
+            value: v ?? `missing — run \`relay-baton login ${id}\` (${desc.tier})`,
+        });
+    }
+    // Auth: presence only, never values.
+    for (const ev of cfg.authPolicy.blockedEnvVars) {
+        const set = !!process.env[ev];
+        if (set && !cfg.authPolicy.allowApiKeyEnv) {
+            checks.push({ status: "warn", label: ev, value: "set — blocked by default (use --allow-api-key-env to pass through)" });
+        }
+        else {
+            checks.push({ status: "info", label: ev, value: set ? "set (passed through)" : "not set" });
+        }
+    }
+    const sm = new core_2.SessionManager(repoRoot, cfg);
+    const hasSession = fs.existsSync(sm.files.dir);
+    checks.push({ status: hasSession ? "ok" : "warn", label: ".ai-session", value: hasSession ? sm.files.dir : "missing — run `relay-baton init`" });
+    return checks;
+}
+/** Extended diagnostics for `doctor --deep`. */
+function deepChecks(repoRoot, cfg) {
+    const checks = [];
+    // Tooling versions.
+    const node = process.version;
+    const major = Number(node.replace(/^v/, "").split(".")[0]);
+    checks.push({ status: major >= 20 ? "ok" : "warn", label: "node version", value: `${node}${major >= 20 ? "" : " (>=20 recommended)"}` });
+    const pnpmV = toolVersion("pnpm");
+    checks.push({ status: pnpmV ? "ok" : "info", label: "pnpm version", value: pnpmV ?? "not found (only needed for development)" });
+    // Adapter args sanity.
+    for (const [id, expected] of Object.entries(exports.EXPECTED_AGENT_ARGS)) {
+        const args = cfg.agents[id]?.args ?? [];
+        const deprecated = args.filter(a => exports.DEPRECATED_AGENT_ARGS.includes(a));
+        if (deprecated.length > 0) {
+            checks.push({ status: "fail", label: `${id} args`, value: `uses forbidden arg(s): ${deprecated.join(", ")}` });
+        }
+        else if (JSON.stringify(args) === JSON.stringify(expected)) {
+            checks.push({ status: "ok", label: `${id} args`, value: args.join(" ") });
+        }
+        else {
+            checks.push({ status: "warn", label: `${id} args`, value: `custom: ${args.join(" ") || "(empty)"} (default: ${expected.join(" ")})` });
+        }
+    }
+    // .gitattributes / CRLF hints (Windows-relevant).
+    const gaPath = path.join(repoRoot, ".gitattributes");
+    const hasGa = fs.existsSync(gaPath);
+    if (os.platform() === "win32") {
+        checks.push({
+            status: hasGa ? "ok" : "warn",
+            label: ".gitattributes",
+            value: hasGa ? "present (EOL normalization configured)" : "missing — add `* text=auto eol=lf` to avoid CRLF churn on Windows",
+        });
+    }
+    else {
+        checks.push({ status: "info", label: ".gitattributes", value: hasGa ? "present" : "absent (ok on this platform)" });
+    }
+    // Registry health.
+    const registryPath = process.env.RELAY_BATON_PROJECTS_FILE
+        ?? path.join(os.homedir(), ".relay-baton", "projects.json");
+    if (fs.existsSync(registryPath)) {
+        try {
+            const data = JSON.parse(readSafe(registryPath));
+            const count = Array.isArray(data?.projects) ? data.projects.length : 0;
+            checks.push({ status: "ok", label: "project registry", value: `${count} project(s) — ${registryPath}` });
+        }
+        catch {
+            checks.push({ status: "fail", label: "project registry", value: `unparseable JSON — ${registryPath}` });
+        }
+    }
+    else {
+        checks.push({ status: "info", label: "project registry", value: "none (cwd-based mode)" });
+    }
+    // Config contract validation (v1.0 frozen schema).
+    {
+        const r = (0, core_4.validateConfig)(cfg);
+        checks.push({
+            status: r.ok ? "ok" : "fail",
+            label: "config contract",
+            value: r.ok ? `valid (v${cfg.configVersion ?? "?"})` : r.errors.join("; "),
+        });
+        for (const w of r.warnings) {
+            checks.push({ status: "warn", label: "config contract", value: w });
+        }
+    }
+    // .ai-session artifact shape validation (v1.0 frozen artifacts).
+    {
+        const report = (0, core_4.validateArtifacts)(repoRoot);
+        if (!report.exists) {
+            checks.push({ status: "info", label: "artifact shapes", value: "no .ai-session yet" });
+        }
+        else {
+            for (const c of report.checks) {
+                const status = c.status === "absent" ? "info" : c.status === "warn" ? "warn" : c.status === "fail" ? "fail" : "ok";
+                checks.push({ status, label: `artifact: ${c.file}`, value: c.detail });
+            }
+        }
+    }
+    // .ai-session artifact schema versions (v2.0 migration checks).
+    {
+        const schema = new core_4.SchemaInspector(repoRoot).inspect();
+        if (!schema.exists) {
+            checks.push({ status: "info", label: "artifact schemas", value: "no .ai-session yet" });
+        }
+        else {
+            for (const c of schema.checks) {
+                if (c.status === "absent")
+                    continue;
+                const status = c.status === "ok" ? "ok" : c.status === "ahead" || c.status === "unreadable" ? "fail" : "warn";
+                const found = c.foundVersion == null ? "-" : `v${c.foundVersion}`;
+                checks.push({ status, label: `schema: ${c.file}`, value: `${c.status} (${found}/v${c.currentVersion})` });
+            }
+            if (schema.migratable) {
+                checks.push({ status: "info", label: "migration", value: "run `relay-baton migrate --check` for guidance" });
+            }
+        }
+    }
+    // .ai-session health.
+    const sm = new core_2.SessionManager(repoRoot, cfg);
+    if (fs.existsSync(sm.files.dir)) {
+        const meta = sm.getMeta();
+        checks.push({ status: meta ? "ok" : "warn", label: "session.json", value: meta ? `status=${meta.status} agent=${meta.activeAgent}` : "missing or unreadable" });
+        // Latest handoff + budget.
+        const history = (0, handoffHistory_1.collectHandoffHistory)(repoRoot);
+        const current = history.find(h => h.current);
+        if (current) {
+            const activeProfile = meta?.tokenDietProfile ?? cfg.tokenDiet.profile;
+            const max = cfg.tokenDiet.profiles[activeProfile]?.maxHandoffChars ?? 0;
+            const over = max > 0 && current.size > max;
+            checks.push({ status: over ? "warn" : "ok", label: "latest handoff", value: `${current.size}B / ${max} budget (${activeProfile})${over ? " — over budget" : ""}` });
+        }
+        else {
+            checks.push({ status: "info", label: "latest handoff", value: "none yet" });
+        }
+        // plan.md status.
+        const planMd = readSafe(sm.files.p("plan"));
+        if (planMd.trim().length > 0) {
+            const missing = core_3.PLAN_SECTIONS.filter(s => (0, core_3.planSectionBody)(planMd, s).length === 0);
+            checks.push({
+                status: missing.length === 0 ? "ok" : "warn",
+                label: "plan.md",
+                value: missing.length === 0 ? `present (${core_3.PLAN_SECTIONS.length} sections)` : `present, empty sections: ${missing.join(", ")}`,
+            });
+        }
+        else {
+            checks.push({ status: "info", label: "plan.md", value: "none" });
+        }
+        // compress-context status (rotated raw artifacts).
+        const rotated = fs.existsSync(sm.files.dir)
+            ? fs.readdirSync(sm.files.dir).filter(n => n.startsWith("commands.log.full."))
+            : [];
+        checks.push({
+            status: "info",
+            label: "compress-context",
+            value: rotated.length > 0 ? `${rotated.length} rotated log(s) — last compression occurred` : "no rotations yet",
+        });
+    }
+    else {
+        checks.push({ status: "info", label: ".ai-session contents", value: "not initialized" });
+    }
+    return checks;
+}
+function loadConfig(repoRoot) {
+    return core_2.ConfigLoader.load(repoRoot);
+}

package/dist/commands/doctor.d.ts

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

package/dist/commands/doctor.js

@@ -0,0 +1,104 @@
+"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.doctorCommand = doctorCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+const diagnostics_1 = require("./diagnostics");
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+function icon(status) {
+    return status === "ok" ? `${GREEN}✓${RESET}`
+        : status === "warn" ? `${YELLOW}!${RESET}`
+            : status === "info" ? `${CYAN}•${RESET}`
+                : `${RED}✗${RESET}`;
+}
+function printCheck(c) {
+    console.log(`  ${icon(c.status)}  ${c.label.padEnd(26)} ${DIM}${c.value}${RESET}`);
+}
+function section(title) {
+    console.log(`\n${CYAN}${BOLD}${title}${RESET}`);
+}
+async function doctorCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const cfgLoad = core_1.ConfigLoader.load(repoRoot);
+    const cfg = cfgLoad.config;
+    console.log(`${BOLD}relay-baton doctor${opts.deep ? " --deep" : ""}${RESET}  ${DIM}${repoRoot}${RESET}`);
+    const core = (0, diagnostics_1.coreChecks)(repoRoot, cfg);
+    section("Core");
+    for (const c of core)
+        printCheck(c);
+    printCheck({ status: "info", label: "config source", value: cfgLoad.source + (cfgLoad.error ? ` (error: ${cfgLoad.error})` : "") });
+    printCheck({ status: "info", label: "AGENTS.md", value: fs.existsSync(path.join(repoRoot, "AGENTS.md")) ? "exists" : "missing" });
+    printCheck({ status: "info", label: "CLAUDE.md", value: fs.existsSync(path.join(repoRoot, "CLAUDE.md")) ? "exists" : "missing" });
+    let deep = [];
+    if (opts.deep) {
+        deep = (0, diagnostics_1.deepChecks)(repoRoot, cfg);
+        section("Deep diagnostics");
+        for (const c of deep)
+            printCheck(c);
+    }
+    const all = [...core, ...deep];
+    const fails = all.filter(c => c.status === "fail").length;
+    const warns = all.filter(c => c.status === "warn").length;
+    section("Summary");
+    if (fails > 0) {
+        console.log(`  ${RED}${fails} failure(s)${RESET}, ${warns} warning(s).`);
+    }
+    else if (warns > 0) {
+        console.log(`  ${YELLOW}${warns} warning(s)${RESET}, no failures.`);
+    }
+    else {
+        console.log(`  ${GREEN}All checks passed.${RESET}`);
+    }
+    if (!opts.deep) {
+        console.log(`  ${DIM}Run \`relay-baton doctor --deep\` for extended diagnostics.${RESET}`);
+    }
+    // doctor never exits non-zero on warnings; only on hard failures.
+    if (fails > 0)
+        process.exitCode = 1;
+    // Touch SessionManager so an uninitialized repo still gives a hint.
+    const sm = new core_1.SessionManager(repoRoot, cfg);
+    if (!fs.existsSync(sm.files.dir)) {
+        console.log(`  ${DIM}→ Run \`relay-baton init\` to create .ai-session/.${RESET}`);
+    }
+}

package/dist/commands/execute.d.ts

@@ -0,0 +1,9 @@
+import { ProjectOpts } from "./projectOptions";
+export interface ExecuteOpts extends ProjectOpts {
+    diet?: string;
+    with?: string;
+    from?: string;
+    force?: boolean;
+    allowApiKeyEnv?: boolean;
+}
+export declare function executeCommand(opts: ExecuteOpts): Promise<void>;