@agentbridge1/cli 0.0.5 → 0.0.7

package/dist/local-supervision.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSupervisionIntent = resolveSupervisionIntent;
+exports.probeCloudCapability = probeCloudCapability;
+exports.runLocalSupervision = runLocalSupervision;
+const promises_1 = require("node:readline/promises");
+const node_process_1 = require("node:process");
+const config_1 = require("./config");
+const domain_resolution_1 = require("./domain-resolution");
+const git_status_1 = require("./git-status");
+const local_proof_1 = require("./local-proof");
+const local_memory_1 = require("./local-memory");
+const session_1 = require("./session");
+const session_state_1 = require("./session-state");
+const server_sync_1 = require("./server-sync");
+const preflight_changed_files_1 = require("./preflight-changed-files");
+function resolveSupervisionIntent(prompt, currentWorkFiles, existing) {
+    if (prompt?.trim())
+        return prompt.trim();
+    if (existing?.intent?.trim())
+        return existing.intent.trim();
+    if (currentWorkFiles.length > 0) {
+        const branch = (0, git_status_1.getBranchName)();
+        if (branch !== "unknown")
+            return `Work on ${branch}`;
+        const preview = currentWorkFiles.slice(0, 2).join(", ");
+        return currentWorkFiles.length > 2 ? `Changes in ${preview}...` : `Changes in ${preview}`;
+    }
+    return undefined;
+}
+async function probeCloudCapability() {
+    const cfg = (0, config_1.readConfig)();
+    const projectId = cfg.projectId?.trim() || process.env.AGENTBRIDGE_PROJECT_ID?.trim();
+    const apiKey = cfg.apiKey?.trim() || process.env.AGENTBRIDGE_API_KEY?.trim();
+    const apiBaseUrl = cfg.apiBaseUrl?.trim() || process.env.AGENTBRIDGE_API_BASE_URL?.trim();
+    const hasActiveAgent = Boolean(cfg.activeAgentId?.trim() || process.env.AGENTBRIDGE_AGENT_ID?.trim());
+    const hasExecutionSurface = Boolean(cfg.executionSurfaceId?.trim());
+    if (!projectId || !apiKey || !apiBaseUrl) {
+        return {
+            localSupervision: "ready",
+            cloudSync: "not_configured",
+            strictTrackedWork: "unavailable",
+            reason: "missing project credentials",
+        };
+    }
+    try {
+        await (0, server_sync_1.fetchProjectPacket)((0, config_1.contextFromConfig)());
+        if (!hasActiveAgent || !hasExecutionSurface) {
+            return {
+                localSupervision: "ready",
+                cloudSync: "incomplete",
+                strictTrackedWork: "unavailable",
+                reason: !hasExecutionSurface ? "execution surface missing" : "active agent missing",
+            };
+        }
+        return {
+            localSupervision: "ready",
+            cloudSync: "ready",
+            strictTrackedWork: "ready",
+        };
+    }
+    catch {
+        return {
+            localSupervision: "ready",
+            cloudSync: "unreachable",
+            strictTrackedWork: "unavailable",
+            reason: "could not reach project API",
+        };
+    }
+}
+function cloudSyncLabel(status) {
+    if (status === "ready")
+        return "configured";
+    if (status === "not_configured")
+        return "not configured";
+    if (status === "incomplete")
+        return "incomplete";
+    return "unreachable";
+}
+function memoryCloudSync(status) {
+    if (status === "ready")
+        return "synced";
+    if (status === "not_configured")
+        return "not_configured";
+    return "failed";
+}
+function persistCurrentWorkFiles(state, currentWorkFiles) {
+    state.changedFiles = currentWorkFiles;
+    state.updatedAt = new Date().toISOString();
+    (0, session_state_1.writeSessionState)(state);
+    return currentWorkFiles;
+}
+async function askConfirmClose() {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        const answer = await rl.question("Close this task and write memory? [Y/n] ");
+        const trimmed = answer.trim().toLowerCase();
+        return trimmed === "" || trimmed === "y" || trimmed === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+function ensureLocalSession(intent, existing) {
+    if ((0, session_state_1.isActiveLocalSession)(existing)) {
+        if (intent && existing.intent !== intent) {
+            existing.intent = intent;
+            existing.updatedAt = new Date().toISOString();
+            (0, session_state_1.writeSessionState)(existing);
+        }
+        return existing;
+    }
+    const cfg = (0, config_1.readConfig)();
+    const lane = (0, domain_resolution_1.inferLaneFromFiles)([], cfg.domains ?? []);
+    return (0, session_1.openLocalSession)({
+        agentId: cfg.activeAgentId ?? "local",
+        laneDomain: lane.laneDomain,
+        claimedPaths: [],
+        domains: cfg.domains ?? [],
+        intent,
+        mode: "local_supervision",
+    });
+}
+function formatTaskLine(state, prompt) {
+    const task = prompt?.trim() || state.intent?.trim();
+    return task ? `Task: ${task}` : "Task: none yet";
+}
+function formatStatusLine(currentWorkFiles, blockingIssue, prompt) {
+    if (currentWorkFiles.length === 0) {
+        return prompt?.trim() ? "Status: waiting for changes" : "Status: waiting for new work";
+    }
+    if (blockingIssue) {
+        return `Status: proof required — ${blockingIssue.whatHappened}`;
+    }
+    return `Status: ${currentWorkFiles.length} changed file(s), proof current`;
+}
+function renderProofGuidance(blockingIssue) {
+    if (!blockingIssue)
+        return [];
+    const lines = [blockingIssue.nextAction];
+    if (blockingIssue.errorCode === "PROOF_STALE_AFTER_CHANGE") {
+        lines.push("Proof is stale because files changed after verification.");
+        lines.push("Record fresh proof:");
+        lines.push("agentbridge verify -- <test command>");
+    }
+    else if (blockingIssue.errorCode === "PROOF_MISSING") {
+        lines.push("Proof required for files changed after this session started.");
+        lines.push("Record proof:");
+        lines.push("agentbridge verify -- <test command>");
+    }
+    return lines;
+}
+async function runLocalSupervision(opts = {}) {
+    const cfg = (0, config_1.readConfig)();
+    const cloud = await probeCloudCapability();
+    const existing = (0, session_state_1.readSessionState)();
+    const isNewSession = !(0, session_state_1.isActiveLocalSession)(existing);
+    if (!(0, session_state_1.isActiveLocalSession)(existing) && cfg.activeChangeRequestId) {
+        (0, config_1.updateConfig)({ activeChangeRequestId: undefined });
+        process.stdout.write("Note: ignoring stale previously tracked task linkage in checkpoint mode.\n");
+    }
+    const dirtyNow = (0, git_status_1.getDirtyWorkingTreeFiles)();
+    const promptIntent = opts.prompt?.trim() || undefined;
+    const preliminaryIntent = promptIntent || ((0, session_state_1.isActiveLocalSession)(existing) ? existing?.intent : undefined);
+    const state = ensureLocalSession(preliminaryIntent, existing);
+    let currentWorkFiles = (0, preflight_changed_files_1.computeCurrentWorkFiles)(state, dirtyNow);
+    const derivedIntent = resolveSupervisionIntent(undefined, currentWorkFiles, state);
+    if (!state.intent?.trim() && derivedIntent) {
+        state.intent = derivedIntent;
+        state.updatedAt = new Date().toISOString();
+        (0, session_state_1.writeSessionState)(state);
+    }
+    currentWorkFiles = persistCurrentWorkFiles(state, currentWorkFiles);
+    const proofEval = (0, local_proof_1.evaluateLocalProof)(currentWorkFiles, state.lastLocalVerificationRun);
+    const blockingIssue = (0, local_proof_1.buildLocalProofBlockingIssue)(proofEval);
+    const lines = [];
+    const baselineCount = state.dirtyFilesAtStart?.length ?? 0;
+    if (isNewSession) {
+        lines.push("Task checkpoint opened.");
+        if (baselineCount > 0) {
+            lines.push(`Pre-existing dirty files found: ${baselineCount}`);
+            lines.push("These will be treated as baseline, not current work.");
+            lines.push("Waiting for new changes.");
+        }
+        lines.push("");
+    }
+    lines.push(formatTaskLine(state, opts.prompt));
+    lines.push("Mode: task checkpoint");
+    lines.push(`Cloud sync: ${cloudSyncLabel(cloud.cloudSync)}${cloud.reason ? ` (${cloud.reason})` : ""}`);
+    lines.push(formatStatusLine(currentWorkFiles, blockingIssue, opts.prompt));
+    if (currentWorkFiles.length === 0) {
+        lines.push("No new work detected since this checkpoint opened.");
+    }
+    if (blockingIssue) {
+        lines.push("");
+        lines.push(...renderProofGuidance(blockingIssue));
+    }
+    if (opts.details) {
+        lines.push("");
+        if (baselineCount > 0) {
+            lines.push("Baseline files (not current work):");
+            for (const file of (state.dirtyFilesAtStart ?? []).slice(0, 10)) {
+                lines.push(`- ${file}`);
+            }
+            if (baselineCount > 10) {
+                lines.push(`- ... +${baselineCount - 10} more`);
+            }
+            lines.push("");
+        }
+        if (currentWorkFiles.length > 0) {
+            lines.push("Current work files:");
+            for (const file of currentWorkFiles.slice(0, 10)) {
+                lines.push(`- ${file}`);
+            }
+            if (currentWorkFiles.length > 10) {
+                lines.push(`- ... +${currentWorkFiles.length - 10} more`);
+            }
+        }
+    }
+    lines.push("");
+    lines.push("For live supervision while the agent codes:");
+    lines.push("  agentbridge watch");
+    lines.push("");
+    lines.push("For task checkpoint/close:");
+    lines.push("  agentbridge start");
+    process.stdout.write(`${lines.join("\n")}\n`);
+    if (!blockingIssue && currentWorkFiles.length > 0) {
+        const shouldClose = opts.confirmClose === true || (await askConfirmClose());
+        if (shouldClose) {
+            state.closeReason = "completed";
+            const closeResult = (0, session_1.closeLocalSession)(state);
+            if (!closeResult.ok) {
+                process.stdout.write(`\nCould not close: ${closeResult.reason}\n`);
+                return;
+            }
+            (0, local_memory_1.writeLocalMemory)(state, { cloudSync: memoryCloudSync(cloud.cloudSync) });
+            process.stdout.write("\n");
+            process.stdout.write("Task closed.\n");
+            process.stdout.write("Local memory written.\n");
+            process.stdout.write(`Cloud sync: ${cloudSyncLabel(cloud.cloudSync)}\n`);
+            process.stdout.write("Run `agentbridge start \"<intent>\"` for the next task checkpoint.\n");
+            return;
+        }
+    }
+    if (cloud.cloudSync !== "ready") {
+        process.stdout.write("\nContinuing locally.\n");
+    }
+}