fix: statsData fully filters test nodes/edges, add MCP hotspots no_tests

- statsData now filters nodes and edges by excluding all nodes belonging
  to test files (previously only file counts and hotspots were filtered)
- Add no_tests schema property and handler passthrough to MCP hotspots tool
- Add 7 integration tests verifying noTests filtering behavior across
  queryNameData, statsData, impactAnalysisData, fileDepsData, moduleMapData

Author: github-actions[bot]

src/mcp.js

@@ -286,6 +286,7 @@ const BASE_TOOLS = [
           description: 'Rank files or directories',
         },
         limit: { type: 'number', description: 'Number of results to return', default: 10 },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
       },
     },
   },
@@ -540,6 +541,7 @@ export async function startMCPServer(customDbPath, options = {}) {
             metric: args.metric,
             level: args.level,
             limit: args.limit,
+            noTests: args.no_tests,
           });
           break;
         }

src/queries.js

@@ -739,8 +739,36 @@ export function statsData(customDbPath, opts = {}) {
   const db = openReadonlyOrFail(customDbPath);
   const noTests = opts.noTests || false;
 
+  // Build set of test file IDs for filtering nodes and edges
+  let testFileIds = null;
+  if (noTests) {
+    const allFileNodes = db.prepare("SELECT id, file FROM nodes WHERE kind = 'file'").all();
+    testFileIds = new Set();
+    const testFiles = new Set();
+    for (const n of allFileNodes) {
+      if (isTestFile(n.file)) {
+        testFileIds.add(n.id);
+        testFiles.add(n.file);
+      }
+    }
+    // Also collect non-file node IDs that belong to test files
+    const allNodes = db.prepare('SELECT id, file FROM nodes').all();
+    for (const n of allNodes) {
+      if (testFiles.has(n.file)) testFileIds.add(n.id);
+    }
+  }
+
   // Node breakdown by kind
-  const nodeRows = db.prepare('SELECT kind, COUNT(*) as c FROM nodes GROUP BY kind').all();
+  let nodeRows;
+  if (noTests) {
+    const allNodes = db.prepare('SELECT id, kind, file FROM nodes').all();
+    const filtered = allNodes.filter((n) => !testFileIds.has(n.id));
+    const counts = {};
+    for (const n of filtered) counts[n.kind] = (counts[n.kind] || 0) + 1;
+    nodeRows = Object.entries(counts).map(([kind, c]) => ({ kind, c }));
+  } else {
+    nodeRows = db.prepare('SELECT kind, COUNT(*) as c FROM nodes GROUP BY kind').all();
+  }
   const nodesByKind = {};
   let totalNodes = 0;
   for (const r of nodeRows) {
@@ -749,7 +777,18 @@ export function statsData(customDbPath, opts = {}) {
   }
 
   // Edge breakdown by kind
-  const edgeRows = db.prepare('SELECT kind, COUNT(*) as c FROM edges GROUP BY kind').all();
+  let edgeRows;
+  if (noTests) {
+    const allEdges = db.prepare('SELECT source_id, target_id, kind FROM edges').all();
+    const filtered = allEdges.filter(
+      (e) => !testFileIds.has(e.source_id) && !testFileIds.has(e.target_id),
+    );
+    const counts = {};
+    for (const e of filtered) counts[e.kind] = (counts[e.kind] || 0) + 1;
+    edgeRows = Object.entries(counts).map(([kind, c]) => ({ kind, c }));
+  } else {
+    edgeRows = db.prepare('SELECT kind, COUNT(*) as c FROM edges GROUP BY kind').all();
+  }
   const edgesByKind = {};
   let totalEdges = 0;
   for (const r of edgeRows) {

tests/integration/queries.test.js

@@ -34,6 +34,7 @@ import {
   impactAnalysisData,
   moduleMapData,
   queryNameData,
+  statsData,
   whereData,
 } from '../../src/queries.js';
 
@@ -470,3 +471,86 @@ describe('whereData', () => {
     expect(data.results).toHaveLength(0);
   });
 });
+
+// ─── noTests filtering ───────────────────────────────────────────────
+
+describe('noTests filtering', () => {
+  test('queryNameData excludes test file nodes and callers', () => {
+    const all = queryNameData('authenticate', dbPath);
+    const filtered = queryNameData('authenticate', dbPath, { noTests: true });
+
+    const allFn = all.results.find((r) => r.name === 'authenticate' && r.kind === 'function');
+    const filteredFn = filtered.results.find(
+      (r) => r.name === 'authenticate' && r.kind === 'function',
+    );
+
+    // testAuthenticate should be in callers without filter
+    expect(allFn.callers.map((c) => c.name)).toContain('testAuthenticate');
+    // testAuthenticate should be excluded with noTests
+    expect(filteredFn.callers.map((c) => c.name)).not.toContain('testAuthenticate');
+  });
+
+  test('queryNameData excludes test file results', () => {
+    const all = queryNameData('testAuthenticate', dbPath);
+    const filtered = queryNameData('testAuthenticate', dbPath, { noTests: true });
+
+    expect(all.results).toHaveLength(1);
+    expect(filtered.results).toHaveLength(0);
+  });
+
+  test('statsData excludes test files from counts', () => {
+    const all = statsData(dbPath);
+    const filtered = statsData(dbPath, { noTests: true });
+
+    // File count should be lower
+    expect(filtered.files.total).toBeLessThan(all.files.total);
+    // Node count should be lower (test file + testAuthenticate removed)
+    expect(filtered.nodes.total).toBeLessThan(all.nodes.total);
+    // Edge count should be lower (test import + test call edge removed)
+    expect(filtered.edges.total).toBeLessThan(all.edges.total);
+  });
+
+  test('statsData hotspots exclude test files', () => {
+    const filtered = statsData(dbPath, { noTests: true });
+    for (const h of filtered.hotspots) {
+      expect(h.file).not.toMatch(/\.test\./);
+    }
+  });
+
+  test('impactAnalysisData excludes test dependents', () => {
+    const all = impactAnalysisData('auth.js', dbPath);
+    const filtered = impactAnalysisData('auth.js', dbPath, { noTests: true });
+
+    const allFiles = Object.values(all.levels)
+      .flat()
+      .map((f) => f.file);
+    const filteredFiles = Object.values(filtered.levels)
+      .flat()
+      .map((f) => f.file);
+
+    expect(allFiles).toContain('auth.test.js');
+    expect(filteredFiles).not.toContain('auth.test.js');
+  });
+
+  test('fileDepsData excludes test importers', () => {
+    const all = fileDepsData('auth.js', dbPath);
+    const filtered = fileDepsData('auth.js', dbPath, { noTests: true });
+
+    const allImportedBy = all.results[0].importedBy.map((i) => i.file);
+    const filteredImportedBy = filtered.results[0].importedBy.map((i) => i.file);
+
+    expect(allImportedBy).toContain('auth.test.js');
+    expect(filteredImportedBy).not.toContain('auth.test.js');
+  });
+
+  test('moduleMapData excludes test files', () => {
+    const all = moduleMapData(dbPath, 20);
+    const filtered = moduleMapData(dbPath, 20, { noTests: true });
+
+    const allFiles = all.topNodes.map((n) => n.file);
+    const filteredFiles = filtered.topNodes.map((n) => n.file);
+
+    expect(allFiles).toContain('auth.test.js');
+    expect(filteredFiles).not.toContain('auth.test.js');
+  });
+});