gitnexus 1.0.0

package/dist/cli/mcp.js

@@ -0,0 +1,85 @@
+/**
+ * MCP Command
+ *
+ * Starts the MCP server in standalone mode using local .gitnexus/ index.
+ * Auto-detects repository by searching for .gitnexus/ folder.
+ */
+import path from 'path';
+import fs from 'fs/promises';
+import { startMCPServer } from '../mcp/server.js';
+import { LocalBackend, findRepo } from '../mcp/local/local-backend.js';
+/**
+ * Get candidate paths to search for .gitnexus/ folder
+ */
+function getCandidatePaths() {
+    const candidates = [];
+    // 1. Explicit override (highest priority)
+    if (process.env.GITNEXUS_CWD) {
+        candidates.push(process.env.GITNEXUS_CWD);
+    }
+    // 2. Current working directory
+    candidates.push(process.cwd());
+    // 3. VS Code workspace folders (if available via env)
+    if (process.env.VSCODE_WORKSPACE_FOLDER) {
+        candidates.push(process.env.VSCODE_WORKSPACE_FOLDER);
+    }
+    // Deduplicate while preserving order
+    return [...new Set(candidates.map(p => path.resolve(p)))];
+}
+/**
+ * Find a git repository root by walking up the directory tree
+ */
+async function findGitRoot(startPath) {
+    let current = path.resolve(startPath);
+    const root = path.parse(current).root;
+    while (current !== root) {
+        try {
+            const gitPath = path.join(current, '.git');
+            const stat = await fs.stat(gitPath);
+            if (stat.isDirectory())
+                return current;
+        }
+        catch { }
+        current = path.dirname(current);
+    }
+    return null;
+}
+export const mcpCommand = async () => {
+    // Try multiple candidate paths to find .gitnexus/
+    const candidates = getCandidatePaths();
+    for (const candidate of candidates) {
+        const repo = await findRepo(candidate);
+        if (repo) {
+            const local = new LocalBackend();
+            await local.init(candidate);
+            console.error(`GitNexus: Found index at ${repo.storagePath}`);
+            // Start MCP server (no watcher daemon - staleness hints guide LLM to call analyze)
+            await startMCPServer(local);
+            return;
+        }
+    }
+    // No index found - give helpful error message
+    for (const candidate of candidates) {
+        const gitRoot = await findGitRoot(candidate);
+        if (gitRoot) {
+            console.error('');
+            console.error('╔════════════════════════════════════════════════════╗');
+            console.error('║          GitNexus: Repository Not Indexed          ║');
+            console.error('╠════════════════════════════════════════════════════╣');
+            console.error(`║ Found git repo: ${gitRoot.slice(0, 35).padEnd(35)} ║`);
+            console.error('║                                                    ║');
+            console.error('║ To enable AI code understanding, run:              ║');
+            console.error('║                                                    ║');
+            console.error('║   npx gitnexus analyze                             ║');
+            console.error('║                                                    ║');
+            console.error('║ Then restart your IDE.                             ║');
+            console.error('╚════════════════════════════════════════════════════╝');
+            console.error('');
+            process.exit(1);
+        }
+    }
+    // No git repo found
+    console.error('GitNexus: No git repository found.');
+    console.error(`Searched: ${candidates.join(', ')}`);
+    process.exit(1);
+};

package/dist/cli/serve.d.ts

@@ -0,0 +1,3 @@
+export declare const serveCommand: (options?: {
+    port?: string;
+}) => Promise<void>;

package/dist/cli/serve.js

@@ -0,0 +1,5 @@
+import { createServer } from '../server/api.js';
+export const serveCommand = async (options) => {
+    const port = Number(options?.port ?? 4747);
+    await createServer(port);
+};

package/dist/cli/status.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Status Command
+ *
+ * Shows the indexing status of the current repository.
+ */
+export declare const statusCommand: () => Promise<void>;

