gitnexus 1.0.0

package/dist/core/tree-sitter/parser-loader.js

@@ -0,0 +1,42 @@
+import Parser from 'tree-sitter';
+import JavaScript from 'tree-sitter-javascript';
+import TypeScript from 'tree-sitter-typescript';
+import Python from 'tree-sitter-python';
+import Java from 'tree-sitter-java';
+import C from 'tree-sitter-c';
+import CPP from 'tree-sitter-cpp';
+import CSharp from 'tree-sitter-c-sharp';
+import Go from 'tree-sitter-go';
+import Rust from 'tree-sitter-rust';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+let parser = null;
+const languageMap = {
+    [SupportedLanguages.JavaScript]: JavaScript,
+    [SupportedLanguages.TypeScript]: TypeScript.typescript,
+    [`${SupportedLanguages.TypeScript}:tsx`]: TypeScript.tsx,
+    [SupportedLanguages.Python]: Python,
+    [SupportedLanguages.Java]: Java,
+    [SupportedLanguages.C]: C,
+    [SupportedLanguages.CPlusPlus]: CPP,
+    [SupportedLanguages.CSharp]: CSharp,
+    [SupportedLanguages.Go]: Go,
+    [SupportedLanguages.Rust]: Rust,
+};
+export const loadParser = async () => {
+    if (parser)
+        return parser;
+    parser = new Parser();
+    return parser;
+};
+export const loadLanguage = async (language, filePath) => {
+    if (!parser)
+        await loadParser();
+    const key = language === SupportedLanguages.TypeScript && filePath?.endsWith('.tsx')
+        ? `${language}:tsx`
+        : language;
+    const lang = languageMap[key];
+    if (!lang) {
+        throw new Error(`Unsupported language: ${language}`);
+    }
+    parser.setLanguage(lang);
+};

package/dist/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare const generateId: (label: string, name: string) => string;

package/dist/lib/utils.js

@@ -0,0 +1,3 @@
+export const generateId = (label, name) => {
+    return `${label}:${name}`;
+};

package/dist/mcp/core/embedder.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Embedder Module (Read-Only)
+ *
+ * Singleton factory for transformers.js embedding pipeline.
+ * For MCP, we only need to compute query embeddings, not batch embed.
+ */
+import { type FeatureExtractionPipeline } from '@huggingface/transformers';
+/**
+ * Initialize the embedding model (lazy, on first search)
+ */
+export declare const initEmbedder: () => Promise<FeatureExtractionPipeline>;
+/**
+ * Check if embedder is ready
+ */
+export declare const isEmbedderReady: () => boolean;
+/**
+ * Embed a query text for semantic search
+ */
+export declare const embedQuery: (query: string) => Promise<number[]>;
+/**
+ * Get embedding dimensions
+ */
+export declare const getEmbeddingDims: () => number;
+/**
+ * Cleanup embedder
+ */
+export declare const disposeEmbedder: () => Promise<void>;

package/dist/mcp/core/embedder.js

@@ -0,0 +1,93 @@
+/**
+ * Embedder Module (Read-Only)
+ *
+ * Singleton factory for transformers.js embedding pipeline.
+ * For MCP, we only need to compute query embeddings, not batch embed.
+ */
+import { pipeline, env } from '@huggingface/transformers';
+// Model config
+const MODEL_ID = 'Snowflake/snowflake-arctic-embed-xs';
+const EMBEDDING_DIMS = 384;
+// Module-level state for singleton pattern
+let embedderInstance = null;
+let isInitializing = false;
+let initPromise = null;
+/**
+ * Initialize the embedding model (lazy, on first search)
+ */
+export const initEmbedder = async () => {
+    if (embedderInstance) {
+        return embedderInstance;
+    }
+    if (isInitializing && initPromise) {
+        return initPromise;
+    }
+    isInitializing = true;
+    initPromise = (async () => {
+        try {
+            env.allowLocalModels = false;
+            console.error('GitNexus: Loading embedding model (first search may take a moment)...');
+            // Try WebGPU first (Windows DirectX12), fall back to CPU
+            const devicesToTry = ['webgpu', 'cpu'];
+            for (const device of devicesToTry) {
+                try {
+                    embedderInstance = await pipeline('feature-extraction', MODEL_ID, {
+                        device: device,
+                        dtype: 'fp32',
+                    });
+                    console.error(`GitNexus: Embedding model loaded (${device})`);
+                    return embedderInstance;
+                }
+                catch {
+                    if (device === 'cpu')
+                        throw new Error('Failed to load embedding model');
+                }
+            }
+            throw new Error('No suitable device found');
+        }
+        catch (error) {
+            isInitializing = false;
+            initPromise = null;
+            embedderInstance = null;
+            throw error;
+        }
+        finally {
+            isInitializing = false;
+        }
+    })();
+    return initPromise;
+};
+/**
+ * Check if embedder is ready
+ */
+export const isEmbedderReady = () => embedderInstance !== null;
+/**
+ * Embed a query text for semantic search
+ */
+export const embedQuery = async (query) => {
+    const embedder = await initEmbedder();
+    const result = await embedder(query, {
+        pooling: 'mean',
+        normalize: true,
+    });
+    return Array.from(result.data);
+};
+/**
+ * Get embedding dimensions
+ */
+export const getEmbeddingDims = () => EMBEDDING_DIMS;
+/**
+ * Cleanup embedder
+ */
+export const disposeEmbedder = async () => {
+    if (embedderInstance) {
+        try {
+            if ('dispose' in embedderInstance && typeof embedderInstance.dispose === 'function') {
+                await embedderInstance.dispose();
+            }
+        }
+        catch { }
+        embedderInstance = null;
+        initPromise = null;
+    }
+};

