gitnexus 1.4.7 → 1.4.9

package/dist/cli/wiki.js

@@ -12,6 +12,7 @@ import { getGitRoot, isGitRepo } from '../storage/git.js';
 import { getStoragePaths, loadMeta, loadCLIConfig, saveCLIConfig } from '../storage/repo-manager.js';
 import { WikiGenerator } from '../core/wiki/generator.js';
 import { resolveLLMConfig } from '../core/wiki/llm-client.js';
+import { detectCursorCLI } from '../core/wiki/cursor-client.js';
 /**
  * Prompt the user for input via stdin.
  */
@@ -65,6 +66,10 @@ function prompt(question, hide = false) {
     });
 }
 export const wikiCommand = async (inputPath, options) => {
+    // Set verbose mode globally for cursor-client to pick up
+    if (options?.verbose) {
+        process.env.GITNEXUS_VERBOSE = '1';
+    }
     console.log('\n  GitNexus Wiki Generator\n');
     // ── Resolve repo path ───────────────────────────────────────────────
     let repoPath;
@@ -96,94 +101,130 @@ export const wikiCommand = async (inputPath, options) => {
     }
     // ── Resolve LLM config (with interactive fallback) ─────────────────
     // Save any CLI overrides immediately
-    if (options?.apiKey || options?.model || options?.baseUrl) {
+    if (options?.apiKey || options?.model || options?.baseUrl || options?.provider) {
         const existing = await loadCLIConfig();
         const updates = {};
         if (options.apiKey)
             updates.apiKey = options.apiKey;
-        if (options.model)
-            updates.model = options.model;
         if (options.baseUrl)
             updates.baseUrl = options.baseUrl;
+        if (options.provider)
+            updates.provider = options.provider;
+        // Save model to appropriate field based on provider
+        if (options.model) {
+            if (options.provider === 'cursor') {
+                updates.cursorModel = options.model;
+            }
+            else {
+                updates.model = options.model;
+            }
+        }
         await saveCLIConfig({ ...existing, ...updates });
         console.log('  Config saved to ~/.gitnexus/config.json\n');
     }
     const savedConfig = await loadCLIConfig();
-    const hasSavedConfig = !!(savedConfig.apiKey && savedConfig.baseUrl);
-    const hasCLIOverrides = !!(options?.apiKey || options?.model || options?.baseUrl);
+    const hasSavedConfig = !!(savedConfig.provider === 'cursor' || (savedConfig.apiKey && savedConfig.baseUrl));
+    const hasCLIOverrides = !!(options?.apiKey || options?.model || options?.baseUrl || options?.provider);
     let llmConfig = await resolveLLMConfig({
         model: options?.model,
         baseUrl: options?.baseUrl,
         apiKey: options?.apiKey,
+        provider: options?.provider,
     });
     // Run interactive setup if no saved config and no CLI flags provided
     // (even if env vars exist — let user explicitly choose their provider)
     if (!hasSavedConfig && !hasCLIOverrides) {
         if (!process.stdin.isTTY) {
-            if (!llmConfig.apiKey) {
+            // Non-interactive mode — need either API key or Cursor CLI
+            if (!llmConfig.apiKey && llmConfig.provider !== 'cursor') {
                 console.log('  Error: No LLM API key found.');
                 console.log('  Set OPENAI_API_KEY or GITNEXUS_API_KEY environment variable,');
-                console.log('  or pass --api-key <key>.\n');
+                console.log('  or pass --api-key <key>, or use --provider cursor.\n');
                 process.exitCode = 1;
                 return;
             }
-            // Non-interactive with env var — just use it
+            // Non-interactive with env var or cursor — just use it
         }
         else {
             console.log('  No LLM configured. Let\'s set it up.\n');
-            console.log('  Supports OpenAI, OpenRouter, or any OpenAI-compatible API.\n');
+            console.log('  Supports OpenAI, OpenRouter, any OpenAI-compatible API, or Cursor CLI.\n');
+            // Check if Cursor CLI is available
+            const hasCursor = detectCursorCLI();
             // Provider selection
             console.log('  [1] OpenAI (api.openai.com)');
             console.log('  [2] OpenRouter (openrouter.ai)');
-            console.log('  [3] Custom endpoint\n');
-            const choice = await prompt('  Select provider (1/2/3): ');
+            console.log('  [3] Custom endpoint');
+            if (hasCursor) {
+                console.log('  [4] Cursor CLI (local, uses your Cursor subscription)');
+            }
+            console.log('');
+            const maxChoice = hasCursor ? '4' : '3';
+            const choice = await prompt(`  Select provider (1/${maxChoice}): `);
             let baseUrl;
             let defaultModel;
-            if (choice === '2') {
-                baseUrl = 'https://openrouter.ai/api/v1';
-                defaultModel = 'minimax/minimax-m2.5';
-            }
-            else if (choice === '3') {
-                baseUrl = await prompt('  Base URL (e.g. http://localhost:11434/v1): ');
-                if (!baseUrl) {
-                    console.log('\n  No URL provided. Aborting.\n');
-                    process.exitCode = 1;
-                    return;
-                }
-                defaultModel = 'gpt-4o-mini';
+            let provider = 'openai';
+            let key = '';
+            if (choice === '4' && hasCursor) {
+                // Cursor CLI selected - model defaults to 'auto' (Cursor's default)
+                provider = 'cursor';
+                baseUrl = '';
+                const modelInput = await prompt('  Model (leave empty for auto): ');
+                const model = modelInput || '';
+                // Save config for Cursor
+                const cursorConfig = { provider: 'cursor' };
+                if (model)
+                    cursorConfig.cursorModel = model;
+                await saveCLIConfig(cursorConfig);
+                console.log('  Config saved to ~/.gitnexus/config.json\n');
+                llmConfig = { ...llmConfig, provider: 'cursor', model, apiKey: '', baseUrl: '' };
             }
             else {
-                baseUrl = 'https://api.openai.com/v1';
-                defaultModel = 'gpt-4o-mini';
-            }
-            // Model
-            const modelInput = await prompt(`  Model (default: ${defaultModel}): `);
-            const model = modelInput || defaultModel;
-            // API key — pre-fill hint if env var exists
-            const envKey = process.env.GITNEXUS_API_KEY || process.env.OPENAI_API_KEY || '';
-            let key;
-            if (envKey) {
-                const masked = envKey.slice(0, 6) + '...' + envKey.slice(-4);
-                const useEnv = await prompt(`  Use existing env key (${masked})? (Y/n): `);
-                if (!useEnv || useEnv.toLowerCase() === 'y' || useEnv.toLowerCase() === 'yes') {
-                    key = envKey;
+                // OpenAI-compatible provider
+                if (choice === '2') {
+                    baseUrl = 'https://openrouter.ai/api/v1';
+                    defaultModel = 'minimax/minimax-m2.5';
+                }
+                else if (choice === '3') {
+                    baseUrl = await prompt('  Base URL (e.g. http://localhost:11434/v1): ');
+                    if (!baseUrl) {
+                        console.log('\n  No URL provided. Aborting.\n');
+                        process.exitCode = 1;
+                        return;
+                    }
+                    defaultModel = 'gpt-4o-mini';
+                }
+                else {
+                    baseUrl = 'https://api.openai.com/v1';
+                    defaultModel = 'gpt-4o-mini';
+                }
+                // Model
+                const modelInput = await prompt(`  Model (default: ${defaultModel}): `);
+                const model = modelInput || defaultModel;
+                // API key — pre-fill hint if env var exists
+                const envKey = process.env.GITNEXUS_API_KEY || process.env.OPENAI_API_KEY || '';
+                if (envKey) {
+                    const masked = envKey.slice(0, 6) + '...' + envKey.slice(-4);
+                    const useEnv = await prompt(`  Use existing env key (${masked})? (Y/n): `);
+                    if (!useEnv || useEnv.toLowerCase() === 'y' || useEnv.toLowerCase() === 'yes') {
+                        key = envKey;
+                    }
+                    else {
+                        key = await prompt('  API key: ', true);
+                    }
                 }
                 else {
                     key = await prompt('  API key: ', true);
                 }
+                if (!key) {
+                    console.log('\n  No key provided. Aborting.\n');
+                    process.exitCode = 1;
+                    return;
+                }
+                // Save
+                await saveCLIConfig({ apiKey: key, baseUrl, model, provider: 'openai' });
+                console.log('  Config saved to ~/.gitnexus/config.json\n');
+                llmConfig = { ...llmConfig, apiKey: key, baseUrl, model, provider: 'openai' };
             }
-            else {
-                key = await prompt('  API key: ', true);
-            }
-            if (!key) {
-                console.log('\n  No key provided. Aborting.\n');
-                process.exitCode = 1;
-                return;
-            }
-            // Save
-            await saveCLIConfig({ apiKey: key, baseUrl, model });
-            console.log('  Config saved to ~/.gitnexus/config.json\n');
-            llmConfig = { ...llmConfig, apiKey: key, baseUrl, model };
         }
     }
     // ── Setup progress bar with elapsed timer ──────────────────────────
@@ -213,9 +254,8 @@ export const wikiCommand = async (inputPath, options) => {
     // ── Run generator ───────────────────────────────────────────────────
     const wikiOptions = {
         force: options?.force,
-        model: options?.model,
-        baseUrl: options?.baseUrl,
         concurrency: options?.concurrency ? parseInt(options.concurrency, 10) : undefined,
+        reviewOnly: options?.review,
     };
     const generator = new WikiGenerator(repoPath, storagePath, lbugPath, llmConfig, wikiOptions, (phase, percent, detail) => {
         const label = detail || phase;
@@ -228,11 +268,92 @@ export const wikiCommand = async (inputPath, options) => {
     try {
         const result = await generator.run();
         clearInterval(elapsedTimer);
-        bar.update(100, { phase: 'Done' });
         bar.stop();
         const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
         const wikiDir = path.join(storagePath, 'wiki');
         const viewerPath = path.join(wikiDir, 'index.html');
+        const treeFile = path.join(wikiDir, 'module_tree.json');
+        // Review mode: show module tree and ask for confirmation
+        if (options?.review && result.moduleTree) {
+            console.log(`\n  Module structure ready for review (${elapsed}s)\n`);
+            console.log('  Modules to generate:\n');
+            const printTree = (nodes, indent = 0) => {
+                for (const node of nodes) {
+                    const prefix = '  '.repeat(indent + 2);
+                    const fileCount = node.files?.length || 0;
+                    const childCount = node.children?.length || 0;
+                    const suffix = fileCount > 0 ? ` (${fileCount} files)` : childCount > 0 ? ` (${childCount} children)` : '';
+                    console.log(`${prefix}- ${node.name}${suffix}`);
+                    if (node.children && node.children.length > 0) {
+                        printTree(node.children, indent + 1);
+                    }
+                }
+            };
+            printTree(result.moduleTree);
+            console.log(`\n  Tree saved to: ${treeFile}`);
+            console.log('  You can edit this file to remove/rename modules.\n');
+            // Ask for confirmation (auto-continue in non-interactive environments)
+            if (!process.stdin.isTTY) {
+                console.log('  Non-interactive mode — auto-continuing with generation.\n');
+            }
+            const answer = process.stdin.isTTY
+                ? await prompt('  Continue with generation? (Y/n/edit): ')
+                : 'y';
+            const choice = answer.trim().toLowerCase();
+            if (choice === 'n' || choice === 'no') {
+                console.log('\n  Generation cancelled. Run `gitnexus wiki` later to generate.\n');
+                return;
+            }
+            if (choice === 'edit' || choice === 'e') {
+                // Open editor for the user
+                const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+                console.log(`\n  Opening ${treeFile} in ${editor}...`);
+                console.log('  Save and close the editor when done.\n');
+                try {
+                    execSync(`${editor} "${treeFile}"`, { stdio: 'inherit' });
+                }
+                catch {
+                    console.log(`  Could not open editor. Please edit manually:\n  ${treeFile}\n`);
+                    console.log('  Then run `gitnexus wiki` to continue.\n');
+                    return;
+                }
+            }
+            // Continue with generation using the (possibly edited) tree
+            console.log('\n  Continuing with wiki generation...\n');
+            bar.start(100, 30, { phase: 'Generating pages...' });
+            // Re-run generator without reviewOnly flag
+            const continueOptions = {
+                ...wikiOptions,
+                reviewOnly: false,
+            };
+            const continueGenerator = new WikiGenerator(repoPath, storagePath, lbugPath, llmConfig, continueOptions, (phase, percent, detail) => {
+                const label = detail || phase;
+                if (label !== lastPhase) {
+                    lastPhase = label;
+                    phaseStart = Date.now();
+                }
+                bar.update(percent, { phase: label });
+            });
+            const continueResult = await continueGenerator.run();
+            bar.update(100, { phase: 'Done' });
+            bar.stop();
+            const totalElapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            console.log(`\n  Wiki generated successfully (${totalElapsed}s)\n`);
+            console.log(`  Mode: ${continueResult.mode}`);
+            console.log(`  Pages: ${continueResult.pagesGenerated}`);
+            console.log(`  Output: ${wikiDir}`);
+            console.log(`  Viewer: ${viewerPath}`);
+            if (continueResult.failedModules && continueResult.failedModules.length > 0) {
+                console.log(`\n  Failed modules (${continueResult.failedModules.length}):`);
+                for (const mod of continueResult.failedModules) {
+                    console.log(`    - ${mod}`);
+                }
+            }
+            console.log('');
+            await maybePublishGist(viewerPath, options?.gist);
+            return;
+        }
+        bar.update(100, { phase: 'Done' });
         if (result.mode === 'up-to-date' && !options?.force) {
             console.log('\n  Wiki is already up to date.');
             console.log(`  Viewer: ${viewerPath}\n`);
@@ -280,7 +401,7 @@ export const wikiCommand = async (inputPath, options) => {
         }
         else {
             console.log(`\n  Error: ${err.message}\n`);
-            if (process.env.DEBUG) {
+            if (process.env.GITNEXUS_VERBOSE) {
                 console.error(err);
             }
         }

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

@@ -1,3 +1,32 @@
+/**
+ * HOW TO ADD A NEW LANGUAGE:
+ *
+ * 1. Add the enum member below (e.g., Scala = 'scala')
+ * 2. Run `tsc --noEmit` — compiler errors guide you to every dispatch table
+ * 3. Use this checklist for each file:
+ *
+ *    FILE                              | WHAT TO ADD                              | DEFAULT (simple languages)
+ *    ----------------------------------|------------------------------------------|---------------------------
+ *    tree-sitter-queries.ts            | Query string + LANGUAGE_QUERIES entry    | (required)
+ *    export-detection.ts               | ExportChecker function + table entry     | (required)
+ *    import-resolvers/<lang>.ts        | Exported resolve<Lang>Import function    | resolveStandard(...)
+ *    call-routing.ts                   | CallRouter function (or noRouting)       | noRouting
+ *    entry-point-scoring.ts            | ENTRY_POINT_PATTERNS entry               | []
+ *    framework-detection.ts            | AST_FRAMEWORK_PATTERNS entry             | []
+ *    type-extractors/<lang>.ts         | New file + index.ts import               | (required)
+ *    resolvers/<lang>.ts               | Resolver file (if non-standard)          | (only if resolveStandard insufficient)
+ *    named-bindings/<lang>.ts          | Extractor (if named imports)             | (only if language has named imports)
+ *
+ * 4. Also check these files for language-specific if-checks (no compile-time guard):
+ *    - mro-processor.ts (MRO strategy selection)
+ *    - heritage-processor.ts (extends/implements handling)
+ *    - parse-worker.ts (AST edge cases)
+ *    - parsing-processor.ts (node label normalization)
+ *
+ * 5. Add tree-sitter-<lang> to package.json dependencies
+ * 6. Add file extension mapping in utils.ts getLanguageFromFilename()
+ * 7. Run full test suite
+ */
 export declare enum SupportedLanguages {
     JavaScript = "javascript",
     TypeScript = "typescript",
@@ -11,5 +40,8 @@ export declare enum SupportedLanguages {
     Rust = "rust",
     PHP = "php",
     Kotlin = "kotlin",
-    Swift = "swift"
+    Swift = "swift",
+    Dart = "dart",
+    /** Standalone regex processor — no tree-sitter, no LanguageProvider. */
+    Cobol = "cobol"
 }

package/dist/config/supported-languages.js

@@ -1,3 +1,32 @@
+/**
+ * HOW TO ADD A NEW LANGUAGE:
+ *
+ * 1. Add the enum member below (e.g., Scala = 'scala')
+ * 2. Run `tsc --noEmit` — compiler errors guide you to every dispatch table
+ * 3. Use this checklist for each file:
+ *
+ *    FILE                              | WHAT TO ADD                              | DEFAULT (simple languages)
+ *    ----------------------------------|------------------------------------------|---------------------------
+ *    tree-sitter-queries.ts            | Query string + LANGUAGE_QUERIES entry    | (required)
+ *    export-detection.ts               | ExportChecker function + table entry     | (required)
+ *    import-resolvers/<lang>.ts        | Exported resolve<Lang>Import function    | resolveStandard(...)
+ *    call-routing.ts                   | CallRouter function (or noRouting)       | noRouting
+ *    entry-point-scoring.ts            | ENTRY_POINT_PATTERNS entry               | []
+ *    framework-detection.ts            | AST_FRAMEWORK_PATTERNS entry             | []
+ *    type-extractors/<lang>.ts         | New file + index.ts import               | (required)
+ *    resolvers/<lang>.ts               | Resolver file (if non-standard)          | (only if resolveStandard insufficient)
+ *    named-bindings/<lang>.ts          | Extractor (if named imports)             | (only if language has named imports)
+ *
+ * 4. Also check these files for language-specific if-checks (no compile-time guard):
+ *    - mro-processor.ts (MRO strategy selection)
+ *    - heritage-processor.ts (extends/implements handling)
+ *    - parse-worker.ts (AST edge cases)
+ *    - parsing-processor.ts (node label normalization)
+ *
+ * 5. Add tree-sitter-<lang> to package.json dependencies
+ * 6. Add file extension mapping in utils.ts getLanguageFromFilename()
+ * 7. Run full test suite
+ */
 export var SupportedLanguages;
 (function (SupportedLanguages) {
     SupportedLanguages["JavaScript"] = "javascript";
@@ -13,4 +42,7 @@ export var SupportedLanguages;
     SupportedLanguages["PHP"] = "php";
     SupportedLanguages["Kotlin"] = "kotlin";
     SupportedLanguages["Swift"] = "swift";
+    SupportedLanguages["Dart"] = "dart";
+    /** Standalone regex processor — no tree-sitter, no LanguageProvider. */
+    SupportedLanguages["Cobol"] = "cobol";
 })(SupportedLanguages || (SupportedLanguages = {}));

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

@@ -30,6 +30,11 @@ export declare const initEmbedder: (onProgress?: ModelProgressCallback, config?:
  * Check if the embedder is initialized and ready
  */
 export declare const isEmbedderReady: () => boolean;
+/**
+ * Get the effective embedding dimensions.
+ * In HTTP mode, uses GITNEXUS_EMBEDDING_DIMS if set, otherwise the default.
+ */
+export declare const getEmbeddingDimensions: () => number;
 /**
  * Get the embedder instance (throws if not initialized)
  */
@@ -38,7 +43,7 @@ export declare const getEmbedder: () => FeatureExtractionPipeline;
  * Embed a single text string
  *
  * @param text - Text to embed
- * @returns Float32Array of embedding vector (384 dimensions)
+ * @returns Float32Array of embedding vector
  */
 export declare const embedText: (text: string) => Promise<Float32Array>;
 /**

package/dist/core/embeddings/embedder.js

@@ -15,17 +15,53 @@ if (!process.env.ORT_LOG_LEVEL) {
 import { pipeline, env } from '@huggingface/transformers';
 import { existsSync } from 'fs';
 import { execFileSync } from 'child_process';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { createRequire } from 'module';
 import { DEFAULT_EMBEDDING_CONFIG } from './types.js';
+import { isHttpMode, getHttpDimensions, httpEmbed } from './http-client.js';
+/**
+ * Check whether the onnxruntime-node package that @huggingface/transformers
+ * will actually load at runtime ships the CUDA execution provider.
+ *
+ * Critical: we resolve from transformers' own module scope, NOT from ours.
+ * npm may install two copies — a top-level 1.24.x (our dep) and a nested
+ * 1.21.0 (transformers' pinned dep). The guard must inspect whichever copy
+ * transformers.js will dlopen, otherwise the check is meaningless.
+ */
+function hasOrtCudaProvider() {
+    try {
+        const require = createRequire(import.meta.url);
+        // Resolve from @huggingface/transformers' scope so we find the same
+        // onnxruntime-node binary that transformers.js will use at runtime
+        const transformersDir = dirname(require.resolve('@huggingface/transformers/package.json'));
+        const ortRequire = createRequire(join(transformersDir, 'package.json'));
+        const ortPath = dirname(ortRequire.resolve('onnxruntime-node/package.json'));
+        // ORT 1.24.x only ships CUDA binaries for linux/x64 (downloaded from NuGet
+        // at postinstall). arm64 will correctly return false here until ORT adds support.
+        const arch = process.arch;
+        return existsSync(join(ortPath, 'bin', 'napi-v6', 'linux', arch, 'libonnxruntime_providers_cuda.so'));
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Check whether CUDA libraries are actually available on this system.
  * ONNX Runtime's native layer crashes (uncatchable) if we attempt CUDA
  * without the required shared libraries, so we probe first.
  *
- * Checks the dynamic linker cache (ldconfig) which covers all architectures
- * and install paths, then falls back to CUDA_PATH / LD_LIBRARY_PATH env vars.
+ * Checks both:
+ * 1. That system CUDA libraries (libcublasLt) are present
+ * 2. That onnxruntime-node ships the CUDA execution provider binary
+ *
+ * Both conditions must be true — system CUDA libs alone are not enough
+ * if onnxruntime-node is a CPU-only build (versions < 1.24.0).
  */
 function isCudaAvailable() {
+    // First, verify onnxruntime-node has the CUDA provider binary.
+    // Without this, requesting CUDA causes an uncatchable native crash.
+    if (!hasOrtCudaProvider())
+        return false;
     // Primary: query the dynamic linker cache — covers all architectures,
     // distro layouts, and custom install paths registered with ldconfig
     try {
@@ -70,6 +106,10 @@ export const getCurrentDevice = () => currentDevice;
  * @returns Promise resolving to the embedder pipeline
  */
 export const initEmbedder = async (onProgress, config = {}, forceDevice) => {
+    if (isHttpMode()) {
+        throw new Error('initEmbedder() should not be called in HTTP mode. ' +
+            'Use embedText()/embedBatch() which handle HTTP transparently.');
+    }
     // Return existing instance if available
     if (embedderInstance) {
         return embedderInstance;
@@ -169,12 +209,25 @@ export const initEmbedder = async (onProgress, config = {}, forceDevice) => {
  * Check if the embedder is initialized and ready
  */
 export const isEmbedderReady = () => {
-    return embedderInstance !== null;
+    return isHttpMode() || embedderInstance !== null;
+};
+/**
+ * Get the effective embedding dimensions.
+ * In HTTP mode, uses GITNEXUS_EMBEDDING_DIMS if set, otherwise the default.
+ */
+export const getEmbeddingDimensions = () => {
+    if (isHttpMode()) {
+        return getHttpDimensions() ?? DEFAULT_EMBEDDING_CONFIG.dimensions;
+    }
+    return DEFAULT_EMBEDDING_CONFIG.dimensions;
 };
 /**
  * Get the embedder instance (throws if not initialized)
  */
 export const getEmbedder = () => {
+    if (isHttpMode()) {
+        throw new Error('getEmbedder() is not available in HTTP embedding mode. Use embedText()/embedBatch() instead.');
+    }
     if (!embedderInstance) {
         throw new Error('Embedder not initialized. Call initEmbedder() first.');
     }
@@ -184,9 +237,13 @@ export const getEmbedder = () => {
  * Embed a single text string
  *
  * @param text - Text to embed
- * @returns Float32Array of embedding vector (384 dimensions)
+ * @returns Float32Array of embedding vector
  */
 export const embedText = async (text) => {
+    if (isHttpMode()) {
+        const [vec] = await httpEmbed([text]);
+        return vec;
+    }
     const embedder = getEmbedder();
     const result = await embedder(text, {
         pooling: 'mean',
@@ -206,6 +263,9 @@ export const embedBatch = async (texts) => {
     if (texts.length === 0) {
         return [];
     }
+    if (isHttpMode()) {
+        return httpEmbed(texts);
+    }
     const embedder = getEmbedder();
     // Process batch
     const result = await embedder(texts, {

package/dist/core/embeddings/embedding-pipeline.js

@@ -121,14 +121,16 @@ export const runEmbeddingPipeline = async (executeQuery, executeWithReusedStatem
             percent: 0,
             modelDownloadPercent: 0,
         });
-        await initEmbedder((modelProgress) => {
-            const downloadPercent = modelProgress.progress ?? 0;
-            onProgress({
-                phase: 'loading-model',
-                percent: Math.round(downloadPercent * 0.2),
-                modelDownloadPercent: downloadPercent,
-            });
-        }, finalConfig);
+        if (!isEmbedderReady()) {
+            await initEmbedder((modelProgress) => {
+                const downloadPercent = modelProgress.progress ?? 0;
+                onProgress({
+                    phase: 'loading-model',
+                    percent: Math.round(downloadPercent * 0.2),
+                    modelDownloadPercent: downloadPercent,
+                });
+            }, finalConfig);
+        }
         onProgress({
             phase: 'loading-model',
             percent: 20,
@@ -255,7 +257,7 @@ export const semanticSearch = async (executeQuery, query, k = 10, maxDistance =
     // Query the vector index on CodeEmbedding to get nodeIds and distances
     const vectorQuery = `
     CALL QUERY_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 
-      CAST(${queryVecStr} AS FLOAT[384]), ${k})
+      CAST(${queryVecStr} AS FLOAT[${queryVec.length}]), ${k})
     YIELD node AS emb, distance
     WITH emb, distance
     WHERE distance < ${maxDistance}

package/dist/core/embeddings/http-client.d.ts

@@ -0,0 +1,31 @@
+/**
+ * HTTP Embedding Client
+ *
+ * Shared fetch+retry logic for OpenAI-compatible /v1/embeddings endpoints.
+ * Imported by both the core embedder (batch) and MCP embedder (query).
+ */
+/**
+ * Check whether HTTP embedding mode is active (env vars are set).
+ */
+export declare const isHttpMode: () => boolean;
+/**
+ * Return the configured embedding dimensions for HTTP mode, or undefined
+ * if HTTP mode is not active or no explicit dimensions are set.
+ */
+export declare const getHttpDimensions: () => number | undefined;
+/**
+ * Embed texts via the HTTP backend, splitting into batches.
+ * Reads config from env vars on every call.
+ *
+ * @param texts - Array of texts to embed
+ * @returns Array of Float32Array embedding vectors
+ */
+export declare const httpEmbed: (texts: string[]) => Promise<Float32Array[]>;
+/**
+ * Embed a single query text via the HTTP backend.
+ * Convenience for MCP search where only one vector is needed.
+ *
+ * @param text - Query text to embed
+ * @returns Embedding vector as number array
+ */
+export declare const httpEmbedQuery: (text: string) => Promise<number[]>;