codesearch-mcp 0.2.3-alpha → 0.4.0-alpha

package/dist/src/setup.js

@@ -34,7 +34,16 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EMBEDDING_PROVIDER_CHOICES = void 0;
+exports.recordedStep = recordedStep;
+exports.setupStepLogger = setupStepLogger;
 exports.dockerPromptDefault = dockerPromptDefault;
+exports.rerankerChoices = rerankerChoices;
+exports.voyageEmbeddingModels = voyageEmbeddingModels;
+exports.promptModelChoice = promptModelChoice;
+exports.promptVoyageSetup = promptVoyageSetup;
+exports.promptSearchThreshold = promptSearchThreshold;
+exports.searchThresholdBlock = searchThresholdBlock;
+exports.promptReranker = promptReranker;
 exports.prepareComposeAndStartDb = prepareComposeAndStartDb;
 exports.provisionInfinity = provisionInfinity;
 exports.runSetup = runSetup;
@@ -43,6 +52,7 @@ 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 infinity_provisioning_1 = require("./services/infinity-provisioning");
@@ -54,6 +64,18 @@ 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');
+function recordedStep(question, raw) {
+    const q = question.split('\n').find(l => l.trim())?.trim() ?? question.trim();
+    const a = /password|key|secret|token/i.test(q) ? '***' : raw.trim();
+    return { q, a };
+}
+function setupStepLogger(logger, steps) {
+    return (question, raw) => {
+        const step = recordedStep(question, raw);
+        logger?.debug('setup: prompt', step);
+        steps.push(step);
+    };
+}
 function ask(rl, question) {
     return new Promise(resolve => rl.question(question, resolve));
 }
@@ -68,51 +90,194 @@ function expandHome(p) {
 }
 const PROVIDER_DEFAULTS = {
     '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 === '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))
+    if (!isLocalBackend(provider) || !baseURL)
         return true;
     return (0, infinity_provisioning_1.probeInfinityHealth)(baseURL);
 }
-/**
- * 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';
 }
-/**
- * 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 */ }
+    catch { }
     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 */ }
