@agentbridge1/cli 0.0.4 → 0.0.6

package/dist/commands/recover.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runRecover = runRecover;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_process_1 = require("node:process");
 const config_1 = require("../config");
 const errors_1 = require("../errors");
-const server_sync_1 = require("../server-sync");
-const node_process_1 = require("node:process");
 const gates_1 = require("../gates");
+const http_1 = require("../http");
 const init_1 = require("../init");
+const recovery_reconcile_1 = require("../recovery-reconcile");
+const server_sync_1 = require("../server-sync");
 function resolveNetworkContext() {
     const cfg = (0, config_1.readConfig)();
     const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId ?? "";
@@ -19,9 +23,14 @@ function resolveNetworkContext() {
     }
     return { projectId, apiKey, apiBaseUrl };
 }
+function rulesInstalled(repoRoot) {
+    return ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, "AGENTBRIDGE.md")) &&
+        (0, node_fs_1.existsSync)((0, node_path_1.resolve)(repoRoot, ".cursor", "rules", "agentbridge.mdc")));
+}
 function renderRecoverOutput(packet) {
     const lines = [];
-    const domainCount = packet.domains_summary.length;
+    const activeDomains = (packet.domains_summary ?? []).filter((d) => d.state !== "retired");
+    const domainCount = activeDomains.length;
     const ruleCount = packet.global_rules?.length ?? 0;
     const hasCharterContext = Boolean(packet.charter_summary?.purpose);
     lines.push("Project recovered.");
@@ -35,7 +44,7 @@ function renderRecoverOutput(packet) {
     if (domainCount > 0) {
         lines.push("");
         lines.push("Domains found:");
-        for (const domain of packet.domains_summary) {
+        for (const domain of activeDomains) {
             const pathNote = domain.owned_path_count > 0 ? `${domain.owned_path_count} path(s)` : "paths pending";
             lines.push(`- ${domain.domain_name} — ${pathNote}`);
         }
@@ -54,18 +63,56 @@ function renderRecoverOutput(packet) {
     }
     lines.push("");
     lines.push("Next:");
-    lines.push("  agentbridge start");
+    lines.push("  agentbridge watch");
     lines.push("");
     return lines.join("\n");
 }
 function recoveryStatusLabel(packet) {
     return packet.recovery_status ?? "unknown";
 }
-function baselineRequired(packet) {
-    const status = packet.recovery_status ?? null;
-    if (packet.project_mode !== "recovery")
-        return false;
-    return status === "baseline_required" || status === "pending" || status === null;
+function formatDomainLines(refs) {
+    if (refs.length === 0)
+        return "  (none)";
+    return refs.map((d) => `- ${d.name}`).join("\n");
+}
+function renderReconcileReport(input) {
+    const { plan, applied, qualityAfter } = input;
+    const lines = [""];
+    if (applied) {
+        lines.push("AgentBridge checked recovery.");
+        lines.push(`Recovery quality: ${qualityAfter}`);
+        if (plan.toAdd.length > 0) {
+            lines.push("");
+            lines.push("Added:");
+            lines.push(formatDomainLines(plan.toAdd));
+        }
+        if (plan.toPreserve.length > 0) {
+            lines.push("");
+            lines.push("Existing domains preserved:");
+            lines.push(formatDomainLines(plan.toPreserve));
+        }
+        if (plan.toRetire.length > 0) {
+            lines.push("");
+            lines.push("Retired:");
+            lines.push(formatDomainLines(plan.toRetire));
+        }
+    }
+    else {
+        lines.push("AgentBridge checked recovery.");
+        lines.push("No changes needed.");
+        lines.push("Recovery is up to date.");
+        lines.push(`Recovery quality: ${qualityAfter}`);
+    }
+    return lines.join("\n") + "\n";
+}
+function renderBasicHint() {
+    return [
+        "",
+        "Recovery: basic",
+        "AgentBridge found only a generic project area.",
+        "Run `agent recover --force` to rebuild the domain map.",
+        "",
+    ].join("\n");
 }
 function renderRecoveryStatusBlock(input) {
     const lines = [];
@@ -78,6 +125,60 @@ function renderRecoveryStatusBlock(input) {
     lines.push("");
     return lines.join("\n");
 }
+function normalizeBootstrapError(error) {
+    if ((0, http_1.isCliHttpError)(error) && error.status === 422) {
+        const parsed = (0, http_1.parseCliHttpErrorBody)(error);
+        const details = [];
+        const nestedError = parsed && typeof parsed.error === "object" && parsed.error !== null
+            ? parsed.error
+            : null;
+        const fieldErrors = nestedError && typeof nestedError.fieldErrors === "object" && nestedError.fieldErrors !== null
+            ? nestedError.fieldErrors
+            : null;
+        if (fieldErrors) {
+            for (const [field, value] of Object.entries(fieldErrors)) {
+                if (Array.isArray(value) && value.length > 0) {
+                    details.push(`${field}: ${String(value[0])}`);
+                }
+            }
+        }
+        const detailText = details.length > 0 ? ` (${details.join("; ")})` : "";
+        return (0, errors_1.catalogCliError)("CONFIG_INCOMPLETE", {
+            what: `Recovery bootstrap payload was rejected by server validation${detailText}.`,
+            why: "The server cannot activate recovery until required bootstrap fields pass validation.",
+            next: "Retry `agentbridge recover`. If it fails again, run with AGENTBRIDGE_DEBUG=1 and share output.",
+        });
+    }
+    if (error instanceof Error) {
+        const message = error.message;
+        if (/does not have any commits yet/i.test(message) ||
+            /bad revision ['"]head['"]/i.test(message) ||
+            /not a git repository/i.test(message)) {
+            return new errors_1.SafeCliError({
+                code: "CONFIG_INCOMPLETE",
+                category: "CONFIG_ERROR",
+                what: "Repository has no usable git history for recovery mapping.",
+                why: "Recover infers baseline context from commit history and cannot proceed without it.",
+                next: [
+                    "Create an initial commit, then rerun recover:",
+                    "1) git add .",
+                    "2) git commit -m \"Initial commit\"",
+                    "3) agentbridge recover",
+                ].join("\n"),
+            });
+        }
+        if (/payload too large after compaction/i.test(message)) {
+            return new errors_1.SafeCliError({
+                code: "CONFIG_INCOMPLETE",
+                category: "CONFIG_ERROR",
+                what: "Repository evidence exceeded bootstrap payload limits.",
+                why: "The recovery evidence payload could not be compacted enough for server ingestion.",
+                next: "Run `agentbridge init` for an interactive baseline, or retry recover after reducing repository noise.",
+            });
+        }
+    }
+    return error;
+}
 async function runRecover(options = {}) {
     process.exitCode = 0;
     process.stdout.write([
@@ -120,18 +221,64 @@ async function runRecover(options = {}) {
         return;
     }
     const beforePacket = packet;
-    const needsRecovery = baselineRequired(beforePacket);
-    let actionTaken = "baseline already exists; no rebuild needed";
-    if (needsRecovery || options.force) {
-        actionTaken = needsRecovery
+    const cfg = (0, config_1.readConfig)();
+    const repoRoot = (0, node_process_1.cwd)();
+    const rulesOk = rulesInstalled(repoRoot);
+    let scan;
+    try {
+        process.stdout.write("Scanning repository layout...\n");
+        scan = await (0, init_1.scanRecoveryFromRepo)(ctx);
+    }
+    catch (error) {
+        process.stderr.write(`${(0, errors_1.renderCliError)(normalizeBootstrapError(error))}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const existingActive = (0, recovery_reconcile_1.packetDomainsToRefs)(beforePacket, cfg.domains ?? []);
+    const plan = (0, recovery_reconcile_1.buildReconcilePlan)({
+        existingActive,
+        candidates: scan.candidateRefs,
+        mode: options.force ? "force" : "safe",
+        packet: beforePacket,
+        rulesInstalled: rulesOk,
+    });
+    const needsBaseline = (0, recovery_reconcile_1.recoveryBaselineRequired)(beforePacket);
+    const shouldApply = needsBaseline || options.force || plan.hasChanges;
+    let actionTaken = "reconciliation check only; no changes needed";
+    if (shouldApply) {
+        actionTaken = needsBaseline
             ? "build recovery baseline from repository evidence"
-            : "force-refresh recovery baseline from repository evidence";
-        process.stdout.write("Building recovery baseline now...\n");
-        await (0, init_1.runBootstrapRecovery)(ctx);
-        packet = await (0, server_sync_1.fetchProjectPacket)(ctx);
+            : options.force
+                ? "force-refresh recovery baseline from repository evidence"
+                : "reconcile recovery with repository evidence";
+        process.stdout.write("Applying recovery changes...\n");
+        try {
+            await (0, init_1.runBootstrapRecovery)(ctx, {
+                reconcilePlan: plan,
+                scan,
+            });
+            packet = await (0, server_sync_1.fetchProjectPacket)(ctx);
+        }
+        catch (error) {
+            process.stderr.write(`${(0, errors_1.renderCliError)(normalizeBootstrapError(error))}\n`);
+            process.exitCode = 1;
+            return;
+        }
     }
     const afterPacket = packet;
-    if (baselineRequired(afterPacket)) {
+    const qualityAfter = (0, recovery_reconcile_1.recoveryQualityLabel)((0, recovery_reconcile_1.buildReconcilePlan)({
+        existingActive: (0, recovery_reconcile_1.packetDomainsToRefs)(afterPacket, cfg.domains ?? []),
+        candidates: scan.candidateRefs,
+        mode: options.force ? "force" : "safe",
+        packet: afterPacket,
+        rulesInstalled: rulesOk,
+    }).quality);
+    process.stdout.write(renderReconcileReport({
+        plan,
+        applied: shouldApply,
+        qualityAfter,
+    }));
+    if ((0, recovery_reconcile_1.recoveryBaselineRequired)(afterPacket)) {
         process.stderr.write([
             "Recovery could not complete: baseline still required.",
             "",
@@ -146,7 +293,6 @@ async function runRecover(options = {}) {
         process.exitCode = 1;
         return;
     }
-    const repoRoot = (0, node_process_1.cwd)();
     (0, gates_1.ensureGitignoreSessionEntry)(repoRoot);
     (0, gates_1.ensureGatesFile)(repoRoot);
     process.stdout.write(renderRecoveryStatusBlock({
@@ -154,7 +300,10 @@ async function runRecover(options = {}) {
         before: beforePacket,
         after: afterPacket,
         action: actionTaken,
-        next: "agentbridge start",
+        next: "agentbridge watch",
     }));
-    process.stdout.write(renderRecoverOutput(packet));
+    process.stdout.write(renderRecoverOutput(afterPacket));
+    if ((0, recovery_reconcile_1.recoveryIsBasicPacket)(afterPacket)) {
+        process.stdout.write(renderBasicHint());
+    }
 }

package/dist/commands/setup-mcp.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSetupMcp = runSetupMcp;
+const node_path_1 = require("node:path");
 const config_1 = require("../config");
+const mcp_runtime_1 = require("../mcp-runtime");
 const MCP_SERVER_NAME = "agentbridge";
 function standardSnippet(projectId, apiKey, apiBaseUrl) {
     const serverConfig = {
@@ -47,8 +49,27 @@ async function runSetupMcp(options = {}) {
     else {
         process.stdout.write("\n✓ Credentials filled from .agentbridge/config.json\n");
     }
+    const cliDistDir = (0, node_path_1.resolve)(__dirname, "..");
+    if (!(0, mcp_runtime_1.isMcpRuntimeAvailable)(cliDistDir)) {
+        process.stdout.write([
+            "",
+            "⚠  MCP runtime is missing from this CLI install.",
+            "   `agentbridge mcp` will exit until you reinstall:",
+            "     npm install -g @agentbridge1/cli@latest",
+            "",
+            "   Or point mcp.json at a repo build:",
+            "     node /path/to/AuthAgent/cli/dist/mcp/agentbridge-mcp.js",
+            "",
+        ].join("\n"));
+    }
+    else {
+        process.stdout.write([
+            "",
+            "✓ MCP runtime is bundled with this CLI (`agentbridge mcp` is ready).",
+            "",
+        ].join("\n"));
+    }
     process.stdout.write([
-        "",
         "After saving the config, restart your editor to activate the MCP server.",
         "The MCP server lets your AI assistant call tools like agent_hello, check AgentBridge status, and trigger approvals.",
         "",

package/dist/commands/start.js

@@ -39,9 +39,8 @@ const domain_resolution_1 = require("../domain-resolution");
 const errors_1 = require("../errors");
 const error_catalog_1 = require("../error-catalog");
 const http_1 = require("../http");
-const git_status_1 = require("../git-status");
 const session_1 = require("../session");
-const work_contract_1 = require("../work-contract");
+const session_state_1 = require("../session-state");
 const server_sync_1 = require("../server-sync");
 const work_context_resolver_1 = require("../work-context-resolver");
 const PROMOTION_PLAN = {
@@ -395,6 +394,29 @@ function renderOtherSessions(lines, sessionIds) {
         ...sessionIds.map((id) => `- ${id}`),
     ];
 }
+async function resolveExecutionSurfaceIdForStart(ctx, opts, cfgExecutionSurfaceId) {
+    const explicitExecutionSurfaceId = opts.executionSurfaceId?.trim();
+    if (explicitExecutionSurfaceId) {
+        (0, config_1.updateConfig)({ executionSurfaceId: explicitExecutionSurfaceId });
+        return explicitExecutionSurfaceId;
+    }
+    const configuredExecutionSurfaceId = cfgExecutionSurfaceId?.trim();
+    if (configuredExecutionSurfaceId) {
+        return configuredExecutionSurfaceId;
+    }
+    try {
+        const callerPacket = await (0, server_sync_1.fetchCallerIdentityPacket)(ctx);
+        const discoveredExecutionSurfaceId = callerPacket?.execution_surface?.id?.trim() || null;
+        if (discoveredExecutionSurfaceId) {
+            (0, config_1.updateConfig)({ executionSurfaceId: discoveredExecutionSurfaceId });
+            return discoveredExecutionSurfaceId;
+        }
+    }
+    catch {
+        // Keep the existing catalog error path if caller identity discovery fails.
+    }
+    return null;
+}
 async function executeStartWorkSession(opts) {
     const summary = trimRequired(opts.summary ?? "", "--summary");
     const scope = trimRequired(opts.scope ?? "", "--scope");
@@ -406,7 +428,7 @@ async function executeStartWorkSession(opts) {
     if (!explicitAgentId && !configuredActiveAgentId) {
         throw (0, errors_1.catalogCliError)("START_MISSING_ACTIVE_AGENT");
     }
-    const executionSurfaceId = cfg.executionSurfaceId?.trim();
+    const executionSurfaceId = await resolveExecutionSurfaceIdForStart(ctx, opts, cfg.executionSurfaceId);
     if (!executionSurfaceId) {
         throw (0, errors_1.catalogCliError)("START_EXECUTION_SURFACE_REQUIRED");
     }
@@ -544,83 +566,55 @@ async function executeStartWorkSession(opts) {
         otherSessionIds: [...new Set(otherSessionIds)],
     };
 }
-async function runSmartStart(opts = {}) {
-    const cfg = (0, config_1.readConfig)();
-    await ensureProjectAccess();
-    const explicitAgentId = opts.agentId?.trim();
-    const configuredActiveAgentId = cfg.activeAgentId?.trim();
-    if (!explicitAgentId && !configuredActiveAgentId) {
-        throw (0, errors_1.catalogCliError)("START_MISSING_ACTIVE_AGENT");
-    }
-    if (!cfg.executionSurfaceId?.trim()) {
-        throw (0, errors_1.catalogCliError)("START_EXECUTION_SURFACE_REQUIRED");
-    }
-    const ctx = (0, config_1.contextFromConfig)();
-    const resolution = await (0, work_context_resolver_1.resolveWorkContext)(ctx, {
-        allowServerCurrentForCr: true,
-        includeOtherActiveSessions: true,
-    });
-    if (resolution.state === "current_session_resolved") {
-        process.stdout.write("Active work session found - entering watch mode.\n");
-        if (!opts.skipWatch) {
-            const { runWatch } = await Promise.resolve().then(() => __importStar(require("./watch")));
-            await runWatch({ allowDirty: true });
-        }
-        return;
-    }
-    if (resolution.state === "ambiguous_active_sessions") {
-        process.stdout.write(`${(0, work_context_resolver_1.renderWorkContextLines)(resolution).join("\n")}\n`);
-        throw (0, errors_1.catalogCliError)((0, error_catalog_1.workContextStateToCode)(resolution.state));
-    }
-    if (resolution.state === "mismatch" || resolution.state === "stale_orphan_session_detected") {
-        process.stdout.write(`${(0, work_context_resolver_1.renderWorkContextLines)(resolution).join("\n")}\n`);
-        throw (0, errors_1.catalogCliError)((0, error_catalog_1.workContextStateToCode)(resolution.state));
-    }
-    const inferred = (0, work_contract_1.inferWorkContract)({
+function hasActiveLocalRun() {
+    const local = (0, session_state_1.readSessionState)();
+    if (!local)
+        return false;
+    if (local.status !== "active" && local.status !== "blocked")
+        return false;
+    if (!local.id || local.id === "none")
+        return false;
+    return true;
+}
+async function runDefaultStart(opts = {}) {
+    const { runLocalSupervision } = await Promise.resolve().then(() => __importStar(require("../local-supervision")));
+    await runLocalSupervision({
         prompt: opts.prompt,
-        branchName: (0, git_status_1.getBranchName)(),
-        dirtyFiles: (0, git_status_1.getDirtyWorkingTreeFiles)(),
-        activeChangeRequestId: cfg.activeChangeRequestId ?? null,
-    });
-    const draft = {
-        summary: inferred.summary,
-        scope: opts.scope?.trim() || inferred.scope,
-    };
-    const confirmed = await (0, work_contract_1.confirmWorkContract)(draft, {
-        nonInteractive: !process.stdin.isTTY,
-    });
-    if (!confirmed) {
-        process.stdout.write("Cancelled.\n");
-        return;
-    }
-    await executeStartWorkSession({
-        ...opts,
-        summary: confirmed.summary,
-        scope: confirmed.scope,
+        details: opts.details,
+        confirmClose: opts.confirmClose,
     });
-    process.stdout.write("Work session started. Entering watch mode...\n");
-    if (!opts.skipWatch) {
-        const { runWatch } = await Promise.resolve().then(() => __importStar(require("./watch")));
-        await runWatch({ allowDirty: true });
-    }
+}
+function isStrictTrackedStartRequest(opts) {
+    if (opts.resume === true)
+        return true;
+    if (opts.changeRequestId?.trim())
+        return true;
+    const explicitSummaryFlag = opts.summaryFlagProvided === true;
+    const explicitScopeFlag = opts.scopeFlagProvided === true;
+    const explicitInputProvided = opts.summary !== undefined || opts.scope !== undefined;
+    return explicitSummaryFlag || explicitScopeFlag || explicitInputProvided;
 }
 async function runStart(opts = {}) {
+    const strictTrackedStart = isStrictTrackedStartRequest(opts);
     const explicitSummaryFlag = opts.summaryFlagProvided === true;
     const explicitScopeFlag = opts.scopeFlagProvided === true;
     const explicitInputProvided = opts.summary !== undefined || opts.scope !== undefined;
     const explicitModeRequested = explicitSummaryFlag || explicitScopeFlag || explicitInputProvided;
     const explicitSummary = opts.summary?.trim();
     const explicitScope = opts.scope?.trim();
-    if (explicitModeRequested && explicitSummary && explicitScope) {
+    if (strictTrackedStart && explicitSummary && explicitScope) {
         await executeStartWorkSession({ ...opts, summary: explicitSummary, scope: explicitScope });
         if (!opts.skipWatch) {
             const { runWatch } = await Promise.resolve().then(() => __importStar(require("./watch")));
-            await runWatch({ allowDirty: true });
+            await runWatch({ allowDirty: true, details: opts.details });
         }
         return;
     }
+    if (strictTrackedStart) {
+        throw (0, errors_1.catalogCliError)("START_EXPLICIT_PAIR_REQUIRED");
+    }
     if (explicitModeRequested) {
         throw (0, errors_1.catalogCliError)("START_EXPLICIT_PAIR_REQUIRED");
     }
-    await runSmartStart(opts);
+    await runDefaultStart(opts);
 }