@agentbridge1/cli 0.0.1

package/dist/commands/memory.js

@@ -0,0 +1,400 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMemorySuggest = runMemorySuggest;
+exports.runMemoryApply = runMemoryApply;
+exports.runMemoryReject = runMemoryReject;
+exports.runMemoryDefer = runMemoryDefer;
+exports.runMemoryIntakeEscapedBug = runMemoryIntakeEscapedBug;
+exports.runMemoryRevert = runMemoryRevert;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("../config");
+const server_sync_1 = require("../server-sync");
+const http_1 = require("../http");
+const errors_1 = require("../errors");
+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({
+            code: "CONFIG_INCOMPLETE",
+            category: "CONFIG_ERROR",
+            what: "Missing AGENTBRIDGE_PROJECT_ID.",
+            why: "Memory commands cannot reach the server without a project ID.",
+            next: "Set AGENTBRIDGE_PROJECT_ID or run `agentbridge init --project <id>`.",
+        });
+    }
+    if (!apiKey) {
+        throw new errors_1.SafeCliError({
+            code: "CONFIG_INCOMPLETE",
+            category: "CONFIG_ERROR",
+            what: "Missing AGENTBRIDGE_API_KEY.",
+            why: "Memory commands cannot authenticate without an API key.",
+            next: "Provide --api-key, set AGENTBRIDGE_API_KEY, or save apiKey in .agentbridge/config.json.",
+        });
+    }
+    return { projectId, apiKey, apiBaseUrl };
+}
+function isSecretLike(text) {
+    return /(api[_-]?key|bearer\s|sk-[a-z0-9]{10,}|password\s*[:=])/i.test(text);
+}
+function formatList(title, items) {
+    if (items.length === 0)
+        return [];
+    return [title, ...items.map((item) => `  - ${item}`)];
+}
+function firstTopItem(candidate) {
+    return (candidate.invariants[0] ??
+        candidate.known_traps[0] ??
+        candidate.future_proof_requirements[0] ??
+        candidate.accepted_lessons[0] ??
+        null);
+}
+function renderSuggestion(candidate, compact) {
+    const lines = [];
+    const rationale = candidate.reason ?? candidate.signal.reason;
+    lines.push(`Memory suggest: ${candidate.decision}`);
+    lines.push(`Rationale: ${rationale}`);
+    lines.push(`Signal durability: ${candidate.signal.durability} (${candidate.signal.reason})`);
+    lines.push(candidate.accepted_summary);
+    if (candidate.work_session_id) {
+        lines.push(`Work session: ${candidate.work_session_id}`);
+    }
+    if (candidate.change_request_id) {
+        lines.push(`Change request: ${candidate.change_request_id}`);
+    }
+    if (compact) {
+        const topItem = firstTopItem(candidate);
+        if (topItem)
+            lines.push(`Top item: ${topItem}`);
+        lines.push(`Evidence refs: ${candidate.evidence_refs.length}`);
+        if (candidate.omitted_low_signal_items?.length) {
+            lines.push(`Filtered items: ${candidate.omitted_low_signal_items.length}`);
+        }
+        if (candidate.excluded_audit_facts.length > 0) {
+            lines.push(`Excluded noise: ${candidate.excluded_audit_facts.length}`);
+        }
+    }
+    else {
+        lines.push(`Suggested scope: ${candidate.suggested_scope}`);
+        if (candidate.domain)
+            lines.push(`Domain: ${candidate.domain}`);
+        if (candidate.signal.detectors_triggered.length > 0) {
+            lines.push(`Detectors: ${candidate.signal.detectors_triggered.join(", ")}`);
+        }
+        lines.push(...formatList("Invariants:", candidate.invariants));
+        lines.push(...formatList("Known traps:", candidate.known_traps));
+        lines.push(...formatList("Future proof requirements:", candidate.future_proof_requirements));
+        lines.push(...formatList("Accepted lessons:", candidate.accepted_lessons));
+        if (candidate.evidence_refs.length > 0) {
+            lines.push("Evidence refs:");
+            for (const ref of candidate.evidence_refs) {
+                const note = ref.note ? ` (${ref.note})` : "";
+                lines.push(`  - ${ref.type}:${ref.id}${note}`);
+            }
+        }
+        if (candidate.excluded_audit_facts.length > 0) {
+            lines.push(...formatList("Excluded noise:", candidate.excluded_audit_facts));
+        }
+        if (candidate.omitted_low_signal_items?.length) {
+            lines.push(...formatList("Omitted low signal items:", candidate.omitted_low_signal_items));
+        }
+        if (candidate.duplicate_or_related_memory?.length) {
+            lines.push("Related memory:");
+            for (const dup of candidate.duplicate_or_related_memory) {
+                const domain = dup.domain ? ` domain=${dup.domain}` : "";
+                lines.push(`  - [${dup.scope}${domain}] ${dup.reason} (${dup.matched_fields.join(", ")})`);
+            }
+        }
+    }
+    const output = lines.join("\n");
+    if (isSecretLike(output)) {
+        throw new Error("Refusing to print memory suggestion output that may contain secrets.");
+    }
+    process.stdout.write(`${output}\n`);
+}
+async function runMemorySuggest(options) {
+    const ctx = resolveNetworkContext();
+    try {
+        const candidate = await (0, server_sync_1.fetchMemorySuggestion)(ctx, {
+            workSessionId: options.workSessionId,
+            changeRequestId: options.changeRequestId,
+            domain: options.domain,
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ suggestion: candidate }, null, 2)}\n`);
+            return;
+        }
+        renderSuggestion(candidate, options.compact === true);
+    }
+    catch (error) {
+        const status = error instanceof http_1.CliHttpError
+            ? error.status
+            : typeof error === "object" &&
+                error !== null &&
+                "status" in error &&
+                typeof error.status === "number"
+                ? error.status
+                : null;
+        if (status !== null) {
+            const detail = status === 404
+                ? "No matching or accepted work session found. Try --work-session <id> or accept a session first."
+                : status === 400 || status === 422
+                    ? "Invalid memory suggest request. Check --work-session/--change-request values."
+                    : "Memory suggest failed. Run `agentbridge doctor` and retry.";
+            const why = status === 404
+                ? "Memory suggestions require a resolvable accepted or active work session context."
+                : status === 400 || status === 422
+                    ? "The request payload did not satisfy server validation."
+                    : "The server could not process this request.";
+            process.stderr.write([
+                `What happened: Memory suggest failed. ${detail}`,
+                `Why it matters: ${why}`,
+                "Next action: Run `agentbridge status` to confirm current context, then retry.",
+            ].join("\n") + "\n");
+            return;
+        }
+        throw error;
+    }
+}
+// ── Phase 6B: apply / reject / defer / revert ────────────────────────────────
+function parseItemsFlag(value) {
+    if (!value || value.trim().length === 0)
+        return undefined;
+    // Expected format: --items invariants,known_traps  (apply all from those buckets)
+    const buckets = value
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    if (buckets.length === 0)
+        return undefined;
+    const out = {};
+    for (const bucket of buckets) {
+        if (bucket === "invariants" ||
+            bucket === "known_traps" ||
+            bucket === "future_proof_requirements" ||
+            bucket === "accepted_lessons") {
+            out[bucket] = null; // placeholder; resolved at apply time using candidate
+        }
+        else {
+            throw new Error(`Unknown items bucket: ${bucket}. Allowed: invariants, known_traps, future_proof_requirements, accepted_lessons`);
+        }
+    }
+    return out;
+}
+function fetchAndValidateCandidate(ctx, options) {
+    return (0, server_sync_1.fetchMemorySuggestion)(ctx, options);
+}
+function ensureSuggestable(candidate) {
+    if (candidate.decision === "skip") {
+        throw new Error(`Candidate decision is "skip": ${candidate.signal.reason}. Nothing to apply.`);
+    }
+}
+function resolveAppliedItems(candidate, itemsFlag) {
+    if (!itemsFlag)
+        return undefined;
+    const out = {};
+    if (Object.prototype.hasOwnProperty.call(itemsFlag, "invariants")) {
+        out.invariants = candidate.invariants;
+    }
+    if (Object.prototype.hasOwnProperty.call(itemsFlag, "known_traps")) {
+        out.known_traps = candidate.known_traps;
+    }
+    if (Object.prototype.hasOwnProperty.call(itemsFlag, "future_proof_requirements")) {
+        out.future_proof_requirements = candidate.future_proof_requirements;
+    }
+    if (Object.prototype.hasOwnProperty.call(itemsFlag, "accepted_lessons")) {
+        out.accepted_lessons = candidate.accepted_lessons;
+    }
+    return out;
+}
+function handleApplyError(error, action) {
+    const view = (0, errors_1.formatCliError)(error);
+    const what = `Memory ${action} failed. ${view.what}`.trim();
+    process.stderr.write([
+        `What happened: ${what}`,
+        `Why it matters: ${view.why}`,
+        `Next action: ${view.next}`,
+    ].join("\n") + "\n");
+}
+async function runMemoryApply(options) {
+    const ctx = resolveNetworkContext();
+    try {
+        const candidate = await fetchAndValidateCandidate(ctx, {
+            workSessionId: options.workSessionId,
+            changeRequestId: options.changeRequestId,
+            domain: options.domain,
+        });
+        ensureSuggestable(candidate);
+        const scope = options.scope ?? candidate.suggested_scope;
+        const domain = options.domain ?? candidate.domain;
+        const itemsFlag = parseItemsFlag(options.items);
+        const resolvedItems = resolveAppliedItems(candidate, itemsFlag);
+        const result = await (0, server_sync_1.applyMemoryCandidateRequest)(ctx, {
+            scope,
+            domain,
+            items: resolvedItems,
+            reviewerNote: options.reviewerNote,
+            candidate,
+        });
+        const lines = [
+            `Memory applied: scope=${result.scope}${result.domain ? ` domain=${result.domain}` : ""}`,
+            `Approval audit_id: ${result.audit_id}`,
+        ];
+        if (result.pcs_id)
+            lines.push(`ProjectCurrentState id: ${result.pcs_id}`);
+        if (result.dm_id)
+            lines.push(`DomainMemory id: ${result.dm_id}`);
+        if (result.warnings.length > 0) {
+            lines.push(...formatList("Warnings:", result.warnings));
+        }
+        lines.push(`Revert with: agentbridge memory revert --approval-audit ${result.audit_id}`);
+        process.stdout.write(`${lines.join("\n")}\n`);
+    }
+    catch (error) {
+        handleApplyError(error, "apply");
+    }
+}
+async function runMemoryReject(options) {
+    const ctx = resolveNetworkContext();
+    try {
+        const candidate = await fetchAndValidateCandidate(ctx, {
+            workSessionId: options.workSessionId,
+            changeRequestId: options.changeRequestId,
+            domain: options.domain,
+        });
+        const result = await (0, server_sync_1.rejectMemoryCandidateRequest)(ctx, {
+            reviewerNote: options.reviewerNote,
+            candidate,
+        });
+        process.stdout.write(`Memory candidate rejected. Audit id: ${result.audit_id}\n`);
+    }
+    catch (error) {
+        handleApplyError(error, "reject");
+    }
+}
+async function runMemoryDefer(options) {
+    const ctx = resolveNetworkContext();
+    try {
+        const candidate = await fetchAndValidateCandidate(ctx, {
+            workSessionId: options.workSessionId,
+            changeRequestId: options.changeRequestId,
+            domain: options.domain,
+        });
+        const result = await (0, server_sync_1.deferMemoryCandidateRequest)(ctx, {
+            reviewerNote: options.reviewerNote,
+            candidate,
+        });
+        process.stdout.write(`Memory candidate deferred. Audit id: ${result.audit_id}\n`);
+    }
+    catch (error) {
+        handleApplyError(error, "defer");
+    }
+}
+// ── Phase 6E: escaped-bug intake ─────────────────────────────────────────────
+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 loadFindingFromFile(path) {
+    const abs = (0, node_path_1.resolve)(process.cwd(), path);
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)(abs, "utf8");
+    }
+    catch (err) {
+        throw new Error(`Failed to read escaped-bug finding file at ${abs}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Invalid JSON in ${abs}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error(`Escaped-bug finding file must be a JSON object: ${abs}`);
+    }
+    return parsed;
+}
+async function runMemoryIntakeEscapedBug(options) {
+    const ctx = resolveNetworkContext();
+    let finding;
+    if (options.fromFile && options.fromFile.trim().length > 0) {
+        finding = loadFindingFromFile(options.fromFile.trim());
+        // Allow flag overrides for convenience.
+        if (options.domain)
+            finding.domain = options.domain;
+        if (options.workSessionId)
+            finding.work_session_id = options.workSessionId;
+        if (options.changeRequestId)
+            finding.change_request_id = options.changeRequestId;
+        if (options.reviewerNote)
+            finding.reviewer_note = options.reviewerNote;
+    }
+    else {
+        if (!options.title || options.title.trim().length === 0) {
+            process.stderr.write("Missing --title \"<text>\" (or --from-file <path>). Escaped-bug findings require a title.\n");
+            return;
+        }
+        if (!options.summary || options.summary.trim().length === 0) {
+            process.stderr.write("Missing --summary \"<text>\" (or --from-file <path>). Escaped-bug findings require a summary.\n");
+            return;
+        }
+        finding = {
+            title: options.title.trim(),
+            summary: options.summary.trim(),
+            domain: options.domain,
+            work_session_id: options.workSessionId,
+            change_request_id: options.changeRequestId,
+            reviewer_note: options.reviewerNote,
+            invariants: splitListFlag(options.invariants),
+            known_traps: splitListFlag(options.knownTraps),
+            future_proof_requirements: splitListFlag(options.futureProofRequirements),
+            accepted_lessons: splitListFlag(options.acceptedLessons),
+        };
+    }
+    try {
+        const { candidate } = await (0, server_sync_1.intakeEscapedBugRequest)(ctx, finding);
+        process.stdout.write("Escaped bug recorded. Generated candidate:\n");
+        renderSuggestion(candidate, options.compact === true);
+        if (candidate.decision !== "skip") {
+            process.stdout.write("Apply with: agentbridge memory apply (after human review, use --work-session/--change-request to re-fetch the same candidate path if relevant)\n");
+        }
+    }
+    catch (error) {
+        handleApplyError(error, "intake-escaped-bug");
+    }
+}
+async function runMemoryRevert(options) {
+    if (!options.approvalAuditId || options.approvalAuditId.trim().length === 0) {
+        process.stderr.write("Missing --approval-audit <id>. Use the audit_id printed by `agentbridge memory apply`.\n");
+        return;
+    }
+    const ctx = resolveNetworkContext();
+    try {
+        const result = await (0, server_sync_1.revertMemoryCandidateRequest)(ctx, {
+            approvalAuditId: options.approvalAuditId,
+            reviewerNote: options.reviewerNote,
+            force: options.force,
+        });
+        const lines = [
+            `Memory reverted: approval=${result.approval_audit_id}`,
+            `Revert audit_id: ${result.revert_audit_id}`,
+        ];
+        if (result.warnings.length > 0) {
+            lines.push(...formatList("Warnings:", result.warnings));
+        }
+        process.stdout.write(`${lines.join("\n")}\n`);
+    }
+    catch (error) {
+        handleApplyError(error, "revert");
+    }
+}

