claude-eidetic 0.1.1 → 0.1.2

package/dist/splitter/symbol-extract.js

@@ -0,0 +1,61 @@
+const CONTAINER_TYPES = new Set(['class_declaration', 'class_definition', 'interface_declaration']);
+const KIND_MAP = {
+    function_declaration: 'function',
+    arrow_function: 'function',
+    async_function_definition: 'function',
+    function_definition: 'function',
+    class_declaration: 'class',
+    class_definition: 'class',
+    interface_declaration: 'interface',
+    method_definition: 'method',
+    method_declaration: 'method',
+    type_alias_declaration: 'type',
+    enum_declaration: 'enum',
+    // Java
+    constructor_declaration: 'constructor',
+    // Rust
+    function_item: 'function',
+    impl_item: 'impl',
+    struct_item: 'struct',
+    enum_item: 'enum',
+    trait_item: 'trait',
+    // C#
+    struct_declaration: 'struct',
+};
+function getIdentifier(node, code) {
+    const identChild = node.children.find((c) => c.type === 'identifier' || c.type === 'type_identifier' || c.type === 'name');
+    if (identChild)
+        return code.slice(identChild.startIndex, identChild.endIndex);
+    return undefined;
+}
+function extractSignature(node, code) {
+    const text = code.slice(node.startIndex, node.endIndex);
+    // Take first line up to opening brace or end of line
+    const firstLine = text.split('\n')[0];
+    const upToBrace = firstLine.split('{')[0].trimEnd();
+    const sig = upToBrace || firstLine;
+    return sig.length > 200 ? sig.slice(0, 200) + '…' : sig;
+}
+export function extractSymbolInfo(node, code, parentName) {
+    const nodeType = node.type;
+    // Handle export_statement: recurse into declaration child
+    if (nodeType === 'export_statement') {
+        const declChild = node.children.find((c) => c.type !== 'export' && c.type !== 'default' && c.type !== ';' && c.type !== 'identifier');
+        if (declChild)
+            return extractSymbolInfo(declChild, code, parentName);
+        return undefined;
+    }
+    const kind = KIND_MAP[nodeType];
+    if (!kind)
+        return undefined;
+    const name = getIdentifier(node, code);
+    if (!name)
+        return undefined;
+    const signature = extractSignature(node, code);
+    void parentName; // consumed by caller to set chunk.parentSymbol
+    return { name, kind, signature };
+}
+export function isContainerType(nodeType) {
+    return CONTAINER_TYPES.has(nodeType);
+}
+//# sourceMappingURL=symbol-extract.js.map

package/dist/splitter/types.d.ts