package/dist/cli/status.js

@@ -0,0 +1,27 @@
+/**
+ * Status Command
+ *
+ * Shows the indexing status of the current repository.
+ */
+import { findRepo } from '../storage/repo-manager.js';
+import { getCurrentCommit, isGitRepo } from '../storage/git.js';
+export const statusCommand = async () => {
+    const cwd = process.cwd();
+    if (!isGitRepo(cwd)) {
+        console.log('Not a git repository.');
+        return;
+    }
+    const repo = await findRepo(cwd);
+    if (!repo) {
+        console.log('Repository not indexed.');
+        console.log('Run: gitnexus analyze');
+        return;
+    }
+    const currentCommit = getCurrentCommit(repo.repoPath);
+    const isUpToDate = currentCommit === repo.meta.lastCommit;
+    console.log(`Repository: ${repo.repoPath}`);
+    console.log(`Indexed: ${new Date(repo.meta.indexedAt).toLocaleString()}`);
+    console.log(`Indexed commit: ${repo.meta.lastCommit?.slice(0, 7)}`);
+    console.log(`Current commit: ${currentCommit?.slice(0, 7)}`);
+    console.log(`Status: ${isUpToDate ? '✅ up-to-date' : '⚠️ stale (re-run gitnexus analyze)'}`);
+};

package/dist/config/ignore-service.d.ts

@@ -0,0 +1 @@
+export declare const shouldIgnorePath: (filePath: string) => boolean;

package/dist/config/ignore-service.js

