@agentbridge1/cli 0.0.10 → 0.0.11

package/dist/proof-parser.js

@@ -6,15 +6,7 @@
 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"],
-};
+const domain_keywords_1 = require("./domain-keywords");
 // Vitest / Jest summary: "12 passed", "Tests: 5 passed", "5 failed"
 const PASSED_RE = /(\d+)\s+passed/i;
 const FAILED_RE = /(\d+)\s+failed/i;
@@ -41,24 +33,30 @@ function detectRunner(stdout) {
 }
 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)))
+    const text = testNames.join(" ");
+    for (const domain of Object.keys(domain_keywords_1.DOMAIN_KEYWORDS)) {
+        if ((0, domain_keywords_1.matchesDomainKeywords)(text, domain))
             found.add(domain);
     }
     return [...found];
 }
+function normalizeCoverageDomain(domain) {
+    const lower = domain.trim().toLowerCase();
+    if (lower in domain_keywords_1.DOMAIN_KEYWORDS)
+        return lower;
+    if (lower === "db")
+        return "database";
+    if (lower === "payment")
+        return "payments";
+    if (lower === "test")
+        return "tests";
+    return null;
+}
 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));
+    const canonical = normalizeCoverageDomain(domain);
+    if (!canonical)
+        return false;
+    return domainKeywordsInPassed.includes(canonical);
 }
 function parseProofOutput(proofRun) {
     const stdout = proofRun.stdoutExcerpt ?? "";
@@ -106,12 +104,13 @@ function parseProofOutput(proofRun) {
 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 canonicalDomain = domain ? normalizeCoverageDomain(domain) : null;
+    if (canonicalDomain && parsed.passed > 0) {
+        if (parsed.has_domain_coverage(canonicalDomain)) {
             const covering = parsed.domain_keywords_in_passed.join(", ");
             return `${base} Tests covering: ${covering}.`;
         }
-        const keywords = DOMAIN_TEST_KEYWORDS[domain]?.slice(0, 3).join(", ") ?? domain;
+        const keywords = domain_keywords_1.DOMAIN_KEYWORDS[canonicalDomain]?.slice(0, 3).join(", ") ?? canonicalDomain;
         return `${base} No passed tests mention ${keywords} — domain coverage unconfirmed.`;
     }
     return base;

package/dist/test-runner.js

@@ -10,6 +10,96 @@ exports.analyzeCoherence = analyzeCoherence;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_child_process_1 = require("node:child_process");
+function detectRunnerFromCommand(command) {
+    const lower = command.toLowerCase();
+    if (/\bvitest\b/.test(lower))
+        return "vitest";
+    if (/\bjest\b/.test(lower))
+        return "jest";
+    if (/\bpytest\b/.test(lower))
+        return "pytest";
+    return "unknown";
+}
+function quoteArg(value) {
+    return `"${value.replaceAll(`"`, `\\"`)}"`;
+}
+function classifyFailure(stdout, stderr, timedOut) {
+    if (timedOut)
+        return "timeout";
+    const combined = `${stdout}\n${stderr}`.toLowerCase();
+    if (combined.includes("unknown option") ||
+        combined.includes("unknown argument") ||
+        combined.includes("unrecognized option") ||
+        combined.includes("cacerror")) {
+        return "command_invalid";
+    }
+    if (combined.includes("command not found") ||
+        combined.includes("enoent") ||
+        combined.includes("cannot find module") ||
+        combined.includes("is not recognized as an internal or external command")) {
+        return "tooling_missing";
+    }
+    if (extractFailedTestNames(`${stdout}\n${stderr}`).length > 0) {
+        return "test_failures";
+    }
+    if (combined.includes("failed to load config") ||
+        combined.includes("syntaxerror") ||
+        combined.includes("typeerror") ||
+        combined.includes("referenceerror")) {
+        return "runtime_error";
+    }
+    return "test_failures";
+}
+async function runSingleCommand(command, options) {
+    const started = Date.now();
+    return new Promise((resolveResult) => {
+        const child = (0, node_child_process_1.spawn)(command, {
+            shell: true,
+            cwd: options.cwd,
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let didTimeout = false;
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        const timer = setTimeout(() => {
+            didTimeout = true;
+            child.kill("SIGTERM");
+            const durationMs = Date.now() - started;
+            resolveResult({
+                command,
+                passed: false,
+                stdout,
+                stderr: `${stderr}\nTimed out after ${options.timeoutMs}ms`,
+                durationMs,
+                timedOut: true,
+                failureType: "timeout",
+            });
+        }, options.timeoutMs);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (didTimeout)
+                return; // already resolved
+            const durationMs = Date.now() - started;
+            const passed = code === 0;
+            resolveResult({
+                command,
+                passed,
+                stdout,
+                stderr,
+                durationMs,
+                timedOut: false,
+                failureType: passed ? undefined : classifyFailure(stdout, stderr, false),
+            });
+        });
+    });
+}
 /**
  * Detect the appropriate test command for the project rooted at `cwd`.
  * Checks config override first, then language-specific conventions.
@@ -75,16 +165,25 @@ function detectTestCommand(cwd = process.cwd()) {
 function buildScopedCommand(base, relatedFiles) {
     if (!relatedFiles.length)
         return base;
-    // vitest / jest both support --testPathPattern (regex)
-    if (/vitest|jest/.test(base)) {
+    const runner = detectRunnerFromCommand(base);
+    // Jest supports --testPathPattern (regex)
+    if (runner === "jest") {
         // Build a pattern that matches the test files corresponding to the changed source files.
         // e.g. "src/foo.ts" → look for "src/foo" anywhere in test paths.
         const stems = relatedFiles.map((f) => f.replace(/\.[^/.]+$/, "").replace(/\//g, "\\/"));
         const pattern = stems.join("|");
         return `${base} --testPathPattern="${pattern}"`;
     }
+    // Vitest supports positional filters; avoid jest-only --testPathPattern.
+    if (runner === "vitest") {
+        const stems = relatedFiles.map((f) => f.replace(/\.[^/.]+$/, "").replaceAll("\\", "/"));
+        const unique = [...new Set(stems)].filter(Boolean).slice(0, 10);
+        if (!unique.length)
+            return base;
+        return `${base} ${unique.map(quoteArg).join(" ")}`;
+    }
     // pytest supports positional file/dir args (best effort)
-    if (base.startsWith("pytest")) {
+    if (runner === "pytest") {
         const pyFiles = relatedFiles
             .map((f) => f.replace(/\.ts$/, ".py"))
             .filter((f) => (0, node_fs_1.existsSync)(f));
@@ -125,52 +224,41 @@ async function runDetectedTests(optionsOrTimeout = {}) {
     const baseCommand = detectTestCommand(cwd);
     if (!baseCommand)
         return null;
-    const command = options.relatedFiles?.length
+    const scopedCommand = options.relatedFiles?.length
         ? buildScopedCommand(baseCommand, options.relatedFiles)
         : baseCommand;
-    const started = Date.now();
-    return new Promise((resolveResult) => {
-        const child = (0, node_child_process_1.spawn)(command, {
-            shell: true,
-            cwd,
-            env: process.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        let didTimeout = false;
-        child.stdout?.on("data", (chunk) => {
-            stdout += chunk.toString();
+    const scopedResult = await runSingleCommand(scopedCommand, { cwd, timeoutMs });
+    const attempts = [
+        {
+            command: scopedResult.command,
+            passed: scopedResult.passed,
+            durationMs: scopedResult.durationMs,
+            timedOut: Boolean(scopedResult.timedOut),
+            failureType: scopedResult.failureType,
+        },
+    ];
+    if (scopedCommand !== baseCommand &&
+        !scopedResult.passed &&
+        (scopedResult.failureType === "command_invalid" || scopedResult.failureType === "tooling_missing")) {
+        const fallbackResult = await runSingleCommand(baseCommand, { cwd, timeoutMs });
+        attempts.push({
+            command: fallbackResult.command,
+            passed: fallbackResult.passed,
+            durationMs: fallbackResult.durationMs,
+            timedOut: Boolean(fallbackResult.timedOut),
+            failureType: fallbackResult.failureType,
         });
-        child.stderr?.on("data", (chunk) => {
-            stderr += chunk.toString();
-        });
-        const timer = setTimeout(() => {
-            didTimeout = true;
-            child.kill("SIGTERM");
-            resolveResult({
-                command,
-                passed: false,
-                stdout,
-                stderr: `${stderr}\nTimed out after ${timeoutMs}ms`,
-                durationMs: Date.now() - started,
-                timedOut: true,
-            });
-        }, timeoutMs);
-        child.on("close", (code) => {
-            clearTimeout(timer);
-            if (didTimeout)
-                return; // already resolved
-            resolveResult({
-                command,
-                passed: code === 0,
-                stdout,
-                stderr,
-                durationMs: Date.now() - started,
-                timedOut: false,
-            });
-        });
-    });
+        return {
+            ...fallbackResult,
+            attempts,
+            fallbackUsed: true,
+        };
+    }
+    return {
+        ...scopedResult,
+        attempts,
+        fallbackUsed: false,
+    };
 }
 /** Common English stop words to strip from intent before keyword extraction. */
 const STOP_WORDS = new Set([

package/package.json

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