package/dist/mcp/core/kuzu-adapter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * KuzuDB Adapter (Persistent Connection)
+ *
+ * Holds a single database connection for the lifetime of the MCP session.
+ * This is safe since the watcher has been removed -- only one process
+ * accesses the database at a time.
+ */
+/**
+ * Initialize with a persistent connection to the database
+ */
+export declare const initKuzu: (path: string) => Promise<void>;
+/**
+ * Execute a query using the persistent connection
+ */
+export declare const executeQuery: (cypher: string) => Promise<any[]>;
+/**
+ * Close the persistent connection
+ */
+export declare const closeKuzu: () => Promise<void>;
+/**
+ * Check if the database connection is active
+ */
+export declare const isKuzuReady: () => boolean;

package/dist/mcp/core/kuzu-adapter.js

@@ -0,0 +1,62 @@
+/**
+ * KuzuDB Adapter (Persistent Connection)
+ *
+ * Holds a single database connection for the lifetime of the MCP session.
+ * This is safe since the watcher has been removed -- only one process
+ * accesses the database at a time.
+ */
+import fs from 'fs/promises';
+import kuzu from 'kuzu';
+let db = null;
+let conn = null;
+/**
+ * Initialize with a persistent connection to the database
+ */
+export const initKuzu = async (path) => {
+    if (conn)
+        return; // Already initialized
+    // Check if database exists
+    try {
+        await fs.stat(path);
+    }
+    catch {
+        throw new Error(`KuzuDB not found at ${path}. Run: gitnexus analyze`);
+    }
+    db = new kuzu.Database(path);
+    conn = new kuzu.Connection(db);
+};
+/**
+ * Execute a query using the persistent connection
+ */
+export const executeQuery = async (cypher) => {
+    if (!conn) {
+        throw new Error('KuzuDB not initialized. Call initKuzu first.');
+    }
+    const queryResult = await conn.query(cypher);
+    const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
+    const rows = await result.getAll();
+    return rows;
+};
+/**
+ * Close the persistent connection
+ */
+export const closeKuzu = async () => {
+    if (conn) {
+        try {
+            await conn.close();
+        }
+        catch { }
+        conn = null;
+    }
+    if (db) {
+        try {
+            await db.close();
+        }
+        catch { }
+        db = null;
+    }
+};
+/**
+ * Check if the database connection is active
+ */
+export const isKuzuReady = () => conn !== null && db !== null;

package/dist/mcp/local/local-backend.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Local Backend
+ *
+ * Provides tool implementations using local .gitnexus/ index.
+ * This enables MCP to work without the browser.
+ */
+export interface RepoMeta {
+    repoPath: string;
+    lastCommit: string;
+    indexedAt: string;
+    stats?: {
+        files?: number;
+        nodes?: number;
+        edges?: number;
+        communities?: number;
+        processes?: number;
+    };
+}
+export interface IndexedRepo {
+    repoPath: string;
+    storagePath: string;
+    kuzuPath: string;
+    metaPath: string;
+    meta: RepoMeta;
+}
+export declare function findRepo(startPath: string): Promise<IndexedRepo | null>;
+export interface CodebaseContext {
+    projectName: string;
+    stats: {
+        fileCount: number;
+        functionCount: number;
+        classCount: number;
+        interfaceCount: number;
+        methodCount: number;
+        communityCount: number;
+        processCount: number;
+    };
+    hotspots: Array<{
+        name: string;
+        type: string;
+        filePath: string;
+        connections: number;
+    }>;
+    folderTree: string;
+}
+export declare class LocalBackend {
+    private repo;
+    private _context;
+    private initialized;
+    init(cwd: string): Promise<boolean>;
+    private ensureInitialized;
+    get context(): CodebaseContext | null;
+    get isReady(): boolean;
+    get repoPath(): string | null;
+    get storagePath(): string | null;
+    get meta(): any;
+    callTool(method: string, params: any): Promise<any>;
+    private search;
+    /**
+     * BM25 keyword search helper - uses KuzuDB FTS for always-fresh results
+     */
+    private bm25Search;
+    /**
+     * Semantic vector search helper
+     */
+    private semanticSearch;
+    private cypher;
+    private overview;
+    private explore;
+    private impact;
+    private analyze;
+    disconnect(): Promise<void>;
+}