@codragraph/cli 2.1.4 → 2.1.6

package/dist/core/cgdb/pool-adapter.js

@@ -16,7 +16,49 @@
  */
 import fs from 'fs/promises';
 import cgdb from '@ladybugdb/core';
+import { NODE_TABLES } from './schema.js';
 const pool = new Map();
+const SIMPLE_LABELLESS_MATCH_RE = /^MATCH\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/i;
+const CYPHER_LIMIT_RE = /\bLIMIT\s+(\d+)\s*;?\s*$/i;
+const CYPHER_RELATION_RE = /--|-\[|\]-|->|<-/;
+const NATIVE_UNSAFE_NODE_LABELS = new Set(['Union']);
+function quoteKnownNodeLabels(query) {
+    return query;
+}
+function getNativeUnsafeNodeLabel(query) {
+    const labelRe = /\(\s*[A-Za-z_][A-Za-z0-9_]*\s*:\s*`?([A-Za-z_][A-Za-z0-9_]*)`?(?=[\s){])/g;
+    for (const match of query.matchAll(labelRe)) {
+        const label = match[1];
+        if (NATIVE_UNSAFE_NODE_LABELS.has(label))
+            return label;
+    }
+    return null;
+}
+function getSimpleLabellessNodeAlias(query) {
+    const trimmed = query.trim();
+    const match = SIMPLE_LABELLESS_MATCH_RE.exec(trimmed);
+    if (!match)
+        return null;
+    if (CYPHER_RELATION_RE.test(trimmed))
+        return null;
+    if (/\bMATCH\b/i.test(trimmed.slice(match[0].length)))
+        return null;
+    return match[1];
+}
+function getCypherLimit(query) {
+    const match = CYPHER_LIMIT_RE.exec(query);
+    if (!match)
+        return null;
+    const limit = Number.parseInt(match[1], 10);
+    return Number.isFinite(limit) && limit > 0 ? limit : null;
+}
+function withCypherLimit(query, limit) {
+    const safeLimit = Math.max(1, Math.trunc(limit));
+    if (CYPHER_LIMIT_RE.test(query)) {
+        return query.replace(CYPHER_LIMIT_RE, `LIMIT ${safeLimit}`);
+    }
+    return `${query.replace(/;\s*$/, '')} LIMIT ${safeLimit}`;
+}
 const poolCloseListeners = new Set();
 /**
  * Subscribe to pool-close events. Returns a disposer that removes the
@@ -463,15 +505,7 @@ function withTimeout(promise, ms, label) {
     });
     return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
-export const executeQuery = async (repoId, cypher) => {
-    const entry = pool.get(repoId);
-    if (!entry) {
-        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initCgdb first.`);
-    }
-    if (isWriteQuery(cypher)) {
-        throw new Error('Write operations are not allowed. The pool adapter is read-only.');
-    }
-    entry.lastUsed = Date.now();
+async function runQueryOnEntry(entry, cypher) {
     const conn = await checkout(entry);
     silenceStdout();
     activeQueryCount++;
@@ -486,17 +520,8 @@ export const executeQuery = async (repoId, cypher) => {
         restoreStdout();
         checkin(entry, conn);
     }
-};
-/**
- * Execute a parameterized query on a specific repo's connection pool.
- * Uses prepare/execute pattern to prevent Cypher injection.
- */
-export const executeParameterized = async (repoId, cypher, params) => {
-    const entry = pool.get(repoId);
-    if (!entry) {
-        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initCgdb first.`);
-    }
-    entry.lastUsed = Date.now();
+}
+async function runParameterizedOnEntry(entry, cypher, params) {
     const conn = await checkout(entry);
     silenceStdout();
     activeQueryCount++;
@@ -516,6 +541,91 @@ export const executeParameterized = async (repoId, cypher, params) => {
         restoreStdout();
         checkin(entry, conn);
     }
+}
+async function runLabellessNodeScan(query, alias, runner) {
+    const limit = getCypherLimit(query) ?? 100;
+    const rows = [];
+    let lastError = null;
+    for (const label of NODE_TABLES) {
+        if (NATIVE_UNSAFE_NODE_LABELS.has(label))
+            continue;
+        if (rows.length >= limit)
+            break;
+        const labelQuery = withCypherLimit(query.replace(SIMPLE_LABELLESS_MATCH_RE, `MATCH (${alias}:\`${label}\`)`), limit - rows.length);
+        try {
+            const labelRows = await runner(labelQuery);
+            rows.push(...decorateLabellessRows(labelRows, label));
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            if (!isBenignLabelScanError(error)) {
+                lastError = error;
+            }
+        }
+    }
+    if (rows.length === 0 && lastError) {
+        throw lastError;
+    }
+    return rows.slice(0, limit);
+}
+function decorateLabellessRows(rows, label) {
+    return rows.map((row) => {
+        if (!row || typeof row !== 'object' || Array.isArray(row))
+            return row;
+        const decorated = { ...row, __cgLabel: label };
+        for (const key of ['type', 'kind', 'label']) {
+            const value = decorated[key];
+            if (value === '' || value === null || value === undefined) {
+                decorated[key] = label;
+            }
+        }
+        return decorated;
+    });
+}
+function isBenignLabelScanError(error) {
+    const message = error.message.toLowerCase();
+    return (message.includes('cannot find property') ||
+        message.includes('does not have property') ||
+        (message.includes('property') && message.includes('not found')));
+}
+export const executeQuery = async (repoId, cypher) => {
+    const entry = pool.get(repoId);
+    if (!entry) {
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initCgdb first.`);
+    }
+    const safeCypher = quoteKnownNodeLabels(cypher);
+    if (isWriteQuery(safeCypher)) {
+        throw new Error('Write operations are not allowed. The pool adapter is read-only.');
+    }
+    if (getNativeUnsafeNodeLabel(safeCypher)) {
+        return [];
+    }
+    entry.lastUsed = Date.now();
+    const labellessAlias = getSimpleLabellessNodeAlias(safeCypher);
+    if (labellessAlias) {
+        return runLabellessNodeScan(safeCypher, labellessAlias, (labelQuery) => runQueryOnEntry(entry, labelQuery));
+    }
+    return runQueryOnEntry(entry, safeCypher);
+};
+/**
+ * Execute a parameterized query on a specific repo's connection pool.
+ * Uses prepare/execute pattern to prevent Cypher injection.
+ */
+export const executeParameterized = async (repoId, cypher, params) => {
+    const entry = pool.get(repoId);
+    if (!entry) {
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initCgdb first.`);
+    }
+    entry.lastUsed = Date.now();
+    const safeCypher = quoteKnownNodeLabels(cypher);
+    if (getNativeUnsafeNodeLabel(safeCypher)) {
+        return [];
+    }
+    const labellessAlias = getSimpleLabellessNodeAlias(safeCypher);
+    if (labellessAlias) {
+        return runLabellessNodeScan(safeCypher, labellessAlias, (labelQuery) => runParameterizedOnEntry(entry, labelQuery, params));
+    }
+    return runParameterizedOnEntry(entry, safeCypher, params);
 };
 /**
  * Close one or all repo pools.

package/dist/core/ingestion/parsing-processor.js

@@ -567,7 +567,13 @@ scopeTreeCache, onFileProgress, workerPool) => {
             return await processParsingWithWorkers(graph, files, symbolTable, astCache, workerPool, onFileProgress);
         }
         catch (err) {
-            console.warn('Worker pool parsing failed, falling back to sequential:', err instanceof Error ? err.message : err);
+            console.warn('Worker pool parsing failed for this chunk, falling back to sequential:', err instanceof Error ? err.message : err);
+            try {
+                await workerPool.terminate();
+            }
+            catch (terminateErr) {
+                console.warn('Worker pool termination after parsing failure failed:', terminateErr instanceof Error ? terminateErr.message : terminateErr);
+            }
         }
     }
     // Fallback: sequential parsing (no pre-extracted data)

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -119,7 +119,9 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     workerUrl = pathToFileURL(distWorker);
                 }
             }
-            workerPool = createWorkerPool(workerUrl);
+            workerPool = createWorkerPool(workerUrl, options?.workerPoolSize, {
+                subBatchSize: options?.workerSubBatchSize,
+            });
         }
         catch (err) {
             console.warn('Worker pool creation failed, using sequential fallback:', err.message);
@@ -170,6 +172,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
             const chunkFiles = chunkPaths
                 .filter((p) => chunkContents.has(p))
                 .map((p) => ({ path: p, content: chunkContents.get(p) }));
+            const usedWorkerPoolForChunk = workerPool !== undefined;
             const chunkWorkerData = await processParsing(graph, chunkFiles, symbolTable, astCache, scopeTreeCache, (current, _total, filePath) => {
                 const globalCurrent = filesParsedSoFar + current;
                 const parsingProgress = 20 + (globalCurrent / totalParseable) * 62;
@@ -185,6 +188,9 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     },
                 });
             }, workerPool);
+            if (usedWorkerPoolForChunk && !chunkWorkerData) {
+                workerPool = undefined;
+            }
             const chunkBasePercent = 20 + (filesParsedSoFar / totalParseable) * 62;
             if (chunkWorkerData) {
                 await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, ctx, (current, total) => {

package/dist/core/ingestion/pipeline-phases/structure.js

@@ -20,16 +20,32 @@ export const structurePhase = {
             message: 'Analyzing project structure...',
             stats: { filesProcessed: 0, totalFiles, nodesCreated: ctx.graph.nodeCount },
         });
-        processStructure(ctx.graph, allPaths);
+        const focusSet = ctx.options?.focusPaths
+            ? new Set(ctx.options.focusPaths.map((p) => p.replace(/\\/g, '/')))
+            : null;
+        const graphPaths = focusSet ? allPaths.filter((p) => focusSet.has(p)) : allPaths;
+        processStructure(ctx.graph, graphPaths);
         ctx.onProgress({
             phase: 'structure',
             percent: 20,
             message: 'Project structure analyzed',
-            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: ctx.graph.nodeCount },
+            stats: {
+                filesProcessed: graphPaths.length,
+                totalFiles: focusSet ? graphPaths.length : totalFiles,
+                nodesCreated: ctx.graph.nodeCount,
+            },
         });
         // Build the set once here so cobol, markdown, and cross-file propagation
         // can all reuse it instead of re-materializing `new Set(allPaths)` each.
         const allPathSet = new Set(allPaths);
-        return { scannedFiles, allPaths, allPathSet, totalFiles };
+        const focusedScannedFiles = focusSet
+            ? scannedFiles.filter((f) => focusSet.has(f.path))
+            : scannedFiles;
+        return {
+            scannedFiles: focusedScannedFiles,
+            allPaths,
+            allPathSet,
+            totalFiles: focusSet ? focusedScannedFiles.length : totalFiles,
+        };
     },
 };

package/dist/core/ingestion/pipeline.d.ts

@@ -25,6 +25,16 @@ export interface PipelineOptions {
     featureClusterRepo?: string;
     /** Indexed source commit written onto FeatureCluster metadata. */
     lastIndexedCommit?: string;