+    catch { }
+}
+const VOYAGE_API_ENV = 'VOYAGE_API_KEY';
+const VOYAGE_RERANK_ENV = 'VOYAGE_RERANK_API_KEY';
+const RERANKER_ENV = 'RERANKER_API_KEY';
+function rerankerChoices(embProvider) {
+    if (embProvider === 'infinity')
+        return ['infinity', 'voyage', 'openai-compatible', 'none'];
+    return ['none', 'voyage', 'openai-compatible'];
+}
+function voyageEmbeddingModels() {
+    return Object.entries(constants_1.MODEL_REGISTRY).filter(([, info]) => info.provider === 'voyage').map(([name]) => name);
+}
+async function askRequired(io, question, required = '  A value is required.') {
+    for (;;) {
+        const answer = (await io.ask(question)).trim();
+        if (answer)
+            return answer;
+        io.log(required);
+    }
+}
+async function promptModelChoice(io, label, models) {
+    models.forEach((m, i) => io.log(`  ${i + 1}) ${m}${i === 0 ? ' (default)' : ''}`));
+    for (;;) {
+        const answer = (await io.ask(`${label} (1-${models.length} or a model name) (1): `)).trim();
+        if (!answer)
+            return models[0];
+        if (!/^\d+$/.test(answer))
+            return answer;
+        const n = parseInt(answer, 10);
+        if (n >= 1 && n <= models.length)
+            return models[n - 1];
+        io.log(`  Enter a number from 1-${models.length}, or a model name.`);
+    }
+}
+async function promptVoyageSetup(io) {
+    const key = await askRequired(io, `Voyage API key (stored in ${config_store_1.ENV_FILE} as ${VOYAGE_API_ENV}): `, '  The Voyage API key is required.');
+    io.writeEnvKey(VOYAGE_API_ENV, key);
+    io.log(`  Saved API key to ${config_store_1.ENV_FILE} as ${VOYAGE_API_ENV}.`);
+    const apiKey = `env:${VOYAGE_API_ENV}`;
+    const model = await promptModelChoice(io, 'Embedding model', voyageEmbeddingModels());
+    const embedding = { provider: 'voyage', model, apiKey };
+    io.log('\n--- Reranker ---');
+    let enable;
+    for (;;) {
+        enable = (await io.prompt('Enable Voyage reranker? (y/n)', 'y')).trim().toLowerCase();
+        if (enable === 'y' || enable === 'n')
+            break;
+        io.log('  Answer y or n.');
+    }
+    if (enable === 'n')
+        return { embedding, reranker: { enabled: false } };
+    const rerankModel = await promptModelChoice(io, 'Reranker model', constants_1.VOYAGE_RERANK_MODELS);
+    return { embedding, reranker: { enabled: true, provider: 'voyage', model: rerankModel, apiKey } };
+}
+async function promptSearchThreshold(io, model) {
+    const recommended = constants_1.MODEL_REGISTRY[model]?.defaultThreshold;
+    io.log('\n--- Search threshold ---');
+    io.log(recommended !== undefined
+        ? `  Recommended for ${model}: ${(0, constants_1.formatThreshold)(recommended)}`
+        : `  ${model} has no recommended value; left blank, only unrelated results are filtered out.`);
+    for (;;) {
+        const answer = (await io.ask('Similarity threshold: max cosine distance 0-1, lower is stricter (blank to follow the model): ')).trim();
+        if (!answer)
+            return undefined;
+        const value = Number(answer);
+        if (value >= 0 && value <= 1)
+            return value;
+        io.log('  Enter a number from 0 to 1, or leave it blank.');
+    }
+}
+function searchThresholdBlock(threshold) {
+    return threshold === undefined ? {} : { search: { similarityThreshold: threshold } };
+}
+function isHttpUrl(value) {
+    try {
+        const { protocol, username, password } = new URL(value);
+        return (protocol === 'http:' || protocol === 'https:') && !username && !password;
+    }
+    catch {
+        return false;
+    }
+}
+async function askHttpUrl(io, question) {
+    for (;;) {
+        const answer = await askRequired(io, question);
+        if (isHttpUrl(answer))
+            return answer;
+        io.log('  Enter an absolute http(s):// URL without credentials, e.g. http://localhost:7997.');
+    }
+}
+async function promptReranker(embProvider, embBaseURL, io) {
+    const choices = rerankerChoices(embProvider);
+    io.log('\n--- Reranker ---');
+    if (choices.includes('infinity'))
+        io.log('  infinity          — served by the same Infinity container');
+    io.log('  voyage            — Voyage AI cloud (needs a Voyage API key)');
+    io.log('  openai-compatible — any /rerank server (Infinity, vLLM)');
+    io.log('  none              — no reranking');
+    let choice;
+    for (;;) {
+        choice = (await io.prompt(`Reranker (${choices.join('/')})`, choices[0])).trim();
+        if (choices.includes(choice))
+            break;
+        io.log(`  Invalid reranker. Choose: ${choices.join(', ')}`);
+    }
+    if (choice === 'none')
+        return { enabled: false };
+    if (choice === 'infinity') {
+        const model = (await io.prompt('Reranker model (served by the same Infinity container)', config_store_1.CONFIG_DEFAULTS['reranker.model'])).trim();
+        return { enabled: true, provider: 'openai-compatible', baseURL: embBaseURL, model };
+    }
+    if (choice === 'voyage') {
+        const model = (await io.prompt(`Reranker model (${constants_1.VOYAGE_RERANK_MODELS.join(' / ')})`, constants_1.VOYAGE_RERANK_MODELS[0])).trim();
+        for (;;) {
+            const key = (await io.ask(`Voyage reranker API key (stored in ${config_store_1.ENV_FILE} as ${VOYAGE_RERANK_ENV}): `)).trim();
+            if (key) {
+                io.writeEnvKey(VOYAGE_RERANK_ENV, key);
+                io.log(`  Saved reranker API key to ${config_store_1.ENV_FILE} as ${VOYAGE_RERANK_ENV}.`);
+                return { enabled: true, provider: 'voyage', model, apiKey: `env:${VOYAGE_RERANK_ENV}` };
+            }
+            io.log('  The Voyage reranker is not configured without an API key.');
+            const disable = (await io.prompt('Disable the reranker? (y/n)', 'y')).trim().toLowerCase();
+            if (disable === 'y')
+                return { enabled: false };
+        }
+    }
+    const baseURL = await askHttpUrl(io, 'Rerank server base URL: ');
+    const model = await askRequired(io, 'Reranker model: ');
+    const key = (await io.ask(`Reranker API key (stored in ${config_store_1.ENV_FILE} as ${RERANKER_ENV}, blank for none): `)).trim();
+    if (key)
+        io.writeEnvKey(RERANKER_ENV, key);
+    return {
+        enabled: true, provider: 'openai-compatible', baseURL, model,
+        ...(key ? { apiKey: `env:${RERANKER_ENV}` } : {}),
+    };
+}
+async function promptGenericBackend(embProvider, io) {
+    const pd = PROVIDER_DEFAULTS[embProvider];
+    const embBaseURL = await io.prompt('Base URL', pd.baseURL);
+    const embModel = await io.prompt('Embedding model', pd.model);
+    let apiKeyRef = '';
+    if (!isLocalBackend(embProvider)) {
+        const key = (await io.ask(`API key (stored in ${config_store_1.ENV_FILE}, leave blank to set later): `)).trim();
+        apiKeyRef = `env:${pd.envVar}`;
+        if (key) {
+            io.writeEnvKey(pd.envVar, key);
+            io.log(`  Saved API key to ${config_store_1.ENV_FILE} as ${pd.envVar} (config references env:${pd.envVar}).`);
+        }
+        else {
+            io.log(`  No key entered — set it later: echo '${pd.envVar}=sk-…' >> ${config_store_1.ENV_FILE}`);
+        }
+    }
+    const reranker = await promptReranker(embProvider, embBaseURL, io);
+    const embedding = {
+        provider: embProvider,
+        baseURL: embBaseURL,
+        model: embModel,
+        ...(apiKeyRef ? { apiKey: apiKeyRef } : {}),
+    };
+    return { embedding, reranker };
 }
 async function waitForDb(host, port, user, pass, db, maxWaitSec = 60, logger, steps) {
     const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
@@ -147,18 +312,10 @@ async function checkRemoteDb(host, port, user, pass, db, logger, steps) {
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         console.error(`  Connection failed: ${msg}`);
-        logger?.error('checkRemoteDb: connection failed', { reason: msg, steps: JSON.stringify(steps) });
+        logger?.error('checkRemoteDb: connection failed', { err, steps: JSON.stringify(steps) });
         return false;
     }
 }
