@rpcajr/smart-graph-indexer 1.0.0

package/src/parser.ts

@@ -0,0 +1,484 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import Parser from 'web-tree-sitter';
+
+export interface SymbolSkeleton {
+  name: string;
+  kind: 'Class' | 'Struct' | 'Method' | 'Property' | 'Interface' | 'Function' | 'Enum' | 'Trait';
+  signature: string;
+  docstring?: string;
+  start_line: number; // 1-indexed
+  end_line: number; // 1-indexed
+}
+
+export interface FileSkeleton {
+  file_path: string;
+  file_hash: string;
+  symbols: SymbolSkeleton[];
+  dependencies: string[];
+}
+
+export class ASTParser {
+  private isInitialized = false;
+  private languages: Record<string, Parser.Language> = {};
+
+  constructor() {}
+
+  /**
+   * Initializes the web-tree-sitter parser and loads language WASM files.
+   */
+  public async init(wasmDir: string) {
+    if (this.isInitialized) return;
+
+    await Parser.init({
+      locateFile: (filepath: string) => {
+        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 Parser.Language.load(fullPath);
+        } catch (err) {
+          console.error(`Failed to load grammar: ${file}`, err);
+        }
+      }
+    }
+    this.isInitialized = true;
+  }
+
+  /**
+   * Calculates MD5 hash of file content.
+   */
+  public getHash(content: string): string {
+    return crypto.createHash('md5').update(content).digest('hex');
+  }
+
+  /**
+   * Parsers a file and extracts its skeleton.
+   */
+  public parseFile(filePath: string, content: string): FileSkeleton {
+    const ext = path.extname(filePath).toLowerCase();
+    const file_hash = this.getHash(content);
+    const dependencies = this.extractDependencies(content, ext);
+
+    let symbols: SymbolSkeleton[] = [];
+
+    if (!this.isInitialized) {
+      return { file_path: filePath, file_hash, symbols, dependencies };
+    }
+
+    const parser = new Parser();
+
+    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,
+    };
+  }
+
+  private extractDependencies(content: string, ext: string): string[] {
+    const deps = new Set<string>();
+    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);
+  }
+
+  private getPrecedingDocstring(node: Parser.SyntaxNode, content: string): string | undefined {
+    const startLine = node.startPosition.row;
+    const lines = content.split('\n');
+    let lineIdx = startLine - 1;
+    const comments: string[] = [];
+
+    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;
+  }
+
+  private parseCSharp(root: Parser.SyntaxNode, content: string): SymbolSkeleton[] {
+    const symbols: SymbolSkeleton[] = [];
+    const traverse = (node: Parser.SyntaxNode) => {
+      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;
+  }
+
+  private parseTypeScript(root: Parser.SyntaxNode, content: string): SymbolSkeleton[] {
+    const symbols: SymbolSkeleton[] = [];
+    const traverse = (node: Parser.SyntaxNode) => {
+      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;
+  }
+
+  private parsePython(root: Parser.SyntaxNode, content: string): SymbolSkeleton[] {
+    const symbols: SymbolSkeleton[] = [];
+    const traverse = (node: Parser.SyntaxNode) => {
+      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;
+  }
+
+  private getPythonDocstring(bodyNode: Parser.SyntaxNode | null, content: string): string | undefined {
+    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;
+  }
+
+  private parseJava(root: Parser.SyntaxNode, content: string): SymbolSkeleton[] {
+    const symbols: SymbolSkeleton[] = [];
+    const traverse = (node: Parser.SyntaxNode) => {
+      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;
+  }
+
+  private parseGo(root: Parser.SyntaxNode, content: string): SymbolSkeleton[] {
+    const symbols: SymbolSkeleton[] = [];
+    const traverse = (node: Parser.SyntaxNode) => {
+      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;
+  }
+
+  private parseRust(root: Parser.SyntaxNode, content: string): SymbolSkeleton[] {
+    const symbols: SymbolSkeleton[] = [];
+    const traverse = (node: Parser.SyntaxNode) => {
+      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;
+  }
+
+  private parseRuby(root: Parser.SyntaxNode, content: string): SymbolSkeleton[] {
+    const symbols: SymbolSkeleton[] = [];
+    const traverse = (node: Parser.SyntaxNode) => {
+      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;
+  }
+
+  private parseCpp(root: Parser.SyntaxNode, content: string): SymbolSkeleton[] {
+    const symbols: SymbolSkeleton[] = [];
+    const traverse = (node: Parser.SyntaxNode) => {
+      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;
+  }
+}

package/src/stats.ts

@@ -0,0 +1,156 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface ToolCallStats {
+  calls: number;
+  saved: number;
+  actual: number;
+  alternative: number;
+  totalTimeMs: number;
+}
+
+export interface HistoryEntry {
+  timestamp: string; // ISO string
+  sessionId: string; // timestamp of session start
+  toolName: string;
+  saved: number;
+  actual: number;
+  alternative: number;
+  target?: string; // file path or search query target
+  execTimeMs: number; // execution time in milliseconds
+}
+
+export interface TokenStats {
+  totalCalls: number;
+  totalTokensSaved: number;
+  totalTokensActual: number;
+  totalTokensAlternative: number;
+  efficiencyPercentage: number;
+  callsByType: Record<string, ToolCallStats>;
+  history: HistoryEntry[];
+}
+
+export class StatsManager {
+  private statsPath: string;
+  private stats: TokenStats;
+  private currentSessionId: string;
+
+  constructor(projectPath: string) {
+    const mcpDir = path.join(path.resolve(projectPath), '.graph-indexer');
+    this.statsPath = path.join(mcpDir, 'stats.json');
+    this.currentSessionId = new Date().toISOString();
+    this.stats = this.loadStats();
+  }
+
+  private loadStats(): TokenStats {
+    if (fs.existsSync(this.statsPath)) {
+      try {
+        const raw = fs.readFileSync(this.statsPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed && parsed.totalCalls !== undefined) {
+          if (!parsed.history) {
+            parsed.history = [];
+          }
+          parsed.efficiencyPercentage = parsed.totalTokensAlternative > 0
+            ? Math.round((parsed.totalTokensSaved / parsed.totalTokensAlternative) * 100)
+            : 0;
+          return parsed;
+        }
+      } catch (err) {
+        console.error('Failed to load stats, resetting...', err);
+      }
+    }
+    return {
+      totalCalls: 0,
+      totalTokensSaved: 0,
+      totalTokensActual: 0,
+      totalTokensAlternative: 0,
+      efficiencyPercentage: 0,
+      callsByType: {
+        search_symbols: { calls: 0, saved: 0, actual: 0, alternative: 0, totalTimeMs: 0 },
+        get_file_skeleton: { calls: 0, saved: 0, actual: 0, alternative: 0, totalTimeMs: 0 },
+        get_dependencies: { calls: 0, saved: 0, actual: 0, alternative: 0, totalTimeMs: 0 },
+        read_symbol_body: { calls: 0, saved: 0, actual: 0, alternative: 0, totalTimeMs: 0 }
+      },
+      history: []
+    };
+  }
+
+  private saveStats() {
+    try {
+      const mcpDir = path.dirname(this.statsPath);
+      if (!fs.existsSync(mcpDir)) {
+        fs.mkdirSync(mcpDir, { recursive: true });
+      }
+      fs.writeFileSync(this.statsPath, JSON.stringify(this.stats, null, 2), 'utf-8');
+    } catch (err) {
+      console.error('Failed to save stats:', err);
+    }
+  }
+
+  /**
+   * Estimates tokens based on character count (1 token approx 4 characters).
+   */
+  public estimateTokens(text: string): number {
+    return Math.ceil(text.length / 4);
+  }
+
+  /**
+   * Records a tool call and computes the token savings.
+   */
+  public recordCall(
+    toolName: string,
+    actualPayload: string,
+    alternativeText: string,
+    target?: string,
+    execTimeMs: number = 0
+  ) {
+    const actualTokens = this.estimateTokens(actualPayload);
+    const alternativeTokens = this.estimateTokens(alternativeText);
+    const savedTokens = Math.max(0, alternativeTokens - actualTokens);
+
+    this.stats.totalCalls += 1;
+    this.stats.totalTokensActual += actualTokens;
+    this.stats.totalTokensAlternative += alternativeTokens;
+    this.stats.totalTokensSaved += savedTokens;
+    
+    // Calculate overall efficiency percentage
+    this.stats.efficiencyPercentage = this.stats.totalTokensAlternative > 0
+      ? Math.round((this.stats.totalTokensSaved / this.stats.totalTokensAlternative) * 100)
+      : 0;
+
+    if (!this.stats.callsByType[toolName]) {
+      this.stats.callsByType[toolName] = { calls: 0, saved: 0, actual: 0, alternative: 0, totalTimeMs: 0 };
+    }
+    
+    const toolStats = this.stats.callsByType[toolName];
+    toolStats.calls += 1;
+    toolStats.saved += savedTokens;
+    toolStats.actual += actualTokens;
+    toolStats.alternative += alternativeTokens;
+    toolStats.totalTimeMs += execTimeMs;
+
+    // Add entry to history
+    this.stats.history.unshift({
+      timestamp: new Date().toISOString(),
+      sessionId: this.currentSessionId,
+      toolName,
+      saved: savedTokens,
+      actual: actualTokens,
+      alternative: alternativeTokens,
+      target,
+      execTimeMs
+    });
+
+    // Cap history to 500 entries to avoid file bloat
+    if (this.stats.history.length > 500) {
+      this.stats.history = this.stats.history.slice(0, 500);
+    }
+
+    this.saveStats();
+  }
+
+  public getStats(): TokenStats {
+    return this.stats;
+  }
+}