package/dist/commands/next.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNext = runNext;
+const chalk_1 = __importDefault(require("chalk"));
+const operator_snapshot_1 = require("../operator-snapshot");
+const health_1 = require("./health");
+async function runNext(options) {
+    const summary = await (0, health_1.collectHealthSummary)({
+        includeOtherActiveSessions: true,
+    });
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ snapshot: summary.snapshot, rollup: summary.rollup }, null, 2)}\n`);
+        return;
+    }
+    process.stdout.write(`${chalk_1.default.bold("AgentBridge Next")}\n`);
+    process.stdout.write(`${(0, operator_snapshot_1.renderOperatorSnapshotHuman)(summary.snapshot)}\n`);
+    process.stdout.write(`Signals: ${summary.rollup.overall_status} · next=${summary.rollup.next_action}\n`);
+}

package/dist/commands/precommit-check.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrecommitCheckCommand = runPrecommitCheckCommand;
+const precommit_1 = require("../precommit");
+function runPrecommitCheckCommand() {
+    const staged = (0, precommit_1.stagedFilesFromGit)();
+    const result = (0, precommit_1.runPrecommitCheckFromSession)(staged);
+    if (!result.ok) {
+        process.stderr.write("Blocked commit due to unresolved protected boundary crossing(s):\n");
+        for (const file of result.blocked) {
+            process.stderr.write(`- ${file}\n`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write("Pre-commit check passed.\n");
+}

package/dist/commands/recover.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRecover = runRecover;
+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 init_1 = require("../init");
+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 };
+}
+function renderRecoverOutput(packet) {
+    const lines = [];
+    lines.push("Project recovered.");
+    lines.push("");
+    lines.push(`Project: ${packet.project_name ?? packet.project_id}`);
+    if (packet.domains_summary.length > 0) {
+        lines.push("");
+        lines.push("Domains found:");
+        for (const domain of packet.domains_summary) {
+            const pathNote = domain.owned_path_count > 0 ? `${domain.owned_path_count} path(s)` : "paths pending";
+            lines.push(`- ${domain.domain_name} — ${pathNote}`);
+        }
+    }
+    if (packet.charter_summary?.purpose) {
+        lines.push("");
+        lines.push("Known context:");
+        lines.push(`- ${packet.charter_summary.purpose}`);
+    }
+    if (packet.global_rules && packet.global_rules.length > 0) {
+        lines.push("");
+        lines.push("Project rules:");
+        for (const rule of packet.global_rules.slice(0, 3)) {
+            lines.push(`- ${rule}`);
+        }
+    }
+    lines.push("");
+    lines.push("Next:");
+    lines.push("  agentbridge start");
+    lines.push("");
+    return lines.join("\n");
+}
+async function runRecover(options = {}) {
+    process.exitCode = 0;
+    process.stdout.write([
+        "AgentBridge is recovering this project.",
+        "It will identify project context, domains, known traps, and memory for future agent work.",
+        "",
+    ].join("\n"));
+    let ctx;
+    try {
+        ctx = resolveNetworkContext();
+    }
+    catch (err) {
+        if (err instanceof errors_1.SafeCliError) {
+            process.stderr.write(`${(0, errors_1.renderCliError)(err)}\n`);
+        }
+        else {
+            process.stderr.write(`${(0, errors_1.renderCliError)((0, errors_1.catalogCliError)("CONFIG_INCOMPLETE"))}\n`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write("Verifying project access...\n");
+    let packet;
+    try {
+        packet = await (0, server_sync_1.fetchProjectPacket)(ctx);
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        process.stderr.write([
+            "",
+            "Recovery could not complete.",
+            "",
+            "What happened: AgentBridge could not reach the project.",
+            "Why it matters: Project context is required before AI agents can work safely.",
+            `Next action: Run "agentbridge doctor" to diagnose the connection, then retry.`,
+            `Error: ${errMsg}`,
+            "",
+        ].join("\n"));
+        process.exitCode = 1;
+        return;
+    }
+    const alreadyRecovered = (packet.domains_summary?.length ?? 0) > 0 ||
+        (packet.recovery_status !== null &&
+            packet.recovery_status !== undefined &&
+            packet.recovery_status !== "pending");
+    if (!options.force && alreadyRecovered) {
+        const repoRoot = (0, node_process_1.cwd)();
+        (0, gates_1.ensureGitignoreSessionEntry)(repoRoot);
+        (0, gates_1.ensureGatesFile)(repoRoot);
+        process.stdout.write("Project context already exists.\n\n");
+        process.stdout.write(renderRecoverOutput(packet));
+        return;
+    }
+    if (!alreadyRecovered) {
+        process.stdout.write("No baseline found. Building recovery baseline now...\n");
+        await (0, init_1.runBootstrapRecovery)(ctx);
+        packet = await (0, server_sync_1.fetchProjectPacket)(ctx);
+    }
+    // force mode or partial state: show current state
+    const repoRoot = (0, node_process_1.cwd)();
+    (0, gates_1.ensureGitignoreSessionEntry)(repoRoot);
+    (0, gates_1.ensureGatesFile)(repoRoot);
+    process.stdout.write(renderRecoverOutput(packet));
+}