vigiles 14.0.0 → 14.2.0

package/dist/rule-inventory.js

@@ -42,7 +42,7 @@ exports.buildRuleInventory = buildRuleInventory;
 // the DYNAMIC available-rule catalog — enumerate the rules the repo's linter
 // ACTUALLY has (spike: 702 for this repo vs ~23 here) and match prose against
 // THAT, own-repo/consented since it executes the linter. Do NOT keep growing this
-// by hand. See research/rule-compiler-multilang-design.md §0.
+// by hand. See research/rule-enforcer-multilang-design.md §0.
 exports.INTENT_MAP = [
     {
         intent: "no console.log / use the logger",
@@ -235,12 +235,93 @@ exports.INTENT_MAP = [
         rule: "no-only-tests/no-only-tests",
         configFix: '"no-only-tests/no-only-tests": "error"',
     },
+    // --- Ruff (Python) — the modern default (allow-list, like ESLint). These are
+    // the NET-NEW intents Pylint does NOT already cover (imports-inside-functions,
+    // annotations, logger.exception, print, import-sorting). The SHARED Python
+    // intents (bare-except, broad-except, mutable-default, wildcard, global,
+    // too-many-*, line-length, unused, f-strings, docstrings) stay with the Pylint
+    // entries below — one intent, one linter, so keyword disjointness holds (the
+    // `rule-routing-dogfood` invariant test) and prose never double-routes. Whether
+    // shared Python NL prose should later PREFER Ruff over Pylint is an open
+    // ownership decision, deferred. ROUTE-ONLY like Pylint: config-state
+    // (buildRuleInventory) stays gated to eslint — Ruff's select/ignore config shape
+    // differs from the eslint rules-map, so the eslint-shaped check would MISLABEL;
+    // accurate Ruff enabled-state is the catalog/ConfigProbe follow-up
+    // (rule-enforcer-multilang-design.md §3). Every CODE was verified to exist
+    // against ruff 0.15.8 (`ruff rule <CODE>`); keywords are Python-diagnostic (no
+    // cross-language phrase that would mis-attribute the linter in a JS/TS doc).
+    {
+        intent: "no imports inside functions (Python)",
+        linter: "ruff",
+        keywords: [
+            "PLC0415",
+            "inline import",
+            "inline imports",
+            "imports inside functions",
+            "import inside a function",
+            "import inside functions",
+        ],
+        rule: "PLC0415",
+        configFix: 'add "PLC0415" (import-outside-top-level) to [tool.ruff.lint] select',
+    },
+    {
+        // E402 flags module-level code BEFORE the imports; the "no imports inside
+        // functions" reading is PLC0415 above. Code-only keyword ON PURPOSE: the
+        // phrase "imports at the top" is ambiguous between the two AND collides with
+        // ESLint `import/first` in a JS doc, so it is NOT a keyword here (a missing
+        // route is recoverable; a wrong "enforceable" claim is not).
+        intent: "no module code before imports (Python)",
+        linter: "ruff",
+        keywords: ["E402"],
+        rule: "E402",
+        configFix: 'add "E402" (module-import-not-at-top-of-file) to [tool.ruff.lint] select',
+    },
+    {
+        intent: "require argument type annotations (Python)",
+        linter: "ruff",
+        keywords: [
+            "ANN001",
+            "type hints required",
+            "type hints are required",
+            "require type hints",
+        ],
+        rule: "ANN001",
+        configFix: 'add "ANN001" (missing-type-function-argument) to [tool.ruff.lint] select',
+    },
+    {
+        intent: "require return type annotations (Python)",
+        linter: "ruff",
+        keywords: ["ANN201"],
+        rule: "ANN201",
+        configFix: 'add "ANN201" (missing-return-type-undocumented-public-function) to [tool.ruff.lint] select',
+    },
+    {
+        intent: "use logger.exception in handlers (Python)",
+        linter: "ruff",
+        keywords: ["TRY400", "logger.exception", "logging.exception"],
+        rule: "TRY400",
+        configFix: 'add "TRY400" (error-instead-of-exception) to [tool.ruff.lint] select',
+    },
+    {
+        intent: "no print statements — use logging (Python)",
+        linter: "ruff",
+        keywords: ["T201", "print statement", "print statements"],
+        rule: "T201",
+        configFix: 'add "T201" (print) to [tool.ruff.lint] select',
+    },
+    {
+        intent: "keep imports sorted (Python)",
+        linter: "ruff",
+        keywords: ["I001", "sorted imports", "isort"],
+        rule: "I001",
+        configFix: 'add "I001" (unsorted-imports) to [tool.ruff.lint] select',
+    },
     // --- Pylint (Python) — routing basics. These feed classify() (routing → reuse);
     // buildRuleInventory is gated to eslint (see below) because pylint is
     // ON-BY-DEFAULT (deny-list), so the eslint-shaped config-state check would
     // MISLABEL it (a symbol in `disable=` reads as "in-config", an absent one as
     // "enable it"). Accurate pylint enabled-state needs the inverted-polarity
-    // ConfigProbe (research/rule-compiler-multilang-design.md §3), deferred —
+    // ConfigProbe (research/rule-enforcer-multilang-design.md §3), deferred —
     // classify() needs NO enabled-state, so pylint prose still routes honestly.
     // Keywords are code-shaped symbols + Python-UNAMBIGUOUS compounds (singular AND
     // plural, since matchesWholeToken is boundary-exact); bare ambiguous words
@@ -351,6 +432,74 @@ exports.INTENT_MAP = [
         rule: "unused-import",
         configFix: "pylint enables unused-import (W0611) by default; keep it out of the disable list",
     },
+    // --- Clippy (Rust) — routing basics (backlog #3: the 0%→ win for Rust
+    // rulebooks; codex/ghostty routed 0% purely because clippy was unmapped, yet
+    // codex literally says "avoid patterns that require `panic!`, `unreachable!`,
+    // or `.unwrap()`" and "make `match` exhaustive … avoid wildcard arms"). Every
+    // lint is a real clippy restriction lint. Route-only, like ruff/pylint —
+    // config-state stays eslint-gated (L639) because clippy's lint levels live in
+    // Cargo.toml `[lints.clippy]` / crate attrs, a different shape (accurate
+    // enabled-state is the ConfigProbe follow-up, rule-enforcer-multilang-design
+    // §3). Keywords are Rust-UNAMBIGUOUS — macro `!` forms, `.method` call forms,
+    // `clippy::` symbols, and Rust-only compounds ("wildcard arm(s)", NOT bare
+    // "wildcard" which collides with pylint `wildcard-import`) — so a Python/JS
+    // doc never mis-attributes clippy (the cross-language-FP test guards this).
+    {
+        intent: "no .unwrap() (Rust)",
+        linter: "clippy",
+        keywords: ["clippy::unwrap_used", "unwrap_used", ".unwrap"],
+        rule: "clippy::unwrap_used",
+        configFix: 'set unwrap_used = "warn" in [lints.clippy] (Cargo.toml), or #![warn(clippy::unwrap_used)]',
+    },
+    {
+        intent: "no .expect() (Rust)",
+        linter: "clippy",
+        keywords: ["clippy::expect_used", "expect_used", ".expect"],
+        rule: "clippy::expect_used",
+        configFix: 'set expect_used = "warn" in [lints.clippy] (Cargo.toml), or #![warn(clippy::expect_used)]',
+    },
+    {
+        intent: "no panic! (Rust)",
+        linter: "clippy",
+        keywords: ["clippy::panic", "panic!"],
+        rule: "clippy::panic",
+        configFix: 'set panic = "warn" in [lints.clippy] (Cargo.toml), or #![warn(clippy::panic)]',
+    },
+    {
+        intent: "no unreachable! (Rust)",
+        linter: "clippy",
+        keywords: ["clippy::unreachable", "unreachable!"],
+        rule: "clippy::unreachable",
+        configFix: 'set unreachable = "warn" in [lints.clippy] (Cargo.toml), or #![warn(clippy::unreachable)]',
+    },
+    {
+        intent: "no todo! (Rust)",
+        linter: "clippy",
+        keywords: ["clippy::todo", "todo!"],
+        rule: "clippy::todo",
+        configFix: 'set todo = "warn" in [lints.clippy] (Cargo.toml), or #![warn(clippy::todo)]',
+    },
+    {
+        intent: "no dbg! (Rust)",
+        linter: "clippy",
+        keywords: ["clippy::dbg_macro", "dbg!"],
+        rule: "clippy::dbg_macro",
+        configFix: 'set dbg_macro = "warn" in [lints.clippy] (Cargo.toml), or #![warn(clippy::dbg_macro)]',
+    },
+    {
+        intent: "exhaustive match — no wildcard enum arm (Rust)",
+        linter: "clippy",
+        keywords: [
+            "clippy::wildcard_enum_match_arm",
+            "wildcard_enum_match_arm",
+            "wildcard match arm",
+            "wildcard match arms",
+            "wildcard arm",
+            "wildcard arms",
+        ],
+        rule: "clippy::wildcard_enum_match_arm",
+        configFix: 'set wildcard_enum_match_arm = "warn" in [lints.clippy] (Cargo.toml), or #![warn(clippy::wildcard_enum_match_arm)]',
+    },
 ];
 /** Escape a keyword for use inside a RegExp. */
 function escapeRe(s) {

package/dist/rule-routing.d.ts

@@ -1,8 +1,61 @@
+/**
+ * rule-routing.ts — the deterministic (no-model) State-B routing PREVIEW.
+ *
+ * `rule-inventory.ts` answers a narrow question ("which prose lines name an
+ * off-the-shelf lint rule, and is it enabled?"). This goes one honest step
+ * further: it SEGMENTS the whole instruction file into atomic rules
+ * ({@link segmentInstructions}) and routes each one into the class that a real
+ * enforcement path would take — WITHOUT running a model:
+ *
+ *   reuse    → the rule text names an off-the-shelf lint rule ({@link INTENT_MAP})
+ *              → mechanism: flip one config line. The "narrow list we compile
+ *              very well" — everything else is honestly labelled, not force-fit.
+ *   hook     → an ACTION rule a linter can't see (git push, rm -rf, "before you
+ *              commit") → mechanism: a pre-commit / PreToolUse hook.
+ *   meta     → an agent-instruction, not a code rule ("read X first", "tell the
+ *              user", "you are …") → mechanism: stays prose. Split out of
+ *              `unrouted` so it never reads as "compilable but hard" (it isn't).
+ *   semantic → a judgment call ("readable", "single responsibility") no checker
+ *              can honestly decide → mechanism: stays prose.
+ *   unrouted → looks like a code rule but matched no off-the-shelf rule: HARD to
+ *              codify → mechanism `synthesize`: the opt-in SYNTHESIS tier (a
+ *              skill on your subscription) MIGHT write a custom checker, gated —
+ *              but it is NOT guaranteed (the gate may abstain). This is the
+ *              bucket audit must present clearly as "hard", never as done.
+ *
+ * NB "compile" is NOT used here — `vigiles compile` is the unrelated spec→markdown
+ * verb. Synthesis is its own opt-in tier; the mechanism value is `synthesize`.
+ *
+ * HONESTY BY CONSTRUCTION: the deterministic tier NEVER claims a rule is
+ * "synthesizable" — deciding that a custom rule can be written (and gating it)
+ * is exactly the work the opt-in model tier does. `unrouted` means "hard — a
+ * synthesis skill may try", never a promise; `meta`/`semantic` mean "not an
+ * enforceable code rule at all" (a different, honest kind of no).
+ *
+ * Pure, deterministic, dependency-free. Reuses `rule-inventory`'s hardened
+ * whole-token matcher + `INTENT_MAP`, and `segment`'s Tier-A segmenter.
+ */
+import { type SkippedBullet } from "./segment.js";
 import { type LinterName } from "./rule-inventory.js";
 import type { RuleCatalog } from "./core/rule-catalog.js";
 /** How a routed rule would be enforced (a MECHANISM ladder, not a 1-10 score). */
 export type RuleCategory = "reuse" | "hook" | "meta" | "semantic" | "unrouted";
 export type RuleMechanism = "config-line" | "hook" | "prose" | "synthesize";
+/**
+ * The user-facing presentation of each routing category — its glyph + lane
+ * label. The SINGLE SOURCE the terminal summary reads (and the HTML report
+ * mirrors), so the category-name → lane-label mapping lives in one place.
+ *
+ * NB the type name `unrouted` is a WIRE value (it appears in the versioned
+ * `AuditReport` JSON), which is why it isn't renamed to its lane label `custom`;
+ * this table is where the human-facing name is resolved. The category meanings
+ * are documented in the file header; the mapping is tabled in
+ * `research/rule-enforcer-design.md` §4.
+ */
+export declare const LANE_META: Record<RuleCategory, {
+    readonly glyph: string;
+    readonly label: string;
+}>;
 /** One segmented, deterministically-routed rule with provenance. */
 export interface RoutedRule {
     /** Normalized atomic rule text (from the segmenter). */
@@ -29,10 +82,19 @@ export interface RoutedRule {
     readonly source?: "marker" | "heuristic";
 }
 export interface RuleRouting {
-    /** How many atomic rules were routed (after the confidence filter). */
+    /** How many CONFIDENT atomic rules were routed (high or rescued). */
     readonly segmented: number;
     readonly counts: Record<RuleCategory, number>;
+    /** The CONFIDENT tier — cleared the precision bar; these are the routed rules. */
     readonly rules: readonly RoutedRule[];
+    /** The POSSIBLE tier — rule-ish bullets (medium confidence) that did NOT clear
+     * the bar, still classified so a human can review + promote them. Detection is
+     * precision-first, so this is where a declarative rule ("Every X must Y") that
+     * the confident tier misses shows up. See `research/rule-enforcer-design.md` §2. */
+    readonly possible: readonly RoutedRule[];
+    /** Bullets the segmenter decided were NOT rules, each with a reason — so the
+     * report is honest about what it set aside (§3). */
+    readonly skipped: readonly SkippedBullet[];
 }
 export interface RouteOptions {
     /**