claude-eidetic 0.1.0

package/dist/vectordb/qdrant.js

@@ -0,0 +1,241 @@
+import { QdrantClient } from '@qdrant/js-client-rest';
+import { randomUUID } from 'node:crypto';
+import { VectorDBError } from '../errors.js';
+import { getConfig } from '../config.js';
+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)
+export class QdrantVectorDB {
+    client;
+    constructor(url, apiKey) {
+        const config = getConfig();
+        this.client = new QdrantClient({
+            url: url ?? config.qdrantUrl,
+            ...(apiKey ?? config.qdrantApiKey ? { apiKey: apiKey ?? config.qdrantApiKey } : {}),
+        });
+    }
+    async createCollection(name, dimension) {
+        try {
+            await this.client.createCollection(name, {
+                vectors: {
+                    dense: { size: dimension, distance: 'Cosine' },
+                },
+            });
+            // Create payload indexes for filtering and full-text search
+            await Promise.all([
+                this.client.createPayloadIndex(name, {
+                    field_name: 'content',
+                    field_schema: 'text',
+                    wait: true,
+                }),
+                this.client.createPayloadIndex(name, {
+                    field_name: 'relativePath',
+                    field_schema: 'keyword',
+                    wait: true,
+                }),
+                this.client.createPayloadIndex(name, {
+                    field_name: 'fileExtension',
+                    field_schema: 'keyword',
+                    wait: true,
+                }),
+            ]);
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to create collection "${name}"`, err);
+        }
+    }
+    async hasCollection(name) {
+        try {
+            const response = await this.client.collectionExists(name);
+            return response.exists;
+        }
+        catch {
+            return false;
+        }
+    }
+    async dropCollection(name) {
+        try {
+            if (await this.hasCollection(name)) {
+                await this.client.deleteCollection(name);
+            }
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to drop collection "${name}"`, err);
+        }
+    }
+    async insert(name, documents) {
+        if (documents.length === 0)
+            return;
+        try {
+            const batchSize = 100;
+            for (let i = 0; i < documents.length; i += batchSize) {
+                const batch = documents.slice(i, i + batchSize);
+                await this.client.upsert(name, {
+                    wait: true,
+                    points: batch.map(doc => ({
+                        id: doc.id ?? randomUUID(),
+                        vector: { dense: doc.vector },
+                        payload: {
+                            content: doc.content,
+                            relativePath: doc.relativePath,
+                            startLine: doc.startLine,
+                            endLine: doc.endLine,
+                            fileExtension: doc.fileExtension,
+                            language: doc.language,
+                        },
+                    })),
+                });
+            }
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to insert ${documents.length} documents into "${name}"`, err);
+        }
+    }
+    async search(name, params) {
+        try {
+            const fetchLimit = params.limit * 2;
+            const extensionFilter = params.extensionFilter?.length
+                ? {
+                    should: params.extensionFilter.map(ext => ({
+                        key: 'fileExtension',
+                        match: { value: ext },
+                    })),
+                }
+                : undefined;
+            const denseResults = await this.client.search(name, {
+                vector: { name: 'dense', vector: params.queryVector },
+                limit: fetchLimit,
+                with_payload: true,
+                ...(extensionFilter ? { filter: { must: [extensionFilter] } } : {}),
+            });
+            const textFilter = [
+                { key: 'content', match: { text: params.queryText } },
+            ];
+            if (extensionFilter) {
+                textFilter.push(extensionFilter);
+            }
+            const textResponse = await this.client.scroll(name, {
+                filter: { must: textFilter },
+                limit: fetchLimit,
+                with_payload: true,
+            });
+            // Rank text results by query term frequency so RRF receives a meaningful ordering
+            const rankedTextResults = rankByTermFrequency(textResponse.points, params.queryText);
+            // 3. Client-side RRF fusion blending rank position with raw similarity scores
+            return reciprocalRankFusion(denseResults, rankedTextResults, params.limit);
+        }
+        catch (err) {
+            throw new VectorDBError(`Search failed in collection "${name}"`, err);
+        }
+    }
+    async deleteByPath(name, relativePath) {
+        try {
+            await this.client.delete(name, {
+                filter: {
+                    must: [{ key: 'relativePath', match: { value: relativePath } }],
+                },
+                wait: true,
+            });
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to delete documents for path "${relativePath}" from "${name}"`, err);
+        }
+    }
+}
+/**
+ * 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 function rankByTermFrequency(points, queryText) {
+    if (points.length === 0)
+        return [];
+    // Split query into individual terms, deduplicate, and build escaped regex patterns
+    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);
+        // Count total term occurrences across all query terms
+        let hits = 0;
+        for (const pattern of termPatterns) {
+            pattern.lastIndex = 0; // reset stateful regex
+            const matches = content.match(pattern);
+            hits += matches ? matches.length : 0;
+        }
+        // Normalize by word count (TF = hits / total words)
+        const tf = hits / wordCount;
+        return { point, tf };
+    });
+    // Sort by TF descending (best matches first)
+    scored.sort((a, b) => b.tf - a.tf);
+    // Normalize TF to 0-1 range for blending with cosine similarity
+    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 ?? ''),
+    };
+}
+export function reciprocalRankFusion(denseResults, textResults, limit) {
+    const scoreMap = new Map();
+    // Hybrid RRF blended with raw similarity:
+    //   score = alpha * (1/(k + rank + 1)) + (1-alpha) * rawSimilarity
+    // alpha=0.7 preserves rank-fusion stability while 0.3 raw similarity
+    // injects query-specific signal so identical ranks get different scores.
+    const blendedScore = (rank, rawSimilarity) => RRF_ALPHA * (1 / (RRF_K + rank + 1)) + (1 - RRF_ALPHA) * rawSimilarity;
+    // Score from dense results (cosine similarity from Qdrant)
+    for (let rank = 0; rank < denseResults.length; rank++) {
+        const point = denseResults[rank];
+        const rawSim = point.score ?? 0; // cosine similarity (0-1)
+        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 });
+        }
+    }
+    // Score from text results (normalized TF from rankByTermFrequency)
+    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,
+    }));
+}
+//# sourceMappingURL=qdrant.js.map

package/dist/vectordb/types.d.ts

@@ -0,0 +1,35 @@
+import type { EmbeddingVector } from '../embedding/types.js';
+export interface CodeDocument {
+    id: string;
+    content: string;
+    vector: EmbeddingVector;
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+    fileExtension: string;
+    language: string;
+}
+export interface HybridSearchParams {
+    queryVector: EmbeddingVector;
+    queryText: string;
+    limit: number;
+    extensionFilter?: string[];
+}
+export interface SearchResult {
+    content: string;
+    relativePath: string;
+    startLine: number;
+    endLine: number;
+    fileExtension: string;
+    language: string;
+    score: number;
+}
+export interface VectorDB {
+    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>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/vectordb/types.js

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

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "claude-eidetic",
+  "version": "0.1.0",
+  "description": "Semantic code search MCP server — lean, correct, fast",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "claude-eidetic": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "!dist/**/*.test.*",
+    "!dist/__test__/**",
+    "!dist/e2e/**"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx --watch src/index.ts",
+    "start": "node dist/index.js",
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:all": "vitest run && vitest run --config vitest.integration.config.ts",
+    "test:audit": "tsx scripts/audit/lonely-source.ts; tsx scripts/audit/mock-hygiene.ts; tsx scripts/audit/bare-hands.ts; tsx scripts/audit/timer-drift.ts",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@qdrant/js-client-rest": "^1.13.0",
+    "glob": "^10.0.0",
+    "openai": "^5.1.1",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-c-sharp": "^0.21.0",
+    "tree-sitter-cpp": "^0.22.0",
+    "tree-sitter-go": "^0.21.0",
+    "tree-sitter-java": "^0.21.0",
+    "tree-sitter-javascript": "^0.21.0",
+    "tree-sitter-python": "^0.21.0",
+    "tree-sitter-rust": "^0.21.0",
+    "tree-sitter-typescript": "^0.21.0",
+    "zod": "^3.25.0"
+  },
+  "optionalDependencies": {
+    "@zilliz/milvus2-sdk-node": "^2.5.10"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "rimraf": "^6.0.1",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "MIT"
+}