claude-eidetic 0.1.1 → 0.1.2

package/dist/tool-schemas.js

@@ -1,3 +1,31 @@
+const READ_FILE_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).
+
+Use offset and limit to page through large files. \
+Add lineNumbers=true only when you need line references for editing.`;
+const INDEX_DOCUMENT_DESCRIPTION = `\
+Cache external documentation (from query-docs, WebFetch, etc.) for cheap semantic search later.
+
+After 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).
+
+The 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.`;
+const SEARCH_DOCUMENTS_DESCRIPTION = `\
+Search cached documentation using natural language queries.
+
+Returns results from previously cached documentation (via index_document). \
+Much cheaper than re-fetching docs (~20 tokens/result vs ~5K+ tokens/fetch).
+
+If a specific library is provided, searches only that library's collection. \
+Otherwise searches across all cached documentation. Results include staleness indicators.`;
+const CLEANUP_DESCRIPTION = `\
+Remove orphaned vectors for files that no longer exist on disk. Lightweight alternative to re-indexing — no embedding cost.
+
+Provide either \`path\` (absolute) or \`project\` (name). Use \`list_indexed\` to see registered projects.
+
+Use \`dryRun=true\` first to preview which files would be cleaned without making any changes.`;
 const INDEX_DESCRIPTION = `\
 Index a codebase directory to enable semantic search using a configurable code splitter.
 
@@ -10,6 +38,8 @@ Usage Guidance:
 you MUST prompt the user to confirm whether to proceed with a force index.`;
 const SEARCH_DESCRIPTION = `\
 Search the indexed codebase using natural language queries.
+Prefer over Grep for conceptual/semantic queries — returns ~20 tokens/result vs ~100+ for Grep.
+Try before launching an Explore agent — faster and cheaper for understanding code.
 
 Provide either \`path\` (absolute) or \`project\` (name). Use \`list_indexed\` to see registered projects.
 
@@ -149,6 +179,283 @@ export const TOOL_DEFINITIONS = [
             required: [],
         },
     },
+    {
+        name: 'cleanup_vectors',
+        description: CLEANUP_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Absolute path to the codebase directory.',
+                },
+                project: {
+                    type: 'string',
+                    description: 'Project name (resolves via registry). Use list_indexed to see registered projects.',
+                },
+                dryRun: {
+                    type: 'boolean',
+                    description: 'List files that would be cleaned without actually deleting any vectors.',
+                    default: false,
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'index_document',
+        description: INDEX_DOCUMENT_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: {
+                    type: 'string',
+                    description: 'The full text content of the documentation to cache.',
+                },
+                source: {
+                    type: 'string',
+                    description: 'Source URL or identifier (e.g., "https://docs.langfuse.com/guides/evaluators" or "context7:langfuse/hooks").',
+                },
+                library: {
+                    type: 'string',
+                    description: 'Library name (e.g., "react", "langfuse"). Used for collection grouping.',
+                },
+                topic: {
+                    type: 'string',
+                    description: 'Topic within the library (e.g., "hooks", "evaluators").',
+                },
+                ttlDays: {
+                    type: 'number',
+                    description: 'Days before the cached content is considered stale.',
+                    default: 7,
+                },
+            },
+            required: ['content', 'source', 'library', 'topic'],
+        },
+    },
+    {
+        name: 'search_documents',
+        description: SEARCH_DOCUMENTS_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Natural language query to search cached documentation.',
+                },
+                library: {
+                    type: 'string',
+                    description: 'Optional: limit search to a specific library (e.g., "langfuse"). Omit to search all cached docs.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of results to return.',
+                    default: 5,
+                    maximum: 20,
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'read_file',
+        description: READ_FILE_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Absolute file path to read.',
+                },
+                offset: {
+                    type: 'number',
+                    description: '1-based line number to start reading from.',
+                    default: 1,
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of lines to return.',
+                    default: 5000,
+                    maximum: 10000,
+                },
+                lineNumbers: {
+                    type: 'boolean',
+                    description: 'Prefix each line with its line number. Only enable when you need line references for editing.',
+                    default: false,
+                },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'add_memory',
+        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.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: {
+                    type: 'string',
+                    description: 'Text containing developer knowledge to extract and store (conversation snippets, notes, preferences).',
+                },
+                source: {
+                    type: 'string',
+                    description: 'Optional source identifier (e.g., "conversation", "claude-code", "user-note").',
+                },
+            },
+            required: ['content'],
+        },
+    },
+    {
+        name: 'search_memory',
+        description: 'Search stored developer memories using natural language. Returns semantically similar memories ranked by relevance.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Natural language query to search memories.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of results.',
+                    default: 10,
+                    maximum: 50,
+                },
+                category: {
+                    type: 'string',
+                    description: 'Filter by category: coding_style, tools, architecture, conventions, debugging, workflow, preferences.',
+                    enum: [
+                        'coding_style',
+                        'tools',
+                        'architecture',
+                        'conventions',
+                        'debugging',
+                        'workflow',
+                        'preferences',
+                    ],
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'list_memories',
+        description: 'List all stored developer memories, optionally filtered by category.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                category: {
+                    type: 'string',
+                    description: 'Filter by category: coding_style, tools, architecture, conventions, debugging, workflow, preferences.',
+                    enum: [
+                        'coding_style',
+                        'tools',
+                        'architecture',
+                        'conventions',
+                        'debugging',
+                        'workflow',
+                        'preferences',
+                    ],
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of memories to return.',
+                    default: 50,
+                    maximum: 100,
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'delete_memory',
+        description: 'Delete a specific memory by its ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'The UUID of the memory to delete.',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'memory_history',
+        description: 'View the change history for a specific memory (additions, updates, deletions).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'string',
+                    description: 'The UUID of the memory to view history for.',
+                },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'browse_structure',
+        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.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Absolute path to the codebase directory.',
+                },
+                project: {
+                    type: 'string',
+                    description: 'Project name (resolves via registry). Use list_indexed to see registered projects.',
+                },
+                pathFilter: {
+                    type: 'string',
+                    description: 'Glob pattern to filter by file path (e.g., "src/core/**", "**/*.ts").',
+                },
+                kind: {
+                    type: 'string',
+                    description: 'Filter by symbol kind: function, class, interface, method, type, enum, etc.',
+                },
+                maxTokens: {
+                    type: 'number',
+                    description: 'Approximate token budget for the output (1 token ≈ 4 chars). Default: 4000.',
+                    default: 4000,
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'list_symbols',
+        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.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Absolute path to the codebase directory.',
+                },
+                project: {
+                    type: 'string',
+                    description: 'Project name (resolves via registry). Use list_indexed to see registered projects.',
+                },
+                pathFilter: {
+                    type: 'string',
+                    description: 'Glob pattern to filter by file path (e.g., "src/core/**").',
+                },
+                kind: {
+                    type: 'string',
+                    description: 'Filter by symbol kind: function, class, interface, method, type, enum, etc.',
+                },
+                nameFilter: {
+                    type: 'string',
+                    description: 'Substring filter on symbol name (case-insensitive).',
+                },
+            },
+            required: [],
+        },
+    },
     {
         name: '__IMPORTANT',
         description: 'Workflow guidance for efficient code search. ALWAYS index before searching. Use project names after first index. Use extensionFilter to narrow results.',

package/dist/tools.d.ts

@@ -1,11 +1,14 @@
 import { StateManager } from './state/snapshot.js';
 import type { Embedding } from './embedding/types.js';
 import type { VectorDB } from './vectordb/types.js';
+import type { MemoryStore } from './memory/store.js';
 export declare class ToolHandlers {
     private embedding;
     private vectordb;
     private state;
+    private memoryStore;
     constructor(embedding: Embedding, vectordb: VectorDB, state: StateManager);
+    setMemoryStore(store: MemoryStore): void;
     handleIndexCodebase(args: Record<string, unknown>): Promise<{
         content: {
             type: string;
@@ -36,5 +39,71 @@ export declare class ToolHandlers {
             text: string;
         }[];
     }>;
+    handleCleanupVectors(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleIndexDocument(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleSearchDocuments(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleAddMemory(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleSearchMemory(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleListMemories(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleDeleteMemory(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleMemoryHistory(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleBrowseStructure(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleListSymbols(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
 }
+export declare function handleReadFile(args: Record<string, unknown>): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
 //# sourceMappingURL=tools.d.ts.map