@optave/codegraph 3.3.1 → 3.4.1

package/dist/features/structure.js

@@ -1,11 +1,7 @@
 import path from 'node:path';
-import { getNodeId, openReadonlyOrFail, testFilterSQL } from '../db/index.js';
-import { loadConfig } from '../infrastructure/config.js';
+import { getNodeId, testFilterSQL } from '../db/index.js';
 import { debug } from '../infrastructure/logger.js';
-import { isTestFile } from '../infrastructure/test-filter.js';
 import { normalizePath } from '../shared/constants.js';
-import { paginateResult } from '../shared/paginate.js';
-// ─── Build-time helpers ───────────────────────────────────────────────
 function getAncestorDirs(filePaths) {
     const dirs = new Set();
     for (const f of filePaths) {
@@ -19,14 +15,14 @@ function getAncestorDirs(filePaths) {
 }
 function cleanupPreviousData(db, getNodeIdStmt, isIncremental, changedFiles) {
     if (isIncremental) {
-        const affectedDirs = getAncestorDirs(changedFiles);
+        const affectedDirs = getAncestorDirs(changedFiles ?? []);
         const deleteContainsForDir = db.prepare("DELETE FROM edges WHERE kind = 'contains' AND source_id IN (SELECT id FROM nodes WHERE name = ? AND kind = 'directory')");
         const deleteMetricForNode = db.prepare('DELETE FROM node_metrics WHERE node_id = ?');
         db.transaction(() => {
             for (const dir of affectedDirs) {
                 deleteContainsForDir.run(dir);
             }
-            for (const f of changedFiles) {
+            for (const f of changedFiles ?? []) {
                 const fileRow = getNodeIdStmt.get(f, 'file', f, 0);
                 if (fileRow)
                     deleteMetricForNode.run(fileRow.id);
@@ -67,7 +63,7 @@ function collectAllDirectories(directories, fileSymbols) {
 }
 function insertContainsEdges(db, insertEdge, getNodeIdStmt, fileSymbols, allDirs, changedFiles) {
     const isIncremental = changedFiles != null && changedFiles.length > 0;
-    const affectedDirs = isIncremental ? getAncestorDirs(changedFiles) : null;
+    const affectedDirs = isIncremental ? getAncestorDirs(changedFiles ?? []) : null;
     db.transaction(() => {
         for (const relPath of fileSymbols.keys()) {
             const dir = normalizePath(path.dirname(relPath));
@@ -147,7 +143,7 @@ function computeDirectoryMetrics(db, upsertMetric, getNodeIdStmt, fileSymbols, a
         let d = normalizePath(path.dirname(relPath));
         while (d && d !== '.') {
             if (dirFiles.has(d)) {
-                dirFiles.get(d).push(relPath);
+                dirFiles.get(d)?.push(relPath);
             }
             d = normalizePath(path.dirname(d));
         }
@@ -157,7 +153,7 @@ function computeDirectoryMetrics(db, upsertMetric, getNodeIdStmt, fileSymbols, a
         for (const f of files) {
             if (!fileToAncestorDirs.has(f))
                 fileToAncestorDirs.set(f, new Set());
-            fileToAncestorDirs.get(f).add(dir);
+            fileToAncestorDirs.get(f)?.add(dir);
         }
     }
     const dirEdgeCounts = new Map();
@@ -221,16 +217,6 @@ function computeDirectoryMetrics(db, upsertMetric, getNodeIdStmt, fileSymbols, a
     })();
 }
 // ─── Build-time: insert directory nodes, contains edges, and metrics ────
-/**
- * Build directory structure nodes, containment edges, and compute metrics.
- * Called from builder.js after edge building.
- *
- * @param {import('better-sqlite3').Database} db - Open read-write database
- * @param {Map<string, object>} fileSymbols - Map of relPath → { definitions, imports, exports, calls }
- * @param {string} rootDir - Absolute root directory
- * @param {Map<string, number>} lineCountMap - Map of relPath → line count
- * @param {Set<string>} directories - Set of relative directory paths
- */
 export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, directories, changedFiles) {
     const insertNode = db.prepare('INSERT OR IGNORE INTO nodes (name, kind, file, line, end_line) VALUES (?, ?, ?, ?, ?)');
     const getNodeIdStmt = {
@@ -246,14 +232,14 @@ export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, director
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
     const isIncremental = changedFiles != null && changedFiles.length > 0;
-    cleanupPreviousData(db, getNodeIdStmt, isIncremental, changedFiles);
+    cleanupPreviousData(db, getNodeIdStmt, isIncremental, changedFiles ?? null);
     const allDirs = collectAllDirectories(directories, fileSymbols);
     db.transaction(() => {
         for (const dir of allDirs) {
             insertNode.run(dir, 'directory', dir, 0, null);
         }
     })();
-    insertContainsEdges(db, insertEdge, getNodeIdStmt, fileSymbols, allDirs, changedFiles);
+    insertContainsEdges(db, insertEdge, getNodeIdStmt, fileSymbols, allDirs, changedFiles ?? null);
     const { fanInMap, fanOutMap, importEdges } = computeImportEdgeMaps(db);
     computeFileMetrics(db, upsertMetric, getNodeIdStmt, fileSymbols, lineCountMap, fanInMap, fanOutMap);
     computeDirectoryMetrics(db, upsertMetric, getNodeIdStmt, fileSymbols, allDirs, importEdges);
@@ -262,8 +248,45 @@ export function buildStructure(db, fileSymbols, _rootDir, lineCountMap, director
 // ─── Node role classification ─────────────────────────────────────────
 // Re-export from classifier for backward compatibility
 export { FRAMEWORK_ENTRY_PREFIXES } from '../graph/classifiers/roles.js';
-import { classifyRoles } from '../graph/classifiers/roles.js';
-export function classifyNodeRoles(db) {
+import { classifyRoles, median } from '../graph/classifiers/roles.js';
+/**
+ * Classify every node in the graph into a role (core, entry, utility, etc.).
+ *
+ * When `changedFiles` is provided, only nodes from those files (and their
+ * edge neighbours) are reclassified. The returned `RoleSummary` in that case
+ * reflects **only the affected subset**, not the entire graph. Callers that
+ * need graph-wide totals should perform a full classification (omit
+ * `changedFiles`) or query the DB directly.
+ */
+export function classifyNodeRoles(db, changedFiles) {
+    const emptySummary = {
+        entry: 0,
+        core: 0,
+        utility: 0,
+        adapter: 0,
+        dead: 0,
+        'dead-leaf': 0,
+        'dead-entry': 0,
+        'dead-ffi': 0,
+        'dead-unresolved': 0,
+        'test-only': 0,
+        leaf: 0,
+    };
+    // Incremental path: only reclassify nodes from affected files
+    if (changedFiles && changedFiles.length > 0) {
+        return classifyNodeRolesIncremental(db, changedFiles, emptySummary);
+    }
+    return classifyNodeRolesFull(db, emptySummary);
+}
+function classifyNodeRolesFull(db, emptySummary) {
+    // Leaf kinds (parameter, property) can never have callers/callees.
+    // Classify them directly as dead-leaf without the expensive fan-in/fan-out JOINs.
+    const leafRows = db
+        .prepare(`SELECT n.id
+      FROM nodes n
+      WHERE n.kind IN ('parameter', 'property')`)
+        .all();
+    // Only compute fan-in/fan-out for callable/classifiable nodes
     const rows = db
         .prepare(`SELECT n.id, n.name, n.kind, n.file,
         COALESCE(fi.cnt, 0) AS fan_in,
@@ -275,31 +298,17 @@ export function classifyNodeRoles(db) {
       LEFT JOIN (
         SELECT source_id, COUNT(*) AS cnt FROM edges WHERE kind = 'calls' GROUP BY source_id
       ) fo ON n.id = fo.source_id
-      WHERE n.kind NOT IN ('file', 'directory')`)
+      WHERE n.kind NOT IN ('file', 'directory', 'parameter', 'property')`)
         .all();
-    if (rows.length === 0) {
-        return {
-            entry: 0,
-            core: 0,
-            utility: 0,
-            adapter: 0,
-            dead: 0,
-            'dead-leaf': 0,
-            'dead-entry': 0,
-            'dead-ffi': 0,
-            'dead-unresolved': 0,
-            'test-only': 0,
-            leaf: 0,
-        };
-    }
+    if (rows.length === 0 && leafRows.length === 0)
+        return emptySummary;
     const exportedIds = new Set(db
         .prepare(`SELECT DISTINCT e.target_id
         FROM edges e
         JOIN nodes caller ON e.source_id = caller.id
         JOIN nodes target ON e.target_id = target.id
         WHERE e.kind = 'calls' AND caller.file != target.file`)
-        .all()
-        .map((r) => r.target_id));
+        .all().map((r) => r.target_id));
     // Compute production fan-in (excluding callers in test files)
     const prodFanInMap = new Map();
     const prodRows = db
@@ -325,272 +334,195 @@ export function classifyNodeRoles(db) {
         productionFanIn: prodFanInMap.get(r.id) || 0,
     }));
     const roleMap = classifyRoles(classifierInput);
-    // Build summary and updates
-    const summary = {
-        entry: 0,
-        core: 0,
-        utility: 0,
-        adapter: 0,
-        dead: 0,
-        'dead-leaf': 0,
-        'dead-entry': 0,
-        'dead-ffi': 0,
-        'dead-unresolved': 0,
-        'test-only': 0,
-        leaf: 0,
-    };
-    const updates = [];
+    // Build summary and group updates by role for batch UPDATE
+    const summary = { ...emptySummary };
+    const idsByRole = new Map();
+    // Leaf kinds are always dead-leaf -- skip classifier
+    if (leafRows.length > 0) {
+        const leafIds = [];
+        for (const row of leafRows)
+            leafIds.push(row.id);
+        idsByRole.set('dead-leaf', leafIds);
+        summary.dead += leafRows.length;
+        summary['dead-leaf'] += leafRows.length;
+    }
     for (const row of rows) {
         const role = roleMap.get(String(row.id)) || 'leaf';
-        updates.push({ id: row.id, role });
         if (role.startsWith('dead'))
             summary.dead++;
         summary[role] = (summary[role] || 0) + 1;
+        let ids = idsByRole.get(role);
+        if (!ids) {
+            ids = [];
+            idsByRole.set(role, ids);
+        }
+        ids.push(row.id);
     }
-    const clearRoles = db.prepare('UPDATE nodes SET role = NULL');
-    const setRole = db.prepare('UPDATE nodes SET role = ? WHERE id = ?');
+    // Batch UPDATE: one statement per role instead of one per node
+    const ROLE_CHUNK = 500;
+    const roleStmtCache = new Map();
     db.transaction(() => {
-        clearRoles.run();
-        for (const u of updates) {
-            setRole.run(u.role, u.id);
+        db.prepare('UPDATE nodes SET role = NULL').run();
+        for (const [role, ids] of idsByRole) {
+            for (let i = 0; i < ids.length; i += ROLE_CHUNK) {
+                const end = Math.min(i + ROLE_CHUNK, ids.length);
+                const chunkSize = end - i;
+                let stmt = roleStmtCache.get(chunkSize);
+                if (!stmt) {
+                    const placeholders = Array.from({ length: chunkSize }, () => '?').join(',');
+                    stmt = db.prepare(`UPDATE nodes SET role = ? WHERE id IN (${placeholders})`);
+                    roleStmtCache.set(chunkSize, stmt);
+                }
+                const vals = [role];
+                for (let j = i; j < end; j++)
+                    vals.push(ids[j]);
+                stmt.run(...vals);
+            }
         }
     })();
     return summary;
 }
-// ─── Query functions (read-only) ──────────────────────────────────────
 /**
- * Return hierarchical directory tree with metrics.
+ * Incremental role classification: only reclassify nodes from changed files
+ * plus their immediate edge neighbours (callers and callees in other files).
+ *
+ * Uses indexed point lookups for fan-in/fan-out instead of full table scans.
+ * Global medians are computed from edge distribution (fast GROUP BY on index).
+ * Unchanged files not connected to changed files keep their roles from the
+ * previous build.
  */
-export function structureData(customDbPath, opts = {}) {
-    const db = openReadonlyOrFail(customDbPath);
-    try {
-        const rawDir = opts.directory || null;
-        const filterDir = rawDir && normalizePath(rawDir) !== '.' ? rawDir : null;
-        const maxDepth = opts.depth || null;
-        const sortBy = opts.sort || 'files';
-        const noTests = opts.noTests || false;
-        const full = opts.full || false;
-        const fileLimit = opts.fileLimit || 25;
-        // Get all directory nodes with their metrics
-        let dirs = db
-            .prepare(`
-        SELECT n.id, n.name, n.file, nm.symbol_count, nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n
-        LEFT JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = 'directory'
-      `)
-            .all();
-        if (filterDir) {
-            const norm = normalizePath(filterDir);
-            dirs = dirs.filter((d) => d.name === norm || d.name.startsWith(`${norm}/`));
-        }
-        if (maxDepth) {
-            const baseDepth = filterDir ? normalizePath(filterDir).split('/').length : 0;
-            dirs = dirs.filter((d) => {
-                const depth = d.name.split('/').length - baseDepth;
-                return depth <= maxDepth;
-            });
-        }
-        // Sort
-        const sortFn = getSortFn(sortBy);
-        dirs.sort(sortFn);
-        // Get file metrics for each directory
-        const result = dirs.map((d) => {
-            let files = db
-                .prepare(`
-          SELECT n.name, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count, nm.fan_in, nm.fan_out
-          FROM edges e
-          JOIN nodes n ON e.target_id = n.id
-          LEFT JOIN node_metrics nm ON n.id = nm.node_id
-          WHERE e.source_id = ? AND e.kind = 'contains' AND n.kind = 'file'
-        `)
-                .all(d.id);
-            if (noTests)
-                files = files.filter((f) => !isTestFile(f.name));
-            const subdirs = db
-                .prepare(`
-          SELECT n.name
+function classifyNodeRolesIncremental(db, changedFiles, emptySummary) {
+    // Expand affected set: include files containing nodes that are edge neighbours
+    // of changed-file nodes. This ensures that removing a call from file A to a
+    // node in file B causes B's roles to be recalculated (fan_in changed).
+    const seedPlaceholders = changedFiles.map(() => '?').join(',');
+    const neighbourFiles = db
+        .prepare(`SELECT DISTINCT n2.file FROM edges e
+       JOIN nodes n1 ON (e.source_id = n1.id OR e.target_id = n1.id)
+       JOIN nodes n2 ON (e.source_id = n2.id OR e.target_id = n2.id)
+       WHERE e.kind = 'calls'
+         AND n1.file IN (${seedPlaceholders})
+         AND n2.file NOT IN (${seedPlaceholders})
+         AND n2.kind NOT IN ('file', 'directory')`)
+        .all(...changedFiles, ...changedFiles);
+    const allAffectedFiles = [...changedFiles, ...neighbourFiles.map((r) => r.file)];
+    const placeholders = allAffectedFiles.map(() => '?').join(',');
+    // 1. Compute global medians from edge distribution (fast: scans edge index, no node join)
+    const fanInDist = db
+        .prepare(`SELECT COUNT(*) AS cnt FROM edges WHERE kind = 'calls' GROUP BY target_id`)
+        .all()
+        .map((r) => r.cnt)
+        .sort((a, b) => a - b);
+    const fanOutDist = db
+        .prepare(`SELECT COUNT(*) AS cnt FROM edges WHERE kind = 'calls' GROUP BY source_id`)
+        .all()
+        .map((r) => r.cnt)
+        .sort((a, b) => a - b);
+    const globalMedians = { fanIn: median(fanInDist), fanOut: median(fanOutDist) };
+    // 2a. Leaf kinds (parameter, property) in affected files — always dead-leaf
+    const leafRows = db
+        .prepare(`SELECT n.id FROM nodes n
+      WHERE n.kind IN ('parameter', 'property')
+        AND n.file IN (${placeholders})`)
+        .all(...allAffectedFiles);
+    // 2b. Get callable nodes using indexed correlated subqueries (fast point lookups)
+    const rows = db
+        .prepare(`SELECT n.id, n.name, n.kind, n.file,
+        (SELECT COUNT(*) FROM edges WHERE kind = 'calls' AND target_id = n.id) AS fan_in,
+        (SELECT COUNT(*) FROM edges WHERE kind = 'calls' AND source_id = n.id) AS fan_out
+      FROM nodes n
+      WHERE n.kind NOT IN ('file', 'directory', 'parameter', 'property')
+        AND n.file IN (${placeholders})`)
+        .all(...allAffectedFiles);
+    if (rows.length === 0 && leafRows.length === 0)
+        return emptySummary;
+    // 3. Get exported status for affected nodes only (scoped to changed files)
+    const exportedIds = new Set(db
+        .prepare(`SELECT DISTINCT e.target_id
           FROM edges e
-          JOIN nodes n ON e.target_id = n.id
-          WHERE e.source_id = ? AND e.kind = 'contains' AND n.kind = 'directory'
-        `)
-                .all(d.id);
-            const fileCount = noTests ? files.length : d.file_count || 0;
-            return {
-                directory: d.name,
-                fileCount,
-                symbolCount: d.symbol_count || 0,
-                fanIn: d.fan_in || 0,
-                fanOut: d.fan_out || 0,
-                cohesion: d.cohesion,
-                density: fileCount > 0 ? (d.symbol_count || 0) / fileCount : 0,
-                files: files.map((f) => ({
-                    file: f.name,
-                    lineCount: f.line_count || 0,
-                    symbolCount: f.symbol_count || 0,
-                    importCount: f.import_count || 0,
-                    exportCount: f.export_count || 0,
-                    fanIn: f.fan_in || 0,
-                    fanOut: f.fan_out || 0,
-                })),
-                subdirectories: subdirs.map((s) => s.name),
-            };
-        });
-        // Apply global file limit unless full mode
-        if (!full) {
-            const totalFiles = result.reduce((sum, d) => sum + d.files.length, 0);
-            if (totalFiles > fileLimit) {
-                let shown = 0;
-                for (const d of result) {
-                    const remaining = fileLimit - shown;
-                    if (remaining <= 0) {
-                        d.files = [];
-                    }
-                    else if (d.files.length > remaining) {
-                        d.files = d.files.slice(0, remaining);
-                        shown = fileLimit;
-                    }
-                    else {
-                        shown += d.files.length;
-                    }
-                }
-                const suppressed = totalFiles - fileLimit;
-                return {
-                    directories: result,
-                    count: result.length,
-                    suppressed,
-                    warning: `${suppressed} files omitted (showing ${fileLimit}/${totalFiles}). Use --full to show all files, or narrow with --directory.`,
-                };
-            }
-        }
-        const base = { directories: result, count: result.length };
-        return paginateResult(base, 'directories', { limit: opts.limit, offset: opts.offset });
-    }
-    finally {
-        db.close();
-    }
-}
-/**
- * Return top N files or directories ranked by a chosen metric.
- */
-export function hotspotsData(customDbPath, opts = {}) {
-    const db = openReadonlyOrFail(customDbPath);
-    try {
-        const metric = opts.metric || 'fan-in';
-        const level = opts.level || 'file';
-        const limit = opts.limit || 10;
-        const noTests = opts.noTests || false;
-        const kind = level === 'directory' ? 'directory' : 'file';
-        const testFilter = testFilterSQL('n.name', noTests && kind === 'file');
-        const HOTSPOT_QUERIES = {
-            'fan-in': db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY nm.fan_in DESC NULLS LAST LIMIT ?`),
-            'fan-out': db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY nm.fan_out DESC NULLS LAST LIMIT ?`),
-            density: db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY nm.symbol_count DESC NULLS LAST LIMIT ?`),
-            coupling: db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY (COALESCE(nm.fan_in, 0) + COALESCE(nm.fan_out, 0)) DESC NULLS LAST LIMIT ?`),
-        };
-        const stmt = HOTSPOT_QUERIES[metric] || HOTSPOT_QUERIES['fan-in'];
-        const rows = stmt.all(kind, limit);
-        const hotspots = rows.map((r) => ({
-            name: r.name,
-            kind: r.kind,
-            lineCount: r.line_count,
-            symbolCount: r.symbol_count,
-            importCount: r.import_count,
-            exportCount: r.export_count,
-            fanIn: r.fan_in,
-            fanOut: r.fan_out,
-            cohesion: r.cohesion,
-            fileCount: r.file_count,
-            density: r.file_count > 0
-                ? (r.symbol_count || 0) / r.file_count
-                : r.line_count > 0
-                    ? (r.symbol_count || 0) / r.line_count
-                    : 0,
-            coupling: (r.fan_in || 0) + (r.fan_out || 0),
-        }));
-        const base = { metric, level, limit, hotspots };
-        return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });
-    }
-    finally {
-        db.close();
-    }
-}
-/**
- * Return directories with cohesion above threshold, with top exports/imports.
- */
-export function moduleBoundariesData(customDbPath, opts = {}) {
-    const db = openReadonlyOrFail(customDbPath);
-    try {
-        const config = opts.config || loadConfig();
-        const threshold = opts.threshold ?? config.structure?.cohesionThreshold ?? 0.3;
-        const dirs = db
-            .prepare(`
-        SELECT n.id, n.name, nm.symbol_count, nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n
-        JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = 'directory' AND nm.cohesion IS NOT NULL AND nm.cohesion >= ?
-        ORDER BY nm.cohesion DESC
-      `)
-            .all(threshold);
-        const modules = dirs.map((d) => {
-            // Get files inside this directory
-            const files = db
-                .prepare(`
-          SELECT n.name FROM edges e
-          JOIN nodes n ON e.target_id = n.id
-          WHERE e.source_id = ? AND e.kind = 'contains' AND n.kind = 'file'
-        `)
-                .all(d.id)
-                .map((f) => f.name);
-            return {
-                directory: d.name,
-                cohesion: d.cohesion,
-                fileCount: d.file_count || 0,
-                symbolCount: d.symbol_count || 0,
-                fanIn: d.fan_in || 0,
-                fanOut: d.fan_out || 0,
-                files,
-            };
-        });
-        return { threshold, modules, count: modules.length };
+          JOIN nodes caller ON e.source_id = caller.id
+          JOIN nodes target ON e.target_id = target.id
+          WHERE e.kind = 'calls' AND caller.file != target.file
+            AND target.file IN (${placeholders})`)
+        .all(...allAffectedFiles).map((r) => r.target_id));
+    // 4. Production fan-in for affected nodes only
+    const prodFanInMap = new Map();
+    const prodRows = db
+        .prepare(`SELECT e.target_id, COUNT(*) AS cnt
+      FROM edges e
+      JOIN nodes caller ON e.source_id = caller.id
+      JOIN nodes target ON e.target_id = target.id
+      WHERE e.kind = 'calls'
+        AND target.file IN (${placeholders})
+        ${testFilterSQL('caller.file')}
+      GROUP BY e.target_id`)
+        .all(...allAffectedFiles);
+    for (const r of prodRows) {
+        prodFanInMap.set(r.target_id, r.cnt);
     }
-    finally {
-        db.close();
+    // 5. Classify affected nodes using global medians
+    const classifierInput = rows.map((r) => ({
+        id: String(r.id),
+        name: r.name,
+        kind: r.kind,
+        file: r.file,
+        fanIn: r.fan_in,
+        fanOut: r.fan_out,
+        isExported: exportedIds.has(r.id),
+        productionFanIn: prodFanInMap.get(r.id) || 0,
+    }));
+    const roleMap = classifyRoles(classifierInput, globalMedians);
+    // 6. Build summary (only for affected nodes) and update only those nodes
+    const summary = { ...emptySummary };
+    const idsByRole = new Map();
+    // Leaf kinds are always dead-leaf -- skip classifier
+    if (leafRows.length > 0) {
+        const leafIds = [];
+        for (const row of leafRows)
+            leafIds.push(row.id);
+        idsByRole.set('dead-leaf', leafIds);
+        summary.dead += leafRows.length;
+        summary['dead-leaf'] += leafRows.length;
     }
-}
-// ─── Helpers ──────────────────────────────────────────────────────────
-function getSortFn(sortBy) {
-    switch (sortBy) {
-        case 'cohesion':
-            return (a, b) => (b.cohesion ?? -1) - (a.cohesion ?? -1);
-        case 'fan-in':
-            return (a, b) => (b.fan_in || 0) - (a.fan_in || 0);
-        case 'fan-out':
-            return (a, b) => (b.fan_out || 0) - (a.fan_out || 0);
-        case 'density':
-            return (a, b) => {
-                const da = a.file_count > 0 ? (a.symbol_count || 0) / a.file_count : 0;
-                const db_ = b.file_count > 0 ? (b.symbol_count || 0) / b.file_count : 0;
-                return db_ - da;
-            };
-        default:
-            return (a, b) => a.name.localeCompare(b.name);
+    for (const row of rows) {
+        const role = roleMap.get(String(row.id)) || 'leaf';
+        if (role.startsWith('dead'))
+            summary.dead++;
+        summary[role] = (summary[role] || 0) + 1;
+        let ids = idsByRole.get(role);
+        if (!ids) {
+            ids = [];
+            idsByRole.set(role, ids);
+        }
+        ids.push(row.id);
     }
+    // Only update affected nodes — no global NULL reset
+    const ROLE_CHUNK = 500;
+    const roleStmtCache = new Map();
+    db.transaction(() => {
+        // Reset roles only for affected files' nodes
+        db.prepare(`UPDATE nodes SET role = NULL WHERE file IN (${placeholders}) AND kind NOT IN ('file', 'directory')`).run(...allAffectedFiles);
+        for (const [role, ids] of idsByRole) {
+            for (let i = 0; i < ids.length; i += ROLE_CHUNK) {
+                const end = Math.min(i + ROLE_CHUNK, ids.length);
+                const chunkSize = end - i;
+                let stmt = roleStmtCache.get(chunkSize);
+                if (!stmt) {
+                    const ph = Array.from({ length: chunkSize }, () => '?').join(',');
+                    stmt = db.prepare(`UPDATE nodes SET role = ? WHERE id IN (${ph})`);
+                    roleStmtCache.set(chunkSize, stmt);
+                }
+                const vals = [role];
+                for (let j = i; j < end; j++)
+                    vals.push(ids[j]);
+                stmt.run(...vals);
+            }
+        }
+    })();
+    return summary;
 }
+// ─── Query functions (re-exported from structure-query.ts) ────────────
+// Split to separate query-time concerns (DB reads, sorting, pagination)
+// from build-time concerns (directory insertion, metrics computation, role classification).
+export { hotspotsData, moduleBoundariesData, structureData } from './structure-query.js';
 //# sourceMappingURL=structure.js.map