claude-eidetic 0.1.0

package/dist/tools.js

@@ -0,0 +1,169 @@
+import { normalizePath, pathToCollectionName } from './paths.js';
+import { indexCodebase, previewCodebase, deleteSnapshot } from './core/indexer.js';
+import { getConfig } from './config.js';
+import { searchCode, formatSearchResults, formatCompactResults } from './core/searcher.js';
+import { registerProject, resolveProject, listProjects } from './state/registry.js';
+import { textResult, formatPreview, formatIndexResult, formatListIndexed } from './format.js';
+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) {
+    // Chain onto any existing operation for this key (FIFO ordering, no race)
+    const prev = locks.get(key) ?? Promise.resolve();
+    let resolve;
+    const current = new Promise(r => { resolve = r; });
+    locks.set(key, current);
+    // Wait for previous operation to complete
+    await prev;
+    try {
+        return await fn();
+    }
+    finally {
+        resolve();
+        // Only delete if we're still the latest operation
+        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 handleIndexCodebase(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, this.embedding, customExt, customIgnore);
+                return textResult(formatPreview(preview, normalizedPath));
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(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 = err instanceof Error ? err.message : String(err);
+                this.state.setError(normalizedPath, message);
+                return textResult(`Error indexing ${normalizedPath}: ${message}`);
+            }
+        });
+    }
+    async handleSearchCode(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; // default true
+        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 = err instanceof Error ? err.message : String(err);
+            return textResult(`Error: ${message}`);
+        }
+    }
+    async handleClearIndex(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 = err instanceof Error ? err.message : String(err);
+                return textResult(`Error clearing index: ${message}`);
+            }
+        });
+    }
+    async handleGetIndexingStatus(args) {
+        const normalizedPath = resolvePath(args);
+        if (!normalizedPath)
+            return noPathError();
+        const state = this.state.getState(normalizedPath);
+        if (!state) {
+            const collectionName = pathToCollectionName(normalizedPath);
+            const exists = await this.vectordb.hasCollection(collectionName);
+            if (exists) {
+                return textResult(`Codebase at ${normalizedPath} is indexed (status loaded from vector DB).`);
+            }
+            return textResult(`Codebase at ${normalizedPath} is not indexed.`);
+        }
+        const lines = [`Status for ${normalizedPath}: **${state.status}**`];
+        if (state.status === 'indexing' && state.progress !== undefined) {
+            lines.push(`Progress: ${state.progress}% - ${state.progressMessage ?? ''}`);
+        }
+        if (state.status === 'indexed') {
+            lines.push(`Last indexed: ${state.lastIndexed ?? 'unknown'}`);
+            if (state.totalFiles)
+                lines.push(`Files: ${state.totalFiles}`);
+            if (state.totalChunks)
+                lines.push(`Chunks: ${state.totalChunks}`);
+        }
+        if (state.status === 'error') {
+            lines.push(`Error: ${state.error ?? 'unknown'}`);
+        }
+        return textResult(lines.join('\n'));
+    }
+    async handleListIndexed() {
+        const states = this.state.getAllStates();
+        if (states.length === 0) {
+            return textResult('No codebases are currently indexed in this session.\n\nUse `index_codebase` to index a codebase first.');
+        }
+        return textResult(formatListIndexed(states));
+    }
+}
+//# sourceMappingURL=tools.js.map

package/dist/vectordb/milvus.d.ts

@@ -0,0 +1,33 @@
+import type { VectorDB, CodeDocument, HybridSearchParams, SearchResult } from './types.js';
+/**
+ * Detects the "data type 104 not supported" error from older Milvus versions
+ * that lack SparseFloatVector support (< v2.4).
+ */
+export declare function isSparseUnsupportedError(err: unknown): boolean;
+export declare class MilvusVectorDB implements VectorDB {
+    private client;
+    private initPromise;
+    private hybridCollections;
+    constructor(client?: any);
+    private initialize;
+    private ready;
+    createCollection(name: string, dimension: number): Promise<void>;
+    private createHybridCollection;
+    private createDenseOnlyCollection;
+    hasCollection(name: string): Promise<boolean>;
+    dropCollection(name: string): Promise<void>;
+    insert(name: string, documents: CodeDocument[]): Promise<void>;
+    search(name: string, params: HybridSearchParams): Promise<SearchResult[]>;
+    private hybridSearch;
+    private denseOnlySearch;
+    private mapResults;
+    /**
+     * Detect whether a collection has the sparse_vector field (hybrid) or not.
+     * Caches result in hybridCollections set.
+     */
+    private detectHybrid;
+    deleteByPath(name: string, relativePath: string): Promise<void>;
+    private ensureLoaded;
+    private waitForLoad;
+}
+//# sourceMappingURL=milvus.d.ts.map

