@agentbridge1/cli 0.0.1

package/dist/preflight-changed-files.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repoDirtySnapshot = repoDirtySnapshot;
+exports.preflightSyncChangedFiles = preflightSyncChangedFiles;
+const claimed_paths_1 = require("./claimed-paths");
+const file_fingerprints_1 = require("./file-fingerprints");
+const git_status_1 = require("./git-status");
+const session_state_1 = require("./session-state");
+const server_sync_1 = require("./server-sync");
+function normalizeChangedFiles(files) {
+    return [...new Set(files.map((file) => file.trim()).filter((file) => file.length > 0))].sort();
+}
+function buildChangedFileEntries(input) {
+    const { files, claimedPaths, activeLaneDomain, dirtyAtStart, fingerprintsByPath } = input;
+    return files.map((path) => {
+        const fingerprint = fingerprintsByPath.get(path);
+        const status = fingerprint?.exists === false ? "deleted" : dirtyAtStart.has(path) ? "modified" : "added";
+        const crossing = claimedPaths.length > 0 && !(0, claimed_paths_1.fileWithinClaimedPaths)(path, claimedPaths);
+        return {
+            path,
+            status,
+            owningDomain: null,
+            activeLaneDomain,
+            crossing,
+            severity: "tier_b",
+        };
+    });
+}
+/** Git working-tree paths (repo-relative), excluding .agentbridge noise. */
+function repoDirtySnapshot() {
+    return normalizeChangedFiles((0, git_status_1.repoDirtySnapshotFromGitStatus)());
+}
+/**
+ * Sync changed files to the server before acceptance decisions.
+ * Merges watch-tracked files with a git dirty snapshot so check/done/handoff
+ * do not depend on a long-running watch process.
+ */
+async function preflightSyncChangedFiles(ctx) {
+    const state = (0, session_state_1.readSessionState)();
+    if (!state?.serverSessionId) {
+        return { syncedFiles: [], observedFiles: [] };
+    }
+    const watchFiles = normalizeChangedFiles(state.changedFiles ?? []);
+    const gitFiles = repoDirtySnapshot();
+    const gitFileSet = new Set(gitFiles);
+    const claimedPaths = normalizeChangedFiles(state.claimedPaths ?? []);
+    // Phase 2/3: Filter out files that were already dirty when this session started
+    // and have NOT changed since (contamination control). Only include them once they
+    // acquire new content within the session.
+    const dirtyAtStart = new Set(state.dirtyFilesAtStart ?? []);
+    const startFingerprints = state.fingerprintsAtStart ?? {};
+    /** True when a git-dirty file is genuinely new work within this session. */
+    function isNewWorkFile(file) {
+        if (!dirtyAtStart.has(file))
+            return true; // wasn't dirty at start → always new work
+        // Was dirty at start – only include if content changed since start
+        const fps = (0, file_fingerprints_1.computeFileFingerprints)([file]);
+        const current = fps[0];
+        if (!current?.exists) {
+            // File now missing. Treat as new work only when it previously existed at start.
+            return startFingerprints[file] !== undefined;
+        }
+        const currentFp = current.sha256 ?? current.mtimeMs?.toString() ?? "";
+        const baseFp = startFingerprints[file];
+        return baseFp === undefined || currentFp !== baseFp;
+    }
+    const watchOnlyFiles = watchFiles.filter((file) => !gitFileSet.has(file));
+    const watchOnlyFingerprints = (0, file_fingerprints_1.computeFileFingerprints)(watchOnlyFiles);
+    const activeWatchOnlyFiles = watchOnlyFingerprints
+        .filter((fingerprint) => fingerprint.exists)
+        .map((fingerprint) => fingerprint.path);
+    const merged = normalizeChangedFiles([
+        ...watchFiles.filter((file) => gitFileSet.has(file)),
+        ...activeWatchOnlyFiles,
+        ...gitFiles.filter((file) => isNewWorkFile(file) &&
+            (claimedPaths.length === 0 || (0, claimed_paths_1.fileWithinClaimedPaths)(file, claimedPaths))),
+        ...gitFiles.filter((file) => isNewWorkFile(file) &&
+            claimedPaths.length > 0 &&
+            !(0, claimed_paths_1.fileWithinClaimedPaths)(file, claimedPaths)),
+    ]);
+    // Phase 4: Include content fingerprints in the hash so that changing the *content*
+    // of a file (without changing the file list) correctly triggers a new server sync.
+    // Also allow transitioning to an empty set to clear current server-side drift.
+    const fingerprints = (0, file_fingerprints_1.computeFileFingerprints)(merged);
+    const fpMap = new Map(fingerprints.map((fp) => [fp.path, fp.sha256 ?? fp.mtimeMs?.toString() ?? ""]));
+    const nextHash = merged.length === 0 ? "" : merged.map((f) => `${f}:${fpMap.get(f) ?? ""}`).join("\n");
+    if (state.lastSyncedChangedFilesHash === nextHash) {
+        return { syncedFiles: [], observedFiles: merged };
+    }
+    const fingerprintByPath = new Map(fingerprints.map((fp) => [fp.path, fp]));
+    const changedFileEntries = buildChangedFileEntries({
+        files: merged,
+        claimedPaths,
+        activeLaneDomain: state.laneDomain ?? null,
+        dirtyAtStart,
+        fingerprintsByPath: fingerprintByPath,
+    });
+    await (0, server_sync_1.postObservedDiff)(ctx, { workSessionId: state.serverSessionId }, {
+        activeLaneDomain: state.laneDomain ?? null,
+        changedFiles: merged,
+        changedFileEntries,
+        boundaryCrossings: [],
+        fileFingerprints: fingerprints,
+    });
+    state.changedFiles = merged;
+    state.lastSyncedChangedFilesHash = nextHash;
+    (0, session_state_1.writeSessionState)(state);
+    return { syncedFiles: merged, observedFiles: merged };
+}

