@tai-io/codesearch 2026.313.1614

package/dist/core/targeted-indexer.js

@@ -0,0 +1,127 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { AstSplitter } from '../splitter/ast.js';
+import { LineSplitter } from '../splitter/line.js';
+import { extensionToLanguage, buildSnapshot } from './sync.js';
+import { getConfig } from '../config.js';
+import { normalizePath, pathToCollectionName } from '../paths.js';
+import { classifyFileCategory } from './file-category.js';
+import { loadSnapshot, saveSnapshot } from '../vectordb/sqlite.js';
+/**
+ * Re-index a specific set of files within a project.
+ * For each file: delete stale vectors, re-split, re-embed, re-insert, update snapshot.
+ *
+ * @param rootPath       Absolute path to the project root
+ * @param relativePaths  Relative paths (from rootPath) of files to re-index
+ * @param embedding      Embedding provider
+ * @param vectordb       Vector DB provider
+ */
+export async function indexFiles(rootPath, relativePaths, embedding, vectordb) {
+    const start = Date.now();
+    const normalizedRoot = normalizePath(rootPath);
+    const collectionName = pathToCollectionName(normalizedRoot);
+    const config = getConfig();
+    // Skip if the collection doesn't exist (codebase never indexed)
+    if (!(await vectordb.hasCollection(collectionName))) {
+        process.stderr.write(`[targeted-indexer] No collection for ${normalizedRoot} — codebase not indexed, skipping.\n`);
+        return {
+            processedFiles: 0,
+            totalChunks: 0,
+            skippedFiles: relativePaths.length,
+            durationMs: Date.now() - start,
+        };
+    }
+    const astSplitter = new AstSplitter();
+    const lineSplitter = new LineSplitter();
+    const allChunks = [];
+    const processedPaths = [];
+    const deletedPaths = [];
+    let skippedFiles = 0;
+    // Step 1: delete stale vectors and split files
+    const concurrency = config.indexingConcurrency;
+    for (let i = 0; i < relativePaths.length; i += concurrency) {
+        const batch = relativePaths.slice(i, i + concurrency);
+        const batchResults = await Promise.all(batch.map(async (relPath) => {
+            // Always remove stale vectors first
+            await vectordb.deleteByPath(collectionName, relPath);
+            const fullPath = path.join(normalizedRoot, relPath);
+            let code;
+            try {
+                code = fs.readFileSync(fullPath, 'utf-8');
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    // File was deleted — vectors removed, skip re-embedding
+                    return { relPath, chunks: [], deleted: true };
+                }
+                throw err;
+            }
+            if (code.trim().length === 0)
+                return { relPath, chunks: [], deleted: false };
+            const ext = path.extname(relPath);
+            const language = extensionToLanguage(ext);
+            let chunks = astSplitter.split(code, language, relPath);
+            if (chunks.length === 0) {
+                chunks = lineSplitter.split(code, language, relPath);
+            }
+            return { relPath, chunks, deleted: false };
+        }));
+        for (const { relPath, chunks, deleted } of batchResults) {
+            if (deleted) {
+                deletedPaths.push(relPath);
+                skippedFiles++;
+            }
+            else {
+                allChunks.push(...chunks);
+                processedPaths.push(relPath);
+            }
+        }
+    }
+    // Step 2: embed and insert chunks
+    const batchSize = config.embeddingBatchSize;
+    let totalChunks = 0;
+    for (let i = 0; i < allChunks.length; i += batchSize) {
+        const batch = allChunks.slice(i, i + batchSize);
+        const texts = batch.map((c) => c.content);
+        const vectors = await embedding.embedBatch(texts);
+        const documents = batch.map((chunk, j) => ({
+            id: randomUUID(),
+            content: chunk.content,
+            vector: vectors[j],
+            relativePath: chunk.filePath,
+            startLine: chunk.startLine,
+            endLine: chunk.endLine,
+            fileExtension: path.extname(chunk.filePath),
+            language: chunk.language,
+            fileCategory: classifyFileCategory(chunk.filePath),
+            symbolName: chunk.symbolName,
+            symbolKind: chunk.symbolKind,
+            symbolSignature: chunk.symbolSignature,
+            parentSymbol: chunk.parentSymbol,
+        }));
+        await vectordb.insert(collectionName, documents);
+        totalChunks += batch.length;
+    }
+    // Step 3: update snapshot — refresh hashes for processed files, remove deleted
+    const snapshot = loadSnapshot(normalizedRoot);
+    if (snapshot) {
+        const freshSnapshot = buildSnapshot(normalizedRoot, processedPaths);
+        for (const relPath of processedPaths) {
+            if (freshSnapshot[relPath]) {
+                snapshot[relPath] = freshSnapshot[relPath];
+            }
+        }
+        for (const relPath of deletedPaths) {
+            Reflect.deleteProperty(snapshot, relPath);
+        }
+        saveSnapshot(normalizedRoot, snapshot);
+    }
+    return {
+        processedFiles: processedPaths.length,
+        totalChunks,
+        skippedFiles,
+        durationMs: Date.now() - start,
+    };
+}
+//# sourceMappingURL=targeted-indexer.js.map

