@rpcajr/smart-graph-indexer 1.0.0

package/dist/parser.js

@@ -0,0 +1,529 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASTParser = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const web_tree_sitter_1 = __importDefault(require("web-tree-sitter"));
+class ASTParser {
+    isInitialized = false;
+    languages = {};
+    constructor() { }
+    /**
+     * Initializes the web-tree-sitter parser and loads language WASM files.
+     */
+    async init(wasmDir) {
+        if (this.isInitialized)
+            return;
+        await web_tree_sitter_1.default.init({
+            locateFile: (filepath) => {
+                if (filepath === 'tree-sitter.wasm') {
+                    return path.join(wasmDir, 'tree-sitter.wasm');
+                }
+                return filepath;
+            }
+        });
+        const langFiles = {
+            csharp: 'tree-sitter-c_sharp.wasm',
+            typescript: 'tree-sitter-typescript.wasm',
+            python: 'tree-sitter-python.wasm',
+            java: 'tree-sitter-java.wasm',
+            go: 'tree-sitter-go.wasm',
+            rust: 'tree-sitter-rust.wasm',
+            ruby: 'tree-sitter-ruby.wasm',
+            cpp: 'tree-sitter-cpp.wasm',
+            c: 'tree-sitter-c.wasm',
+        };
+        for (const [key, file] of Object.entries(langFiles)) {
+            const fullPath = path.join(wasmDir, file);
+            if (fs.existsSync(fullPath)) {
+                try {
+                    this.languages[key] = await web_tree_sitter_1.default.Language.load(fullPath);
+                }
+                catch (err) {
+                    console.error(`Failed to load grammar: ${file}`, err);
+                }
+            }
+        }
+        this.isInitialized = true;
+    }
+    /**
+     * Calculates MD5 hash of file content.
+     */
+    getHash(content) {
+        return crypto.createHash('md5').update(content).digest('hex');
+    }
+    /**
+     * Parsers a file and extracts its skeleton.
+     */
+    parseFile(filePath, content) {
+        const ext = path.extname(filePath).toLowerCase();
+        const file_hash = this.getHash(content);
+        const dependencies = this.extractDependencies(content, ext);
+        let symbols = [];
+        if (!this.isInitialized) {
+            return { file_path: filePath, file_hash, symbols, dependencies };
+        }
+        const parser = new web_tree_sitter_1.default();
+        try {
+            if (ext === '.cs' && this.languages.csharp) {
+                parser.setLanguage(this.languages.csharp);
+                const tree = parser.parse(content);
+                symbols = this.parseCSharp(tree.rootNode, content);
+            }
+            else if (['.ts', '.tsx', '.js', '.jsx'].includes(ext) && this.languages.typescript) {
+                parser.setLanguage(this.languages.typescript);
+                const tree = parser.parse(content);
+                symbols = this.parseTypeScript(tree.rootNode, content);
+            }
+            else if (ext === '.py' && this.languages.python) {
+                parser.setLanguage(this.languages.python);
+                const tree = parser.parse(content);
+                symbols = this.parsePython(tree.rootNode, content);
+            }
+            else if (ext === '.java' && this.languages.java) {
+                parser.setLanguage(this.languages.java);
+                const tree = parser.parse(content);
+                symbols = this.parseJava(tree.rootNode, content);
+            }
+            else if (ext === '.go' && this.languages.go) {
+                parser.setLanguage(this.languages.go);
+                const tree = parser.parse(content);
+                symbols = this.parseGo(tree.rootNode, content);
+            }
+            else if (ext === '.rs' && this.languages.rust) {
+                parser.setLanguage(this.languages.rust);
+                const tree = parser.parse(content);
+                symbols = this.parseRust(tree.rootNode, content);
+            }
+            else if (ext === '.rb' && this.languages.ruby) {
+                parser.setLanguage(this.languages.ruby);
+                const tree = parser.parse(content);
+                symbols = this.parseRuby(tree.rootNode, content);
+            }
+            else if (['.cpp', '.hpp', '.cc', '.cxx', '.h', '.c'].includes(ext)) {
+                const lang = ['.c', '.h'].includes(ext) ? this.languages.c : this.languages.cpp;
+                if (lang) {
+                    parser.setLanguage(lang);
+                    const tree = parser.parse(content);
+                    symbols = this.parseCpp(tree.rootNode, content);
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Error parsing AST for ${filePath}:`, err);
+        }
+        return {
+            file_path: filePath,
+            file_hash,
+            symbols,
+            dependencies,
+        };
+    }
+    extractDependencies(content, ext) {
+        const deps = new Set();
+        if (ext === '.cs') {
+            const match = content.matchAll(/^\s*using\s+([^;=]+);/gm);
+            for (const m of match)
+                deps.add(m[1].trim());
+        }
+        else if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
+            const importMatch = content.matchAll(/import\s+(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/g);
+            for (const m of importMatch)
+                deps.add(m[1]);
+            const requireMatch = content.matchAll(/(?:const|let|var)\s+.*\s*=\s*require\(['"]([^'"]+)['"]\)/g);
+            for (const m of requireMatch)
+                deps.add(m[1]);
+        }
+        else if (ext === '.py') {
+            const importMatch = content.matchAll(/^\s*import\s+([^\s\n#]+)/gm);
+            for (const m of importMatch)
+                deps.add(m[1].trim());
+            const fromMatch = content.matchAll(/^\s*from\s+([^\s\n#]+)\s+import/gm);
+            for (const m of fromMatch)
+                deps.add(m[1].trim());
+        }
+        else if (ext === '.java') {
+            const match = content.matchAll(/^\s*import\s+([^;]+);/gm);
+            for (const m of match)
+                deps.add(m[1].trim());
+        }
+        else if (ext === '.go') {
+            const match = content.matchAll(/^\s*import\s+(?:\([^)]+\)|"[^"]+")/g);
+            for (const m of match) {
+                const inner = m[0].match(/"([^"]+)"/g);
+                if (inner) {
+                    for (const item of inner)
+                        deps.add(item.replace(/"/g, ''));
+                }
+            }
+        }
+        else if (ext === '.rs') {
+            const match = content.matchAll(/^\s*use\s+([^;]+);/gm);
+            for (const m of match)
+                deps.add(m[1].trim());
+        }
+        else if (ext === '.rb') {
+            const match = content.matchAll(/^\s*(?:require|require_relative)\s+['"]([^'"]+)['"]/gm);
+            for (const m of match)
+                deps.add(m[1].trim());
+        }
+        else if (['.cpp', '.hpp', '.cc', '.cxx', '.h', '.c'].includes(ext)) {
+            const match = content.matchAll(/^\s*#\s*include\s+([<"][^>"]+[>"])/gm);
+            for (const m of match)
+                deps.add(m[1].trim());
+        }
+        return Array.from(deps);
+    }
+    getPrecedingDocstring(node, content) {
+        const startLine = node.startPosition.row;
+        const lines = content.split('\n');
+        let lineIdx = startLine - 1;
+        const comments = [];
+        while (lineIdx >= 0) {
+            const currentLine = lines[lineIdx].trim();
+            if (currentLine.startsWith('///') || currentLine.startsWith('//') || currentLine.startsWith('/*') || currentLine.startsWith('*') || currentLine.endsWith('*/') || currentLine.startsWith('#')) {
+                comments.unshift(lines[lineIdx].trim());
+                lineIdx--;
+            }
+            else if (currentLine === '') {
+                lineIdx--;
+            }
+            else {
+                break;
+            }
+        }
+        if (comments.length > 0) {
+            return comments.join('\n');
+        }
+        return undefined;
+    }
+    parseCSharp(root, content) {
+        const symbols = [];
+        const traverse = (node) => {
+            const type = node.type;
+            if (type === 'class_declaration' || type === 'interface_declaration' || type === 'struct_declaration') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const kind = type === 'class_declaration' ? 'Class' : type === 'interface_declaration' ? 'Interface' : 'Struct';
+                const bodyNode = node.childForFieldName('body') || node.lastChild;
+                const sigEnd = bodyNode && bodyNode.type === 'declaration_list' ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind,
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            else if (type === 'method_declaration') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const bodyNode = node.childForFieldName('body');
+                const sigEnd = bodyNode ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind: 'Method',
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            for (let i = 0; i < node.childCount; i++)
+                traverse(node.child(i));
+        };
+        traverse(root);
+        return symbols;
+    }
+    parseTypeScript(root, content) {
+        const symbols = [];
+        const traverse = (node) => {
+            const type = node.type;
+            if (type === 'class_declaration' || type === 'interface_declaration') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const kind = type === 'class_declaration' ? 'Class' : 'Interface';
+                const bodyNode = node.childForFieldName('body') || node.lastChild;
+                const sigEnd = bodyNode && (bodyNode.type === 'class_body' || bodyNode.type === 'object_type') ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind,
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            else if (type === 'method_definition' || type === 'function_declaration') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const bodyNode = node.childForFieldName('body');
+                const sigEnd = bodyNode ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind: type === 'method_definition' ? 'Method' : 'Function',
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            for (let i = 0; i < node.childCount; i++)
+                traverse(node.child(i));
+        };
+        traverse(root);
+        return symbols;
+    }
+    parsePython(root, content) {
+        const symbols = [];
+        const traverse = (node) => {
+            const type = node.type;
+            if (type === 'class_definition' || type === 'function_definition') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const bodyNode = node.childForFieldName('body');
+                const sigEnd = bodyNode ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind: type === 'class_definition' ? 'Class' : 'Function',
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPythonDocstring(bodyNode, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            for (let i = 0; i < node.childCount; i++)
+                traverse(node.child(i));
+        };
+        traverse(root);
+        return symbols;
+    }
+    getPythonDocstring(bodyNode, content) {
+        if (!bodyNode || bodyNode.childCount === 0)
+            return undefined;
+        const firstStmt = bodyNode.child(0);
+        if (firstStmt && firstStmt.type === 'expression_statement') {
+            const stringNode = firstStmt.child(0);
+            if (stringNode && stringNode.type === 'string') {
+                let text = stringNode.text.trim();
+                if (text.startsWith('"""') && text.endsWith('"""'))
+                    return text.substring(3, text.length - 3).trim();
+                if (text.startsWith("'''") && text.endsWith("'''"))
+                    return text.substring(3, text.length - 3).trim();
+                return text;
+            }
+        }
+        return undefined;
+    }
+    parseJava(root, content) {
+        const symbols = [];
+        const traverse = (node) => {
+            const type = node.type;
+            if (type === 'class_declaration' || type === 'interface_declaration') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const bodyNode = node.childForFieldName('body');
+                const sigEnd = bodyNode ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind: type === 'class_declaration' ? 'Class' : 'Interface',
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            else if (type === 'method_declaration') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const bodyNode = node.childForFieldName('body');
+                const sigEnd = bodyNode ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind: 'Method',
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            for (let i = 0; i < node.childCount; i++)
+                traverse(node.child(i));
+        };
+        traverse(root);
+        return symbols;
+    }
+    parseGo(root, content) {
+        const symbols = [];
+        const traverse = (node) => {
+            const type = node.type;
+            if (type === 'type_spec') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const typeNode = node.childForFieldName('type');
+                const kind = typeNode && typeNode.type === 'interface_type' ? 'Interface' : 'Struct';
+                symbols.push({
+                    name, kind,
+                    signature: content.substring(node.startIndex, node.endIndex).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            else if (type === 'function_declaration' || type === 'method_declaration') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const bodyNode = node.childForFieldName('body');
+                const sigEnd = bodyNode ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind: type === 'method_declaration' ? 'Method' : 'Function',
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            for (let i = 0; i < node.childCount; i++)
+                traverse(node.child(i));
+        };
+        traverse(root);
+        return symbols;
+    }
+    parseRust(root, content) {
+        const symbols = [];
+        const traverse = (node) => {
+            const type = node.type;
+            if (type === 'struct_item' || type === 'enum_item' || type === 'trait_item') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const kind = type === 'struct_item' ? 'Struct' : type === 'enum_item' ? 'Enum' : 'Trait';
+                const bodyNode = node.childForFieldName('body') || node.lastChild;
+                const sigEnd = bodyNode ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind,
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            else if (type === 'function_item') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const bodyNode = node.childForFieldName('body');
+                const sigEnd = bodyNode ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind: 'Function',
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            for (let i = 0; i < node.childCount; i++)
+                traverse(node.child(i));
+        };
+        traverse(root);
+        return symbols;
+    }
+    parseRuby(root, content) {
+        const symbols = [];
+        const traverse = (node) => {
+            const type = node.type;
+            if (type === 'class' || type === 'module') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                symbols.push({
+                    name, kind: type === 'class' ? 'Class' : 'Interface',
+                    signature: `${type} ${name}`,
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            else if (type === 'method') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                symbols.push({
+                    name, kind: 'Method',
+                    signature: `def ${name}`,
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            for (let i = 0; i < node.childCount; i++)
+                traverse(node.child(i));
+        };
+        traverse(root);
+        return symbols;
+    }
+    parseCpp(root, content) {
+        const symbols = [];
+        const traverse = (node) => {
+            const type = node.type;
+            if (type === 'class_specifier' || type === 'struct_specifier') {
+                const nameNode = node.childForFieldName('name');
+                const name = nameNode ? nameNode.text : 'Unknown';
+                const bodyNode = node.childForFieldName('body');
+                const sigEnd = bodyNode ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind: type === 'class_specifier' ? 'Class' : 'Struct',
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            else if (type === 'function_definition') {
+                const declarator = node.childForFieldName('declarator');
+                const name = declarator ? declarator.text : 'Unknown';
+                const bodyNode = node.childForFieldName('body');
+                const sigEnd = bodyNode ? bodyNode.startIndex : node.endIndex;
+                symbols.push({
+                    name, kind: 'Function',
+                    signature: content.substring(node.startIndex, sigEnd).trim(),
+                    docstring: this.getPrecedingDocstring(node, content),
+                    start_line: node.startPosition.row + 1,
+                    end_line: node.endPosition.row + 1,
+                });
+            }
+            for (let i = 0; i < node.childCount; i++)
+                traverse(node.child(i));
+        };
+        traverse(root);
+        return symbols;
+    }
+}
+exports.ASTParser = ASTParser;

package/dist/stats.d.ts

@@ -0,0 +1,43 @@
+export interface ToolCallStats {
+    calls: number;
+    saved: number;
+    actual: number;
+    alternative: number;
+    totalTimeMs: number;
+}
+export interface HistoryEntry {
+    timestamp: string;
+    sessionId: string;
+    toolName: string;
+    saved: number;
+    actual: number;
+    alternative: number;
+    target?: string;
+    execTimeMs: number;
+}
+export interface TokenStats {
+    totalCalls: number;
+    totalTokensSaved: number;
+    totalTokensActual: number;
+    totalTokensAlternative: number;
+    efficiencyPercentage: number;
+    callsByType: Record<string, ToolCallStats>;
+    history: HistoryEntry[];
+}
+export declare class StatsManager {
+    private statsPath;
+    private stats;
+    private currentSessionId;
+    constructor(projectPath: string);
+    private loadStats;
+    private saveStats;
+    /**
+     * Estimates tokens based on character count (1 token approx 4 characters).
+     */
+    estimateTokens(text: string): number;
+    /**
+     * Records a tool call and computes the token savings.
+     */
+    recordCall(toolName: string, actualPayload: string, alternativeText: string, target?: string, execTimeMs?: number): void;
+    getStats(): TokenStats;
+}