@zuvia-software-solutions/code-mapper 1.4.0 → 2.0.1

package/dist/core/incremental/child-process.js

@@ -1,649 +0,0 @@
-// code-mapper/src/core/incremental/child-process.ts
-/**
- * @file child-process.ts
- * @description Forked child process entry point for incremental DB updates. Opens
- *   LadybugDB in READ-WRITE mode, deletes stale nodes for changed files, re-parses
- *   them with tree-sitter, inserts new nodes/edges, resolves imports/calls/heritage,
- *   and rebuilds FTS indexes. Communicates with the parent via structured IPC messages
- */
-import fs from 'fs/promises';
-import path from 'path';
-import Parser from 'tree-sitter';
-import lbug from '@ladybugdb/core';
-import { parseParentMessage, } from './types.js';
-import { NODE_TABLES, REL_TABLE_NAME } from '../lbug/schema.js';
-import { LANGUAGE_QUERIES } from '../ingestion/tree-sitter-queries.js';
-import { getLanguageFromFilename, getDefinitionNodeFromCaptures } from '../ingestion/utils.js';
-import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
-import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from '../ingestion/constants.js';
-import { generateId } from '../../lib/utils.js';
-import { FTS_TABLES } from '../search/types.js';
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-/** Tables that require backtick-quoting in Cypher because they collide with reserved words */
-const BACKTICK_TABLES = new Set([
-    'Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
-    'TypeAlias', 'Const', 'Static', 'Property', 'Record', 'Delegate', 'Annotation',
-    'Constructor', 'Template', 'Module',
-]);
-/** Tables that are global metadata and should NOT be deleted per-file */
-const SKIP_DELETE_TABLES = new Set(['Community', 'Process']);
-// ---------------------------------------------------------------------------
-// IPC helpers — all outbound messages go through sendMessage()
-// ---------------------------------------------------------------------------
-function sendMessage(msg) {
-    if (typeof process.send === 'function') {
-        process.send(msg);
-    }
-}
-function sendSuccess(payload) {
-    sendMessage({ kind: 'success', payload });
-}
-function sendError(err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const stack = err instanceof Error ? err.stack : undefined;
-    sendMessage({ kind: 'error', message, stack });
-}
-// Typed progress sender to avoid inline casting
-function progress(phase, detail) {
-    sendMessage({ kind: 'progress', phase, detail });
-}
-/** Log a non-fatal warning to stderr so it's visible in MCP server logs */
-function warn(context, err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[incremental-child] ${context}: ${msg}\n`);
-}
-// ---------------------------------------------------------------------------
-// Cypher helpers
-// ---------------------------------------------------------------------------
-/** Quote a table name for Cypher if it requires backticks */
-function quoteTable(table) {
-    return BACKTICK_TABLES.has(table) ? `\`${table}\`` : table;
-}
-/** Escape a string value for use inside a Cypher single-quoted literal */
-function escapeCypher(value) {
-    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-}
-// ---------------------------------------------------------------------------
-// Existing file paths (passed from parent via env)
-// ---------------------------------------------------------------------------
-function loadExistingPaths() {
-    const raw = process.env.CODE_MAPPER_EXISTING_PATHS;
-    if (!raw)
-        return new Set();
-    try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed))
-            return new Set();
-        return new Set(parsed.filter((p) => typeof p === 'string'));
-    }
-    catch {
-        return new Set();
-    }
-}
-// ---------------------------------------------------------------------------
-// Core refresh pipeline
-// ---------------------------------------------------------------------------
-async function runRefresh(payload) {
-    const t0 = Date.now();
-    const { repoRoot, dbPath, dirtyFiles } = payload;
-    const existingPaths = loadExistingPaths();
-    let nodesDeleted = 0;
-    let nodesInserted = 0;
-    let edgesInserted = 0;
-    let filesSkipped = 0;
-    // -- Open DB in READ-WRITE mode -----------------------------------------
-    // If this fails with a lock error, the parent process didn't release its
-    // read-only handle before forking. This is a bug in the coordinator flow.
-    let db;
-    let conn;
-    try {
-        db = new lbug.Database(dbPath);
-        conn = new lbug.Connection(db);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to open DB for write: ${msg} (dbPath=${dbPath})`);
-    }
-    try {
-        // =====================================================================
-        // Phase 1 — Delete old nodes for all dirty files
-        // =====================================================================
-        progress('deleting-old-nodes', `Deleting nodes for ${dirtyFiles.length} file(s)`);
-        for (const entry of dirtyFiles) {
-            const escaped = escapeCypher(entry.relativePath);
-            for (const table of NODE_TABLES) {
-                if (SKIP_DELETE_TABLES.has(table))
-                    continue;
-                const quoted = quoteTable(table);
-                try {
-                    await conn.query(`MATCH (n:${quoted}) WHERE n.filePath = '${escaped}' DETACH DELETE n`);
-                    nodesDeleted += 1; // Approximate — one query per table per file
-                }
-                catch (err) {
-                    warn(`DELETE ${table} for ${entry.relativePath}`, err);
-                }
-            }
-        }
-        // =====================================================================
-        // Phase 2 — Parse changed/created files with tree-sitter
-        // =====================================================================
-        progress('parsing', 'Parsing modified and created files');
-        const parser = await loadParser();
-        const allDefinitions = [];
-        const allImports = [];
-        const allCalls = [];
-        const allHeritage = [];
-        // Track File nodes we insert so we know which files are in the DB
-        const insertedFilePaths = new Set();
-        const filesToProcess = dirtyFiles.filter((f) => f.changeKind === 'modified' || f.changeKind === 'created');
-        for (const entry of filesToProcess) {
-            const relPath = entry.relativePath;
-            const absPath = path.resolve(repoRoot, relPath);
-            // Determine language
-            const language = getLanguageFromFilename(relPath);
-            if (!language) {
-                filesSkipped += 1;
-                continue;
-            }
-            if (!isLanguageAvailable(language)) {
-                filesSkipped += 1;
-                continue;
-            }
-            // Read file content from disk
-            let content;
-            try {
-                content = await fs.readFile(absPath, 'utf-8');
-            }
-            catch {
-                // File may have been deleted between detection and processing
-                filesSkipped += 1;
-                continue;
-            }
-            // Skip files exceeding tree-sitter buffer limits
-            if (content.length > TREE_SITTER_MAX_BUFFER) {
-                filesSkipped += 1;
-                continue;
-            }
-            // Load language and parse
-            try {
-                await loadLanguage(language, relPath);
-            }
-            catch {
-                filesSkipped += 1;
-                continue;
-            }
-            let tree;
-            try {
-                tree = parser.parse(content, undefined, {
-                    bufferSize: getTreeSitterBufferSize(content.length),
-                });
-            }
-            catch {
-                filesSkipped += 1;
-                continue;
-            }
-            // Run tree-sitter queries to extract definitions, imports, calls, heritage
-            const queryString = LANGUAGE_QUERIES[language];
-            if (!queryString) {
-                filesSkipped += 1;
-                continue;
-            }
-            let query;
-            let matches;
-            try {
-                const tsLanguage = parser.getLanguage();
-                query = new Parser.Query(tsLanguage, queryString);
-                matches = query.matches(tree.rootNode);
-            }
-            catch {
-                filesSkipped += 1;
-                continue;
-            }
-            // Track this file for File node insertion
-            insertedFilePaths.add(relPath);
-            // Process each match
-            for (const match of matches) {
-                const captureMap = {};
-                for (const c of match.captures) {
-                    captureMap[c.name] = c.node;
-                }
-                // -- Extract imports ------------------------------------------------
-                if (captureMap['import'] || captureMap['import.source']) {
-                    const sourceNode = captureMap['import.source'];
-                    if (sourceNode) {
-                        // Strip surrounding quotes from import source
-                        const raw = sourceNode.text;
-                        const source = raw.replace(/^['"`]|['"`]$/g, '');
-                        allImports.push({ filePath: relPath, source });
-                    }
-                    continue;
-                }
-                // -- Extract calls --------------------------------------------------
-                if (captureMap['call'] || captureMap['call.name']) {
-                    const callNameNode = captureMap['call.name'];
-                    if (callNameNode) {
-                        allCalls.push({
-                            filePath: relPath,
-                            callerNodeId: null, // Simplified — we don't track the caller node
-                            calleeName: callNameNode.text,
-                        });
-                    }
-                    continue;
-                }
-                // -- Extract heritage -----------------------------------------------
-                if (captureMap['heritage'] || captureMap['heritage.impl']) {
-                    const classNameNode = captureMap['heritage.class'];
-                    const extendsNode = captureMap['heritage.extends'];
-                    const implementsNode = captureMap['heritage.implements'];
-                    if (classNameNode && extendsNode) {
-                        const className = classNameNode.text;
-                        allHeritage.push({
-                            filePath: relPath,
-                            className,
-                            classNodeId: generateId('Class', `${relPath}:${className}`),
-                            parentName: extendsNode.text,
-                            kind: 'extends',
-                        });
-                    }
-                    if (classNameNode && implementsNode) {
-                        const className = classNameNode.text;
-                        allHeritage.push({
-                            filePath: relPath,
-                            className,
-                            classNodeId: generateId('Class', `${relPath}:${className}`),
-                            parentName: implementsNode.text,
-                            kind: 'implements',
-                        });
-                    }
-                    continue;
-                }
-                // -- Extract definitions --------------------------------------------
-                const nameNode = captureMap['name'];
-                if (!nameNode && !captureMap['definition.constructor'])
-                    continue;
-                const nodeName = nameNode ? nameNode.text : 'init';
-                let nodeLabel = 'CodeElement';
-                if (captureMap['definition.function'])
-                    nodeLabel = 'Function';
-                else if (captureMap['definition.class'])
-                    nodeLabel = 'Class';
-                else if (captureMap['definition.interface'])
-                    nodeLabel = 'Interface';
-                else if (captureMap['definition.method'])
-                    nodeLabel = 'Method';
-                else if (captureMap['definition.struct'])
-                    nodeLabel = 'Struct';
-                else if (captureMap['definition.enum'])
-                    nodeLabel = 'Enum';
-                else if (captureMap['definition.namespace'])
-                    nodeLabel = 'Namespace';
-                else if (captureMap['definition.module'])
-                    nodeLabel = 'Module';
-                else if (captureMap['definition.trait'])
-                    nodeLabel = 'Trait';
-                else if (captureMap['definition.impl'])
-                    nodeLabel = 'Impl';
-                else if (captureMap['definition.type'])
-                    nodeLabel = 'TypeAlias';
-                else if (captureMap['definition.const'])
-                    nodeLabel = 'Const';
-                else if (captureMap['definition.static'])
-                    nodeLabel = 'Static';
-                else if (captureMap['definition.typedef'])
-                    nodeLabel = 'Typedef';
-                else if (captureMap['definition.macro'])
-                    nodeLabel = 'Macro';
-                else if (captureMap['definition.union'])
-                    nodeLabel = 'Union';
-                else if (captureMap['definition.property'])
-                    nodeLabel = 'Property';
-                else if (captureMap['definition.record'])
-                    nodeLabel = 'Record';
-                else if (captureMap['definition.delegate'])
-                    nodeLabel = 'Delegate';
-                else if (captureMap['definition.annotation'])
-                    nodeLabel = 'Annotation';
-                else if (captureMap['definition.constructor'])
-                    nodeLabel = 'Constructor';
-                else if (captureMap['definition.template'])
-                    nodeLabel = 'Template';
-                const definitionNode = getDefinitionNodeFromCaptures(captureMap);
-                const startLine = definitionNode
-                    ? definitionNode.startPosition.row
-                    : (nameNode ? nameNode.startPosition.row : 0);
-                const endLine = definitionNode
-                    ? definitionNode.endPosition.row
-                    : startLine;
-                const nodeId = generateId(nodeLabel, `${relPath}:${nodeName}`);
-                // Truncate content — aligned with csv-generator MAX_SNIPPET (50K)
-                const nodeContent = definitionNode
-                    ? (definitionNode.text || '').slice(0, 50_000)
-                    : '';
-                allDefinitions.push({
-                    nodeId,
-                    name: nodeName,
-                    label: nodeLabel,
-                    filePath: relPath,
-                    startLine,
-                    endLine,
-                    content: nodeContent,
-                });
-            }
-        }
-        // =====================================================================
-        // Phase 3 — Insert File nodes + symbol nodes into DB
-        // =====================================================================
-        progress('inserting-nodes', `Inserting ${allDefinitions.length} symbol(s) across ${insertedFilePaths.size} file(s)`);
-        // Insert File nodes
-        for (const filePath of insertedFilePaths) {
-            const fileId = generateId('File', filePath);
-            const fileName = path.basename(filePath);
-            const escapedPath = escapeCypher(filePath);
-            const escapedName = escapeCypher(fileName);
-            try {
-                await conn.query(`CREATE (n:File {id: '${escapeCypher(fileId)}', name: '${escapedName}', filePath: '${escapedPath}', content: ''})`);
-                nodesInserted += 1;
-            }
-            catch (err) {
-                warn(`CREATE File node ${filePath}`, err);
-            }
-        }
-        // Insert symbol (definition) nodes
-        for (const def of allDefinitions) {
-            const quoted = quoteTable(def.label);
-            const escapedId = escapeCypher(def.nodeId);
-            const escapedName = escapeCypher(def.name);
-            const escapedPath = escapeCypher(def.filePath);
-            const escapedContent = escapeCypher(def.content);
-            try {
-                await conn.query(`CREATE (n:${quoted} {id: '${escapedId}', name: '${escapedName}', filePath: '${escapedPath}', startLine: ${def.startLine}, endLine: ${def.endLine}, content: '${escapedContent}', description: ''})`);
-                nodesInserted += 1;
-            }
-            catch (err) {
-                warn(`CREATE ${def.label} node ${def.name} in ${def.filePath}`, err);
-            }
-            // Create DEFINES edge from File to symbol
-            const fileId = generateId('File', def.filePath);
-            try {
-                await conn.query(`MATCH (a:File), (b:${quoted}) WHERE a.id = '${escapeCypher(fileId)}' AND b.id = '${escapedId}' CREATE (a)-[:${REL_TABLE_NAME} {type: 'DEFINES', confidence: 1.0, reason: '', step: 0}]->(b)`);
-                edgesInserted += 1;
-            }
-            catch (err) {
-                warn(`CREATE DEFINES edge File→${def.label} for ${def.name}`, err);
-            }
-        }
-        // =====================================================================
-        // Phase 4 — Resolve imports
-        // =====================================================================
-        progress('resolving-imports', `Resolving ${allImports.length} import(s)`);
-        // Build a set of all known file paths (existing + newly inserted)
-        const allKnownPaths = new Set(existingPaths);
-        for (const fp of insertedFilePaths) {
-            allKnownPaths.add(fp);
-        }
-        for (const imp of allImports) {
-            const targetPath = resolveImportSource(imp.source, imp.filePath, allKnownPaths);
-            if (!targetPath)
-                continue;
-            const fromFileId = generateId('File', imp.filePath);
-            const toFileId = generateId('File', targetPath);
-            try {
-                await conn.query(`MATCH (a:File), (b:File) WHERE a.id = '${escapeCypher(fromFileId)}' AND b.id = '${escapeCypher(toFileId)}' CREATE (a)-[:${REL_TABLE_NAME} {type: 'IMPORTS', confidence: 0.9, reason: 'incremental-import-resolution', step: 0}]->(b)`);
-                edgesInserted += 1;
-            }
-            catch (err) {
-                warn(`CREATE IMPORTS edge ${imp.filePath}→${targetPath}`, err);
-            }
-        }
-        // =====================================================================
-        // Phase 5 — Resolve calls
-        // =====================================================================
-        progress('resolving-calls', `Resolving ${allCalls.length} call site(s)`);
-        // Build a set of files that the current file imports (for preference scoring)
-        const fileImportTargets = new Map();
-        for (const imp of allImports) {
-            const targetPath = resolveImportSource(imp.source, imp.filePath, allKnownPaths);
-            if (targetPath) {
-                let targets = fileImportTargets.get(imp.filePath);
-                if (!targets) {
-                    targets = new Set();
-                    fileImportTargets.set(imp.filePath, targets);
-                }
-                targets.add(targetPath);
-            }
-        }
-        for (const call of allCalls) {
-            const calleeName = call.calleeName;
-            const escapedCalleeName = escapeCypher(calleeName);
-            // Query DB for candidate targets
-            let candidates;
-            try {
-                const result = await conn.query(`MATCH (n) WHERE n.name = '${escapedCalleeName}' AND (n:Function OR n:Method OR n:Class OR n:Constructor) RETURN n.id AS id, n.filePath AS filePath LIMIT 5`);
-                const resultObj = Array.isArray(result) ? result[0] : result;
-                const rows = await resultObj.getAll();
-                candidates = rows.map((row) => ({
-                    id: String(row.id ?? ''),
-                    filePath: String(row.filePath ?? ''),
-                }));
-            }
-            catch (err) {
-                warn(`query call candidates for ${calleeName}`, err);
-                continue;
-            }
-            if (candidates.length === 0)
-                continue;
-            // Pick the best candidate: prefer same-file, then imported file, then any
-            const importedFiles = fileImportTargets.get(call.filePath);
-            let best = candidates[0];
-            for (const c of candidates) {
-                if (c.filePath === call.filePath) {
-                    best = c;
-                    break;
-                }
-                if (importedFiles?.has(c.filePath)) {
-                    best = c;
-                    // Don't break — same-file is still better
-                }
-            }
-            // Determine confidence based on match quality
-            let confidence = 0.5;
-            if (best.filePath === call.filePath)
-                confidence = 0.9;
-            else if (importedFiles?.has(best.filePath))
-                confidence = 0.8;
-            // Determine caller node — use the first definition in this file, or the file itself
-            const callerFileId = generateId('File', call.filePath);
-            const escapedCallerId = escapeCypher(callerFileId);
-            const escapedTargetId = escapeCypher(best.id);
-            try {
-                await conn.query(`MATCH (a:File), (b) WHERE a.id = '${escapedCallerId}' AND b.id = '${escapedTargetId}' CREATE (a)-[:${REL_TABLE_NAME} {type: 'CALLS', confidence: ${confidence}, reason: 'incremental-call-resolution', step: 0}]->(b)`);
-                edgesInserted += 1;
-            }
-            catch (err) {
-                warn(`CREATE CALLS edge for ${call.calleeName}`, err);
-            }
-        }
-        // =====================================================================
-        // Phase 6 — Resolve heritage (extends/implements)
-        // =====================================================================
-        progress('resolving-heritage', `Resolving ${allHeritage.length} heritage relationship(s)`);
-        for (const h of allHeritage) {
-            const escapedParentName = escapeCypher(h.parentName);
-            const relType = h.kind === 'extends' ? 'EXTENDS' : 'IMPLEMENTS';
-            // Query DB for the parent class/interface
-            let parentId = null;
-            try {
-                const result = await conn.query(`MATCH (n) WHERE n.name = '${escapedParentName}' AND (n:Class OR n:Interface OR n:\`Struct\` OR n:\`Trait\`) RETURN n.id AS id LIMIT 1`);
-                const resultObj = Array.isArray(result) ? result[0] : result;
-                const rows = await resultObj.getAll();
-                if (rows.length > 0) {
-                    parentId = String(rows[0].id ?? '');
-                }
-            }
-            catch (err) {
-                warn(`query heritage parent ${h.parentName}`, err);
-                continue;
-            }
-            if (!parentId)
-                continue;
-            const escapedClassId = escapeCypher(h.classNodeId);
-            const escapedParentId = escapeCypher(parentId);
-            try {
-                await conn.query(`MATCH (a), (b) WHERE a.id = '${escapedClassId}' AND b.id = '${escapedParentId}' CREATE (a)-[:${REL_TABLE_NAME} {type: '${relType}', confidence: 1.0, reason: 'incremental-heritage-resolution', step: 0}]->(b)`);
-                edgesInserted += 1;
-            }
-            catch (err) {
-                warn(`CREATE ${relType} edge ${h.className}→${h.parentName}`, err);
-            }
-        }
-        // =====================================================================
-        // Phase 7 — Rebuild FTS indexes
-        // =====================================================================
-        progress('rebuilding-fts', 'Rebuilding full-text search indexes');
-        // Load FTS extension
-        try {
-            await conn.query('INSTALL fts');
-            await conn.query('LOAD EXTENSION fts');
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : '';
-            if (!msg.includes('already loaded') && !msg.includes('already installed') && !msg.includes('already exists')) {
-                // FTS extension unavailable — skip FTS rebuild, not fatal
-                progress('rebuilding-fts', 'FTS extension unavailable, skipping');
-            }
-        }
-        // Drop and recreate each FTS index
-        for (const { table, index } of FTS_TABLES) {
-            try {
-                await conn.query(`CALL DROP_FTS_INDEX('${table}', '${index}')`);
-            }
-            catch {
-                // Index may not exist — ignore
-            }
-            try {
-                await conn.query(`CALL CREATE_FTS_INDEX('${table}', '${index}', ['name', 'content'], stemmer := 'porter')`);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : '';
-                if (!msg.includes('already exists')) {
-                    // Non-fatal — log but continue
-                }
-            }
-        }
-        // =====================================================================
-        // Done
-        // =====================================================================
-        progress('done', 'Refresh complete');
-        const result = {
-            filesProcessed: filesToProcess.length,
-            filesSkipped,
-            nodesDeleted,
-            nodesInserted,
-            edgesInserted,
-            durationMs: Date.now() - t0,
-        };
-        return result;
-    }
-    finally {
-        // Always close DB connection
-        try {
-            await conn.close();
-        }
-        catch { }
-        try {
-            await db.close();
-        }
-        catch { }
-    }
-}
-// ---------------------------------------------------------------------------
-// Import resolution helper
-// ---------------------------------------------------------------------------
-/**
- * Attempt to resolve an import source string to a known file path
- *
- * Handles relative paths (./foo, ../bar) and tries common extensions.
- * Returns the matching relative file path or null if not found
- */
-function resolveImportSource(source, importingFile, knownPaths) {
-    // Only resolve relative imports for now
-    if (!source.startsWith('.'))
-        return null;
-    const importDir = path.dirname(importingFile);
-    const resolved = path.posix.normalize(path.posix.join(importDir, source));
-    // Try exact match first
-    if (knownPaths.has(resolved))
-        return resolved;
-    // Try common extensions
-    const extensions = [
-        '.ts', '.tsx', '.js', '.jsx', '.py', '.java', '.go', '.rs',
-        '.kt', '.cs', '.cpp', '.c', '.h', '.hpp', '.php', '.rb', '.swift',
-        '/index.ts', '/index.tsx', '/index.js', '/index.jsx',
-    ];
-    for (const ext of extensions) {
-        const candidate = resolved + ext;
-        if (knownPaths.has(candidate))
-            return candidate;
-    }
-    // Try stripping existing extension and re-resolving (e.g. './foo.js' -> './foo.ts')
-    const withoutExt = resolved.replace(/\.[^/.]+$/, '');
-    if (withoutExt !== resolved) {
-        for (const ext of extensions) {
-            const candidate = withoutExt + ext;
-            if (knownPaths.has(candidate))
-                return candidate;
-        }
-    }
-    return null;
-}
-// ---------------------------------------------------------------------------
-// IPC message listener — entry point
-// ---------------------------------------------------------------------------
-process.on('message', async (raw) => {
-    let msg;
-    try {
-        msg = parseParentMessage(raw);
-    }
-    catch (err) {
-        sendError(new Error(`Failed to parse parent message: ${err instanceof Error ? err.message : String(err)}`));
-        process.exit(1);
-        return; // unreachable but satisfies control flow analysis
-    }
-    switch (msg.kind) {
-        case 'shutdown':
-            process.exit(0);
-            break;
-        case 'refresh':
-            try {
-                const result = await runRefresh(msg.payload);
-                sendSuccess(result);
-            }
-            catch (err) {
-                sendError(err instanceof Error ? err : new Error(String(err)));
-                process.exit(1);
-            }
-            break;
-        default: {
-            const _exhaustive = msg;
-            throw new Error(`Unhandled parent message kind: ${JSON.stringify(_exhaustive)}`);
-        }
-    }
-});
-// ---------------------------------------------------------------------------
-// Safety nets — ensure the child never crashes silently
-// ---------------------------------------------------------------------------
-process.on('uncaughtException', (err) => {
-    sendError(new Error(`Uncaught exception in child: ${err.message}`));
-    process.exit(1);
-});
-process.on('unhandledRejection', (reason) => {
-    const message = reason instanceof Error ? reason.message : String(reason);
-    sendError(new Error(`Unhandled rejection in child: ${message}`));
-    process.exit(1);
-});
-// If the parent disconnects (closes the IPC channel), exit gracefully
-process.on('disconnect', () => {
-    process.exit(0);
-});

