claude-eidetic 0.1.1 → 0.1.2

package/dist/core/sync.js

@@ -3,34 +3,60 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { glob } from 'glob';
 const DEFAULT_EXTENSIONS = new Set([
-    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
-    '.py', '.pyi',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.py',
+    '.pyi',
     '.go',
     '.java',
     '.rs',
-    '.cpp', '.cc', '.cxx', '.c', '.h', '.hpp',
+    '.cpp',
+    '.cc',
+    '.cxx',
+    '.c',
+    '.h',
+    '.hpp',
     '.cs',
     '.scala',
     '.rb',
     '.php',
     '.swift',
-    '.kt', '.kts',
+    '.kt',
+    '.kts',
     '.lua',
-    '.sh', '.bash', '.zsh',
+    '.sh',
+    '.bash',
+    '.zsh',
     '.sql',
-    '.r', '.R',
-    '.m', '.mm', // Objective-C
+    '.r',
+    '.R',
+    '.m',
+    '.mm', // Objective-C
     '.dart',
-    '.ex', '.exs', // Elixir
-    '.erl', '.hrl', // Erlang
+    '.ex',
+    '.exs', // Elixir
+    '.erl',
+    '.hrl', // Erlang
     '.hs', // Haskell
-    '.ml', '.mli', // OCaml
-    '.vue', '.svelte', '.astro',
-    '.yaml', '.yml',
+    '.ml',
+    '.mli', // OCaml
+    '.vue',
+    '.svelte',
+    '.astro',
+    '.yaml',
+    '.yml',
     '.toml',
     '.json',
-    '.md', '.mdx',
-    '.html', '.css', '.scss', '.less',
+    '.md',
+    '.mdx',
+    '.html',
+    '.css',
+    '.scss',
+    '.less',
 ]);
 const DEFAULT_IGNORE = [
     '**/node_modules/**',
@@ -51,13 +77,8 @@ const DEFAULT_IGNORE = [
     '**/pnpm-lock.yaml',
     '**/yarn.lock',
 ];
-/**
- * Scan a directory and return relative paths of indexable files.
- * Respects .gitignore if present.
- */
 export async function scanFiles(rootPath, customExtensions = [], customIgnore = []) {
     const extensions = new Set([...DEFAULT_EXTENSIONS, ...customExtensions]);
-    // Read .gitignore patterns if present
     const gitignorePatterns = readGitignore(rootPath);
     const allIgnore = [...DEFAULT_IGNORE, ...gitignorePatterns, ...customIgnore];
     const files = await glob('**/*', {
@@ -67,22 +88,12 @@ export async function scanFiles(rootPath, customExtensions = [], customIgnore =
         ignore: allIgnore,
         absolute: false,
     });
-    return files
-        .filter(f => extensions.has(path.extname(f).toLowerCase()))
-        .sort();
+    return files.filter((f) => extensions.has(path.extname(f).toLowerCase())).sort();
 }
-/**
- * Compute a truncated SHA-256 hash of a file's contents.
- * 16 hex chars (64 bits) is sufficient for change detection — collisions
- * would only cause a redundant re-index, not data loss.
- */
 function hashFileContent(fullPath) {
     const content = fs.readFileSync(fullPath);
     return createHash('sha256').update(content).digest('hex').slice(0, 16);
 }
-/**
- * Build a size+contentHash snapshot for a list of files.
- */
 export function buildSnapshot(rootPath, relativePaths) {
     const snapshot = {};
     for (const rel of relativePaths) {
@@ -92,16 +103,11 @@ export function buildSnapshot(rootPath, relativePaths) {
             snapshot[rel] = { contentHash };
         }
         catch (err) {
-            console.warn(`Skipping "${rel}": ${err}`);
+            console.warn(`Skipping "${rel}":`, err);
         }
     }
     return snapshot;
 }
-/**
- * Compare current snapshot to a previous one. Returns added, modified, and removed files.
- * Uses content hash as the authoritative change signal — immune to git ops, IDE formatters,
- * NFS clock skew, and other mtime-only pitfalls.
- */
 export function diffSnapshots(previous, current) {
     const added = [];
     const modified = [];
@@ -122,31 +128,23 @@ export function diffSnapshots(previous, current) {
     }
     return { added, modified, removed };
 }
-/**
- * Parse .gitignore content into glob patterns.
- * Pure function — no filesystem access.
- */
 export function parseGitignorePatterns(content) {
     return content
         .split('\n')
-        .map(line => line.trim())
-        .filter(line => line && !line.startsWith('#') && !line.startsWith('!'))
-        .map(pattern => {
-        // Strip trailing spaces (gitignore spec)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#') && !line.startsWith('!'))
+        .map((pattern) => {
         pattern = pattern.replace(/\s+$/, '');
-        // Directory-only patterns: trailing /
         if (pattern.endsWith('/')) {
             pattern = pattern.slice(0, -1);
         }
-        // Rooted patterns: leading /
         if (pattern.startsWith('/'))
             return pattern.slice(1);
-        // Unrooted patterns without / match anywhere
         if (!pattern.includes('/'))
             return `**/${pattern}`;
         return pattern;
     })
-        .filter(p => p.length > 0);
+        .filter((p) => p.length > 0);
 }
 function readGitignore(rootPath) {
     const gitignorePath = path.join(rootPath, '.gitignore');
@@ -158,30 +156,57 @@ function readGitignore(rootPath) {
         return [];
     }
 }
-/**
- * Map file extension to language name for the splitter.
- */
 export function extensionToLanguage(ext) {
     const map = {
-        '.ts': 'typescript', '.tsx': 'tsx',
-        '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
-        '.py': 'python', '.pyi': 'python',
+        '.ts': 'typescript',
+        '.tsx': 'tsx',
+        '.js': 'javascript',
+        '.jsx': 'javascript',
+        '.mjs': 'javascript',
+        '.cjs': 'javascript',
+        '.py': 'python',
+        '.pyi': 'python',
         '.go': 'go',
         '.java': 'java',
         '.rs': 'rust',
-        '.cpp': 'cpp', '.cc': 'cpp', '.cxx': 'cpp', '.c': 'c', '.h': 'cpp', '.hpp': 'cpp',
+        '.cpp': 'cpp',
+        '.cc': 'cpp',
+        '.cxx': 'cpp',
+        '.c': 'c',
+        '.h': 'cpp',
+        '.hpp': 'cpp',
         '.cs': 'csharp',
         '.scala': 'scala',
-        '.rb': 'ruby', '.php': 'php', '.swift': 'swift',
-        '.kt': 'kotlin', '.kts': 'kotlin',
-        '.lua': 'lua', '.sh': 'bash', '.bash': 'bash', '.zsh': 'bash',
-        '.sql': 'sql', '.r': 'r', '.R': 'r',
-        '.dart': 'dart', '.ex': 'elixir', '.exs': 'elixir',
-        '.hs': 'haskell', '.ml': 'ocaml',
-        '.vue': 'vue', '.svelte': 'svelte', '.astro': 'astro',
-        '.yaml': 'yaml', '.yml': 'yaml', '.toml': 'toml', '.json': 'json',
-        '.md': 'markdown', '.mdx': 'markdown',
-        '.html': 'html', '.css': 'css', '.scss': 'scss', '.less': 'less',
+        '.rb': 'ruby',
+        '.php': 'php',
+        '.swift': 'swift',
+        '.kt': 'kotlin',
+        '.kts': 'kotlin',
+        '.lua': 'lua',
+        '.sh': 'bash',
+        '.bash': 'bash',
+        '.zsh': 'bash',
+        '.sql': 'sql',
+        '.r': 'r',
+        '.R': 'r',
+        '.dart': 'dart',
+        '.ex': 'elixir',
+        '.exs': 'elixir',
+        '.hs': 'haskell',
+        '.ml': 'ocaml',
+        '.vue': 'vue',
+        '.svelte': 'svelte',
+        '.astro': 'astro',
+        '.yaml': 'yaml',
+        '.yml': 'yaml',
+        '.toml': 'toml',
+        '.json': 'json',
+        '.md': 'markdown',
+        '.mdx': 'markdown',
+        '.html': 'html',
+        '.css': 'css',
+        '.scss': 'scss',
+        '.less': 'less',
     };
     return map[ext.toLowerCase()] ?? 'unknown';
 }

package/dist/core/targeted-indexer.d.ts

@@ -0,0 +1,19 @@
+import type { Embedding } from '../embedding/types.js';
+import type { VectorDB } from '../vectordb/types.js';
+export interface TargetedIndexResult {
+    processedFiles: number;
+    totalChunks: number;
+    skippedFiles: number;
+    durationMs: number;
+}
+/**
+ * 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 declare function indexFiles(rootPath: string, relativePaths: string[], embedding: Embedding, vectordb: VectorDB): Promise<TargetedIndexResult>;
+//# sourceMappingURL=targeted-indexer.d.ts.map

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 './snapshot-io.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

@@ -1,17 +1,4 @@
 import type { Config } from '../config.js';
 import type { Embedding } from './types.js';
-/**
- * Create an Embedding instance based on the configured provider.
- *
- * - 'openai'  Uses the OpenAI API directly (requires OPENAI_API_KEY).
- * - 'ollama'  Uses Ollama's OpenAI-compatible /v1/embeddings endpoint.
- *             No API key required; defaults to model "nomic-embed-text".
- * - 'local'   Uses any OpenAI-compatible server at OPENAI_BASE_URL.
- *             Useful for LM Studio, vLLM, LocalAI, etc.
- *
- * The key insight is that Ollama and most local servers expose an
- * OpenAI-compatible embeddings API, so we reuse OpenAIEmbedding
- * with different connection parameters rather than creating separate classes.
- */
 export declare function createEmbedding(config: Config): Embedding;
 //# sourceMappingURL=factory.d.ts.map

package/dist/embedding/factory.js

@@ -1,32 +1,15 @@
 import { OpenAIEmbedding } from './openai.js';
-/**
- * Create an Embedding instance based on the configured provider.
- *
- * - 'openai'  Uses the OpenAI API directly (requires OPENAI_API_KEY).
- * - 'ollama'  Uses Ollama's OpenAI-compatible /v1/embeddings endpoint.
- *             No API key required; defaults to model "nomic-embed-text".
- * - 'local'   Uses any OpenAI-compatible server at OPENAI_BASE_URL.
- *             Useful for LM Studio, vLLM, LocalAI, etc.
- *
- * The key insight is that Ollama and most local servers expose an
- * OpenAI-compatible embeddings API, so we reuse OpenAIEmbedding
- * with different connection parameters rather than creating separate classes.
- */
 export function createEmbedding(config) {
     switch (config.embeddingProvider) {
         case 'openai':
             return new OpenAIEmbedding();
         case 'ollama':
-            // Ollama exposes OpenAI-compatible /v1/embeddings endpoint.
-            // It ignores the API key but the OpenAI SDK requires a non-empty string.
             return new OpenAIEmbedding({
                 apiKey: config.openaiApiKey || 'ollama',
                 baseUrl: config.ollamaBaseUrl,
                 model: config.embeddingModel,
             });
         case 'local':
-            // Generic OpenAI-compatible endpoint (LM Studio, vLLM, LocalAI, etc.).
-            // API key is optional (many local servers skip auth).
             return new OpenAIEmbedding({
                 apiKey: config.openaiApiKey || 'local',
                 baseUrl: config.openaiBaseUrl,

package/dist/embedding/openai.d.ts

@@ -1,4 +1,4 @@
-import { type Embedding, type EmbeddingVector } from './types.js';
+import { type Embedding, type EmbeddingVector, type TokenEstimate } from './types.js';
 export declare function contentHash(text: string): string;
 export interface OpenAIEmbeddingOptions {
     apiKey?: string;
@@ -22,19 +22,7 @@ export declare class OpenAIEmbedding implements Embedding {
     private ensureInitialized;
     embed(text: string): Promise<EmbeddingVector>;
     embedBatch(texts: string[]): Promise<EmbeddingVector[]>;
-    /**
-     * Estimate the token cost for embedding a set of texts.
-     * Rough heuristic: ~4 chars per token for code.
-     * Cost rates are model-specific; local models (Ollama, etc.) are free.
-     */
-    estimateTokens(texts: string[]): {
-        totalChars: number;
-        estimatedTokens: number;
-        estimatedCostUsd: number;
-    };
-    /**
-     * Set a value in the memory cache, evicting the oldest entry if at capacity.
-     */
+    estimateTokens(texts: string[]): TokenEstimate;
     private setMemoryCache;
     private callWithRetry;
     private callApi;

package/dist/embedding/openai.js

@@ -115,21 +115,14 @@ export class OpenAIEmbedding {
             const hash = contentHash(texts[idx]);
             const vec = freshEmbeddings[i];
             this.setMemoryCache(hash, vec);
-            // Fire-and-forget: don't await the disk write
             this.writeDiskCache(hash, vec);
             results[idx] = vec;
         }
-        // Verify no nulls remain before casting
-        if (results.some(r => r === null)) {
+        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;
     }
-    /**
-     * Estimate the token cost for embedding a set of texts.
-     * Rough heuristic: ~4 chars per token for code.
-     * Cost rates are model-specific; local models (Ollama, etc.) are free.
-     */
     estimateTokens(texts) {
         const totalChars = texts.reduce((sum, t) => sum + t.length, 0);
         const estimatedTokens = Math.ceil(totalChars / 4);
@@ -137,15 +130,12 @@ export class OpenAIEmbedding {
         const COST_PER_MILLION = {
             'text-embedding-3-small': 0.02,
             'text-embedding-3-large': 0.13,
-            'text-embedding-ada-002': 0.10,
+            '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 };
     }
-    /**
-     * Set a value in the memory cache, evicting the oldest entry if at capacity.
-     */
     setMemoryCache(hash, vec) {
         if (this.memoryCache.size >= MAX_MEMORY_CACHE_SIZE && !this.memoryCache.has(hash)) {
             // Delete the oldest entry (first key from the iterator)
@@ -192,7 +182,6 @@ export class OpenAIEmbedding {
                 await sleep(delay);
             }
         }
-        // Unreachable but satisfies TypeScript compiler
         throw new EmbeddingError('Unexpected: exhausted retries');
     }
     async callApi(texts) {
@@ -200,9 +189,8 @@ export class OpenAIEmbedding {
             model: this.model,
             input: texts.map(truncateToSafeLength),
         });
-        // Sort by index to guarantee order (API may return out-of-order)
         const sorted = response.data.sort((a, b) => a.index - b.index);
-        return sorted.map(d => d.embedding);
+        return sorted.map((d) => d.embedding);
     }
     getDiskCachePath(hash) {
         // Shard into subdirectories to avoid too many files in one dir
@@ -230,14 +218,13 @@ export class OpenAIEmbedding {
     writeDiskCache(hash, vector) {
         const filepath = this.getDiskCachePath(hash);
         // Fire-and-forget async write
-        fsp.mkdir(path.dirname(filepath), { recursive: true })
+        fsp
+            .mkdir(path.dirname(filepath), { recursive: true })
             .then(() => fsp.writeFile(filepath, JSON.stringify(vector)))
-            .catch(() => {
-            // Non-fatal: cache write failure doesn't block indexing
-        });
+            .catch(() => { });
     }
 }
 function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 //# sourceMappingURL=openai.js.map

package/dist/errors.d.ts

@@ -14,4 +14,6 @@ export declare class SearchError extends EideticError {
 }
 export declare class BootstrapError extends EideticError {
 }
+export declare class MemoryError extends EideticError {
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -18,4 +18,6 @@ export class SearchError extends EideticError {
 }
 export class BootstrapError extends EideticError {
 }
+export class MemoryError extends EideticError {
+}
 //# sourceMappingURL=errors.js.map

package/dist/format.d.ts

@@ -1,12 +1,24 @@
+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';
+import type { MemoryItem, MemoryAction } from './memory/types.js';
+import type { HistoryEntry } from './memory/history.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;
+export declare function formatMemoryActions(actions: MemoryAction[]): string;
+export declare function formatMemorySearchResults(items: MemoryItem[], query: string): string;
+export declare function formatMemoryList(items: MemoryItem[]): string;
+export declare function formatMemoryHistory(entries: HistoryEntry[], memoryId: string): string;
 //# sourceMappingURL=format.d.ts.map