code-auditor-mcp 4.1.1 → 5.0.2

package/dist/phase/routing.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Spec 68 §11.1 — the both-paths route split.
+ *
+ * During migration the tool runs BOTH analysis paths side by side: the legacy
+ * pipeline analyzers and the new phase model (Parse → Process → Analyze). Every
+ * rule is served by exactly one path. The split is *derived*, never written:
+ * `migrated` is the id set of `MIGRATED_RULES` (the rules whose `analyze(ctx)`
+ * is live and whose declared facts have producers), and `legacy` is every other
+ * registry rule. The two sets are disjoint by construction and their union is
+ * the whole registry — the conformance tests in spec68-routing.spec.ts pin
+ * exactly that, so a rule can no more be silently dropped from one path than it
+ * can be served by both.
+ */
+/** The two routes a rule can take during the migration. */
+export type Route = 'phase' | 'legacy';
+/** The derived split: which rule ids ride which path. */
+export interface RouteSplit {
+    readonly migrated: ReadonlySet<string>;
+    readonly legacy: ReadonlySet<string>;
+}
+/**
+ * Derive `{ migrated, legacy }` from MIGRATED_RULES against RULE_REGISTRY.
+ *
+ * @returns The disjoint `migrated` and `legacy` rule-id sets.
+ */
+export declare function splitRoutes(): RouteSplit;
+/** The route a rule id takes — `'phase'` if migrated, `'legacy'` if registry-only,
+ *  `undefined` if it is not a registry rule at all.
+ *
+ *  @param ruleId - The rule id whose route is resolved.
+ *  @returns `'phase'`, `'legacy'`, or `undefined` for an unknown rule. */
+export declare function routeFor(ruleId: string): Route | undefined;
+/**
+ * Full attribution: every registry rule mapped to its route.
+ *
+ * @returns A `ruleId` → route map over the whole registry.
+ */
+export declare function attributeRoutes(): ReadonlyMap<string, Route>;
+/**
+ * The migrated rule ids the phase model runs. Spec 68 §15 deletes the analyzer
+ * *selection* model — there is no `enabledAnalyzers`, so the phase path always
+ * runs every migrated rule. `analyzer` now lives on `RuleDefinition` (not the
+ * registry entry) and is only a re-emission bucket label; it no longer gates
+ * which rules run.
+ */
+export declare function enabledMigratedRules(): ReadonlySet<string>;
+//# sourceMappingURL=routing.d.ts.map

package/dist/phase/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/phase/routing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,2DAA2D;AAC3D,MAAM,MAAM,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEvC,yDAAyD;AACzD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACtC;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,UAAU,CAMxC;AAED;;;;0EAI0E;AAC1E,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAI1D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,CAM5D;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,WAAW,CAAC,MAAM,CAAC,CAE1D"}

package/dist/phase/routing.js

