codesearch-mcp 0.1.0-alpha → 0.2.1-alpha

package/dist/src/services/InfinityEmbedder.js

@@ -33,167 +33,56 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InfinityEmbedder = void 0;
-exports.serverRoot = serverRoot;
-exports.probeInfinityHealth = probeInfinityHealth;
-exports.listInfinityModels = listInfinityModels;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const child_process_1 = require("child_process");
+exports.InfinityEmbedder = exports.listInfinityModels = exports.probeInfinityHealth = exports.serverRoot = void 0;
 const LoggerService_1 = require("./LoggerService");
 const config_store_1 = require("../config-store");
 const OpenAICompatibleEmbedder_1 = require("./OpenAICompatibleEmbedder");
-/**
- * Strip trailing slashes and a trailing `/embeddings` or `/v1` to get the server
- * root — Infinity serves `/health`, `/models`, `/rerank`, `/embeddings` from the
- * root, so a baseURL written with an OpenAI-style suffix must be normalized here
- * to keep the probe/models URLs aligned with the embeddings URL.
- */
-function serverRoot(baseURL) {
-    return baseURL.replace(/\/+$/, '').replace(/\/(embeddings|v1)$/, '');
-}
-/**
- * Probe an Infinity-style `/health` endpoint. Resolves `true` when the server
- * answers with a 2xx, `false` on any error or non-2xx. Reused by setup's
- * `waitForInfinity`.
- */
-async function probeInfinityHealth(baseURL, fetchImpl = fetch, timeoutMs = 2000) {
-    try {
-        const res = await fetchImpl(`${serverRoot(baseURL)}/health`, {
-            method: 'GET',
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * List the model ids an Infinity server currently serves via its OpenAI-style
- * `/models` listing (`{ data: [{ id }] }`). Returns `[]` on any error.
- */
-async function listInfinityModels(baseURL, fetchImpl = fetch, timeoutMs = 5000) {
-    try {
-        const res = await fetchImpl(`${serverRoot(baseURL)}/models`, {
-            method: 'GET',
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        if (!res.ok)
-            return [];
-        const data = await res.json();
-        return (data.data ?? []).map(m => m.id).filter((id) => Boolean(id));
-    }
-    catch {
-        return [];
-    }
-}
+const infinity_provisioning_1 = require("./infinity-provisioning");
+Object.defineProperty(exports, "serverRoot", { enumerable: true, get: function () { return infinity_provisioning_1.serverRoot; } });
+Object.defineProperty(exports, "probeInfinityHealth", { enumerable: true, get: function () { return infinity_provisioning_1.probeInfinityHealth; } });
+Object.defineProperty(exports, "listInfinityModels", { enumerable: true, get: function () { return infinity_provisioning_1.listInfinityModels; } });
+const path = __importStar(require("path"));
 /**
  * Embedder for a local Infinity server. Inherits the OpenAI-style `/embeddings`
  * HTTP path, batching, retry, and reranker wiring from `OpenAICompatibleEmbedder`
- * unchanged — it adds ONLY container-readiness behavior (`ensureModelAvailable`),
+ * unchanged — it adds ONLY container-readiness behavior (`ensureModelAvailable`,
+ * `listModels`), delegating to the standalone `infinity-provisioning` primitive
  * because Infinity binds its model set at container startup and exposes no
  * runtime model-pull API.
  */
 class InfinityEmbedder extends OpenAICompatibleEmbedder_1.OpenAICompatibleEmbedder {
     base;
-    doFetchImpl;
-    runCommand;
     composePath;
-    pollIntervalMs;
-    log;
+    provisioningDeps;
     constructor(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
         super(config, logger, deps);
-        this.base = serverRoot(config.embedding.baseURL);
-        this.doFetchImpl = deps.fetchImpl ?? fetch;
-        this.runCommand = deps.runCommand ?? ((cmd, args, env) => {
-            const r = (0, child_process_1.spawnSync)(cmd, args, { stdio: 'inherit', env: env ? { ...process.env, ...env } : process.env });
-            return { status: r.status, stdout: r.stdout?.toString() };
-        });
+        this.base = (0, infinity_provisioning_1.serverRoot)(config.embedding.baseURL);
         this.composePath = deps.composePath ?? path.join(config_store_1.CONFIG_DIR, 'docker-compose.yml');
-        this.pollIntervalMs = deps.pollIntervalMs ?? 2000;
-        this.log = logger;
-    }
-    isHealthy() {
-        return probeInfinityHealth(this.base, this.doFetchImpl);
-    }
-    servedModels() {
-        return listInfinityModels(this.base, this.doFetchImpl);
-    }
-    /** True when a managed compose file exists AND declares an `infinity` service. */
-    hasManagedService() {
-        try {
-            const content = fs.readFileSync(this.composePath, 'utf-8');
-            return /^\s*infinity:\s*$/m.test(content);
-        }
-        catch {
-            return false;
-        }
+        this.provisioningDeps = {
+            fetchImpl: deps.fetchImpl,
+            runCommand: deps.runCommand,
+            pollIntervalMs: deps.pollIntervalMs,
+            readinessTimeoutMs: deps.readinessTimeoutMs,
+        };
     }
     /**
-     * Bring the Infinity backend to a serving state per the D4 decision tree:
-     *   healthy + model served      → OK
-     *   healthy + model NOT served  → throw (restart container with correct --model-id)
-     *   unreachable + managed        → `docker compose up -d infinity`, wait /health
-     *   unreachable + external       → print manual instructions (no Docker touched)
-     *
-     * Called by `IndexCommand` before `prepareEmbeddingSchema()`.
+     * Index-time embed readiness (see `local-backend-provisioning`): verifies only
+     * the embedding model — indexing does not use the reranker, so a missing
+     * reranker model never blocks or restarts indexing. Whenever a recreate is
+     * needed, the full configured set is written so an already-served reranker
+     * model is never dropped. Called by `IndexCommand` before indexing.
      */
     async ensureModelAvailable() {
-        const model = this.config.embedding.model;
-        if (await this.isHealthy()) {
-            const served = await this.servedModels();
-            // A server that lists no models (older Infinity, or listing disabled) is
-            // trusted — the embed request will surface a real error if the model is
-            // truly absent.
-            if (served.length === 0 || served.includes(model))
-                return;
-            throw new Error(`Infinity at ${this.base} serves [${served.join(', ')}] but embedding.model is "${model}". ` +
-                `Restart the container with the correct --model-id (e.g. recreate the managed container ` +
-                `via rag-setup, or fix embedding.model).`);
-        }
-        // Unreachable.
-        if (this.hasManagedService()) {
-            console.log(`Infinity not reachable at ${this.base} — starting the managed container...`);
-            this.log.info('InfinityEmbedder: starting managed container', { composePath: this.composePath });
-            // Bind the SAME model set the config expects (embed + reranker when enabled),
-            // so the auto-started container matches the config — otherwise compose would
-            // (re)create it with the compose default and silently drop the reranker /
-            // serve the wrong embed model. `--force-recreate` picks up a changed set.
-            const modelIds = [
-                this.config.embedding.model,
-                ...(this.config.reranker.enabled && this.config.reranker.model ? [this.config.reranker.model] : []),
-            ].join(';');
-            const r = this.runCommand('docker', ['compose', '-f', this.composePath, 'up', '-d', '--force-recreate', 'infinity'], { INFINITY_MODEL_ID: modelIds });
-            if (r.status !== 0) {
-                throw new Error(`Failed to start the managed Infinity container (docker compose exited ${r.status}). ` +
-                    `Ensure Docker is running, or start Infinity manually.`);
-            }
-            await this.waitForHealthy();
-            return;
-        }
-        throw new Error(`Infinity is not reachable at ${this.base} and no managed container is configured. ` +
-            `Start it manually, e.g.:\n` +
-            `  docker run -it --gpus all -p 7997:7997 michaelf34/infinity:latest \\\n` +
-            `    v2 --model-id ${model} --port 7997\n` +
-            `(drop --gpus all to run on CPU), or re-run rag-setup to provision it.`);
+        await (0, infinity_provisioning_1.ensureBackendReady)({
+            baseURL: this.config.embedding.baseURL,
+            requiredModels: [this.config.embedding.model],
+            modelSetToWrite: (0, infinity_provisioning_1.requiredModelSet)(this.config),
+            composePath: this.composePath,
+            deps: this.provisioningDeps,
+        });
     }
-    /**
-     * Poll `/health` until ready or the timeout elapses. Generous default (30 min)
-     * because a CPU first boot downloads the model set and runs a lengthy per-model
-     * warmup before `/health` flips to 200.
-     */
-    async waitForHealthy(maxWaitSec = 1800) {
-        console.log('Waiting for Infinity to be ready (first boot downloads + warms up the model set, this can take several minutes on CPU)...');
-        const deadline = Date.now() + maxWaitSec * 1000;
-        while (Date.now() < deadline) {
-            if (await this.isHealthy()) {
-                console.log('  ✓ Infinity ready.');
-                return;
-            }
-            await new Promise(r => setTimeout(r, this.pollIntervalMs));
-        }
-        throw new Error(`Infinity did not become ready within ${maxWaitSec}s at ${this.base}.`);
+    async listModels() {
+        return (0, infinity_provisioning_1.listInfinityModels)(this.base, this.provisioningDeps.fetchImpl ?? fetch, 2000);
     }
 }
 exports.InfinityEmbedder = InfinityEmbedder;

package/dist/src/services/LoggerService.d.ts

@@ -3,7 +3,8 @@ import type { ILogger } from '../interfaces/ILogger';
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 export declare class LoggerService implements ILogger {
     private readonly logger;
-    constructor(logger: pino.Logger);
+    private readonly metricsLogger;
+    constructor(logger: pino.Logger, metricsLogger?: pino.Logger | null);
     static silent(): LoggerService;
     static fromConfig(cfg: {
         level: string;
@@ -14,4 +15,5 @@ export declare class LoggerService implements ILogger {
     info(msg: string, data?: Record<string, unknown>): void;
     warn(msg: string, data?: Record<string, unknown>): void;
     error(msg: string, data?: Record<string, unknown>): void;
+    metric(msg: string, data?: Record<string, unknown>): void;
 }

package/dist/src/services/LoggerService.js

@@ -44,8 +44,13 @@ const fs = __importStar(require("fs"));
 const DEFAULT_LOG_DIR = path.join(os.homedir(), '.config', 'codesearch-mcp', 'logs');
 class LoggerService {
     logger;
-    constructor(logger) {
+    // Dedicated `info`-level channel for search telemetry, independent of the
+    // main logger's configured level. Null when file logging is disabled so
+    // metrics never reach stdout (owned by the MCP JSON transport).
+    metricsLogger;
+    constructor(logger, metricsLogger = null) {
         this.logger = logger;
+        this.metricsLogger = metricsLogger;
     }
     static silent() {
         return new LoggerService((0, pino_1.default)({ level: 'silent' }));
@@ -66,6 +71,10 @@ class LoggerService {
     static buildFromPath(level, filePath) {
         if (filePath)
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        // The transport target must accept `info` so the metrics channel can emit
+        // even when the main level is `warn`/`error`; the main logger still gates
+        // normal calls at `level`, so nothing else leaks below it.
+        const targetLevel = pino_1.default.levels.values[level] < pino_1.default.levels.values.info ? level : 'info';
         const transport = filePath
             ? pino_1.default.transport({
                 targets: [{
@@ -79,18 +88,23 @@ class LoggerService {
                             limit: { count: 30 },
                             size: '50m',
                         },
-                        level,
+                        level: targetLevel,
                     }],
             })
             : undefined;
         const logger = transport
             ? (0, pino_1.default)({ level }, transport)
             : (0, pino_1.default)({ level: 'silent' });
-        return new LoggerService(logger);
+        // Child logger pinned at `info` regardless of the parent level; only used by
+        // metric(). Null when there is no file transport (default stdout must stay
+        // clean for the MCP transport).
+        const metricsLogger = transport ? logger.child({}, { level: 'info' }) : null;
+        return new LoggerService(logger, metricsLogger);
     }
     debug(msg, data) { this.logger.debug(data ?? {}, msg); }
     info(msg, data) { this.logger.info(data ?? {}, msg); }
     warn(msg, data) { this.logger.warn(data ?? {}, msg); }
     error(msg, data) { this.logger.error(data ?? {}, msg); }
+    metric(msg, data) { this.metricsLogger?.info(data ?? {}, msg); }
 }
 exports.LoggerService = LoggerService;

package/dist/src/services/McpServer.js

@@ -73,8 +73,8 @@ Pick one workflow based on what you need:
 - **read_file_range** — read a specific line range from any indexed file. Expects a **relative path** as returned by search_codebase.
 - **get_dependencies** — show what files a given file imports (direct or transitive). Use to understand what a file depends on.
 - **get_dependents** — show which files import a given file (reverse graph). Use before refactoring to find all callers.
-- **find_symbol** — find where a symbol (function, class, type, interface, variable, method) is defined by exact name. Faster than semantic search when you know the name.
-- **get_callers** — find all call sites of a function or method by exact name. Uses the call graph index — faster and more precise than grep. Use after find_symbol to trace where a symbol is actually called.
+- **find_symbol** — find where a symbol is defined by exact name: top-level declarations, 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 (\`assertUsersInOrg\`), a qualified name (\`RepairsService.assertUsersInOrg\`, \`NS.Parser.parse\`) to disambiguate same-named members, a quoted name for string-literal members (\`Router.'kebab-name'\`), or a computed name (\`Stack.[Symbol.iterator]\`). Faster than semantic search when you know the name.
+- **get_callers** — find all call sites of a function or method by exact name. Accepts a bare or qualified (\`Class.method\`) symbol, using the same suffix matching as \`find_symbol\`. Uses the call graph index — faster and more precise than grep. A call through an interface-typed receiver is recorded under the interface member (e.g. \`IEmbedder.embedBatch\`), not the implementing class. Use after find_symbol to trace where a symbol is actually called.
 - **list_files** — browse the directory tree of a project path. Use to understand project structure before reading files.
 - **read_file** — read a complete file by **absolute path** with line numbers. Truncates at max_lines with a hint to continue.
 
@@ -86,7 +86,7 @@ Pick one workflow based on what you need:
 3. If a result looks **truncated or incomplete**, call \`read_file_range\` with the returned \`file_path\` and \`start_line\`.
 4. For exploratory searches where results span chunk boundaries, pass \`include_neighbors: true\`.
 5. To immediately see a file's imports and callers without extra tool calls, pass \`include_graph_context: true\` to \`search_codebase\`. Use this when doing a quick structural survey; switch to \`get_dependencies\`/\`get_dependents\` for full transitive graphs.
-6. Use \`find_symbol\` when you know the exact name — faster than semantic search. Use \`kind: "method"\` for class methods — grep matches lines where \`public\`, \`async\`, \`static\`, or \`override\` appears before the name. After locating a symbol, use \`get_callers\` to find all call sites — faster and more precise than grep (requires \`rag-index backfill --calls\` to have been run).
+6. Use \`find_symbol\` when you know the exact name — faster than semantic search. Use a qualified name (\`Class.method\`) to disambiguate same-named methods of different classes; a bare name searches every container. Hits marked \`(grep — not in index; may be stale or imprecise)\` come from a fallback text search, not the index — treat them as less reliable. After locating a symbol, use \`get_callers\` to find all call sites — faster and more precise than grep.
 7. Use \`list_files\` to explore project structure before diving into files. Use \`read_file\` to read a complete file by absolute path.
 
 ### Flow audit (mandatory steps — do not skip 3 and 4)

package/dist/src/services/SearcherService.d.ts

@@ -55,7 +55,7 @@ export interface GrepMatch {
     filePath: string;
     line: number;
 }
-export type SymbolKind = 'function' | 'class' | 'type' | 'interface' | 'variable' | 'method' | 'all';
+export type SymbolKind = 'function' | 'class' | 'type' | 'interface' | 'variable' | 'method' | 'get_accessor' | 'set_accessor' | 'constructor' | 'function_property' | 'method_signature' | 'all';
 export interface CallerRow {
     fromFile: string;
     fromSymbol: string | null;
@@ -69,6 +69,10 @@ export interface SymbolHit {
     column: number;
     kind: Exclude<SymbolKind, 'all'>;
     signature: string;
+    /** `container.name`, or `name` when the container is null. */
+    qualified: string;
+    isStatic: boolean;
+    source: 'index' | 'grep';
 }
 export declare class SearcherService {
     private db;
@@ -106,16 +110,38 @@ export declare class SearcherService {
     /**
      * Refuse when the configured embedding model disagrees with the one that built
      * the index — embedding a query into a foreign vector space returns noise. A
-     * missing `index_meta` (un-migrated DB / not yet indexed) does not block.
+     * missing `index_meta` row with an empty (or altogether absent) `code_chunk`
+     * does not block — but a *populated* `code_chunk` with no `index_meta` row is a
+     * pre-`index_meta` install, treated as the legacy `ollama`/`bge-m3` index (same
+     * interpretation as the `rag-index` legacy-Ollama guard), read-only — this check
+     * never writes `index_meta`.
      */
     assertIndexMatches(): Promise<void>;
+    private compareIndexed;
     listProjects(): Promise<ProjectRow[]>;
     searchChunks(query: string, limit: number, project: string | null, threshold?: number): Promise<SearchResult[]>;
+    /**
+     * Emit one structured search-tuning line (via `logger.metric`, at `info`
+     * regardless of `logging.level`). `candidates` are in cosine order, so a
+     * candidate's array index is its cosine rank — `maxCosineRankSurvived` is the
+     * deepest cosine position that survived reranking into the returned set. Read
+     * it alongside `poolSaturated` to tune `candidateFloor`/`overfetch`/threshold
+     * per hardware. Never logs chunk content, embeddings, or credentials.
+     */
+    private emitSearchMetrics;
     fetchNeighbors(results: SearchResult[]): Promise<NeighborResult[]>;
     fetchGraphContext(results: SearchResult[]): Promise<Map<string, GraphContext>>;
     getDependencies(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
     getDependents(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
     getCallers(symbol: string, project: string, calleeFile?: string | null): Promise<CallerRow[]>;
+    /**
+     * One-line warning when any project in `scope` (the given `project`, or
+     * every project with `code_chunk`/`code_symbol` rows) is outdated — shown
+     * first in `find_symbol`/`get_callers` output. Any failure to determine the
+     * scope or read markers only drops the notice (warn logged); the lookup
+     * itself is unaffected.
+     */
+    outdatedNotice(project: string | null): Promise<string | null>;
     grepSymbol(symbol: string, project: string, excludeFile: string): Promise<{
         matches: GrepMatch[];
         truncated: boolean;
@@ -123,6 +149,7 @@ export declare class SearcherService {
     findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<{
         hits: SymbolHit[];
         truncated: boolean;
+        grepFailed: boolean;
     }>;
     private findSymbolFromIndex;
     private grepFindSymbol;
@@ -133,11 +160,19 @@ export declare class SearcherService {
     readFileAbsolute(absPath: string, maxLines: number): Promise<FileRangeResult>;
     readFileRange(filePath: string, startLine: number, endLine: number): Promise<FileRangeResult>;
     private walkDir;
+    /**
+     * ERE pattern for a grep-fallback kind, or null when that kind is never
+     * grepped (`function_property`/`method_signature` are index-only; a bare
+     * `constructor` search only makes sense when the name itself is `constructor`).
+     */
     private buildFindSymbolPattern;
+    /** 1-based index of the first whole-word occurrence of `name` in `line`, or -1. */
+    private static wholeWordIndex;
     private inferKind;
     /**
-     * Async wrapper around grep to avoid blocking the event loop.
-     * Returns stdout as a string, or null if grep returned no results or errored.
+     * Async wrapper around grep to avoid blocking the event loop. `ok: false`
+     * means grep could not be spawned or exited with status ≥ 2 (distinguishable
+     * from a clean "no matches", which is `ok: true, output: null`).
      */
     private spawnGrep;
 }