@@ -0,0 +1,208 @@
+const DEFAULT_IGNORE_LIST = new Set([
+    // Version Control
+    '.git',
+    '.svn',
+    '.hg',
+    '.bzr',
+    // IDEs & Editors
+    '.idea',
+    '.vscode',
+    '.vs',
+    '.eclipse',
+    '.settings',
+    '.DS_Store',
+    'Thumbs.db',
+    // Dependencies
+    'node_modules',
+    'bower_components',
+    'jspm_packages',
+    'vendor', // PHP/Go
+    // 'packages' removed - commonly used for monorepo source code (lerna, pnpm, yarn workspaces)
+    'venv',
+    '.venv',
+    'env',
+    '.env',
+    '__pycache__',
+    '.pytest_cache',
+    '.mypy_cache',
+    'site-packages',
+    '.tox',
+    'eggs',
+    '.eggs',
+    'lib64',
+    'parts',
+    'sdist',
+    'wheels',
+    // Build Outputs
+    'dist',
+    'build',
+    'out',
+    'output',
+    'bin',
+    'obj',
+    'target', // Java/Rust
+    '.next',
+    '.nuxt',
+    '.output',
+    '.vercel',
+    '.netlify',
+    '.serverless',
+    '_build',
+    'public/build',
+    '.parcel-cache',
+    '.turbo',
+    '.svelte-kit',
+    // Test & Coverage
+    'coverage',
+    '.nyc_output',
+    'htmlcov',
+    '.coverage',
+    '__tests__', // Often just test files
+    '__mocks__',
+    '.jest',
+    // Logs & Temp
+    'logs',
+    'log',
+    'tmp',
+    'temp',
+    'cache',
+    '.cache',
+    '.tmp',
+    '.temp',
+    // Generated/Compiled
+    '.generated',
+    'generated',
+    'auto-generated',
+    '.terraform',
+    '.serverless',
+    // Documentation (optional - might want to keep)
+    // 'docs',
+    // 'documentation',
+    // Misc
+    '.husky',
+    '.github', // GitHub config, not code
+    '.circleci',
+    '.gitlab',
+    'fixtures', // Test fixtures
+    'snapshots', // Jest snapshots
+    '__snapshots__',
+]);
+const IGNORED_EXTENSIONS = new Set([
+    // Images
+    '.png', '.jpg', '.jpeg', '.gif', '.svg', '.ico', '.webp', '.bmp', '.tiff', '.tif',
+    '.psd', '.ai', '.sketch', '.fig', '.xd',
+    // Archives
+    '.zip', '.tar', '.gz', '.rar', '.7z', '.bz2', '.xz', '.tgz',
+    // Binary/Compiled
+    '.exe', '.dll', '.so', '.dylib', '.a', '.lib', '.o', '.obj',
+    '.class', '.jar', '.war', '.ear',
+    '.pyc', '.pyo', '.pyd',
+    '.beam', // Erlang
+    '.wasm', // WebAssembly - important!
+    '.node', // Native Node addons
+    // Documents
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+    '.odt', '.ods', '.odp',
+    // Media
+    '.mp4', '.mp3', '.wav', '.mov', '.avi', '.mkv', '.flv', '.wmv',
+    '.ogg', '.webm', '.flac', '.aac', '.m4a',
+    // Fonts
+    '.woff', '.woff2', '.ttf', '.eot', '.otf',
+    // Databases
+    '.db', '.sqlite', '.sqlite3', '.mdb', '.accdb',
+    // Minified/Bundled files
+    '.min.js', '.min.css', '.bundle.js', '.chunk.js',
+    // Source maps (debug files, not source)
+    '.map',
+    // Lock files (handled separately, but also here)
+    '.lock',
+    // Certificates & Keys (security - don't index!)
+    '.pem', '.key', '.crt', '.cer', '.p12', '.pfx',
+    // Data files (often large/binary)
+    '.csv', '.tsv', '.parquet', '.avro', '.feather',
+    '.npy', '.npz', '.pkl', '.pickle', '.h5', '.hdf5',
+    // Misc binary
+    '.bin', '.dat', '.data', '.raw',
+    '.iso', '.img', '.dmg',
+]);
+// Files to ignore by exact name
+const IGNORED_FILES = new Set([
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'composer.lock',
+    'Gemfile.lock',
+    'poetry.lock',
+    'Cargo.lock',
+    'go.sum',
+    '.gitignore',
+    '.gitattributes',
+    '.npmrc',
+    '.yarnrc',
+    '.editorconfig',
+    '.prettierrc',
+    '.prettierignore',
+    '.eslintignore',
+    '.dockerignore',
+    'Thumbs.db',
+    '.DS_Store',
+    'LICENSE',
+    'LICENSE.md',
+    'LICENSE.txt',
+    'CHANGELOG.md',
+    'CHANGELOG',
+    'CONTRIBUTING.md',
+    'CODE_OF_CONDUCT.md',
+    'SECURITY.md',
+    '.env',
+    '.env.local',
+    '.env.development',
+    '.env.production',
+    '.env.test',
+    '.env.example',
+]);
+export const shouldIgnorePath = (filePath) => {
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const parts = normalizedPath.split('/');
+    const fileName = parts[parts.length - 1];
+    const fileNameLower = fileName.toLowerCase();
+    // Check if any path segment is in ignore list
+    for (const part of parts) {
+        if (DEFAULT_IGNORE_LIST.has(part)) {
+            return true;
+        }
+    }
+    // Check exact filename matches
+    if (IGNORED_FILES.has(fileName) || IGNORED_FILES.has(fileNameLower)) {
+        return true;
+    }
+    // Check extension
+    const lastDotIndex = fileNameLower.lastIndexOf('.');
+    if (lastDotIndex !== -1) {
+        const ext = fileNameLower.substring(lastDotIndex);
+        if (IGNORED_EXTENSIONS.has(ext))
+            return true;
+        // Handle compound extensions like .min.js, .bundle.js
+        const secondLastDot = fileNameLower.lastIndexOf('.', lastDotIndex - 1);
+        if (secondLastDot !== -1) {
+            const compoundExt = fileNameLower.substring(secondLastDot);
+            if (IGNORED_EXTENSIONS.has(compoundExt))
+                return true;
+        }
+    }
+    // Ignore hidden files (starting with .)
+    if (fileName.startsWith('.') && fileName !== '.') {
+        // But allow some important config files
+        const allowedDotFiles = ['.env', '.gitignore']; // Already in IGNORED_FILES, so this is redundant
+        // Actually, let's NOT ignore all dot files - many are important configs
+        // Just rely on the explicit lists above
+    }
+    // Ignore files that look like generated/bundled code
+    if (fileNameLower.includes('.bundle.') ||
+        fileNameLower.includes('.chunk.') ||
+        fileNameLower.includes('.generated.') ||
+        fileNameLower.endsWith('.d.ts')) { // TypeScript declaration files
+        return true;
+    }
+    return false;
+};

