vigiles 13.0.0 → 14.0.0

package/dist/rule-inventory.js

@@ -37,6 +37,12 @@ exports.buildRuleInventory = buildRuleInventory;
  * ESLint-only today — Ruff/Clippy/Pylint/RuboCop/Stylelint entries append here
  * with their own `linter` + rule-name keywords, no code change.
  */
+// SCOPE (2026-07-14): this hand-curated list is a small high-precision FAST-PATH
+// (alias enrichment for the most common rules), NOT the strategy. The strategy is
+// 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.
 exports.INTENT_MAP = [
     {
         intent: "no console.log / use the logger",
@@ -196,6 +202,155 @@ exports.INTENT_MAP = [
         rule: "no-warning-comments",
         configFix: '"no-warning-comments": ["error", {"terms": ["todo", "fixme"], "location": "anywhere"}]',
     },
+    // Grounded in the OSS-corpus sweep — rules real AGENTS.md files actually NAME
+    // (cloudflare/workers-sdk names all three inline). Keyword set is rule-name /
+    // code-shaped only, so it fires when the doc names the rule, never on prose.
+    {
+        intent: "require curly braces for control flow",
+        linter: "eslint",
+        keywords: ["curly", "curly braces"],
+        rule: "curly",
+        configFix: '"curly": ["error", "all"]',
+    },
+    {
+        intent: "use import type for type-only imports",
+        linter: "eslint",
+        keywords: [
+            "consistent-type-imports",
+            "@typescript-eslint/consistent-type-imports",
+        ],
+        rule: "@typescript-eslint/consistent-type-imports",
+        configFix: '"@typescript-eslint/consistent-type-imports": "error"',
+    },
+    {
+        intent: "no focused / .only tests committed",
+        linter: "eslint",
+        keywords: [
+            "no-only-tests",
+            "no-focused-tests",
+            "describe.only",
+            "it.only",
+            "test.only",
+        ],
+        rule: "no-only-tests/no-only-tests",
+        configFix: '"no-only-tests/no-only-tests": "error"',
+    },
+    // --- 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 —
+    // 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
+    // (`snake_case` — Rust/Ruby too, `import *` — JS `import * as`, "unused imports"
+    // — collides with eslint) are deliberately EXCLUDED to avoid cross-language FPs.
+    {
+        intent: "no bare except (Python)",
+        linter: "pylint",
+        keywords: ["bare-except", "bare except", "W0702"],
+        rule: "bare-except",
+        configFix: "pylint enables bare-except (W0702) by default; keep it out of the disable list",
+    },
+    {
+        intent: "no broad exception catch (Python)",
+        linter: "pylint",
+        keywords: [
+            "broad-exception-caught",
+            "broad except",
+            "broad exception",
+            "W0718",
+        ],
+        rule: "broad-exception-caught",
+        configFix: "pylint enables broad-exception-caught (W0718) by default; keep it out of the disable list",
+    },
+    {
+        intent: "require docstrings (Python)",
+        linter: "pylint",
+        // Bare "docstring"/"docstrings" removed — it over-fires on docstring
+        // CONTENT/STYLE rules (the dogfood caught langchain's "docstring warnings" /
+        // "backticks in docstrings"). Presence ("add docstrings", "docstrings for
+        // each") is handled by the PATTERN_RULE_MAP docstring-presence pattern in
+        // rule-routing.ts; only the rule SYMBOL matches here.
+        keywords: ["missing-docstring", "missing-function-docstring", "C0116"],
+        rule: "missing-function-docstring",
+        configFix: "pylint enables missing-function-docstring (C0116) by default; keep it out of the disable list",
+    },
+    {
+        intent: "no mutable default arguments (Python)",
+        linter: "pylint",
+        keywords: [
+            "dangerous-default-value",
+            "mutable default",
+            "mutable default argument",
+            "mutable default arguments",
+            "W0102",
+        ],
+        rule: "dangerous-default-value",
+        configFix: "pylint enables dangerous-default-value (W0102) by default; keep it out of the disable list",
+    },
+    {
+        intent: "prefer f-strings (Python)",
+        linter: "pylint",
+        keywords: ["f-string", "f-strings", "consider-using-f-string", "C0209"],
+        rule: "consider-using-f-string",
+        configFix: "pylint enables consider-using-f-string (C0209) by default; keep it out of the disable list",
+    },
+    {
+        intent: "consistent naming (Python)",
+        linter: "pylint",
+        keywords: ["invalid-name", "C0103"],
+        rule: "invalid-name",
+        configFix: "pylint enables invalid-name (C0103) by default; set naming-style in [tool.pylint], keep it out of disable",
+    },
+    {
+        intent: "limit function arguments (Python)",
+        linter: "pylint",
+        keywords: ["too-many-arguments", "R0913"],
+        rule: "too-many-arguments",
+        configFix: "pylint enables too-many-arguments (R0913) by default; set max-args in [tool.pylint]",
+    },
+    {
+        intent: "limit function length (Python)",
+        linter: "pylint",
+        keywords: ["too-many-statements", "R0915"],
+        rule: "too-many-statements",
+        configFix: "pylint enables too-many-statements (R0915) by default; set max-statements in [tool.pylint]",
+    },
+    {
+        intent: "no wildcard imports (Python)",
+        linter: "pylint",
+        keywords: [
+            "wildcard-import",
+            "wildcard import",
+            "wildcard imports",
+            "W0401",
+        ],
+        rule: "wildcard-import",
+        configFix: "pylint enables wildcard-import (W0401) by default; keep it out of the disable list",
+    },
+    {
+        intent: "no global statement (Python)",
+        linter: "pylint",
+        keywords: ["global-statement", "global statement", "W0603"],
+        rule: "global-statement",
+        configFix: "pylint enables global-statement (W0603) by default; keep it out of the disable list",
+    },
+    {
+        intent: "max line length (Python)",
+        linter: "pylint",
+        keywords: ["line-too-long", "C0301"],
+        rule: "line-too-long",
+        configFix: "pylint enables line-too-long (C0301) by default; set max-line-length in [tool.pylint]",
+    },
+    {
+        intent: "no unused imports (Python)",
+        linter: "pylint",
+        keywords: ["unused-import", "W0611"],
+        rule: "unused-import",
+        configFix: "pylint enables unused-import (W0611) by default; keep it out of the disable list",
+    },
 ];
 /** Escape a keyword for use inside a RegExp. */
 function escapeRe(s) {
@@ -206,9 +361,15 @@ function escapeRe(s) {
  * non-`[\w/@.-]` character on each side (so `no-console` matches in
  * `` `no-console` `` and `enforce no-console;` but `no-console-x` does not,
  * and prose containing the substring elsewhere never trips it).
+ *
+ * The TRAILING boundary is a lookahead, not a consuming class, so a keyword at
+ * SENTENCE END ("No wildcard imports.") matches: a `.` is allowed unless it
+ * CONTINUES a code token (`.log` in `console.log`), which still blocks a partial
+ * match. `(?![\w/@-])` rejects a word/`/`/`@`/`-` continuation; `(?!\.[\w/@-])`
+ * rejects a dotted continuation but permits a trailing sentence `.`.
  */
 function matchesWholeToken(text, keyword) {
-    const re = new RegExp(`(^|[^\\w/@.-])${escapeRe(keyword)}([^\\w/@.-]|$)`, "i");
+    const re = new RegExp(`(^|[^\\w/@.-])${escapeRe(keyword)}(?![\\w/@-])(?!\\.[\\w/@-])`, "i");
     return re.test(text);
 }
 /**
@@ -292,6 +453,14 @@ function buildRuleInventory(instructionText, configText, options = {}) {
     for (const m of exports.INTENT_MAP) {
         if (linters && !linters.includes(m.linter))
             continue;
+        // ROUTE-ONLY for non-eslint linters: the config-state check below
+        // (ruleSetOff/ruleInConfig) is eslint-config-shaped and would MISLABEL a
+        // pylint rule, which is ON-BY-DEFAULT (a symbol in `disable=` reads as
+        // "in-config"; an absent one as "enable it" — both inverted). The routing
+        // preview (classify) still reuses these; accurate pylint enabled-state waits
+        // on the inverted-polarity ConfigProbe (design doc §3). Don't cry wolf.
+        if (m.linter !== "eslint")
+            continue;
         const matched = m.keywords.find((kw) => matchesWholeToken(instructionText, kw));
         if (!matched)
             continue;

package/dist/rule-routing.d.ts

@@ -1,7 +1,8 @@
 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" | "semantic" | "unrouted";
-export type RuleMechanism = "config-line" | "hook" | "prose" | "compile";
+export type RuleCategory = "reuse" | "hook" | "meta" | "semantic" | "unrouted";
+export type RuleMechanism = "config-line" | "hook" | "prose" | "synthesize";
 /** One segmented, deterministically-routed rule with provenance. */
 export interface RoutedRule {
     /** Normalized atomic rule text (from the segmenter). */
@@ -19,6 +20,13 @@ export interface RoutedRule {
     readonly rule?: string;
     /** reuse only: the linter that rule belongs to. */
     readonly linter?: LinterName;
+    /** reuse via the DYNAMIC catalog only: whether the rule is currently enabled in
+     * the repo's config (a disabled match is the "documented but OFF" nudge). */
+    readonly enabled?: boolean;
+    /** How this rule was found: `"marker"` = an explicit `**Enforced by:**` /
+     * `**Guard:**` / `**Guidance only**` marker (definitive, zero-heuristic — a
+     * compiled/marked doc); `"heuristic"` = the Tier-A segmenter. Absent ⇒ heuristic. */
+    readonly source?: "marker" | "heuristic";
 }
 export interface RuleRouting {
     /** How many atomic rules were routed (after the confidence filter). */
@@ -36,6 +44,14 @@ export interface RouteOptions {
      * `"medium"` to include both.
      */
     readonly minConfidence?: "high" | "medium";
+    /**
+     * The repo's DYNAMIC available-rule catalog (from `enumerateEslintCatalog`).
+     * When provided (OWN-REPO / consented — it executes the linter), a bullet that
+     * NAMES any of the repo's real rules routes to `reuse` with its enabled state —
+     * not just the ~23 static `INTENT_MAP` aliases. Absent = foreign-safe default
+     * (static map only, no execution).
+     */
+    readonly availableRules?: RuleCatalog;
 }
 /**
  * Segment the instruction file and route every atomic rule deterministically.
@@ -43,4 +59,11 @@ export interface RouteOptions {
  * source path for provenance). Returns per-category counts + the routed rules.
  */
 export declare function routeRules(instructionText: string, file?: string, options?: RouteOptions): RuleRouting;
+/**
+ * Merge per-file routings into one. Each instruction source is routed SEPARATELY
+ * (so every rule keeps its OWN file path + line numbers — concatenating first
+ * would corrupt the provenance the preview promises), then folded here: rules
+ * concatenated, counts + segmented summed. Pure. `[]` → an empty routing.
+ */
+export declare function mergeRoutings(routings: readonly RuleRouting[]): RuleRouting;
 //# sourceMappingURL=rule-routing.d.ts.map