code-graph-context 2.13.1 → 2.13.3

package/dist/cli/cli.js

@@ -174,7 +174,10 @@ const installSidecarDeps = (sidecarDir) => {
 const verifySidecar = (sidecarDir) => {
     return new Promise((resolve) => {
         const python = getSidecarPython(sidecarDir);
-        const test = spawnProcess(python, ['-c', `import transformers.modeling_utils as _mu; hasattr(_mu,"Conv1D") or setattr(_mu,"Conv1D",__import__("transformers.pytorch_utils",fromlist=["Conv1D"]).Conv1D); from sentence_transformers import SentenceTransformer; print("ok")`], {
+        const test = spawnProcess(python, [
+            '-c',
+            `import transformers.modeling_utils as _mu; hasattr(_mu,"Conv1D") or setattr(_mu,"Conv1D",__import__("transformers.pytorch_utils",fromlist=["Conv1D"]).Conv1D); from sentence_transformers import SentenceTransformer; print("ok")`,
+        ], {
             cwd: sidecarDir,
             stdio: ['pipe', 'pipe', 'pipe'],
         });

package/dist/core/embeddings/embedding-sidecar.js

@@ -25,9 +25,40 @@ export class EmbeddingSidecar {
     stopping = false;
     _exitHandler = null;
     _idleTimer = null;
+    // Concurrency semaphore — model.encode() is GPU-bound and processes
+    // requests serially inside uvicorn. If 15 workers send requests at once,
+    // the first takes ~3s, the last waits ~45s and times out. By queuing
+    // excess requests here (no timeout pressure) we let only N through at a
+    // time, keeping each request well within the 60s timeout.
+    maxConcurrent = parseInt(process.env.EMBEDDING_MAX_CONCURRENT ?? '', 10) || 2;
+    inflight = 0;
+    waitQueue = [];
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
+    /**
+     * Wait for a concurrency slot. If under the limit, returns immediately.
+     * Otherwise parks the caller in a FIFO queue until a slot opens.
+     */
+    acquireSlot() {
+        if (this.inflight < this.maxConcurrent) {
+            this.inflight++;
+            return; // fast path — no allocation, no Promise
+        }
+        return new Promise((resolve) => this.waitQueue.push(() => {
+            this.inflight++;
+            resolve();
+        }));
+    }
+    /**
+     * Release a slot, unblocking the next queued caller if any.
+     */
+    releaseSlot() {
+        this.inflight--;
+        const next = this.waitQueue.shift();
+        if (next)
+            next(); // wake one waiter — it will increment inflight
+    }
     get baseUrl() {
         return `http://${this.config.host}:${this.config.port}`;
     }
@@ -183,9 +214,19 @@ export class EmbeddingSidecar {
     }
     /**
      * Embed an array of texts. Lazily starts the sidecar if not running.
+     * Concurrency-limited: at most `maxConcurrent` requests hit the sidecar
+     * at once. Excess callers wait in a FIFO queue (no timeout pressure).
      */
     async embed(texts, gpuBatchSize) {
         await this.start();
+        // Wait for a concurrency slot — the timeout only starts AFTER we
+        // acquire the slot, so queued requests don't eat into their timeout.
+        const queuedAt = Date.now();
+        await this.acquireSlot();
+        const queueMs = Date.now() - queuedAt;
+        if (queueMs > 100) {
+            console.error(`[embedding-sidecar] Waited ${queueMs}ms for concurrency slot (inflight=${this.inflight}, queued=${this.waitQueue.length})`);
+        }
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
         const startTime = Date.now();
@@ -203,8 +244,6 @@ export class EmbeddingSidecar {
                 const detail = await res.text();
                 const isOOM = detail.toLowerCase().includes('out of memory');
                 if (res.status === 500 && isOOM) {
-                    // OOM leaves GPU memory in a corrupted state — kill the sidecar
-                    // so the next request spawns a fresh process with clean memory
                     console.error('[embedding-sidecar] OOM detected, restarting sidecar to reclaim GPU memory');
                     await this.stop();
                 }
@@ -230,6 +269,7 @@ export class EmbeddingSidecar {
         }
         finally {
             clearTimeout(timeout);
+            this.releaseSlot(); // always release, even on error
         }
     }
     /**

package/dist/core/embeddings/local-embeddings.service.js

@@ -31,7 +31,13 @@ export class LocalEmbeddingsService {
         const httpBatches = Math.ceil(texts.length / httpLimit);
         const gpuBatchesPerRequest = Math.ceil(httpLimit / gpuBatchSize);
         console.error(`[embedding] ${texts.length} texts → ${httpBatches} HTTP requests (http_limit=${httpLimit}, gpu_batch_size=${gpuBatchSize}, ~${gpuBatchesPerRequest} GPU batches/req)`);
-        await debugLog('Batch embedding started', { provider: 'local', textCount: texts.length, gpuBatchSize, httpLimit, httpBatches });
+        await debugLog('Batch embedding started', {
+            provider: 'local',
+            textCount: texts.length,
+            gpuBatchSize,
+            httpLimit,
+            httpBatches,
+        });
         const sidecar = getEmbeddingSidecar();
         const allResults = [];
         for (let i = 0; i < texts.length; i += httpLimit) {

package/dist/mcp/constants.js

@@ -449,3 +449,30 @@ export const MESSAGES = {
         startingServer: 'Starting MCP server...',
     },
 };
+export const CONFIG_FILE_PATTERNS = {
+    defaultGlobs: [
+        'docker-compose*.{yml,yaml}',
+        'Dockerfile*',
+        '**/*.json', // All JSON files (package.json, tsconfig.json, .mcp.json, etc.)
+        '**/*.{yml,yaml}', // All YAML files (CI configs, k8s manifests, etc.)
+        '**/*.toml', // Cargo.toml, pyproject.toml, etc.
+        '**/*.cfg', // Python setup.cfg, etc.
+        '**/*.ini', // INI config files
+        '**/Makefile', // Makefiles
+        '.env*',
+        '**/*.sh', // Shell scripts
+        '**/*.py', // Python files (sidecar, scripts)
+    ],
+    excludeGlobs: [
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/build/**',
+        '**/.git/**',
+        '**/coverage/**',
+        '**/.next/**',
+        '**/package-lock.json', // Too large, not useful for search
+        '**/yarn.lock',
+        '**/pnpm-lock.yaml',
+    ],
+    maxFileSizeBytes: 512 * 1024, // 512 KB — skip large generated files
+};

package/dist/mcp/handlers/graph-generator.handler.js

@@ -3,7 +3,14 @@
  * Handles importing parsed graph data into Neo4j with embeddings
  */
 import fs from 'fs/promises';
-import { EMBEDDING_BATCH_CONFIG, getEmbeddingDimensions } from '../../core/embeddings/embeddings.service.js';
+import path from 'path';
+import { glob } from 'glob';
+import { EXCLUDE_PATTERNS_GLOB } from '../../constants.js';
+import { CoreNodeType } from '../../core/config/schema.js';
+import { EMBEDDING_BATCH_CONFIG, getEmbeddingDimensions, } from '../../core/embeddings/embeddings.service.js';
+import { normalizeCode } from '../../core/utils/code-normalizer.js';
+import { hashFile } from '../../core/utils/file-utils.js';
+import { generateDeterministicId } from '../../core/utils/graph-factory.js';
 import { QUERIES } from '../../storage/neo4j/neo4j.service.js';
 import { DEFAULTS } from '../constants.js';
 import { debugLog } from '../utils.js';
@@ -35,7 +42,14 @@ export class GraphGeneratorHandler {
      *   Use this for chunked imports where indexes are created once before/after all chunks.
      */
     async generateGraphFromData(nodes, edges, batchSize = DEFAULTS.batchSize, clearExisting = true, metadata = {}, skipIndexes = false) {
-        await debugLog('Starting graph generation', { nodeCount: nodes.length, edgeCount: edges.length, batchSize, clearExisting, skipIndexes, projectId: this.projectId });
+        await debugLog('Starting graph generation', {
+            nodeCount: nodes.length,
+            edgeCount: edges.length,
+            batchSize,
+            clearExisting,
+            skipIndexes,
+            projectId: this.projectId,
+        });
         try {
             console.error(`Generating graph with ${nodes.length} nodes and ${edges.length} edges`);
             if (clearExisting) {
@@ -63,6 +77,61 @@ export class GraphGeneratorHandler {
             throw error;
         }
     }
+    async ingestConfigFiles(projectPath, projectId, globs, excludeGlobs, maxFileSizeBytes, batchSize = DEFAULTS.batchSize) {
+        const files = await glob(globs, {
+            cwd: projectPath,
+            ignore: [...EXCLUDE_PATTERNS_GLOB, ...excludeGlobs],
+            absolute: true,
+        });
+        console.error(`[config-ingest] Found ${files.length} config files to ingest`);
+        const nodes = [];
+        for (const file of files) {
+            const stats = await fs.stat(file);
+            if (stats.size > maxFileSizeBytes) {
+                console.error(`[config-ingest] Skipping ${file} (${stats.size} bytes > ${maxFileSizeBytes})`);
+                continue;
+            }
+            const content = await fs.readFile(file, 'utf-8');
+            const name = path.basename(file);
+            const relativePath = path.relative(projectPath, file);
+            const lineCount = content.split('\n').length;
+            const contentHash = await hashFile(file);
+            const nodeId = generateDeterministicId(projectId, CoreNodeType.SOURCE_FILE, relativePath, name);
+            let normalizedHash;
+            try {
+                const result = normalizeCode(content);
+                if (result.normalizedHash)
+                    normalizedHash = result.normalizedHash;
+            }
+            catch {
+                // Config files may not normalize cleanly — skip
+            }
+            const properties = {
+                id: nodeId,
+                projectId,
+                name,
+                coreType: CoreNodeType.SOURCE_FILE,
+                semanticType: 'ConfigFile',
+                filePath: relativePath,
+                sourceCode: content,
+                startLine: 1,
+                endLine: lineCount,
+                createdAt: new Date().toISOString(),
+                size: Number(stats.size),
+                mtime: Number(stats.mtimeMs),
+                contentHash,
+                ...(normalizedHash && { normalizedHash }),
+            };
+            nodes.push({
+                id: nodeId,
+                labels: ['SourceFile'],
+                properties,
+            });
+        }
+        console.error(`[config-ingest] Importing ${nodes.length} config file nodes`);
+        await this.importNodes(nodes, batchSize);
+        return { nodesCreated: nodes.length };
+    }
     /**
      * Create all indexes. Call once before chunked imports start.
      */

package/dist/mcp/tools/parse-typescript-project.tool.js

@@ -16,7 +16,7 @@ import { ParserFactory } from '../../core/parsers/parser-factory.js';
 import { detectChangedFiles } from '../../core/utils/file-change-detection.js';
 import { resolveProjectId, getProjectName, UPSERT_PROJECT_QUERY, UPDATE_PROJECT_STATUS_QUERY, } from '../../core/utils/project-id.js';
 import { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
-import { TOOL_NAMES, TOOL_METADATA, DEFAULTS, FILE_PATHS, LOG_CONFIG, PARSING } from '../constants.js';
+import { TOOL_NAMES, TOOL_METADATA, DEFAULTS, FILE_PATHS, LOG_CONFIG, PARSING, CONFIG_FILE_PATTERNS, } from '../constants.js';
 import { deleteSourceFileSubgraphs, loadExistingNodesForEdgeDetection, getCrossFileEdges, } from '../handlers/cross-file-edge.helpers.js';
 import { GraphGeneratorHandler } from '../handlers/graph-generator.handler.js';
 import { StreamingImportHandler } from '../handlers/streaming-import.handler.js';
@@ -67,6 +67,11 @@ export const createParseTypescriptProjectTool = (server) => {
         inputSchema: {
             projectPath: z.string().describe('Path to the TypeScript project root directory'),
             tsconfigPath: z.string().describe('Path to TypeScript project tsconfig.json file'),
+            configFileGlobs: z
+                .array(z.string())
+                .optional()
+                .describe('Custom glob patterns for config files (default: all JSON, YAML, .env, Dockerfile, .sh, .py)')
+                .default(CONFIG_FILE_PATTERNS.defaultGlobs),
             projectId: z
                 .string()
                 .optional()
@@ -107,7 +112,7 @@ export const createParseTypescriptProjectTool = (server) => {
                 .default(1000)
                 .describe('Debounce delay for watch mode in milliseconds (default: 1000)'),
         },
-    }, async ({ tsconfigPath, projectPath, projectId, clearExisting, projectType = 'auto', chunkSize = 100, useStreaming = 'auto', async: asyncMode = false, watch = false, watchDebounceMs = 1000, }) => {
+    }, async ({ tsconfigPath, projectPath, projectId, configFileGlobs, clearExisting, projectType = 'auto', chunkSize = 100, useStreaming = 'auto', async: asyncMode = false, watch = false, watchDebounceMs = 1000, }) => {
         try {
             // SECURITY: Validate input paths before processing
             await validatePathExists(projectPath, 'directory');
@@ -145,6 +150,7 @@ export const createParseTypescriptProjectTool = (server) => {
                         projectId: resolvedProjectId,
                         projectType,
                         chunkSize: chunkSize > 0 ? chunkSize : 50,
+                        configFileGlobs,
                     },
                     resourceLimits: {
                         maxOldGenerationSizeMb: 8192, // 8GB heap for large monorepos
@@ -254,6 +260,10 @@ export const createParseTypescriptProjectTool = (server) => {
                         projectId: resolvedProjectId,
                     });
                     await debugLog('Streaming import completed', result);
+                    // Ingest config files
+                    const configResult = await graphGeneratorHandler.ingestConfigFiles(projectPath, resolvedProjectId, configFileGlobs, CONFIG_FILE_PATTERNS.excludeGlobs, CONFIG_FILE_PATTERNS.maxFileSizeBytes);
+                    result.nodesImported += configResult.nodesCreated;
+                    await debugLog('Config file ingestion completed', { nodesCreated: configResult.nodesCreated });
                     // Update Project node status to complete
                     await neo4jService.run(UPDATE_PROJECT_STATUS_QUERY, {
                         projectId: resolvedProjectId,
@@ -328,6 +338,10 @@ export const createParseTypescriptProjectTool = (server) => {
                 }
                 console.error('Graph generation completed:', result);
                 await debugLog('Neo4j import completed', result);
+                // Ingest config files
+                const configResult = await graphGeneratorHandler.ingestConfigFiles(projectPath, finalProjectId, configFileGlobs, CONFIG_FILE_PATTERNS.excludeGlobs, CONFIG_FILE_PATTERNS.maxFileSizeBytes);
+                result.nodesImported += configResult.nodesCreated;
+                await debugLog('Config file ingestion completed', { nodesCreated: configResult.nodesCreated });
                 // Update Project node status to complete
                 await neo4jService.run(UPDATE_PROJECT_STATUS_QUERY, {
                     projectId: finalProjectId,

package/dist/mcp/tools/swarm-cleanup.tool.js

@@ -165,7 +165,9 @@ export const createSwarmCleanupTool = (server) => {
                     const msgResult = await neo4jService.run(COUNT_MESSAGES_BY_SWARM_QUERY, params);
                     messageCount = msgResult[0]?.count ?? 0;
                     messageCount =
-                        typeof messageCount === 'object' && 'toNumber' in messageCount ? messageCount.toNumber() : messageCount;
+                        typeof messageCount === 'object' && 'toNumber' in messageCount
+                            ? messageCount.toNumber()
+                            : messageCount;
                     messageCategories = msgResult[0]?.categories ?? [];
                 }
                 return createSuccessResponse(JSON.stringify({

package/dist/mcp/tools/swarm-message.tool.js

@@ -164,46 +164,24 @@ export const createSwarmMessageTool = (server) => {
                 .enum(['send', 'read', 'acknowledge'])
                 .describe('Action: send (post message), read (get messages), acknowledge (mark as read)'),
             // Send parameters
-            toAgentId: z
-                .string()
-                .optional()
-                .describe('Target agent ID. Omit for broadcast to all swarm agents.'),
+            toAgentId: z.string().optional().describe('Target agent ID. Omit for broadcast to all swarm agents.'),
             category: z
                 .enum(MESSAGE_CATEGORY_KEYS)
                 .optional()
                 .describe('Message category: blocked (need help), conflict (resource clash), finding (important discovery), ' +
                 'request (direct ask), alert (urgent notification), handoff (context transfer)'),
-            content: z
-                .string()
-                .optional()
-                .describe('Message content (required for send action)'),
-            taskId: z
-                .string()
-                .optional()
-                .describe('Related task ID for context'),
-            filePaths: z
-                .array(z.string())
-                .optional()
-                .describe('File paths relevant to this message'),
+            content: z.string().optional().describe('Message content (required for send action)'),
+            taskId: z.string().optional().describe('Related task ID for context'),
+            filePaths: z.array(z.string()).optional().describe('File paths relevant to this message'),
             ttlMs: z
                 .number()
                 .int()
                 .optional()
                 .describe(`Time-to-live in ms (default: ${MESSAGE_DEFAULT_TTL_MS / 3600000}h). Set 0 for swarm lifetime.`),
             // Read parameters
-            unreadOnly: z
-                .boolean()
-                .optional()
-                .default(true)
-                .describe('Only return unread messages (default: true)'),
-            categories: z
-                .array(z.enum(MESSAGE_CATEGORY_KEYS))
-                .optional()
-                .describe('Filter by message categories'),
-            fromAgentId: z
-                .string()
-                .optional()
-                .describe('Filter messages from a specific agent'),
+            unreadOnly: z.boolean().optional().default(true).describe('Only return unread messages (default: true)'),
+            categories: z.array(z.enum(MESSAGE_CATEGORY_KEYS)).optional().describe('Filter by message categories'),
+            fromAgentId: z.string().optional().describe('Filter messages from a specific agent'),
             limit: z
                 .number()
                 .int()
@@ -218,11 +196,7 @@ export const createSwarmMessageTool = (server) => {
                 .optional()
                 .describe('Specific message IDs to acknowledge. Omit to acknowledge all unread.'),
             // Maintenance
-            cleanup: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe('Also clean up expired messages'),
+            cleanup: z.boolean().optional().default(false).describe('Also clean up expired messages'),
         },
     }, async ({ projectId, swarmId, agentId, action, toAgentId, category, content, taskId, filePaths, ttlMs, unreadOnly = true, categories, fromAgentId, limit = 20, messageIds, cleanup = false, }) => {
         const neo4jService = new Neo4jService();
@@ -341,7 +315,7 @@ export const createSwarmMessageTool = (server) => {
                     });
                     const count = typeof result[0]?.acknowledged === 'object'
                         ? result[0].acknowledged.toNumber()
-                        : result[0]?.acknowledged ?? 0;
+                        : (result[0]?.acknowledged ?? 0);
                     return createSuccessResponse(JSON.stringify({
                         action: 'acknowledged_all',
                         count,

package/dist/mcp/tools/swarm-pheromone.tool.js

@@ -66,13 +66,20 @@ const DELETE_PHEROMONE_QUERY = `
   DETACH DELETE p
   RETURN count(p) as deleted
 `;
+const BY_FILE_PATH = `MATCH (n:SourceFile)
+     WHERE n.projectId = $projectId AND n.filePath ENDS WITH $filePath
+     RETURN n.id as nodeId LIMIT 1`;
 export const createSwarmPheromoneTool = (server) => {
     server.registerTool(TOOL_NAMES.swarmPheromone, {
         title: TOOL_METADATA[TOOL_NAMES.swarmPheromone].title,
         description: TOOL_METADATA[TOOL_NAMES.swarmPheromone].description,
         inputSchema: {
             projectId: z.string().describe('Project ID, name, or path (e.g., "backend" or "proj_a1b2c3d4e5f6")'),
-            nodeId: z.string().describe('The code node ID to mark with a pheromone'),
+            nodeId: z.string().optional().describe('The code node ID to mark with a pheromone'),
+            filePath: z
+                .string()
+                .optional()
+                .describe('File path to mark (alternative to nodeId — auto-resolves to SourceFile node)'),
             type: z
                 .enum(PHEROMONE_TYPES)
                 .describe('Type of pheromone: exploring (browsing), modifying (active work), claiming (ownership), completed (done), warning (danger), blocked (stuck), proposal (awaiting approval), needs_review (review request), session_context (session working set)'),
@@ -99,8 +106,11 @@ export const createSwarmPheromoneTool = (server) => {
                 .default(false)
                 .describe('If true, removes the pheromone instead of creating/updating it'),
         },
-    }, async ({ projectId, nodeId, type, intensity = 1.0, agentId, swarmId, sessionId, data, remove = false }) => {
+    }, async ({ projectId, nodeId, filePath, type, intensity = 1.0, agentId, swarmId, sessionId, data, remove = false, }) => {
         const neo4jService = new Neo4jService();
+        if (!nodeId && !filePath) {
+            return createErrorResponse(new Error('nodeId or filePath required'));
+        }
         // Resolve project ID
         const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
         if (!projectResult.success) {
@@ -109,6 +119,21 @@ export const createSwarmPheromoneTool = (server) => {
         }
         const resolvedProjectId = projectResult.projectId;
         try {
+            // Resolve filePath to nodeId before any queries that need it
+            let resolvedFromFilePath = false;
+            let linkedToNode = true;
+            if (!nodeId && filePath) {
+                const records = await neo4jService.run(BY_FILE_PATH, { projectId: resolvedProjectId, filePath });
+                if (records[0]?.nodeId) {
+                    nodeId = records[0].nodeId;
+                }
+                else {
+                    // No graph node — use filePath as identifier so pheromone is still created
+                    nodeId = filePath;
+                    linkedToNode = false;
+                }
+                resolvedFromFilePath = true;
+            }
             if (remove) {
                 const result = await neo4jService.run(DELETE_PHEROMONE_QUERY, {
                     projectId: resolvedProjectId,

package/dist/mcp/tools/swarm-sense.tool.js

@@ -101,6 +101,10 @@ export const createSwarmSenseTool = (server) => {
                 .optional()
                 .describe('Filter by pheromone types. If empty, returns all types. Options: exploring, modifying, claiming, completed, warning, blocked, proposal, needs_review'),
             nodeIds: z.array(z.string()).optional().describe('Filter by specific node IDs. If empty, searches all nodes.'),
+            filePaths: z
+                .array(z.string())
+                .optional()
+                .describe('Filter by file paths (resolves to SourceFile nodeIds). Also matches pheromones placed via filePath.'),
             agentIds: z
                 .array(z.string())
                 .optional()
@@ -136,7 +140,7 @@ export const createSwarmSenseTool = (server) => {
                 .default(false)
                 .describe('Run cleanup of fully decayed pheromones (intensity < 0.01)'),
         },
-    }, async ({ projectId, types, nodeIds, agentIds, swarmId, excludeAgentId, sessionId, minIntensity = 0.3, limit = 50, includeStats = false, cleanup = false, }) => {
+    }, async ({ projectId, types, nodeIds, filePaths, agentIds, swarmId, excludeAgentId, sessionId, minIntensity = 0.3, limit = 50, includeStats = false, cleanup = false, }) => {
         const neo4jService = new Neo4jService();
         // Resolve project ID
         const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
@@ -146,6 +150,19 @@ export const createSwarmSenseTool = (server) => {
         }
         const resolvedProjectId = projectResult.projectId;
         try {
+            // Resolve filePaths to nodeIds and merge with any explicit nodeIds
+            if (filePaths?.length) {
+                const resolvedIds = [...(nodeIds ?? [])];
+                const records = await neo4jService.run(`MATCH (n:SourceFile)
+             WHERE n.projectId = $projectId AND any(fp IN $filePaths WHERE n.filePath ENDS WITH fp)
+             RETURN collect(n.id) as nodeIds`, { projectId: resolvedProjectId, filePaths });
+                if (records[0]?.nodeIds) {
+                    resolvedIds.push(...records[0].nodeIds);
+                }
+                // Also include raw filePaths — catches pheromones placed on new files via filePath
+                resolvedIds.push(...filePaths);
+                nodeIds = resolvedIds;
+            }
             const result = {
                 pheromones: [],
                 projectId: resolvedProjectId,

package/dist/mcp/workers/parse-coordinator.js

@@ -18,7 +18,7 @@ import { debugLog } from '../../core/utils/file-utils.js';
 import { getProjectName, UPSERT_PROJECT_QUERY, UPDATE_PROJECT_STATUS_QUERY } from '../../core/utils/project-id.js';
 import { WorkspaceDetector } from '../../core/workspace/index.js';
 import { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
-import { PARSING } from '../constants.js';
+import { PARSING, CONFIG_FILE_PATTERNS } from '../constants.js';
 import { GraphGeneratorHandler } from '../handlers/graph-generator.handler.js';
 import { ParallelImportHandler } from '../handlers/parallel-import.handler.js';
 import { StreamingImportHandler } from '../handlers/streaming-import.handler.js';
@@ -122,6 +122,11 @@ const runParser = async () => {
             totalNodesImported = result.nodesImported;
             totalEdgesImported = result.edgesImported;
         }
+        // Ingest config files (JSON, YAML, Dockerfiles, etc.)
+        const configGlobs = config.configFileGlobs ?? CONFIG_FILE_PATTERNS.defaultGlobs;
+        const configResult = await graphGeneratorHandler.ingestConfigFiles(config.projectPath, resolvedProjectId, configGlobs, CONFIG_FILE_PATTERNS.excludeGlobs, CONFIG_FILE_PATTERNS.maxFileSizeBytes);
+        totalNodesImported += configResult.nodesCreated;
+        await debugLog('Config file ingestion completed', { nodesCreated: configResult.nodesCreated });
         await neo4jService.run(UPDATE_PROJECT_STATUS_QUERY, {
             projectId: resolvedProjectId,
             status: 'complete',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-graph-context",
-  "version": "2.13.1",
+  "version": "2.13.3",
   "description": "MCP server that builds code graphs to provide rich context to LLMs",
   "type": "module",
   "homepage": "https://github.com/drewdrewH/code-graph-context#readme",