claude-eidetic 0.1.1 → 0.1.2

package/dist/vectordb/qdrant.d.ts

@@ -1,4 +1,4 @@
-import type { VectorDB, CodeDocument, HybridSearchParams, SearchResult } from './types.js';
+import type { VectorDB, CodeDocument, HybridSearchParams, SearchResult, SymbolEntry } from './types.js';
 export declare const RRF_K = 5;
 export declare const RRF_ALPHA = 0.7;
 export declare class QdrantVectorDB implements VectorDB {
@@ -9,22 +9,19 @@ export declare class QdrantVectorDB implements VectorDB {
     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>;
+    listSymbols(name: string): Promise<SymbolEntry[]>;
 }
 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;
@@ -37,6 +34,7 @@ interface ScoredPayload {
     endLine: number;
     fileExtension: string;
     language: string;
+    fileCategory: string;
 }
 export declare function extractPayload(point: {
     id: string | number;

package/dist/vectordb/qdrant.js

@@ -10,7 +10,7 @@ export class QdrantVectorDB {
         const config = getConfig();
         this.client = new QdrantClient({
             url: url ?? config.qdrantUrl,
-            ...(apiKey ?? config.qdrantApiKey ? { apiKey: apiKey ?? config.qdrantApiKey } : {}),
+            ...((apiKey ?? config.qdrantApiKey) ? { apiKey: apiKey ?? config.qdrantApiKey } : {}),
         });
     }
     async createCollection(name, dimension) {
@@ -20,7 +20,6 @@ export class QdrantVectorDB {
                     dense: { size: dimension, distance: 'Cosine' },
                 },
             });
-            // Create payload indexes for filtering and full-text search
             await Promise.all([
                 this.client.createPayloadIndex(name, {
                     field_name: 'content',
@@ -37,6 +36,11 @@ export class QdrantVectorDB {
                     field_schema: 'keyword',
                     wait: true,
                 }),
+                this.client.createPayloadIndex(name, {
+                    field_name: 'fileCategory',
+                    field_schema: 'keyword',
+                    wait: true,
+                }),
             ]);
         }
         catch (err) {
@@ -71,7 +75,7 @@ export class QdrantVectorDB {
                 const batch = documents.slice(i, i + batchSize);
                 await this.client.upsert(name, {
                     wait: true,
-                    points: batch.map(doc => ({
+                    points: batch.map((doc) => ({
                         id: doc.id ?? randomUUID(),
                         vector: { dense: doc.vector },
                         payload: {
@@ -81,6 +85,11 @@ export class QdrantVectorDB {
                             endLine: doc.endLine,
                             fileExtension: doc.fileExtension,
                             language: doc.language,
+                            fileCategory: doc.fileCategory ?? 'source',
+                            symbolName: doc.symbolName ?? '',
+                            symbolKind: doc.symbolKind ?? '',
+                            symbolSignature: doc.symbolSignature ?? '',
+                            parentSymbol: doc.parentSymbol ?? '',
                         },
                     })),
                 });
@@ -95,7 +104,7 @@ export class QdrantVectorDB {
             const fetchLimit = params.limit * 2;
             const extensionFilter = params.extensionFilter?.length
                 ? {
-                    should: params.extensionFilter.map(ext => ({
+                    should: params.extensionFilter.map((ext) => ({
                         key: 'fileExtension',
                         match: { value: ext },
                     })),
@@ -118,15 +127,51 @@ export class QdrantVectorDB {
                 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 getById(name, id) {
+        try {
+            const results = await this.client.retrieve(name, {
+                ids: [id],
+                with_payload: true,
+                with_vector: true,
+            });
+            if (results.length === 0)
+                return null;
+            const point = results[0];
+            const vectors = point.vector;
+            const vector = Array.isArray(vectors) ? vectors : (vectors?.dense ?? []);
+            return {
+                payload: point.payload ?? {},
+                vector,
+            };
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to retrieve point "${id}" from "${name}"`, err);
+        }
+    }
+    async updatePoint(name, id, vector, payload) {
+        try {
+            await this.client.upsert(name, {
+                wait: true,
+                points: [
+                    {
+                        id,
+                        vector: { dense: vector },
+                        payload,
+                    },
+                ],
+            });
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to update point "${id}" in "${name}"`, err);
+        }
+    }
     async deleteByPath(name, relativePath) {
         try {
             await this.client.delete(name, {
@@ -140,43 +185,74 @@ export class QdrantVectorDB {
             throw new VectorDBError(`Failed to delete documents for path "${relativePath}" from "${name}"`, err);
         }
     }
+    async listSymbols(name) {
+        try {
+            const results = [];
+            let offset = undefined;
+            const pageSize = 1000;
+            while (true) {
+                const response = await this.client.scroll(name, {
+                    filter: {
+                        must_not: [{ is_empty: { key: 'symbolName' } }],
+                    },
+                    limit: pageSize,
+                    with_payload: true,
+                    with_vector: false,
+                    ...(offset !== undefined ? { offset } : {}),
+                });
+                for (const point of response.points) {
+                    const p = point.payload ?? {};
+                    const symName = String(p.symbolName ?? '');
+                    if (!symName)
+                        continue;
+                    results.push({
+                        name: symName,
+                        kind: String(p.symbolKind ?? ''),
+                        relativePath: String(p.relativePath ?? ''),
+                        startLine: Number(p.startLine ?? 0),
+                        ...(p.symbolSignature ? { signature: String(p.symbolSignature) } : {}),
+                        ...(p.parentSymbol ? { parentName: String(p.parentSymbol) } : {}),
+                    });
+                }
+                if (response.next_page_offset == null || response.points.length < pageSize)
+                    break;
+                offset = response.next_page_offset;
+            }
+            return results;
+        }
+        catch (err) {
+            throw new VectorDBError(`Failed to list symbols 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.
- */
+// Rank text-match results by normalized term frequency so RRF receives a meaningful ordering.
 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))];
+    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 => {
+        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
+            pattern.lastIndex = 0;
             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 => ({
+    return scored.map((s) => ({
         ...s.point,
         rawScore: maxTf > 0 ? s.tf / maxTf : 0,
     }));
@@ -191,19 +267,15 @@ export function extractPayload(point) {
         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();
-    // 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 rawSim = point.score ?? 0;
         const score = blendedScore(rank, rawSim);
         const existing = scoreMap.get(point.id);
         const payload = extractPayload(point);
@@ -214,7 +286,6 @@ export function reciprocalRankFusion(denseResults, textResults, limit) {
             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);
@@ -236,6 +307,7 @@ export function reciprocalRankFusion(denseResults, textResults, limit) {
         fileExtension: payload.fileExtension,
         language: payload.language,
         score,
+        fileCategory: payload.fileCategory,
     }));
 }
 //# sourceMappingURL=qdrant.js.map

package/dist/vectordb/types.d.ts

@@ -8,6 +8,19 @@ export interface CodeDocument {
     endLine: number;
     fileExtension: string;
     language: string;
+    fileCategory?: string;
+    symbolName?: string;
+    symbolKind?: string;
+    symbolSignature?: string;
+    parentSymbol?: string;
+}
+export interface SymbolEntry {
+    name: string;
+    kind: string;
+    relativePath: string;
+    startLine: number;
+    signature?: string;
+    parentName?: string;
 }
 export interface HybridSearchParams {
     queryVector: EmbeddingVector;
@@ -23,6 +36,7 @@ export interface SearchResult {
     fileExtension: string;
     language: string;
     score: number;
+    fileCategory?: string;
 }
 export interface VectorDB {
     createCollection(name: string, dimension: number): Promise<void>;
@@ -31,5 +45,11 @@ export interface VectorDB {
     insert(name: string, documents: CodeDocument[]): Promise<void>;
     search(name: string, params: HybridSearchParams): Promise<SearchResult[]>;
     deleteByPath(name: string, relativePath: string): Promise<void>;
+    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>;
+    listSymbols(name: string): Promise<SymbolEntry[]>;
 }
 //# sourceMappingURL=types.d.ts.map

package/messages.yaml

@@ -0,0 +1,50 @@
+# Eidetic user-facing messages — edit here, everything else reads from this file.
+
+setup:
+  missing:
+    header: "Eidetic setup required: No API key configured."
+    diagnosis: >
+      `OPENAI_API_KEY` is not set and no alternative provider is configured.
+    step1: "**Get an API key**: https://platform.openai.com/api-keys"
+
+  invalid:
+    header: "Eidetic setup failed: {error}"
+    diagnosis: >
+      Key/provider is configured but initialization failed.
+      The key may be invalid, expired, or the provider may be unreachable.
+    step1: "**Verify your key** is valid and has embedding permissions"
+
+  unknown:
+    header: "Eidetic setup failed: {error}"
+    diagnosis: ""
+    step1: "**Get an API key**: https://platform.openai.com/api-keys"
+
+  # Shared across all contexts
+  config_instructions: |
+    ### Windows
+    ```
+      setx OPENAI_API_KEY sk-your-key-here
+    ```
+
+    ### macOS / Linux
+    Add to your shell profile (`~/.bashrc`, `~/.zshrc`, etc.):
+    ```
+      export OPENAI_API_KEY="sk-your-key-here"
+    ```
+
+    ### Manual
+
+    Edit `~/.claude/plugins/claude-eidetic/config.json`:
+    ```json
+    {
+      "env": {
+        "OPENAI_API_KEY": "sk-your-key-here"
+      }
+    }
+    ```
+
+    ### Using Ollama instead (free, local)
+
+    Set `EMBEDDING_PROVIDER=ollama` in the same env block (requires Ollama running locally with `nomic-embed-text`).
+
+  footer: "**Restart Claude Code** for changes to take effect."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-eidetic",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Semantic code search MCP server — lean, correct, fast",
   "type": "module",
   "main": "dist/index.js",
@@ -11,27 +11,37 @@
     "dist/**/*.js",
     "dist/**/*.d.ts",
     "!dist/**/*.test.*",
-    "!dist/__test__/**",
-    "!dist/e2e/**"
+    "!dist/__tests__/**",
+    "!dist/**/tests/**",
+    "!dist/e2e/**",
+    "messages.yaml"
   ],
   "scripts": {
     "build": "tsc",
     "dev": "tsx --watch src/index.ts",
     "start": "node dist/index.js",
     "clean": "rimraf dist",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
     "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"
+    "test:eval": "tsx scripts/eval/recall-at-k.ts && tsx scripts/eval/fusion-lift.ts && tsx scripts/eval/ndcg.ts",
+    "test:eval:generate": "tsx scripts/eval/generate-queries.ts",
+    "prepublishOnly": "npm run clean && npm run build",
+    "release": "bash scripts/release.sh"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@qdrant/js-client-rest": "^1.13.0",
-    "glob": "^10.0.0",
+    "better-sqlite3": "^12.6.2",
+    "glob": "^11.0.0",
     "openai": "^5.1.1",
     "tree-sitter": "^0.21.1",
     "tree-sitter-c-sharp": "^0.21.0",
@@ -42,21 +52,36 @@
     "tree-sitter-python": "^0.21.0",
     "tree-sitter-rust": "^0.21.0",
     "tree-sitter-typescript": "^0.21.0",
+    "yaml": "^2.8.2",
     "zod": "^3.25.0"
   },
   "optionalDependencies": {
     "@zilliz/milvus2-sdk-node": "^2.5.10"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.3",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^20.0.0",
     "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.39.3",
+    "eslint-config-prettier": "^10.1.8",
+    "prettier": "^3.8.1",
     "rimraf": "^6.0.1",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
+    "typescript-eslint": "^8.56.0",
     "vitest": "^4.0.18"
   },
+  "overrides": {
+    "minimatch": "^10.2.1",
+    "@grpc/grpc-js": "^1.8.22"
+  },
   "engines": {
     "node": ">=20.0.0"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eidetics/claude-eidetic"
+  },
   "license": "MIT"
 }