@agentbridge1/cli 0.0.1

package/dist/commands/accept.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAccept = runAccept;
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const http_1 = require("../http");
+const session_state_1 = require("../session-state");
+const memory_1 = require("./memory");
+const server_sync_1 = require("../server-sync");
+const operator_snapshot_1 = require("../operator-snapshot");
+const work_context_resolver_1 = require("../work-context-resolver");
+const error_catalog_1 = require("../error-catalog");
+const acceptance_preflight_1 = require("../acceptance-preflight");
+const acceptance_block_1 = require("../acceptance-block");
+function resolveNetworkContext() {
+    const cfg = (0, config_1.readConfig)();
+    const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId;
+    const apiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "";
+    const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ?? cfg.apiBaseUrl ?? "https://agentauth-api-production.up.railway.app";
+    if (!projectId) {
+        throw new errors_1.SafeCliError("Missing AGENTBRIDGE_PROJECT_ID. Set AGENTBRIDGE_PROJECT_ID (or run `agentbridge init --project ...`).");
+    }
+    if (!apiKey) {
+        throw new errors_1.SafeCliError("Missing AGENTBRIDGE_API_KEY. Provide --api-key, set AGENTBRIDGE_API_KEY, or save apiKey in .agentbridge/config.json.");
+    }
+    return { projectId, apiKey, apiBaseUrl };
+}
+function buildBlockReasons(report) {
+    return report.completion.blockingReasons;
+}
+function blockedErrorCode(report) {
+    if (report.completion.state === "ready_for_handoff" ||
+        buildBlockReasons(report).some((reason) => reason.toLowerCase().includes("handoff required"))) {
+        return "HANDOFF_REQUIRED";
+    }
+    if ((report.out_of_scope_files ?? []).length > 0 || report.scope_status === "drift") {
+        return "SCOPE_DRIFT_OUT_OF_SCOPE_FILE";
+    }
+    if (report.decision === "needs_proof")
+        return "PROOF_MISSING";
+    if (report.decision === "stale_evidence")
+        return "PROOF_STALE_AFTER_CHANGE";
+    return "ACCEPTANCE_BLOCKED";
+}
+function buildStructuredBlockedOutput(report) {
+    const code = blockedErrorCode(report);
+    const entry = (0, error_catalog_1.catalogEntryForCode)(code);
+    const lines = ["Acceptance blocked."];
+    lines.push(`What happened: ${entry?.what ?? "Acceptance preconditions are not satisfied."}`);
+    lines.push(`Why it matters: ${entry?.why ?? "Blocked work cannot be accepted or closed."}`);
+    lines.push("Next action:");
+    if (entry?.next)
+        lines.push(`- ${entry.next}`);
+    if (report.completion.nextCommand)
+        lines.push(`- ${report.completion.nextCommand}`);
+    for (const action of report.next_required_action) {
+        lines.push(`- ${action}`);
+    }
+    for (const reason of buildBlockReasons(report)) {
+        lines.push(`- ${reason}`);
+    }
+    if (code === "SCOPE_DRIFT_OUT_OF_SCOPE_FILE" && (report.out_of_scope_files ?? []).length > 0) {
+        lines.push("Out-of-scope changed files:");
+        for (const file of report.out_of_scope_files ?? []) {
+            lines.push(`- ${file}`);
+        }
+    }
+    lines.push(`Error code: ${code}`);
+    return lines;
+}
+function isNoActiveSessionHttpError(err) {
+    if (!(err instanceof http_1.CliHttpError) || err.status !== 404)
+        return false;
+    try {
+        const parsed = JSON.parse(err.body);
+        return parsed.code === "active_work_session_not_found" || parsed.error === "active_work_session_not_found";
+    }
+    catch {
+        return false;
+    }
+}
+async function runAccept(options = {}) {
+    const ctx = resolveNetworkContext();
+    const { resolution, report } = await (0, acceptance_preflight_1.resolveAcceptanceWorkContext)(ctx);
+    if (resolution.state !== "current_session_resolved" || !report) {
+        if (options.json) {
+            const snapshot = (0, operator_snapshot_1.buildOperatorSnapshot)(resolution);
+            process.stdout.write(`${JSON.stringify({ snapshot }, null, 2)}\n`);
+        }
+        else {
+            process.stdout.write(`${(0, work_context_resolver_1.renderWorkContextLines)(resolution).join("\n")}\n`);
+        }
+        const code = (0, error_catalog_1.workContextStateToCode)(resolution.state);
+        const entry = (0, error_catalog_1.catalogEntryForCode)(code);
+        throw new errors_1.SafeCliError({
+            code,
+            category: entry?.category ?? "WORK_CONTEXT_ERROR",
+            what: resolution.message,
+            why: entry?.why ?? "Acceptance requires a bound active work session.",
+            next: entry?.next ?? "Run `agentbridge watch` to bind a session, then retry accept.",
+        });
+    }
+    const binding = (0, work_context_resolver_1.requireWorkContextBinding)(resolution, "accept");
+    const snapshot = (0, operator_snapshot_1.buildOperatorSnapshot)(resolution);
+    const locallyAcceptable = report.completion.state === "ready_to_accept" || report.completion.state === "accepted";
+    if (!locallyAcceptable || (0, acceptance_block_1.shouldBlockAcceptanceAction)(report)) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({
+                snapshot,
+                acceptance: {
+                    accepted: false,
+                    blocked_reasons: buildBlockReasons(report),
+                    next_action: report.next_required_action,
+                },
+            }, null, 2)}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        for (const line of buildStructuredBlockedOutput(report))
+            process.stdout.write(`${line}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const result = await (0, server_sync_1.acceptWorkSession)(ctx, binding);
+        const sessionClosed = result.session_status === "closed";
+        if (!options.json) {
+            if (!result.accepted) {
+                const blockedReport = {
+                    ...report,
+                    decision: result.decision,
+                    next_required_action: result.next_action.length > 0 ? result.next_action : report.next_required_action,
+                    completion: {
+                        ...report.completion,
+                        blockingReasons: result.reasons.length > 0 ? result.reasons : report.completion.blockingReasons,
+                    },
+                };
+                for (const line of buildStructuredBlockedOutput(blockedReport)) {
+                    process.stdout.write(`${line}\n`);
+                }
+            }
+            else if (sessionClosed) {
+                process.stdout.write("Accepted. Session fully closed.\n");
+            }
+            else {
+                process.stdout.write("Accepted, but session is still open. Manual close required.\n");
+            }
+            if (result.accepted) {
+                process.stdout.write([
+                    `CR/session: ${result.change_request_id ?? "none"} / ${result.work_session_id}`,
+                    `Decision: ${result.decision}`,
+                    `Session status: ${result.session_status ?? "unchanged"}`,
+                ].join("\n") + "\n");
+                if (result.reasons.length > 0) {
+                    for (const reason of result.reasons)
+                        process.stdout.write(`- ${reason}\n`);
+                }
+                if (result.next_action.length > 0) {
+                    process.stdout.write("Next action:\n");
+                    for (const action of result.next_action)
+                        process.stdout.write(`- ${action}\n`);
+                }
+            }
+        }
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({
+                snapshot,
+                acceptance: {
+                    accepted: result.accepted,
+                    decision: result.decision,
+                    reasons: result.reasons,
+                    next_action: result.next_action,
+                    work_session_id: result.work_session_id,
+                    change_request_id: result.change_request_id,
+                    session_status: result.session_status ?? "unchanged",
+                },
+            }, null, 2)}\n`);
+            if (!result.accepted) {
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (!result.accepted) {
+            process.exitCode = 1;
+            return;
+        }
+        if (sessionClosed) {
+            (0, session_state_1.clearSessionState)();
+            const cfg = (0, config_1.readConfig)();
+            const nextCfg = {
+                ...cfg,
+                lastAcceptedSessionId: result.work_session_id,
+                lastAcceptedAt: new Date().toISOString(),
+            };
+            if (cfg.activeChangeRequestId &&
+                result.change_request_id &&
+                cfg.activeChangeRequestId === result.change_request_id) {
+                delete nextCfg.activeChangeRequestId;
+            }
+            (0, config_1.writeConfig)(nextCfg);
+            try {
+                await (0, memory_1.runMemorySuggest)({ workSessionId: result.work_session_id, compact: true });
+            }
+            catch {
+                process.stderr.write("Memory suggest failed (session was accepted). Run `agentbridge memory suggest` manually.\n");
+            }
+        }
+    }
+    catch (err) {
+        if (isNoActiveSessionHttpError(err)) {
+            if (options.json) {
+                const fallbackSnapshot = (0, operator_snapshot_1.buildOperatorSnapshot)(resolution);
+                process.stdout.write(`${JSON.stringify({ snapshot: fallbackSnapshot }, null, 2)}\n`);
+                process.exitCode = 1;
+                return;
+            }
+            process.stdout.write(`${(0, work_context_resolver_1.renderWorkContextLines)(resolution).join("\n")}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        if (err instanceof http_1.CliHttpError && err.status === 409) {
+            if (options.json) {
+                process.stdout.write(`${JSON.stringify({
+                    snapshot,
+                    acceptance: {
+                        accepted: false,
+                        blocked_reasons: buildBlockReasons(report),
+                        next_action: report.next_required_action,
+                    },
+                }, null, 2)}\n`);
+                process.exitCode = 1;
+                return;
+            }
+            for (const line of buildStructuredBlockedOutput(report))
+                process.stdout.write(`${line}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        throw err;
+    }
+}

package/dist/commands/attention.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAttentionList = runAttentionList;
+exports.runAttentionResolve = runAttentionResolve;
+exports.runAttention = runAttention;
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const http_1 = require("../http");
+function resolveNetworkContext() {
+    const cfg = (0, config_1.readConfig)();
+    const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId;
+    const apiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "";
+    const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ?? cfg.apiBaseUrl ?? "https://agentauth-api-production.up.railway.app";
+    if (!projectId || !apiKey) {
+        throw (0, errors_1.catalogCliError)("CONFIG_INCOMPLETE");
+    }
+    return { projectId, apiKey, apiBaseUrl };
+}
+const REASON_LABELS = {
+    ambiguous_intent: "Ambiguous intent",
+    scope_conflict: "Scope conflict",
+    handoff_rejected: "Handoff rejected",
+    close_blocked: "Close blocked",
+    accept_blocked: "Accept blocked",
+    policy_violation: "Policy violation",
+    stale_draft: "Stale draft",
+    manual_escalation: "Manual escalation",
+};
+function fmtReason(code) {
+    return REASON_LABELS[code] ?? code;
+}
+async function runAttentionList() {
+    const ctx = resolveNetworkContext();
+    const res = await (0, http_1.getJson)(ctx, `/v1/dev/projects/${ctx.projectId}/attention`);
+    const items = res.attention ?? res.items ?? [];
+    if (items.length === 0) {
+        console.log("All clear — no pending attention items.");
+        return;
+    }
+    console.log(`Pending attention items — project ${ctx.projectId}\n`);
+    for (const item of items) {
+        const session = item.workSessionId ? item.workSessionId.slice(0, 8) : "n/a";
+        const severity = (item.attentionPayload?.severity ?? "info").toUpperCase();
+        const reason = fmtReason(item.reason ?? "");
+        const label = item.title || reason;
+        console.log(`  ${item.id.slice(0, 8)}  [${severity}]  ${label}  session=${session}`);
+        if (item.attentionPayload?.suggestedAction) {
+            console.log(`           Suggested: ${item.attentionPayload.suggestedAction}`);
+        }
+    }
+}
+async function runAttentionResolve(argv) {
+    const id = argv[0];
+    if (!id) {
+        console.error("Usage: agentbridge attention resolve <id> --resolution dismissed|actioned");
+        process.exit(1);
+    }
+    const resolutionIdx = argv.indexOf("--resolution");
+    const resolution = resolutionIdx !== -1 ? argv[resolutionIdx + 1] : undefined;
+    if (!resolution || !["dismissed", "actioned"].includes(resolution)) {
+        console.error('--resolution must be one of: dismissed, actioned');
+        process.exit(1);
+    }
+    const ctx = resolveNetworkContext();
+    await (0, http_1.postJson)(ctx, `/v1/dev/projects/${ctx.projectId}/attention/${id}/resolve`, { resolution });
+    console.log(`Attention item ${id.slice(0, 8)} resolved as "${resolution}".`);
+}
+async function runAttention(argv) {
+    const sub = argv[0];
+    if (!sub || sub === "list") {
+        await runAttentionList();
+        return;
+    }
+    if (sub === "resolve") {
+        await runAttentionResolve(argv.slice(1));
+        return;
+    }
+    console.log([
+        "Usage: agentbridge attention [command]",
+        "",
+        "Commands:",
+        "  (no args)         List pending attention items",
+        "  resolve <id>      Resolve an item  (--resolution dismissed|actioned)",
+    ].join("\n"));
+}

package/dist/commands/autopilot.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAutopilotStatus = runAutopilotStatus;
+exports.runAutopilotEnable = runAutopilotEnable;
+exports.runAutopilotDisable = runAutopilotDisable;
+exports.runAutopilot = runAutopilot;
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const http_1 = require("../http");
+const server_sync_1 = require("../server-sync");
+function resolveNetworkContext() {
+    const cfg = (0, config_1.readConfig)();
+    const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId;
+    const apiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "";
+    const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ?? cfg.apiBaseUrl ?? "https://agentauth-api-production.up.railway.app";
+    if (!projectId || !apiKey) {
+        throw (0, errors_1.catalogCliError)("CONFIG_INCOMPLETE");
+    }
+    return { projectId, apiKey, apiBaseUrl };
+}
+const AUTOMATION_STATES = {
+    idle: "idle",
+    draft_ready: "draft ready",
+    ready_to_close: "ready to close",
+    ready_to_accept: "ready to accept",
+    blocked_needs_attention: "BLOCKED – needs attention",
+};
+function fmtState(status) {
+    return AUTOMATION_STATES[status] ?? status;
+}
+async function runAutopilotStatus() {
+    const ctx = resolveNetworkContext();
+    const sessions = await (0, server_sync_1.listWorkSessions)(ctx, { status: "active" });
+    if (sessions.length === 0) {
+        console.log("No active sessions found.");
+        return;
+    }
+    console.log(`Autopilot status — project ${ctx.projectId}\n`);
+    for (const s of sessions) {
+        const mode = s.automation_mode ? "enabled" : "disabled";
+        const state = fmtState(s.status);
+        console.log(`  ${s.id.slice(0, 8)}  mode=${mode}  state=${state}  (${s.intent ?? "no intent"})`);
+    }
+}
+async function runAutopilotEnable() {
+    const ctx = resolveNetworkContext();
+    const sessions = await (0, server_sync_1.listWorkSessions)(ctx, { status: "active" });
+    if (sessions.length === 0) {
+        console.error("No active sessions found for this project.");
+        process.exit(1);
+    }
+    const target = sessions[0];
+    await (0, http_1.postJson)(ctx, `/v1/dev/projects/${ctx.projectId}/work-sessions/${target.id}/automation/evaluate`, {
+        enable: true,
+    });
+    console.log(`Autopilot enabled on session ${target.id.slice(0, 8)}.`);
+}
+async function runAutopilotDisable() {
+    const ctx = resolveNetworkContext();
+    const sessions = await (0, server_sync_1.listWorkSessions)(ctx, { status: "active" });
+    if (sessions.length === 0) {
+        console.error("No active sessions found for this project.");
+        process.exit(1);
+    }
+    const target = sessions[0];
+    await (0, http_1.postJson)(ctx, `/v1/dev/projects/${ctx.projectId}/work-sessions/${target.id}/automation/evaluate`, {
+        enable: false,
+    });
+    console.log(`Autopilot disabled on session ${target.id.slice(0, 8)}.`);
+}
+async function runAutopilot(argv) {
+    const sub = argv[0];
+    switch (sub) {
+        case "status":
+            await runAutopilotStatus();
+            break;
+        case "enable":
+            await runAutopilotEnable();
+            break;
+        case "disable":
+            await runAutopilotDisable();
+            break;
+        default:
+            console.log([
+                "Usage: agentbridge autopilot <command>",
+                "",
+                "Commands:",
+                "  status   Show automation state for active sessions",
+                "  enable   Enable autopilot on the current active session",
+                "  disable  Disable autopilot on the current active session",
+            ].join("\n"));
+    }
+}

package/dist/commands/bug.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBugReport = runBugReport;
+exports.runBugValidate = runBugValidate;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const bug_registry_1 = require("../bug-registry");
+function splitListFlag(value) {
+    if (!value)
+        return undefined;
+    const parts = value
+        .split(/[,\n]/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    return parts.length > 0 ? parts : undefined;
+}
+function findRepoRoot(startDir) {
+    let current = (0, node_path_1.resolve)(startDir);
+    for (let i = 0; i < 12; i += 1) {
+        try {
+            (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(current, "package.json"), "utf8");
+            return current;
+        }
+        catch {
+            const parent = (0, node_path_1.resolve)(current, "..");
+            if (parent === current)
+                break;
+            current = parent;
+        }
+    }
+    return startDir;
+}
+async function runBugReport(options) {
+    const foundIn = splitListFlag(options.foundIn) ?? ["dogfood"];
+    const validation = (0, bug_registry_1.validateBugReportInput)({
+        title: options.title,
+        severity: options.severity,
+        category: options.category,
+        foundIn,
+        observed: options.observed,
+        expected: options.expected,
+    });
+    if (!validation.ok) {
+        for (const err of validation.errors) {
+            process.stderr.write(`bug report: ${err}\n`);
+        }
+        process.exit(1);
+        return;
+    }
+    const repoRoot = options.repoRoot ?? findRepoRoot(process.cwd());
+    const record = (0, bug_registry_1.buildBugRecord)({
+        title: options.title.trim(),
+        severity: options.severity,
+        category: options.category,
+        foundIn: foundIn,
+        observed: options.observed.trim(),
+        expected: options.expected.trim(),
+        projectId: options.projectId,
+        workSessionId: options.workSessionId,
+        changeRequestId: options.changeRequestId,
+        affectedCommands: splitListFlag(options.commands),
+        affectedFiles: splitListFlag(options.files),
+        userImpact: options.userImpact,
+        logs: options.logs,
+        repoRoot,
+    });
+    const path = (0, bug_registry_1.writeBugReportFile)(repoRoot, record);
+    process.stdout.write(`Bug report written: ${path}\n`);
+    process.stdout.write(`Next: classify in docs/launch-bugs.md; retro: docs/templates/escaped-bug-retro.md\n`);
+}
+async function runBugValidate(options) {
+    if (!options.file || options.file.trim().length === 0) {
+        process.stderr.write("Missing --file <path> to bug markdown record.\n");
+        process.exit(1);
+        return;
+    }
+    const abs = (0, node_path_1.resolve)(process.cwd(), options.file.trim());
+    let content;
+    try {
+        content = (0, node_fs_1.readFileSync)(abs, "utf8");
+    }
+    catch (err) {
+        process.stderr.write(`Failed to read bug file ${abs}: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+        return;
+    }
+    let record;
+    try {
+        record = (0, bug_registry_1.parseBugRecordFromFile)(content);
+    }
+    catch (err) {
+        process.stderr.write(`Invalid bug file ${abs}: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+        return;
+    }
+    const result = (0, bug_registry_1.validateBugCloseReadiness)(record);
+    if (result.ok) {
+        process.stdout.write(`OK: ${abs} satisfies close rules for status=${record.status}.\n`);
+        return;
+    }
+    process.stderr.write(`Bug close validation failed for ${abs}:\n`);
+    for (const err of result.errors) {
+        process.stderr.write(`  - ${err}\n`);
+    }
+    process.exit(1);
+}