@rpcajr/smart-graph-indexer 1.0.0

package/src/vector.ts

@@ -0,0 +1,166 @@
+import { pipeline } from '@xenova/transformers';
+import { SymbolSkeleton } from './parser.js';
+
+export interface VectorSymbol {
+  id: string; // filePath + ":" + symbolName
+  filePath: string;
+  symbolName: string;
+  kind: string;
+  signature: string;
+  docstring?: string;
+  embedding: number[];
+}
+
+export class VectorStore {
+  private extractor: any = null;
+  private symbols: VectorSymbol[] = [];
+  private isInitialized = false;
+
+  constructor() {}
+
+  /**
+   * Initializes the embedding model.
+   */
+  public async init() {
+    if (this.isInitialized) return;
+
+    try {
+      // Disable remote downloading if you want pure local, but first-time execution
+      // needs to fetch the 90MB all-MiniLM-L6-v2 model from Hugging Face Xenova repository.
+      // After the first download, it will be cached locally and run entirely offline.
+      this.extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+      this.isInitialized = true;
+    } catch (err) {
+      console.error('Failed to initialize local embedding engine:', err);
+      throw err;
+    }
+  }
+
+  /**
+   * Generates embedding vector for a given string.
+   */
+  public async generateEmbedding(text: string): Promise<number[]> {
+    if (!this.isInitialized) {
+      await this.init();
+    }
+    const output = await this.extractor(text, { pooling: 'mean', normalize: true });
+    return Array.from(output.data) as number[];
+  }
+
+  /**
+   * Helper to format symbol for vectorization following spec template.
+   */
+  public formatSymbolForEmbedding(filePath: string, symbol: SymbolSkeleton): string {
+    return `File: ${filePath} | Symbol: ${symbol.name} (${symbol.kind}) | Signature: ${symbol.signature} | Doc: ${symbol.docstring || ''}`;
+  }
+
+  /**
+   * Adds or updates a symbol in the vector store.
+   */
+  public async addSymbol(filePath: string, symbol: SymbolSkeleton) {
+    const id = `${filePath}:${symbol.name}`;
+    this.removeSymbol(filePath, symbol.name);
+
+    const textToEmbed = this.formatSymbolForEmbedding(filePath, symbol);
+    try {
+      const embedding = await this.generateEmbedding(textToEmbed);
+      this.symbols.push({
+        id,
+        filePath,
+        symbolName: symbol.name,
+        kind: symbol.kind,
+        signature: symbol.signature,
+        docstring: symbol.docstring,
+        embedding,
+      });
+    } catch (err) {
+      console.error(`Error embedding symbol ${id}:`, err);
+    }
+  }
+
+  /**
+   * Removes symbols belonging to a specific file.
+   */
+  public removeFileSymbols(filePath: string) {
+    this.symbols = this.symbols.filter(s => s.filePath !== filePath);
+  }
+
+  /**
+   * Removes a specific symbol.
+   */
+  public removeSymbol(filePath: string, symbolName: string) {
+    const id = `${filePath}:${symbolName}`;
+    this.symbols = this.symbols.filter(s => s.id !== id);
+  }
+
+  /**
+   * Clears the vector store.
+   */
+  public clear() {
+    this.symbols = [];
+  }
+
+  /**
+   * Computes dot product (cosine similarity since embeddings are normalized).
+   */
+  private cosineSimilarity(a: number[], b: number[]): number {
+    let dotProduct = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+    }
+    return dotProduct;
+  }
+
+  /**
+   * Performs hybrid search (semantic similarity + exact substring matching).
+   */
+  public async search(query: string, limit: number = 5): Promise<Array<{ symbol: Omit<VectorSymbol, 'embedding'>; score: number }>> {
+    if (!query.trim()) return [];
+
+    // 1. Generate query embedding
+    const queryEmbedding = await this.generateEmbedding(query);
+
+    // 2. Compute similarity for all indexed symbols
+    const results = this.symbols.map(s => {
+      let score = this.cosineSimilarity(queryEmbedding, s.embedding);
+
+      // Boost score if query is a substring of the symbol name (lexical matching)
+      const nameLower = s.symbolName.toLowerCase();
+      const queryLower = query.toLowerCase();
+      if (nameLower.includes(queryLower)) {
+        score += 0.25; // boost for direct match
+      }
+
+      return {
+        symbol: {
+          id: s.id,
+          filePath: s.filePath,
+          symbolName: s.symbolName,
+          kind: s.kind,
+          signature: s.signature,
+          docstring: s.docstring,
+        },
+        score,
+      };
+    });
+
+    // 3. Sort by score descending and limit results
+    return results
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit);
+  }
+
+  /**
+   * Retrieves all loaded symbols.
+   */
+  public getAllSymbols() {
+    return this.symbols.map(s => ({
+      id: s.id,
+      filePath: s.filePath,
+      symbolName: s.symbolName,
+      kind: s.kind,
+      signature: s.signature,
+      docstring: s.docstring,
+    }));
+  }
+}