package/dist/config/supported-languages.d.ts

@@ -0,0 +1,11 @@
+export declare enum SupportedLanguages {
+    JavaScript = "javascript",
+    TypeScript = "typescript",
+    Python = "python",
+    Java = "java",
+    C = "c",
+    CPlusPlus = "cpp",
+    CSharp = "csharp",
+    Go = "go",
+    Rust = "rust"
+}

package/dist/config/supported-languages.js

@@ -0,0 +1,15 @@
+export var SupportedLanguages;
+(function (SupportedLanguages) {
+    SupportedLanguages["JavaScript"] = "javascript";
+    SupportedLanguages["TypeScript"] = "typescript";
+    SupportedLanguages["Python"] = "python";
+    SupportedLanguages["Java"] = "java";
+    SupportedLanguages["C"] = "c";
+    SupportedLanguages["CPlusPlus"] = "cpp";
+    SupportedLanguages["CSharp"] = "csharp";
+    SupportedLanguages["Go"] = "go";
+    SupportedLanguages["Rust"] = "rust";
+    // PHP = 'php',
+    // Ruby = 'ruby',
+    // Swift = 'swift',
+})(SupportedLanguages || (SupportedLanguages = {}));

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

@@ -0,0 +1,60 @@
+/**
+ * Embedder Module
+ *
+ * Singleton factory for transformers.js embedding pipeline.
+ * Handles model loading, caching, and both single and batch embedding operations.
+ *
+ * Uses snowflake-arctic-embed-xs by default (22M params, 384 dims, ~90MB)
+ */
+import { type FeatureExtractionPipeline } from '@huggingface/transformers';
+import { type EmbeddingConfig, type ModelProgress } from './types.js';
+/**
+ * Progress callback type for model loading
+ */
+export type ModelProgressCallback = (progress: ModelProgress) => void;
+/**
+ * Get the current device being used for inference
+ */
+export declare const getCurrentDevice: () => "webgpu" | "cuda" | "cpu" | "wasm" | null;
+/**
+ * Initialize the embedding model
+ * Uses singleton pattern - only loads once, subsequent calls return cached instance
+ *
+ * @param onProgress - Optional callback for model download progress
+ * @param config - Optional configuration override
+ * @param forceDevice - Force a specific device
+ * @returns Promise resolving to the embedder pipeline
+ */
+export declare const initEmbedder: (onProgress?: ModelProgressCallback, config?: Partial<EmbeddingConfig>, forceDevice?: "webgpu" | "cuda" | "cpu" | "wasm") => Promise<FeatureExtractionPipeline>;
+/**
+ * Check if the embedder is initialized and ready
+ */
+export declare const isEmbedderReady: () => boolean;
+/**
+ * Get the embedder instance (throws if not initialized)
+ */
+export declare const getEmbedder: () => FeatureExtractionPipeline;
+/**
+ * Embed a single text string
+ *
+ * @param text - Text to embed
+ * @returns Float32Array of embedding vector (384 dimensions)
+ */
+export declare const embedText: (text: string) => Promise<Float32Array>;
+/**
+ * Embed multiple texts in a single batch
+ * More efficient than calling embedText multiple times
+ *
+ * @param texts - Array of texts to embed
+ * @returns Array of Float32Array embedding vectors
+ */
+export declare const embedBatch: (texts: string[]) => Promise<Float32Array[]>;
+/**
+ * Convert Float32Array to regular number array (for KuzuDB storage)
+ */
+export declare const embeddingToArray: (embedding: Float32Array) => number[];
+/**
+ * Cleanup the embedder (free memory)
+ * Call this when done with embeddings
+ */
+export declare const disposeEmbedder: () => Promise<void>;