package/dist/embedding/factory.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../config.js';
+import type { Embedding } from './types.js';
+export declare function createEmbedding(config: Config): Embedding;
+//# sourceMappingURL=factory.d.ts.map

package/dist/embedding/factory.js

@@ -0,0 +1,24 @@
+import { OpenAIEmbedding } from './openai.js';
+export function createEmbedding(config) {
+    switch (config.embeddingProvider) {
+        case 'openai':
+            return new OpenAIEmbedding();
+        case 'ollama':
+            return new OpenAIEmbedding({
+                apiKey: config.openaiApiKey || 'ollama',
+                baseUrl: config.ollamaBaseUrl,
+                model: config.embeddingModel,
+            });
+        case 'local':
+            return new OpenAIEmbedding({
+                apiKey: config.openaiApiKey || 'local',
+                baseUrl: config.openaiBaseUrl,
+                model: config.embeddingModel,
+            });
+        default: {
+            const _exhaustive = config.embeddingProvider;
+            throw new Error(`Unknown embedding provider: ${_exhaustive}`);
+        }
+    }
+}
+//# sourceMappingURL=factory.js.map

package/dist/embedding/openai.d.ts

@@ -0,0 +1,33 @@
+import { type Embedding, type EmbeddingVector, type TokenEstimate } from './types.js';
+export declare function contentHash(text: string): string;
+export interface OpenAIEmbeddingOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+}
+export declare class OpenAIEmbedding implements Embedding {
+    private client;
+    private model;
+    private _dimension;
+    private initialized;
+    private memoryCache;
+    private cacheDir;
+    constructor(options?: OpenAIEmbeddingOptions);
+    get dimension(): number;
+    /**
+     * Validate the API key and detect embedding dimension by embedding a test string.
+     * Must be called once before any other operations.
+     */
+    initialize(): Promise<void>;
+    private ensureInitialized;
+    embed(text: string): Promise<EmbeddingVector>;
+    embedBatch(texts: string[]): Promise<EmbeddingVector[]>;
+    estimateTokens(texts: string[]): TokenEstimate;
+    private setMemoryCache;
+    private callWithRetry;
+    private callApi;
+    private getDiskCachePath;
+    private readDiskCache;
+    private writeDiskCache;
+}
+//# sourceMappingURL=openai.d.ts.map

package/dist/embedding/openai.js

