codesearch-mcp 0.2.2-alpha → 0.3.0-alpha

package/dist/src/setup.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EMBEDDING_PROVIDER_CHOICES = void 0;
 exports.dockerPromptDefault = dockerPromptDefault;
+exports.rerankerChoices = rerankerChoices;
+exports.promptReranker = promptReranker;
 exports.prepareComposeAndStartDb = prepareComposeAndStartDb;
 exports.provisionInfinity = provisionInfinity;
 exports.runSetup = runSetup;
@@ -43,6 +45,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");
@@ -68,51 +71,115 @@ 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' },
+    'voyage': { baseURL: 'https://api.voyageai.com/v1', model: 'voyage-code-4', 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))
         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_RERANK_ENV = 'VOYAGE_RERANK_API_KEY';
+const RERANKER_ENV = 'RERANKER_API_KEY';
+function rerankerChoices(embProvider) {
+    if (embProvider === 'infinity')
+        return ['infinity', 'voyage', 'openai-compatible', 'none'];
+    if (embProvider === 'voyage')
+        return ['voyage', 'openai-compatible', 'none'];
+    return ['none', 'voyage', 'openai-compatible'];
+}
+async function askRequired(io, question) {
+    for (;;) {
+        const answer = (await io.ask(question)).trim();
+        if (answer)
+            return answer;
+        io.log('  A value is required.');
+    }
+}
+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 waitForDb(host, port, user, pass, db, maxWaitSec = 60, logger, steps) {
     const { Client } = await Promise.resolve().then(() => __importStar(require('pg')));
@@ -147,18 +214,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 +227,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 +240,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 +257,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 +283,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;
@@ -311,12 +354,6 @@ async function runSetup(logger) {
     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();
@@ -330,6 +367,9 @@ async function runSetup(logger) {
             console.log(`  No key entered — set it later: echo '${pd.envVar}=sk-…' >> ${config_store_1.ENV_FILE}`);
         }
     }
+    const reranker = await promptReranker(embProvider, embBaseURL, {
+        prompt: loggedPrompt, ask: loggedAsk, writeEnvKey, log: msg => console.log(msg),
+    });
     console.log('\n--- Database ---');
     const dbHost = await loggedPrompt('DB host', 'localhost');
     const dbPort = await loggedPrompt('DB port', '5433');
@@ -339,8 +379,6 @@ 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);
     if (isLocalBackend(embProvider)) {
@@ -400,26 +438,15 @@ async function runSetup(logger) {
             model: embModel,
             ...(apiKeyRef ? { apiKey: apiKeyRef } : {}),
         },
+        reranker,
         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);
     }
@@ -438,7 +465,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

@@ -16,22 +16,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 +29,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

