claude-eidetic 0.1.1 → 0.1.2

package/dist/format.js

@@ -2,26 +2,54 @@ import { listProjects } from './state/registry.js';
 export function textResult(text) {
     return { content: [{ type: 'text', text }] };
 }
+export function formatCleanupResult(result, normalizedPath, dryRun) {
+    if (dryRun) {
+        if (result.removedFiles.length === 0) {
+            return `Dry run for ${normalizedPath}: no orphaned vectors found.`;
+        }
+        const lines = [
+            `Dry run for ${normalizedPath}: ${result.removedFiles.length} file(s) would be cleaned:`,
+            '',
+        ];
+        for (const f of result.removedFiles) {
+            lines.push(`  - ${f}`);
+        }
+        return lines.join('\n');
+    }
+    if (result.totalRemoved === 0) {
+        return `Cleanup complete for ${normalizedPath}: no orphaned vectors found.`;
+    }
+    const lines = [
+        `Cleanup complete for ${normalizedPath}`,
+        '',
+        `  Removed:   ${result.totalRemoved} file(s)`,
+        `  Duration:  ${(result.durationMs / 1000).toFixed(1)}s`,
+        '',
+        'Cleaned files:',
+    ];
+    for (const f of result.removedFiles) {
+        lines.push(`  - ${f}`);
+    }
+    return lines.join('\n');
+}
 export function formatIndexResult(result, normalizedPath) {
     const lines = [
         `Indexing complete for ${normalizedPath}`,
         '',
-        `| Metric | Value |`,
-        `|--------|-------|`,
-        `| Total files | ${result.totalFiles} |`,
-        `| Total chunks | ${result.totalChunks} |`,
-        `| Added files | ${result.addedFiles} |`,
-        `| Modified files | ${result.modifiedFiles} |`,
-        `| Removed files | ${result.removedFiles} |`,
-        `| Skipped (unchanged) | ${result.skippedFiles} |`,
-        `| Parse failures | ${result.parseFailures.length} |`,
-        `| Estimated tokens | ~${(result.estimatedTokens / 1000).toFixed(0)}K |`,
-        `| Estimated cost | $${result.estimatedCostUsd.toFixed(4)} |`,
-        `| Duration | ${(result.durationMs / 1000).toFixed(1)}s |`,
+        `  Total files:    ${result.totalFiles}`,
+        `  Total chunks:   ${result.totalChunks}`,
+        `  Added:          ${result.addedFiles}`,
+        `  Modified:       ${result.modifiedFiles}`,
+        `  Removed:        ${result.removedFiles}`,
+        `  Skipped:        ${result.skippedFiles}`,
+        `  Parse failures: ${result.parseFailures.length}`,
+        `  Tokens:         ~${(result.estimatedTokens / 1000).toFixed(0)}K`,
+        `  Cost:           $${result.estimatedCostUsd.toFixed(4)}`,
+        `  Duration:       ${(result.durationMs / 1000).toFixed(1)}s`,
     ];
     if (result.parseFailures.length > 0) {
         lines.push('');
-        lines.push('**Parse Failures:**');
+        lines.push('Parse failures:');
         const toShow = result.parseFailures.slice(0, 10);
         for (const file of toShow) {
             lines.push(`- ${file}`);
@@ -34,18 +62,14 @@ export function formatIndexResult(result, normalizedPath) {
 }
 export function formatPreview(preview, rootPath) {
     const lines = [`Preview for ${rootPath}:`, ''];
-    // Extension table
-    const sorted = Object.entries(preview.byExtension)
-        .sort((a, b) => b[1] - a[1]);
+    const sorted = Object.entries(preview.byExtension).sort((a, b) => b[1] - a[1]);
     if (sorted.length > 0) {
-        lines.push('| Extension | Files |');
-        lines.push('|-----------|-------|');
+        const maxExt = Math.max(...sorted.map(([ext]) => ext.length));
         for (const [ext, count] of sorted) {
-            lines.push(`| ${ext} | ${count.toLocaleString()} |`);
+            lines.push(`  ${ext.padEnd(maxExt)}  ${count.toLocaleString()}`);
         }
     }
     lines.push(`Total: ${preview.totalFiles.toLocaleString()} files`, '');
-    // Top directories
     if (preview.topDirectories.length > 0) {
         lines.push('Top directories:');
         for (const { dir, count } of preview.topDirectories) {
@@ -53,12 +77,10 @@ export function formatPreview(preview, rootPath) {
         }
         lines.push('');
     }
-    // Cost estimate
     const tokenStr = preview.estimatedTokens >= 1_000_000
         ? `~${(preview.estimatedTokens / 1_000_000).toFixed(1)}M`
         : `~${(preview.estimatedTokens / 1000).toFixed(0)}K`;
     lines.push(`Estimated: ${tokenStr} tokens (~$${preview.estimatedCostUsd.toFixed(4)})`, '');
-    // Warnings
     lines.push('Warnings:');
     if (preview.warnings.length === 0) {
         lines.push('- None');
@@ -73,23 +95,130 @@ export function formatPreview(preview, rootPath) {
 export function formatListIndexed(states) {
     const registry = listProjects();
     const pathToProject = new Map(Object.entries(registry).map(([name, p]) => [p, name]));
-    const lines = [`## Indexed Codebases (${states.length})\n`];
+    const lines = [`Indexed Codebases (${states.length})`, ''];
     for (const s of states) {
         const projectName = pathToProject.get(s.path);
-        const heading = projectName ? `${s.path} (project: \`${projectName}\`)` : s.path;
-        lines.push(`### ${heading}`);
-        lines.push(`- **Status:** ${s.status}`);
+        const heading = projectName ? `${s.path} (project: ${projectName})` : s.path;
+        lines.push(heading);
+        lines.push(`  Status:       ${s.status}`);
         if (s.totalFiles)
-            lines.push(`- **Files:** ${s.totalFiles}`);
+            lines.push(`  Files:        ${s.totalFiles}`);
         if (s.totalChunks)
-            lines.push(`- **Chunks:** ${s.totalChunks}`);
+            lines.push(`  Chunks:       ${s.totalChunks}`);
         if (s.lastIndexed)
-            lines.push(`- **Last indexed:** ${s.lastIndexed}`);
+            lines.push(`  Last indexed: ${s.lastIndexed}`);
         if (s.status === 'indexing' && s.progress !== undefined) {
-            lines.push(`- **Progress:** ${s.progress}% — ${s.progressMessage ?? ''}`);
+            lines.push(`  Progress:     ${s.progress}% — ${s.progressMessage ?? ''}`);
         }
         if (s.error)
-            lines.push(`- **Error:** ${s.error}`);
+            lines.push(`  Error:        ${s.error}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function formatDocIndexResult(result) {
+    const lines = [
+        `Documentation cached: ${result.library}/${result.topic}`,
+        '',
+        `  Source:     ${result.source}`,
+        `  Chunks:    ${result.totalChunks}`,
+        `  Tokens:    ~${(result.estimatedTokens / 1000).toFixed(0)}K`,
+        `  Duration:  ${(result.durationMs / 1000).toFixed(1)}s`,
+        `  Collection: ${result.collectionName}`,
+        '',
+        `Use \`search_documents(query="...", library="${result.library}")\` to search this documentation.`,
+    ];
+    return lines.join('\n');
+}
+export function formatDocSearchResults(results, query) {
+    if (results.length === 0) {
+        return `No cached documentation found for "${query}".`;
+    }
+    const lines = [`Found ${results.length} result(s) for "${query}" in cached docs:\n`];
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const staleTag = r.stale ? ' **[STALE]**' : '';
+        lines.push(`### Result ${i + 1}`);
+        lines.push(`**Library:** ${r.library}/${r.topic} | **Source:** ${r.source}${staleTag}`);
+        lines.push(`**Score:** ${r.score.toFixed(4)}`);
+        lines.push('```markdown');
+        lines.push(r.content);
+        lines.push('```');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function formatMemoryActions(actions) {
+    if (actions.length === 0) {
+        return 'No new facts extracted from the provided content.';
+    }
+    const lines = [`Processed ${actions.length} memory action(s):`, ''];
+    for (const action of actions) {
+        const icon = action.event === 'ADD' ? '+' : '~';
+        lines.push(`  ${icon} [${action.event}] ${action.memory}`);
+        lines.push(`    Category: ${action.category ?? 'unknown'} | ID: ${action.id}`);
+        if (action.previous) {
+            lines.push(`    Previous: ${action.previous}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatMemorySearchResults(items, query) {
+    if (items.length === 0) {
+        return `No memories found for "${query}".`;
+    }
+    const lines = [`Found ${items.length} memory(ies) for "${query}":\n`];
+    for (let i = 0; i < items.length; i++) {
+        const m = items[i];
+        lines.push(`${i + 1}. ${m.memory}`);
+        lines.push(`   Category: ${m.category} | ID: ${m.id}`);
+        if (m.source)
+            lines.push(`   Source: ${m.source}`);
+        if (m.created_at || m.updated_at) {
+            lines.push(`   Created: ${m.created_at || 'unknown'} | Updated: ${m.updated_at || 'unknown'}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function formatMemoryList(items) {
+    if (items.length === 0) {
+        return 'No memories stored yet. Use `add_memory` to store developer knowledge.';
+    }
+    const lines = [`Stored Memories (${items.length}):\n`];
+    const grouped = new Map();
+    for (const m of items) {
+        const cat = m.category || 'uncategorized';
+        let catList = grouped.get(cat);
+        if (!catList) {
+            catList = [];
+            grouped.set(cat, catList);
+        }
+        catList.push(m);
+    }
+    for (const [category, memories] of grouped) {
+        lines.push(`### ${category} (${memories.length})`);
+        for (const m of memories) {
+            const updatedDate = m.updated_at ? ` (updated: ${m.updated_at.slice(0, 10)})` : '';
+            lines.push(`  - ${m.memory}  [${m.id.slice(0, 8)}...]${updatedDate}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function formatMemoryHistory(entries, memoryId) {
+    if (entries.length === 0) {
+        return `No history found for memory ${memoryId}.`;
+    }
+    const lines = [`History for memory ${memoryId} (${entries.length} event(s)):\n`];
+    for (const e of entries) {
+        lines.push(`  [${e.event}] ${e.created_at}`);
+        if (e.new_value)
+            lines.push(`    Value: ${e.new_value}`);
+        if (e.previous_value)
+            lines.push(`    Previous: ${e.previous_value}`);
+        if (e.source)
+            lines.push(`    Source: ${e.source}`);
         lines.push('');
     }
     return lines.join('\n');

package/dist/hooks/post-tool-use.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse hook entry point.
+ *
+ * Receives hook data via stdin when Write or Edit tools are used.
+ * Maintains a shadow git index per session to track which files were
+ * modified, without touching HEAD or the working index.
+ *
+ * Shadow index: <git-dir>/claude/indexes/<session-id>/index
+ * Base commit:  <git-dir>/claude/indexes/<session-id>/base_commit
+ */
+export {};
+//# sourceMappingURL=post-tool-use.d.ts.map

package/dist/hooks/post-tool-use.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse hook entry point.
+ *
+ * Receives hook data via stdin when Write or Edit tools are used.
+ * Maintains a shadow git index per session to track which files were
+ * modified, without touching HEAD or the working index.
+ *
+ * Shadow index: <git-dir>/claude/indexes/<session-id>/index
+ * Base commit:  <git-dir>/claude/indexes/<session-id>/base_commit
+ */
+import { z } from 'zod';
+import path from 'node:path';
+import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+const PostToolUseInputSchema = z.object({
+    session_id: z.string(),
+    cwd: z.string(),
+    hook_event_name: z.literal('PostToolUse'),
+    tool_name: z.string(),
+    tool_input: z
+        .object({
+        file_path: z.string().optional(),
+    })
+        .passthrough(),
+});
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+function outputSuccess() {
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: {} }));
+}
+function outputError(message) {
+    process.stderr.write(`[eidetic:post-tool-use] ${message}\n`);
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: {} }));
+}
+async function main() {
+    try {
+        const input = await readStdin();
+        const parseResult = PostToolUseInputSchema.safeParse(JSON.parse(input));
+        if (!parseResult.success) {
+            outputError(`Invalid hook input: ${parseResult.error.message}`);
+            return;
+        }
+        const { session_id, cwd, tool_name, tool_input } = parseResult.data;
+        // Safety check beyond matcher — only process Write and Edit
+        if (tool_name !== 'Write' && tool_name !== 'Edit') {
+            outputSuccess();
+            return;
+        }
+        const filePath = tool_input.file_path;
+        if (!filePath) {
+            outputSuccess();
+            return;
+        }
+        // Resolve git dir
+        let gitDir;
+        try {
+            gitDir = execFileSync('git', ['-C', cwd, 'rev-parse', '--git-dir'], {
+                encoding: 'utf-8',
+                timeout: 5000,
+            }).trim();
+        }
+        catch {
+            // Not a git repo — silently skip
+            outputSuccess();
+            return;
+        }
+        if (!path.isAbsolute(gitDir)) {
+            gitDir = path.resolve(cwd, gitDir);
+        }
+        const shadowDir = path.join(gitDir, 'claude', 'indexes', session_id);
+        const shadowIndex = path.join(shadowDir, 'index');
+        const baseCommitFile = path.join(shadowDir, 'base_commit');
+        // First call for this session: seed shadow index from HEAD
+        if (!fs.existsSync(shadowIndex)) {
+            fs.mkdirSync(shadowDir, { recursive: true });
+            let headSha;
+            try {
+                headSha = execFileSync('git', ['-C', cwd, 'rev-parse', 'HEAD'], {
+                    encoding: 'utf-8',
+                    timeout: 5000,
+                }).trim();
+            }
+            catch {
+                // Empty repo / no commits — cannot seed from HEAD
+                outputSuccess();
+                return;
+            }
+            // Seed shadow index from HEAD tree
+            execFileSync('git', ['-C', cwd, 'read-tree', `--index-output=${shadowIndex}`, 'HEAD'], {
+                timeout: 5000,
+            });
+            fs.writeFileSync(baseCommitFile, headSha, 'utf-8');
+        }
+        // Stage the file into the shadow index
+        const absoluteFilePath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+        execFileSync('git', ['-C', cwd, 'add', absoluteFilePath], {
+            env: { ...process.env, GIT_INDEX_FILE: shadowIndex },
+            timeout: 5000,
+        });
+        outputSuccess();
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err));
+    }
+}
+void main();
+//# sourceMappingURL=post-tool-use.js.map

package/dist/hooks/stop-hook.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Stop hook entry point.
+ *
+ * Receives hook data via stdin when a Claude session ends.
+ * Commits the session's shadow git index to refs/heads/claude/<session-id>,
+ * diffs against base commit to find modified files, then spawns a
+ * detached background targeted re-indexer.
+ */
+export {};
+//# sourceMappingURL=stop-hook.d.ts.map

package/dist/hooks/stop-hook.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/**
+ * Stop hook entry point.
+ *
+ * Receives hook data via stdin when a Claude session ends.
+ * Commits the session's shadow git index to refs/heads/claude/<session-id>,
+ * diffs against base commit to find modified files, then spawns a
+ * detached background targeted re-indexer.
+ */
+import { z } from 'zod';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { execFileSync, spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const StopInputSchema = z.object({
+    session_id: z.string(),
+    cwd: z.string(),
+    hook_event_name: z.literal('Stop'),
+    stop_hook_active: z.boolean().optional(),
+});
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+function outputSuccess() {
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: {} }));
+}
+function outputError(message) {
+    process.stderr.write(`[eidetic:stop-hook] ${message}\n`);
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: {} }));
+}
+async function main() {
+    try {
+        const input = await readStdin();
+        const parseResult = StopInputSchema.safeParse(JSON.parse(input));
+        if (!parseResult.success) {
+            outputError(`Invalid hook input: ${parseResult.error.message}`);
+            return;
+        }
+        const { session_id, cwd } = parseResult.data;
+        // Resolve git dir
+        let gitDir;
+        try {
+            gitDir = execFileSync('git', ['-C', cwd, 'rev-parse', '--git-dir'], {
+                encoding: 'utf-8',
+                timeout: 5000,
+            }).trim();
+        }
+        catch {
+            // Not a git repo — nothing to do
+            outputSuccess();
+            return;
+        }
+        if (!path.isAbsolute(gitDir)) {
+            gitDir = path.resolve(cwd, gitDir);
+        }
+        const shadowDir = path.join(gitDir, 'claude', 'indexes', session_id);
+        const shadowIndex = path.join(shadowDir, 'index');
+        const baseCommitFile = path.join(shadowDir, 'base_commit');
+        // No shadow index means no edits happened this session
+        if (!fs.existsSync(shadowIndex)) {
+            outputSuccess();
+            return;
+        }
+        const baseCommit = fs.readFileSync(baseCommitFile, 'utf-8').trim();
+        // Write tree from shadow index
+        const treeSha = execFileSync('git', ['-C', cwd, 'write-tree'], {
+            env: { ...process.env, GIT_INDEX_FILE: shadowIndex },
+            encoding: 'utf-8',
+            timeout: 10000,
+        }).trim();
+        // Create a commit object pointing to that tree
+        const commitSha = execFileSync('git', ['-C', cwd, 'commit-tree', treeSha, '-p', baseCommit, '-m', `eidetic: session ${session_id}`], { encoding: 'utf-8', timeout: 10000 }).trim();
+        // Store under refs/heads/claude/<session-id> for history
+        execFileSync('git', ['-C', cwd, 'update-ref', `refs/heads/claude/${session_id}`, commitSha], {
+            timeout: 5000,
+        });
+        // Find files that changed between base and new commit
+        const diffOutput = execFileSync('git', ['-C', cwd, 'diff-tree', '--no-commit-id', '--name-only', '-r', baseCommit, commitSha], { encoding: 'utf-8', timeout: 5000 }).trim();
+        const modifiedFiles = diffOutput
+            .split('\n')
+            .map((f) => f.trim())
+            .filter((f) => f.length > 0);
+        // Clean up shadow index directory
+        try {
+            fs.rmSync(shadowDir, { recursive: true, force: true });
+        }
+        catch (err) {
+            process.stderr.write(`[eidetic:stop-hook] Failed to clean shadow index: ${String(err)}\n`);
+        }
+        if (modifiedFiles.length === 0) {
+            outputSuccess();
+            return;
+        }
+        // Write manifest for targeted runner
+        const manifest = { projectPath: cwd, modifiedFiles };
+        const manifestFile = path.join(os.tmpdir(), `eidetic-reindex-${session_id}.json`);
+        fs.writeFileSync(manifestFile, JSON.stringify(manifest), 'utf-8');
+        // Spawn detached background targeted runner
+        const runnerPath = path.join(__dirname, 'targeted-runner.js');
+        const child = spawn(process.execPath, [runnerPath, manifestFile], {
+            detached: true,
+            stdio: 'ignore',
+            env: process.env,
+            windowsHide: true,
+        });
+        child.unref();
+        outputSuccess();
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err));
+    }
+}
+void main();
+//# sourceMappingURL=stop-hook.js.map

package/dist/hooks/targeted-runner.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Standalone CLI for background targeted re-indexing.
+ * Spawned as a detached child process by stop-hook.ts.
+ *
+ * Usage: node targeted-runner.js <manifest-json-path>
+ *
+ * Manifest JSON: { projectPath: string, modifiedFiles: string[] }
+ */
+export {};
+//# sourceMappingURL=targeted-runner.d.ts.map

package/dist/hooks/targeted-runner.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Standalone CLI for background targeted re-indexing.
+ * Spawned as a detached child process by stop-hook.ts.
+ *
+ * Usage: node targeted-runner.js <manifest-json-path>
+ *
+ * Manifest JSON: { projectPath: string, modifiedFiles: string[] }
+ */
+import fs from 'node:fs';
+import { indexFiles } from '../core/targeted-indexer.js';
+import { createEmbedding } from '../embedding/factory.js';
+import { QdrantVectorDB } from '../vectordb/qdrant.js';
+import { bootstrapQdrant } from '../infra/qdrant-bootstrap.js';
+import { loadConfig } from '../config.js';
+async function main() {
+    const manifestPath = process.argv[2];
+    if (!manifestPath) {
+        process.stderr.write('Usage: targeted-runner.js <manifest-json-path>\n');
+        process.exit(1);
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    }
+    catch (err) {
+        process.stderr.write(`[targeted-runner] Failed to read manifest: ${String(err)}\n`);
+        process.exit(1);
+    }
+    // Clean up manifest file
+    try {
+        fs.unlinkSync(manifestPath);
+    }
+    catch {
+        // Ignore — best effort
+    }
+    const { projectPath, modifiedFiles } = manifest;
+    if (!projectPath || !Array.isArray(modifiedFiles) || modifiedFiles.length === 0) {
+        process.stderr.write('[targeted-runner] Empty or invalid manifest, nothing to do.\n');
+        process.exit(0);
+    }
+    try {
+        const config = loadConfig();
+        const embedding = createEmbedding(config);
+        await embedding.initialize();
+        let vectordb;
+        if (config.vectordbProvider === 'milvus') {
+            const { MilvusVectorDB } = await import('../vectordb/milvus.js');
+            vectordb = new MilvusVectorDB();
+        }
+        else {
+            const qdrantUrl = await bootstrapQdrant();
+            vectordb = new QdrantVectorDB(qdrantUrl, config.qdrantApiKey);
+        }
+        const result = await indexFiles(projectPath, modifiedFiles, embedding, vectordb);
+        process.stderr.write(`[targeted-runner] Re-indexed ${result.processedFiles} files ` +
+            `(${result.totalChunks} chunks, ${result.skippedFiles} deleted) ` +
+            `in ${result.durationMs}ms\n`);
+    }
+    catch (err) {
+        process.stderr.write(`[targeted-runner] Failed: ${String(err)}\n`);
+        process.exit(1);
+    }
+}
+void main();
+//# sourceMappingURL=targeted-runner.js.map