@@ -0,0 +1,62 @@
+/**
+ * Spec 68 §11.1 — the both-paths route split.
+ *
+ * During migration the tool runs BOTH analysis paths side by side: the legacy
+ * pipeline analyzers and the new phase model (Parse → Process → Analyze). Every
+ * rule is served by exactly one path. The split is *derived*, never written:
+ * `migrated` is the id set of `MIGRATED_RULES` (the rules whose `analyze(ctx)`
+ * is live and whose declared facts have producers), and `legacy` is every other
+ * registry rule. The two sets are disjoint by construction and their union is
+ * the whole registry — the conformance tests in spec68-routing.spec.ts pin
+ * exactly that, so a rule can no more be silently dropped from one path than it
+ * can be served by both.
+ */
+import { MIGRATED_RULES } from './rules/registry.js';
+import { RULE_REGISTRY } from '../analyzers/ruleRegistry.js';
+/**
+ * Derive `{ migrated, legacy }` from MIGRATED_RULES against RULE_REGISTRY.
+ *
+ * @returns The disjoint `migrated` and `legacy` rule-id sets.
+ */
+export function splitRoutes() {
+    const migrated = new Set(MIGRATED_RULES.map((r) => r.id));
+    const legacy = new Set(Object.keys(RULE_REGISTRY).filter((id) => !migrated.has(id)));
+    return { migrated, legacy };
+}
+/** The route a rule id takes — `'phase'` if migrated, `'legacy'` if registry-only,
+ *  `undefined` if it is not a registry rule at all.
+ *
+ *  @param ruleId - The rule id whose route is resolved.
+ *  @returns `'phase'`, `'legacy'`, or `undefined` for an unknown rule. */
+export function routeFor(ruleId) {
+    if (MIGRATED_RULES.some((r) => r.id === ruleId))
+        return 'phase';
+    if (Object.prototype.hasOwnProperty.call(RULE_REGISTRY, ruleId))
+        return 'legacy';
+    return undefined;
+}
+/**
+ * Full attribution: every registry rule mapped to its route.
+ *
+ * @returns A `ruleId` → route map over the whole registry.
+ */
+export function attributeRoutes() {
+    const { migrated, legacy } = splitRoutes();
+    const map = new Map();
+    for (const id of migrated)
+        map.set(id, 'phase');
+    for (const id of legacy)
+        map.set(id, 'legacy');
+    return map;
+}
+/**
+ * The migrated rule ids the phase model runs. Spec 68 §15 deletes the analyzer
+ * *selection* model — there is no `enabledAnalyzers`, so the phase path always
+ * runs every migrated rule. `analyzer` now lives on `RuleDefinition` (not the
+ * registry entry) and is only a re-emission bucket label; it no longer gates
+ * which rules run.
+ */
+export function enabledMigratedRules() {
+    return new Set(MIGRATED_RULES.map((r) => r.id));
+}
+//# sourceMappingURL=routing.js.map

package/dist/phase/routing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.js","sourceRoot":"","sources":["../../src/phase/routing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAW7D;;;;GAIG;AACH,MAAM,UAAU,WAAW;IACzB,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1D,MAAM,MAAM,GAAG,IAAI,GAAG,CACpB,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAC7D,CAAC;IACF,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;AAC9B,CAAC;AAED;;;;0EAI0E;AAC1E,MAAM,UAAU,QAAQ,CAAC,MAAc;IACrC,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC;QAAE,OAAO,OAAO,CAAC;IAChE,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC;QAAE,OAAO,QAAQ,CAAC;IACjF,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe;IAC7B,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,CAAC;IAC3C,MAAM,GAAG,GAAG,IAAI,GAAG,EAAiB,CAAC;IACrC,KAAK,MAAM,EAAE,IAAI,QAAQ;QAAE,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAChD,KAAK,MAAM,EAAE,IAAI,MAAM;QAAE,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;IAC/C,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,IAAI,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAClD,CAAC"}

