codesearch-mcp 0.0.18-alpha → 0.1.0-alpha

package/dist/src/setup.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.dockerPromptDefault = dockerPromptDefault;
 exports.runSetup = runSetup;
 const readline = __importStar(require("readline"));
 const fs = __importStar(require("fs"));
@@ -42,12 +43,16 @@ const child_process_1 = require("child_process");
 const constants_1 = require("./constants");
 const config_store_1 = require("./config-store");
 const config_1 = require("./config");
+const InfinityEmbedder_1 = require("./services/InfinityEmbedder");
 const DEFAULT_LOG_DIR = path.join(config_store_1.CONFIG_DIR, 'logs');
 const _projectRoot = fs.existsSync(path.join(__dirname, '..', 'package.json'))
     ? path.join(__dirname, '..')
     : path.join(__dirname, '..', '..');
 const DOCKER_COMPOSE_SRC = path.join(_projectRoot, 'docker', 'docker-compose.yml');
 const DOCKER_COMPOSE_DST = path.join(config_store_1.CONFIG_DIR, 'docker-compose.yml');
+const DOCKER_GPU_OVERRIDE_SRC = path.join(_projectRoot, 'docker', 'docker-compose.infinity-gpu.yml');
+const DOCKER_GPU_OVERRIDE_DST = path.join(config_store_1.CONFIG_DIR, 'docker-compose.infinity-gpu.yml');
+const DEFAULT_INFINITY_RERANK_MODEL = 'Alibaba-NLP/gte-reranker-modernbert-base';
 function ask(rl, question) {
     return new Promise(resolve => rl.question(question, resolve));
 }
@@ -60,6 +65,79 @@ function expandHome(p) {
         return path.join(os.homedir(), p.slice(2));
     return p;
 }