+    /**
+     * Optional focused indexing set for incremental file analysis. The walker
+     * still scans the repo so import resolution sees every path, but graph
+     * writes and content parsing are limited to these relative paths.
+     */
+    focusPaths?: readonly string[];
+    /** Adaptive analyze worker pool size. */
+    workerPoolSize?: number;
+    /** Adaptive analyze max files per worker message. */
+    workerSubBatchSize?: number;
     /**
      * @internal Test-only override for worker-pool gating thresholds.
      * When unset, production defaults apply (15 files OR 512 KB total bytes).

package/dist/core/ingestion/workers/parse-worker.js

@@ -452,7 +452,7 @@ const processBatch = (files, onProgress) => {
     }
     let totalProcessed = 0;
     let lastReported = 0;
-    const PROGRESS_INTERVAL = 100; // report every 100 files
+    const PROGRESS_INTERVAL = 25; // report often enough to keep worker idle timers fresh
     const onFileProcessed = onProgress
         ? () => {
             totalProcessed++;

package/dist/core/ingestion/workers/worker-pool.d.ts

@@ -10,7 +10,20 @@ export interface WorkerPool {
     /** Number of workers in the pool */
     readonly size: number;
 }
+export interface WorkerPoolOptions {
+    /**
+     * Max files to send to a worker in one postMessage. Lower values reduce
+     * structured-clone memory spikes and give the main thread more chances to
+     * observe progress on large repos.
+     */
+    subBatchSize?: number;
+    /**
+     * Idle timeout while waiting for a worker response. Reset by worker progress
+     * so slow-but-moving chunks do not get retried sequentially.
+     */
+    subBatchIdleTimeoutMs?: number;
+}
 /**
  * Create a pool of worker threads.
  */
