@agentbridge1/cli 0.0.8 → 0.0.9

package/dist/proof-parser.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Proof output parser — reads proofRun.stdoutExcerpt for structured test results.
+ * Supports vitest, jest, mocha. All logic is deterministic regex.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProofOutput = parseProofOutput;
+exports.proofEvidenceString = proofEvidenceString;
+const DOMAIN_TEST_KEYWORDS = {
+    auth: ["auth", "login", "logout", "session", "token", "password", "oauth", "signin", "signup"],
+    database: ["db", "database", "prisma", "migration", "schema", "query", "model"],
+    api: ["api", "route", "endpoint", "handler", "request", "response"],
+    payments: ["payment", "billing", "stripe", "invoice", "webhook", "subscription"],
+    mcp: ["mcp", "setup", "rules", "config", "agentbridge"],
+    ui: ["component", "render", "view", "style", "page", "layout"],
+    tests: ["test", "spec"],
+};
+// Vitest / Jest summary: "12 passed", "Tests: 5 passed", "5 failed"
+const PASSED_RE = /(\d+)\s+passed/i;
+const FAILED_RE = /(\d+)\s+failed/i;
+const SKIPPED_RE = /(\d+)\s+skipped/i;
+// Jest alternative: "Tests: 5 passed, 1 failed, 6 total"
+const JEST_SUMMARY_RE = /Tests:\s+(?:(\d+)\s+skipped,\s*)?(?:(\d+)\s+passed)?(?:,\s*(\d+)\s+failed)?/i;
+// Test name lines — vitest uses ✓/✗, jest uses ✓/×/✕, some use √
+const PASS_NAME_RE = /^\s*[✓√]\s+(.+)/;
+const FAIL_NAME_RE = /^\s*[✗×✕✘]\s+(.+)/;
+// Vitest detection: output contains "Test Files" or "Duration" or vitest version header
+const VITEST_DETECT_RE = /Test Files|vitest|v\d+\.\d+\.\d+.*vitest/i;
+// Jest detection
+const JEST_DETECT_RE = /PASS|FAIL|jest|Tests:/;
+// Mocha
+const MOCHA_DETECT_RE = /passing|failing|pending.*mocha/i;
+function detectRunner(stdout) {
+    if (VITEST_DETECT_RE.test(stdout))
+        return "vitest";
+    if (JEST_DETECT_RE.test(stdout))
+        return "jest";
+    if (MOCHA_DETECT_RE.test(stdout))
+        return "mocha";
+    return "unknown";
+}
+function extractDomainKeywords(testNames) {
+    const found = new Set();
+    const lower = testNames.join(" ").toLowerCase();
+    for (const [domain, keywords] of Object.entries(DOMAIN_TEST_KEYWORDS)) {
+        if (keywords.some((kw) => lower.includes(kw)))
+            found.add(domain);
+    }
+    return [...found];
+}
+function hasDomainCoverage(domain, domainKeywordsInPassed) {
+    const aliases = {
+        auth: ["auth"],
+        database: ["database"],
+        api: ["api"],
+        payments: ["payments"],
+        mcp: ["mcp"],
+        ui: ["ui"],
+    };
+    const check = aliases[domain] ?? [domain];
+    return check.some((alias) => domainKeywordsInPassed.includes(alias));
+}
+function parseProofOutput(proofRun) {
+    const stdout = proofRun.stdoutExcerpt ?? "";
+    const lines = stdout.split("\n");
+    const runner = detectRunner(stdout);
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const test_names_passed = [];
+    const test_names_failed = [];
+    for (const line of lines) {
+        // Count summary
+        const pm = PASSED_RE.exec(line);
+        if (pm)
+            passed = Math.max(passed, parseInt(pm[1], 10));
+        const fm = FAILED_RE.exec(line);
+        if (fm)
+            failed = Math.max(failed, parseInt(fm[1], 10));
+        const sm = SKIPPED_RE.exec(line);
+        if (sm)
+            skipped = Math.max(skipped, parseInt(sm[1], 10));
+        // Named test lines
+        const passName = PASS_NAME_RE.exec(line);
+        if (passName)
+            test_names_passed.push(passName[1].trim());
+        const failName = FAIL_NAME_RE.exec(line);
+        if (failName)
+            test_names_failed.push(failName[1].trim());
+    }
+    const domain_keywords_in_passed = extractDomainKeywords(test_names_passed);
+    return {
+        runner,
+        passed,
+        failed,
+        skipped,
+        test_names_passed,
+        test_names_failed,
+        domain_keywords_in_passed,
+        has_domain_coverage: (domain) => hasDomainCoverage(domain, domain_keywords_in_passed),
+    };
+}
+/**
+ * Builds a human-readable evidence string from a parsed proof, for use in criterion evaluation.
+ */
+function proofEvidenceString(parsed, domain) {
+    const total = parsed.passed + parsed.failed + parsed.skipped;
+    const base = `Proof run ${parsed.failed > 0 ? "failed" : "passed"} (${parsed.passed}/${total} tests passed).`;
+    if (domain && parsed.passed > 0) {
+        if (parsed.has_domain_coverage(domain)) {
+            const covering = parsed.domain_keywords_in_passed.join(", ");
+            return `${base} Tests covering: ${covering}.`;
+        }
+        const keywords = DOMAIN_TEST_KEYWORDS[domain]?.slice(0, 3).join(", ") ?? domain;
+        return `${base} No passed tests mention ${keywords} — domain coverage unconfirmed.`;
+    }
+    return base;
+}