package/dist/core/incremental/refresh-coordinator.d.ts

@@ -1,32 +0,0 @@
-/**
- * @file refresh-coordinator.ts
- * @description Parent-side orchestrator that manages child process lifecycle for
- *   incremental DB refreshes — forks the worker, sends dirty files over IPC,
- *   and resolves/rejects the caller's promise based on the child's response
- */
-import { type RepoId, type RepoRoot, type DbPath, type DirtyFileEntry, type RefreshResult } from './types.js';
-/** Identifies a repo and its storage locations for a refresh operation */
-export interface RefreshTarget {
-    readonly id: RepoId;
-    readonly repoRoot: RepoRoot;
-    readonly dbPath: DbPath;
-    readonly storagePath: string;
-}
-export declare class RefreshCoordinator {
-    /** In-flight refreshes keyed by repo ID — ensures one refresh per repo at a time */
-    private readonly inFlight;
-    /**
-     * Trigger an incremental refresh for the given repo
-     *
-     * If a refresh for this repo is already in progress the existing promise is
-     * returned (deduplication). Otherwise a child process is forked, the dirty
-     * file list is sent over IPC, and the returned promise settles once the child
-     * reports success or failure
-     */
-    refresh(repo: RefreshTarget, dirtyFiles: readonly DirtyFileEntry[], existingPaths: readonly string[], timeoutMs?: number): Promise<RefreshResult>;
-    /**
-     * Core refresh logic — queries existing file paths from the DB, forks the
-     * child process, and wires up IPC + timeout handling
-     */
-    private doRefresh;
-}