package/src/watcher.ts

@@ -0,0 +1,144 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import chokidar from 'chokidar';
+import ignore from 'ignore';
+
+const execAsync = promisify(exec);
+
+export interface WatcherOptions {
+  projectPath: string;
+  onChange: (changedFiles: string[]) => void;
+  debounceMs?: number;
+}
+
+export class GitAwareWatcher {
+  private projectPath: string;
+  private onChange: (changedFiles: string[]) => void;
+  private debounceMs: number;
+  private watcher: chokidar.FSWatcher | null = null;
+  private ig: ReturnType<typeof ignore>;
+  private changedQueue: Set<string> = new Set();
+  private debounceTimeout: NodeJS.Timeout | null = null;
+
+  constructor(options: WatcherOptions) {
+    this.projectPath = path.resolve(options.projectPath);
+    this.onChange = options.onChange;
+    this.debounceMs = options.debounceMs ?? 1500;
+    this.ig = ignore();
+    this.loadGitignore();
+  }
+
+  /**
+   * Loads and parses .gitignore rules.
+   */
+  private loadGitignore() {
+    const gitignorePath = path.join(this.projectPath, '.gitignore');
+    this.ig = ignore();
+    // Always ignore standard node_modules and .git folders
+    this.ig.add(['node_modules', '.git', 'dist', '.graph-indexer']);
+
+    if (fs.existsSync(gitignorePath)) {
+      try {
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        this.ig.add(content);
+      } catch (err) {
+        console.error('Error reading .gitignore file:', err);
+      }
+    }
+  }
+
+  /**
+   * Helper to check if a relative path is ignored.
+   */
+  public isIgnored(relativeFilePath: string): boolean {
+    // Normalize path separators to forward slashes for the ignore library
+    const normalized = relativeFilePath.replace(/\\/g, '/');
+    if (!normalized || normalized === '.') return true;
+    return this.ig.ignores(normalized);
+  }
+
+  /**
+   * Runs `git status --porcelain` to get the list of modified/untracked files.
+   */
+  public async getGitDeltas(): Promise<string[]> {
+    try {
+      const { stdout } = await execAsync('git status --porcelain', { cwd: this.projectPath });
+      const deltas: string[] = [];
+
+      for (const line of stdout.split('\n')) {
+        if (!line.trim()) continue;
+        // git status --porcelain outputs: XY path/to/file -> path/to/file or XY path/to/file
+        // We capture everything after the first 3 characters
+        const filePath = line.substring(3).trim();
+        const relativePath = path.relative(this.projectPath, path.resolve(this.projectPath, filePath));
+        
+        if (!this.isIgnored(relativePath)) {
+          deltas.push(relativePath);
+        }
+      }
+      return deltas;
+    } catch (err) {
+      // If not a git repo or git not found, return empty array
+      return [];
+    }
+  }
+
+  /**
+   * Starts watching the filesystem.
+   */
+  public start() {
+    this.loadGitignore();
+
+    this.watcher = chokidar.watch(this.projectPath, {
+      ignored: (filePath) => {
+        const relativePath = path.relative(this.projectPath, filePath);
+        return this.isIgnored(relativePath);
+      },
+      persistent: true,
+      ignoreInitial: true,
+    });
+
+    const handleFileChange = (filePath: string) => {
+      const relativePath = path.relative(this.projectPath, filePath);
+      if (this.isIgnored(relativePath)) return;
+
+      this.changedQueue.add(relativePath);
+      this.triggerDebounce();
+    };
+
+    this.watcher
+      .on('add', handleFileChange)
+      .on('change', handleFileChange)
+      .on('unlink', handleFileChange);
+  }
+
+  /**
+   * Stops the filesystem watcher.
+   */
+  public async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.debounceTimeout) {
+      clearTimeout(this.debounceTimeout);
+      this.debounceTimeout = null;
+    }
+  }
+
+  private triggerDebounce() {
+    if (this.debounceTimeout) {
+      clearTimeout(this.debounceTimeout);
+    }
+
+    this.debounceTimeout = setTimeout(() => {
+      const changed = Array.from(this.changedQueue);
+      this.changedQueue.clear();
+      if (changed.length > 0) {
+        this.onChange(changed);
+      }
+    }, this.debounceMs);
+  }
+}

