code-graph-context 2.4.4 → 2.4.5

package/dist/mcp/handlers/file-change-detection.js

@@ -1,105 +0,0 @@
-/**
- * File Change Detection
- * Shared utilities for detecting changed files for incremental parsing
- */
-import { stat, realpath } from 'fs/promises';
-import { resolve, sep } from 'path';
-import { glob } from 'glob';
-import { EXCLUDE_PATTERNS_GLOB } from '../../constants.js';
-import { QUERIES } from '../../storage/neo4j/neo4j.service.js';
-import { hashFile } from '../../utils/file-utils.js';
-/**
- * Detect which files have changed and need reparsing.
- * Compares current files on disk with indexed files in Neo4j.
- *
- * SECURITY: Validates that all file paths stay within the project directory
- * after symlink resolution to prevent path traversal attacks.
- *
- * @param projectPath - Root path of the project
- * @param neo4jService - Neo4j service instance
- * @param projectId - Project ID for scoping queries
- * @param options - Optional configuration
- * @returns Files that need reparsing and files that were deleted
- */
-export const detectChangedFiles = async (projectPath, neo4jService, projectId, options = {}) => {
-    const { logWarnings = true } = options;
-    // SECURITY: Resolve project path to real path to handle symlinks consistently
-    const realProjectPath = await realpath(projectPath);
-    const relativeFiles = await glob('**/*.{ts,tsx}', { cwd: projectPath, ignore: EXCLUDE_PATTERNS_GLOB });
-    // SECURITY: Validate each file stays within project directory after symlink resolution
-    const validatedFiles = [];
-    for (const relFile of relativeFiles) {
-        const absolutePath = resolve(projectPath, relFile);
-        try {
-            const realFilePath = await realpath(absolutePath);
-            // Check that resolved path is within project
-            if (realFilePath.startsWith(realProjectPath + sep) || realFilePath === realProjectPath) {
-                // Use realFilePath for consistent path matching with Neo4j
-                validatedFiles.push(realFilePath);
-            }
-            else if (logWarnings) {
-                console.warn(`SECURITY: Skipping file outside project directory: ${relFile}`);
-            }
-        }
-        catch {
-            // File may have been deleted between glob and realpath - skip it
-            if (logWarnings) {
-                console.warn(`File no longer accessible: ${relFile}`);
-            }
-        }
-    }
-    const currentFiles = new Set(validatedFiles);
-    // Get indexed files from Neo4j
-    const queryResult = await neo4jService.run(QUERIES.GET_SOURCE_FILE_TRACKING_INFO, { projectId });
-    const indexedFiles = queryResult;
-    const indexedMap = new Map(indexedFiles.map((f) => [f.filePath, f]));
-    const filesToReparse = [];
-    const filesToDelete = [];
-    // Check each current file against indexed state
-    for (const filePath of currentFiles) {
-        const indexed = indexedMap.get(filePath);
-        if (!indexed) {
-            // New file - needs parsing
-            filesToReparse.push(filePath);
-            continue;
-        }
-        try {
-            const fileStats = await stat(filePath);
-            const currentHash = await hashFile(filePath);
-            // Only skip if mtime, size, AND hash all match (correctness over optimization)
-            if (fileStats.mtimeMs === indexed.mtime &&
-                fileStats.size === indexed.size &&
-                currentHash === indexed.contentHash) {
-                continue;
-            }
-            // Any mismatch means file changed
-            filesToReparse.push(filePath);
-        }
-        catch (error) {
-            const nodeError = error;
-            if (nodeError.code === 'ENOENT') {
-                // File was deleted between glob and stat - will be caught in deletion logic below
-                if (logWarnings) {
-                    console.warn(`File deleted between glob and stat: ${filePath}`);
-                }
-            }
-            else if (nodeError.code === 'EACCES') {
-                // Permission denied - assume changed to be safe
-                if (logWarnings) {
-                    console.warn(`Permission denied reading file: ${filePath}`);
-                }
-                filesToReparse.push(filePath);
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    // Find deleted files (indexed but no longer on disk)
-    for (const indexedPath of indexedMap.keys()) {
-        if (!currentFiles.has(indexedPath)) {
-            filesToDelete.push(indexedPath);
-        }
-    }
-    return { filesToReparse, filesToDelete };
-};

package/dist/mcp/services.js

@@ -1,79 +0,0 @@
-/**
- * Service Initialization
- * Handles initialization of external services like Neo4j schema and OpenAI assistant
- */
-import fs from 'fs/promises';
-import { join } from 'path';
-import { Neo4jService, QUERIES } from '../storage/neo4j/neo4j.service.js';
-import { FILE_PATHS, LOG_CONFIG } from './constants.js';
-import { initializeNaturalLanguageService } from './tools/natural-language-to-cypher.tool.js';
-import { debugLog } from './utils.js';
-/**
- * Initialize all external services required by the MCP server
- */
-export const initializeServices = async () => {
-    await Promise.all([initializeNeo4jSchema(), initializeNaturalLanguageService()]);
-};
-/**
- * Dynamically discover schema from the actual graph contents.
- * This is framework-agnostic - it discovers what's actually in the graph.
- */
-const discoverSchemaFromGraph = async (neo4jService) => {
-    try {
-        // Discover actual node types, relationships, and patterns from the graph
-        const [nodeTypes, relationshipTypes, semanticTypes, commonPatterns] = await Promise.all([
-            neo4jService.run(QUERIES.DISCOVER_NODE_TYPES),
-            neo4jService.run(QUERIES.DISCOVER_RELATIONSHIP_TYPES),
-            neo4jService.run(QUERIES.DISCOVER_SEMANTIC_TYPES),
-            neo4jService.run(QUERIES.DISCOVER_COMMON_PATTERNS),
-        ]);
-        return {
-            nodeTypes: nodeTypes.map((r) => ({
-                label: r.label,
-                count: typeof r.nodeCount === 'object' ? r.nodeCount.toNumber() : r.nodeCount,
-                properties: r.sampleProperties ?? [],
-            })),
-            relationshipTypes: relationshipTypes.map((r) => ({
-                type: r.relationshipType,
-                count: typeof r.relCount === 'object' ? r.relCount.toNumber() : r.relCount,
-                connections: r.connections ?? [],
-            })),
-            semanticTypes: semanticTypes.map((r) => ({
-                type: r.semanticType,
-                count: typeof r.count === 'object' ? r.count.toNumber() : r.count,
-            })),
-            commonPatterns: commonPatterns.map((r) => ({
-                from: r.fromType,
-                relationship: r.relType,
-                to: r.toType,
-                count: typeof r.count === 'object' ? r.count.toNumber() : r.count,
-            })),
-        };
-    }
-    catch (error) {
-        await debugLog('Failed to discover schema from graph', error);
-        return null;
-    }
-};
-/**
- * Initialize Neo4j schema by fetching from APOC and discovering actual graph structure
- */
-const initializeNeo4jSchema = async () => {
-    try {
-        const neo4jService = new Neo4jService();
-        const rawSchema = await neo4jService.getSchema();
-        // Dynamically discover what's actually in the graph
-        const discoveredSchema = await discoverSchemaFromGraph(neo4jService);
-        const schema = {
-            rawSchema,
-            discoveredSchema,
-        };
-        const schemaPath = join(process.cwd(), FILE_PATHS.schemaOutput);
-        await fs.writeFile(schemaPath, JSON.stringify(schema, null, LOG_CONFIG.jsonIndentation));
-        await debugLog('Neo4j schema cached successfully', { schemaPath });
-    }
-    catch (error) {
-        await debugLog('Failed to initialize Neo4j schema', error);
-        // Don't throw - service can still function without cached schema
-    }
-};

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

@@ -1,198 +0,0 @@
-/**
- * Parse Worker
- * Runs TypeScript parsing in a separate thread to avoid blocking the MCP server
- */
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-import { parentPort, workerData } from 'worker_threads';
-// Load environment variables in worker thread
-import dotenv from 'dotenv';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-dotenv.config({ path: join(__dirname, '..', '..', '..', '.env') });
-import { EmbeddingsService } from '../../core/embeddings/embeddings.service.js';
-import { ParserFactory } from '../../core/parsers/parser-factory.js';
-import { WorkspaceParser } from '../../core/parsers/workspace-parser.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 { debugLog } from '../../core/utils/file-utils.js';
-import { GraphGeneratorHandler } from '../handlers/graph-generator.handler.js';
-import { StreamingImportHandler } from '../handlers/streaming-import.handler.js';
-const sendMessage = (msg) => {
-    parentPort?.postMessage(msg);
-};
-const runParser = async () => {
-    const config = workerData;
-    const startTime = Date.now();
-    // Declare outside try block so it's available in catch/finally
-    let resolvedProjectId = config.projectId;
-    let neo4jService = null;
-    try {
-        sendMessage({
-            type: 'progress',
-            data: {
-                phase: 'discovery',
-                filesProcessed: 0,
-                filesTotal: 0,
-                nodesImported: 0,
-                edgesImported: 0,
-                currentChunk: 0,
-                totalChunks: 0,
-            },
-        });
-        neo4jService = new Neo4jService();
-        const embeddingsService = new EmbeddingsService();
-        const graphGeneratorHandler = new GraphGeneratorHandler(neo4jService, embeddingsService);
-        // Use lazy loading to avoid OOM on large projects
-        const lazyLoad = true;
-        // Auto-detect workspace (Turborepo, pnpm, yarn, npm workspaces)
-        const workspaceDetector = new WorkspaceDetector();
-        await debugLog('Detecting workspace', { projectPath: config.projectPath });
-        const workspaceConfig = await workspaceDetector.detect(config.projectPath);
-        await debugLog('Workspace detection result', {
-            type: workspaceConfig.type,
-            rootPath: workspaceConfig.rootPath,
-            packageCount: workspaceConfig.packages.length,
-            packages: workspaceConfig.packages.map((p) => p.name),
-        });
-        // Use WorkspaceParser for monorepos, TypeScriptParser for single projects
-        let parser;
-        if (workspaceConfig.type !== 'single' && workspaceConfig.packages.length > 1) {
-            await debugLog('Using WorkspaceParser', {
-                type: workspaceConfig.type,
-                packageCount: workspaceConfig.packages.length,
-            });
-            // for workspaces default to auto for now
-            // TODO: allow worker config to specify projectType array to support multi-framework monorepos
-            parser = new WorkspaceParser(workspaceConfig, config.projectId, lazyLoad, 'auto');
-            resolvedProjectId = parser.getProjectId();
-        }
-        else {
-            await debugLog('Using single project mode', {
-                type: workspaceConfig.type,
-                packageCount: workspaceConfig.packages.length,
-            });
-            parser =
-                config.projectType === 'auto'
-                    ? await ParserFactory.createParserWithAutoDetection(config.projectPath, config.tsconfigPath, config.projectId, lazyLoad)
-                    : ParserFactory.createParser({
-                        workspacePath: config.projectPath,
-                        tsConfigPath: config.tsconfigPath,
-                        projectType: config.projectType,
-                        projectId: config.projectId,
-                        lazyLoad,
-                    });
-            resolvedProjectId = parser.getProjectId();
-        }
-        // Use async file discovery (works in lazy mode)
-        const sourceFiles = await parser.discoverSourceFiles();
-        const totalFiles = sourceFiles.length;
-        sendMessage({
-            type: 'progress',
-            data: {
-                phase: 'parsing',
-                filesProcessed: 0,
-                filesTotal: totalFiles,
-                nodesImported: 0,
-                edgesImported: 0,
-                currentChunk: 0,
-                totalChunks: Math.ceil(totalFiles / config.chunkSize),
-            },
-        });
-        // Clear existing project data first
-        graphGeneratorHandler.setProjectId(resolvedProjectId);
-        await neo4jService.run(QUERIES.CLEAR_PROJECT, { projectId: resolvedProjectId });
-        // Create/update Project node with 'parsing' status
-        const projectName = await getProjectName(config.projectPath);
-        await neo4jService.run(UPSERT_PROJECT_QUERY, {
-            projectId: resolvedProjectId,
-            name: projectName,
-            path: config.projectPath,
-            status: 'parsing',
-        });
-        await debugLog('Project node created', { projectId: resolvedProjectId, name: projectName });
-        const streamingHandler = new StreamingImportHandler(graphGeneratorHandler);
-        const result = await streamingHandler.importProjectStreaming(parser, {
-            chunkSize: config.chunkSize > 0 ? config.chunkSize : 100,
-            projectId: resolvedProjectId,
-            onProgress: async (progress) => {
-                sendMessage({
-                    type: 'progress',
-                    data: {
-                        phase: progress.phase,
-                        filesProcessed: progress.current,
-                        filesTotal: progress.total,
-                        nodesImported: progress.details?.nodesCreated ?? 0,
-                        edgesImported: progress.details?.edgesCreated ?? 0,
-                        currentChunk: progress.details?.chunkIndex ?? 0,
-                        totalChunks: progress.details?.totalChunks ?? 0,
-                    },
-                });
-            },
-        });
-        // Update Project node with 'complete' status and final counts
-        await neo4jService.run(UPDATE_PROJECT_STATUS_QUERY, {
-            projectId: resolvedProjectId,
-            status: 'complete',
-            nodeCount: result.nodesImported,
-            edgeCount: result.edgesImported,
-        });
-        await debugLog('Project node updated', {
-            projectId: resolvedProjectId,
-            status: 'complete',
-            nodeCount: result.nodesImported,
-            edgeCount: result.edgesImported,
-        });
-        sendMessage({
-            type: 'complete',
-            data: {
-                nodesImported: result.nodesImported,
-                edgesImported: result.edgesImported,
-                elapsedMs: Date.now() - startTime,
-            },
-        });
-    }
-    catch (error) {
-        // Try to update Project node with 'failed' status
-        try {
-            // Use existing service if available, otherwise create temporary one
-            const serviceForUpdate = neo4jService ?? new Neo4jService();
-            await serviceForUpdate.run(UPDATE_PROJECT_STATUS_QUERY, {
-                projectId: resolvedProjectId, // Use resolved ID, not config.projectId
-                status: 'failed',
-                nodeCount: 0,
-                edgeCount: 0,
-            });
-            // Close temporary service if we created one
-            if (!neo4jService) {
-                await serviceForUpdate.close();
-            }
-        }
-        catch {
-            // Ignore errors updating project status on failure
-        }
-        sendMessage({
-            type: 'error',
-            error: error.message ?? String(error),
-        });
-    }
-    finally {
-        // Always close the Neo4j connection to prevent resource leaks
-        if (neo4jService) {
-            try {
-                await neo4jService.close();
-            }
-            catch {
-                // Ignore cleanup errors
-            }
-        }
-    }
-};
-// Run the parser
-runParser().catch((err) => {
-    sendMessage({
-        type: 'error',
-        error: err.message ?? String(err),
-    });
-});

package/dist/mcp/workers/worker.pool.js

@@ -1,54 +0,0 @@
-import { Worker } from 'worker_threads';
-export class ParallelPool {
-    workerPath;
-    numWorkers;
-    constructor(workerPath, numWorkers = 2) {
-        this.workerPath = workerPath;
-        this.numWorkers = numWorkers;
-    }
-    async run(items) {
-        const start = Date.now();
-        const indexBuffer = new SharedArrayBuffer(4);
-        const sharedIndex = new Int32Array(indexBuffer);
-        const workerPromises = Array.from({ length: this.numWorkers }, (_, id) => this.spawnWorker(id, items, indexBuffer));
-        const workerResults = await Promise.all(workerPromises);
-        const results = [];
-        const workerTaskCounts = [];
-        for (const { results: map, count } of workerResults) {
-            workerTaskCounts.push(count);
-            for (const [i, result] of map) {
-                results[i] = result;
-            }
-        }
-        return {
-            results,
-            stats: {
-                workerTaskCounts,
-                totalTasks: items.length,
-                totalTimeMs: Date.now() - start,
-            },
-        };
-    }
-    spawnWorker(workerId, items, indexBuffer) {
-        return new Promise((resolve, reject) => {
-            const worker = new Worker(this.workerPath, {
-                workerData: {
-                    items,
-                    indexBuffer,
-                    total: items.length,
-                    workerId,
-                },
-            });
-            worker.on('message', (result) => {
-                worker.terminate();
-                resolve(result);
-            });
-            worker.on('error', reject);
-            worker.on('exit', (code) => {
-                if (code !== 0) {
-                    reject(new Error(`Worker ${workerId} exited with code ${code}`));
-                }
-            });
-        });
-    }
-}

package/dist/parsers/cypher-result.parser.js

@@ -1,44 +0,0 @@
-export class CypherResultParser {
-    static parseCypherResult(result) {
-        if (!result || result.length === 0) {
-            return 'No results found.';
-        }
-        const parsedResults = {};
-        // Parse nodes
-        if (result[0].nodes) {
-            parsedResults.nodes = result[0].nodes.map((node) => ({
-                identity: node.identity.toString(),
-                labels: node.labels,
-                properties: node.properties,
-            }));
-        }
-        // Parse relationships
-        if (result[0].relationships) {
-            parsedResults.relationships = result[0].relationships.map((rel) => ({
-                identity: rel.identity.toString(),
-                type: rel.type,
-                properties: rel.properties,
-                start: rel.start.toString(),
-                end: rel.end.toString(),
-            }));
-        }
-        // Parse paths
-        if (result[0].paths) {
-            parsedResults.paths = result[0].paths.map((path) => ({
-                start: path.start,
-                end: path.end,
-                segments: path.segments,
-                length: path.length,
-            }));
-        }
-        // Parse data
-        if (result[0].data) {
-            parsedResults.data = result[0].data;
-        }
-        // Parse summary
-        if (result[0].summary) {
-            parsedResults.summary = result[0].summary;
-        }
-        return JSON.stringify(parsedResults, null, 2);
-    }
-}

package/dist/utils/file-utils.js

@@ -1,20 +0,0 @@
-import * as crypto from 'crypto';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-const DEBUG_LOG_FILE = 'debug-search.log';
-const LOG_SEPARATOR = '---';
-const JSON_INDENT = 2;
-export const hashFile = async (filePath) => {
-    const content = await fs.readFile(filePath);
-    return crypto.createHash('sha256').update(content).digest('hex');
-};
-export const debugLog = async (message, data) => {
-    const timestamp = new Date().toISOString();
-    const logEntry = `[${timestamp}] ${message}\n${data ? JSON.stringify(data, null, JSON_INDENT) : ''}\n${LOG_SEPARATOR}\n`;
-    try {
-        await fs.appendFile(path.join(process.cwd(), DEBUG_LOG_FILE), logEntry);
-    }
-    catch (error) {
-        console.error('Failed to write debug log:', error);
-    }
-};

package/dist/utils/test.js

@@ -1,19 +0,0 @@
-import 'reflect-metadata';
-import { writeFileSync } from 'node:fs';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { NESTJS_FRAMEWORK_SCHEMA } from '../core/config/graph-v2';
-import { TypeScriptParser } from '../core/parsers/typescript-parser-v2';
-const workspace = path.join(os.homedir(), 'nestjs/iluvcoffee');
-const tsconfig = path.join(workspace, 'tsconfig.json'); // or tsconfig.build.json etc.
-(async () => {
-    console.log({ workspace, tsconfig, exists: fs.existsSync(tsconfig) });
-    const parser = new TypeScriptParser(workspace, tsconfig, undefined, [NESTJS_FRAMEWORK_SCHEMA]);
-    // 👇  pull in every *.ts file under the repo
-    parser['project'].addSourceFilesAtPaths(path.join(workspace, 'src/**/*.ts'));
-    const { nodes, edges } = await parser.parseWorkspace(); // runs fine now
-    const { nodes: cleanNodes, edges: cleanEdges } = parser.exportToJson();
-    console.log(`Parsed ${cleanNodes.length} nodes / ${cleanEdges.length} edges`);
-    writeFileSync('em-backend-graph.json', JSON.stringify({ nodes: cleanNodes, edges: cleanEdges }, null, 2));
-})();