-/**
- * 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);
@@ -168,14 +325,11 @@ async function prepareComposeAndStartDb(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 */ }
+    catch { }
     if (existingModelId) {
         composeContent = composeContent.replace(/INFINITY_MODEL_ID:\s*"[^"]*"/, `INFINITY_MODEL_ID: "${existingModelId}"`);
     }
@@ -184,13 +338,12 @@ async function prepareComposeAndStartDb(opts) {
     try {
         existingMode = fs.statSync(DOCKER_COMPOSE_DST).mode;
     }
-    catch { /* first-ever write */ }
+    catch { }
     (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 */ }
+    catch { }
     if (!startDb)
         return;
     console.log('\nStarting the database container...');
@@ -202,30 +355,19 @@ async function prepareComposeAndStartDb(opts) {
     }
     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 });
+            logger?.error('provisionInfinity: compose write failed', { err });
             process.exitCode = 1;
         }
     }
@@ -239,17 +381,16 @@ async function provisionInfinity(savedConfig, startDocker, logger, deps = {}, co
             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 });
+                logger?.warn('provisionInfinity: readiness timeout (non-fatal)', { err });
             }
             else {
                 console.error(`\nInfinity provisioning failed: ${msg}`);
-                logger?.error('provisionInfinity: failed', { reason: msg });
+                logger?.error('provisionInfinity: failed', { err });
                 process.exitCode = 1;
             }
         }
         return;
     }