package/dist/phase/rules/conventions.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Spec 68 §3.2 — the three function-index-servable conventions rules, migrated
+ * to `analyze(ctx)`.
+ *
+ * The conventions analyzer is index-backed: it never walked an AST, it queried
+ * the SQLite `conventions` + `functions` + `function_calls` tables. Its three
+ * function-index-servable detectors are a clean reduction over the
+ * `mined-conventions` corpus fact plus the `function-index` fact that fed it:
+ *
+ *   - usage-pair — a function that calls the antecedent but not the consequent
+ *     of a mined pair (reads `function-index` call sets + the mined pairs).
+ *   - error-handling — a function whose detected error-handling shape differs
+ *     from its directory's dominant shape.
+ *   - naming — an exported symbol whose casing differs from its directory+kind's
+ *     dominant casing.
+ *   - export-shape — an exported symbol whose export form (default vs named)
+ *     differs from its directory's dominant form (reads `export-form`).
+ *
+ * The detection logic is re-homed verbatim from `UniversalConventionsAnalyzer`'s
+ * `detectUsagePairForConvention` / `detectErrorHandlingForRow` /
+ * `detectNamingForRow` / `detectExportShapeForRow` (and its `buildCallMaps` /
+ * `buildDirShapes` / `buildDirKindCases` / `classifyExportKind` /
+ * `buildDirForms` helpers). The DB-assigned `id` becomes the array index; the
+ * finding anchors to `(file, line)` and never to the id, so the numbering is a
+ * key only.
+ *
+ * `import-form` reads the `import-form` fact (regex-parsed source, not the AST
+ * `imports` fact) plus the `function-index` file set: the legacy detector read
+ * `SELECT DISTINCT file_path FROM functions`, so a file with imports but no
+ * indexed function is never checked. The error-handling `cannot-fire` diagnostic
+ * (a non-TS/JS body) has no `analyze` channel — §8 derives coverage states, so
+ * the diagnostic folds into that, not into findings.
+ */
+import type { RuleDefinition } from '../types.js';
+/** The shared declaration for the three function-index-servable rules. */
+type ConventionNeeds = {
+    readonly formats: readonly ['typescript', 'tsx', 'javascript'];
+    readonly facts: readonly ['function-index', 'mined-conventions'];
+};
+/** The three function-index-servable conventions rules, in registry order. */
+export declare const conventionsRules: readonly RuleDefinition<ConventionNeeds>[];
+/** The export-shape rule reads one extra fact (`export-form`), so it carries a
+ *  distinct `Needs` tuple and lives in its own array. */
+type ExportShapeNeeds = {
+    readonly formats: readonly ['typescript', 'tsx', 'javascript'];
+    readonly facts: readonly ['function-index', 'mined-conventions', 'export-form'];
+};
+/** The export-shape conventions rule, in registry order. */
+export declare const conventionsExportShapeRules: readonly RuleDefinition<ExportShapeNeeds>[];
+/** The import-form rule reads the `import-form` fact plus the `function-index`
+ *  file set (to skip imports in files with no indexed function) and the
+ *  `mined-conventions` corpus fact. Its own `Needs` tuple reflects that third
+ *  fact, so it lives in its own array alongside export-shape. */
+type ImportFormNeeds = {
+    readonly formats: readonly ['typescript', 'tsx', 'javascript'];
+    readonly facts: readonly ['function-index', 'import-form', 'mined-conventions'];
+};
+/** The import-form conventions rule, in registry order. */
+export declare const conventionsImportFormRules: readonly RuleDefinition<ImportFormNeeds>[];
+export {};
+//# sourceMappingURL=conventions.d.ts.map

package/dist/phase/rules/conventions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conventions.d.ts","sourceRoot":"","sources":["../../../src/phase/rules/conventions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,KAAK,EAAE,cAAc,EAA+E,MAAM,aAAa,CAAC;AAQ/H,0EAA0E;AAC1E,KAAK,eAAe,GAAG;IACrB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,YAAY,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;IAC/D,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,gBAAgB,EAAE,mBAAmB,CAAC,CAAC;CAClE,CAAC;AAuWF,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,EAAE,SAAS,cAAc,CAAC,eAAe,CAAC,EAItE,CAAC;AAEF;yDACyD;AACzD,KAAK,gBAAgB,GAAG;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,YAAY,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;IAC/D,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,gBAAgB,EAAE,mBAAmB,EAAE,aAAa,CAAC,CAAC;CACjF,CAAC;AAkBF,4DAA4D;AAC5D,eAAO,MAAM,2BAA2B,EAAE,SAAS,cAAc,CAAC,gBAAgB,CAAC,EAElF,CAAC;AAEF;;;iEAGiE;AACjE,KAAK,eAAe,GAAG;IACrB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,YAAY,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;IAC/D,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,gBAAgB,EAAE,aAAa,EAAE,mBAAmB,CAAC,CAAC;CACjF,CAAC;AAkBF,2DAA2D;AAC3D,eAAO,MAAM,0BAA0B,EAAE,SAAS,cAAc,CAAC,eAAe,CAAC,EAEhF,CAAC"}

package/dist/phase/rules/conventions.js

