claude-eidetic 0.1.4 → 0.1.5

package/dist/format.js

@@ -156,7 +156,8 @@ export function formatMemoryActions(actions) {
     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}`);
+        const projectTag = action.project && action.project !== 'global' ? ` | Project: ${action.project}` : '';
+        lines.push(`    Category: ${action.category ?? 'unknown'} | ID: ${action.id}${projectTag}`);
         if (action.previous) {
             lines.push(`    Previous: ${action.previous}`);
         }
@@ -171,9 +172,13 @@ export function formatMemorySearchResults(items, query) {
     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}`);
+        const projectTag = m.project && m.project !== 'global' ? ` | Project: ${m.project}` : '';
+        lines.push(`   Category: ${m.category} | ID: ${m.id}${projectTag}`);
         if (m.source)
             lines.push(`   Source: ${m.source}`);
+        if (m.access_count > 0) {
+            lines.push(`   Accessed: ${m.access_count}x | Last: ${m.last_accessed.slice(0, 10)}`);
+        }
         if (m.created_at || m.updated_at) {
             lines.push(`   Created: ${m.created_at || 'unknown'} | Updated: ${m.updated_at || 'unknown'}`);
         }
@@ -200,7 +205,9 @@ export function formatMemoryList(items) {
         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}`);
+            const projectTag = m.project && m.project !== 'global' ? ` [${m.project}]` : '';
+            const accessTag = m.access_count > 0 ? ` (accessed: ${m.access_count}x)` : '';
+            lines.push(`  - ${m.memory}  [${m.id.slice(0, 8)}...]${updatedDate}${projectTag}${accessTag}`);
         }
         lines.push('');
     }

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse automatic memory extraction.
+ * Replaces the nudge-based memory-nudge.sh approach.
+ *
+ * Reads PostToolUse stdin JSON (includes tool_response), pattern-matches on outcomes,
+ * and stores facts directly via MemoryStore — no Claude involvement required.
+ *
+ * Matches: WebFetch | Bash
+ */
+export {};
+//# sourceMappingURL=post-tool-extract.d.ts.map

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

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse automatic memory extraction.
+ * Replaces the nudge-based memory-nudge.sh approach.
+ *
+ * Reads PostToolUse stdin JSON (includes tool_response), pattern-matches on outcomes,
+ * and stores facts directly via MemoryStore — no Claude involvement required.
+ *
+ * Matches: WebFetch | Bash
+ */
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+const MAX_RESPONSE_SIZE = 10_000; // Skip extraction for large responses (data dumps)
+async function main() {
+    let input;
+    try {
+        const raw = await readStdin();
+        input = JSON.parse(raw);
+    }
+    catch {
+        // Can't parse stdin — exit silently
+        writeOutput();
+        return;
+    }
+    const toolName = input.tool_name ?? '';
+    if (toolName !== 'WebFetch' && toolName !== 'Bash') {
+        writeOutput();
+        return;
+    }
+    const responseStr = stringifyResponse(input.tool_response);
+    // Skip if response is too large (likely a successful data dump, not an error)
+    if (responseStr.length > MAX_RESPONSE_SIZE) {
+        writeOutput();
+        return;
+    }
+    const facts = extractFacts(toolName, input.tool_input ?? {}, responseStr);
+    if (facts.length === 0) {
+        writeOutput();
+        return;
+    }
+    try {
+        const cwd = input.cwd ?? process.cwd();
+        const project = detectProject(cwd);
+        const [{ loadConfig }, { createEmbedding }, { MemoryHistory }, { MemoryStore }] = await Promise.all([
+            import('../config.js'),
+            import('../embedding/factory.js'),
+            import('../memory/history.js'),
+            import('../memory/store.js'),
+        ]);
+        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 { QdrantVectorDB } = await import('../vectordb/qdrant.js');
+            vectordb = new QdrantVectorDB(config.qdrantUrl, config.qdrantApiKey);
+        }
+        // Quick-exit if memory collection doesn't exist yet
+        const exists = await vectordb.hasCollection('eidetic_memory');
+        if (!exists) {
+            writeOutput();
+            return;
+        }
+        const { getMemoryDbPath } = await import('../paths.js');
+        const history = new MemoryHistory(getMemoryDbPath());
+        const store = new MemoryStore(embedding, vectordb, history);
+        await store.addMemory(facts, 'post-tool-extract', project);
+    }
+    catch (err) {
+        process.stderr.write(`post-tool-extract failed: ${String(err)}\n`);
+    }
+    writeOutput();
+}
+function extractFacts(toolName, toolInput, responseStr) {
+    const facts = [];
+    if (toolName === 'WebFetch') {
+        const url = String(toolInput.url ?? '');
+        facts.push(...extractWebFetchFacts(url, responseStr));
+    }
+    else if (toolName === 'Bash') {
+        const command = String(toolInput.command ?? '');
+        facts.push(...extractBashFacts(command, responseStr));
+    }
+    return facts;
+}
+function extractWebFetchFacts(url, responseStr) {
+    const facts = [];
+    const lower = responseStr.toLowerCase();
+    // Detect 404 / not found
+    if (/\b404\b/.test(responseStr) ||
+        lower.includes('page not found') ||
+        lower.includes('not found')) {
+        if (url) {
+            facts.push({
+                fact: `URL ${url} returned 404 / not found`,
+                category: 'debugging',
+            });
+        }
+        return facts;
+    }
+    // Detect redirect notice
+    const redirectMatch = /redirected?\s+to\s+(https?:\/\/\S+)/i.exec(responseStr);
+    if (redirectMatch) {
+        facts.push({
+            fact: `URL ${url} redirects to ${redirectMatch[1]}`,
+            category: 'tools',
+        });
+        return facts;
+    }
+    // Detect other errors
+    if (/(?:error|fail|403|ENOENT|EACCES)/i.test(responseStr)) {
+        const snippet = responseStr.slice(0, 150).replace(/\n/g, ' ').trim();
+        facts.push({
+            fact: `Fetching ${url} failed: ${snippet}`,
+            category: 'debugging',
+        });
+        return facts;
+    }
+    // Successful fetch — extract URL + key finding (first 200 chars)
+    if (url) {
+        const snippet = responseStr.slice(0, 200).replace(/\n/g, ' ').trim();
+        if (snippet.length > 20) {
+            facts.push({
+                fact: `Docs at ${url}: ${snippet}`,
+                category: 'tools',
+            });
+        }
+    }
+    return facts;
+}
+function extractBashFacts(command, responseStr) {
+    const facts = [];
+    const lower = responseStr.toLowerCase();
+    const isError = /(?:error|fail|not.found|command not found|ENOENT|EACCES|no such file)/i.test(responseStr) ||
+        lower.includes('exit code') ||
+        lower.includes('permission denied');
+    if (isError) {
+        const snippet = responseStr.slice(0, 200).replace(/\n/g, ' ').trim();
+        const shortCmd = command.slice(0, 100);
+        facts.push({
+            fact: `Command '${shortCmd}' failed: ${snippet}`,
+            category: 'debugging',
+        });
+        return facts;
+    }
+    // Detect successful installs
+    const installMatch = /(?:npm|yarn|pnpm|pip|pip3|brew|apt|apt-get|cargo)\s+(?:install|add|i)\s+(.+)/.exec(command);
+    if (installMatch) {
+        const pkg = installMatch[1].trim().slice(0, 80);
+        const manager = command.split(' ')[0];
+        facts.push({
+            fact: `Installed ${pkg} via ${manager}`,
+            category: 'tools',
+        });
+        return facts;
+    }
+    // Detect config commands (git config, npm config, etc.)
+    if (/\bconfig\b/.test(command) && !isError) {
+        const shortCmd = command.slice(0, 120).replace(/\n/g, ' ').trim();
+        facts.push({
+            fact: `Configured: ${shortCmd}`,
+            category: 'workflow',
+        });
+    }
+    return facts;
+}
+function detectProject(cwd) {
+    try {
+        const result = execSync('git rev-parse --show-toplevel', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return path.basename(result.trim());
+    }
+    catch {
+        return 'global';
+    }
+}
+function stringifyResponse(response) {
+    if (typeof response === 'string')
+        return response;
+    if (response === null || response === undefined)
+        return '';
+    try {
+        return JSON.stringify(response);
+    }
+    catch {
+        return String(response);
+    }
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        process.stdin.on('data', (chunk) => chunks.push(chunk));
+        process.stdin.on('end', () => {
+            resolve(Buffer.concat(chunks).toString('utf-8'));
+        });
+        process.stdin.on('error', reject);
+    });
+}
+function writeOutput() {
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: {} }) + '\n');
+}
+void main();
+//# sourceMappingURL=post-tool-extract.js.map

package/dist/memory/store.d.ts

@@ -9,11 +9,12 @@ export declare class MemoryStore {
     private initialized;
     constructor(embedding: Embedding, vectordb: VectorDB, history: MemoryHistory);
     private ensureCollection;
-    addMemory(facts: ExtractedFact[], source?: string): Promise<MemoryAction[]>;
-    searchMemory(query: string, limit?: number, category?: string): Promise<MemoryItem[]>;
-    listMemories(category?: string, limit?: number): Promise<MemoryItem[]>;
+    addMemory(facts: ExtractedFact[], source?: string, project?: string): Promise<MemoryAction[]>;
+    searchMemory(query: string, limit?: number, category?: string, project?: string): Promise<MemoryItem[]>;
+    listMemories(category?: string, limit?: number, project?: string): Promise<MemoryItem[]>;
     deleteMemory(id: string): Promise<boolean>;
     getHistory(memoryId: string): import("./history.js").HistoryEntry[];
+    private bumpAccessCounts;
     private processFact;
 }
 //# sourceMappingURL=store.d.ts.map

package/dist/memory/store.js

@@ -2,12 +2,14 @@ import { randomUUID } from 'node:crypto';
 import { hashMemory, reconcile } from './reconciler.js';
 const COLLECTION_NAME = 'eidetic_memory';
 const SEARCH_CANDIDATES = 5;
+const ACCESS_BUMP_COUNT = 5;
 // Data model mapping (reuses existing VectorDB/SearchResult fields):
 //   content      → memory text (full-text search)
 //   relativePath → memory UUID (enables deleteByPath for single-memory deletion)
 //   fileExtension→ category (enables extensionFilter for category filtering)
 //   language     → source
-//   Additional payload: hash, memory, category, source, created_at, updated_at
+//   Additional payload: hash, memory, category, source, project,
+//                       access_count, last_accessed, created_at, updated_at
 export class MemoryStore {
     embedding;
     vectordb;
@@ -27,25 +29,27 @@ export class MemoryStore {
         }
         this.initialized = true;
     }
-    async addMemory(facts, source) {
+    async addMemory(facts, source, project = 'global') {
         await this.ensureCollection();
         if (facts.length === 0)
             return [];
         const actions = [];
         for (const fact of facts) {
-            const action = await this.processFact(fact, source);
+            const action = await this.processFact(fact, source, project);
             if (action)
                 actions.push(action);
         }
         return actions;
     }
-    async searchMemory(query, limit = 10, category) {
+    async searchMemory(query, limit = 10, category, project) {
         await this.ensureCollection();
         const queryVector = await this.embedding.embed(query);
+        // Fetch extra candidates for project re-ranking when project is specified
+        const fetchLimit = project ? limit * 2 : limit;
         const results = await this.vectordb.search(COLLECTION_NAME, {
             queryVector,
             queryText: query,
-            limit,
+            limit: fetchLimit,
             ...(category ? { extensionFilter: [category] } : {}),
         });
         // Enrich with full payload from getById
@@ -57,9 +61,19 @@ export class MemoryStore {
                 continue;
             items.push(payloadToMemoryItem(id, point.payload));
         }
-        return items;
+        // Project re-ranking: boost project-matching items to the front
+        let ranked = items;
+        if (project) {
+            const projectItems = items.filter((m) => m.project === project);
+            const otherItems = items.filter((m) => m.project !== project);
+            ranked = [...projectItems, ...otherItems].slice(0, limit);
+        }
+        // Fire-and-forget: bump access_count and last_accessed for top results
+        const topIds = ranked.slice(0, ACCESS_BUMP_COUNT).map((m) => m.id);
+        void this.bumpAccessCounts(topIds);
+        return ranked;
     }
-    async listMemories(category, limit = 50) {
+    async listMemories(category, limit = 50, project) {
         await this.ensureCollection();
         const queryVector = await this.embedding.embed('developer knowledge');
         const results = await this.vectordb.search(COLLECTION_NAME, {
@@ -76,6 +90,10 @@ export class MemoryStore {
                 continue;
             items.push(payloadToMemoryItem(id, point.payload));
         }
+        // Filter by project if specified
+        if (project) {
+            return items.filter((m) => m.project === project || m.project === 'global');
+        }
         return items;
     }
     async deleteMemory(id) {
@@ -91,7 +109,26 @@ export class MemoryStore {
     getHistory(memoryId) {
         return this.history.getHistory(memoryId);
     }
-    async processFact(fact, source) {
+    async bumpAccessCounts(ids) {
+        const now = new Date().toISOString();
+        for (const id of ids) {
+            try {
+                const point = await this.vectordb.getById(COLLECTION_NAME, id);
+                if (!point)
+                    continue;
+                const currentCount = Number(point.payload.access_count ?? 0);
+                await this.vectordb.updatePoint(COLLECTION_NAME, id, point.vector, {
+                    ...point.payload,
+                    access_count: currentCount + 1,
+                    last_accessed: now,
+                });
+            }
+            catch {
+                // Silently ignore — access tracking is a best-effort utility signal
+            }
+        }
+    }
+    async processFact(fact, source, project = 'global') {
         const hash = hashMemory(fact.fact);
         const vector = await this.embedding.embed(fact.fact);
         const searchResults = await this.vectordb.search(COLLECTION_NAME, {
@@ -119,9 +156,13 @@ export class MemoryStore {
         if (decision.action === 'NONE')
             return null;
         const now = new Date().toISOString();
+        const effectiveProject = fact.project ?? project;
         if (decision.action === 'UPDATE' && decision.existingId) {
             const existingPoint = await this.vectordb.getById(COLLECTION_NAME, decision.existingId);
             const createdAt = String(existingPoint?.payload.created_at ?? now);
+            // Preserve existing access tracking
+            const existingAccessCount = Number(existingPoint?.payload.access_count ?? 0);
+            const existingLastAccessed = String(existingPoint?.payload.last_accessed ?? '');
             await this.vectordb.updatePoint(COLLECTION_NAME, decision.existingId, vector, {
                 content: fact.fact,
                 relativePath: decision.existingId,
@@ -133,6 +174,9 @@ export class MemoryStore {
                 memory: fact.fact,
                 category: fact.category,
                 source: source ?? '',
+                project: effectiveProject,
+                access_count: existingAccessCount,
+                last_accessed: existingLastAccessed,
                 created_at: createdAt,
                 updated_at: now,
             });
@@ -144,6 +188,7 @@ export class MemoryStore {
                 previous: decision.existingMemory,
                 category: fact.category,
                 source,
+                project: effectiveProject,
             };
         }
         // ADD
@@ -159,6 +204,9 @@ export class MemoryStore {
             memory: fact.fact,
             category: fact.category,
             source: source ?? '',
+            project: effectiveProject,
+            access_count: 0,
+            last_accessed: '',
             created_at: now,
             updated_at: now,
         });
@@ -169,6 +217,7 @@ export class MemoryStore {
             memory: fact.fact,
             category: fact.category,
             source,
+            project: effectiveProject,
         };
     }
 }
@@ -179,6 +228,9 @@ function payloadToMemoryItem(id, payload) {
         hash: String(payload.hash ?? ''),
         category: String(payload.category ?? payload.fileExtension ?? ''),
         source: String(payload.source ?? payload.language ?? ''),
+        project: String(payload.project ?? 'global'),
+        access_count: Number(payload.access_count ?? 0),
+        last_accessed: String(payload.last_accessed ?? ''),
         created_at: String(payload.created_at ?? ''),
         updated_at: String(payload.updated_at ?? ''),
     };

package/dist/memory/types.d.ts

@@ -4,6 +4,9 @@ export interface MemoryItem {
     hash: string;
     category: string;
     source: string;
+    project: string;
+    access_count: number;
+    last_accessed: string;
     created_at: string;
     updated_at: string;
 }
@@ -15,6 +18,7 @@ export interface MemoryAction {
     previous?: string;
     category?: string;
     source?: string;
+    project?: string;
 }
 export interface ReconcileResult {
     action: 'ADD' | 'UPDATE' | 'NONE';
@@ -24,5 +28,6 @@ export interface ReconcileResult {
 export interface ExtractedFact {
     fact: string;
     category: string;
+    project?: string;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/precompact/memory-inject.js

@@ -46,7 +46,7 @@ async function main() {
         const { getMemoryDbPath } = await import('../paths.js');
         const history = new MemoryHistory(getMemoryDbPath());
         const store = new MemoryStore(embedding, vectordb, history);
-        const memories = await store.searchMemory(`${projectName} development knowledge`, 7);
+        const memories = await store.searchMemory(`${projectName} development knowledge`, 7, undefined, projectName);
         if (memories.length === 0) {
             return;
         }

package/dist/tool-schemas.d.ts

@@ -256,12 +256,16 @@ export declare const TOOL_DEFINITIONS: readonly [{
                 readonly type: "string";
                 readonly description: "Optional source identifier (e.g., \"conversation\", \"claude-code\", \"user-note\").";
             };
+            readonly project: {
+                readonly type: "string";
+                readonly description: "Optional project name to scope this memory (e.g., \"my-app\"). Defaults to \"global\" for cross-project memories.";
+            };
         };
         readonly required: readonly ["facts"];
     };
 }, {
     readonly name: "search_memory";
-    readonly description: "Search stored developer memories using natural language. Returns semantically similar memories ranked by relevance.";
+    readonly description: "Search stored developer memories using natural language. Returns semantically similar memories ranked by relevance. When a project is specified, project-specific memories are ranked higher.";
     readonly inputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -280,12 +284,16 @@ export declare const TOOL_DEFINITIONS: readonly [{
                 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 project: {
+                readonly type: "string";
+                readonly description: "Optional project name to boost project-specific memories in results (e.g., \"my-app\"). Cross-project memories still appear but ranked lower.";
+            };
         };
         readonly required: readonly ["query"];
     };
 }, {
     readonly name: "list_memories";
-    readonly description: "List all stored developer memories, optionally filtered by category.";
+    readonly description: "List all stored developer memories, optionally filtered by category or project.";
     readonly inputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -300,6 +308,10 @@ export declare const TOOL_DEFINITIONS: readonly [{
                 readonly default: 50;
                 readonly maximum: 100;
             };
+            readonly project: {
+                readonly type: "string";
+                readonly description: "Optional project name to filter memories. Returns only project-specific and global memories.";
+            };
         };
         readonly required: readonly [];
     };

package/dist/tool-schemas.js

@@ -324,13 +324,17 @@ export const TOOL_DEFINITIONS = [
                     type: 'string',
                     description: 'Optional source identifier (e.g., "conversation", "claude-code", "user-note").',
                 },
+                project: {
+                    type: 'string',
+                    description: 'Optional project name to scope this memory (e.g., "my-app"). Defaults to "global" for cross-project memories.',
+                },
             },
             required: ['facts'],
         },
     },
     {
         name: 'search_memory',
-        description: 'Search stored developer memories using natural language. Returns semantically similar memories ranked by relevance.',
+        description: 'Search stored developer memories using natural language. Returns semantically similar memories ranked by relevance. When a project is specified, project-specific memories are ranked higher.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -357,13 +361,17 @@ export const TOOL_DEFINITIONS = [
                         'preferences',
                     ],
                 },
+                project: {
+                    type: 'string',
+                    description: 'Optional project name to boost project-specific memories in results (e.g., "my-app"). Cross-project memories still appear but ranked lower.',
+                },
             },
             required: ['query'],
         },
     },
     {
         name: 'list_memories',
-        description: 'List all stored developer memories, optionally filtered by category.',
+        description: 'List all stored developer memories, optionally filtered by category or project.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -386,6 +394,10 @@ export const TOOL_DEFINITIONS = [
                     default: 50,
                     maximum: 100,
                 },
+                project: {
+                    type: 'string',
+                    description: 'Optional project name to filter memories. Returns only project-specific and global memories.',
+                },
             },
             required: [],
         },

package/dist/tools.js

@@ -261,8 +261,9 @@ export class ToolHandlers {
         if (!facts || !Array.isArray(facts) || facts.length === 0)
             return textResult('Error: "facts" is required. Provide an array of pre-extracted facts with fact and category fields.');
         const source = args.source;
+        const project = args.project;
         try {
-            const actions = await this.memoryStore.addMemory(facts, source);
+            const actions = await this.memoryStore.addMemory(facts, source, project);
             return textResult(formatMemoryActions(actions));
         }
         catch (err) {
@@ -278,8 +279,9 @@ export class ToolHandlers {
             return textResult('Error: "query" is required. Provide a natural language search query.');
         const limit = args.limit ?? 10;
         const category = args.category;
+        const project = args.project;
         try {
-            const results = await this.memoryStore.searchMemory(query, limit, category);
+            const results = await this.memoryStore.searchMemory(query, limit, category, project);
             return textResult(formatMemorySearchResults(results, query));
         }
         catch (err) {
@@ -292,8 +294,9 @@ export class ToolHandlers {
             return textResult('Error: Memory system not initialized.');
         const category = args.category;
         const limit = args.limit ?? 50;
+        const project = args.project;
         try {
-            const results = await this.memoryStore.listMemories(category, limit);
+            const results = await this.memoryStore.listMemories(category, limit, project);
             return textResult(formatMemoryList(results));
         }
         catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-eidetic",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Semantic code search MCP server — lean, correct, fast",
   "type": "module",
   "main": "dist/index.js",