code-auditor-mcp 4.0.1 → 4.0.2

package/dist/pipelineAdapters.js

@@ -49,10 +49,9 @@ function lazySingleton(loader) {
         return promise;
     };
 }
-// ── SOLID visitor ────────────────────────────────────────────────────────────
 export function createSolidVisitor() {
     const getAnalyzer = lazySingleton(() => import('./analyzers/universal/UniversalSOLIDAnalyzer.js').then((m) => new m.UniversalSOLIDAnalyzer()));
-    return {
+    const visitor = {
         name: 'solid',
         stage: 'visitor',
         getRuleIds: () => getRuleIdsFor('solid'),
@@ -68,6 +67,18 @@ export function createSolidVisitor() {
         description: 'Detects violations of SOLID principles',
         category: 'architecture',
     };
+    return {
+        visitor,
+        getSizeSamples: async () => {
+            try {
+                const a = await getAnalyzer();
+                return a.sizeSamples ?? [];
+            }
+            catch {
+                return [];
+            }
+        },
+    };
 }
 export function createDryVisitor(fullFunctionIndex) {
     const getAnalyzer = lazySingleton(() => import('./analyzers/universal/UniversalDRYAnalyzer.js').then((m) => new m.UniversalDRYAnalyzer()));
@@ -544,7 +555,7 @@ export function createReactVisitor() {
                 }
             }
             catch {
-                // Cross-component checks are advisory
+                // Cross-component checks are high
             }
             return violations;
         },
@@ -1560,6 +1571,100 @@ function clComputeReachability(fileFacts, options) {
     }
     return { reachability, importersOf };
 }