@@ -0,0 +1,403 @@
+/**
+ * Spec 68 §3.2 — the three function-index-servable conventions rules, migrated
+ * to `analyze(ctx)`.
+ *
+ * The conventions analyzer is index-backed: it never walked an AST, it queried
+ * the SQLite `conventions` + `functions` + `function_calls` tables. Its three
+ * function-index-servable detectors are a clean reduction over the
+ * `mined-conventions` corpus fact plus the `function-index` fact that fed it:
+ *
+ *   - usage-pair — a function that calls the antecedent but not the consequent
+ *     of a mined pair (reads `function-index` call sets + the mined pairs).
+ *   - error-handling — a function whose detected error-handling shape differs
+ *     from its directory's dominant shape.
+ *   - naming — an exported symbol whose casing differs from its directory+kind's
+ *     dominant casing.
+ *   - export-shape — an exported symbol whose export form (default vs named)
+ *     differs from its directory's dominant form (reads `export-form`).
+ *
+ * The detection logic is re-homed verbatim from `UniversalConventionsAnalyzer`'s
+ * `detectUsagePairForConvention` / `detectErrorHandlingForRow` /
+ * `detectNamingForRow` / `detectExportShapeForRow` (and its `buildCallMaps` /
+ * `buildDirShapes` / `buildDirKindCases` / `classifyExportKind` /
+ * `buildDirForms` helpers). The DB-assigned `id` becomes the array index; the
+ * finding anchors to `(file, line)` and never to the id, so the numbering is a
+ * key only.
+ *
+ * `import-form` reads the `import-form` fact (regex-parsed source, not the AST
+ * `imports` fact) plus the `function-index` file set: the legacy detector read
+ * `SELECT DISTINCT file_path FROM functions`, so a file with imports but no
+ * indexed function is never checked. The error-handling `cannot-fire` diagnostic
+ * (a non-TS/JS body) has no `analyze` channel — §8 derives coverage states, so
+ * the diagnostic folds into that, not into findings.
+ */
+import * as path from 'path';
+import { RULE_REGISTRY } from '../../analyzers/ruleRegistry.js';
+import { detectCase, detectErrorHandlingShape, hasNonLatinChars, } from '../../conventions/conventionMiner.js';
+const META = RULE_REGISTRY;
+/** Languages whose error-handling shape `detectErrorHandlingShape` can classify
+ *  (re-homes the analyzer's `ERROR_HANDLING_HANDLED_LANGUAGES`). The producer
+ *  only emits these languages, so the guard is a fidelity check, not a filter. */
+const ERROR_HANDLING_HANDLED_LANGUAGES = new Set(['typescript', 'javascript']);
+/** Build the `(exemplar: file:line)` suffix shared across convention messages. */
+function exemplarRef(conv) {
+    return conv.exemplar_file
+        ? ` (exemplar: ${conv.exemplar_file}${conv.exemplar_line ? `:${conv.exemplar_line}` : ''})`
+        : '';
+}
+/** The caller→callees and callee→callers maps, keyed by the function's array
+ *  index (re-homes `buildCallMaps`). */
+function buildCallMaps(facts) {
+    const callerCalls = new Map();
+    const antecedentCallers = new Map();
+    facts.forEach((f, i) => {
+        const callees = new Set(f.functionCalls);
+        callerCalls.set(i, callees);
+        for (const callee of f.functionCalls) {
+            const callers = antecedentCallers.get(callee);
+            if (callers)
+                callers.add(i);
+            else
+                antecedentCallers.set(callee, new Set([i]));
+        }
+    });
+    return { callerCalls, antecedentCallers };
+}
+/** The convention rows whose domain matches, in the order the corpus fact carries. */
+function conventionsOf(conventions, domain) {
+    return conventions.filter((c) => c.domain === domain);
+}
+// ── usage-pair ──────────────────────────────────────────────────────────────
+function detectUsagePair(findings, facts, conventions) {
+    const { callerCalls, antecedentCallers } = buildCallMaps(facts);
+    const funcById = new Map(facts.map((f, i) => [i, f]));
+    for (const conv of conventionsOf(conventions, 'usage-pair')) {
+        if (!conv.antecedent || !conv.consequent)
+            continue;
+        const antecedent = conv.antecedent;
+        const consequent = conv.consequent;
+        const callerIds = antecedentCallers.get(antecedent);
+        if (!callerIds || callerIds.size === 0)
+            continue;
+        for (const cid of callerIds) {
+            const callSet = callerCalls.get(cid);
+            if (!callSet || !callSet.has(consequent)) {
+                const func = funcById.get(cid);
+                if (!func)
+                    continue;
+                const pct = Math.round(conv.confidence * 100);
+                findings.push({
+                    ruleId: 'conventions/usage-pair',
+                    severity: 'high',
+                    message: `${pct}% of \`${antecedent}\` callers also call \`${consequent}\` — ` +
+                        `this function calls \`${antecedent}\` without \`${consequent}\`${exemplarRef(conv)}`,
+                    file: func.file,
+                    line: func.line,
+                    column: 1,
+                    symbol: func.name,
+                    resolution: {
+                        action: 'call-companion',
+                        summary: `Add a call to the companion function \`${consequent}\` in \`${func.name}\` — ${pct}% of \`${antecedent}\` callers also call it.`,
+                        symbols: [consequent, antecedent],
+                        files: [func.file],
+                        lines: [func.line],
+                    },
+                });
+            }
+        }
+    }
+}
+// ── error-handling ──────────────────────────────────────────────────────────
+function buildDirShapes(conventions) {
+    const dirShapes = new Map();
+    for (const conv of conventionsOf(conventions, 'error-handling')) {
+        const dir = conv.directory ?? '.';
+        if (!conv.pattern)
+            continue;
+        dirShapes.set(dir, conv);
+    }
+    return dirShapes;
+}
+function detectErrorHandling(findings, facts, conventions) {
+    const dirShapes = buildDirShapes(conventions);
+    for (const fact of facts) {
+        if (!ERROR_HANDLING_HANDLED_LANGUAGES.has(fact.language))
+            continue;
+        if (fact.body == null)
+            continue;
+        const directory = path.dirname(fact.file) || '.';
+        const conv = dirShapes.get(directory);
+        if (!conv)
+            continue;
+        const shape = detectErrorHandlingShape(fact.body);
+        if (!shape)
+            continue; // no error handling → skip
+        if (shape === conv.pattern)
+            continue; // matches convention
+        const pct = Math.round(conv.confidence * 100);
+        findings.push({
+            ruleId: 'conventions/error-handling',
+            severity: 'high',
+            message: `${pct}% of error-handling functions in \`${directory}/\` use ` +
+                `\`${conv.pattern}\` — this function uses \`${shape}\`${exemplarRef(conv)}`,
+            file: fact.file,
+            line: fact.line,
+            column: 1,
+            symbol: fact.name,
+        });
+    }
+}
+// ── naming ──────────────────────────────────────────────────────────────────
+/** Classify an exported function into a naming kind (re-homes the analyzer's
+ *  `classifyExportKind`). */
+function classifyExportKind(fact) {
+    if (fact.entityType === 'component' || fact.componentType !== null) {
+        return 'react-component';
+    }
+    if (/^use[A-Z]/.test(fact.name))
+        return 'hook';
+    return 'function';
+}
+function buildDirKindCases(conventions) {
+    const dirKindCases = new Map();
+    for (const conv of conventionsOf(conventions, 'naming')) {
+        const dir = conv.directory ?? '.';
+        const casing = conv.pattern;
+        if (!casing)
+            continue;
+        const kind = conv.export_kind ?? 'function';
+        if (!dirKindCases.has(dir))
+            dirKindCases.set(dir, new Map());
+        dirKindCases.get(dir).set(kind, conv);
+    }
+    return dirKindCases;
+}
+function detectNaming(findings, facts, conventions) {
+    const dirKindCases = buildDirKindCases(conventions);
+    for (const fact of facts) {
+        if (!fact.isExported)
+            continue;
+        const directory = path.dirname(fact.file) || '.';
+        const kindConvs = dirKindCases.get(directory);
+        if (!kindConvs)
+            continue;
+        const rowKind = classifyExportKind(fact);
+        const conv = kindConvs.get(rowKind);
+        if (!conv)
+            continue;
+        if (hasNonLatinChars(fact.name))
+            continue;
+        const casing = detectCase(fact.name);
+        if (!casing || casing === conv.pattern)
+            continue;
+        const pct = Math.round(conv.confidence * 100);
+        findings.push({
+            ruleId: 'conventions/naming',
+            severity: 'high',
+            message: `${pct}% of ${rowKind} exports in \`${directory}/\` use ${conv.pattern} — ` +
+                `\`${fact.name}\` uses ${casing}${exemplarRef(conv)}`,
+            file: fact.file,
+            line: fact.line,
+            column: 1,
+            symbol: fact.name,
+        });
+    }
+}
+// ── export-shape ────────────────────────────────────────────────────────────
+/** Build directory → dominant export form from convention rows (re-homes the
+ *  analyzer's `buildDirForms`). */
+function buildDirFormsForShape(conventions) {
+    const dirForms = new Map();
+    for (const conv of conventionsOf(conventions, 'export-shape')) {
+        const dir = conv.directory ?? '.';
+        if (!conv.pattern)
+            continue;
+        dirForms.set(dir, conv);
+    }
+    return dirForms;
+}
+/** Detect an export-shape deviation for each exported function (re-homes the
+ *  analyzer's `detectExportShapeForRow`). The form resolves from the
+ *  `export-form` fact — the same AST-extracted `(name, isDefault)` pairs the
+ *  legacy reducer read as `exportsMap`. */
+function detectExportShape(findings, facts, conventions, exportForms) {
+    const dirForms = buildDirFormsForShape(conventions);
+    // file → exports, grouped from the flat export-form fact.
+    const exportsByFile = new Map();
+    for (const e of exportForms) {
+        const list = exportsByFile.get(e.file);
+        if (list)
+            list.push({ name: e.name, isDefault: e.isDefault });
+        else
+            exportsByFile.set(e.file, [{ name: e.name, isDefault: e.isDefault }]);
+    }
+    for (const fact of facts) {
+        if (!fact.isExported)
+            continue;
+        const directory = path.dirname(fact.file) || '.';
+        const conv = dirForms.get(directory);
+        if (!conv)
+            continue;
+        const fileExports = exportsByFile.get(fact.file);
+        if (!fileExports)
+            continue;
+        const match = fileExports.find((e) => e.name === fact.name);
+        if (!match)
+            continue;
+        const form = match.isDefault ? 'default' : 'named';
+        if (form === conv.pattern)
+            continue;
+        const pct = Math.round(conv.confidence * 100);
+        findings.push({
+            ruleId: 'conventions/export-shape',
+            severity: 'high',
+            message: `${pct}% of exports in \`${directory}/\` use ${conv.pattern} export — ` +
+                `\`${fact.name}\` uses ${form}${exemplarRef(conv)}`,
+            file: fact.file,
+            line: fact.line,
+            column: 1,
+            symbol: fact.name,
+        });
+    }
+}
+// ── import-form ─────────────────────────────────────────────────────────────
+/** Build directory → Map<source, convention> from import-form rows (re-homes the
+ *  analyzer's `buildDirImports`). The convention's `consequent` is the dominant
+ *  form; `antecedent` is the module source. */
+function buildDirImportsForForm(conventions) {
+    const dirImports = new Map();
+    for (const conv of conventionsOf(conventions, 'import-form')) {
+        const dir = conv.directory ?? '.';
+        const source = conv.antecedent;
+        if (!source)
+            continue;
+        const form = conv.consequent;
+        if (!form)
+            continue;
+        if (!dirImports.has(dir))
+            dirImports.set(dir, new Map());
+        dirImports.get(dir).set(source, conv);
+    }
+    return dirImports;
+}
+/** Detect an import-form deviation for each import in a function-indexed file
+ *  (re-homes the analyzer's `detectImportFormForFile`). The legacy detector read
+ *  files from `functions`, so only imports whose file is in the `function-index`
+ *  fact are checked — a file with imports but no indexed function is skipped on
+ *  both paths. */
+function detectImportForm(findings, facts, importForms, conventions) {
+    const dirImports = buildDirImportsForForm(conventions);
+    const funcFiles = new Set(facts.map((f) => f.file));
+    for (const imp of importForms) {
+        if (!funcFiles.has(imp.file))
+            continue;
+        const directory = path.dirname(imp.file) || '.';
+        const conv = dirImports.get(directory)?.get(imp.source);
+        if (!conv || imp.form === conv.consequent)
+            continue;
+        const pct = Math.round(conv.confidence * 100);
+        findings.push({
+            ruleId: 'conventions/import-form',
+            severity: 'high',
+            message: `${pct}% of imports of \`${imp.source}\` in \`${directory}/\` ` +
+                `use ${conv.consequent} import — this file uses ${imp.form}${exemplarRef(conv)}`,
+            file: imp.file,
+            line: imp.line,
+            column: 1,
+            // §7 — the module source is what located this finding; two deviating
+            // imports in one file must not collapse to one fingerprint.
+            symbol: imp.source,
+        });
+    }
+}
+// ── Rule definitions ────────────────────────────────────────────────────────
+const usagePair = {
+    id: 'conventions/usage-pair',
+    analyzer: 'conventions',
+    needs: { formats: ['typescript', 'tsx', 'javascript'], facts: ['function-index', 'mined-conventions'] },
+    severity: 'high',
+    message: META['conventions/usage-pair'].message,
+    docs: META['conventions/usage-pair'].docs,
+    thresholds: META['conventions/usage-pair'].thresholds,
+    samples: META['conventions/usage-pair'].samples,
+    analyze(ctx) {
+        const out = [];
+        detectUsagePair(out, ctx.facts['function-index'], ctx.facts['mined-conventions']);
+        return out;
+    },
+};
+const errorHandling = {
+    id: 'conventions/error-handling',
+    analyzer: 'conventions',
+    needs: { formats: ['typescript', 'tsx', 'javascript'], facts: ['function-index', 'mined-conventions'] },
+    severity: 'high',
+    message: META['conventions/error-handling'].message,
+    docs: META['conventions/error-handling'].docs,
+    thresholds: META['conventions/error-handling'].thresholds,
+    samples: META['conventions/error-handling'].samples,
+    analyze(ctx) {
+        const out = [];
+        detectErrorHandling(out, ctx.facts['function-index'], ctx.facts['mined-conventions']);
+        return out;
+    },
+};
+const naming = {
+    id: 'conventions/naming',
+    analyzer: 'conventions',
+    needs: { formats: ['typescript', 'tsx', 'javascript'], facts: ['function-index', 'mined-conventions'] },
+    severity: 'high',
+    message: META['conventions/naming'].message,
+    docs: META['conventions/naming'].docs,
+    thresholds: META['conventions/naming'].thresholds,
+    samples: META['conventions/naming'].samples,
+    analyze(ctx) {
+        const out = [];
+        detectNaming(out, ctx.facts['function-index'], ctx.facts['mined-conventions']);
+        return out;
+    },
+};
+/** The three function-index-servable conventions rules, in registry order. */
+export const conventionsRules = [
+    usagePair,
+    errorHandling,
+    naming,
+];
+const exportShape = {
+    id: 'conventions/export-shape',
+    analyzer: 'conventions',
+    needs: { formats: ['typescript', 'tsx', 'javascript'], facts: ['function-index', 'mined-conventions', 'export-form'] },
+    severity: 'high',
+    message: META['conventions/export-shape'].message,
+    docs: META['conventions/export-shape'].docs,
+    thresholds: META['conventions/export-shape'].thresholds,
+    samples: META['conventions/export-shape'].samples,
+    analyze(ctx) {
+        const out = [];
+        detectExportShape(out, ctx.facts['function-index'], ctx.facts['mined-conventions'], ctx.facts['export-form']);
+        return out;
+    },
+};
+/** The export-shape conventions rule, in registry order. */
+export const conventionsExportShapeRules = [
+    exportShape,
+];
+const importForm = {
+    id: 'conventions/import-form',
+    analyzer: 'conventions',
+    needs: { formats: ['typescript', 'tsx', 'javascript'], facts: ['function-index', 'import-form', 'mined-conventions'] },
+    severity: 'high',
+    message: META['conventions/import-form'].message,
+    docs: META['conventions/import-form'].docs,
+    thresholds: META['conventions/import-form'].thresholds,
+    samples: META['conventions/import-form'].samples,
+    analyze(ctx) {
+        const out = [];
+        detectImportForm(out, ctx.facts['function-index'], ctx.facts['import-form'], ctx.facts['mined-conventions']);
+        return out;
+    },
+};
+/** The import-form conventions rule, in registry order. */
+export const conventionsImportFormRules = [
+    importForm,
+];
+//# sourceMappingURL=conventions.js.map

package/dist/phase/rules/conventions.js.map

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