@tai-io/codesearch 2026.313.1614

package/dist/tools.d.ts

@@ -0,0 +1,58 @@
+import { StateManager } from './state/snapshot.js';
+import type { Embedding } from './embedding/types.js';
+import type { VectorDB } from './vectordb/types.js';
+export declare class ToolHandlers {
+    private embedding;
+    private vectordb;
+    private state;
+    constructor(embedding: Embedding, vectordb: VectorDB, state: StateManager);
+    handleIndex(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleSearch(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleClear(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleList(): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleCleanup(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleIngest(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleLookup(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleBrowse(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+}
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.js

@@ -0,0 +1,245 @@
+import { normalizePath, pathToCollectionName } from './paths.js';
+import { indexCodebase, previewCodebase, deleteSnapshot } from './core/indexer.js';
+import { cleanupVectors } from './core/cleanup.js';
+import { scanFiles, buildSnapshot, diffSnapshots } from './core/sync.js';
+import { loadSnapshot } from './vectordb/sqlite.js';
+import { getConfig } from './config.js';
+import { searchCode, formatSearchResults, formatCompactResults } from './core/searcher.js';
+import { indexDocument } from './core/doc-indexer.js';
+import { searchDocuments } from './core/doc-searcher.js';
+import { generateRepoMap, VectorDBSymbolSource } from './core/repo-map.js';
+import { registerProject, resolveProject, listProjects } from './state/registry.js';
+import { textResult, formatCleanupResult, formatPreview, formatIndexResult, formatListIndexed, formatDocIndexResult, formatDocSearchResults, } from './format.js';
+function getErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function resolvePath(args) {
+    const pathArg = args.path;
+    if (pathArg)
+        return normalizePath(pathArg);
+    const projectArg = args.project;
+    if (projectArg)
+        return resolveProject(projectArg);
+    return undefined;
+}
+function noPathError() {
+    const projects = listProjects();
+    const names = Object.keys(projects);
+    if (names.length > 0) {
+        const list = names.map((n) => `  - ${n} → ${projects[n]}`).join('\n');
+        return textResult(`Error: provide \`path\` or \`project\`. Registered projects:\n${list}`);
+    }
+    return textResult('Error: provide `path` (absolute) or `project` (name). No projects registered yet — index a codebase first.');
+}
+const locks = new Map();
+async function withMutex(key, fn) {
+    const prev = locks.get(key) ?? Promise.resolve();
+    let resolve;
+    const current = new Promise((r) => {
+        resolve = r;
+    });
+    locks.set(key, current);
+    await prev;
+    try {
+        return await fn();
+    }
+    finally {
+        resolve();
+        if (locks.get(key) === current) {
+            locks.delete(key);
+        }
+    }
+}
+export class ToolHandlers {
+    embedding;
+    vectordb;
+    state;
+    constructor(embedding, vectordb, state) {
+        this.embedding = embedding;
+        this.vectordb = vectordb;
+        this.state = state;
+    }
+    async handleIndex(args) {
+        const normalizedPath = resolvePath(args);
+        if (!normalizedPath)
+            return noPathError();
+        const force = args.force ?? false;
+        const dryRun = args.dryRun ?? false;
+        const config = getConfig();
+        const customExt = args.customExtensions ?? config.customExtensions;
+        const customIgnore = args.customIgnorePatterns ?? config.customIgnorePatterns;
+        const collectionName = pathToCollectionName(normalizedPath);
+        if (dryRun) {
+            try {
+                const preview = await previewCodebase(normalizedPath, customExt, customIgnore);
+                return textResult(formatPreview(preview, normalizedPath));
+            }
+            catch (err) {
+                const message = getErrorMessage(err);
+                return textResult(`Error previewing ${normalizedPath}: ${message}`);
+            }
+        }
+        return withMutex(normalizedPath, async () => {
+            this.state.setIndexing(normalizedPath, collectionName);
+            try {
+                const result = await indexCodebase(normalizedPath, this.embedding, this.vectordb, force, (pct, msg) => {
+                    this.state.updateProgress(normalizedPath, pct, msg);
+                }, customExt, customIgnore);
+                this.state.setIndexed(normalizedPath, result.totalFiles, result.totalChunks);
+                registerProject(normalizedPath);
+                return textResult(formatIndexResult(result, normalizedPath));
+            }
+            catch (err) {
+                const message = getErrorMessage(err);
+                this.state.setError(normalizedPath, message);
+                return textResult(`Error indexing ${normalizedPath}: ${message}`);
+            }
+        });
+    }
+    async handleSearch(args) {
+        const query = args.query;
+        if (!query)
+            return textResult('Error: "query" is required. Provide a natural language search query.');
+        const normalizedPath = resolvePath(args);
+        if (!normalizedPath)
+            return noPathError();
+        const rawLimit = args.limit;
+        const limit = rawLimit !== undefined && Number.isFinite(rawLimit) && rawLimit >= 1 ? rawLimit : undefined;
+        const extensionFilter = args.extensionFilter;
+        const compact = args.compact !== false;
+        try {
+            const results = await searchCode(normalizedPath, query, this.embedding, this.vectordb, {
+                limit,
+                extensionFilter,
+            });
+            const formatted = compact
+                ? formatCompactResults(results, query, normalizedPath)
+                : formatSearchResults(results, query, normalizedPath);
+            return textResult(formatted);
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error: ${message}`);
+        }
+    }
+    async handleClear(args) {
+        const normalizedPath = resolvePath(args);
+        if (!normalizedPath)
+            return noPathError();
+        const collectionName = pathToCollectionName(normalizedPath);
+        return withMutex(normalizedPath, async () => {
+            try {
+                await this.vectordb.dropCollection(collectionName);
+                deleteSnapshot(normalizedPath);
+                this.state.remove(normalizedPath);
+                return textResult(`Index cleared for ${normalizedPath}.`);
+            }
+            catch (err) {
+                const message = getErrorMessage(err);
+                return textResult(`Error clearing index: ${message}`);
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async handleList() {
+        const states = this.state.getAllStates();
+        if (states.length === 0) {
+            return textResult('No codebases are currently indexed in this session.\n\nUse `index` to index a codebase first.');
+        }
+        return textResult(formatListIndexed(states));
+    }
+    async handleCleanup(args) {
+        const normalizedPath = resolvePath(args);
+        if (!normalizedPath)
+            return noPathError();
+        const dryRun = args.dryRun ?? false;
+        const config = getConfig();
+        const customExt = args.customExtensions ?? config.customExtensions;
+        const customIgnore = args.customIgnorePatterns ?? config.customIgnorePatterns;
+        return withMutex(normalizedPath, async () => {
+            try {
+                if (dryRun) {
+                    const previousSnapshot = loadSnapshot(normalizedPath);
+                    if (!previousSnapshot) {
+                        return textResult(`Error: No snapshot found for ${normalizedPath}. Index the codebase first before running cleanup.`);
+                    }
+                    const filePaths = await scanFiles(normalizedPath, customExt, customIgnore);
+                    const currentSnapshot = buildSnapshot(normalizedPath, filePaths);
+                    const { removed } = diffSnapshots(previousSnapshot, currentSnapshot);
+                    const dryResult = { removedFiles: removed, totalRemoved: removed.length, durationMs: 0 };
+                    return textResult(formatCleanupResult(dryResult, normalizedPath, true));
+                }
+                const result = await cleanupVectors(normalizedPath, this.vectordb, undefined, customExt, customIgnore);
+                return textResult(formatCleanupResult(result, normalizedPath, false));
+            }
+            catch (err) {
+                const message = getErrorMessage(err);
+                return textResult(`Error during cleanup: ${message}`);
+            }
+        });
+    }
+    async handleIngest(args) {
+        const content = args.content;
+        if (!content)
+            return textResult('Error: "content" is required. Provide the documentation text to cache.');
+        const source = args.source;
+        if (!source)
+            return textResult('Error: "source" is required. Provide the source URL or identifier.');
+        const library = args.library;
+        if (!library)
+            return textResult('Error: "library" is required. Provide the library name (e.g., "react", "langfuse").');
+        const topic = args.topic;
+        if (!topic)
+            return textResult('Error: "topic" is required. Provide the topic within the library (e.g., "hooks").');
+        const ttlDays = args.ttlDays ?? 7;
+        try {
+            const result = await indexDocument(content, source, library, topic, this.embedding, this.vectordb, ttlDays);
+            return textResult(formatDocIndexResult(result));
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error caching documentation: ${message}`);
+        }
+    }
+    async handleLookup(args) {
+        const query = args.query;
+        if (!query)
+            return textResult('Error: "query" is required. Provide a natural language search query.');
+        const library = args.library;
+        const rawLimit = args.limit;
+        const limit = rawLimit !== undefined && Number.isFinite(rawLimit) && rawLimit >= 1 ? rawLimit : undefined;
+        try {
+            const results = await searchDocuments(query, this.embedding, this.vectordb, {
+                library,
+                limit,
+            });
+            return textResult(formatDocSearchResults(results, query));
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error: ${message}`);
+        }
+    }
+    async handleBrowse(args) {
+        const normalizedPath = resolvePath(args);
+        if (!normalizedPath)
+            return noPathError();
+        const pathFilter = args.pathFilter;
+        const kindFilter = args.kind;
+        const maxTokens = args.maxTokens;
+        try {
+            const source = new VectorDBSymbolSource(this.vectordb);
+            const map = await generateRepoMap(normalizedPath, source, {
+                pathFilter,
+                kindFilter,
+                maxTokens,
+            });
+            return textResult(map);
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            return textResult(`Error: ${message}`);
+        }
+    }
+}
+//# sourceMappingURL=tools.js.map

package/dist/vectordb/rrf.d.ts

@@ -0,0 +1,32 @@
+import type { SearchResult } from './types.js';
+export declare const RRF_K = 5;
+export declare const RRF_ALPHA = 0.7;
+export interface RankedPoint {
+    id: string | number;
+    payload?: Record<string, unknown> | null;
+    rawScore: number;
+}
+export interface ScoredPayload {
+    id: string | number;
+    content: string;
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+    fileExtension: string;
+    language: string;
+    fileCategory: string;
+}
+export declare function rankByTermFrequency(points: {
+    id: string | number;
+    payload?: Record<string, unknown> | null;
+}[], queryText: string): RankedPoint[];
+export declare function extractPayload(point: {
+    id: string | number;
+    payload?: Record<string, unknown> | null;
+}): ScoredPayload;
+export declare function reciprocalRankFusion(denseResults: {
+    id: string | number;
+    score?: number;
+    payload?: Record<string, unknown> | null;
+}[], textResults: RankedPoint[], limit: number): SearchResult[];
+//# sourceMappingURL=rrf.d.ts.map

package/dist/vectordb/rrf.js

@@ -0,0 +1,88 @@
+export const RRF_K = 5; // Reciprocal Rank Fusion constant (low k for code search — stronger rank separation)
+export const RRF_ALPHA = 0.7; // Blend weight: 70% rank-based (fusion stability), 30% raw similarity (query-specific signal)
+// Rank text-match results by normalized term frequency so RRF receives a meaningful ordering.
+export function rankByTermFrequency(points, queryText) {
+    if (points.length === 0)
+        return [];
+    const terms = [
+        ...new Set(queryText
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((t) => t.length > 0)),
+    ];
+    if (terms.length === 0)
+        return points.map((p) => ({ ...p, rawScore: 0 }));
+    const termPatterns = terms.map((t) => new RegExp(t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'));
+    const scored = points.map((point) => {
+        const content = point.payload?.content ?? '';
+        const wordCount = Math.max(1, content.split(/\s+/).length);
+        let hits = 0;
+        for (const pattern of termPatterns) {
+            pattern.lastIndex = 0;
+            const matches = content.match(pattern);
+            hits += matches ? matches.length : 0;
+        }
+        const tf = hits / wordCount;
+        return { point, tf };
+    });
+    scored.sort((a, b) => b.tf - a.tf);
+    const maxTf = scored[0].tf;
+    return scored.map((s) => ({
+        ...s.point,
+        rawScore: maxTf > 0 ? s.tf / maxTf : 0,
+    }));
+}
+export function extractPayload(point) {
+    const p = point.payload ?? {};
+    return {
+        id: point.id,
+        content: String(p.content ?? ''),
+        relativePath: String(p.relativePath ?? ''),
+        startLine: Number(p.startLine ?? 0),
+        endLine: Number(p.endLine ?? 0),
+        fileExtension: String(p.fileExtension ?? ''),
+        language: String(p.language ?? ''),
+        fileCategory: String(p.fileCategory ?? ''),
+    };
+}
+export function reciprocalRankFusion(denseResults, textResults, limit) {
+    const scoreMap = new Map();
+    const blendedScore = (rank, rawSimilarity) => RRF_ALPHA * (1 / (RRF_K + rank + 1)) + (1 - RRF_ALPHA) * rawSimilarity;
+    for (let rank = 0; rank < denseResults.length; rank++) {
+        const point = denseResults[rank];
+        const rawSim = point.score ?? 0;
+        const score = blendedScore(rank, rawSim);
+        const existing = scoreMap.get(point.id);
+        const payload = extractPayload(point);
+        if (existing) {
+            existing.score += score;
+        }
+        else {
+            scoreMap.set(point.id, { score, payload });
+        }
+    }
+    for (let rank = 0; rank < textResults.length; rank++) {
+        const point = textResults[rank];
+        const score = blendedScore(rank, point.rawScore);
+        const existing = scoreMap.get(point.id);
+        const payload = extractPayload(point);
+        if (existing) {
+            existing.score += score;
+        }
+        else {
+            scoreMap.set(point.id, { score, payload });
+        }
+    }
+    const sorted = [...scoreMap.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+    return sorted.map(({ score, payload }) => ({
+        content: payload.content,
+        relativePath: payload.relativePath,
+        startLine: payload.startLine,
+        endLine: payload.endLine,
+        fileExtension: payload.fileExtension,
+        language: payload.language,
+        score,
+        fileCategory: payload.fileCategory,
+    }));
+}
+//# sourceMappingURL=rrf.js.map

package/dist/vectordb/sqlite.d.ts

@@ -0,0 +1,34 @@
+import type { VectorDB, CodeDocument, HybridSearchParams, SearchResult, SymbolEntry } from './types.js';
+import type { FileSnapshot } from '../core/sync.js';
+export declare class SqliteVectorDB implements VectorDB {
+    private dbPath;
+    constructor(dbPath: string);
+    private get db();
+    createCollection(name: string, dimension: number): Promise<void>;
+    hasCollection(name: string): Promise<boolean>;
+    dropCollection(name: string): Promise<void>;
+    insert(name: string, documents: CodeDocument[]): Promise<void>;
+    search(name: string, params: HybridSearchParams): Promise<SearchResult[]>;
+    getById(name: string, id: string): Promise<{
+        payload: Record<string, unknown>;
+        vector: number[];
+    } | null>;
+    updatePoint(name: string, id: string, vector: number[], payload: Record<string, unknown>): Promise<void>;
+    deleteByPath(name: string, relativePath: string): Promise<void>;
+    deleteByFilter(name: string, filter: Record<string, unknown>): Promise<void>;
+    listSymbols(name: string): Promise<SymbolEntry[]>;
+    scrollAll(name: string): Promise<{
+        id: string | number;
+        vector: number[];
+        payload: Record<string, unknown>;
+    }[]>;
+}
+export declare function loadSnapshot(rootPath: string, dbPath?: string): FileSnapshot | null;
+export declare function saveSnapshot(rootPath: string, snapshot: FileSnapshot, dbPath?: string): void;
+export declare function deleteSnapshot(rootPath: string, dbPath?: string): void;
+export declare function snapshotExists(rootPath: string, dbPath?: string): boolean;
+export declare function listSnapshotCollections(dbPath?: string): string[];
+export declare function deleteSnapshotByCollection(collectionName: string, dbPath?: string): void;
+/** Reset the module-level DB connection (for testing). */
+export declare function resetForTesting(): void;
+//# sourceMappingURL=sqlite.d.ts.map