-export declare const createWorkerPool: (workerUrl: URL, poolSize?: number) => WorkerPool;
+export declare const createWorkerPool: (workerUrl: URL, poolSize?: number, options?: WorkerPoolOptions) => WorkerPool;

package/dist/core/ingestion/workers/worker-pool.js

@@ -6,14 +6,24 @@ import { fileURLToPath } from 'node:url';
  * Max files to send to a worker in a single postMessage.
  * Keeps structured-clone memory bounded per sub-batch.
  */
-const SUB_BATCH_SIZE = 1500;
-/** Per sub-batch timeout. If a single sub-batch takes longer than this,
- *  likely a pathological file (e.g. minified 50MB JS). Fail fast. */
-const SUB_BATCH_TIMEOUT_MS = 30_000;
+const DEFAULT_SUB_BATCH_SIZE = 250;
+/**
+ * Idle timeout while waiting for a worker response. This is not a wall-clock
+ * limit: worker progress resets it. Large repos can legitimately need more
+ * than 30s for a chunk, but a wedged parser should still fall back.
+ */
+const DEFAULT_SUB_BATCH_IDLE_TIMEOUT_MS = 120_000;
+const positiveIntFromEnv = (name, fallback) => {
+    const raw = process.env[name];
+    if (!raw)
+        return fallback;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
 /**
  * Create a pool of worker threads.
  */
-export const createWorkerPool = (workerUrl, poolSize) => {
+export const createWorkerPool = (workerUrl, poolSize, options = {}) => {
     // Validate worker script exists before spawning to prevent uncaught
     // MODULE_NOT_FOUND crashes in worker threads (e.g. when running from src/ via vitest)
     const workerPath = fileURLToPath(workerUrl);
@@ -21,6 +31,10 @@ export const createWorkerPool = (workerUrl, poolSize) => {
         throw new Error(`Worker script not found: ${workerPath}`);
     }
     const size = poolSize ?? Math.min(8, Math.max(1, os.cpus().length - 1));
+    const subBatchSize = options.subBatchSize ??
+        positiveIntFromEnv('CODRAGRAPH_WORKER_SUB_BATCH_SIZE', DEFAULT_SUB_BATCH_SIZE);
+    const subBatchIdleTimeoutMs = options.subBatchIdleTimeoutMs ??
+        positiveIntFromEnv('CODRAGRAPH_WORKER_IDLE_TIMEOUT_MS', DEFAULT_SUB_BATCH_IDLE_TIMEOUT_MS);
     const workers = [];
     for (let i = 0; i < size; i++) {
         workers.push(new Worker(workerUrl));
@@ -38,41 +52,43 @@ export const createWorkerPool = (workerUrl, poolSize) => {
             const worker = workers[i];
             return new Promise((resolve, reject) => {
                 let settled = false;
-                let subBatchTimer = null;
+                let workerIdleTimer = null;
                 const cleanup = () => {
-                    if (subBatchTimer)
-                        clearTimeout(subBatchTimer);
+                    if (workerIdleTimer)
+                        clearTimeout(workerIdleTimer);
                     worker.removeListener('message', handler);
                     worker.removeListener('error', errorHandler);
                     worker.removeListener('exit', exitHandler);
                 };
-                const resetSubBatchTimer = () => {
-                    if (subBatchTimer)
-                        clearTimeout(subBatchTimer);
-                    subBatchTimer = setTimeout(() => {
+                const resetWorkerIdleTimer = () => {
+                    if (workerIdleTimer)
+                        clearTimeout(workerIdleTimer);
+                    workerIdleTimer = setTimeout(() => {
                         if (!settled) {
                             settled = true;
                             cleanup();
-                            reject(new Error(`Worker ${i} sub-batch timed out after ${SUB_BATCH_TIMEOUT_MS / 1000}s (chunk: ${chunk.length} items).`));
+                            reject(new Error(`Worker ${i} was idle for ${subBatchIdleTimeoutMs / 1000}s while waiting for a response (chunk: ${chunk.length} items).`));
                         }
-                    }, SUB_BATCH_TIMEOUT_MS);
+                    }, subBatchIdleTimeoutMs);
                 };
                 let subBatchIdx = 0;
                 const sendNextSubBatch = () => {
-                    const start = subBatchIdx * SUB_BATCH_SIZE;
+                    const start = subBatchIdx * subBatchSize;
                     if (start >= chunk.length) {
+                        resetWorkerIdleTimer();
                         worker.postMessage({ type: 'flush' });
                         return;
                     }
-                    const subBatch = chunk.slice(start, start + SUB_BATCH_SIZE);
+                    const subBatch = chunk.slice(start, start + subBatchSize);
                     subBatchIdx++;
-                    resetSubBatchTimer();
+                    resetWorkerIdleTimer();
                     worker.postMessage({ type: 'sub-batch', files: subBatch });
                 };
                 const handler = (msg) => {
                     if (settled)
                         return;
                     if (msg.type === 'progress') {
+                        resetWorkerIdleTimer();
                         workerProgress[i] = msg.filesProcessed;
                         if (onProgress) {
                             const total = workerProgress.reduce((a, b) => a + b, 0);

package/dist/core/run-analyze.d.ts

@@ -10,6 +10,7 @@
  */
 import { type RepoMeta } from '../storage/repo-manager.js';
 import type { ContentEncoding } from '@codragraph/graphstore';
+import { type AnalyzeProfileOption, type CompressionOption, type EmbeddingMode } from './adaptive-profile.js';
 export interface AnalyzeCallbacks {
     onProgress: (phase: string, percent: number, message: string) => void;
     onLog?: (message: string) => void;
@@ -23,6 +24,8 @@ export interface AnalyzeOptions {
      */
     force?: boolean;
     embeddings?: boolean;
+    profile?: AnalyzeProfileOption;
+    embeddingMode?: EmbeddingMode;
     skipGit?: boolean;
     /** Skip AGENTS.md and CLAUDE.md codragraph block updates. */
     skipAgentsMd?: boolean;
@@ -54,7 +57,7 @@ export interface AnalyzeOptions {
      * that wrote the rows). Readers on older Node will get a clear
      * forward-compat error rather than silently bad content.
      */
-    compress?: ContentEncoding;
+    compress?: CompressionOption;
 }
 export interface AnalyzeResult {
     repoName: string;
@@ -91,7 +94,29 @@ export declare const isGeneratedAgentContextPath: (filePath: string) => boolean;
 export declare const isGraphContentPath: (filePath: string) => boolean;
 export declare const changedPathAffectsGraph: (change: AnalyzeChangedPath) => boolean;
 export declare const getGraphRelevantChangedPaths: (changes: readonly AnalyzeChangedPath[]) => AnalyzeChangedPath[];
-export declare const getAnalyzeConfigRebuildReason: (existingMeta: Pick<RepoMeta, "compress" | "stats">, options: Pick<AnalyzeOptions, "compress" | "embeddings">) => string | null;
+export interface IncrementalFilePatchPlan {
+    eligible: boolean;
+    reason: string;
+    replacePaths: string[];
+    currentPaths: string[];
+    fileCountDelta: number;
+    /**
+     * True when a change can affect resolver/global structure broadly
+     * (config/ignore/package). The incremental path still avoids deleting the
+     * whole DB, but it replaces every file-scoped node from a fresh full scan.
+     */
+    replaceAllFileScoped: boolean;
+    /** Old path -> new path aliases used to reconnect external edges across renames. */
+    pathAliases: Record<string, string>;
+}
+export declare const isPatchableIncrementalPath: (filePath: string) => boolean;
+export declare const buildIncrementalFilePatchPlan: (changes: readonly AnalyzeChangedPath[], _options?: {
+    limit?: number;
+}) => IncrementalFilePatchPlan;
+export declare const getAnalyzeConfigRebuildReason: (existingMeta: Pick<RepoMeta, "compress" | "searchIndexes" | "stats">, options: {
+    compress?: ContentEncoding;
+    embeddings?: boolean;
+}) => string | null;
 /**
  * Run the full CodraGraph analysis pipeline.
  *