@@ -1,9 +1,14 @@
+export declare const MAX_CHUNK_CHARS = 2500;
 export interface CodeChunk {
     content: string;
     startLine: number;
     endLine: number;
     language: string;
     filePath: string;
+    symbolName?: string;
+    symbolKind?: string;
+    symbolSignature?: string;
+    parentSymbol?: string;
 }
 export interface Splitter {
     split(code: string, language: string, filePath: string): CodeChunk[];

package/dist/splitter/types.js

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

package/dist/state/doc-metadata.d.ts

@@ -0,0 +1,18 @@
+export interface DocEntry {
+    library: string;
+    topic: string;
+    source: string;
+    collectionName: string;
+    indexedAt: string;
+    ttlDays: number;
+    totalChunks: number;
+}
+export type DocMetadata = Record<string, DocEntry>;
+export declare function loadDocMetadata(): DocMetadata;
+export declare function saveDocMetadata(metadata: DocMetadata): void;
+export declare function upsertDocEntry(entry: DocEntry): void;
+export declare function removeDocEntry(library: string, topic: string): boolean;
+export declare function findDocEntries(library: string): DocEntry[];
+export declare function isStale(entry: DocEntry): boolean;
+export declare function listDocLibraries(): string[];
+//# sourceMappingURL=doc-metadata.d.ts.map

package/dist/state/doc-metadata.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDocMetadataPath } from '../paths.js';
+function metadataKey(library, topic) {
+    return `${library.toLowerCase()}::${topic.toLowerCase()}`;
+}
+export function loadDocMetadata() {
+    const metadataPath = getDocMetadataPath();
+    try {
+        const data = fs.readFileSync(metadataPath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+export function saveDocMetadata(metadata) {
+    const metadataPath = getDocMetadataPath();
+    const dir = path.dirname(metadataPath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2) + '\n', 'utf-8');
+}
+export function upsertDocEntry(entry) {
+    const metadata = loadDocMetadata();
+    const key = metadataKey(entry.library, entry.topic);
+    metadata[key] = entry;
+    saveDocMetadata(metadata);
+}
+export function removeDocEntry(library, topic) {
+    const metadata = loadDocMetadata();
+    const key = metadataKey(library, topic);
+    if (!(key in metadata))
+        return false;
+    Reflect.deleteProperty(metadata, key);
+    saveDocMetadata(metadata);
+    return true;
+}
+export function findDocEntries(library) {
+    const metadata = loadDocMetadata();
+    const prefix = `${library.toLowerCase()}::`;
+    return Object.entries(metadata)
+        .filter(([key]) => key.startsWith(prefix))
+        .map(([, entry]) => entry);
+}
+export function isStale(entry) {
+    const indexedAt = new Date(entry.indexedAt).getTime();
+    const now = Date.now();
+    const ttlMs = entry.ttlDays * 24 * 60 * 60 * 1000;
+    return now - indexedAt > ttlMs;
+}
+export function listDocLibraries() {
+    const metadata = loadDocMetadata();
+    const libs = new Set();
+    for (const entry of Object.values(metadata)) {
+        libs.add(entry.library);
+    }
+    return [...libs].sort();
+}
+//# sourceMappingURL=doc-metadata.js.map

package/dist/state/registry.d.ts

@@ -1,6 +1,4 @@
-interface Registry {
-    [project: string]: string;
-}
+type Registry = Record<string, string>;
 export declare function registerProject(absolutePath: string): void;
 export declare function resolveProject(project: string): string | undefined;
 export declare function listProjects(): Registry;

package/dist/state/snapshot.d.ts

@@ -20,7 +20,6 @@ export declare class StateManager {
     setIndexed(normalizedPath: string, totalFiles: number, totalChunks: number): void;
     setError(normalizedPath: string, error: string): void;
     remove(normalizedPath: string): void;
-    markExisting(normalizedPath: string, collectionName: string): void;
 }
 export declare function cleanupOrphanedSnapshots(vectordb: VectorDB): Promise<number>;
 //# sourceMappingURL=snapshot.d.ts.map

package/dist/state/snapshot.js

@@ -46,14 +46,6 @@ export class StateManager {
     remove(normalizedPath) {
         this.states.delete(normalizedPath);
     }
-    markExisting(normalizedPath, collectionName) {
-        this.states.set(normalizedPath, {
-            path: normalizedPath,
-            collectionName,
-            status: 'indexed',
-            lastIndexed: 'unknown (pre-existing)',
-        });
-    }
 }
 export async function cleanupOrphanedSnapshots(vectordb) {
     const snapshotDir = getSnapshotDir();
@@ -61,16 +53,10 @@ export async function cleanupOrphanedSnapshots(vectordb) {
     try {
         if (!fs.existsSync(snapshotDir))
             return 0;
-        const files = fs.readdirSync(snapshotDir).filter(f => f.endsWith('.json'));
+        const files = fs.readdirSync(snapshotDir).filter((f) => f.endsWith('.json'));
         if (files.length === 0)
             return 0;
-        // Connectivity probe: use a name unlikely to exist. If hasCollection throws
-        // or the vector DB is unreachable (Qdrant's hasCollection returns false on
-        // network error), we must not proceed -- deleting snapshots when we cannot
-        // confirm collection absence would destroy valid state.
         const probeResult = await vectordb.hasCollection('__eidetic_connectivity_probe__');
-        // If the probe returns true for a name that should never exist, something is
-        // wrong -- skip cleanup to be safe.
         if (probeResult) {
             console.warn('Orphan cleanup skipped: connectivity probe returned unexpected result.');
             return 0;
@@ -87,14 +73,12 @@ export async function cleanupOrphanedSnapshots(vectordb) {
                 }
             }
             catch (err) {
-                // Network error for this specific check -- skip rather than risk deletion
-                console.warn(`Skipping orphan check for ${collectionName}: ${err}`);
+                console.warn(`Skipping orphan check for ${collectionName}:`, err);
             }
         }
     }
     catch (err) {
-        // Connectivity probe failure or filesystem error -- skip cleanup entirely
-        console.warn(`Orphan cleanup skipped: ${err}`);
+        console.warn('Orphan cleanup skipped:', err);
     }
     return cleaned;
 }

package/dist/tool-schemas.d.ts

@@ -43,7 +43,7 @@ export declare const TOOL_DEFINITIONS: readonly [{
     };
 }, {
     readonly name: "search_code";
-    readonly description: "Search the indexed codebase using natural language queries.\n\nProvide either `path` (absolute) or `project` (name). Use `list_indexed` to see registered projects.\n\nWhen to Use:\n- Code search: Find specific functions, classes, or implementations\n- Context-aware assistance: Gather relevant code context before making changes\n- Issue identification: Locate problematic code sections or bugs\n- Code review: Understand existing implementations and patterns\n- Refactoring: Find all related code pieces that need to be updated\n- Feature development: Understand existing architecture and similar implementations\n- Duplicate detection: Identify redundant or duplicated code patterns\n\nIf the codebase is not indexed, this tool will return a clear error message indicating that indexing is required first.";
+    readonly description: "Search the indexed codebase using natural language queries.\nPrefer over Grep for conceptual/semantic queries — returns ~20 tokens/result vs ~100+ for Grep.\nTry before launching an Explore agent — faster and cheaper for understanding code.\n\nProvide either `path` (absolute) or `project` (name). Use `list_indexed` to see registered projects.\n\nWhen to Use:\n- Code search: Find specific functions, classes, or implementations\n- Context-aware assistance: Gather relevant code context before making changes\n- Issue identification: Locate problematic code sections or bugs\n- Code review: Understand existing implementations and patterns\n- Refactoring: Find all related code pieces that need to be updated\n- Feature development: Understand existing architecture and similar implementations\n- Duplicate detection: Identify redundant or duplicated code patterns\n\nIf the codebase is not indexed, this tool will return a clear error message indicating that indexing is required first.";
     readonly inputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -123,6 +123,256 @@ export declare const TOOL_DEFINITIONS: readonly [{
         readonly properties: {};
         readonly required: readonly [];
     };
+}, {
+    readonly name: "cleanup_vectors";
+    readonly description: "Remove orphaned vectors for files that no longer exist on disk. Lightweight alternative to re-indexing — no embedding cost.\n\nProvide either `path` (absolute) or `project` (name). Use `list_indexed` to see registered projects.\n\nUse `dryRun=true` first to preview which files would be cleaned without making any changes.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly description: "Absolute path to the codebase directory.";
+            };
+            readonly project: {
+                readonly type: "string";
+                readonly description: "Project name (resolves via registry). Use list_indexed to see registered projects.";
+            };
+            readonly dryRun: {
+                readonly type: "boolean";
+                readonly description: "List files that would be cleaned without actually deleting any vectors.";
+                readonly default: false;
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "index_document";
+    readonly description: "Cache external documentation (from query-docs, WebFetch, etc.) for cheap semantic search later.\n\nAfter fetching documentation from an external source, call this tool to store it. Subsequent queries about the same library will use search_documents (~20 tokens/result) instead of re-fetching (~5K+ tokens).\n\nThe content is split into chunks, embedded, and stored in a vector collection grouped by library. A TTL tracks staleness — stale docs still return results but are flagged.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly content: {
+                readonly type: "string";
+                readonly description: "The full text content of the documentation to cache.";
+            };
+            readonly source: {
+                readonly type: "string";
+                readonly description: "Source URL or identifier (e.g., \"https://docs.langfuse.com/guides/evaluators\" or \"context7:langfuse/hooks\").";
+            };
+            readonly library: {
+                readonly type: "string";
+                readonly description: "Library name (e.g., \"react\", \"langfuse\"). Used for collection grouping.";
+            };
+            readonly topic: {
+                readonly type: "string";
+                readonly description: "Topic within the library (e.g., \"hooks\", \"evaluators\").";
+            };
+            readonly ttlDays: {
+                readonly type: "number";
+                readonly description: "Days before the cached content is considered stale.";
+                readonly default: 7;
+            };
+        };
+        readonly required: readonly ["content", "source", "library", "topic"];
+    };
+}, {
+    readonly name: "search_documents";
+    readonly description: "Search cached documentation using natural language queries.\n\nReturns results from previously cached documentation (via index_document). Much cheaper than re-fetching docs (~20 tokens/result vs ~5K+ tokens/fetch).\n\nIf a specific library is provided, searches only that library's collection. Otherwise searches across all cached documentation. Results include staleness indicators.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+                readonly description: "Natural language query to search cached documentation.";
+            };
+            readonly library: {
+                readonly type: "string";
+                readonly description: "Optional: limit search to a specific library (e.g., \"langfuse\"). Omit to search all cached docs.";
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "Maximum number of results to return.";
+                readonly default: 5;
+                readonly maximum: 20;
+            };
+        };
+        readonly required: readonly ["query"];
+    };
+}, {
+    readonly name: "read_file";
+    readonly description: "Read a file and return raw content without line-number overhead (~15-20% fewer tokens than built-in Read for code, more for short-line files).\n\nUse offset and limit to page through large files. Add lineNumbers=true only when you need line references for editing.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly description: "Absolute file path to read.";
+            };
+            readonly offset: {
+                readonly type: "number";
+                readonly description: "1-based line number to start reading from.";
+                readonly default: 1;
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "Maximum number of lines to return.";
+                readonly default: 5000;
+                readonly maximum: 10000;
+            };
+            readonly lineNumbers: {
+                readonly type: "boolean";
+                readonly description: "Prefix each line with its line number. Only enable when you need line references for editing.";
+                readonly default: false;
+            };
+        };
+        readonly required: readonly ["path"];
+    };
+}, {
+    readonly name: "add_memory";
+    readonly description: "Extract and store developer knowledge from text. Uses LLM to identify facts about coding style, tools, architecture, conventions, debugging insights, and workflow preferences. Automatically deduplicates against existing memories.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly content: {
+                readonly type: "string";
+                readonly description: "Text containing developer knowledge to extract and store (conversation snippets, notes, preferences).";
+            };
+            readonly source: {
+                readonly type: "string";
+                readonly description: "Optional source identifier (e.g., \"conversation\", \"claude-code\", \"user-note\").";
+            };
+        };
+        readonly required: readonly ["content"];
+    };
+}, {
+    readonly name: "search_memory";
+    readonly description: "Search stored developer memories using natural language. Returns semantically similar memories ranked by relevance.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+                readonly description: "Natural language query to search memories.";
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "Maximum number of results.";
+                readonly default: 10;
+                readonly maximum: 50;
+            };
+            readonly category: {
+                readonly type: "string";
+                readonly description: "Filter by category: coding_style, tools, architecture, conventions, debugging, workflow, preferences.";
+                readonly enum: readonly ["coding_style", "tools", "architecture", "conventions", "debugging", "workflow", "preferences"];
+            };
+        };
+        readonly required: readonly ["query"];
+    };
+}, {
+    readonly name: "list_memories";
+    readonly description: "List all stored developer memories, optionally filtered by category.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly category: {
+                readonly type: "string";
+                readonly description: "Filter by category: coding_style, tools, architecture, conventions, debugging, workflow, preferences.";
+                readonly enum: readonly ["coding_style", "tools", "architecture", "conventions", "debugging", "workflow", "preferences"];
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "Maximum number of memories to return.";
+                readonly default: 50;
+                readonly maximum: 100;
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "delete_memory";
+    readonly description: "Delete a specific memory by its ID.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly id: {
+                readonly type: "string";
+                readonly description: "The UUID of the memory to delete.";
+            };
+        };
+        readonly required: readonly ["id"];
+    };
+}, {
+    readonly name: "memory_history";
+    readonly description: "View the change history for a specific memory (additions, updates, deletions).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly id: {
+                readonly type: "string";
+                readonly description: "The UUID of the memory to view history for.";
+            };
+        };
+        readonly required: readonly ["id"];
+    };
+}, {
+    readonly name: "browse_structure";
+    readonly description: "Show a condensed structural map of the indexed codebase — classes, functions, methods with signatures, grouped by file.\nPrefer over Glob + Read cascades for understanding architecture — one call vs many.\n\nProvide either `path` (absolute) or `project` (name). Use `list_indexed` to see registered projects.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly description: "Absolute path to the codebase directory.";
+            };
+            readonly project: {
+                readonly type: "string";
+                readonly description: "Project name (resolves via registry). Use list_indexed to see registered projects.";
+            };
+            readonly pathFilter: {
+                readonly type: "string";
+                readonly description: "Glob pattern to filter by file path (e.g., \"src/core/**\", \"**/*.ts\").";
+            };
+            readonly kind: {
+                readonly type: "string";
+                readonly description: "Filter by symbol kind: function, class, interface, method, type, enum, etc.";
+            };
+            readonly maxTokens: {
+                readonly type: "number";
+                readonly description: "Approximate token budget for the output (1 token ≈ 4 chars). Default: 4000.";
+                readonly default: 4000;
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "list_symbols";
+    readonly description: "List symbols (functions, classes, methods, etc.) from the indexed codebase as a compact table. Supports filtering by name, kind, or path.\n\nProvide either `path` (absolute) or `project` (name). Use `list_indexed` to see registered projects.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly description: "Absolute path to the codebase directory.";
+            };
+            readonly project: {
+                readonly type: "string";
+                readonly description: "Project name (resolves via registry). Use list_indexed to see registered projects.";
+            };
+            readonly pathFilter: {
+                readonly type: "string";
+                readonly description: "Glob pattern to filter by file path (e.g., \"src/core/**\").";
+            };
+            readonly kind: {
+                readonly type: "string";
+                readonly description: "Filter by symbol kind: function, class, interface, method, type, enum, etc.";
+            };
+            readonly nameFilter: {
+                readonly type: "string";
+                readonly description: "Substring filter on symbol name (case-insensitive).";
+            };
+        };
+        readonly required: readonly [];
+    };
 }, {
     readonly name: "__IMPORTANT";
     readonly description: "Workflow guidance for efficient code search. ALWAYS index before searching. Use project names after first index. Use extensionFilter to narrow results.";