@mmnto/totem 1.18.2 → 1.19.0

package/dist/stage4-verifier.js

@@ -0,0 +1,355 @@
+/**
+ * ADR-091 Stage 4 Verify-Against-Codebase verifier (mmnto-ai/totem#1682).
+ *
+ * Runs a compiled rule deterministically (zero LLM) against the consumer's
+ * existing codebase before promoting it to Active status. Catches the class
+ * of false positive that Layer 3 (ADR-088) cannot — Layer 3 verifies the
+ * pattern matches the lesson's authored `badExample` (internal consistency);
+ * Stage 4 verifies the pattern doesn't accidentally fire on legitimate code
+ * (global false-positive safety).
+ *
+ * Four outcomes per ADR-091 §"Stage 4: Verify-Against-Codebase":
+ *
+ *   - **No matches** (`outcome: 'no-matches'`) — the verifier ran, found zero
+ *     hits in the codebase. Caller sets `status: 'untested-against-codebase'`;
+ *     subsequent compile cycles in a populated repo can re-run Stage 4 and
+ *     promote.
+ *   - **Out-of-scope baseline match** (`outcome: 'out-of-scope'`) — the rule
+ *     fired on at least one file in the verification baseline (test files,
+ *     fixture directories, or files outside the rule's `fileGlobs` scope).
+ *     The pattern is over-broad. Caller archives the rule with
+ *     `reasonCode: 'stage4-out-of-scope-match'` and the offending paths.
+ *   - **In-scope `badExample`-shape match** (`outcome: 'in-scope-bad-example'`)
+ *     — the rule fired only on in-scope files AND every in-scope match line is
+ *     structurally equivalent to the rule's `badExample`. The rule fires on
+ *     real code in the exact authored shape. Caller sets `status: 'active'`
+ *     with `confidence: 'high'`.
+ *   - **Candidate Debt** (`outcome: 'candidate-debt'`) — the rule fired only
+ *     on in-scope files but at least one match line differs from the
+ *     `badExample` shape. The rule may be catching real debt, or producing
+ *     false positives the LLM-generated pattern overshoots into. Caller
+ *     accepts as `status: 'active'` and forces `severity: 'warning'` so it
+ *     never breaks CI on first run; `totem doctor` (mmnto-ai/totem#1685)
+ *     surfaces the candidate-debt sites for human confirmation.
+ *
+ * Bootstrap modes: T1 ships local-compile fully (the verifier runs against
+ * the consumer's working tree before `totem lesson compile` serializes the
+ * rule). Pack install→lint promotion lands in T3 (mmnto-ai/totem#1684).
+ * Consumer baseline overrides land in T2 (mmnto-ai/totem#1683). Perf
+ * optimizations (single-pass, file-tree caching, streaming short-circuit)
+ * land in T5 (mmnto-ai/totem#1686). T1 walks per-rule, no caching.
+ *
+ * Architecture: callback-based filesystem. The verifier accepts `listFiles`
+ * + `readFile` callbacks instead of touching `fs` directly so core stays
+ * orchestration-only. CLI implementations back the callbacks with `git
+ * ls-files` and `fs.readFile`; tests stub them with synthetic file maps.
+ */
+import { applyAstRulesToAdditions, applyRulesToAdditions } from './rule-engine.js';
+// ─── Default baseline ───────────────────────────────
+/**
+ * Glob shapes the test-contract scope classifier (mmnto-ai/totem#1626 /
+ * mmnto-ai/totem#1652) promotes-to-test-inclusive when emitting LLM scope.
+ * Stage 4 mirrors them as the default baseline so any rule that fires on a
+ * test or fixture file is treated as out-of-scope by default. T2
+ * (mmnto-ai/totem#1683) lets consumers `exclude` from this list when their
+ * project legitimately treats `tests/` as production.
+ */
+export const DEFAULT_BASELINE_GLOBS = [
+    '**/*.test.*',
+    '**/*.spec.*',
+    '**/__tests__/**',
+    '**/tests/**',
+    '**/__fixtures__/**',
+    '**/fixtures/**',
+];
+export function getDefaultBaseline() {
+    // T1: the default baseline is rule-independent (every rule gets the same
+    // test/fixture exclusion). T2 (mmnto-ai/totem#1683) introduces per-config
+    // `extend`/`exclude` overrides; the function signature accepts a rule
+    // parameter then so per-rule baseline derivation can layer on top.
+    return { excludeFileGlobs: DEFAULT_BASELINE_GLOBS };
+}
+// ─── Glob matching (matches rule-engine semantics) ─
+function matchesGlob(filePath, glob) {
+    // Normalize Windows backslashes to forward slashes — globs use forward
+    // slashes universally, repo paths come back from git-ls-files in either
+    // shape on Windows depending on core.autocrlf.
+    const normalized = filePath.replace(/\\/g, '/');
+    // Exact glob match — escape regex metacharacters except `*`, `?`, and
+    // brace groups, then expand `**` to `.*`, `*` to `[^/]*`, `?` to `.`.
+    if (glob.includes('*') || glob.includes('?') || glob.includes('{')) {
+        const regexPattern = globToRegex(glob);
+        return new RegExp(`^${regexPattern}$`).test(normalized);
+    }
+    // Literal filename match (e.g., "Dockerfile")
+    return normalized === glob || normalized.endsWith('/' + glob);
+}
+function globToRegex(glob) {
+    let result = '';
+    let i = 0;
+    while (i < glob.length) {
+        const ch = glob[i];
+        if (ch === '*') {
+            if (glob[i + 1] === '*') {
+                result += '.*';
+                i += 2;
+                // Consume trailing `/` if present so `**/foo` becomes `.*foo`
+                if (glob[i] === '/')
+                    i++;
+                continue;
+            }
+            result += '[^/]*';
+        }
+        else if (ch === '?') {
+            result += '[^/]';
+        }
+        else if (ch === '{') {
+            const end = glob.indexOf('}', i);
+            if (end === -1) {
+                result += '\\{';
+            }
+            else {
+                const alts = glob.slice(i + 1, end).split(',');
+                result += '(?:' + alts.map(escapeRegex).join('|') + ')';
+                i = end + 1;
+                continue;
+            }
+        }
+        else if ('.+()[]^$|\\'.includes(ch)) {
+            result += '\\' + ch;
+        }
+        else {
+            result += ch;
+        }
+        i++;
+    }
+    return result;
+}
+function escapeRegex(s) {
+    return s.replace(/[.+()[\]^$|\\*?{}]/g, '\\$&');
+}
+function fileMatchesAnyGlob(filePath, globs) {
+    return globs.some((g) => matchesGlob(filePath, g));
+}
+/**
+ * A file is "in scope" for Stage 4 verification when it matches the rule's
+ * declared `fileGlobs` (or has none, meaning the rule applies everywhere)
+ * AND is not in the baseline-excluded set. A baseline-excluded test file
+ * inside `**\/*.ts` scope counts as baseline, not in-scope, because the
+ * verifier's job is to detect over-broad firing — including on tests the
+ * rule is supposed to skip.
+ */
+function classifyFile(filePath, ruleFileGlobs, baseline) {
+    // Rule has explicit fileGlobs and this file doesn't match → baseline (out-of-scope).
+    if (ruleFileGlobs && ruleFileGlobs.length > 0) {
+        const positive = ruleFileGlobs.filter((g) => !g.startsWith('!'));
+        const negative = ruleFileGlobs.filter((g) => g.startsWith('!')).map((g) => g.slice(1));
+        const matchesPositive = positive.length === 0 || fileMatchesAnyGlob(filePath, positive);
+        const matchesNegative = fileMatchesAnyGlob(filePath, negative);
+        if (!matchesPositive || matchesNegative)
+            return 'baseline';
+    }
+    // File matches rule scope (or rule has no scope). Now check baseline overrides.
+    if (fileMatchesAnyGlob(filePath, baseline.excludeFileGlobs))
+        return 'baseline';
+    return 'in-scope';
+}
+// ─── Synthetic DiffAddition production ─────────────
+/**
+ * Convert raw file content into the `DiffAddition[]` shape the rule engine
+ * expects. One addition per line. `precedingLine` carries the prior line
+ * verbatim so suppression directives (`// totem-ignore-next-line`) work
+ * inside the verifier the same way they do in lint. `astContext` is left
+ * undefined — the engine treats undefined as "code", which is exactly the
+ * Stage 4 contract: detect over-broad firing on any source line, not just
+ * lines a Tree-sitter classifier labels as code.
+ */
+function fileToAdditions(file, content) {
+    // CR mmnto-ai/totem#1757 R3: don't synthesize a trailing blank line.
+    // `''.split(/\r?\n/)` returns `['']` and `'foo\n'.split(/\r?\n/)`
+    // returns `['foo', '']`, both of which would inject a non-existent
+    // blank addition. A pattern like `^$` (blank-line detector) would
+    // then falsely fire on every newline-terminated file in the
+    // codebase, flipping rules into out-of-scope or candidate-debt for
+    // the wrong reason.
+    if (content.length === 0)
+        return [];
+    const lines = content.split(/\r?\n/);
+    if (/\r?\n$/.test(content)) {
+        lines.pop();
+    }
+    const additions = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        additions.push({
+            file,
+            line,
+            lineNumber: i + 1,
+            precedingLine: i > 0 ? (lines[i - 1] ?? null) : null,
+        });
+    }
+    return additions;
+}
+// ─── Rule execution ────────────────────────────────
+const NOOP_LOGGER = { warn: () => undefined };
+function defaultRuleCtx() {
+    return {
+        logger: NOOP_LOGGER,
+        state: { hasWarnedShieldContext: false },
+    };
+}
+/**
+ * Run the rule against the entire codebase, with `fileGlobs` stripped so
+ * the rule fires on every file (in-scope AND baseline). Stage 4 partitions
+ * the resulting violations by file classification afterward. Without the
+ * strip, `applyRulesToAdditions` would skip baseline files internally and
+ * the verifier would see zero out-of-scope hits even when the pattern is
+ * obviously over-broad.
+ */
+async function runRuleAgainstAllFiles(rule, additions, ctx, workingDirectory) {
+    const ruleNoScope = { ...rule, fileGlobs: undefined };
+    if (rule.engine === 'regex' || !rule.engine) {
+        return applyRulesToAdditions(ctx, [ruleNoScope], [...additions]);
+    }
+    // ast / ast-grep — requires a working directory for file resolution.
+    // Fail loud when absent so Stage 4 cannot silently misclassify the run
+    // as `'no-matches'`. T1's CLI integration always passes a
+    // workingDirectory; tests that hit this path must pass one too.
+    // (CR mmnto-ai/totem#1757 R1 — earlier `return []` short-circuit
+    // hid the missing-input case as a clean result.)
+    if (!workingDirectory) {
+        const msg = `[Totem Error] Stage 4 verifier requires deps.workingDirectory for ${rule.engine} rules.`;
+        throw new Error(msg);
+    }
+    return applyAstRulesToAdditions(ctx, [ruleNoScope], [...additions], workingDirectory);
+}
+// ─── Structural equivalence ────────────────────────
+/**
+ * T1 uses byte-equal trimmed comparison: a violation line is `badExample`-
+ * shape iff `line.trim()` equals `badExample.trim()`. Stricter equivalence
+ * (full subtree match for ast-grep, normalized whitespace for regex) is
+ * deferred to T5 (mmnto-ai/totem#1686) when the perf-pass adds AST-aware
+ * comparison.
+ *
+ * `badExample` may carry multiple lines (Pipeline 3 reuses Bad snippets
+ * verbatim). The function compares against ANY trimmed line of the
+ * `badExample` block — a violation matches if the line equals any one of
+ * the badExample's component lines.
+ */
+function lineMatchesBadExample(line, badExample) {
+    if (badExample === undefined)
+        return false;
+    const trimmedLine = line.trim();
+    if (trimmedLine.length === 0)
+        return false;
+    for (const candidate of badExample.split(/\r?\n/)) {
+        if (candidate.trim() === trimmedLine)
+            return true;
+    }
+    return false;
+}
+// ─── Public API ────────────────────────────────────
+/**
+ * Run Stage 4 verification for a single compiled rule against the consumer's
+ * codebase. Caller decides what to do with the returned outcome:
+ *
+ *   - `'no-matches'`           → set rule.status = 'untested-against-codebase'
+ *   - `'out-of-scope'`         → archive rule with reasonCode 'stage4-out-of-scope-match'
+ *   - `'in-scope-bad-example'` → set rule.status = 'active', confidence = 'high'
+ *   - `'candidate-debt'`       → set rule.status = 'active', force severity = 'warning'
+ *
+ * The verifier itself does NOT mutate the rule. Mutation happens at the
+ * compileLesson integration site so the trace event and lifecycle field
+ * preservation remain centralized.
+ *
+ * For Pipeline 1 manual rules, the integration site bypasses Stage 4
+ * entirely — those rules are human-authored and Stage 4 is a safety net
+ * for LLM-generated patterns. The verifier itself is engine-agnostic and
+ * will run on any rule it's handed.
+ */
+export async function verifyAgainstCodebase(rule, baseline, deps) {
+    const files = await deps.listFiles();
+    const ctx = deps.ruleCtx ?? defaultRuleCtx();
+    // Build all additions across all files. T5 (mmnto-ai/totem#1686) will
+    // batch this across rules per compile cycle; T1 walks per-rule.
+    const additions = [];
+    for (const file of files) {
+        let content;
+        try {
+            content = await deps.readFile(file);
+        }
+        catch (err) {
+            // Fail loud per Tenet 4. The file showed up in listFiles() so its
+            // absence here is a real environment problem (race with deletion,
+            // permission change, broken symlink). The operator needs to see
+            // exactly which file failed; preserving `cause` keeps the original
+            // stack/context intact (CR mmnto-ai/totem#1757 R2 — the prior
+            // `${err.message}` concat flattened the original exception).
+            throw new Error(`Stage 4 verifier could not read ${file}.`, { cause: err });
+        }
+        additions.push(...fileToAdditions(file, content));
+    }
+    if (additions.length === 0) {
+        return {
+            outcome: 'no-matches',
+            baselineMatches: [],
+            inScopeMatches: [],
+            candidateDebtLines: [],
+        };
+    }
+    const violations = await runRuleAgainstAllFiles(rule, additions, ctx, deps.workingDirectory);
+    if (violations.length === 0) {
+        return {
+            outcome: 'no-matches',
+            baselineMatches: [],
+            inScopeMatches: [],
+            candidateDebtLines: [],
+        };
+    }
+    // Partition violations by file classification.
+    const baselineMatchSet = new Set();
+    const inScopeMatchSet = new Set();
+    const candidateDebtLines = [];
+    for (const violation of violations) {
+        const classification = classifyFile(violation.file, rule.fileGlobs, baseline);
+        if (classification === 'baseline') {
+            baselineMatchSet.add(violation.file);
+        }
+        else {
+            inScopeMatchSet.add(violation.file);
+            if (!lineMatchesBadExample(violation.line, rule.badExample)) {
+                candidateDebtLines.push(violation.line);
+            }
+        }
+    }
+    // Out-of-scope wins precedence over in-scope outcomes — even one baseline
+    // match means the pattern is over-broad and gets archived. ADR-091
+    // §"Stage 4: Verify-Against-Codebase" is explicit on this ordering.
+    if (baselineMatchSet.size > 0) {
+        return {
+            outcome: 'out-of-scope',
+            baselineMatches: [...baselineMatchSet].sort(),
+            inScopeMatches: [...inScopeMatchSet].sort(),
+            candidateDebtLines: [],
+        };
+    }
+    // All violations are in-scope. Distinguish bad-example shape from
+    // candidate debt by whether ANY violation line failed to match the
+    // badExample. A single mismatch flips the outcome to candidate-debt;
+    // the rule ships at warning severity until a human confirms the hits.
+    if (candidateDebtLines.length === 0) {
+        return {
+            outcome: 'in-scope-bad-example',
+            baselineMatches: [],
+            inScopeMatches: [...inScopeMatchSet].sort(),
+            candidateDebtLines: [],
+        };
+    }
+    return {
+        outcome: 'candidate-debt',
+        baselineMatches: [],
+        inScopeMatches: [...inScopeMatchSet].sort(),
+        candidateDebtLines,
+    };
+}
+//# sourceMappingURL=stage4-verifier.js.map

package/dist/stage4-verifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage4-verifier.js","sourceRoot":"","sources":["../src/stage4-verifier.ts"],"names":[],"mappings":"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"}

package/dist/stage4-verifier.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stage4-verifier.test.d.ts.map

package/dist/stage4-verifier.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stage4-verifier.test.d.ts","sourceRoot":"","sources":["../src/stage4-verifier.test.ts"],"names":[],"mappings":""}