package/dist/core/embeddings/embedder.js

@@ -0,0 +1,205 @@
+/**
+ * Embedder Module
+ *
+ * Singleton factory for transformers.js embedding pipeline.
+ * Handles model loading, caching, and both single and batch embedding operations.
+ *
+ * Uses snowflake-arctic-embed-xs by default (22M params, 384 dims, ~90MB)
+ */
+import { pipeline, env } from '@huggingface/transformers';
+import { DEFAULT_EMBEDDING_CONFIG } from './types.js';
+// Module-level state for singleton pattern
+let embedderInstance = null;
+let isInitializing = false;
+let initPromise = null;
+let currentDevice = null;
+/**
+ * Get the current device being used for inference
+ */
+export const getCurrentDevice = () => currentDevice;
+/**
+ * Initialize the embedding model
+ * Uses singleton pattern - only loads once, subsequent calls return cached instance
+ *
+ * @param onProgress - Optional callback for model download progress
+ * @param config - Optional configuration override
+ * @param forceDevice - Force a specific device
+ * @returns Promise resolving to the embedder pipeline
+ */
+export const initEmbedder = async (onProgress, config = {}, forceDevice) => {
+    // Return existing instance if available
+    if (embedderInstance) {
+        return embedderInstance;
+    }
+    // If already initializing, wait for that promise
+    if (isInitializing && initPromise) {
+        return initPromise;
+    }
+    isInitializing = true;
+    const finalConfig = { ...DEFAULT_EMBEDDING_CONFIG, ...config };
+    // On Windows, use webgpu for GPU acceleration (via DirectX12/DirectML)
+    // CUDA is only available on Linux with onnxruntime-node
+    const isWindows = process.platform === 'win32';
+    const gpuDevice = isWindows ? 'webgpu' : 'cuda';
+    let requestedDevice = forceDevice || (finalConfig.device === 'auto' ? gpuDevice : finalConfig.device);
+    initPromise = (async () => {
+        try {
+            // Configure transformers.js environment
+            env.allowLocalModels = false;
+            const isDev = process.env.NODE_ENV !== 'production';
+            if (isDev) {
+                console.log(`🧠 Loading embedding model: ${finalConfig.modelId}`);
+            }
+            const progressCallback = onProgress ? (data) => {
+                const progress = {
+                    status: data.status || 'progress',
+                    file: data.file,
+                    progress: data.progress,
+                    loaded: data.loaded,
+                    total: data.total,
+                };
+                onProgress(progress);
+            } : undefined;
+            // Try GPU first if auto, fall back to CPU
+            // Windows: webgpu (DirectX12/DirectML), Linux: cuda
+            const devicesToTry = (requestedDevice === 'webgpu' || requestedDevice === 'cuda')
+                ? [requestedDevice, 'cpu']
+                : [requestedDevice];
+            for (const device of devicesToTry) {
+                try {
+                    if (isDev && device === 'webgpu') {
+                        console.log('🔧 Trying WebGPU (DirectX12) backend...');
+                    }
+                    else if (isDev && device === 'cuda') {
+                        console.log('🔧 Trying CUDA GPU backend...');
+                    }
+                    else if (isDev && device === 'cpu') {
+                        console.log('🔧 Using CPU backend...');
+                    }
+                    else if (isDev && device === 'wasm') {
+                        console.log('🔧 Using WASM backend (slower)...');
+                    }
+                    embedderInstance = await pipeline('feature-extraction', finalConfig.modelId, {
+                        device: device,
+                        dtype: 'fp32',
+                        progress_callback: progressCallback,
+                    });
+                    currentDevice = device;
+                    if (isDev) {
+                        const label = device === 'webgpu' ? 'GPU (WebGPU/DirectX12)'
+                            : device === 'cuda' ? 'GPU (CUDA)'
+                                : device.toUpperCase();
+                        console.log(`✅ Using ${label} backend`);
+                        console.log('✅ Embedding model loaded successfully');
+                    }
+                    return embedderInstance;
+                }
+                catch (deviceError) {
+                    if (isDev && (device === 'cuda' || device === 'webgpu')) {
+                        const gpuType = device === 'webgpu' ? 'WebGPU' : 'CUDA';
+                        console.log(`⚠️  ${gpuType} not available, falling back to CPU...`);
+                    }
+                    // Continue to next device in list
+                    if (device === devicesToTry[devicesToTry.length - 1]) {
+                        throw deviceError; // Last device failed, propagate error
+                    }
+                }
+            }
+            throw new Error('No suitable device found for embedding model');
+        }
+        catch (error) {
+            isInitializing = false;
+            initPromise = null;
+            embedderInstance = null;
+            throw error;
+        }
+        finally {
+            isInitializing = false;
+        }
+    })();
+    return initPromise;
+};
+/**
+ * Check if the embedder is initialized and ready
+ */
+export const isEmbedderReady = () => {
+    return embedderInstance !== null;
+};
+/**
+ * Get the embedder instance (throws if not initialized)
+ */
+export const getEmbedder = () => {
+    if (!embedderInstance) {
+        throw new Error('Embedder not initialized. Call initEmbedder() first.');
+    }
+    return embedderInstance;
+};
+/**
+ * Embed a single text string
+ *
+ * @param text - Text to embed
+ * @returns Float32Array of embedding vector (384 dimensions)
+ */
+export const embedText = async (text) => {
+    const embedder = getEmbedder();
+    const result = await embedder(text, {
+        pooling: 'mean',
+        normalize: true,
+    });
+    // Result is a Tensor, convert to Float32Array
+    return new Float32Array(result.data);
+};
+/**
+ * Embed multiple texts in a single batch
+ * More efficient than calling embedText multiple times
+ *
+ * @param texts - Array of texts to embed
+ * @returns Array of Float32Array embedding vectors
+ */
+export const embedBatch = async (texts) => {
+    if (texts.length === 0) {
+        return [];
+    }
+    const embedder = getEmbedder();
+    // Process batch
+    const result = await embedder(texts, {
+        pooling: 'mean',
+        normalize: true,
+    });
+    // Result shape is [batch_size, dimensions]
+    // Need to split into individual vectors
+    const data = result.data;
+    const dimensions = DEFAULT_EMBEDDING_CONFIG.dimensions;
+    const embeddings = [];
+    for (let i = 0; i < texts.length; i++) {
+        const start = i * dimensions;
+        const end = start + dimensions;
+        embeddings.push(new Float32Array(Array.prototype.slice.call(data, start, end)));
+    }
+    return embeddings;
+};
+/**
+ * Convert Float32Array to regular number array (for KuzuDB storage)
+ */
+export const embeddingToArray = (embedding) => {
+    return Array.from(embedding);
+};
+/**
+ * Cleanup the embedder (free memory)
+ * Call this when done with embeddings
+ */
+export const disposeEmbedder = async () => {
+    if (embedderInstance) {
+        // transformers.js pipelines may have a dispose method
+        try {
+            if ('dispose' in embedderInstance && typeof embedderInstance.dispose === 'function') {
+                await embedderInstance.dispose();
+            }
+        }
+        catch {
+            // Ignore disposal errors
+        }
+        embedderInstance = null;
+        initPromise = null;
+    }
+};