@rpcajr/smart-graph-indexer 1.0.0

package/dist/mcp_server.js

@@ -0,0 +1,433 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexerEngine = void 0;
+exports.createMCPServer = createMCPServer;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const parser_js_1 = require("./parser.js");
+const graph_js_1 = require("./graph.js");
+const vector_js_1 = require("./vector.js");
+const watcher_js_1 = require("./watcher.js");
+const stats_js_1 = require("./stats.js");
+class IndexerEngine {
+    projectPath;
+    parser;
+    graph;
+    vectorStore;
+    watcher;
+    fileSkeletons = new Map();
+    isLoaded = false;
+    stats;
+    constructor(projectPath, onUpdate) {
+        this.projectPath = path.resolve(projectPath);
+        this.stats = new stats_js_1.StatsManager(this.projectPath);
+        this.parser = new parser_js_1.ASTParser();
+        this.graph = new graph_js_1.DependencyGraph();
+        this.vectorStore = new vector_js_1.VectorStore();
+        this.watcher = new watcher_js_1.GitAwareWatcher({
+            projectPath: this.projectPath,
+            onChange: async (changedFiles) => {
+                console.error(`[Watcher] Files modified, re-indexing: ${changedFiles.join(', ')}`);
+                for (const file of changedFiles) {
+                    await this.indexFile(file);
+                }
+                if (onUpdate) {
+                    onUpdate();
+                }
+            },
+        });
+    }
+    updateProjectPath(newPath, onUpdate) {
+        this.projectPath = path.resolve(newPath);
+        this.stats = new stats_js_1.StatsManager(this.projectPath);
+        this.watcher = new watcher_js_1.GitAwareWatcher({
+            projectPath: this.projectPath,
+            onChange: async (changedFiles) => {
+                console.error(`[Watcher] Files modified, re-indexing: ${changedFiles.join(', ')}`);
+                for (const file of changedFiles) {
+                    await this.indexFile(file);
+                }
+                if (onUpdate) {
+                    onUpdate();
+                }
+            },
+        });
+    }
+    startWatcher() {
+        this.watcher.start();
+    }
+    async initialize() {
+        const wasmDir = path.join(__dirname, 'wasm');
+        await this.parser.init(wasmDir);
+        await this.vectorStore.init();
+    }
+    /**
+     * Scans and indexes the entire directory recursively.
+     */
+    async startIndexing() {
+        await this.initialize();
+        // Check if the workspace is initialized for SmartGraphIndexer (.graph-indexer folder exists)
+        const mcpDir = path.join(this.projectPath, '.graph-indexer');
+        if (!fs.existsSync(mcpDir)) {
+            console.error(`[Indexer] .graph-indexer directory not found at: ${this.projectPath}. SmartGraphIndexerMCP is dormant for this workspace.`);
+            this.isLoaded = true;
+            return; // Do not scan or watch
+        }
+        const deltas = await this.watcher.getGitDeltas();
+        console.error(`[Indexer] Git status deltas detected: ${deltas.length} files.`);
+        // Recursive scan
+        await this.scanDir(this.projectPath);
+        this.isLoaded = true;
+        // Start watching filesystem
+        this.watcher.start();
+        console.error('[Indexer] Full initial indexing completed. File watcher active.');
+    }
+    async scanDir(dir) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = path.relative(this.projectPath, fullPath).replace(/\\/g, '/');
+            if (this.watcher.isIgnored(relativePath)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await this.scanDir(fullPath);
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                const supported = [
+                    '.cs', '.ts', '.tsx', '.js', '.jsx', '.py',
+                    '.java', '.go', '.rs', '.rb',
+                    '.cpp', '.hpp', '.cc', '.cxx', '.h', '.c'
+                ];
+                if (supported.includes(ext)) {
+                    await this.indexFile(relativePath);
+                }
+            }
+        }
+    }
+    /**
+     * Indexes a single file.
+     */
+    async indexFile(relativeFilePath) {
+        const normalizedPath = relativeFilePath.replace(/\\/g, '/');
+        const fullPath = path.resolve(this.projectPath, normalizedPath);
+        if (!fs.existsSync(fullPath)) {
+            this.fileSkeletons.delete(normalizedPath);
+            this.graph.removeFile(normalizedPath);
+            this.vectorStore.removeFileSymbols(normalizedPath);
+            return;
+        }
+        try {
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            const hash = this.parser.getHash(content);
+            const cached = this.fileSkeletons.get(normalizedPath);
+            if (cached && cached.file_hash === hash) {
+                return;
+            }
+            const skeleton = this.parser.parseFile(normalizedPath, content);
+            this.fileSkeletons.set(normalizedPath, skeleton);
+            this.graph.updateFileDependencies(normalizedPath, skeleton.dependencies);
+            this.vectorStore.removeFileSymbols(normalizedPath);
+            for (const symbol of skeleton.symbols) {
+                await this.vectorStore.addSymbol(normalizedPath, symbol);
+            }
+        }
+        catch (err) {
+            console.error(`Error indexing file ${normalizedPath}:`, err);
+        }
+    }
+    /**
+     * Gracefully updates a file on demand (for JIT read operations).
+     */
+    async ensureFileUpToDate(relativeFilePath) {
+        await this.indexFile(relativeFilePath);
+        return this.fileSkeletons.get(relativeFilePath);
+    }
+    getFileSkeleton(relativeFilePath) {
+        return this.fileSkeletons.get(relativeFilePath);
+    }
+    getGraph() {
+        return this.graph;
+    }
+    getVectorStore() {
+        return this.vectorStore;
+    }
+    getStatsManager() {
+        return this.stats;
+    }
+    async shutdown() {
+        await this.watcher.stop();
+    }
+    getReport() {
+        return {
+            totalFiles: this.fileSkeletons.size,
+            files: Array.from(this.fileSkeletons.keys()),
+            symbolsCount: this.vectorStore.getAllSymbols().length,
+            dependencyGraph: this.graph.serialize(),
+            tokenStats: this.stats.getStats(),
+        };
+    }
+}
+exports.IndexerEngine = IndexerEngine;
+function createMCPServer(engine) {
+    const server = new index_js_1.Server({
+        name: 'SmartGraphIndexerMCP',
+        version: '1.0.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // 1. List available tools
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    name: 'search_symbols',
+                    description: 'Performs hybrid search (semantic via vectors + lexical via text) over the indexed signatures database.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            query: {
+                                type: 'string',
+                                description: 'Search term or functional description of the logic you want to find.',
+                            },
+                            limit: {
+                                type: 'integer',
+                                description: 'Maximum number of matches to return.',
+                                default: 5,
+                            },
+                        },
+                        required: ['query'],
+                    },
+                },
+                {
+                    name: 'get_file_skeleton',
+                    description: 'Returns the complete structure (skeleton) of a specific file without inner implementations.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            file_path: {
+                                type: 'string',
+                                description: 'Relative path of the file in the project.',
+                            },
+                        },
+                        required: ['file_path'],
+                    },
+                },
+                {
+                    name: 'get_dependencies',
+                    description: 'Queries the in-memory graph and returns imports/dependants of a specific file.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            file_path: {
+                                type: 'string',
+                                description: 'Relative path of the source file.',
+                            },
+                            direction: {
+                                type: 'string',
+                                enum: ['incoming', 'outgoing', 'both'],
+                                description: 'Direction of dependencies to query.',
+                                default: 'both',
+                            },
+                        },
+                        required: ['file_path'],
+                    },
+                },
+                {
+                    name: 'read_symbol_body',
+                    description: 'JIT Extraction. Returns the actual, complete source code of a specific method or class based on coordinates.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            file_path: {
+                                type: 'string',
+                                description: 'Relative path of the file.',
+                            },
+                            symbol_name: {
+                                type: 'string',
+                                description: 'Exact name of the class or method to read.',
+                            },
+                        },
+                        required: ['file_path', 'symbol_name'],
+                    },
+                },
+                {
+                    name: 'get_token_savings',
+                    description: 'Returns token savings statistics accumulated in the project by using this MCP.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+            ],
+        };
+    });
+    // 2. Handle tool calls
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const startTime = Date.now();
+        try {
+            if (name === 'search_symbols') {
+                const query = String(args?.query);
+                const limit = Number(args?.limit ?? 5);
+                const results = await engine.getVectorStore().search(query, limit);
+                const actualPayload = JSON.stringify(results, null, 2);
+                let alternativeText = '';
+                for (const res of results) {
+                    const fullPath = path.resolve(engine.projectPath, res.symbol.filePath);
+                    if (fs.existsSync(fullPath)) {
+                        alternativeText += fs.readFileSync(fullPath, 'utf-8');
+                    }
+                }
+                const execTimeMs = Date.now() - startTime;
+                engine.getStatsManager().recordCall('search_symbols', actualPayload, alternativeText, `Query: "${query}"`, execTimeMs);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: actualPayload,
+                        },
+                    ],
+                };
+            }
+            if (name === 'get_file_skeleton') {
+                const filePath = String(args?.file_path).replace(/\\/g, '/');
+                const skeleton = await engine.ensureFileUpToDate(filePath);
+                if (!skeleton) {
+                    throw new Error(`File ${filePath} not found or could not be parsed.`);
+                }
+                const actualPayload = JSON.stringify(skeleton, null, 2);
+                const fullPath = path.resolve(engine.projectPath, filePath);
+                const alternativeText = fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf-8') : '';
+                const execTimeMs = Date.now() - startTime;
+                engine.getStatsManager().recordCall('get_file_skeleton', actualPayload, alternativeText, filePath, execTimeMs);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: actualPayload,
+                        },
+                    ],
+                };
+            }
+            if (name === 'get_dependencies') {
+                const filePath = String(args?.file_path).replace(/\\/g, '/');
+                const direction = String(args?.direction ?? 'both');
+                const graph = engine.getGraph();
+                const result = {};
+                if (direction === 'outgoing' || direction === 'both') {
+                    result.outgoing = graph.getOutgoing(filePath);
+                }
+                if (direction === 'incoming' || direction === 'both') {
+                    result.incoming = graph.getIncoming(filePath);
+                }
+                const actualPayload = JSON.stringify(result, null, 2);
+                const fullPath = path.resolve(engine.projectPath, filePath);
+                const alternativeText = fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf-8') : '';
+                const execTimeMs = Date.now() - startTime;
+                engine.getStatsManager().recordCall('get_dependencies', actualPayload, alternativeText, filePath, execTimeMs);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: actualPayload,
+                        },
+                    ],
+                };
+            }
+            if (name === 'read_symbol_body') {
+                const filePath = String(args?.file_path).replace(/\\/g, '/');
+                const symbolName = String(args?.symbol_name);
+                const skeleton = await engine.ensureFileUpToDate(filePath);
+                if (!skeleton) {
+                    throw new Error(`File ${filePath} not found or could not be parsed.`);
+                }
+                const symbol = skeleton.symbols.find(s => s.name === symbolName);
+                if (!symbol) {
+                    throw new Error(`Symbol ${symbolName} not found in ${filePath}.`);
+                }
+                const fullPath = path.resolve(engine.projectPath, filePath);
+                if (!fs.existsSync(fullPath)) {
+                    throw new Error(`File ${filePath} does not exist on disk.`);
+                }
+                const fileLines = fs.readFileSync(fullPath, 'utf-8').split('\n');
+                const start = Math.max(0, symbol.start_line - 1);
+                const end = Math.min(fileLines.length, symbol.end_line);
+                const codeSlice = fileLines.slice(start, end).join('\n');
+                const fullContent = fileLines.join('\n');
+                const execTimeMs = Date.now() - startTime;
+                engine.getStatsManager().recordCall('read_symbol_body', codeSlice, fullContent, `${filePath} -> ${symbolName}`, execTimeMs);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: codeSlice,
+                        },
+                    ],
+                };
+            }
+            if (name === 'get_token_savings') {
+                const stats = engine.getStatsManager().getStats();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(stats, null, 2),
+                        },
+                    ],
+                };
+            }
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: err?.message || String(err),
+                    },
+                ],
+            };
+        }
+    });
+    return server;
+}

