@agentbridge1/cli 0.0.4 → 0.0.6

package/dist/local-session-mirror.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAgentActivityMerge = applyAgentActivityMerge;
+exports.mirrorMcpLifecycleEvent = mirrorMcpLifecycleEvent;
+exports.buildMirrorPatchFromMcp = buildMirrorPatchFromMcp;
+exports.mirrorMcpToolSuccess = mirrorMcpToolSuccess;
+const session_1 = require("./session");
+const session_state_1 = require("./session-state");
+function uniquePaths(paths) {
+    return [...new Set(paths.map((p) => p.trim()).filter(Boolean))].sort();
+}
+function truncateSummary(text, max = 120) {
+    const trimmed = text.trim();
+    if (trimmed.length <= max)
+        return trimmed;
+    return `${trimmed.slice(0, max - 1)}…`;
+}
+function mergeClaimedPaths(existing, incoming) {
+    return uniquePaths([...existing, ...incoming]);
+}
+function effectiveClaimedPaths(state, patch) {
+    const base = state.claimedPaths ?? [];
+    const fromActivity = state.agentActivity?.claimedPaths ?? [];
+    const incoming = patch.claimedPaths ?? [];
+    return mergeClaimedPaths(mergeClaimedPaths(base, fromActivity), incoming);
+}
+function buildAgentActivity(state, patch, now) {
+    const claimedPaths = patch.claimedPaths?.length
+        ? mergeClaimedPaths(state.agentActivity?.claimedPaths ?? [], patch.claimedPaths)
+        : state.agentActivity?.claimedPaths;
+    const activity = {
+        source: "mcp",
+        updatedAt: now,
+        lastEvent: patch.event,
+        workSessionId: patch.workSessionId ?? state.agentActivity?.workSessionId ?? state.serverSessionId,
+        changeRequestId: patch.changeRequestId ?? state.agentActivity?.changeRequestId ?? state.changeRequestId,
+        intent: patch.intent ?? state.agentActivity?.intent ?? state.intent,
+        claimedPaths,
+        laneDomain: patch.laneDomain !== undefined ? patch.laneDomain : state.agentActivity?.laneDomain,
+        laneId: patch.laneId ?? state.agentActivity?.laneId,
+        laneType: patch.laneType ?? state.agentActivity?.laneType,
+        laneValue: patch.laneValue ?? state.agentActivity?.laneValue,
+        summary: patch.summary !== undefined ? truncateSummary(patch.summary) : state.agentActivity?.summary,
+        handoffId: patch.handoffId ?? state.agentActivity?.handoffId,
+        closedAt: patch.closeSession ? now : state.agentActivity?.closedAt,
+    };
+    return activity;
+}
+function createShellSession(patch, now) {
+    const baseline = (0, session_1.captureLocalSessionBaseline)();
+    const claimedPaths = uniquePaths(patch.claimedPaths ?? []);
+    return {
+        id: `local_${Date.now().toString(36)}`,
+        agentId: "mcp",
+        laneDomain: patch.laneDomain ?? null,
+        intent: patch.intent?.trim() || undefined,
+        changeRequestId: patch.changeRequestId,
+        claimedPaths,
+        status: "active",
+        changedFiles: [],
+        crossings: [],
+        approvals: [],
+        domains: [],
+        serverSessionId: patch.workSessionId,
+        createdAt: baseline.startedAt,
+        updatedAt: now,
+        startedAt: baseline.startedAt,
+        gitHead: baseline.gitHead,
+        dirtyFilesAtStart: baseline.dirtyFilesAtStart,
+        fingerprintsAtStart: baseline.fingerprintsAtStart,
+    };
+}
+/** Pure merge for tests — does not write disk. */
+function applyAgentActivityMerge(existing, patch, now = new Date().toISOString()) {
+    const needsNew = !existing || existing.status === "closed" || (patch.event === "start_work_session" && existing.status !== "active");
+    let state;
+    if (needsNew && patch.event !== "close_work_session") {
+        state = createShellSession(patch, now);
+    }
+    else if (!existing) {
+        state = createShellSession(patch, now);
+    }
+    else {
+        state = { ...existing };
+    }
+    const agentActivity = buildAgentActivity(state, patch, now);
+    state.agentActivity = agentActivity;
+    state.updatedAt = now;
+    if (patch.workSessionId) {
+        state.serverSessionId = patch.workSessionId;
+    }
+    if (patch.changeRequestId) {
+        state.changeRequestId = patch.changeRequestId;
+    }
+    if (patch.intent?.trim()) {
+        state.intent = patch.intent.trim();
+    }
+    const mergedClaimed = effectiveClaimedPaths(state, patch);
+    if (mergedClaimed.length > 0) {
+        state.claimedPaths = mergedClaimed;
+    }
+    if (patch.laneDomain !== undefined) {
+        state.laneDomain = patch.laneDomain;
+    }
+    if (patch.closeSession) {
+        state.status = "closed";
+        state.closedAt = now;
+    }
+    else if (state.status === "closed" && patch.event === "start_work_session") {
+        state.status = "active";
+        state.closedAt = undefined;
+    }
+    return state;
+}
+/** Mirror MCP lifecycle success into `.agentbridge/session.json`. Never throws. */
+function mirrorMcpLifecycleEvent(patch) {
+    try {
+        const existing = (0, session_state_1.readSessionState)();
+        const now = new Date().toISOString();
+        const next = applyAgentActivityMerge(existing, patch, now);
+        (0, session_state_1.writeSessionState)(next);
+    }
+    catch {
+        // Swallow — MCP tools must not fail on mirror errors.
+    }
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function laneDomainFromArgs(args) {
+    const type = typeof args.type === "string" ? args.type : undefined;
+    const value = typeof args.value === "string" ? args.value : undefined;
+    if (type === "product_area" && value)
+        return value;
+    return null;
+}
+function buildMirrorPatchFromMcp(toolName, args, json) {
+    switch (toolName) {
+        case "start_work_session": {
+            const status = typeof json.status === "string" ? json.status : "";
+            if (status === "pending_boundary_approval" || status === "blocked")
+                return null;
+            const workSessionId = typeof json.id === "string" ? json.id : undefined;
+            const intent = typeof args.intent === "string" ? args.intent : undefined;
+            const changeRequestId = typeof args.change_request_id === "string" ? args.change_request_id : undefined;
+            const claimedPaths = asStringArray(args.claimed_paths);
+            return {
+                event: "start_work_session",
+                workSessionId,
+                changeRequestId,
+                intent,
+                claimedPaths,
+                summary: intent,
+            };
+        }
+        case "start_recovery_bootstrap_session": {
+            const workSessionId = typeof json.work_session_id === "string"
+                ? json.work_session_id
+                : typeof json.id === "string"
+                    ? json.id
+                    : undefined;
+            const intent = typeof args.intent === "string" ? args.intent : "recovery bootstrap";
+            const claimedPaths = asStringArray(args.claimed_paths);
+            return {
+                event: "start_work_session",
+                workSessionId,
+                intent,
+                claimedPaths,
+                summary: intent,
+            };
+        }
+        case "claim_lane": {
+            const workSessionId = typeof args.work_session_id === "string"
+                ? args.work_session_id
+                : typeof json.work_session_id === "string"
+                    ? json.work_session_id
+                    : undefined;
+            const changedFiles = asStringArray(args.changed_files);
+            const type = typeof args.type === "string" ? args.type : undefined;
+            const value = typeof args.value === "string" ? args.value : undefined;
+            const laneId = typeof json.id === "string" ? json.id : undefined;
+            return {
+                event: "claim_lane",
+                workSessionId,
+                claimedPaths: changedFiles,
+                laneDomain: laneDomainFromArgs(args),
+                laneId,
+                laneType: type,
+                laneValue: value,
+                summary: value ? `claimed ${type ?? "lane"}: ${value}` : "claimed lane",
+            };
+        }
+        case "release_lane":
+            return {
+                event: "release_lane",
+                workSessionId: typeof args.work_session_id === "string" ? args.work_session_id : undefined,
+                laneId: typeof args.lane_id === "string" ? args.lane_id : undefined,
+                summary: "released lane",
+            };
+        case "update_work_session_scope": {
+            const additional = asStringArray(args.additional_paths);
+            return {
+                event: "update_work_session_scope",
+                workSessionId: typeof args.work_session_id === "string" ? args.work_session_id : undefined,
+                claimedPaths: additional,
+                summary: additional.length > 0 ? `scope +${additional.length} path(s)` : "updated scope",
+            };
+        }
+        case "post_handoff": {
+            const handoffId = typeof json.id === "string" ? json.id : undefined;
+            const summary = typeof args.completed === "string"
+                ? args.completed
+                : typeof args.summary === "string"
+                    ? args.summary
+                    : typeof args.handoff_summary === "string"
+                        ? args.handoff_summary
+                        : "handoff posted";
+            return {
+                event: "post_handoff",
+                workSessionId: typeof args.work_session_id === "string" ? args.work_session_id : undefined,
+                handoffId,
+                summary,
+            };
+        }
+        case "close_work_session":
+            return {
+                event: "close_work_session",
+                workSessionId: typeof args.work_session_id === "string" ? args.work_session_id : undefined,
+                summary: typeof args.note === "string"
+                    ? args.note
+                    : typeof args.summary === "string"
+                        ? args.summary
+                        : "session closed",
+                closeSession: true,
+            };
+        default:
+            return null;
+    }
+}
+function mirrorMcpToolSuccess(toolName, args, json) {
+    const patch = buildMirrorPatchFromMcp(toolName, args, json);
+    if (!patch)
+        return;
+    mirrorMcpLifecycleEvent(patch);
+}

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");
+    }
+}