claude-eidetic 0.1.0

package/dist/splitter/types.d.ts

@@ -0,0 +1,11 @@
+export interface CodeChunk {
+    content: string;
+    startLine: number;
+    endLine: number;
+    language: string;
+    filePath: string;
+}
+export interface Splitter {
+    split(code: string, language: string, filePath: string): CodeChunk[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/splitter/types.js

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

package/dist/state/registry.d.ts

@@ -0,0 +1,8 @@
+interface Registry {
+    [project: string]: string;
+}
+export declare function registerProject(absolutePath: string): void;
+export declare function resolveProject(project: string): string | undefined;
+export declare function listProjects(): Registry;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/state/registry.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getRegistryPath } from '../paths.js';
+function readRegistry() {
+    const registryPath = getRegistryPath();
+    try {
+        const data = fs.readFileSync(registryPath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+function writeRegistry(registry) {
+    const registryPath = getRegistryPath();
+    const dir = path.dirname(registryPath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2) + '\n', 'utf-8');
+}
+export function registerProject(absolutePath) {
+    const name = path.basename(absolutePath).toLowerCase();
+    const registry = readRegistry();
+    registry[name] = absolutePath;
+    writeRegistry(registry);
+}
+export function resolveProject(project) {
+    const registry = readRegistry();
+    return registry[project.toLowerCase()];
+}
+export function listProjects() {
+    return readRegistry();
+}
+//# sourceMappingURL=registry.js.map

package/dist/state/snapshot.d.ts

@@ -0,0 +1,26 @@
+import type { VectorDB } from '../vectordb/types.js';
+export type CodebaseStatus = 'idle' | 'indexing' | 'indexed' | 'error';
+export interface CodebaseState {
+    path: string;
+    collectionName: string;
+    status: CodebaseStatus;
+    lastIndexed?: string;
+    totalFiles?: number;
+    totalChunks?: number;
+    error?: string;
+    progress?: number;
+    progressMessage?: string;
+}
+export declare class StateManager {
+    private states;
+    getState(normalizedPath: string): CodebaseState | undefined;
+    getAllStates(): CodebaseState[];
+    setIndexing(normalizedPath: string, collectionName: string): void;
+    updateProgress(normalizedPath: string, progress: number, message: string): void;
+    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

@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getSnapshotDir } from '../paths.js';
+export class StateManager {
+    states = new Map();
+    getState(normalizedPath) {
+        return this.states.get(normalizedPath);
+    }
+    getAllStates() {
+        return [...this.states.values()];
+    }
+    setIndexing(normalizedPath, collectionName) {
+        this.states.set(normalizedPath, {
+            path: normalizedPath,
+            collectionName,
+            status: 'indexing',
+            progress: 0,
+            progressMessage: 'Starting...',
+        });
+    }
+    updateProgress(normalizedPath, progress, message) {
+        const state = this.states.get(normalizedPath);
+        if (state) {
+            state.progress = progress;
+            state.progressMessage = message;
+        }
+    }
+    setIndexed(normalizedPath, totalFiles, totalChunks) {
+        const state = this.states.get(normalizedPath);
+        if (state) {
+            state.status = 'indexed';
+            state.lastIndexed = new Date().toISOString();
+            state.totalFiles = totalFiles;
+            state.totalChunks = totalChunks;
+            state.progress = 100;
+            state.progressMessage = 'Done';
+        }
+    }
+    setError(normalizedPath, error) {
+        const state = this.states.get(normalizedPath);
+        if (state) {
+            state.status = 'error';
+            state.error = error;
+        }
+    }
+    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();
+    let cleaned = 0;
+    try {
+        if (!fs.existsSync(snapshotDir))
+            return 0;
+        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;
+        }
+        for (const file of files) {
+            const collectionName = path.basename(file, '.json');
+            try {
+                const exists = await vectordb.hasCollection(collectionName);
+                if (!exists) {
+                    const filePath = path.join(snapshotDir, file);
+                    fs.unlinkSync(filePath);
+                    console.log(`Cleaned orphaned snapshot: ${collectionName}`);
+                    cleaned++;
+                }
+            }
+            catch (err) {
+                // Network error for this specific check -- skip rather than risk deletion
+                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}`);
+    }
+    return cleaned;
+}
+//# sourceMappingURL=snapshot.js.map

package/dist/tool-schemas.d.ts

@@ -0,0 +1,135 @@
+export declare const TOOL_DEFINITIONS: readonly [{
+    readonly name: "index_codebase";
+    readonly description: "Index a codebase directory to enable semantic search using a configurable code splitter.\n\nProvide either `path` (absolute) or `project` (name). Use `list_indexed` to see registered projects.\n\nUsage Guidance:\n- Use dryRun=true first to preview what files would be indexed and catch configuration issues before committing to a full index.\n- This tool is typically used when search fails due to an unindexed codebase.\n- If indexing is attempted on an already indexed path, and a conflict is detected, you MUST prompt the user to confirm whether to proceed with a force index.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly description: "Absolute path to the codebase directory to index.";
+            };
+            readonly project: {
+                readonly type: "string";
+                readonly description: "Project name (resolves via registry). Use list_indexed to see registered projects.";
+            };
+            readonly force: {
+                readonly type: "boolean";
+                readonly description: "Force re-indexing even if already indexed";
+                readonly default: false;
+            };
+            readonly dryRun: {
+                readonly type: "boolean";
+                readonly description: "Preview what would be indexed without actually indexing. Returns file counts by extension, top directories, estimated cost, and warnings.";
+                readonly default: false;
+            };
+            readonly customExtensions: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Additional file extensions to include beyond defaults (e.g., [\".dart\", \".arb\"]). Extensions should include the dot prefix.";
+                readonly default: readonly [];
+            };
+            readonly customIgnorePatterns: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Additional glob patterns to exclude (e.g., [\"**/Pods/**\", \"**/DerivedData/**\"]).";
+                readonly default: readonly [];
+            };
+        };
+        readonly required: 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 inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly path: {
+                readonly type: "string";
+                readonly description: "Absolute path to the codebase directory to search in.";
+            };
+            readonly project: {
+                readonly type: "string";
+                readonly description: "Project name (resolves via registry). Use list_indexed to see registered projects.";
+            };
+            readonly query: {
+                readonly type: "string";
+                readonly description: "Natural language query to search for in the codebase";
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly description: "Maximum number of results to return";
+                readonly default: 10;
+                readonly maximum: 50;
+            };
+            readonly extensionFilter: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Optional: List of file extensions to filter results (e.g., [\".ts\", \".py\"]).";
+                readonly default: readonly [];
+            };
+            readonly compact: {
+                readonly type: "boolean";
+                readonly description: "Return compact table (file, lines, score, ~tokens) instead of full code snippets. Use Read tool to fetch interesting results. Default: true.";
+                readonly default: true;
+            };
+        };
+        readonly required: readonly ["query"];
+    };
+}, {
+    readonly name: "clear_index";
+    readonly description: "Clear the search index. Provide 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 to clear.";
+            };
+            readonly project: {
+                readonly type: "string";
+                readonly description: "Project name (resolves via registry). Use list_indexed to see registered projects.";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "get_indexing_status";
+    readonly description: "Get the current indexing status of a codebase. Provide 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 to check status for.";
+            };
+            readonly project: {
+                readonly type: "string";
+                readonly description: "Project name (resolves via registry). Use list_indexed to see registered projects.";
+            };
+        };
+        readonly required: readonly [];
+    };
+}, {
+    readonly name: "list_indexed";
+    readonly description: "List all currently indexed codebases with their status. Returns paths, file/chunk counts, and indexing status for all known codebases in this session.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        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.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+}];
+//# sourceMappingURL=tool-schemas.d.ts.map

package/dist/tool-schemas.js

@@ -0,0 +1,162 @@
+const INDEX_DESCRIPTION = `\
+Index a codebase directory to enable semantic search using a configurable code splitter.
+
+Provide either \`path\` (absolute) or \`project\` (name). Use \`list_indexed\` to see registered projects.
+
+Usage Guidance:
+- Use dryRun=true first to preview what files would be indexed and catch configuration issues before committing to a full index.
+- This tool is typically used when search fails due to an unindexed codebase.
+- If indexing is attempted on an already indexed path, and a conflict is detected, \
+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.
+
+Provide either \`path\` (absolute) or \`project\` (name). Use \`list_indexed\` to see registered projects.
+
+When to Use:
+- Code search: Find specific functions, classes, or implementations
+- Context-aware assistance: Gather relevant code context before making changes
+- Issue identification: Locate problematic code sections or bugs
+- Code review: Understand existing implementations and patterns
+- Refactoring: Find all related code pieces that need to be updated
+- Feature development: Understand existing architecture and similar implementations
+- Duplicate detection: Identify redundant or duplicated code patterns
+
+If the codebase is not indexed, this tool will return a clear error message \
+indicating that indexing is required first.`;
+export const TOOL_DEFINITIONS = [
+    {
+        name: 'index_codebase',
+        description: INDEX_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Absolute path to the codebase directory to index.',
+                },
+                project: {
+                    type: 'string',
+                    description: 'Project name (resolves via registry). Use list_indexed to see registered projects.',
+                },
+                force: {
+                    type: 'boolean',
+                    description: 'Force re-indexing even if already indexed',
+                    default: false,
+                },
+                dryRun: {
+                    type: 'boolean',
+                    description: 'Preview what would be indexed without actually indexing. Returns file counts by extension, top directories, estimated cost, and warnings.',
+                    default: false,
+                },
+                customExtensions: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Additional file extensions to include beyond defaults (e.g., [".dart", ".arb"]). Extensions should include the dot prefix.',
+                    default: [],
+                },
+                customIgnorePatterns: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Additional glob patterns to exclude (e.g., ["**/Pods/**", "**/DerivedData/**"]).',
+                    default: [],
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'search_code',
+        description: SEARCH_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Absolute path to the codebase directory to search in.',
+                },
+                project: {
+                    type: 'string',
+                    description: 'Project name (resolves via registry). Use list_indexed to see registered projects.',
+                },
+                query: {
+                    type: 'string',
+                    description: 'Natural language query to search for in the codebase',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of results to return',
+                    default: 10,
+                    maximum: 50,
+                },
+                extensionFilter: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional: List of file extensions to filter results (e.g., [".ts", ".py"]).',
+                    default: [],
+                },
+                compact: {
+                    type: 'boolean',
+                    description: 'Return compact table (file, lines, score, ~tokens) instead of full code snippets. Use Read tool to fetch interesting results. Default: true.',
+                    default: true,
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'clear_index',
+        description: 'Clear the search index. Provide 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 to clear.',
+                },
+                project: {
+                    type: 'string',
+                    description: 'Project name (resolves via registry). Use list_indexed to see registered projects.',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'get_indexing_status',
+        description: 'Get the current indexing status of a codebase. Provide 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 to check status for.',
+                },
+                project: {
+                    type: 'string',
+                    description: 'Project name (resolves via registry). Use list_indexed to see registered projects.',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'list_indexed',
+        description: 'List all currently indexed codebases with their status. Returns paths, file/chunk counts, and indexing status for all known codebases in this session.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            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.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+];
+//# sourceMappingURL=tool-schemas.js.map

package/dist/tools.d.ts

@@ -0,0 +1,40 @@
+import { StateManager } from './state/snapshot.js';
+import type { Embedding } from './embedding/types.js';
+import type { VectorDB } from './vectordb/types.js';
+export declare class ToolHandlers {
+    private embedding;
+    private vectordb;
+    private state;
+    constructor(embedding: Embedding, vectordb: VectorDB, state: StateManager);
+    handleIndexCodebase(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleSearchCode(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleClearIndex(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleGetIndexingStatus(args: Record<string, unknown>): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    handleListIndexed(): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+}
+//# sourceMappingURL=tools.d.ts.map