-    // 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;
@@ -266,15 +407,10 @@ async function provisionInfinity(savedConfig, startDocker, logger, deps = {}, co
 async function runSetup(logger) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const steps = [];
-    function logStep(q, raw) {
-        const a = /password|key|secret|token/i.test(q) ? '***' : raw.trim();
-        logger?.debug('setup: prompt', { q, a });
-        steps.push({ q, a });
-    }
+    const logStep = setupStepLogger(logger, steps);
     const loggedAsk = async (question) => {
         const answer = await ask(rl, question);
-        const key = question.split('\n').find(l => l.trim())?.trim() ?? question.trim();
-        logStep(key, answer);
+        logStep(question, answer);
         return answer;
     };
     const loggedPrompt = async (label, def) => {
@@ -308,28 +444,11 @@ async function runSetup(logger) {
         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)`, config_store_1.CONFIG_DEFAULTS['reranker.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}`);
-        }
-    }
+    const promptIO = { prompt: loggedPrompt, ask: loggedAsk, writeEnvKey, log: msg => console.log(msg) };
+    const { embedding, reranker } = embProvider === 'voyage'
+        ? await promptVoyageSetup(promptIO)
+        : await promptGenericBackend(embProvider, promptIO);
+    const searchThreshold = await promptSearchThreshold(promptIO, embedding.model ?? config_store_1.CONFIG_DEFAULTS['embedding.model']);
     console.log('\n--- Database ---');
     const dbHost = await loggedPrompt('DB host', 'localhost');
     const dbPort = await loggedPrompt('DB port', '5433');
@@ -339,10 +458,8 @@ async function runSetup(logger) {
     const dbReachable = await checkRemoteDb(dbHost, dbPort, dbUser, dbPass, 'postgres', logger, steps);
     if (dbReachable)
         console.log('  Database is already reachable.');
-    // 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);
+    const embReachable = await checkEmbeddingBackend(embProvider, embedding.baseURL);
     if (isLocalBackend(embProvider)) {
         console.log(embReachable ? `  ${embProvider} is already reachable.` : `  ${embProvider} is not reachable — it can be started via Docker.`);
     }
@@ -394,38 +511,23 @@ async function runSetup(logger) {
             user: dbVars.user,
             password: dbVars.password,
         },
-        embedding: {
-            provider: embProvider,
-            baseURL: embBaseURL,
-            model: embModel,
-            ...(apiKeyRef ? { apiKey: apiKeyRef } : {}),
-        },
+        embedding,
+        reranker,
+        ...searchThresholdBlock(searchThreshold),
         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);
     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());