+const PROVIDER_DEFAULTS = {
+    'ollama': { baseURL: 'http://localhost:11434', model: constants_1.DEFAULT_EMBED_MODEL, envVar: '' },
+    'openai-compatible': { baseURL: 'https://api.openai.com/v1', model: 'text-embedding-3-small', envVar: 'OPENAI_API_KEY' },
+    'voyage': { baseURL: 'https://api.voyageai.com/v1', model: 'voyage-code-3', envVar: 'VOYAGE_API_KEY' },
+    'infinity': { baseURL: 'http://localhost:7997', model: 'jinaai/jina-embeddings-v2-base-code', envVar: '' },
+};
+/** Providers that run a local inference backend we can probe / provision. */
+function isLocalBackend(p) {
+    return p === 'ollama' || p === 'infinity';
+}
+/**
+ * Probe whether the embedding backend is already reachable, so the "start
+ * Docker?" prompt can default to no (mirrors the DB `checkRemoteDb` flow).
+ * Cloud providers have no local backend → always "reachable" (nothing to start).
+ */
+async function checkEmbeddingBackend(provider, baseURL) {
+    if (!isLocalBackend(provider))
+        return true;
+    if (provider === 'infinity')
+        return (0, InfinityEmbedder_1.probeInfinityHealth)(baseURL);
+    // ollama — probe /api/tags
+    try {
+        const http = await Promise.resolve().then(() => __importStar(require('http')));
+        await new Promise((resolve, reject) => {
+            const req = http.get(`${baseURL.replace(/\/+$/, '')}/api/tags`, res => {
+                res.resume();
+                res.statusCode === 200 ? resolve() : reject(new Error(`status ${res.statusCode}`));
+            });
+            req.on('error', reject);
+            req.setTimeout(2000, () => { req.destroy(); reject(new Error('timeout')); });
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Default answer for the "start Docker containers?" prompt: no only when both
+ * the database and the embedding backend are already reachable. Pure — exported
+ * for unit testing.
+ */
+function dockerPromptDefault(dbReachable, embReachable) {
+    return (dbReachable && embReachable) ? 'n' : 'y';
+}
+/** True when an NVIDIA GPU + `nvidia-smi` is available on this host. */
+function hasNvidiaGpu() {
+    try {
+        return (0, child_process_1.spawnSync)('nvidia-smi', ['-L'], { stdio: 'ignore' }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Write (or replace) a single `KEY=VALUE` line in `~/.config/codesearch-mcp/.env`,
+ * chmod 600. API keys live here — never in config.json — referenced as `env:KEY`.
+ */
+function writeEnvKey(name, value) {
+    fs.mkdirSync(config_store_1.CONFIG_DIR, { recursive: true });
+    let existing = '';
+    try {
+        existing = fs.readFileSync(config_store_1.ENV_FILE, 'utf-8');
+    }
+    catch { /* absent */ }
+    const kept = existing.split(/\r?\n/).filter(l => l.trim() && !l.trim().startsWith(`${name}=`));
+    kept.push(`${name}=${value}`);
+    fs.writeFileSync(config_store_1.ENV_FILE, kept.join('\n') + '\n', { mode: 0o600 });
+    try {
+        fs.chmodSync(config_store_1.ENV_FILE, 0o600);
+    }
+    catch { /* best effort */ }
+}
 async function waitForDb(host, port, user, pass, db, maxWaitSec = 60, logger, steps) {
     const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
     const deadline = Date.now() + maxWaitSec * 1000;
@@ -109,6 +187,31 @@ async function waitForOllama(host, maxWaitSec = 60, logger, steps) {
     logger?.error('waitForOllama: timeout', { reason, steps: JSON.stringify(steps) });
     process.exit(1);
 }
+/**
+ * Poll Infinity's `/health` until ready. Unlike the DB/Ollama waiters this is
+ * NON-fatal: on CPU the first boot downloads the model set AND runs a lengthy
+ * per-model warmup (a reranker warmup batch alone can take minutes), so a
+ * timeout here does not mean failure — the container is usually just still
+ * warming up. Returns whether it became ready; the caller keeps going and
+ * writes the (valid) config either way. Generous default (30 min) for CPU.
+ */
+async function waitForInfinity(baseURL, maxWaitSec = 1800, logger, steps) {
+    const deadline = Date.now() + maxWaitSec * 1000;
+    process.stdout.write('Waiting for Infinity to be ready (first boot downloads + warms up the model set, this can take several minutes on CPU)');
+    while (Date.now() < deadline) {
+        if (await (0, InfinityEmbedder_1.probeInfinityHealth)(baseURL)) {
+            console.log(' ready.');
+            return true;
+        }
+        process.stdout.write('.');
+        await new Promise(r => setTimeout(r, 3000));
+    }
+    const reason = 'Infinity did not answer /health in time — it is likely still warming up.';
+    console.warn(`\n${reason}`);
+    console.warn(`  The container is running; check "docker logs codesearch-mcp-infinity-1" and, once /health responds, run: rag-index`);
+    logger?.warn('waitForInfinity: timeout (non-fatal)', { reason, steps: JSON.stringify(steps) });
+    return false;
+}
 async function checkRemoteDb(host, port, user, pass, db, logger, steps) {
     try {
         const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
@@ -124,7 +227,8 @@ async function checkRemoteDb(host, port, user, pass, db, logger, steps) {
         return false;
     }
 }
-async function startDockerContainers(ollamaHost, dbPort, dbUser, dbPass, logger, steps) {
+async function startDockerContainers(opts) {
+    const { provider, ollamaHost, embBaseURL, dbPort, dbUser, dbPass, embModel, rerankModel, startDb, startBackend, logger, steps } = opts;
     console.log('\nWriting docker-compose.yml to', DOCKER_COMPOSE_DST);
     const yamlQuote = (s) => `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
     let composeContent = fs.readFileSync(DOCKER_COMPOSE_SRC, 'utf-8');
@@ -134,33 +238,77 @@ async function startDockerContainers(ollamaHost, dbPort, dbUser, dbPass, logger,
         .replace('"5433:5432"', `"${dbPort}:5432"`);
     fs.mkdirSync(config_store_1.CONFIG_DIR, { recursive: true });
     fs.writeFileSync(DOCKER_COMPOSE_DST, composeContent, 'utf-8');
-    console.log('\nStarting Docker containers...');
-    const upResult = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'up', '-d'], { stdio: 'inherit' });
-    if (upResult.status !== 0) {
-        const reason = 'Failed to start Docker containers. Make sure Docker is running.';
+    // The GPU override is copied verbatim so the managed Infinity path can layer it.
+    try {
+        fs.copyFileSync(DOCKER_GPU_OVERRIDE_SRC, DOCKER_GPU_OVERRIDE_DST);
+    }
+    catch { /* absent → CPU only */ }
+    const dockerFail = (reason) => {
         console.error(reason);
         logger?.error('startDockerContainers: docker startup failed', { reason, steps: JSON.stringify(steps) });
         process.exit(1);
+    };
+    // --- Database ---
+    if (startDb) {
+        console.log('\nStarting the database container...');
+        const r = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'up', '-d', 'db'], { stdio: 'inherit' });
+        if (r.status !== 0)
+            dockerFail('Failed to start the database container. Make sure Docker is running.');
+        await waitForDb('localhost', parseInt(dbPort), dbUser, dbPass, 'postgres', 60, logger, steps);
     }
-    await waitForDb('localhost', parseInt(dbPort), dbUser, dbPass, 'postgres', 60, logger, steps);
-    await waitForOllama(ollamaHost, 60, logger, steps);
-    const ollamaId = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'ps', '-q', 'ollama'], { encoding: 'utf-8' })
-        .stdout?.trim();
-    if (!ollamaId) {
-        const reason = 'Could not resolve ollama container ID from compose. Pull the model manually:';
-        console.error(reason);
-        console.error(`  docker exec <ollama-container> ollama pull ${constants_1.DEFAULT_EMBED_MODEL}`);
-        logger?.error('startDockerContainers: ollama container not found', { reason, steps: JSON.stringify(steps) });
-        process.exit(1);
+    // --- Embedding backend ---
+    if (!startBackend) {
+        if (isLocalBackend(provider))
+            console.log(`${provider} is already reachable — not starting a managed container.`);
+        else
+            console.log('Cloud embedding provider — no local backend to start.');
+        return;
+    }
+    if (provider === 'ollama') {
+        console.log('\nStarting the Ollama container...');
+        const r = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'up', '-d', 'ollama'], { stdio: 'inherit' });
+        if (r.status !== 0)
+            dockerFail('Failed to start the Ollama container. Make sure Docker is running.');
+        await waitForOllama(ollamaHost, 60, logger, steps);
+        const ollamaId = (0, child_process_1.spawnSync)('docker', ['compose', '-f', DOCKER_COMPOSE_DST, 'ps', '-q', 'ollama'], { encoding: 'utf-8' })
+            .stdout?.trim();
+        if (!ollamaId) {
+            const reason = 'Could not resolve ollama container ID from compose. Pull the model manually:';
+            console.error(reason);
+            console.error(`  docker exec <ollama-container> ollama pull ${embModel}`);
+            logger?.error('startDockerContainers: ollama container not found', { reason, steps: JSON.stringify(steps) });
+            process.exit(1);
+        }
+        console.log(`Pulling ${embModel} model (this may take a while)...`);
+        // `-t` allocates a pseudo-TTY so `ollama pull` renders its live progress bar;
+        // only when our stdout is itself a TTY (docker refuses `-t` without one).
+        const ttyFlag = process.stdout.isTTY ? ['-t'] : [];
+        (0, child_process_1.spawnSync)('docker', ['exec', ...ttyFlag, ollamaId, 'ollama', 'pull', embModel], { stdio: 'inherit' });
+        return;
+    }
+    if (provider === 'infinity') {
+        // Both models are bound at boot via a ";"-separated INFINITY_MODEL_ID.
+        const modelIds = [embModel, ...(rerankModel ? [rerankModel] : [])].join(';');
+        // Only layer the GPU override when it actually exists on disk — otherwise a
+        // GPU host whose override copy failed would get `-f <missing>` → hard failure
+        // instead of the intended CPU fallback.
+        const gpu = hasNvidiaGpu() && fs.existsSync(DOCKER_GPU_OVERRIDE_DST);
+        const files = ['-f', DOCKER_COMPOSE_DST, ...(gpu ? ['-f', DOCKER_GPU_OVERRIDE_DST] : [])];
+        console.log(`\nStarting the Infinity container (${gpu ? 'GPU' : 'CPU'}) serving: ${modelIds}`);
+        // `--force-recreate` so a changed model set recreates the container (D7) —
+        // Infinity binds its models at startup and won't pick up a new set otherwise.
+        const r = (0, child_process_1.spawnSync)('docker', ['compose', ...files, 'up', '-d', '--force-recreate', 'infinity'], { stdio: 'inherit', env: { ...process.env, INFINITY_MODEL_ID: modelIds } });
+        if (r.status !== 0)
+            dockerFail('Failed to start the Infinity container. Make sure Docker is running.');
+        await waitForInfinity(embBaseURL, 1800, logger, steps);
+        return;
     }
-    console.log(`Pulling ${constants_1.DEFAULT_EMBED_MODEL} model (this may take a while)...`);
-    (0, child_process_1.spawnSync)('docker', ['exec', ollamaId, 'ollama', 'pull', constants_1.DEFAULT_EMBED_MODEL], { stdio: 'inherit' });
 }
 async function runSetup(logger) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const steps = [];
     function logStep(q, raw) {
-        const a = /password/i.test(q) ? '***' : raw.trim();
+        const a = /password|key|secret|token/i.test(q) ? '***' : raw.trim();
         logger?.debug('setup: prompt', { q, a });
         steps.push({ q, a });
     }
@@ -191,23 +339,78 @@ async function runSetup(logger) {
             console.log('  Path is required.');
     } while (!workspaceInput.trim());
     const workspaceRoot = expandHome(workspaceInput.trim());
-    const ollamaHost = await loggedPrompt('Ollama API URL', 'http://localhost:11434');
+    console.log('\n--- Embedding backend ---');
+    console.log('  ollama            — local, zero-setup (default)');
+    console.log('  infinity          — local, one container serves embeddings + reranking (GPU/CPU)');
+    console.log('  openai-compatible — OpenAI cloud, or a local Infinity/TEI/vLLM server');
+    console.log('  voyage            — Voyage AI cloud');
+    const validProviders = ['ollama', 'infinity', 'openai-compatible', 'voyage'];
+    let embProvider;
+    do {
+        embProvider = (await loggedPrompt('Provider (ollama/infinity/openai-compatible/voyage)', 'ollama'));
+        if (!validProviders.includes(embProvider))
+            console.log(`  Invalid provider. Choose: ${validProviders.join(', ')}`);
+    } while (!validProviders.includes(embProvider));
+    const pd = PROVIDER_DEFAULTS[embProvider];
+    const embBaseURL = await loggedPrompt('Base URL', pd.baseURL);
+    const embModel = await loggedPrompt('Embedding model', pd.model);
+    // Infinity serves a reranker from the same container — offer to provision one.
+    let rerankModel = '';
+    if (embProvider === 'infinity') {
+        rerankModel = (await loggedPrompt(`Reranker model (served by the same Infinity container; blank to disable)`, DEFAULT_INFINITY_RERANK_MODEL)).trim();
+    }
+    // API keys go into .env (chmod 600); config.json only stores the env: reference.
+    let apiKeyRef = '';
+    if (!isLocalBackend(embProvider)) {
+        const key = (await loggedAsk(`API key (stored in ${config_store_1.ENV_FILE}, leave blank to set later): `)).trim();
+        if (key) {
+            writeEnvKey(pd.envVar, key);
+            apiKeyRef = `env:${pd.envVar}`;
+            console.log(`  Saved API key to ${config_store_1.ENV_FILE} as ${pd.envVar} (config references env:${pd.envVar}).`);
+        }
+        else {
+            apiKeyRef = `env:${pd.envVar}`;
+            console.log(`  No key entered — set it later: echo '${pd.envVar}=sk-…' >> ${config_store_1.ENV_FILE}`);
+        }
+    }
+    // Ollama host used by the Docker helper below (only meaningful for ollama).
+    const ollamaHost = embProvider === 'ollama' ? embBaseURL : 'http://localhost:11434';
     console.log('\n--- Database ---');
     const dbHost = await loggedPrompt('DB host', 'localhost');
     const dbPort = await loggedPrompt('DB port', '5433');
     const dbUser = await loggedPrompt('DB user', 'dev');
     const dbPass = await loggedPrompt('DB password', 'dev');
     process.stdout.write('\nTesting connection...');
-    const alreadyConnected = await checkRemoteDb(dbHost, dbPort, dbUser, dbPass, 'postgres', logger, steps);
-    if (alreadyConnected)
+    const dbReachable = await checkRemoteDb(dbHost, dbPort, dbUser, dbPass, 'postgres', logger, steps);
+    if (dbReachable)
         console.log('  Database is already reachable.');
-    const dockerDefault = alreadyConnected ? 'n' : 'y';
+    // Symmetric to the DB probe: a reachable embedding backend defaults "start
+    // Docker?" to no. Cloud providers have no local backend to start.
+    process.stdout.write('Checking embedding backend...');
+    const embReachable = await checkEmbeddingBackend(embProvider, embBaseURL);
+    if (isLocalBackend(embProvider)) {
+        console.log(embReachable ? `  ${embProvider} is already reachable.` : `  ${embProvider} is not reachable — it can be started via Docker.`);
+    }
+    else {
+        console.log('  cloud provider (no local backend to start).');
+    }
+    const dockerDefault = dockerPromptDefault(dbReachable, embReachable);
     const startDockerRaw = await loggedAsk(`Start Docker containers automatically? (y/n) (${dockerDefault}): `);
     const startDocker = (startDockerRaw.trim().toLowerCase() || dockerDefault) === 'y';
     if (startDocker) {
-        await startDockerContainers(ollamaHost, dbPort, dbUser, dbPass, logger, steps);
+        await startDockerContainers({
+            provider: embProvider,
+            ollamaHost,
+            embBaseURL,
+            dbPort, dbUser, dbPass,
+            embModel,
+            rerankModel: rerankModel || undefined,
+            startDb: !dbReachable,
+            startBackend: isLocalBackend(embProvider) && !embReachable,
+            logger, steps,
+        });
     }
-    else if (!alreadyConnected) {
+    else if (!dbReachable) {
         while (true) {
             console.log('\nTesting connection...');
             const ok = await checkRemoteDb(dbHost, dbPort, dbUser, dbPass, 'postgres', logger, steps);
@@ -242,10 +445,25 @@ async function runSetup(logger) {
             user: dbVars.user,
             password: dbVars.password,
         },
-        ollama: { host: ollamaHost },
+        embedding: {
+            provider: embProvider,
+            baseURL: embBaseURL,
+            model: embModel,
+            ...(apiKeyRef ? { apiKey: apiKeyRef } : {}),
+        },
         logging: { level: logLevel },
         workspaceRoot,
     };
+    // Infinity serves the reranker from the same container — auto-wire reranker.*
+    // to that server. `url` derives from provider + baseURL in the Config constructor.
+    if (embProvider === 'infinity' && rerankModel) {
+        cfg.reranker = {
+            enabled: true,
+            provider: 'openai-compatible',
+            baseURL: embBaseURL,
+            model: rerankModel,
+        };
+    }
     if (logDir)
         cfg.logging.dir = logDir;
     (0, config_store_1.writeConfigJson)(cfg);

package/dist/src/tools/SearchCodebaseTool.js

@@ -18,7 +18,7 @@ class SearchCodebaseTool {
     definition() {
         return {
             name: 'search_codebase',
-            description: 'Search local project codebase by semantic similarity',
+            description: 'Search local project codebase by semantic similarity. Each result shows File, Project, an optional Symbol breadcrumb (owning declaration, e.g. `IndexerService.ingestFile`), Line, the code, and Relevance.',
             inputSchema: {
                 type: 'object',
                 properties: {

package/dist/src/tools/format-helpers.js

@@ -13,7 +13,8 @@ function errorResponse(text) {
     return { isError: true, content: [{ type: 'text', text }] };
 }
 function formatChunk(r, label) {
-    return `${label ? `*(${label})*\n` : ''}**File:** ${r.filePath}\n**Project:** ${r.serviceName}\n**Line:** ${r.startLine}\n\`\`\`\n${r.content}\n\`\`\``;
+    const symbolLine = r.ownerPath ? `**Symbol:** ${r.ownerPath}\n` : '';
+    return `${label ? `*(${label})*\n` : ''}**File:** ${r.filePath}\n**Project:** ${r.serviceName}\n${symbolLine}**Line:** ${r.startLine}\n\`\`\`\n${r.content}\n\`\`\``;
 }
 function formatGraphContext(ctx) {
     const parts = [];

package/dist/src/web/dashboard.js

@@ -176,7 +176,9 @@ function renderDashboardHtml() {
     const isNum = spec.type === 'number' || spec.type === 'integer';
     inp.dataset.key = key;
     inp.dataset.type = isNum ? 'number' : 'string';
+    const isEnvRef = typeof value === 'string' && value.startsWith('env:');
     if (key === 'db.password') inp.type = 'password';
+    else if (key.endsWith('.apiKey')) inp.type = isEnvRef ? 'text' : 'password';
     else if (isNum) {
       inp.type = 'number';
       // Only apply small, meaningful bounds (skip zod's safe-integer noise).
@@ -197,6 +199,9 @@ function renderDashboardHtml() {
     const label = document.createElement('label');
     let html = key.split('.').pop();
     if (spec.description) html += '<span class="desc">' + spec.description + '</span>';
+    if (key.endsWith('.apiKey') && typeof value === 'string' && value.startsWith('env:')) {
+      html += '<span class="defval using">✔ set via ' + value.slice(4) + '</span>';
+    }
     if (def !== undefined) {
       html += '<span class="defval' + (isUnset ? ' using' : '') + '">'
         + (isUnset ? '↪ using default: ' : 'default: ') + fmtDefault(def) + '</span>';

package/docker/docker-compose.infinity-gpu.yml

@@ -0,0 +1,19 @@
+# GPU override for the Infinity service. Layered on top of docker-compose.yml
+# (docker compose -f docker-compose.yml -f docker-compose.infinity-gpu.yml …)
+# only when an NVIDIA GPU + container runtime is detected. Kept separate because
+# a `deploy.reservations.devices` GPU request aborts startup on GPU-less hosts;
+# the base file therefore stays CPU-only and always starts.
+services:
+  infinity:
+    # Warmup is cheap on GPU (seconds) — re-enable it so the first real request
+    # is already fast. On CPU (base file only) it stays off.
+    environment:
+      INFINITY_MODEL_WARMUP: "true"
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities:
+                - gpu

package/docker/docker-compose.yml

@@ -19,6 +19,31 @@ services:
     volumes:
       - ollama_data:/root/.ollama
 
+  # One Infinity container serves both /embeddings and /rerank. The model set is
+  # bound at startup via INFINITY_MODEL_ID (";"-separated for multiple models,
+  # e.g. "BAAI/bge-m3;BAAI/bge-reranker-v2-m3"). Defaults to CPU so it starts on
+  # any host; GPU is opt-in via docker-compose.infinity-gpu.yml (see rag-setup).
+  # Behind an "infinity" profile so `docker compose up -d` (ollama path) doesn't
+  # pull this multi-GB image — it starts only when explicitly targeted.
+  # Model warmup defaults OFF here: on CPU it runs multi-minute benchmark
+  # batches at every boot (a pure perf measurement, not required to serve). The
+  # GPU override turns it back on, where it costs seconds.
+  infinity:
+    image: michaelf34/infinity:latest
+    restart: unless-stopped
+    ports:
+      - "7997:7997"
+    environment:
+      INFINITY_MODEL_ID: ${INFINITY_MODEL_ID:-jinaai/jina-embeddings-v2-base-code}
+      INFINITY_MODEL_WARMUP: ${INFINITY_MODEL_WARMUP:-false}
+      INFINITY_PORT: "7997"
+    command: ["v2"]
+    volumes:
+      - infinity_cache:/app/.cache
+    profiles:
+      - infinity
+
 volumes:
   pgdata:
   ollama_data:
+  infinity_cache:

package/package.json

@@ -1,8 +1,26 @@
 {
   "name": "codesearch-mcp",
-  "version": "0.0.18-alpha",
+  "version": "0.1.0-alpha",
   "description": "Local semantic codebase search via MCP — indexes projects into pgvector, exposes search to Claude",
   "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "rag",
+    "semantic-search",
+    "code-search",
+    "pgvector",
+    "embeddings",
+    "claude",
+    "ollama",
+    "infinity"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "tag": "alpha"
+  },
   "main": "dist/app.js",
   "bin": {
     "rag-index": "dist/app.js",
@@ -19,9 +37,10 @@
     "CHANGELOG.md"
   ],
   "scripts": {
+    "prebuild": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "build": "tsc",
     "postbuild": "node -e \"const fs=require('fs');const f='dist/app.js';fs.writeFileSync(f,'#!/usr/bin/env node\\n'+fs.readFileSync(f,'utf8'));fs.chmodSync(f,0o755);\"",
-    "prepublishOnly": "npm run build && npm run typecheck",
+    "prepublishOnly": "npm run build && npm run typecheck && npm test",
     "start:mcp": "ts-node app.ts mcp",
     "start:web": "ts-node app.ts web",
     "index:workspace": "ts-node app.ts index",

package/dist/src/ast.d.ts

@@ -1,2 +0,0 @@
-import type { CodeDependency } from './db';
-export declare function extractImportEdges(filePath: string, serviceName: string, projectRoot?: string): Promise<Omit<CodeDependency, 'id'>[]>;

package/dist/src/ast.js

@@ -1,110 +0,0 @@
-"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;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractImportEdges = extractImportEdges;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const ts_morph_1 = require("ts-morph");
-// Per-project ts-morph instances keyed by projectRoot. Each project gets its own instance so that
-// projects without a tsconfig (key previously shared as '') don't leak files into each other.
-// Loading the tsconfig gives ts-morph the compilerOptions.paths needed to resolve aliases like @core/*.
-const morphProjects = new Map();
-const FALLBACK_OPTS = { skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: false, compilerOptions: { allowJs: true, noEmit: true } };
-function getMorphProject(projectRoot) {
-    if (!morphProjects.has(projectRoot)) {
-        const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
-        const hasTsconfig = fs.existsSync(tsconfigPath);
-        let project;
-        try {
-            const opts = hasTsconfig
-                ? { tsConfigFilePath: tsconfigPath, skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: false }
-                : FALLBACK_OPTS;
-            project = new ts_morph_1.Project(opts);
-        }
-        catch {
-            // tsconfig is invalid — fall back so other files in the project can still be processed
-            project = new ts_morph_1.Project(FALLBACK_OPTS);
-        }
-        morphProjects.set(projectRoot, project);
-    }
-    return morphProjects.get(projectRoot);
-}
-// Extract import edges from a TS/JS file using ts-morph.
-// projectRoot must be the project root (where tsconfig.json lives) for alias resolution to work.
-// Defaults to the file's directory — callers that need alias resolution must pass the project root explicitly.
-// Removes the source file from the morph project after parsing to prevent memory accumulation.
-async function extractImportEdges(filePath, serviceName, projectRoot = path.dirname(filePath)) {
-    // Only process JS/TS files; skip declaration files
-    if (!/\.(ts|tsx|js|jsx)$/.test(filePath) || /\.d\.ts$/.test(filePath))
-        return [];
-    const morphProject = getMorphProject(projectRoot);
-    // Remove stale cached version before re-adding
-    const existing = morphProject.getSourceFile(filePath);
-    if (existing)
-        morphProject.removeSourceFile(existing);
-    let sourceFile;
-    try {
-        sourceFile = morphProject.addSourceFileAtPath(filePath);
-    }
-    catch {
-        return []; // file disappeared between stat and parse
-    }
-    const edges = [];
-    for (const decl of sourceFile.getImportDeclarations()) {
-        const resolved = decl.getModuleSpecifierSourceFile();
-        if (!resolved)
-            continue; // external package or unresolvable
-        const toFile = resolved.getFilePath();
-        if (toFile.includes('/node_modules/'))
-            continue; // skip package type declarations
-        const namedImports = decl.getNamedImports();
-        const defaultImport = decl.getDefaultImport();
-        const namespaceImport = decl.getNamespaceImport();
-        if (namedImports.length > 0) {
-            for (const named of namedImports) {
-                edges.push({ project: serviceName, fromFile: filePath, fromSymbol: null, toFile, toSymbol: named.getName(), depType: 'import' });
-            }
-        }
-        else if (defaultImport) {
-            edges.push({ project: serviceName, fromFile: filePath, fromSymbol: null, toFile, toSymbol: null, depType: 'import-default' });
-        }
-        else if (namespaceImport) {
-            edges.push({ project: serviceName, fromFile: filePath, fromSymbol: null, toFile, toSymbol: null, depType: 'import-namespace' });
-        }
-    }
-    // Remove from memory — prevents accumulation across large workspaces
-    morphProject.removeSourceFile(sourceFile);
-    return edges;
-}

package/dist/src/commands/SetupCommand.d.ts

@@ -1,7 +0,0 @@
-import type { Container } from '../container';
-import type { ICommand } from './ICommand';
-export declare class SetupCommand implements ICommand {
-    private container;
-    constructor(container: Container);
-    execute(): Promise<void>;
-}

package/dist/src/commands/SetupCommand.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetupCommand = void 0;
-const setup_1 = require("../setup");
-class SetupCommand {
-    container;
-    constructor(container) {
-        this.container = container;
-    }
-    async execute() {
-        await (0, setup_1.runSetup)(this.container.logger);
-    }
-}
-exports.SetupCommand = SetupCommand;

package/dist/src/db/data-source.d.ts

@@ -1,2 +0,0 @@
-import { DataSource } from 'typeorm';
-export declare const db: DataSource;

package/dist/src/db/data-source.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.db = void 0;
-const typeorm_1 = require("typeorm");
-const config_1 = require("../config");
-const code_chunk_entity_1 = require("./entities/code-chunk.entity");
-const code_dependency_entity_1 = require("./entities/code-dependency.entity");
-exports.db = new typeorm_1.DataSource({
-    type: 'postgres',
-    ...config_1.config.db,
-    entities: [code_chunk_entity_1.CodeChunk, code_dependency_entity_1.CodeDependency],
-    synchronize: false,
-});

package/dist/src/db/entities/code-chunk.entity.d.ts

@@ -1,9 +0,0 @@
-export declare class CodeChunk {
-    id: string;
-    serviceName: string;
-    filePath: string;
-    startLine: number | null;
-    content: string;
-    embedding: string;
-    lastModified: number;
-}