package/test_project/App.java

@@ -0,0 +1,16 @@
+package com.example;
+
+import java.util.List;
+
+/**
+ * Main application class.
+ */
+public class App {
+    
+    /**
+     * Executes the main logic.
+     */
+    public static void main(String[] args) {
+        System.out.println("Hello World");
+    }
+}

package/test_project/BillingService.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+
+namespace Shop.Services
+{
+    /// <summary>
+    /// Servico responsavel pelo faturamento e calculo de taxas.
+    /// </summary>
+    public class BillingService : IBillingService
+    {
+        private readonly ITaxCalculator _taxCalculator;
+
+        public BillingService(ITaxCalculator taxCalculator)
+        {
+            _taxCalculator = taxCalculator;
+        }
+
+        /// <summary>
+        /// Calcula o valor final com taxas baseadas na regiao.
+        /// </summary>
+        public decimal ProcessOrder(Order order, decimal discount)
+        {
+            if (order == null) throw new ArgumentNullException(nameof(order));
+            
+            var baseAmount = order.Total - discount;
+            var tax = _taxCalculator.CalculateVAT(baseAmount, order.Region);
+            
+            return baseAmount + tax;
+        }
+    }
+}

package/test_project/auth.ts

@@ -0,0 +1,18 @@
+import { config } from './config.js';
+import { Database } from './database.js';
+
+export class AuthService {
+    private db: Database;
+
+    constructor(db: Database) {
+        this.db = db;
+    }
+
+    public login(username: string): string {
+        const users = this.db.query(`SELECT * FROM users WHERE name = '${username}'`);
+        if (users.length > 0) {
+            return `token-for-${username}-with-${config.jwtSecret}`;
+        }
+        throw new Error('User not found');
+    }
+}

package/test_project/config.ts

@@ -0,0 +1,11 @@
+export interface AppConfig {
+    dbHost: string;
+    dbPort: number;
+    jwtSecret: string;
+}
+
+export const config: AppConfig = {
+    dbHost: 'localhost',
+    dbPort: 5432,
+    jwtSecret: 'super-secret-key'
+};

package/test_project/database.ts

@@ -0,0 +1,21 @@
+import { config } from './config.js';
+
+export class Database {
+    private isConnected = false;
+
+    constructor() {
+        console.log(`Connecting to database at ${config.dbHost}:${config.dbPort}`);
+    }
+
+    public connect(): boolean {
+        this.isConnected = true;
+        return this.isConnected;
+    }
+
+    public query(sql: string): any[] {
+        if (!this.isConnected) {
+            throw new Error('Database not connected');
+        }
+        return [{ id: 1, query: sql }];
+    }
+}

package/test_project/index.ts

@@ -0,0 +1,13 @@
+import { Database } from './database.js';
+import { AuthService } from './auth.js';
+
+export function main() {
+    const db = new Database();
+    db.connect();
+
+    const auth = new AuthService(db);
+    const token = auth.login('admin');
+    console.log(`Success: logged in with token ${token}`);
+}
+
+main();

package/test_project/main.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+// CalculateDistance computes Euclidean distance
+func CalculateDistance(x1, y1, x2, y2 float64) float64 {
+	return math.Sqrt(math.Pow(x2-x1, 2) + math.Pow(y2-y1, 2))
+}

package/test_project/main.py

@@ -0,0 +1,21 @@
+import math
+from processor import Processor
+from utils import log_info
+
+class DataProcessor:
+    """
+    Class designed to process mathematical datasets.
+    """
+    def __init__(self, precision: int = 2):
+        self.precision = precision
+        self.processor = Processor()
+
+    def calculate_average(self, values: list[float]) -> float:
+        """
+        Computes the arithmetic mean of the provided values.
+        """
+        if not values:
+            return 0.0
+        log_info("Calculating average")
+        processed = self.processor.run(values)
+        return round(sum(processed) / len(processed), self.precision)

package/test_project/processor.py

@@ -0,0 +1,12 @@
+from utils import log_info
+
+class Processor:
+    """
+    Main processor class.
+    """
+    def __init__(self):
+        log_info("Processor initialized")
+
+    def run(self, data: list):
+        log_info(f"Processing data with length: {len(data)}")
+        return [x * 2 for x in data]

package/test_project/utils.py

@@ -0,0 +1,13 @@
+import datetime
+
+def get_timestamp() -> str:
+    """
+    Returns current timestamp.
+    """
+    return datetime.datetime.now().isoformat()
+
+def log_info(message: str):
+    """
+    Logs info message.
+    """
+    print(f"[{get_timestamp()}] INFO: {message}")

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"]
+}