@agentbridge1/cli 0.0.8 → 0.0.10

package/dist/contract-verdict.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectOutOfScopeFiles = detectOutOfScopeFiles;
 exports.renderContractVerdict = renderContractVerdict;
 const domain_resolution_1 = require("./domain-resolution");
+const contract_intelligence_1 = require("./contract-intelligence");
+const diff_reader_1 = require("./diff-reader");
 const local_proof_1 = require("./local-proof");
 const INTENT_STOP_WORDS = new Set([
     "a",
@@ -115,34 +117,39 @@ function renderContractVerdict(session, changedFiles, proofRun, domains = []) {
         .map(normalizePath)
         .filter((file) => file.length > 0 && !(0, local_proof_1.isProofNoiseFile)(file));
     const outOfScope = detectOutOfScopeFiles(meaningfulFiles, session, domains);
-    const missing = [];
-    if (!session?.intent?.trim()) {
-        missing.push("No contract intent was recorded.");
-    }
-    if (meaningfulFiles.length === 0) {
-        missing.push("No files changed since the contract baseline.");
-    }
-    if (!proofRun) {
-        missing.push("No proof/test run was recorded.");
-    }
-    else if (proofRun.status === "failed") {
-        missing.push(`Proof failed: ${proofRun.command} (exit ${proofRun.exitCode}).`);
-    }
-    let nextStep = "Contract looks complete. Commit when ready.";
-    if (missing.length > 0 && outOfScope.length > 0) {
-        nextStep =
-            "Review out-of-scope files, run the relevant tests, then decide whether to accept or revert the extra changes.";
-    }
-    else if (missing.some((item) => item.includes("proof"))) {
+    const contract = session?.intent?.trim()
+        ? (0, contract_intelligence_1.localSessionToContractIntelligence)(session)
+        : null;
+    // Read diff once — fresh from git, not stored in session
+    const diff = meaningfulFiles.length > 0 ? (0, diff_reader_1.readRepoDiff)(meaningfulFiles) : null;
+    // Evaluate criteria if we have a session with intent
+    const criteriaEvals = contract
+        ? (0, contract_intelligence_1.evaluateCompletionCriteria)({
+            contract,
+            changedFiles: meaningfulFiles,
+            proofRun,
+            diff,
+        })
+        : null;
+    const proofNeeded = contract?.proofNeeded ?? [];
+    const evidenced = criteriaEvals?.filter((e) => e.status === "evidence_found") ?? [];
+    // Next step: criteria-driven if available, else generic
+    let nextStep;
+    if (criteriaEvals && criteriaEvals.length > 0) {
+        nextStep = (0, contract_intelligence_1.nextStepFromCriteria)(criteriaEvals, proofNeeded);
+    }
+    else if (!proofRun) {
         nextStep = "Run the relevant test command so AgentBridge can record proof for this contract.";
     }
     else if (outOfScope.length > 0) {
-        nextStep =
-            "Ask the agent to justify the out-of-scope files, or revert them before accepting the work.";
+        nextStep = "Ask the agent to justify the out-of-scope files, or revert them before accepting the work.";
     }
     else if (meaningfulFiles.length === 0) {
         nextStep = "No work was recorded. Start a new contract when you are ready to implement.";
     }
+    else {
+        nextStep = "Contract looks complete. Commit when ready.";
+    }
     const lines = [
         "AgentBridge Contract Verdict",
         "─────────────────────────────────────────",
@@ -160,13 +167,59 @@ function renderContractVerdict(session, changedFiles, proofRun, domains = []) {
             lines.push(`  - ${file}`);
         }
     }
-    lines.push("", "Here's what appears missing:");
-    if (missing.length === 0) {
-        lines.push("  Nothing obvious from this contract check.");
+    if (criteriaEvals && criteriaEvals.length > 0) {
+        lines.push("", "Here's what \"done\" needed to prove:");
+        for (const e of criteriaEvals) {
+            const icon = e.status === "evidence_found"
+                ? "✓"
+                : e.status === "partial_evidence"
+                    ? "~"
+                    : e.status === "cannot_verify"
+                        ? "?"
+                        : "✗";
+            lines.push(`  ${icon} [${e.status}] ${e.criterion}`);
+            lines.push(`      ${e.evidence}`);
+        }
+    }
+    else {
+        lines.push("", "Here's what appears missing:");
+        const missing = [];
+        if (!session?.intent?.trim())
+            missing.push("No contract intent was recorded.");
+        if (meaningfulFiles.length === 0)
+            missing.push("No files changed since the contract baseline.");
+        if (!proofRun)
+            missing.push("No proof/test run was recorded.");
+        else if (proofRun.status === "failed")
+            missing.push(`Proof failed: ${proofRun.command} (exit ${proofRun.exitCode}).`);
+        if (missing.length === 0) {
+            lines.push("  Nothing obvious from this contract check.");
+        }
+        else {
+            for (const item of missing)
+                lines.push(`  - ${item}`);
+        }
+    }
+    if (evidenced.length > 0 && criteriaEvals) {
+        lines.push("", "Here's what AgentBridge saw evidence for:");
+        for (const e of evidenced) {
+            lines.push(`  - ${e.criterion}`);
+        }
+    }
+    const stillUnproven = criteriaEvals
+        ? criteriaEvals.filter((e) => e.status === "no_evidence")
+        : [];
+    lines.push("", "Here's what is still unproven:");
+    if (stillUnproven.length === 0 && (!criteriaEvals || criteriaEvals.length === 0)) {
+        lines.push(!proofRun ? "  No proof/test run was recorded." : "  Nothing obvious from this contract check.");
+    }
+    else if (stillUnproven.length === 0) {
+        lines.push("  Nothing detected as fully unproven.");
     }
     else {
-        for (const item of missing) {
-            lines.push(`  - ${item}`);
+        for (const e of stillUnproven) {
+            lines.push(`  - ${e.criterion}`);
+            lines.push(`    ${e.evidence}`);
         }
     }
     lines.push("", "Here's where the work drifted out of scope:");

package/dist/diff-reader.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * Diff reader — parses `git diff HEAD` output into structured change data.
+ * All logic is deterministic regex on git unified diff format. No LLM.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRepoDiff = readRepoDiff;
+exports.parseDiffString = parseDiffString;
+exports.getDiffForFile = getDiffForFile;
+exports.summariseDiff = summariseDiff;
+const node_child_process_1 = require("node:child_process");
+// Function declarations
+const FN_ADDED_RE = /^\+\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/;
+const FN_REMOVED_RE = /^-\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)/;
+// Arrow / const functions: `const foo = (` or `const foo = async (`
+const ARROW_ADDED_RE = /^\+\s*(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/;
+const ARROW_REMOVED_RE = /^-\s*(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/;
+// Non-function consts: `const FOO_BAR =` (all-caps or mixed without open paren)
+const CONST_ADDED_RE = /^\+\s*(?:export\s+)?const\s+(\w+)\s*=/;
+const CONST_REMOVED_RE = /^-\s*(?:export\s+)?const\s+(\w+)\s*=/;
+// Import lines
+const IMPORT_ADDED_RE = /^\+\s*import\s+.+\s+from\s+['"]([^'"]+)['"]/;
+const IMPORT_REMOVED_RE = /^-\s*import\s+.+\s+from\s+['"]([^'"]+)['"]/;
+// Named exports (excluding consts/functions already captured)
+const EXPORT_ADDED_RE = /^\+\s*export\s+(?:const|function|class|type|interface|enum)\s+(\w+)/;
+const EXPORT_REMOVED_RE = /^-\s*export\s+(?:const|function|class|type|interface|enum)\s+(\w+)/;
+// Guard clauses: if(!x) throw / return / continue / break
+const GUARD_RE = /^\+.*\bif\s*\([^)]*\).*\b(?:throw|return new Error|return null|return undefined)\b/;
+// File header in git diff: "diff --git a/foo b/foo"
+const FILE_HEADER_RE = /^diff --git a\/(.+) b\/.+/;
+// Hunk header: @@ -a,b +c,d @@
+const HUNK_RE = /^@@/;
+function isArrowOrFnConst(line, added) {
+    const re = added ? ARROW_ADDED_RE : ARROW_REMOVED_RE;
+    return re.exec(line)?.[1] ?? null;
+}
+function isRegularConst(line, added) {
+    // Only count if it's NOT an arrow function (no open paren immediately after =)
+    const arrowRe = added ? ARROW_ADDED_RE : ARROW_REMOVED_RE;
+    if (arrowRe.test(line))
+        return null;
+    const re = added ? CONST_ADDED_RE : CONST_REMOVED_RE;
+    return re.exec(line)?.[1] ?? null;
+}
+function parseFileDiff(fileName, diffLines) {
+    const fd = {
+        file: fileName,
+        functions_added: [],
+        functions_removed: [],
+        functions_changed: [],
+        constants_added: [],
+        constants_removed: [],
+        imports_added: [],
+        imports_removed: [],
+        exports_added: [],
+        exports_removed: [],
+        guard_clauses_added: 0,
+        lines_added: 0,
+        lines_removed: 0,
+    };
+    for (const line of diffLines) {
+        if (HUNK_RE.test(line))
+            continue;
+        const isAdd = line.startsWith("+") && !line.startsWith("+++");
+        const isDel = line.startsWith("-") && !line.startsWith("---");
+        if (isAdd)
+            fd.lines_added++;
+        if (isDel)
+            fd.lines_removed++;
+        // Functions
+        const fnAdded = FN_ADDED_RE.exec(line)?.[1] ?? isArrowOrFnConst(line, true);
+        if (fnAdded) {
+            if (fd.functions_removed.includes(fnAdded)) {
+                fd.functions_changed.push(fnAdded);
+                fd.functions_removed.splice(fd.functions_removed.indexOf(fnAdded), 1);
+            }
+            else {
+                fd.functions_added.push(fnAdded);
+            }
+        }
+        const fnRemoved = FN_REMOVED_RE.exec(line)?.[1] ?? isArrowOrFnConst(line, false);
+        if (fnRemoved) {
+            const addedIdx = fd.functions_added.indexOf(fnRemoved);
+            if (addedIdx >= 0) {
+                fd.functions_changed.push(fnRemoved);
+                fd.functions_added.splice(addedIdx, 1);
+            }
+            else {
+                fd.functions_removed.push(fnRemoved);
+            }
+        }
+        // Constants (non-function)
+        const constAdded = isRegularConst(line, true);
+        if (constAdded)
+            fd.constants_added.push(constAdded);
+        const constRemoved = isRegularConst(line, false);
+        if (constRemoved)
+            fd.constants_removed.push(constRemoved);
+        // Imports
+        const importAdded = IMPORT_ADDED_RE.exec(line)?.[1];
+        if (importAdded)
+            fd.imports_added.push(importAdded);
+        const importRemoved = IMPORT_REMOVED_RE.exec(line)?.[1];
+        if (importRemoved)
+            fd.imports_removed.push(importRemoved);
+        // Exports
+        const exportAdded = EXPORT_ADDED_RE.exec(line)?.[1];
+        if (exportAdded && !fd.functions_added.includes(exportAdded) && !fd.constants_added.includes(exportAdded)) {
+            fd.exports_added.push(exportAdded);
+        }
+        const exportRemoved = EXPORT_REMOVED_RE.exec(line)?.[1];
+        if (exportRemoved && !fd.functions_removed.includes(exportRemoved) && !fd.constants_removed.includes(exportRemoved)) {
+            fd.exports_removed.push(exportRemoved);
+        }
+        // Guard clauses
+        if (isAdd && GUARD_RE.test(line))
+            fd.guard_clauses_added++;
+    }
+    return fd;
+}
+/**
+ * Reads git diff HEAD for the given changed files and returns structured diffs.
+ * Falls back gracefully if git is unavailable or diff fails.
+ */
+function readRepoDiff(changedFiles) {
+    if (changedFiles.length === 0)
+        return { files: [], totalLinesAdded: 0, totalLinesRemoved: 0 };
+    let rawDiff;
+    try {
+        rawDiff = (0, node_child_process_1.execFileSync)("git", ["diff", "HEAD", "--unified=0", "--", ...changedFiles], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 5000,
+        });
+    }
+    catch {
+        // Fallback: try diff against staged + unstaged
+        try {
+            rawDiff = (0, node_child_process_1.execFileSync)("git", ["diff", "--unified=0", "--", ...changedFiles], {
+                encoding: "utf-8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 5000,
+            });
+        }
+        catch {
+            return { files: [], totalLinesAdded: 0, totalLinesRemoved: 0 };
+        }
+    }
+    return parseDiffString(rawDiff);
+}
+/**
+ * Parse a raw git diff string into RepoDiff. Exported for testing without git.
+ */
+function parseDiffString(rawDiff) {
+    const lines = rawDiff.split("\n");
+    const fileBlocks = [];
+    let current = null;
+    for (const line of lines) {
+        const fileMatch = FILE_HEADER_RE.exec(line);
+        if (fileMatch) {
+            if (current)
+                fileBlocks.push(current);
+            current = { name: fileMatch[1], lines: [] };
+        }
+        else if (current) {
+            current.lines.push(line);
+        }
+    }
+    if (current)
+        fileBlocks.push(current);
+    const files = fileBlocks.map((b) => parseFileDiff(b.name, b.lines));
+    return {
+        files,
+        totalLinesAdded: files.reduce((s, f) => s + f.lines_added, 0),
+        totalLinesRemoved: files.reduce((s, f) => s + f.lines_removed, 0),
+    };
+}
+/**
+ * Returns a FileDiff for a specific file, or null if not in the diff.
+ */
+function getDiffForFile(diff, file) {
+    const normalized = file.replaceAll("\\", "/");
+    return diff.files.find((f) => f.file === normalized || f.file.endsWith(`/${normalized}`) || normalized.endsWith(`/${f.file}`)) ?? null;
+}
+/**
+ * Summarise diff changes across all files in a few readable tokens for evidence strings.
+ */
+function summariseDiff(diff) {
+    const allExportsAdded = diff.files.flatMap((f) => f.exports_added.concat(f.functions_added));
+    const allGuards = diff.files.reduce((s, f) => s + f.guard_clauses_added, 0);
+    const parts = [];
+    if (diff.totalLinesAdded > 0 || diff.totalLinesRemoved > 0) {
+        parts.push(`+${diff.totalLinesAdded}/-${diff.totalLinesRemoved} lines`);
+    }
+    if (allExportsAdded.length > 0)
+        parts.push(`${allExportsAdded.length} new export(s): ${allExportsAdded.slice(0, 3).join(", ")}`);
+    if (allGuards > 0)
+        parts.push(`${allGuards} guard clause(s) added`);
+    return parts.join("; ");
+}

package/dist/git-status.js

@@ -13,7 +13,10 @@ function normalizePath(path) {
 }
 function isAgentbridgeLocalPath(path) {
     const normalized = normalizePath(path);
-    return normalized === ".agentbridge" || normalized.startsWith(".agentbridge/");
+    const lower = normalized.toLowerCase();
+    if (lower === ".agentbridge" || lower.endsWith("/.agentbridge"))
+        return true;
+    return lower.includes(".agentbridge/");
 }
 function isRenameOrCopy(xy) {
     return xy.includes("R") || xy.includes("C");

package/dist/intent-parser.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Intent parser — extracts structured task specification from a raw intent string.
+ * All logic is deterministic: no LLM, no external calls.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIntent = parseIntent;
+exports.buildTaskSpecificCriteria = buildTaskSpecificCriteria;
+const ACTIONS = ["fix", "add", "update", "refactor", "remove", "migrate", "rename", "revert", "delete", "implement", "improve", "patch"];
+const DOMAIN_KEYWORD_MAP = {
+    auth: ["auth", "login", "logout", "session", "token", "oauth", "jwt", "password", "signin", "signup", "sign-in", "sign-up", "register", "credential", "permission", "role"],
+    database: ["database", "db", "schema", "migration", "migrate", "prisma", "sql", "query", "table", "column", "index", "model", "seed", "orm"],
+    payments: ["payment", "payments", "billing", "stripe", "invoice", "subscription", "checkout", "webhook"],
+    api: ["api", "endpoint", "route", "handler", "controller", "request", "response", "rest", "graphql"],
+    ui: ["ui", "style", "css", "component", "page", "layout", "copy", "design", "render", "display", "view", "frontend", "html", "template"],
+    mcp: ["mcp", "agentbridge", "cursor", "rules"],
+    tests: ["test", "tests", "spec", "vitest", "jest", "coverage", "proof"],
+};
+const SYMPTOMS = {
+    "401": ["401", "unauthorized", "unauthenticated"],
+    "403": ["403", "forbidden"],
+    "404": ["404", "not found", "notfound"],
+    "500": ["500", "internal server error", "server error"],
+    "null": ["null", "undefined", "nan", "nil"],
+    "crash": ["crash", "crashes", "crashed", "exception", "throws", "throw"],
+    "loop": ["loop", "infinite loop", "recursion"],
+    "hang": ["hang", "hangs", "timeout", "deadlock"],
+    "slow": ["slow", "performance", "latency", "memory leak", "memory"],
+    "duplicate": ["duplicate", "duplicated", "twice"],
+    "missing": ["missing", "not showing", "not found"],
+};
+// Route pattern: /something or /something/else (no file extension)
+const ROUTE_RE = /(?<!\w)(\/[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_:_-]+)*)/g;
+// File with extension: something.ts, SomeThing.tsx, etc.
+const FILE_RE = /\b([A-Za-z][A-Za-z0-9_-]*\.[a-z]{2,4})\b/g;
+// PascalCase class or model name (≥2 caps or starts with uppercase followed by lowercase+uppercase)
+const PASCAL_RE = /\b([A-Z][a-z]+(?:[A-Z][a-z]*)+)\b/g;
+// camelCase function name — at least one internal uppercase letter, no spaces
+const CAMEL_FN_RE = /\b([a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)+)\b/g;
+// Quoted phrase
+const QUOTED_RE = /"([^"]+)"|'([^']+)'/g;
+function detectDomain(lower) {
+    for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORD_MAP)) {
+        if (keywords.some((kw) => lower.includes(kw)))
+            return domain;
+    }
+    return null;
+}
+function detectAction(lower) {
+    for (const action of ACTIONS) {
+        if (lower.startsWith(action) || lower.includes(` ${action} `))
+            return action;
+    }
+    return null;
+}
+function detectSymptom(lower) {
+    for (const [symptom, patterns] of Object.entries(SYMPTOMS)) {
+        if (patterns.some((p) => lower.includes(p)))
+            return symptom;
+    }
+    return null;
+}
+function extractTargets(raw) {
+    const targets = new Set();
+    // Quoted phrases first
+    for (const m of raw.matchAll(QUOTED_RE)) {
+        const phrase = m[1] ?? m[2];
+        if (phrase)
+            targets.add(phrase.trim());
+    }
+    // API routes
+    for (const m of raw.matchAll(ROUTE_RE)) {
+        targets.add(m[1]);
+    }
+    // Files with extensions
+    for (const m of raw.matchAll(FILE_RE)) {
+        targets.add(m[1]);
+    }
+    // PascalCase (models, classes)
+    for (const m of raw.matchAll(PASCAL_RE)) {
+        targets.add(m[1]);
+    }
+    // camelCase function names — only when short enough to be a name, not prose
+    for (const m of raw.matchAll(CAMEL_FN_RE)) {
+        if (m[1].length <= 40)
+            targets.add(m[1]);
+    }
+    return [...targets];
+}
+function inferLayers(domain, targets, symptom, action, rawLower) {
+    const layers = [];
+    const hasRoute = targets.some((t) => t.startsWith("/"));
+    const hasMigration = action === "migrate" || targets.some((t) => t.toLowerCase().includes("migration"));
+    if (domain === "auth") {
+        if (symptom === "401" || symptom === "403")
+            layers.push("route_handler", "auth_middleware");
+        else if (hasRoute)
+            layers.push("route_handler", "auth_middleware");
+        else
+            layers.push("auth_middleware");
+    }
+    if (domain === "api") {
+        if (hasRoute)
+            layers.push("route_handler");
+        else
+            layers.push("route_handler");
+    }
+    if (domain === "database") {
+        if (hasMigration)
+            layers.push("schema", "migration_file");
+        else
+            layers.push("model", "query");
+    }
+    if (domain === "ui") {
+        layers.push("component", "view");
+    }
+    if (domain === "payments") {
+        if (targets.some((t) => t.toLowerCase().includes("webhook")) || rawLower.includes("webhook")) {
+            layers.push("webhook_handler");
+        }
+        else {
+            layers.push("billing_handler");
+        }
+    }
+    if (domain === "mcp") {
+        layers.push("mcp_server", "config");
+    }
+    return layers;
+}
+function parseIntent(raw) {
+    if (!raw?.trim()) {
+        return { raw: raw ?? "", domain: null, targets: [], symptom: null, action: null, affected_layer: [] };
+    }
+    const lower = raw.toLowerCase();
+    const domain = detectDomain(lower);
+    const action = detectAction(lower);
+    const symptom = detectSymptom(lower);
+    const targets = extractTargets(raw);
+    const affected_layer = inferLayers(domain, targets, symptom, action, lower);
+    return { raw, domain, targets, symptom, action, affected_layer };
+}
+/**
+ * Builds task-specific criteria to prepend/append to a profile's generic criteria.
+ * Returns at most 2 sentences so the checklist stays readable.
+ */
+function buildTaskSpecificCriteria(parsed) {
+    const extra = [];
+    const routeTargets = parsed.targets.filter((t) => t.startsWith("/"));
+    const fileTargets = parsed.targets.filter((t) => t.includes("."));
+    const namedTargets = parsed.targets.filter((t) => !t.startsWith("/") && !t.includes("."));
+    // Task-specific entry criterion (what to look at)
+    if (routeTargets.length > 0 && parsed.domain === "auth" && parsed.symptom) {
+        extra.push(`The ${routeTargets[0]} route handler or its auth middleware chain is updated to address the ${parsed.symptom}.`);
+    }
+    else if (routeTargets.length > 0 && parsed.domain === "api") {
+        extra.push(`The ${routeTargets[0]} endpoint handler is updated as intended.`);
+    }
+    else if (routeTargets.length > 0) {
+        extra.push(`Changes are focused on the ${routeTargets[0]} route.`);
+    }
+    else if (fileTargets.length > 0) {
+        extra.push(`Changes are focused on ${fileTargets[0]}.`);
+    }
+    else if (namedTargets.length > 0) {
+        extra.push(`Changes are focused on ${namedTargets[0]}.`);
+    }
+    // Task-specific proof criterion (what to verify)
+    if (parsed.symptom && routeTargets.length > 0) {
+        extra.push(`Proof exists for the ${parsed.symptom} behavior on ${routeTargets[0]}.`);
+    }
+    else if (parsed.symptom) {
+        extra.push(`Proof exists that the ${parsed.symptom} condition is resolved.`);
+    }
+    else if (parsed.action && parsed.domain) {
+        extra.push(`Proof exists that the ${parsed.action} to the ${parsed.domain} layer is correct.`);
+    }
+    return extra;
+}

package/dist/local-proof.js

@@ -13,6 +13,11 @@ function normalizePath(path) {
 function isProofNoiseFile(file) {
     const normalized = normalizePath(file);
     const lower = normalized.toLowerCase();
+    if (lower === ".agentbridge" ||
+        lower.endsWith("/.agentbridge") ||
+        lower.includes(".agentbridge/")) {
+        return true;
+    }
     if (lower === "agentbridge.md" ||
         lower === ".cursor" ||
         lower.startsWith(".cursor/")) {