@rpcajr/smart-graph-indexer 1.0.0

package/dist/vector.d.ts

@@ -0,0 +1,66 @@
+import { SymbolSkeleton } from './parser.js';
+export interface VectorSymbol {
+    id: string;
+    filePath: string;
+    symbolName: string;
+    kind: string;
+    signature: string;
+    docstring?: string;
+    embedding: number[];
+}
+export declare class VectorStore {
+    private extractor;
+    private symbols;
+    private isInitialized;
+    constructor();
+    /**
+     * Initializes the embedding model.
+     */
+    init(): Promise<void>;
+    /**
+     * Generates embedding vector for a given string.
+     */
+    generateEmbedding(text: string): Promise<number[]>;
+    /**
+     * Helper to format symbol for vectorization following spec template.
+     */
+    formatSymbolForEmbedding(filePath: string, symbol: SymbolSkeleton): string;
+    /**
+     * Adds or updates a symbol in the vector store.
+     */
+    addSymbol(filePath: string, symbol: SymbolSkeleton): Promise<void>;
+    /**
+     * Removes symbols belonging to a specific file.
+     */
+    removeFileSymbols(filePath: string): void;
+    /**
+     * Removes a specific symbol.
+     */
+    removeSymbol(filePath: string, symbolName: string): void;
+    /**
+     * Clears the vector store.
+     */
+    clear(): void;
+    /**
+     * Computes dot product (cosine similarity since embeddings are normalized).
+     */
+    private cosineSimilarity;
+    /**
+     * Performs hybrid search (semantic similarity + exact substring matching).
+     */
+    search(query: string, limit?: number): Promise<Array<{
+        symbol: Omit<VectorSymbol, 'embedding'>;
+        score: number;
+    }>>;
+    /**
+     * Retrieves all loaded symbols.
+     */
+    getAllSymbols(): {
+        id: string;
+        filePath: string;
+        symbolName: string;
+        kind: string;
+        signature: string;
+        docstring: string | undefined;
+    }[];
+}

package/dist/vector.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorStore = void 0;
+const transformers_1 = require("@xenova/transformers");
+class VectorStore {
+    extractor = null;
+    symbols = [];
+    isInitialized = false;
+    constructor() { }
+    /**
+     * Initializes the embedding model.
+     */
+    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 (0, transformers_1.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.
+     */
+    async generateEmbedding(text) {
+        if (!this.isInitialized) {
+            await this.init();
+        }
+        const output = await this.extractor(text, { pooling: 'mean', normalize: true });
+        return Array.from(output.data);
+    }
+    /**
+     * Helper to format symbol for vectorization following spec template.
+     */
+    formatSymbolForEmbedding(filePath, symbol) {
+        return `File: ${filePath} | Symbol: ${symbol.name} (${symbol.kind}) | Signature: ${symbol.signature} | Doc: ${symbol.docstring || ''}`;
+    }
+    /**
+     * Adds or updates a symbol in the vector store.
+     */
+    async addSymbol(filePath, symbol) {
+        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.
+     */
+    removeFileSymbols(filePath) {
+        this.symbols = this.symbols.filter(s => s.filePath !== filePath);
+    }
+    /**
+     * Removes a specific symbol.
+     */
+    removeSymbol(filePath, symbolName) {
+        const id = `${filePath}:${symbolName}`;
+        this.symbols = this.symbols.filter(s => s.id !== id);
+    }
+    /**
+     * Clears the vector store.
+     */
+    clear() {
+        this.symbols = [];
+    }
+    /**
+     * Computes dot product (cosine similarity since embeddings are normalized).
+     */
+    cosineSimilarity(a, b) {
+        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).
+     */
+    async search(query, limit = 5) {
+        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.
+     */
+    getAllSymbols() {
+        return this.symbols.map(s => ({
+            id: s.id,
+            filePath: s.filePath,
+            symbolName: s.symbolName,
+            kind: s.kind,
+            signature: s.signature,
+            docstring: s.docstring,
+        }));
+    }
+}
+exports.VectorStore = VectorStore;

package/dist/watcher.d.ts

@@ -0,0 +1,36 @@
+export interface WatcherOptions {
+    projectPath: string;
+    onChange: (changedFiles: string[]) => void;
+    debounceMs?: number;
+}
+export declare class GitAwareWatcher {
+    private projectPath;
+    private onChange;
+    private debounceMs;
+    private watcher;
+    private ig;
+    private changedQueue;
+    private debounceTimeout;
+    constructor(options: WatcherOptions);
+    /**
+     * Loads and parses .gitignore rules.
+     */
+    private loadGitignore;
+    /**
+     * Helper to check if a relative path is ignored.
+     */
+    isIgnored(relativeFilePath: string): boolean;
+    /**
+     * Runs `git status --porcelain` to get the list of modified/untracked files.
+     */
+    getGitDeltas(): Promise<string[]>;
+    /**
+     * Starts watching the filesystem.
+     */
+    start(): void;
+    /**
+     * Stops the filesystem watcher.
+     */
+    stop(): Promise<void>;
+    private triggerDebounce;
+}

package/dist/watcher.js

@@ -0,0 +1,166 @@
+"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.GitAwareWatcher = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const chokidar_1 = __importDefault(require("chokidar"));
+const ignore_1 = __importDefault(require("ignore"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class GitAwareWatcher {
+    projectPath;
+    onChange;
+    debounceMs;
+    watcher = null;
+    ig;
+    changedQueue = new Set();
+    debounceTimeout = null;
+    constructor(options) {
+        this.projectPath = path.resolve(options.projectPath);
+        this.onChange = options.onChange;
+        this.debounceMs = options.debounceMs ?? 1500;
+        this.ig = (0, ignore_1.default)();
+        this.loadGitignore();
+    }
+    /**
+     * Loads and parses .gitignore rules.
+     */
+    loadGitignore() {
+        const gitignorePath = path.join(this.projectPath, '.gitignore');
+        this.ig = (0, ignore_1.default)();
+        // 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.
+     */
+    isIgnored(relativeFilePath) {
+        // 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.
+     */
+    async getGitDeltas() {
+        try {
+            const { stdout } = await execAsync('git status --porcelain', { cwd: this.projectPath });
+            const deltas = [];
+            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.
+     */
+    start() {
+        this.loadGitignore();
+        this.watcher = chokidar_1.default.watch(this.projectPath, {
+            ignored: (filePath) => {
+                const relativePath = path.relative(this.projectPath, filePath);
+                return this.isIgnored(relativePath);
+            },
+            persistent: true,
+            ignoreInitial: true,
+        });
+        const handleFileChange = (filePath) => {
+            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.
+     */
+    async stop() {
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.debounceTimeout) {
+            clearTimeout(this.debounceTimeout);
+            this.debounceTimeout = null;
+        }
+    }
+    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);
+    }
+}
+exports.GitAwareWatcher = GitAwareWatcher;

package/mcp-config-example.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "smart-graph-indexer": {
+      "command": "graph-indexer",
+      "args": [
+        "start",
+        "--path",
+        "."
+      ]
+    }
+  }
+}