+    const dbService = new DatabaseService(new config_1.Config(), logger);
     let initError = null;
     try {
         await dbService.initDbWithSchema();
@@ -438,7 +540,7 @@ async function runSetup(logger) {
     }
     if (initError) {
         console.error(`Database schema init failed: ${initError.message}`);
-        logger?.error('runSetup: database schema init failed', { reason: initError.message, steps: JSON.stringify(steps) });
+        logger?.error('runSetup: database schema init failed', { err: initError, steps: JSON.stringify(steps) });
         process.exit(1);
     }
     console.log('\nSetup complete!');

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

@@ -1,5 +1,6 @@
 export declare const BARE_NAME_RE: RegExp;
 export declare const QUALIFIED_NAME_RE: RegExp;
+export declare const MAX_GREPPED_NAME_LEN = 256;
 export type FindSymbolQuery = {
     form: 'bare';
     name: string;
@@ -16,22 +17,11 @@ export type FindSymbolQuery = {
     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;
@@ -40,5 +30,4 @@ export declare function parseCallerSymbol(input: string): {
     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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QUALIFIED_NAME_RE = exports.BARE_NAME_RE = void 0;
+exports.MAX_GREPPED_NAME_LEN = exports.QUALIFIED_NAME_RE = exports.BARE_NAME_RE = void 0;
 exports.splitQualified = splitQualified;
 exports.parseFindSymbolName = parseFindSymbolName;
 exports.parseCallerSymbol = parseCallerSymbol;
@@ -10,33 +10,26 @@ 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. */
+exports.MAX_GREPPED_NAME_LEN = 256;
 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 (input.length > exports.MAX_GREPPED_NAME_LEN)
+        return null;
+    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);
@@ -47,13 +40,12 @@ function parseFindSymbolName(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 isQualifiedName(input) {
+    const segments = input.split('.');
+    return segments.length >= 2 && segments.every(segment => exports.BARE_NAME_RE.test(segment));
+}
 function parseCallerSymbol(input) {
-    if (exports.QUALIFIED_NAME_RE.test(input)) {
+    if (isQualifiedName(input)) {
         const { container, name } = splitQualified(input);
         return { form: 'qualified', container, name };
     }
@@ -62,7 +54,6 @@ function parseCallerSymbol(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

@@ -1,17 +1,3 @@
 import type { SymbolEntry } from './interfaces/IAstParser';
 export type CodeSymbolRow = Pick<SymbolEntry, 'project' | 'filePath' | 'name' | 'kind' | 'signature' | 'line' | 'col' | 'container' | 'isStatic' | 'target'>;
-/**
- * Combine top-level symbols, members and GraphQL-named rows 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). `graphqlNames` bypass this collapse — decorators
- * cannot sit on overload signatures, so there is nothing to collapse, and the
- * collapse's `(container, name, kind, isStatic)` key would wrongly merge two
- * different methods exposing the same GraphQL name from two resolver classes
- * (both with container `Query`). A final dedup by `(container, name, kind,
- * line)` matches the DB's unique index.
- */
 export declare function buildSymbolRows(symbols: SymbolEntry[], members: SymbolEntry[], graphqlNames?: SymbolEntry[]): CodeSymbolRow[];

package/dist/src/symbol-rows.js

@@ -1,20 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSymbolRows = buildSymbolRows;
-/**
- * Combine top-level symbols, members and GraphQL-named rows 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). `graphqlNames` bypass this collapse — decorators
- * cannot sit on overload signatures, so there is nothing to collapse, and the
- * collapse's `(container, name, kind, isStatic)` key would wrongly merge two
- * different methods exposing the same GraphQL name from two resolver classes
- * (both with container `Query`). A final dedup by `(container, name, kind,
- * line)` matches the DB's unique index.
- */
 function buildSymbolRows(symbols, members, graphqlNames = []) {
     const groups = new Map();
     for (const entry of [...symbols, ...members]) {

package/dist/src/tool-call-log.d.ts

@@ -0,0 +1,2 @@
+export declare function truncateForLog(value: unknown, depth?: number): unknown;
+export declare function resolveSession(env: Record<string, string | undefined>): string | null;

package/dist/src/tool-call-log.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateForLog = truncateForLog;
+exports.resolveSession = resolveSession;
+const MAX_STRING = 500;
+const MAX_ITEMS = 20;
+const MAX_DEPTH = 4;
+function truncateForLog(value, depth = 1) {
+    if (typeof value === 'string') {
+        return value.length > MAX_STRING ? `${value.slice(0, MAX_STRING)}…(+${value.length - MAX_STRING})` : value;
+    }
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (depth > MAX_DEPTH)
+        return '[depth]';
+    if (Array.isArray(value)) {
+        const kept = value.slice(0, MAX_ITEMS).map(v => truncateForLog(v, depth + 1));
+        return value.length > MAX_ITEMS ? [...kept, `…(+${value.length - MAX_ITEMS})`] : kept;
+    }
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, truncateForLog(v, depth + 1)]));
+}
+function resolveSession(env) {
+    return env.CLAUDE_CODE_SESSION_ID ?? null;
+}