package/dist/vectordb/milvus.js

@@ -0,0 +1,328 @@
+import { VectorDBError } from '../errors.js';
+import { getConfig } from '../config.js';
+// Dynamic import -- @zilliz/milvus2-sdk-node is an optional dependency
+let MilvusClient;
+let DataType;
+let MetricType;
+let FunctionType;
+let LoadState;
+async function loadMilvusSDK() {
+    try {
+        const sdk = await import('@zilliz/milvus2-sdk-node');
+        MilvusClient = sdk.MilvusClient;
+        DataType = sdk.DataType;
+        MetricType = sdk.MetricType;
+        FunctionType = sdk.FunctionType;
+        LoadState = sdk.LoadState;
+    }
+    catch {
+        throw new VectorDBError('Milvus SDK not installed. Run: npm install @zilliz/milvus2-sdk-node');
+    }
+}
+const RRF_K = 60;
+/**
+ * Detects the "data type 104 not supported" error from older Milvus versions
+ * that lack SparseFloatVector support (< v2.4).
+ */
+export function isSparseUnsupportedError(err) {
+    const msg = String(err && typeof err === 'object' && 'reason' in err ? err.reason : err);
+    return /data type[:\s]*104/i.test(msg) || /not supported/i.test(msg) && /104/.test(msg);
+}
+export class MilvusVectorDB {
+    client = null;
+    initPromise;
+    hybridCollections = new Set();
+    constructor(client) {
+        if (client) {
+            this.client = client;
+            this.initPromise = Promise.resolve();
+        }
+        else {
+            this.initPromise = this.initialize();
+        }
+    }
+    async initialize() {
+        await loadMilvusSDK();
+        const config = getConfig();
+        this.client = new MilvusClient({
+            address: config.milvusAddress,
+            ...(config.milvusToken ? { token: config.milvusToken } : {}),
+        });
+    }
+    async ready() {
+        await this.initPromise;
+        if (!this.client)
+            throw new VectorDBError('Milvus client not initialized');
+    }
+    async createCollection(name, dimension) {
+        await this.ready();
+        // Try hybrid first, fall back to dense-only if Milvus version doesn't support sparse
+        try {
+            await this.createHybridCollection(name, dimension);
+            this.hybridCollections.add(name);
+            console.log(`Created hybrid collection "${name}" (dense + BM25 sparse)`);
+            return;
+        }
+        catch (err) {
+            if (isSparseUnsupportedError(err)) {
+                console.warn(`Milvus does not support SparseFloatVector (requires >= v2.4). ` +
+                    `Falling back to dense-only collection for "${name}".`);
+                // Clean up the failed collection attempt
+                try {
+                    await this.client.dropCollection({ collection_name: name });
+                }
+                catch (cleanupErr) {
+                    console.warn(`Failed to clean up collection "${name}": ${cleanupErr}`);
+                }
+            }
+            else {
+                throw new VectorDBError(`Failed to create Milvus collection "${name}"`, err);
+            }
+        }
+        try {
+            await this.createDenseOnlyCollection(name, dimension);
+            console.log(`Created dense-only collection "${name}"`);
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to create Milvus collection "${name}"`, err);
+        }
+    }
+    async createHybridCollection(name, dimension) {
+        const schema = [
+            { name: 'id', data_type: DataType.VarChar, max_length: 128, is_primary_key: true },
+            { name: 'content', data_type: DataType.VarChar, max_length: 65535, enable_analyzer: true },
+            { name: 'vector', data_type: DataType.FloatVector, dim: dimension },
+            { name: 'sparse_vector', data_type: DataType.SparseFloatVector },
+            { name: 'relativePath', data_type: DataType.VarChar, max_length: 1024 },
+            { name: 'startLine', data_type: DataType.Int64 },
+            { name: 'endLine', data_type: DataType.Int64 },
+            { name: 'fileExtension', data_type: DataType.VarChar, max_length: 32 },
+            { name: 'language', data_type: DataType.VarChar, max_length: 64 },
+        ];
+        const functions = [{
+                name: 'content_bm25',
+                type: FunctionType.BM25,
+                input_field_names: ['content'],
+                output_field_names: ['sparse_vector'],
+                params: {},
+            }];
+        await this.client.createCollection({
+            collection_name: name,
+            fields: schema,
+            functions,
+        });
+        await this.client.createIndex({
+            collection_name: name,
+            field_name: 'vector',
+            index_type: 'AUTOINDEX',
+            metric_type: MetricType.COSINE,
+        });
+        await this.client.createIndex({
+            collection_name: name,
+            field_name: 'sparse_vector',
+            index_type: 'SPARSE_INVERTED_INDEX',
+            metric_type: MetricType.BM25,
+        });
+        await this.waitForLoad(name);
+    }
+    async createDenseOnlyCollection(name, dimension) {
+        const schema = [
+            { name: 'id', data_type: DataType.VarChar, max_length: 128, is_primary_key: true },
+            { name: 'content', data_type: DataType.VarChar, max_length: 65535 },
+            { name: 'vector', data_type: DataType.FloatVector, dim: dimension },
+            { name: 'relativePath', data_type: DataType.VarChar, max_length: 1024 },
+            { name: 'startLine', data_type: DataType.Int64 },
+            { name: 'endLine', data_type: DataType.Int64 },
+            { name: 'fileExtension', data_type: DataType.VarChar, max_length: 32 },
+            { name: 'language', data_type: DataType.VarChar, max_length: 64 },
+        ];
+        await this.client.createCollection({
+            collection_name: name,
+            fields: schema,
+        });
+        await this.client.createIndex({
+            collection_name: name,
+            field_name: 'vector',
+            index_type: 'AUTOINDEX',
+            metric_type: MetricType.COSINE,
+        });
+        await this.waitForLoad(name);
+    }
+    async hasCollection(name) {
+        await this.ready();
+        try {
+            const result = await this.client.hasCollection({ collection_name: name });
+            return Boolean(result.value);
+        }
+        catch {
+            return false;
+        }
+    }
+    async dropCollection(name) {
+        await this.ready();
+        try {
+            if (await this.hasCollection(name)) {
+                await this.client.dropCollection({ collection_name: name });
+            }
+            this.hybridCollections.delete(name);
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to drop Milvus collection "${name}"`, err);
+        }
+    }
+    async insert(name, documents) {
+        if (documents.length === 0)
+            return;
+        await this.ready();
+        await this.ensureLoaded(name);
+        try {
+            const data = documents.map(doc => ({
+                id: doc.id,
+                content: doc.content,
+                vector: doc.vector,
+                relativePath: doc.relativePath,
+                startLine: doc.startLine,
+                endLine: doc.endLine,
+                fileExtension: doc.fileExtension,
+                language: doc.language,
+            }));
+            await this.client.insert({ collection_name: name, data });
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to insert into Milvus collection "${name}"`, err);
+        }
+    }
+    async search(name, params) {
+        await this.ready();
+        await this.ensureLoaded(name);
+        const isHybrid = await this.detectHybrid(name);
+        try {
+            let expr;
+            if (params.extensionFilter?.length) {
+                const exts = params.extensionFilter.map(e => `"${e.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`).join(', ');
+                expr = `fileExtension in [${exts}]`;
+            }
+            if (isHybrid) {
+                return await this.hybridSearch(name, params, expr);
+            }
+            return await this.denseOnlySearch(name, params, expr);
+        }
+        catch (err) {
+            throw new VectorDBError(`Milvus search failed in collection "${name}"`, err);
+        }
+    }
+    async hybridSearch(name, params, expr) {
+        const limit = params.limit * 2;
+        const searchParams = {
+            collection_name: name,
+            data: [
+                {
+                    data: [params.queryVector],
+                    anns_field: 'vector',
+                    param: { nprobe: 10 },
+                    limit,
+                },
+                {
+                    data: params.queryText,
+                    anns_field: 'sparse_vector',
+                    param: { drop_ratio_search: 0.2 },
+                    limit,
+                },
+            ],
+            limit: params.limit,
+            rerank: { strategy: 'rrf', params: { k: RRF_K } },
+            output_fields: ['id', 'content', 'relativePath', 'startLine', 'endLine', 'fileExtension', 'language'],
+        };
+        if (expr)
+            searchParams.expr = expr;
+        const result = await this.client.search(searchParams);
+        return this.mapResults(result);
+    }
+    async denseOnlySearch(name, params, expr) {
+        const searchParams = {
+            collection_name: name,
+            data: [params.queryVector],
+            limit: params.limit,
+            output_fields: ['id', 'content', 'relativePath', 'startLine', 'endLine', 'fileExtension', 'language'],
+        };
+        if (expr)
+            searchParams.expr = expr;
+        const result = await this.client.search(searchParams);
+        return this.mapResults(result);
+    }
+    mapResults(result) {
+        if (!result.results?.length)
+            return [];
+        return result.results.map((r) => ({
+            content: r.content ?? '',
+            relativePath: r.relativePath ?? '',
+            startLine: r.startLine ?? 0,
+            endLine: r.endLine ?? 0,
+            fileExtension: r.fileExtension ?? '',
+            language: r.language ?? '',
+            score: r.score ?? 0,
+        }));
+    }
+    /**
+     * Detect whether a collection has the sparse_vector field (hybrid) or not.
+     * Caches result in hybridCollections set.
+     */
+    async detectHybrid(name) {
+        if (this.hybridCollections.has(name))
+            return true;
+        try {
+            const desc = await this.client.describeCollection({ collection_name: name });
+            const fields = desc.schema?.fields ?? [];
+            const hasSparse = fields.some((f) => f.name === 'sparse_vector');
+            if (hasSparse) {
+                this.hybridCollections.add(name);
+            }
+            return hasSparse;
+        }
+        catch {
+            return false;
+        }
+    }
+    async deleteByPath(name, relativePath) {
+        await this.ready();
+        await this.ensureLoaded(name);
+        try {
+            const escaped = relativePath.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+            await this.client.delete({
+                collection_name: name,
+                filter: `relativePath == "${escaped}"`,
+            });
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to delete by path "${relativePath}" from "${name}"`, err);
+        }
+    }
+    async ensureLoaded(name) {
+        try {
+            const result = await this.client.getLoadState({ collection_name: name });
+            if (result.state !== LoadState.LoadStateLoaded) {
+                await this.client.loadCollection({ collection_name: name });
+            }
+        }
+        catch (err) {
+            console.warn(`Failed to ensure collection "${name}" is loaded: ${err}`);
+        }
+    }
+    async waitForLoad(name, timeoutMs = 30_000) {
+        await this.client.loadCollection({ collection_name: name });
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+            try {
+                const result = await this.client.getLoadState({ collection_name: name });
+                if (result.state === LoadState.LoadStateLoaded)
+                    return;
+            }
+            catch (err) {
+                console.warn(`Load state check failed for "${name}": ${err}`);
+            }
+            await new Promise(r => setTimeout(r, 500));
+        }
+        throw new VectorDBError(`Collection "${name}" failed to load within ${timeoutMs}ms`);
+    }
+}
+//# sourceMappingURL=milvus.js.map

package/dist/vectordb/qdrant.d.ts

@@ -0,0 +1,51 @@
+import type { VectorDB, CodeDocument, HybridSearchParams, SearchResult } from './types.js';
+export declare const RRF_K = 5;
+export declare const RRF_ALPHA = 0.7;
+export declare class QdrantVectorDB implements VectorDB {
+    private client;
+    constructor(url?: string, apiKey?: string);
+    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[]>;
+    deleteByPath(name: string, relativePath: string): Promise<void>;
+}
+interface RankedPoint {
+    id: string | number;
+    payload?: Record<string, unknown> | null;
+    rawScore: number;
+}
+/**
+ * Rank text-match results by normalized term frequency.
+ *
+ * Qdrant's scroll API returns text-filtered points in storage order (not by
+ * relevance). Before feeding these into RRF, we score each result by how many
+ * query terms appear in its content, normalized by word count to avoid bias
+ * toward longer chunks. Returns points sorted best-first with rawScore attached
+ * so RRF can blend rank position with content-based signal.
+ */
+export declare function rankByTermFrequency(points: {
+    id: string | number;
+    payload?: Record<string, unknown> | null;
+}[], queryText: string): RankedPoint[];
+interface ScoredPayload {
+    id: string | number;
+    content: string;
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+    fileExtension: string;
+    language: string;
+}
+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[];
+export {};
+//# sourceMappingURL=qdrant.d.ts.map