+/**
+ * Spec 60 R1 — classify every non-test source module as `tested`,
+ * `untested-live`, or `untested-dead` off the file-level import edges
+ * (`importersOf`), not `function_dependencies`.
+ *
+ * A module is `tested` when a test file imports it *directly* (the edge set is
+ * alias-aware — built by `clResolveImport` through `classifyImportSpecifier`).
+ * `untested-dead` is the *post*-exception dead bucket: a file imported by
+ * nothing *and* not a framework entry point. `deadPreException` is the
+ * empty-importers count before the entry-point exception, so the drop
+ * (`deadPreException - untestedDead`) attributes the entry points exempted.
+ */
+export function classifyTestCoverage(fileFacts, importersOf, packageEntrySet) {
+    const result = {
+        tested: 0,
+        untestedLive: 0,
+        untestedDead: 0,
+        total: 0,
+        deadPreException: 0,
+        deadPostException: 0,
+        deadDrop: 0,
+        entryPointExemptions: [],
+        testedFiles: [],
+        untestedLiveFiles: [],
+        untestedDeadFiles: [],
+    };
+    for (const fp of fileFacts.keys()) {
+        if (clIsTestFile(fp))
+            continue;
+        result.total++;
+        const importers = importersOf.get(fp);
+        if (!importers || importers.size === 0) {
+            // Imported by nothing — dead *unless* it is a framework entry point.
+            result.deadPreException++;
+            const isPackageEntry = packageEntrySet.has(fp);
+            const isEntry = isPackageEntry || clIsEntryPointFile(fp);
+            if (isEntry) {
+                result.untestedLive++;
+                result.untestedLiveFiles.push(fp);
+                result.entryPointExemptions.push({
+                    file: fp,
+                    kind: isPackageEntry ? 'package-entry' : 'entry-point',
+                });
+            }
+            else {
+                result.untestedDead++;
+                result.untestedDeadFiles.push(fp);
+            }
+            continue;
+        }
+        let hasTestImporter = false;
+        for (const importer of importers) {
+            if (clIsTestFile(importer)) {
+                hasTestImporter = true;
+                break;
+            }
+        }
+        if (hasTestImporter) {
+            result.tested++;
+            result.testedFiles.push(fp);
+        }
+        else {
+            result.untestedLive++;
+            result.untestedLiveFiles.push(fp);
+        }
+    }
+    result.deadPostException = result.untestedDead;
+    result.deadDrop = result.deadPreException - result.untestedDead;
+    return result;
+}
+/**
+ * Spec 60 R3 — group unreferenced modules by basename, surfacing the pattern of
+ * the same file name appearing in several sibling directories (e.g. two
+ * `ErrorState.tsx`, three `services.ts` under separate `reports` folders). Only
+ * basenames with ≥2 files become clusters; a singleton dead file is not a duplicate.
+ */
+export function clusterDeadModules(deadFiles) {
+    const byBasename = new Map();
+    for (const fp of deadFiles) {
+        const segments = fp.replace(/\\/g, '/').split('/').filter(Boolean);
+        const basename = segments[segments.length - 1] ?? fp;
+        const list = byBasename.get(basename) ?? [];
+        list.push(fp);
+        byBasename.set(basename, list);
+    }
+    const clusters = [];
+    for (const [basename, files] of byBasename) {
+        if (files.length >= 2) {
+            clusters.push({ basename, count: files.length, files });
+        }
+    }
+    clusters.sort((a, b) => b.count - a.count || a.basename.localeCompare(b.basename));
+    return clusters;
+}
 /**
  * Build `calls` cross-references by resolving each entity's extracted callee
  * names against the corpus entity name index. Library calls (fetch, map, …)
@@ -1774,6 +1879,8 @@ export function createDependencyGraphReducer() {
                 }
                 // ── File-level reachability: unreferenced modules + ranking axis ──
                 const fileFacts = clFileFacts(allFacts);
+                let testCoverage;
+                let deadClusters = [];
                 if (fileFacts.size > 0) {
                     // `context.config` is the reducer's merged config (namespace + `_infra`);
                     // a bare reducer context in a unit test omits it, so fall back to the
@@ -1807,10 +1914,34 @@ export function createDependencyGraphReducer() {
                             // neutral default without it.
                         }
                     }
+                    // Spec 60 R1 — persist the file-level import edges (reverse adjacency:
+                    // module → its direct importers) so "what tests exercise this module"
+                    // is answerable downstream from `importersOf`, not the symbol-level
+                    // `function_dependencies` table.
+                    if (context.indexHandle?.rawDb) {
+                        try {
+                            const db = context.indexHandle.rawDb;
+                            const del = db.prepare("DELETE FROM graph_cache WHERE graph_type = 'importers'");
+                            const ins = db.prepare("INSERT OR REPLACE INTO graph_cache (graph_type, node_key, neighbor_key, weight) VALUES ('importers', ?, ?, 1)");
+                            const tx = db.transaction(() => {
+                                del.run();
+                                for (const [fp, importers] of importersOf) {
+                                    for (const importer of importers) {
+                                        ins.run(fp, importer);
+                                    }
+                                }
+                            });
+                            tx();
+                        }
+                        catch {
+                            // Importer-edge persistence is advisory, like reachability.
+                        }
+                    }
                     // Flag files that export symbols yet are imported by nothing and are
                     // not framework entry points — a dead module. This is the signal the
                     // orphaned-nodes check missed: a whole unreferenced file whose every
                     // internal symbol still forms a connected component.
+                    const deadModuleFiles = [];
                     for (const [fp, info] of fileFacts) {
                         if (!info.hasExports)
                             continue;
@@ -1820,6 +1951,7 @@ export function createDependencyGraphReducer() {
                             continue;
                         if ((importersOf.get(fp)?.size ?? 0) > 0)
                             continue;
+                        deadModuleFiles.push(fp);
                         violations.push({
                             file: fp,
                             line: 1,
@@ -1834,6 +1966,12 @@ export function createDependencyGraphReducer() {
                             details: { imports: info.imports },
                         });
                     }
+                    // Spec 60 R1 — classify each non-test module off the import edge set.
+                    testCoverage = classifyTestCoverage(fileFacts, importersOf, packageEntrySet);
+                    // Spec 60 R3 — cluster the unreferenced modules by basename so the
+                    // "dead-and-duplicated" pattern (same file name in sibling dirs) is
+                    // visible as a cluster rather than scattered one-per-file findings.
+                    deadClusters = clusterDeadModules(deadModuleFiles);
                     // Spec 58 R2 — computed-specifier dynamic imports. `import(someVar)`
                     // cannot be resolved into an edge, so any module in this corpus could
                     // be its target and `unreferenced-module` is therefore not exhaustive.
@@ -1854,15 +1992,15 @@ export function createDependencyGraphReducer() {
                 }
                 const HEALTH_SEVERITY = {
                     'break-cycles': 'severe',
-                    'reduce-coupling': 'advisory',
-                    'split-responsibilities': 'advisory',
+                    'reduce-coupling': 'high',
+                    'split-responsibilities': 'high',
                     'review-orphans': 'severe',
                 };
                 for (const s of health.suggestions) {
                     violations.push({
                         file: '(multiple)',
                         line: 0,
-                        severity: HEALTH_SEVERITY[s.type] ?? 'advisory',
+                        severity: HEALTH_SEVERITY[s.type] ?? 'high',
                         message: s.description,
                         rule: s.type,
                         type: s.type,
@@ -1871,7 +2009,12 @@ export function createDependencyGraphReducer() {
                         details: s.affectedNodes ? { affectedNodes: s.affectedNodes } : undefined,
                     });
                 }
-                return { violations, facts: {}, factsConsumed: entities.length, ...(diagnostics.length > 0 && { diagnostics }) };
+                const facts = {};
+                if (testCoverage)
+                    facts.testCoverage = testCoverage;
+                if (deadClusters.length > 0)
+                    facts.deadClusters = deadClusters;
+                return { violations, facts, factsConsumed: entities.length, ...(diagnostics.length > 0 && { diagnostics }) };
             }
             catch (e) {
                 console.error('[dependency-graph reducer] error:', e.message);