package/dist/proof-guidance.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestVerifyCommands = suggestVerifyCommands;
+exports.explainMissingProofItem = explainMissingProofItem;
+exports.getMissingProofDetails = getMissingProofDetails;
+function quoteForShell(input) {
+    return input.replace(/(["\\$`])/g, "\\$1");
+}
+function suggestVerifyCommands(changedFiles, detectedWorkType) {
+    const commands = [];
+    const unique = [...new Set(changedFiles.map((file) => file.trim()).filter((file) => file.length > 0))];
+    const docsFile = unique.find((file) => file.startsWith("docs/"));
+    const hasCli = unique.some((file) => file.startsWith("cli/"));
+    const hasBackend = unique.some((file) => file.startsWith("src/"));
+    if (detectedWorkType === "cli_git_enforcement") {
+        commands.push("agentbridge verify -- npm --prefix cli test");
+        commands.push("agentbridge verify -- npm --prefix cli run typecheck");
+    }
+    if (detectedWorkType === "documentation" && docsFile) {
+        commands.push(`agentbridge verify -- "test -f ${quoteForShell(docsFile)}"`);
+        commands.push('agentbridge verify -- "rg -n \\"TODO|TBD\\" docs/"');
+    }
+    if (detectedWorkType === "general") {
+        commands.push("agentbridge verify -- npm test");
+    }
+    if (hasCli) {
+        commands.push("agentbridge verify -- npm --prefix cli test");
+    }
+    if (hasBackend || detectedWorkType === "general") {
+        commands.push("agentbridge verify -- npm test");
+    }
+    if (docsFile) {
+        commands.push(`agentbridge verify -- "test -f ${quoteForShell(docsFile)}"`);
+    }
+    if (commands.length === 0 && unique.length > 0) {
+        commands.push(`agentbridge verify -- "test -f ${quoteForShell(unique[0])}"`);
+    }
+    if (commands.length === 0) {
+        commands.push("agentbridge verify -- <command>");
+    }
+    return [...new Set(commands)];
+}
+function explainMissingProofItem(item) {
+    const lower = item.toLowerCase();
+    if (lower.includes("verification")) {
+        return "Acceptance requires a fresh verification run that covers the changed files.";
+    }
+    if (lower.includes("handoff")) {
+        return "Acceptance requires a posted handoff before the session can be closed.";
+    }
+    if (lower.includes("scope") || lower.includes("boundary")) {
+        return "Acceptance requires proof that work stayed within the declared lane and boundaries.";
+    }
+    return "Acceptance is blocked until this required proof artifact is provided.";
+}
+function codeFromMissingProof(item) {
+    const lower = item.toLowerCase();
+    if (lower.includes("verification"))
+        return "verification_required";
+    if (lower.includes("handoff"))
+        return "handoff_required";
+    if (lower.includes("scope") || lower.includes("boundary"))
+        return "scope_boundary_required";
+    return "required_proof_missing";
+}
+function sourceRuleFromMissingProof(item) {
+    const lower = item.toLowerCase();
+    if (lower.includes("verification"))
+        return "acceptance.required_proof.verification";
+    if (lower.includes("handoff"))
+        return "acceptance.required_proof.handoff";
+    if (lower.includes("scope") || lower.includes("boundary")) {
+        return "acceptance.required_proof.scope-boundary";
+    }
+    return "acceptance.required_proof.general";
+}
+function proofRecipeFor(workType, changedFiles) {
+    if (workType === "documentation") {
+        return "Validate changed docs exist and are consistent, then record that command output.";
+    }
+    if (workType === "cli_git_enforcement") {
+        return "Run CLI tests + typecheck, then rerun the highest-signal CLI verify command.";
+    }
+    if (changedFiles.some((file) => file.startsWith("src/"))) {
+        return "Run focused module tests and then a broader project test command.";
+    }
+    return "Run the smallest command proving the changed files behave as intended.";
+}
+function getMissingProofDetails(report) {
+    if (report.evidence_missing_details && report.evidence_missing_details.length > 0) {
+        return report.evidence_missing_details.map((detail) => ({
+            code: detail.code,
+            message: detail.message,
+            why: detail.why,
+            source_rule: detail.source_rule,
+            proof_recipe: detail.proof_recipe,
+            suggested_verify: detail.suggested_verify,
+        }));
+    }
+    const fallbackSuggested = suggestVerifyCommands(report.changed_files, report.detected_work_type)[0];
+    const proofRecipe = proofRecipeFor(report.detected_work_type, report.changed_files);
+    return report.evidence_missing.map((item) => ({
+        code: codeFromMissingProof(item),
+        message: item,
+        why: explainMissingProofItem(item),
+        source_rule: sourceRuleFromMissingProof(item),
+        proof_recipe: proofRecipe,
+        ...(fallbackSuggested ? { suggested_verify: fallbackSuggested } : {}),
+    }));
+}

package/dist/redact-secrets.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactSecrets = redactSecrets;
+const SECRET_PATTERNS = [
+    /(?:api[_-]?key|token|secret|password|authorization|bearer)\s*[:=]\s*\S+/gi,
+    /sk-[a-zA-Z0-9]{20,}/g,
+    /eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/g,
+];
+function redactSecrets(value) {
+    let out = value;
+    for (const pattern of SECRET_PATTERNS) {
+        out = out.replace(pattern, "[REDACTED]");
+    }
+    return out;
+}

package/dist/revert-crossing.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revertCrossingFile = revertCrossingFile;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function run(command) {
+    return (0, node_child_process_1.execSync)(command, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+function shellQuote(path) {
+    return `'${path.replace(/'/g, `'\\''`)}'`;
+}
+function inHead(path) {
+    try {
+        (0, node_child_process_1.execSync)(`git cat-file -e HEAD:${shellQuote(path)}`, {
+            stdio: ["ignore", "ignore", "ignore"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function statusCode(path) {
+    const output = run(`git status --porcelain -- ${shellQuote(path)}`);
+    const line = output
+        .split("\n")
+        .map((v) => v.trimEnd())
+        .find((v) => v.trim().length > 0);
+    if (!line)
+        return "  ";
+    return line.slice(0, 2);
+}
+function removeEmptyParents(path, repoRoot) {
+    let cursor = (0, node_path_1.dirname)((0, node_path_1.resolve)(repoRoot, path));
+    const root = (0, node_path_1.resolve)(repoRoot);
+    while (cursor.startsWith(root) && cursor !== root) {
+        try {
+            (0, node_fs_1.rmSync)(cursor);
+            cursor = (0, node_path_1.dirname)(cursor);
+        }
+        catch {
+            break;
+        }
+    }
+}
+function revertCrossingFile(path, repoRoot = process.cwd()) {
+    const code = statusCode(path);
+    const trackedInHead = inHead(path);
+    const absolute = (0, node_path_1.resolve)(repoRoot, path);
+    const x = code[0] ?? " ";
+    const isUntracked = code === "??";
+    const isStaged = x !== " " && x !== "?";
+    if (trackedInHead) {
+        run(`git checkout HEAD -- ${shellQuote(path)}`);
+        return;
+    }
+    if (isStaged) {
+        try {
+            run(`git rm -f --cached -- ${shellQuote(path)}`);
+        }
+        catch {
+            // Continue with filesystem cleanup.
+        }
+    }
+    if (isUntracked || (0, node_fs_1.existsSync)(absolute)) {
+        (0, node_fs_1.rmSync)(absolute, { force: true });
+        removeEmptyParents(path, repoRoot);
+    }
+}