package/dist/session-state.js

@@ -130,6 +130,21 @@ function isLocalSessionState(value) {
         return false;
     if (value.claimedPaths !== undefined && !isStringArray(value.claimedPaths))
         return false;
+    if (value.createdBy !== undefined && value.createdBy !== "user_start" && value.createdBy !== "agent_hello") {
+        return false;
+    }
+    if (value.contractProfiles !== undefined && !isStringArray(value.contractProfiles))
+        return false;
+    if (value.expectedSurfaces !== undefined && !isStringArray(value.expectedSurfaces))
+        return false;
+    if (value.expectedFileAreas !== undefined && !isStringArray(value.expectedFileAreas))
+        return false;
+    if (value.completionCriteria !== undefined && !isStringArray(value.completionCriteria))
+        return false;
+    if (value.proofNeeded !== undefined && !isStringArray(value.proofNeeded))
+        return false;
+    if (value.riskyOmissions !== undefined && !isStringArray(value.riskyOmissions))
+        return false;
     if (value.lastLocalVerificationRun !== undefined &&
         !(0, local_proof_1.isLocalVerificationRun)(value.lastLocalVerificationRun)) {
         return false;

package/dist/session.js

@@ -6,6 +6,7 @@ exports.openLocalSession = openLocalSession;
 exports.closeLocalSession = closeLocalSession;
 const node_child_process_1 = require("node:child_process");
 const http_1 = require("./http");
+const contract_intelligence_1 = require("./contract-intelligence");
 const session_state_1 = require("./session-state");
 const watch_core_1 = require("./watch-core");
 const file_fingerprints_1 = require("./file-fingerprints");
@@ -54,11 +55,20 @@ function openLocalSession(input) {
     const claimedPaths = [...new Set((input.claimedPaths ?? []).map((path) => path.trim()).filter(Boolean))];
     const baseline = captureLocalSessionBaseline();
     const now = baseline.startedAt;
+    const createdBy = input.createdBy ?? (input.agentId?.trim() === "local" ? "user_start" : "agent_hello");
+    const contract = (0, contract_intelligence_1.buildContractIntelligence)(input.intent?.trim(), createdBy);
     const state = {
         id: `local_${Date.now().toString(36)}`,
         agentId: input.agentId?.trim() || "local",
         laneDomain: input.laneDomain,
         intent: input.intent?.trim() || undefined,
+        createdBy,
+        contractProfiles: contract.contractProfiles,
+        expectedSurfaces: contract.expectedSurfaces,
+        expectedFileAreas: contract.expectedFileAreas,
+        completionCriteria: contract.completionCriteria,
+        proofNeeded: contract.proofNeeded,
+        riskyOmissions: contract.riskyOmissions,
         mode: input.mode,
         changeRequestId: input.changeRequestId,
         claimedPaths,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentbridge1/cli",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "CLI for AgentBridge — structured AI agent work sessions with domain authority and approval gates",
   "type": "commonjs",
   "bin": {