@agentbridge1/cli 0.0.7 → 0.0.9

package/dist/test-runner.js

@@ -1,44 +1,152 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectTestCommand = detectTestCommand;
+exports.buildScopedCommand = buildScopedCommand;
+exports.extractFailedTestNames = extractFailedTestNames;
 exports.runDetectedTests = runDetectedTests;
+exports.extractIntentKeywords = extractIntentKeywords;
+exports.tokenizePath = tokenizePath;
+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");
+/**
+ * Detect the appropriate test command for the project rooted at `cwd`.
+ * Checks config override first, then language-specific conventions.
+ */
 function detectTestCommand(cwd = process.cwd()) {
+    // 1. Check .agentbridge.json for an explicit verify.command override
+    const abConfigPath = (0, node_path_1.resolve)(cwd, ".agentbridge.json");
+    if ((0, node_fs_1.existsSync)(abConfigPath)) {
+        try {
+            const cfg = JSON.parse((0, node_fs_1.readFileSync)(abConfigPath, "utf8"));
+            if (cfg.verify?.command)
+                return cfg.verify.command;
+        }
+        catch {
+            // malformed config — fall through
+        }
+    }
+    // 2. Node / npm — prefer test:unit for speed
     const packageJsonPath = (0, node_path_1.resolve)(cwd, "package.json");
-    if (!(0, node_fs_1.existsSync)(packageJsonPath))
-        return null;
-    const pkg = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
-    if (!pkg.scripts)
-        return null;
-    if (pkg.scripts["test:unit"])
-        return "npm run test:unit";
-    if (pkg.scripts.test)
-        return "npm run test";
+    if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+            if (pkg.scripts?.["test:unit"])
+                return "npm run test:unit";
+            if (pkg.scripts?.["test"])
+                return "npm run test";
+        }
+        catch {
+            // malformed package.json — fall through
+        }
+    }
+    // 3. Python
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, "pytest.ini")) || (0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, "pyproject.toml"))) {
+        return "pytest";
+    }
+    // 4. Rust
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, "Cargo.toml"))) {
+        return "cargo test";
+    }
+    // 5. Go
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, "go.mod"))) {
+        return "go test ./...";
+    }
+    // 6. Makefile with a `test` target
+    const makefilePath = (0, node_path_1.resolve)(cwd, "Makefile");
+    if ((0, node_fs_1.existsSync)(makefilePath)) {
+        try {
+            const contents = (0, node_fs_1.readFileSync)(makefilePath, "utf8");
+            if (/^test:/m.test(contents))
+                return "make test";
+        }
+        catch {
+            // unreadable Makefile — fall through
+        }
+    }
     return null;
 }
