codesearch-mcp 0.1.0-alpha → 0.2.1-alpha

package/dist/src/setup.js

@@ -33,17 +33,19 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMBEDDING_PROVIDER_CHOICES = void 0;
 exports.dockerPromptDefault = dockerPromptDefault;
+exports.prepareComposeAndStartDb = prepareComposeAndStartDb;
+exports.provisionInfinity = provisionInfinity;
 exports.runSetup = runSetup;
 const readline = __importStar(require("readline"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 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 infinity_provisioning_1 = require("./services/infinity-provisioning");
 const DEFAULT_LOG_DIR = path.join(config_store_1.CONFIG_DIR, 'logs');
 const _projectRoot = fs.existsSync(path.join(__dirname, '..', 'package.json'))
     ? path.join(__dirname, '..')
@@ -52,7 +54,6 @@ 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));
 }
@@ -66,14 +67,15 @@ function expandHome(p) {
     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 the wizard offers, in prompt order; the first is the preselected default. Exported for unit testing. */
+exports.EMBEDDING_PROVIDER_CHOICES = ['infinity', 'openai-compatible', 'voyage'];
 /** Providers that run a local inference backend we can probe / provision. */
 function isLocalBackend(p) {
-    return p === 'ollama' || p === 'infinity';
+    return p === 'infinity';
 }
 /**
  * Probe whether the embedding backend is already reachable, so the "start
@@ -83,24 +85,7 @@ function isLocalBackend(p) {
 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;
-    }
+    return (0, infinity_provisioning_1.probeInfinityHealth)(baseURL);
 }
 /**
  * Default answer for the "start Docker containers?" prompt: no only when both
@@ -110,15 +95,6 @@ async function checkEmbeddingBackend(provider, baseURL) {
 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`.
@@ -160,58 +136,6 @@ async function waitForDb(host, port, user, pass, db, maxWaitSec = 60, logger, st
     logger?.error('waitForDb: timeout', { reason, steps: JSON.stringify(steps) });
     process.exit(1);
 }
-async function waitForOllama(host, maxWaitSec = 60, logger, steps) {
-    const deadline = Date.now() + maxWaitSec * 1000;
-    process.stdout.write('Waiting for Ollama to be ready');
-    while (Date.now() < deadline) {
-        try {
-            const http = await Promise.resolve().then(() => __importStar(require('http')));
-            await new Promise((resolve, reject) => {
-                const req = http.get(`${host}/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')); });
-            });
-            console.log(' ready.');
-            return;
-        }
-        catch {
-            process.stdout.write('.');
-            await new Promise(r => setTimeout(r, 2000));
-        }
-    }
-    const reason = 'Ollama did not become ready in time.';
-    console.error(`\n${reason}`);
-    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')));
@@ -227,8 +151,16 @@ async function checkRemoteDb(host, port, user, pass, db, logger, steps) {
         return false;
     }
 }
-async function startDockerContainers(opts) {
-    const { provider, ollamaHost, embBaseURL, dbPort, dbUser, dbPass, embModel, rerankModel, startDb, startBackend, logger, steps } = opts;
+/**
+ * Regenerate `CONFIG_DIR/docker-compose.yml` from the shipped template
+ * (carrying over an existing literal `INFINITY_MODEL_ID`, written atomically),
+ * copy the GPU override, and start the DB container when requested. Runs
+ * BEFORE the config file is written — its failure aborts setup unsaved,
+ * matching the existing "abort without saving" behavior of the DB step. Does
+ * NOT touch Infinity provisioning (moved after `writeConfigJson` — see D6a).
+ */
+async function prepareComposeAndStartDb(opts) {
+    const { dbPort, dbUser, dbPass, startDb, 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');
@@ -236,72 +168,99 @@ async function startDockerContainers(opts) {
         .replace('POSTGRES_USER: dev', `POSTGRES_USER: ${yamlQuote(dbUser)}`)
         .replace('POSTGRES_PASSWORD: dev', `POSTGRES_PASSWORD: ${yamlQuote(dbPass)}`)
         .replace('"5433:5432"', `"${dbPort}:5432"`);
+    // Carry over an existing literal INFINITY_MODEL_ID — never the set of the
+    // config still being entered — so a setup that aborts before the config is
+    // written leaves a file consistent with the previously saved config.
+    let existingModelId = null;
+    try {
+        existingModelId = (0, infinity_provisioning_1.extractModelIdValue)(fs.readFileSync(DOCKER_COMPOSE_DST, 'utf-8'));
+    }
+    catch { /* no prior file */ }
+    if (existingModelId) {
+        composeContent = composeContent.replace(/INFINITY_MODEL_ID:\s*"[^"]*"/, `INFINITY_MODEL_ID: "${existingModelId}"`);
+    }
     fs.mkdirSync(config_store_1.CONFIG_DIR, { recursive: true });
-    fs.writeFileSync(DOCKER_COMPOSE_DST, composeContent, 'utf-8');
+    let existingMode = 0o600;
+    try {
+        existingMode = fs.statSync(DOCKER_COMPOSE_DST).mode;
+    }
+    catch { /* first-ever write */ }
+    (0, infinity_provisioning_1.atomicWriteFile)(DOCKER_COMPOSE_DST, composeContent, existingMode);
     // 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) });
+    if (!startDb)
+        return;
+    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) {
+        console.error('Failed to start the database container. Make sure Docker is running.');
+        logger?.error('prepareComposeAndStartDb: docker startup failed', { 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);
     }
-    // --- 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;
+    await waitForDb('localhost', parseInt(dbPort), dbUser, dbPass, 'postgres', 60, logger, steps);
+}
+/**
+ * Infinity provisioning (D6a) — runs AFTER the config file is written, so no
+ * outcome here can leave the config unsaved. `savedConfig` is a fresh read of
+ * the just-written file (never the process's own startup config). Exit-status
+ * rules: 0 for served / timeout (warning) / external instructions / declined
+ * Docker; 1 for any other provisioning failure — the cause is printed and the
+ * remaining setup steps (DB schema init) still run.
+ */
+async function provisionInfinity(savedConfig, startDocker, logger, deps = {}, composePathOverride) {
+    const composePath = composePathOverride ?? DOCKER_COMPOSE_DST;
+    const baseURL = savedConfig.embedding.baseURL;
+    const base = (0, infinity_provisioning_1.serverRoot)(baseURL);
+    const set = (0, infinity_provisioning_1.requiredModelSet)(savedConfig);
+    const managed = (0, infinity_provisioning_1.isManagedInfinity)(baseURL, composePath);
+    // Targeted write happens for a managed backend regardless of what follows
+    // (yes/no, served/missing), so the compose file always matches the saved
+    // config — even when the running container already serves the set.
+    if (managed) {
+        try {
+            (0, infinity_provisioning_1.writeComposeModelSet)(composePath, set);
+        }
+        catch (err) {
+            console.error(`\nFailed to write the managed compose file: ${err.message}`);
+            logger?.error('provisionInfinity: compose write failed', { reason: err.message });
+            process.exitCode = 1;
+        }
     }
-    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);
+    if (startDocker) {
+        try {
+            await (0, infinity_provisioning_1.ensureModelSetServed)(baseURL, composePath, set, deps);
+            console.log(`\nInfinity is serving the configured model set: ${set.join(';')}`);
+        }
+        catch (err) {
+            const msg = err.message;
+            if (/did not become ready within/.test(msg)) {
+                console.warn(`\nWarning: ${msg}`);
+                console.warn('The container is running and likely still warming up. Check again once /health responds, then run: rag-index');
+                logger?.warn('provisionInfinity: readiness timeout (non-fatal)', { reason: msg });
+            }
+            else {
+                console.error(`\nInfinity provisioning failed: ${msg}`);
+                logger?.error('provisionInfinity: failed', { reason: msg });
+                process.exitCode = 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);
+    // Docker declined — no Docker command; print what would apply the set.
+    const evaluation = await (0, infinity_provisioning_1.evaluateBackend)(baseURL, composePath, set, deps);
+    if (evaluation.action === 'served')
         return;
+    if (evaluation.managed) {
+        const files = (0, infinity_provisioning_1.composeFileArgs)(composePath);
+        console.log(`\nInfinity does not yet serve the required model set (${set.join(';')}).`);
+        console.log('Run this to apply it:');
+        console.log(`  docker compose ${files.join(' ')} up -d --force-recreate infinity`);
+    }
+    else {
+        console.log(`\n${(0, infinity_provisioning_1.manualInstructionMessage)(evaluation, base, set)}`);
     }
 }
 async function runSetup(logger) {
@@ -340,24 +299,22 @@ async function runSetup(logger) {
     } while (!workspaceInput.trim());
     const workspaceRoot = expandHome(workspaceInput.trim());
     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('  infinity          — local, one container serves embeddings + reranking (GPU/CPU) (default)');
+    console.log('  openai-compatible — OpenAI cloud, or a local Infinity/TEI/vLLM/Ollama (via its /v1 endpoint) 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));
+        embProvider = (await loggedPrompt('Provider (infinity/openai-compatible/voyage)', exports.EMBEDDING_PROVIDER_CHOICES[0]));
+        if (!exports.EMBEDDING_PROVIDER_CHOICES.includes(embProvider))
+            console.log(`  Invalid provider. Choose: ${exports.EMBEDDING_PROVIDER_CHOICES.join(', ')}`);
+    } while (!exports.EMBEDDING_PROVIDER_CHOICES.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();
+        rerankModel = (await loggedPrompt(`Reranker model (served by the same Infinity container; blank to disable)`, config_store_1.CONFIG_DEFAULTS['reranker.model'])).trim();
     }
     // API keys go into .env (chmod 600); config.json only stores the env: reference.
     let apiKeyRef = '';
@@ -373,8 +330,6 @@ async function runSetup(logger) {
             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');
@@ -398,15 +353,9 @@ async function runSetup(logger) {
     const startDockerRaw = await loggedAsk(`Start Docker containers automatically? (y/n) (${dockerDefault}): `);
     const startDocker = (startDockerRaw.trim().toLowerCase() || dockerDefault) === 'y';
     if (startDocker) {
-        await startDockerContainers({
-            provider: embProvider,
-            ollamaHost,
-            embBaseURL,
+        await prepareComposeAndStartDb({
             dbPort, dbUser, dbPass,
-            embModel,
-            rerankModel: rerankModel || undefined,
             startDb: !dbReachable,
-            startBackend: isLocalBackend(embProvider) && !embReachable,
             logger, steps,
         });
     }
@@ -469,6 +418,11 @@ async function runSetup(logger) {
     (0, config_store_1.writeConfigJson)(cfg);
     console.log(`\nConfig saved to ${config_store_1.CONFIG_FILE}`);
     rl.close();
+    // Infinity provisioning happens only now — after the config is safely on
+    // disk — so a provisioning failure never leaves the wizard's answers unsaved.
+    if (embProvider === 'infinity') {
+        await provisionInfinity(new config_1.Config(), startDocker, logger);
+    }
     console.log('\nInitializing database schema...');
     const { DatabaseService } = await Promise.resolve().then(() => __importStar(require('./services/DatabaseService')));
     const dbService = new DatabaseService(new config_1.Config());

package/dist/src/symbol-name.d.ts

@@ -0,0 +1,44 @@
+export declare const BARE_NAME_RE: RegExp;
+export declare const QUALIFIED_NAME_RE: RegExp;
+export type FindSymbolQuery = {
+    form: 'bare';
+    name: string;
+} | {
+    form: 'qualified';
+    container: string;
+    name: string;
+} | {
+    form: 'quoted';
+    container: string | null;
+    name: string;
+} | {
+    form: 'computed';
+    container: string | null;
+    name: string;
+};
+/** Split `P.n` into container `P` and last segment `n`. Requires a qualified name. */
+export declare function splitQualified(input: string): {
+    container: string;
+    name: string;
+};
+/**
+ * Parse a `find_symbol` name into one of the four accepted forms (bare,
+ * qualified, quoted, computed), or null when it matches none — the caller
+ * should reject with `Invalid symbol name` without querying anything.
+ */
+export declare function parseFindSymbolName(input: string): FindSymbolQuery | null;
+/**
+ * Parse a `get_callers` symbol into bare or qualified form only — the quoted
+ * and computed forms of `find_symbol` are meaningless here (calls through
+ * element access are never recorded in the call graph).
+ */
+export declare function parseCallerSymbol(input: string): {
+    form: 'bare';
+    name: string;
+} | {
+    form: 'qualified';
+    container: string;
+    name: string;
+} | null;
+/** Escape `%`, `_` and `\` for a `LIKE ... ESCAPE '\'` pattern. */
+export declare function escapeLike(s: string): string;

package/dist/src/symbol-name.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUALIFIED_NAME_RE = exports.BARE_NAME_RE = void 0;
+exports.splitQualified = splitQualified;
+exports.parseFindSymbolName = parseFindSymbolName;
+exports.parseCallerSymbol = parseCallerSymbol;
+exports.escapeLike = escapeLike;
+exports.BARE_NAME_RE = /^#?[\w$]+$/;
+exports.QUALIFIED_NAME_RE = /^#?[\w$]+(\.#?[\w$]+)+$/;
+const PFX_SRC = '(?:#?[\\w$]+(?:\\.#?[\\w$]+)*\\.)?';
+const QUOTED_RE = new RegExp(`^(${PFX_SRC})('[^'\\r\\n]+'|"[^"\\r\\n]+")$`);
+const COMPUTED_RE = new RegExp(`^(${PFX_SRC})(\\[[^\\]\\r\\n]+\\])$`);
+const MAX_QUOTED_COMPUTED_LEN = 256;
+/** Strip a qualified name's trailing `.` container prefix, if present. */
+function stripTrailingDot(prefix) {
+    if (!prefix)
+        return null;
+    return prefix.slice(0, -1);
+}
+/** Split `P.n` into container `P` and last segment `n`. Requires a qualified name. */
+function splitQualified(input) {
+    const idx = input.lastIndexOf('.');
+    return { container: input.slice(0, idx), name: input.slice(idx + 1) };
+}
+/**
+ * Parse a `find_symbol` name into one of the four accepted forms (bare,
+ * qualified, quoted, computed), or null when it matches none — the caller
+ * should reject with `Invalid symbol name` without querying anything.
+ */
+function parseFindSymbolName(input) {
+    if (input.length <= MAX_QUOTED_COMPUTED_LEN) {
+        const quoted = input.match(QUOTED_RE);
+        if (quoted) {
+            return { form: 'quoted', container: stripTrailingDot(quoted[1]), name: quoted[2].slice(1, -1) };
+        }
+        const computed = input.match(COMPUTED_RE);
+        if (computed) {
+            return { form: 'computed', container: stripTrailingDot(computed[1]), name: computed[2].replace(/\s+/g, '') };
+        }
+    }
+    if (exports.QUALIFIED_NAME_RE.test(input)) {
+        const { container, name } = splitQualified(input);
+        return { form: 'qualified', container, name };
+    }
+    if (exports.BARE_NAME_RE.test(input)) {
+        return { form: 'bare', name: input };
+    }
+    return null;
+}
+/**
+ * Parse a `get_callers` symbol into bare or qualified form only — the quoted
+ * and computed forms of `find_symbol` are meaningless here (calls through
+ * element access are never recorded in the call graph).
+ */
+function parseCallerSymbol(input) {
+    if (exports.QUALIFIED_NAME_RE.test(input)) {
+        const { container, name } = splitQualified(input);
+        return { form: 'qualified', container, name };
+    }
+    if (exports.BARE_NAME_RE.test(input)) {
+        return { form: 'bare', name: input };
+    }
+    return null;
+}
+/** Escape `%`, `_` and `\` for a `LIKE ... ESCAPE '\'` pattern. */
+function escapeLike(s) {
+    return s.replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_');
+}

package/dist/src/symbol-rows.d.ts

@@ -0,0 +1,12 @@
+import type { SymbolEntry } from './interfaces/IAstParser';
+export type CodeSymbolRow = Pick<SymbolEntry, 'project' | 'filePath' | 'name' | 'kind' | 'signature' | 'line' | 'col' | 'container' | 'isStatic'>;
+/**
+ * Combine top-level symbols and members into the rows written to `code_symbol`.
+ * Overload signatures of one declaration — same `(container, name, kind,
+ * isStatic)` — collapse to a single representative row: the one with a body
+ * (the implementation) when present, otherwise the earliest by line (the first
+ * signature in source order). Static and instance members sharing a name are
+ * never collapsed into each other (`isStatic` is part of the group key). A
+ * final dedup by `(container, name, kind, line)` matches the DB's unique index.
+ */
+export declare function buildSymbolRows(symbols: SymbolEntry[], members: SymbolEntry[]): CodeSymbolRow[];

package/dist/src/symbol-rows.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSymbolRows = buildSymbolRows;
+/**
+ * Combine top-level symbols and members into the rows written to `code_symbol`.
+ * Overload signatures of one declaration — same `(container, name, kind,
+ * isStatic)` — collapse to a single representative row: the one with a body
+ * (the implementation) when present, otherwise the earliest by line (the first
+ * signature in source order). Static and instance members sharing a name are
+ * never collapsed into each other (`isStatic` is part of the group key). A
+ * final dedup by `(container, name, kind, line)` matches the DB's unique index.
+ */
+function buildSymbolRows(symbols, members) {
+    const groups = new Map();
+    for (const entry of [...symbols, ...members]) {
+        const key = JSON.stringify([entry.container, entry.name, entry.kind, entry.isStatic]);
+        const group = groups.get(key);
+        if (group)
+            group.push(entry);
+        else
+            groups.set(key, [entry]);
+    }
+    const collapsed = [];
+    for (const group of groups.values()) {
+        if (group.length === 1) {
+            collapsed.push(group[0]);
+            continue;
+        }
+        const implementation = group.find(e => e.hasBody);
+        collapsed.push(implementation ?? group.reduce((a, b) => ((a.line ?? 0) <= (b.line ?? 0) ? a : b)));
+    }
+    const dedup = new Map();
+    for (const entry of collapsed) {
+        const key = JSON.stringify([entry.container, entry.name, entry.kind, entry.line]);
+        dedup.set(key, entry);
+    }
+    return [...dedup.values()].map(({ project, filePath, name, kind, signature, line, col, container, isStatic }) => ({ project, filePath, name, kind, signature, line, col, container, isStatic }));
+}

package/dist/src/tools/FindSymbolTool.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FindSymbolTool = void 0;
 const format_helpers_1 = require("./format-helpers");
-const VALID_KINDS = ['function', 'class', 'type', 'interface', 'variable', 'method', 'all'];
+const VALID_KINDS = [
+    'function', 'class', 'type', 'interface', 'variable',
+    'method', 'get_accessor', 'set_accessor', 'constructor', 'function_property', 'method_signature',
+    'all',
+];
 class FindSymbolTool {
     searcher;
     constructor(searcher) {
@@ -11,11 +15,16 @@ class FindSymbolTool {
     definition() {
         return {
             name: 'find_symbol',
-            description: 'Find TypeScript/JavaScript symbol definitions (functions, classes, types, interfaces, variables, methods) by exact name. Use when you know the symbol name and want its definition location fast.',
+            description: 'Find TypeScript/JavaScript symbol definitions by exact name: top-level declarations (functions, classes, types, ' +
+                'interfaces, variables), class/object-literal members (methods, get/set accessors, constructors, function ' +
+                'properties), interface and type-literal method signatures, and namespace-level declarations. Accepts a bare name ' +
+                '(any container), a qualified name (`Class.method`, `NS.Class.method`), a quoted name for string-literal members ' +
+                "(`Router.'kebab-name'`), or a computed name (`Stack.[Symbol.iterator]`). Use when you know the symbol name and " +
+                'want its definition location fast.',
             inputSchema: {
                 type: 'object',
                 properties: {
-                    name: { type: 'string', description: 'Exact symbol name (case-sensitive, whole-word match)' },
+                    name: { type: 'string', description: 'Bare, qualified (Class.method), quoted, or computed symbol name (case-sensitive)' },
                     project: { type: 'string', description: 'Limit search to this project (optional). Use list_projects to find names.' },
                     kind: { type: 'string', enum: VALID_KINDS, description: 'Symbol kind filter. Default: all.' },
                 },
@@ -28,15 +37,29 @@ class FindSymbolTool {
         const project = args.project ? String(args.project) : null;
         const rawKind = args.kind;
         const kind = VALID_KINDS.includes(rawKind) ? rawKind : 'all';
-        const { hits, truncated } = await this.searcher.findSymbol(name, project, kind);
-        if (hits.length === 0) {
-            return (0, format_helpers_1.textResponse)(`No definitions found for symbol: ${name}`);
+        let parsed;
+        try {
+            parsed = await this.searcher.findSymbol(name, project, kind);
+        }
+        catch (err) {
+            return (0, format_helpers_1.errorResponse)(err.message);
         }
+        const { hits, truncated, grepFailed } = parsed;
+        const notice = await this.searcher.outdatedNotice(project);
         const lines = [];
+        if (notice)
+            lines.push(notice + '\n');
+        if (hits.length === 0) {
+            const suffix = grepFailed ? ' (grep fallback failed — see log)' : '';
+            lines.push(`No definitions found for symbol: ${name}${suffix}`);
+            return (0, format_helpers_1.textResponse)(lines.join('\n'));
+        }
         if (truncated)
             lines.push(`*(truncated to ${hits.length} results)*\n`);
         for (const h of hits) {
-            lines.push(`**${h.kind}** \`${h.filePath}\` line ${h.line}, col ${h.column}`);
+            const staticTag = h.isStatic ? ' static' : '';
+            const grepTag = h.source === 'grep' ? ' (grep — not in index; may be stale or imprecise)' : '';
+            lines.push(`**${h.kind}** \`${h.qualified}\`${staticTag} \`${h.filePath}\` line ${h.line}, col ${h.column}${grepTag}`);
             lines.push(`\`\`\`\n${h.signature}\n\`\`\``);
         }
         return (0, format_helpers_1.textResponse)(lines.join('\n'));