@@ -11,22 +11,15 @@ 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);
@@ -47,11 +40,6 @@ 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 parseCallerSymbol(input) {
     if (exports.QUALIFIED_NAME_RE.test(input)) {
         const { container, name } = splitQualified(input);
@@ -62,7 +50,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,12 +1,3 @@
 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[];
+export type CodeSymbolRow = Pick<SymbolEntry, 'project' | 'filePath' | 'name' | 'kind' | 'signature' | 'line' | 'col' | 'container' | 'isStatic' | 'target'>;
+export declare function buildSymbolRows(symbols: SymbolEntry[], members: SymbolEntry[], graphqlNames?: SymbolEntry[]): CodeSymbolRow[];

package/dist/src/symbol-rows.js

@@ -1,16 +1,7 @@
 "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) {
+function buildSymbolRows(symbols, members, graphqlNames = []) {
     const groups = new Map();
     for (const entry of [...symbols, ...members]) {
         const key = JSON.stringify([entry.container, entry.name, entry.kind, entry.isStatic]);
@@ -30,9 +21,10 @@ function buildSymbolRows(symbols, members) {
         collapsed.push(implementation ?? group.reduce((a, b) => ((a.line ?? 0) <= (b.line ?? 0) ? a : b)));
     }
     const dedup = new Map();
-    for (const entry of collapsed) {
+    for (const entry of [...collapsed, ...graphqlNames]) {
         const key = JSON.stringify([entry.container, entry.name, entry.kind, entry.line]);
-        dedup.set(key, entry);
+        if (!dedup.has(key))
+            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 }));
+    return [...dedup.values()].map(({ project, filePath, name, kind, signature, line, col, container, isStatic, target }) => ({ project, filePath, name, kind, signature, line, col, container, isStatic, target: target ?? null }));
 }

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;
+}

package/dist/src/tools/FindSymbolTool.js

@@ -5,8 +5,14 @@ const format_helpers_1 = require("./format-helpers");
 const VALID_KINDS = [
     'function', 'class', 'type', 'interface', 'variable',
     'method', 'get_accessor', 'set_accessor', 'constructor', 'function_property', 'method_signature',
+    'graphql_query', 'graphql_mutation', 'graphql_subscription', 'graphql_field', 'graphql_type',
     'all',
 ];
+const GRAPHQL_KINDS = new Set([
+    'graphql_query', 'graphql_mutation', 'graphql_subscription', 'graphql_field', 'graphql_type',
+]);
+const GRAPHQL_STALE_INDEX_HINT = 'Files indexed before GraphQL indexing was added have no GraphQL rows until `rag-index --reindex` — ' +
+    'this miss does not prove the name is absent.';
 class FindSymbolTool {
     searcher;
     constructor(searcher) {
@@ -20,7 +26,10 @@ class FindSymbolTool {
                 '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.',
+                'want its definition location fast. Also finds a NestJS GraphQL operation (`@Query`/`@Mutation`/`@Subscription`), ' +
+                'resolve field (`@ResolveField`) or type (`@ObjectType`/`@InputType`/`@InterfaceType`) by its GraphQL name — the ' +
+                'name the schema exposes, which may differ from the TypeScript declaration name. Pass the matching `graphql_*` ' +
+                'kind when the name comes from a schema, a GraphQL document or a frontend.',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -45,21 +54,21 @@ class FindSymbolTool {
             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}`);
+            if (GRAPHQL_KINDS.has(kind))
+                lines.push(GRAPHQL_STALE_INDEX_HINT);
             return (0, format_helpers_1.textResponse)(lines.join('\n'));
         }
         if (truncated)
             lines.push(`*(truncated to ${hits.length} results)*\n`);
         for (const h of hits) {
             const staticTag = h.isStatic ? ' static' : '';
+            const targetTag = h.target ? ` → \`${h.target}\`` : '';
             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(`**${h.kind}** \`${h.qualified}\`${staticTag}${targetTag} \`${h.filePath}\` line ${h.line}, col ${h.column}${grepTag}`);
             lines.push(`\`\`\`\n${h.signature}\n\`\`\``);
         }
         return (0, format_helpers_1.textResponse)(lines.join('\n'));

package/dist/src/tools/GetCallersTool.d.ts

@@ -1,8 +1,10 @@
 import type { IMcpToolHandler, ToolDefinition, ToolResponse } from '../interfaces/IMcpToolHandler';
 import type { ISearcher } from '../interfaces/ISearcher';
+import type { ILogger } from '../interfaces/ILogger';
 export declare class GetCallersTool implements IMcpToolHandler {
     private searcher;
-    constructor(searcher: ISearcher);
+    private logger;
+    constructor(searcher: ISearcher, logger: ILogger);
     definition(): ToolDefinition;
     handle(args: Record<string, unknown>): Promise<ToolResponse>;
 }

package/dist/src/tools/GetCallersTool.js

@@ -4,8 +4,10 @@ exports.GetCallersTool = void 0;
 const format_helpers_1 = require("./format-helpers");
 class GetCallersTool {
     searcher;
-    constructor(searcher) {
+    logger;
+    constructor(searcher, logger) {
         this.searcher = searcher;
+        this.logger = logger;
     }
     definition() {
         return {
@@ -20,7 +22,7 @@ class GetCallersTool {
                 properties: {
                     symbol: { type: 'string', description: 'Bare or qualified (Class.method) function/method name (case-sensitive)' },
                     project: { type: 'string', description: 'Project name (from list_projects)' },
-                    callee_file: { type: 'string', description: 'Optional: filter by definition file path (as returned by find_symbol) to disambiguate overloaded names' },
+                    callee_file: { type: 'string', description: `Optional: only calls to the definition in this file, to disambiguate overloaded names. ${(0, format_helpers_1.pathArgDescription)()}` },
                 },
                 required: ['symbol', 'project'],
             },
@@ -29,7 +31,18 @@ class GetCallersTool {
     async handle(args) {
         const symbol = String(args.symbol ?? '');
         const project = String(args.project ?? '');
-        const calleeFile = args.callee_file ? String(args.callee_file) : null;
+        const rawCallee = args.callee_file;
+        let calleeFile = null;
+        if (rawCallee != null && rawCallee !== '') {
+            const input = String(rawCallee);
+            const resolved = await this.searcher.resolveToolPath(input);
+            if (!resolved.ok)
+                return (0, format_helpers_1.pathErrorResponse)(this.logger, 'get_callers', 'callee_file', input, input, resolved);
+            const failure = await this.searcher.checkGraphPath(resolved.relPath);
+            if (failure)
+                return (0, format_helpers_1.pathErrorResponse)(this.logger, 'get_callers', 'callee_file', input, resolved.relPath, failure);
+            calleeFile = resolved.relPath;
+        }
         let rows;
         try {
             rows = await this.searcher.getCallers(symbol, project, calleeFile);
@@ -37,10 +50,7 @@ class GetCallersTool {
         catch (err) {
             return (0, format_helpers_1.errorResponse)(err.message);
         }
-        const notice = await this.searcher.outdatedNotice(project);
         const lines = [];
-        if (notice)
-            lines.push(notice + '\n');
         if (rows.length === 0) {
             lines.push(`No call sites found for \`${symbol}\` in project \`${project}\`. Run \`rag-index --reindex\` if the call graph has not been populated yet.`);
             return (0, format_helpers_1.textResponse)(lines.join('\n'));

package/dist/src/tools/GetDependenciesTool.d.ts

@@ -1,8 +1,10 @@
 import type { IMcpToolHandler, ToolDefinition, ToolResponse } from '../interfaces/IMcpToolHandler';
 import type { ISearcher } from '../interfaces/ISearcher';
+import type { ILogger } from '../interfaces/ILogger';
 export declare class GetDependenciesTool implements IMcpToolHandler {
     private searcher;
-    constructor(searcher: ISearcher);
+    private logger;
+    constructor(searcher: ISearcher, logger: ILogger);
     definition(): ToolDefinition;
     handle(args: Record<string, unknown>): Promise<ToolResponse>;
 }

package/dist/src/tools/GetDependenciesTool.js

@@ -4,32 +4,39 @@ exports.GetDependenciesTool = void 0;
 const format_helpers_1 = require("./format-helpers");
 class GetDependenciesTool {
     searcher;
-    constructor(searcher) {
+    logger;
+    constructor(searcher, logger) {
         this.searcher = searcher;
+        this.logger = logger;
     }
     definition() {
         return {
             name: 'get_dependencies',
-            description: 'Show what files a given file imports (direct or transitive). Use to understand what a file depends on before modifying it. depType values: import | import-default | import-namespace | reexport | reexport-namespace.',
+            description: 'Show what files a given file imports (direct or transitive), in any project. Use to understand what a file depends on before modifying it. The direct section prints one line per imported file, with the names imported from it.',
             inputSchema: {
                 type: 'object',
                 properties: {
-                    file_path: { type: 'string', description: 'File path as returned by search_codebase' },
-                    project: { type: 'string', description: 'Project name (use list_projects to find it)' },
+                    file_path: { type: 'string', description: (0, format_helpers_1.pathArgDescription)() },
                     symbol: { type: 'string', description: 'Filter to a specific imported symbol name (optional)' },
                     transitive: { type: 'boolean', description: 'Include transitive (indirect) dependencies. Default: false.' },
                 },
-                required: ['file_path', 'project'],
+                required: ['file_path'],
             },
         };
     }
     async handle(args) {
-        const filePath = String(args.file_path);
-        const project = String(args.project);
+        const input = args.file_path == null ? '' : String(args.file_path);
         const symbol = args.symbol ? String(args.symbol) : null;
         const transitive = Boolean(args.transitive);
-        const rows = await this.searcher.getDependencies(filePath, project, symbol, transitive);
+        const resolved = await this.searcher.resolveToolPath(input);
+        if (!resolved.ok)
+            return (0, format_helpers_1.pathErrorResponse)(this.logger, 'get_dependencies', 'file_path', input, input, resolved);
+        const filePath = resolved.relPath;
+        const rows = await this.searcher.getDependencies(filePath, symbol, transitive);
         if (rows.length === 0) {
+            const failure = await this.searcher.checkGraphPath(filePath);
+            if (failure)
+                return (0, format_helpers_1.pathErrorResponse)(this.logger, 'get_dependencies', 'file_path', input, filePath, failure);
             return (0, format_helpers_1.textResponse)(`No dependencies found for: ${filePath}`);
         }
         return (0, format_helpers_1.textResponse)((0, format_helpers_1.formatDependencies)(filePath, rows, transitive));