@agentbridge1/cli 0.0.1

package/dist/commands/status.js

@@ -0,0 +1,486 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repairMissingBlockingFiles = repairMissingBlockingFiles;
+exports.renderStatus = renderStatus;
+exports.runStatus = runStatus;
+const config_1 = require("../config");
+const session_state_1 = require("../session-state");
+const node_fs_1 = require("node:fs");
+const work_context_resolver_1 = require("../work-context-resolver");
+const operator_snapshot_1 = require("../operator-snapshot");
+const health_1 = require("./health");
+const server_sync_1 = require("../server-sync");
+const canonical_state_1 = require("../canonical-state");
+const acceptance_preflight_1 = require("../acceptance-preflight");
+function repairMissingBlockingFiles() {
+    const state = (0, session_state_1.readSessionState)();
+    if (!state || state.id === "none" || state.status === "closed") {
+        return 0;
+    }
+    let repaired = 0;
+    for (const crossing of state.crossings) {
+        if (crossing.status === "unresolved" &&
+            (crossing.tier === "tier_a" || crossing.tier === "tier_b") &&
+            !(0, node_fs_1.existsSync)(crossing.file)) {
+            crossing.status = "denied";
+            repaired += 1;
+        }
+    }
+    if (repaired > 0) {
+        const unresolvedProtected = state.crossings.some((crossing) => crossing.status === "unresolved" &&
+            (crossing.tier === "tier_a" || crossing.tier === "tier_b"));
+        if (!unresolvedProtected) {
+            state.blockedAt = undefined;
+            state.status = "active";
+        }
+        (0, session_state_1.writeSessionState)(state);
+    }
+    return repaired;
+}
+function renderStatus() {
+    const cfg = (0, config_1.readConfig)();
+    const state = (0, session_state_1.readSessionState)();
+    if (!cfg.projectId && !cfg.activeAgentId) {
+        return "No local AgentBridge config found.\nNext: run `agentbridge init`.";
+    }
+    const lines = [];
+    lines.push(`Project: ${cfg.projectId ?? "not set"}`);
+    lines.push(`Active agent: ${cfg.activeAgentId ?? "not set"}`);
+    const protectedDomains = (cfg.domains ?? [])
+        .filter((domain) => domain.tier === "tier_a" || domain.tier === "tier_b")
+        .map((domain) => domain.domain);
+    lines.push(`Protected domains: ${protectedDomains.length > 0 ? protectedDomains.join(", ") : "none"}`);
+    const recentHandoff = (0, session_state_1.readRecentHandoffs)(1)[0];
+    if (recentHandoff) {
+        lines.push(`Recent handoff: ${recentHandoff.agentId} -> ${recentHandoff.pendingHandoffToAgent ?? "unknown"} (${recentHandoff.pendingHandoffDomain ?? "unclassified"})`);
+    }
+    if (!state || state.id === "none" || state.status === "closed") {
+        lines.push("Session: no active session");
+        if (cfg.lastAcceptedSessionId) {
+            lines.push(`Last accepted session: ${cfg.lastAcceptedSessionId}`);
+        }
+        lines.push("Next: agentbridge watch");
+        return lines.join("\n");
+    }
+    lines.push(`Lane: ${state.laneDomain ?? "unclassified"}`);
+    lines.push(`Session: ${state.status}`);
+    lines.push(`Blocked: ${state.blockedAt ? "yes" : "no"}`);
+    lines.push(`Changed files: ${state.changedFiles.length}`);
+    const unresolvedProtected = state.crossings.filter((c) => c.status === "unresolved" && (c.tier === "tier_a" || c.tier === "tier_b"));
+    const unresolvedInformational = state.crossings.filter((c) => c.status === "unresolved" && c.tier !== "tier_a" && c.tier !== "tier_b");
+    const handoffRequired = state.crossings.some((c) => c.status === "handoff");
+    const approvals = state.approvals.length;
+    lines.push(`Unresolved crossings: ${unresolvedProtected.length}`);
+    if (unresolvedInformational.length > 0) {
+        lines.push(`Informational crossings: ${unresolvedInformational.length}`);
+    }
+    lines.push(`Scoped approvals: ${approvals}`);
+    const acceptanceSummary = unresolvedProtected.length > 0 ? "failed" : "needs_proof";
+    lines.push(`Acceptance: ${acceptanceSummary} (run agentbridge check)`);
+    if (unresolvedProtected.length > 0) {
+        const first = unresolvedProtected[0];
+        lines.push(`Blocking file: ${first.file} (${first.domain ?? "unclassified"} · ${first.tier.toUpperCase()})`);
+        if (!(0, node_fs_1.existsSync)(first.file)) {
+            lines.push("Blocking file no longer exists; run agentbridge status --repair");
+        }
+        lines.push("Allowed actions: approve / deny / limit / handoff / abandon");
+    }
+    else if (handoffRequired) {
+        lines.push("Close state: handoff required");
+        lines.push("Next action: post handoff details (handoff command will be available in Phase 2)");
+    }
+    else if (unresolvedInformational.length > 0) {
+        const firstInfo = unresolvedInformational[0];
+        lines.push(`Informational file: ${firstInfo.file} (${firstInfo.domain ?? "unclassified"} · ${firstInfo.tier.toUpperCase()})`);
+        lines.push("Non-blocking: informational crossing recorded");
+        lines.push("Next action: continue in lane or close session");
+    }
+    else {
+        lines.push("Next action: continue in lane or close session");
+    }
+    return lines.join("\n");
+}
+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)
+        return null;
+    return { projectId, apiKey, apiBaseUrl };
+}
+function hasHandoffRequiredAction(actions) {
+    return actions.some((action) => action.toLowerCase().includes("handoff"));
+}
+function renderAcceptanceBlock(input) {
+    return [
+        "Acceptance:",
+        `- decision: ${input.decision}`,
+        `- changed files: ${input.changedFiles}`,
+        `- missing proof: ${input.missingProof}`,
+        "- next: run agentbridge check",
+    ].join("\n");
+}
+function renderWorkContextTruthBlock(input) {
+    const lines = [];
+    lines.push("WORK CONTEXT");
+    lines.push("Current work context:");
+    lines.push(`- current CR: ${input.currentCr ?? "none"}`);
+    lines.push(`- current session: ${input.currentSessionId ?? "none"}`);
+    lines.push(`- source: ${input.source}`);
+    lines.push("");
+    lines.push("Other active server sessions:");
+    if (input.otherActiveSessions.length === 0) {
+        lines.push("- none");
+    }
+    else {
+        for (const session of input.otherActiveSessions) {
+            lines.push(`- ${session.id} / ${session.change_request_id ?? "no CR"} / ${session.status}`);
+        }
+    }
+    lines.push("");
+    lines.push("Last accepted:");
+    lines.push(`- ${input.lastAcceptedSessionId ?? "none"}`);
+    return lines;
+}
+function firstTopMemoryItem(candidate) {
+    return (candidate.invariants[0] ??
+        candidate.known_traps[0] ??
+        candidate.future_proof_requirements[0] ??
+        candidate.accepted_lessons[0] ??
+        null);
+}
+function renderMemoryCandidatesBlock(input) {
+    if (!input.candidate) {
+        return [
+            "Memory candidates:",
+            "- status: unavailable",
+            `- why: ${input.unavailableReason ?? "No candidate context available."}`,
+            "- next: agentbridge memory suggest --compact",
+        ];
+    }
+    const topItem = firstTopMemoryItem(input.candidate);
+    const lines = ["Memory candidates:", "- status: available", `- decision: ${input.candidate.decision}`];
+    if (topItem) {
+        lines.push(`- top item: ${topItem}`);
+    }
+    lines.push("- next: agentbridge memory suggest --compact");
+    return lines;
+}
+function deriveProofState(snapshot) {
+    if (snapshot.completion_state === "failed")
+        return "failed";
+    if (snapshot.evidence_missing_count > 0 || snapshot.completion_state === "needs_proof") {
+        return "needs_proof";
+    }
+    if (snapshot.completion_state === "needs_review")
+        return "needs_review";
+    return snapshot.completion_state;
+}
+function deriveHandoffState(snapshot) {
+    if (snapshot.completion_state === "ready_for_handoff")
+        return "ready_for_handoff";
+    if (snapshot.completion_state === "ready_to_accept")
+        return "ready_to_accept";
+    if (snapshot.completion_state === "accepted")
+        return "accepted";
+    if (snapshot.completion_state === "no_current_session")
+        return "no_current_session";
+    return "needs_review";
+}
+function buildTrustedTruthLines(input) {
+    const lines = [];
+    lines.push("TRUSTED TRUTH SCREEN");
+    lines.push(`- work context: ${input.snapshot.work_context_state} (source: ${input.workContextSource})`);
+    lines.push(`- current CR/session: ${input.snapshot.current_change_request_id ?? "none"} / ${input.snapshot.current_work_session_id ?? "none"}`);
+    lines.push(`- completion state: ${input.snapshot.completion_state}`);
+    lines.push(`- proof state: ${deriveProofState(input.snapshot)} (missing=${input.snapshot.evidence_missing_count})`);
+    lines.push(`- handoff state: ${deriveHandoffState(input.snapshot)}`);
+    lines.push(`- memory candidate state: ${input.memoryCandidate ? `available (${input.memoryCandidate.decision})` : "unavailable"}`);
+    if (!input.memoryCandidate && input.memoryUnavailableReason) {
+        lines.push(`- memory reason: ${input.memoryUnavailableReason}`);
+    }
+    lines.push(`- other active sessions: ${input.otherActiveSessions.length}`);
+    lines.push(`- last accepted session: ${input.lastAcceptedSessionId ?? "none"}`);
+    lines.push(`- next action: ${input.snapshot.next_action}`);
+    lines.push(`- next reason: ${input.snapshot.next_reason}`);
+    return lines;
+}
+function buildLocalOnlySnapshot(state) {
+    const hasLocalSession = !!state && state.id !== "none" && state.status !== "closed";
+    if (!hasLocalSession) {
+        return {
+            completion_state: "no_current_session",
+            completion_state_label: "No current session",
+            decision: "none",
+            next_action: "agentbridge watch",
+            next_reason: "No local active session and no network context available.",
+            work_context_state: "no_current_session",
+            work_context_source: "none",
+            has_current_session: false,
+            current_change_request_id: null,
+            current_work_session_id: null,
+            other_active_sessions_count: 0,
+            changed_files_count: 0,
+            evidence_missing_count: 0,
+            risks_remaining_count: 0,
+            protocol_warnings_count: 0,
+        };
+    }
+    const unresolvedProtected = state.crossings.filter((crossing) => crossing.status === "unresolved" && (crossing.tier === "tier_a" || crossing.tier === "tier_b"));
+    const localFailed = unresolvedProtected.length > 0;
+    return {
+        completion_state: localFailed ? "failed" : "needs_proof",
+        completion_state_label: localFailed ? "Failed" : "Needs proof",
+        decision: localFailed ? "failed" : "needs_proof",
+        next_action: localFailed ? "agentbridge check" : "agentbridge check",
+        next_reason: localFailed
+            ? "Local protected crossings remain unresolved."
+            : "Local session has pending changes; confirm acceptance when API context is available.",
+        work_context_state: "no_current_session",
+        work_context_source: "local session",
+        has_current_session: true,
+        current_change_request_id: null,
+        current_work_session_id: state.serverSessionId ?? null,
+        other_active_sessions_count: 0,
+        changed_files_count: state.changedFiles.length,
+        evidence_missing_count: state.changedFiles.length > 0 ? 1 : 0,
+        risks_remaining_count: 0,
+        protocol_warnings_count: 0,
+    };
+}
+async function runStatus(options) {
+    const cfg = (0, config_1.readConfig)();
+    if (options?.repair) {
+        const repaired = repairMissingBlockingFiles();
+        process.stdout.write(`Repaired ${repaired} missing blocking crossing(s).\n`);
+    }
+    const state = (0, session_state_1.readSessionState)();
+    const hasLocalSession = !!state && state.id !== "none" && state.status !== "closed";
+    const base = renderStatus();
+    const output = [base];
+    let ctx = null;
+    try {
+        ctx = resolveNetworkContext();
+    }
+    catch {
+        ctx = null;
+    }
+    if (ctx) {
+        const { resolution } = await (0, acceptance_preflight_1.resolveAcceptanceWorkContext)(ctx, {
+            includeOtherActiveSessions: true,
+            useConfigActiveChangeRequestId: false,
+        });
+        const snapshot = (0, operator_snapshot_1.buildOperatorSnapshot)(resolution);
+        const healthChecks = (0, health_1.buildHealthChecks)({
+            configProjectId: !!cfg.projectId,
+            configApiKey: !!cfg.apiKey,
+            workContextResolved: resolution.state === "current_session_resolved",
+            protocolWarnings: snapshot.protocol_warnings_count,
+            evidenceMissing: snapshot.evidence_missing_count,
+        });
+        const healthRollup = (0, health_1.deriveHealthRollup)({ snapshot, checks: healthChecks });
+        let memoryCandidate = null;
+        let memoryUnavailableReason;
+        if (resolution.state === "current_session_resolved" && snapshot.current_work_session_id) {
+            try {
+                memoryCandidate = await (0, server_sync_1.fetchMemorySuggestion)(ctx, {
+                    workSessionId: snapshot.current_work_session_id,
+                    changeRequestId: snapshot.current_change_request_id ?? undefined,
+                });
+            }
+            catch {
+                memoryUnavailableReason = "Memory suggestion is currently unavailable.";
+            }
+        }
+        else {
+            memoryUnavailableReason = "No current resolved server session for memory suggestions.";
+        }
+        const trustedTruth = buildTrustedTruthLines({
+            snapshot,
+            workContextSource: resolution.contextSource,
+            otherActiveSessions: resolution.otherActiveSessions,
+            memoryCandidate,
+            memoryUnavailableReason,
+            lastAcceptedSessionId: cfg.lastAcceptedSessionId ?? null,
+        });
+        if (options?.json) {
+            process.stdout.write(`${JSON.stringify({
+                snapshot,
+                health: {
+                    checks: healthChecks,
+                    rollup: healthRollup,
+                },
+                memory_candidate: memoryCandidate,
+                truth_screen: {
+                    work_context: {
+                        state: snapshot.work_context_state,
+                        source: resolution.contextSource,
+                    },
+                    current_cr_session: {
+                        change_request_id: snapshot.current_change_request_id,
+                        work_session_id: snapshot.current_work_session_id,
+                    },
+                    completion_state: snapshot.completion_state,
+                    proof_state: deriveProofState(snapshot),
+                    handoff_state: deriveHandoffState(snapshot),
+                    memory_candidate_state: memoryCandidate ? "available" : "unavailable",
+                    other_active_sessions: resolution.otherActiveSessions,
+                    last_accepted_session_id: cfg.lastAcceptedSessionId ?? null,
+                    next_action: snapshot.next_action,
+                    next_reason: snapshot.next_reason,
+                },
+            }, null, 2)}\n`);
+            return;
+        }
+        const currentCr = resolution.binding?.changeRequestId ?? resolution.requestedChangeRequestId ?? null;
+        const currentSessionId = resolution.binding?.workSessionId ?? null;
+        output.push(...trustedTruth);
+        output.push("");
+        output.push("");
+        output.push(...renderWorkContextTruthBlock({
+            currentCr,
+            currentSessionId,
+            source: resolution.contextSource,
+            otherActiveSessions: resolution.otherActiveSessions,
+            lastAcceptedSessionId: cfg.lastAcceptedSessionId ?? null,
+        }));
+        if (resolution.state === "current_session_resolved" && resolution.binding) {
+            const report = resolution.binding.report;
+            if (report) {
+                output.push("");
+                output.push(renderAcceptanceBlock({
+                    decision: report.decision,
+                    changedFiles: report.changed_files.length,
+                    missingProof: report.evidence_missing.length,
+                }));
+                if (hasHandoffRequiredAction(report.next_required_action)) {
+                    output.push("Close state: handoff required");
+                    output.push("Next action: agentbridge handoff --summary \"<what changed>\"");
+                }
+            }
+            output.push("");
+            output.push(...renderMemoryCandidatesBlock({ candidate: memoryCandidate, unavailableReason: memoryUnavailableReason }));
+            output.push("");
+            output.push("Health rollup:");
+            output.push(`- overall: ${healthRollup.overall_status}`);
+            output.push(`- checks pass/warn: ${healthRollup.pass_count}/${healthRollup.warn_count}`);
+            output.push(`- missing proof: ${healthRollup.has_missing_proof ? "yes" : "no"}`);
+            output.push(`- protocol warnings: ${healthRollup.has_protocol_warnings ? "yes" : "no"}`);
+            output.push("");
+            output.push(...(0, operator_snapshot_1.renderOperatorNextStepBlock)(snapshot));
+            process.stdout.write(`${output.join("\n")}\n`);
+            return;
+        }
+        output.push("");
+        output.push(...(0, work_context_resolver_1.renderWorkContextLines)(resolution));
+        if (hasLocalSession) {
+            const fallbackDecision = state.crossings.some((crossing) => crossing.status === "unresolved" &&
+                (crossing.tier === "tier_a" || crossing.tier === "tier_b"))
+                ? "failed"
+                : "needs_proof";
+            output.push(renderAcceptanceBlock({
+                decision: fallbackDecision,
+                changedFiles: state.changedFiles.length,
+                missingProof: state.changedFiles.length > 0 ? 1 : 0,
+            }));
+        }
+        output.push("");
+        output.push(...renderMemoryCandidatesBlock({ candidate: memoryCandidate, unavailableReason: memoryUnavailableReason }));
+        output.push("");
+        output.push("Health rollup:");
+        output.push(`- overall: ${healthRollup.overall_status}`);
+        output.push(`- checks pass/warn: ${healthRollup.pass_count}/${healthRollup.warn_count}`);
+        output.push(`- missing proof: ${healthRollup.has_missing_proof ? "yes" : "no"}`);
+        output.push(`- protocol warnings: ${healthRollup.has_protocol_warnings ? "yes" : "no"}`);
+        output.push("");
+        output.push(...(0, operator_snapshot_1.renderOperatorNextStepBlock)(snapshot));
+        process.stdout.write(`${output.join("\n")}\n`);
+        return;
+    }
+    const localSnapshot = buildLocalOnlySnapshot(state);
+    const localHealthChecks = (0, health_1.buildHealthChecks)({
+        configProjectId: !!cfg.projectId,
+        configApiKey: !!cfg.apiKey,
+        workContextResolved: false,
+        protocolWarnings: localSnapshot.protocol_warnings_count,
+        evidenceMissing: localSnapshot.evidence_missing_count,
+    });
+    localHealthChecks[2] = {
+        id: "network-context",
+        status: "warn",
+        detail: "no active API context",
+    };
+    const localHealthRollup = (0, health_1.deriveHealthRollup)({
+        snapshot: localSnapshot,
+        checks: localHealthChecks,
+    });
+    const localResolutionState = hasLocalSession ? "current_session_resolved" : "no_current_session";
+    const localTrustedTruth = buildTrustedTruthLines({
+        snapshot: {
+            ...localSnapshot,
+            work_context_state: (0, canonical_state_1.toCanonicalWorkContextState)(localResolutionState),
+        },
+        workContextSource: hasLocalSession ? "local session" : "none",
+        otherActiveSessions: [],
+        memoryCandidate: null,
+        memoryUnavailableReason: "No network context available.",
+        lastAcceptedSessionId: cfg.lastAcceptedSessionId ?? null,
+    });
+    if (options?.json) {
+        process.stdout.write(`${JSON.stringify({
+            snapshot: localSnapshot,
+            health: {
+                checks: localHealthChecks,
+                rollup: localHealthRollup,
+            },
+            memory_candidate: null,
+            truth_screen: {
+                work_context: {
+                    state: localSnapshot.work_context_state,
+                    source: hasLocalSession ? "local session" : "none",
+                },
+                current_cr_session: {
+                    change_request_id: localSnapshot.current_change_request_id,
+                    work_session_id: localSnapshot.current_work_session_id,
+                },
+                completion_state: localSnapshot.completion_state,
+                proof_state: deriveProofState(localSnapshot),
+                handoff_state: deriveHandoffState(localSnapshot),
+                memory_candidate_state: "unavailable",
+                other_active_sessions: [],
+                last_accepted_session_id: cfg.lastAcceptedSessionId ?? null,
+                next_action: localSnapshot.next_action,
+                next_reason: localSnapshot.next_reason,
+            },
+        }, null, 2)}\n`);
+        return;
+    }
+    output.push(...localTrustedTruth);
+    output.push("");
+    if (hasLocalSession) {
+        const fallbackDecision = state.crossings.some((crossing) => crossing.status === "unresolved" &&
+            (crossing.tier === "tier_a" || crossing.tier === "tier_b"))
+            ? "failed"
+            : "needs_proof";
+        output.push(renderAcceptanceBlock({
+            decision: fallbackDecision,
+            changedFiles: state.changedFiles.length,
+            missingProof: state.changedFiles.length > 0 ? 1 : 0,
+        }));
+    }
+    output.push("");
+    output.push("Work context source:");
+    output.push("- local-only (network/API context unavailable)");
+    output.push("");
+    output.push(...renderMemoryCandidatesBlock({ candidate: null, unavailableReason: "No network context available." }));
+    output.push("");
+    output.push("Health rollup:");
+    output.push(`- overall: ${localHealthRollup.overall_status}`);
+    output.push(`- checks pass/warn: ${localHealthRollup.pass_count}/${localHealthRollup.warn_count}`);
+    output.push(`- missing proof: ${localHealthRollup.has_missing_proof ? "yes" : "no"}`);
+    output.push(`- protocol warnings: ${localHealthRollup.has_protocol_warnings ? "yes" : "no"}`);
+    output.push("");
+    output.push(...(0, operator_snapshot_1.renderOperatorNextStepBlock)(localSnapshot));
+    process.stdout.write(`${output.join("\n")}\n`);
+}

package/dist/commands/use.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUse = runUse;
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+function runUse(agentId) {
+    const trimmed = agentId.trim();
+    if (!trimmed) {
+        throw new errors_1.SafeCliError("Usage: agentbridge use <agent-id>");
+    }
+    (0, config_1.updateConfig)({ activeAgentId: trimmed });
+    process.stdout.write(`Active agent set to ${trimmed}\n`);
+}