-async function runDetectedTests(timeoutMs = 5 * 60 * 1000) {
-    const command = detectTestCommand();
-    if (!command)
+/**
+ * Build a scoped version of the base command that only runs tests related to
+ * the provided files. Falls back to the full command if scoping is not
+ * supported for the detected runner.
+ */
+function buildScopedCommand(base, relatedFiles) {
+    if (!relatedFiles.length)
+        return base;
+    // vitest / jest both support --testPathPattern (regex)
+    if (/vitest|jest/.test(base)) {
+        // 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}"`;
+    }
+    // pytest supports positional file/dir args (best effort)
+    if (base.startsWith("pytest")) {
+        const pyFiles = relatedFiles
+            .map((f) => f.replace(/\.ts$/, ".py"))
+            .filter((f) => (0, node_fs_1.existsSync)(f));
+        if (pyFiles.length)
+            return `${base} ${pyFiles.join(" ")}`;
+    }
+    // Everything else: full run
+    return base;
+}
+/**
+ * Extract failed test names from stdout/stderr output of vitest, jest, or pytest.
+ */
+function extractFailedTestNames(output) {
+    const lines = [];
+    for (const line of output.split("\n")) {
+        const trimmed = line.trim();
+        // vitest / jest: lines starting with × or ✗ or containing "● " (jest describe block)
+        if (/^[×✗]/.test(trimmed) || /^\s*●\s+/.test(line)) {
+            lines.push(trimmed.replace(/^[×✗●\s]+/, "").trim());
+            continue;
+        }
+        // pytest: lines like "FAILED src/foo_test.py::test_name"
+        if (/^FAILED\s+/.test(trimmed)) {
+            lines.push(trimmed.replace(/^FAILED\s+/, "").trim());
+        }
+    }
+    return [...new Set(lines)].filter(Boolean).slice(0, 10);
+}
+/**
+ * Run the detected (or configured) test suite and return the result.
+ * Returns null if no test command could be detected.
+ */
+async function runDetectedTests(optionsOrTimeout = {}) {
+    // Accept the legacy `timeoutMs` number signature for backwards compatibility.
+    const options = typeof optionsOrTimeout === "number" ? { timeoutMs: optionsOrTimeout } : optionsOrTimeout;
+    const cwd = options.cwd ?? process.cwd();
+    const timeoutMs = options.timeoutMs ?? 5 * 60 * 1000;
+    const baseCommand = detectTestCommand(cwd);
+    if (!baseCommand)
         return null;
+    const command = 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: process.cwd(),
+            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 timeout = setTimeout(() => {
+        const timer = setTimeout(() => {
+            didTimeout = true;
             child.kill("SIGTERM");
             resolveResult({
                 command,
@@ -46,17 +154,95 @@ async function runDetectedTests(timeoutMs = 5 * 60 * 1000) {
                 stdout,
                 stderr: `${stderr}\nTimed out after ${timeoutMs}ms`,
                 durationMs: Date.now() - started,
+                timedOut: true,
             });
         }, timeoutMs);
         child.on("close", (code) => {
-            clearTimeout(timeout);
+            clearTimeout(timer);
+            if (didTimeout)
+                return; // already resolved
             resolveResult({
                 command,
                 passed: code === 0,
                 stdout,
                 stderr,
                 durationMs: Date.now() - started,
+                timedOut: false,
             });
         });
     });
 }
+/** Common English stop words to strip from intent before keyword extraction. */
+const STOP_WORDS = new Set([
+    "a", "an", "the", "and", "or", "of", "to", "in", "for", "on", "with",
+    "at", "by", "from", "as", "is", "was", "are", "were", "be", "been",
+    "it", "this", "that", "these", "those", "we", "i", "you", "they",
+    "add", "fix", "update", "change", "make", "get", "set", "use",
+    "all", "some", "any", "new", "old", "via", "into", "also", "should",
+]);
+/**
+ * Extract meaningful tokens from an intent string.
+ * Splits on non-alphanumeric characters and removes stop words.
+ */
+function extractIntentKeywords(intent) {
+    return intent
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
+}
+/**
+ * Extract tokens from a file path (useful for overlap scoring).
+ * e.g. "src/middleware/userAuth.ts" → ["src","middleware","userauth","ts"]
+ */
+function tokenizePath(filePath) {
+    return filePath
+        .toLowerCase()
+        .split(/[/\\._\-]+/)
+        .filter((t) => t.length >= 2);
+}
+/**
+ * Analyse whether the changed files are coherent with the declared intent.
+ * Returns a CoherenceResult with a verdict and list of suspicious files.
+ *
+ * Does NOT require an LLM — purely keyword/token overlap heuristics.
+ */
+function analyzeCoherence(ctx) {
+    const { intent, changedFiles } = ctx;
+    if (!intent || intent.trim().length === 0) {
+        return {
+            score: 0,
+            suspiciousFiles: [],
+            intentKeywords: [],
+            verdict: "unknown",
+        };
+    }
+    const intentKeywords = extractIntentKeywords(intent);
+    if (intentKeywords.length === 0) {
+        return {
+            score: 0,
+            suspiciousFiles: [],
+            intentKeywords: [],
+            verdict: "unknown",
+        };
+    }
+    if (changedFiles.length === 0) {
+        return {
+            score: 1,
+            suspiciousFiles: [],
+            intentKeywords,
+            verdict: "coherent",
+        };
+    }
+    const suspiciousFiles = [];
+    for (const file of changedFiles) {
+        const pathTokens = tokenizePath(file);
+        const hasOverlap = intentKeywords.some((kw) => pathTokens.some((pt) => pt.includes(kw) || kw.includes(pt)));
+        if (!hasOverlap) {
+            suspiciousFiles.push(file);
+        }
+    }
+    const score = (changedFiles.length - suspiciousFiles.length) / changedFiles.length;
+    const driftThreshold = 0.4;
+    const verdict = suspiciousFiles.length / changedFiles.length > driftThreshold ? "drift" : "coherent";
+    return { score, suspiciousFiles, intentKeywords, verdict };
+}

package/package.json

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