package/dist/parser.d.ts

@@ -0,0 +1,42 @@
+export interface SymbolSkeleton {
+    name: string;
+    kind: 'Class' | 'Struct' | 'Method' | 'Property' | 'Interface' | 'Function' | 'Enum' | 'Trait';
+    signature: string;
+    docstring?: string;
+    start_line: number;
+    end_line: number;
+}
+export interface FileSkeleton {
+    file_path: string;
+    file_hash: string;
+    symbols: SymbolSkeleton[];
+    dependencies: string[];
+}
+export declare class ASTParser {
+    private isInitialized;
+    private languages;
+    constructor();
+    /**
+     * Initializes the web-tree-sitter parser and loads language WASM files.
+     */
+    init(wasmDir: string): Promise<void>;
+    /**
+     * Calculates MD5 hash of file content.
+     */
+    getHash(content: string): string;
+    /**
+     * Parsers a file and extracts its skeleton.
+     */
+    parseFile(filePath: string, content: string): FileSkeleton;
+    private extractDependencies;
+    private getPrecedingDocstring;
+    private parseCSharp;
+    private parseTypeScript;
+    private parsePython;
+    private getPythonDocstring;
+    private parseJava;
+    private parseGo;
+    private parseRust;
+    private parseRuby;
+    private parseCpp;
+}