@@ -0,0 +1,234 @@
+import { createHash } from 'node:crypto';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import OpenAI from 'openai';
+import { EmbeddingError } from '../errors.js';
+import { getConfig } from '../config.js';
+import { getCacheDir } from '../paths.js';
+import { truncateToSafeLength } from './truncate.js';
+const RETRY_DELAYS = [1000, 4000, 16000]; // exponential backoff
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503]);
+const MAX_MEMORY_CACHE_SIZE = 10_000;
+const MAX_RETRY_AFTER_MS = 60_000;
+export function contentHash(text) {
+    return createHash('sha256').update(text).digest('hex').slice(0, 16);
+}
+export class OpenAIEmbedding {
+    client;
+    model;
+    _dimension = 0;
+    initialized = false;
+    memoryCache = new Map();
+    cacheDir;
+    constructor(options) {
+        const config = getConfig();
+        const apiKey = options?.apiKey ?? config.openaiApiKey;
+        const baseUrl = options?.baseUrl ?? config.openaiBaseUrl;
+        this.client = new OpenAI({
+            apiKey,
+            ...(baseUrl && { baseURL: baseUrl }),
+        });
+        this.model = options?.model ?? config.embeddingModel;
+        this.cacheDir = path.join(getCacheDir(), 'embeddings');
+    }
+    get dimension() {
+        return this._dimension;
+    }
+    /**
+     * Validate the API key and detect embedding dimension by embedding a test string.
+     * Must be called once before any other operations.
+     */
+    async initialize() {
+        try {
+            const result = await this.callApi(['dimension probe']);
+            this._dimension = result[0].length;
+            this.initialized = true;
+            console.log(`Embedding model "${this.model}" validated. Dimension: ${this._dimension}`);
+        }
+        catch (err) {
+            throw new EmbeddingError(`Failed to initialize embedding provider. Check your API key, base URL, and model name. ` +
+                `Model: "${this.model}"`, err);
+        }
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new EmbeddingError('Embedding provider not initialized. Call initialize() before embed/embedBatch.');
+        }
+    }
+    async embed(text) {
+        this.ensureInitialized();
+        const results = await this.embedBatch([text]);
+        return results[0];
+    }
+    async embedBatch(texts) {
+        this.ensureInitialized();
+        if (texts.length === 0)
+            return [];
+        // Track which indices have empty/whitespace-only text so we return zero vectors for them
+        const emptyIndices = new Set();
+        for (let i = 0; i < texts.length; i++) {
+            if (texts[i].trim().length === 0) {
+                emptyIndices.add(i);
+            }
+        }
+        const results = Array.from({
+            length: texts.length,
+        }).fill(null);
+        // Fill empty-text slots with zero vectors immediately
+        for (const i of emptyIndices) {
+            results[i] = new Array(this._dimension).fill(0);
+        }
+        // Check caches for non-empty texts
+        for (let i = 0; i < texts.length; i++) {
+            if (emptyIndices.has(i))
+                continue;
+            const hash = contentHash(texts[i]);
+            const memHit = this.memoryCache.get(hash);
+            if (memHit) {
+                results[i] = memHit;
+                continue;
+            }
+            const diskHit = await this.readDiskCache(hash);
+            if (diskHit) {
+                this.setMemoryCache(hash, diskHit);
+                results[i] = diskHit;
+            }
+        }
+        const uncachedIndices = [];
+        const uncachedTexts = [];
+        for (let i = 0; i < texts.length; i++) {
+            if (results[i] === null) {
+                uncachedIndices.push(i);
+                uncachedTexts.push(texts[i]);
+            }
+        }
+        if (uncachedTexts.length === 0) {
+            return results;
+        }
+        const batchSize = getConfig().embeddingBatchSize;
+        const freshEmbeddings = [];
+        for (let offset = 0; offset < uncachedTexts.length; offset += batchSize) {
+            const batch = uncachedTexts.slice(offset, offset + batchSize);
+            const batchResult = await this.callWithRetry(batch);
+            freshEmbeddings.push(...batchResult);
+        }
+        for (let i = 0; i < uncachedIndices.length; i++) {
+            const idx = uncachedIndices[i];
+            const hash = contentHash(texts[idx]);
+            const vec = freshEmbeddings[i];
+            this.setMemoryCache(hash, vec);
+            this.writeDiskCache(hash, vec);
+            results[idx] = vec;
+        }
+        if (results.some((r) => r === null)) {
+            throw new EmbeddingError('Missing embeddings: some texts did not receive vectors after cache lookup and API call.');
+        }
+        return results;
+    }
+    estimateTokens(texts) {
+        const totalChars = texts.reduce((sum, t) => sum + t.length, 0);
+        const estimatedTokens = Math.ceil(totalChars / 4);
+        // Per-million-token pricing for known OpenAI models; local models are free
+        const COST_PER_MILLION = {
+            'text-embedding-3-small': 0.02,
+            'text-embedding-3-large': 0.13,
+            'text-embedding-ada-002': 0.1,
+        };
+        const rate = COST_PER_MILLION[this.model] ?? 0;
+        const estimatedCostUsd = (estimatedTokens / 1_000_000) * rate;
+        return { totalChars, estimatedTokens, estimatedCostUsd };
+    }
+    setMemoryCache(hash, vec) {
+        if (this.memoryCache.size >= MAX_MEMORY_CACHE_SIZE && !this.memoryCache.has(hash)) {
+            // Delete the oldest entry (first key from the iterator)
+            const oldest = this.memoryCache.keys().next().value;
+            if (oldest !== undefined) {
+                this.memoryCache.delete(oldest);
+            }
+        }
+        this.memoryCache.set(hash, vec);
+    }
+    async callWithRetry(texts) {
+        let currentBatchSize = texts.length;
+        const allResults = [];
+        let startOffset = 0;
+        for (let attempt = 0; attempt < RETRY_DELAYS.length + 1; attempt++) {
+            try {
+                for (let offset = startOffset; offset < texts.length; offset += currentBatchSize) {
+                    const batch = texts.slice(offset, offset + currentBatchSize);
+                    const result = await this.callApi(batch);
+                    allResults.push(...result);
+                    startOffset = offset + currentBatchSize;
+                }
+                return allResults;
+            }
+            catch (err) {
+                const status = err.status;
+                const isRetryable = status !== undefined && RETRYABLE_STATUS.has(status);
+                if (!isRetryable || attempt >= RETRY_DELAYS.length) {
+                    throw new EmbeddingError(`Embedding API call failed after ${attempt + 1} attempt(s). Status: ${status ?? 'unknown'}`, err);
+                }
+                let delay = RETRY_DELAYS[attempt];
+                if (status === 429) {
+                    const retryAfter = err.headers?.['retry-after'];
+                    if (retryAfter) {
+                        const parsed = parseInt(retryAfter, 10);
+                        if (!isNaN(parsed))
+                            delay = Math.min(parsed * 1000, MAX_RETRY_AFTER_MS);
+                    }
+                    // Halve batch size on rate limit to avoid repeated throttling
+                    currentBatchSize = Math.max(1, Math.floor(currentBatchSize / 2));
+                    console.warn(`Rate limited. Retrying in ${delay}ms with batch size ${currentBatchSize}.`);
+                }
+                else {
+                    console.warn(`Embedding API error (status ${status}). Retrying in ${delay}ms...`);
+                }
+                await sleep(delay);
+            }
+        }
+        throw new EmbeddingError('Unexpected: exhausted retries');
+    }
+    async callApi(texts) {
+        const response = await this.client.embeddings.create({
+            model: this.model,
+            input: texts.map(truncateToSafeLength),
+        });
+        const sorted = response.data.sort((a, b) => a.index - b.index);
+        return sorted.map((d) => d.embedding);
+    }
+    getDiskCachePath(hash) {
+        // Shard into subdirectories to avoid too many files in one dir
+        const shard = hash.slice(0, 2);
+        return path.join(this.cacheDir, this.model.replace(/[^a-zA-Z0-9-]/g, '_'), shard, `${hash}.json`);
+    }
+    async readDiskCache(hash) {
+        const filepath = this.getDiskCachePath(hash);
+        try {
+            const data = await fsp.readFile(filepath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'ENOENT') {
+                // File doesn't exist -- normal cache miss
+                return null;
+            }
+            // Parse error or other I/O problem: warn and remove corrupted file
+            console.warn(`Corrupted embedding cache file ${filepath}, deleting.`);
+            fsp.unlink(filepath).catch(() => { });
+            return null;
+        }
+    }
+    writeDiskCache(hash, vector) {
+        const filepath = this.getDiskCachePath(hash);
+        // Fire-and-forget async write
+        fsp
+            .mkdir(path.dirname(filepath), { recursive: true })
+            .then(() => fsp.writeFile(filepath, JSON.stringify(vector)))
+            .catch(() => { });
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=openai.js.map

package/dist/embedding/truncate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Truncate text to stay within the embedding model's token limit.
+ * Cuts at the last newline boundary to avoid splitting mid-line.
+ */
+export declare function truncateToSafeLength(text: string): string;
+//# sourceMappingURL=truncate.d.ts.map

package/dist/embedding/truncate.js

@@ -0,0 +1,14 @@
+// Safety margin below 8,191 token limit (~4 chars/token for code)
+const MAX_EMBED_CHARS = 6000;
+/**
+ * Truncate text to stay within the embedding model's token limit.
+ * Cuts at the last newline boundary to avoid splitting mid-line.
+ */
+export function truncateToSafeLength(text) {
+    if (text.length <= MAX_EMBED_CHARS)
+        return text;
+    const truncated = text.slice(0, MAX_EMBED_CHARS);
+    const lastNewline = truncated.lastIndexOf('\n');
+    return lastNewline > 0 ? truncated.slice(0, lastNewline) : truncated;
+}
+//# sourceMappingURL=truncate.js.map

package/dist/embedding/types.d.ts

@@ -0,0 +1,18 @@
+export type EmbeddingVector = number[];
+export interface TokenEstimate {
+    totalChars: number;
+    estimatedTokens: number;
+    estimatedCostUsd: number;
+}
+export interface Embedding {
+    /**
+     * Validate provider connectivity and detect embedding dimension.
+     * Must be called once before any embed/embedBatch operations.
+     */
+    initialize(): Promise<void>;
+    embed(text: string): Promise<EmbeddingVector>;
+    embedBatch(texts: string[]): Promise<EmbeddingVector[]>;
+    estimateTokens(texts: string[]): TokenEstimate;
+    readonly dimension: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/embedding/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class CodesearchError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare class ConfigError extends CodesearchError {
+}
+export declare class EmbeddingError extends CodesearchError {
+}
+export declare class VectorDBError extends CodesearchError {
+}
+export declare class IndexingError extends CodesearchError {
+}
+export declare class SearchError extends CodesearchError {
+}
+export declare class BootstrapError extends CodesearchError {
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,21 @@
+export class CodesearchError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = this.constructor.name;
+    }
+}
+export class ConfigError extends CodesearchError {
+}
+export class EmbeddingError extends CodesearchError {
+}
+export class VectorDBError extends CodesearchError {
+}
+export class IndexingError extends CodesearchError {
+}
+export class SearchError extends CodesearchError {
+}
+export class BootstrapError extends CodesearchError {
+}
+//# sourceMappingURL=errors.js.map

package/dist/format.d.ts

@@ -0,0 +1,18 @@
+import type { CleanupResult } from './core/cleanup.js';
+import type { PreviewResult, IndexResult } from './core/indexer.js';
+import type { DocIndexResult } from './core/doc-indexer.js';
+import type { DocSearchResult } from './core/doc-searcher.js';
+import type { CodebaseState } from './state/snapshot.js';
+export declare function textResult(text: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export declare function formatCleanupResult(result: CleanupResult, normalizedPath: string, dryRun: boolean): string;
+export declare function formatIndexResult(result: IndexResult, normalizedPath: string): string;
+export declare function formatPreview(preview: PreviewResult, rootPath: string): string;
+export declare function formatListIndexed(states: CodebaseState[]): string;
+export declare function formatDocIndexResult(result: DocIndexResult): string;
+export declare function formatDocSearchResults(results: DocSearchResult[], query: string): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/format.js

@@ -0,0 +1,151 @@
+import { listProjects } from './state/registry.js';
+export function textResult(text) {
+    return { content: [{ type: 'text', text }] };
+}
+export function formatCleanupResult(result, normalizedPath, dryRun) {
+    if (dryRun) {
+        if (result.removedFiles.length === 0) {
+            return `Dry run for ${normalizedPath}: no orphaned vectors found.`;
+        }
+        const lines = [
+            `Dry run for ${normalizedPath}: ${result.removedFiles.length} file(s) would be cleaned:`,
+            '',
+        ];
+        for (const f of result.removedFiles) {
+            lines.push(`  - ${f}`);
+        }
+        return lines.join('\n');
+    }
+    if (result.totalRemoved === 0) {
+        return `Cleanup complete for ${normalizedPath}: no orphaned vectors found.`;
+    }
+    const lines = [
+        `Cleanup complete for ${normalizedPath}`,
+        '',
+        `  Removed:   ${result.totalRemoved} file(s)`,
+        `  Duration:  ${(result.durationMs / 1000).toFixed(1)}s`,
+        '',
+        'Cleaned files:',
+    ];
+    for (const f of result.removedFiles) {
+        lines.push(`  - ${f}`);
+    }
+    return lines.join('\n');
+}
+export function formatIndexResult(result, normalizedPath) {
+    const lines = [
+        `Indexing complete for ${normalizedPath}`,
+        '',
+        `  Total files:    ${result.totalFiles}`,
+        `  Total chunks:   ${result.totalChunks}`,
+        `  Added:          ${result.addedFiles}`,
+        `  Modified:       ${result.modifiedFiles}`,
+        `  Removed:        ${result.removedFiles}`,
+        `  Skipped:        ${result.skippedFiles}`,
+        `  Parse failures: ${result.parseFailures.length}`,
+        `  Tokens:         ~${(result.estimatedTokens / 1000).toFixed(0)}K`,
+        `  Cost:           $${result.estimatedCostUsd.toFixed(4)}`,
+        `  Duration:       ${(result.durationMs / 1000).toFixed(1)}s`,
+    ];
+    if (result.parseFailures.length > 0) {
+        lines.push('');
+        lines.push('Parse failures:');
+        const toShow = result.parseFailures.slice(0, 10);
+        for (const file of toShow) {
+            lines.push(`- ${file}`);
+        }
+        if (result.parseFailures.length > 10) {
+            lines.push(`- ... and ${result.parseFailures.length - 10} more`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatPreview(preview, rootPath) {
+    const lines = [`Preview for ${rootPath}:`, ''];
+    const sorted = Object.entries(preview.byExtension).sort((a, b) => b[1] - a[1]);
+    if (sorted.length > 0) {
+        const maxExt = Math.max(...sorted.map(([ext]) => ext.length));
+        for (const [ext, count] of sorted) {
+            lines.push(`  ${ext.padEnd(maxExt)}  ${count.toLocaleString()}`);
+        }
+    }
+    lines.push(`Total: ${preview.totalFiles.toLocaleString()} files`, '');
+    if (preview.topDirectories.length > 0) {
+        lines.push('Top directories:');
+        for (const { dir, count } of preview.topDirectories) {
+            lines.push(`  ${dir}/: ${count.toLocaleString()} files`);
+        }
+        lines.push('');
+    }
+    const tokenStr = preview.estimatedTokens >= 1_000_000
+        ? `~${(preview.estimatedTokens / 1_000_000).toFixed(1)}M`
+        : `~${(preview.estimatedTokens / 1000).toFixed(0)}K`;
+    lines.push(`Estimated: ${tokenStr} tokens (~$${preview.estimatedCostUsd.toFixed(4)})`, '');
+    lines.push('Warnings:');
+    if (preview.warnings.length === 0) {
+        lines.push('- None');
+    }
+    else {
+        for (const w of preview.warnings) {
+            lines.push(`- ${w}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatListIndexed(states) {
+    const registry = listProjects();
+    const pathToProject = new Map(Object.entries(registry).map(([name, p]) => [p, name]));
+    const lines = [`Indexed Codebases (${states.length})`, ''];
+    for (const s of states) {
+        const projectName = pathToProject.get(s.path);
+        const heading = projectName ? `${s.path} (project: ${projectName})` : s.path;
+        lines.push(heading);
+        lines.push(`  Status:       ${s.status}`);
+        if (s.totalFiles)
+            lines.push(`  Files:        ${s.totalFiles}`);
+        if (s.totalChunks)
+            lines.push(`  Chunks:       ${s.totalChunks}`);
+        if (s.lastIndexed)
+            lines.push(`  Last indexed: ${s.lastIndexed}`);
+        if (s.status === 'indexing' && s.progress !== undefined) {
+            lines.push(`  Progress:     ${s.progress}% — ${s.progressMessage ?? ''}`);
+        }
+        if (s.error)
+            lines.push(`  Error:        ${s.error}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function formatDocIndexResult(result) {
+    const lines = [
+        `Documentation cached: ${result.library}/${result.topic}`,
+        '',
+        `  Source:     ${result.source}`,
+        `  Chunks:    ${result.totalChunks}`,
+        `  Tokens:    ~${(result.estimatedTokens / 1000).toFixed(0)}K`,
+        `  Duration:  ${(result.durationMs / 1000).toFixed(1)}s`,
+        `  Collection: ${result.collectionName}`,
+        '',
+        `Use \`lookup(query="...", library="${result.library}")\` to search this documentation.`,
+    ];
+    return lines.join('\n');
+}
+export function formatDocSearchResults(results, query) {
+    if (results.length === 0) {
+        return `No cached documentation found for "${query}".`;
+    }
+    const lines = [`Found ${results.length} result(s) for "${query}" in cached docs:\n`];
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const staleTag = r.stale ? ' **[STALE]**' : '';
+        lines.push(`### Result ${i + 1}`);
+        lines.push(`**Library:** ${r.library}/${r.topic} | **Source:** ${r.source}${staleTag}`);
+        lines.push(`**Score:** ${r.score.toFixed(4)}`);
+        lines.push('```markdown');
+        lines.push(r.content);
+        lines.push('```');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=format.js.map