claude-eidetic 0.1.3 → 0.1.5

package/README.md

@@ -16,8 +16,7 @@ claude plugin install eidetics/claude-eidetic
 ```
 
 ```bash
-export OPENAI_API_KEY=sk-...         # for embeddings (default)
-export ANTHROPIC_API_KEY=sk-ant-...  # for memory extraction (default)
+export OPENAI_API_KEY=sk-...  # for embeddings (default)
 ```
 
 Index your codebase once, then search by meaning:
@@ -157,16 +156,13 @@ Add to your `.mcp.json`:
       "command": "npx",
       "args": ["-y", "claude-eidetic"],
       "env": {
-        "OPENAI_API_KEY": "sk-...",
-        "ANTHROPIC_API_KEY": "sk-ant-..."
+        "OPENAI_API_KEY": "sk-..."
       }
     }
   }
 }
 ```
 
-`ANTHROPIC_API_KEY` is needed for the memory LLM (default provider). Omit it if using `MEMORY_LLM_PROVIDER=openai` or `ollama`.
-
 ### Global install
 
 ```bash
@@ -184,7 +180,7 @@ npm install && npx tsc && npm start
 ### Requirements
 
 - Node.js >= 20.0.0
-- An API key (OpenAI for embeddings, Anthropic for memory extraction, or Ollama for both free)
+- An API key (OpenAI for embeddings, or Ollama for free local embeddings)
 - Docker (optional): Qdrant auto-provisions via Docker if not already running
 - C/C++ build tools: required by tree-sitter native bindings (`node-gyp`)
 
@@ -207,8 +203,7 @@ export MEMORY_LLM_PROVIDER=ollama
 
 | Variable | Default | Description |
 |---|---|---|
-| `OPENAI_API_KEY` | _(required for openai)_ | OpenAI API key for embeddings and/or memory |
-| `ANTHROPIC_API_KEY` | _(required for anthropic memory)_ | Anthropic API key for memory LLM |
+| `OPENAI_API_KEY` | _(required for openai)_ | OpenAI API key for embeddings |
 | `EMBEDDING_PROVIDER` | `openai` | `openai`, `ollama`, or `local` |
 | `EMBEDDING_MODEL` | `text-embedding-3-small` (openai) / `nomic-embed-text` (ollama) | Embedding model name |
 | `EMBEDDING_BATCH_SIZE` | `100` | Batch size for embedding requests (1-2048) |
@@ -223,10 +218,6 @@ export MEMORY_LLM_PROVIDER=ollama
 | `EIDETIC_DATA_DIR` | `~/.eidetic/` | Data root for snapshots, memory DB, registry |
 | `CUSTOM_EXTENSIONS` | `[]` | JSON array of extra file extensions to index (e.g., `[".dart",".arb"]`) |
 | `CUSTOM_IGNORE_PATTERNS` | `[]` | JSON array of glob patterns to exclude |
-| `MEMORY_LLM_PROVIDER` | `anthropic` | `anthropic`, `openai`, or `ollama` |
-| `MEMORY_LLM_MODEL` | `claude-haiku-4-5-20251001` (anthropic) / `gpt-4o-mini` (openai) / `llama3.2` (ollama) | Model for memory extraction |
-| `MEMORY_LLM_BASE_URL` | _(none)_ | Custom base URL for memory LLM |
-| `MEMORY_LLM_API_KEY` | _(none)_ | API key override for memory LLM |
 
 </details>
 

package/dist/config.d.ts

@@ -15,11 +15,6 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     eideticDataDir: z.ZodDefault<z.ZodString>;
     customExtensions: z.ZodEffects<z.ZodDefault<z.ZodArray<z.ZodString, "many">>, string[], unknown>;
     customIgnorePatterns: z.ZodEffects<z.ZodDefault<z.ZodArray<z.ZodString, "many">>, string[], unknown>;
-    memoryLlmProvider: z.ZodDefault<z.ZodEnum<["openai", "ollama", "anthropic"]>>;
-    memoryLlmModel: z.ZodOptional<z.ZodString>;
-    memoryLlmBaseUrl: z.ZodOptional<z.ZodString>;
-    memoryLlmApiKey: z.ZodOptional<z.ZodString>;
-    anthropicApiKey: z.ZodDefault<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     embeddingProvider: "openai" | "ollama" | "local";
     openaiApiKey: string;
@@ -32,15 +27,10 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     eideticDataDir: string;
     customExtensions: string[];
     customIgnorePatterns: string[];
-    memoryLlmProvider: "openai" | "ollama" | "anthropic";
-    anthropicApiKey: string;
     openaiBaseUrl?: string | undefined;
     embeddingModel?: string | undefined;
     qdrantApiKey?: string | undefined;
     milvusToken?: string | undefined;
-    memoryLlmModel?: string | undefined;
-    memoryLlmBaseUrl?: string | undefined;
-    memoryLlmApiKey?: string | undefined;
 }, {
     embeddingProvider?: "openai" | "ollama" | "local" | undefined;
     openaiApiKey?: string | undefined;
@@ -57,14 +47,8 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     eideticDataDir?: string | undefined;
     customExtensions?: unknown;
     customIgnorePatterns?: unknown;
-    memoryLlmProvider?: "openai" | "ollama" | "anthropic" | undefined;
-    memoryLlmModel?: string | undefined;
-    memoryLlmBaseUrl?: string | undefined;
-    memoryLlmApiKey?: string | undefined;
-    anthropicApiKey?: string | undefined;
 }>, {
     embeddingModel: string;
-    memoryLlmModel: string;
     embeddingProvider: "openai" | "ollama" | "local";
     openaiApiKey: string;
     ollamaBaseUrl: string;
@@ -76,13 +60,9 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     eideticDataDir: string;
     customExtensions: string[];
     customIgnorePatterns: string[];
-    memoryLlmProvider: "openai" | "ollama" | "anthropic";
-    anthropicApiKey: string;
     openaiBaseUrl?: string | undefined;
     qdrantApiKey?: string | undefined;
     milvusToken?: string | undefined;
-    memoryLlmBaseUrl?: string | undefined;
-    memoryLlmApiKey?: string | undefined;
 }, {
     embeddingProvider?: "openai" | "ollama" | "local" | undefined;
     openaiApiKey?: string | undefined;
@@ -99,11 +79,6 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     eideticDataDir?: string | undefined;
     customExtensions?: unknown;
     customIgnorePatterns?: unknown;
-    memoryLlmProvider?: "openai" | "ollama" | "anthropic" | undefined;
-    memoryLlmModel?: string | undefined;
-    memoryLlmBaseUrl?: string | undefined;
-    memoryLlmApiKey?: string | undefined;
-    anthropicApiKey?: string | undefined;
 }>;
 export type Config = z.infer<typeof configSchema>;
 export declare function loadConfig(): Config;

package/dist/config.js

@@ -19,24 +19,12 @@ const configSchema = z
     eideticDataDir: z.string().default(path.join(os.homedir(), '.eidetic')),
     customExtensions: z.preprocess((val) => (typeof val === 'string' ? JSON.parse(val) : val), z.array(z.string()).default([])),
     customIgnorePatterns: z.preprocess((val) => (typeof val === 'string' ? JSON.parse(val) : val), z.array(z.string()).default([])),
-    memoryLlmProvider: z.enum(['openai', 'ollama', 'anthropic']).default('anthropic'),
-    memoryLlmModel: z.string().optional(),
-    memoryLlmBaseUrl: z.string().optional(),
-    memoryLlmApiKey: z.string().optional(),
-    anthropicApiKey: z.string().default(''),
 })
     .transform((cfg) => ({
     ...cfg,
     // Default embedding model depends on provider
     embeddingModel: cfg.embeddingModel ??
         (cfg.embeddingProvider === 'ollama' ? 'nomic-embed-text' : 'text-embedding-3-small'),
-    // Default memory LLM model depends on provider
-    memoryLlmModel: cfg.memoryLlmModel ??
-        (cfg.memoryLlmProvider === 'ollama'
-            ? 'llama3.2'
-            : cfg.memoryLlmProvider === 'anthropic'
-                ? 'claude-haiku-4-5-20251001'
-                : 'gpt-4o-mini'),
 }));
 let cachedConfig = null;
 export function loadConfig() {
@@ -56,11 +44,6 @@ export function loadConfig() {
         eideticDataDir: process.env.EIDETIC_DATA_DIR,
         customExtensions: process.env.CUSTOM_EXTENSIONS,
         customIgnorePatterns: process.env.CUSTOM_IGNORE_PATTERNS,
-        memoryLlmProvider: process.env.MEMORY_LLM_PROVIDER,
-        memoryLlmModel: process.env.MEMORY_LLM_MODEL || undefined,
-        memoryLlmBaseUrl: process.env.MEMORY_LLM_BASE_URL || undefined,
-        memoryLlmApiKey: process.env.MEMORY_LLM_API_KEY?.trim().replace(/^["']|["']$/g, '') || undefined,
-        anthropicApiKey: (process.env.ANTHROPIC_API_KEY ?? '').trim().replace(/^["']|["']$/g, ''),
     };
     const result = configSchema.safeParse(raw);
     if (!result.success) {

package/dist/embedding/openai.js

@@ -148,7 +148,7 @@ export class OpenAIEmbedding {
     }
     async callWithRetry(texts) {
         let currentBatchSize = texts.length;
-        for (let attempt = 0; attempt <= RETRY_DELAYS.length; attempt++) {
+        for (let attempt = 0; attempt < RETRY_DELAYS.length + 1; attempt++) {
             try {
                 const allResults = [];
                 for (let offset = 0; offset < texts.length; offset += currentBatchSize) {

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/index.js

@@ -58,7 +58,7 @@ const WORKFLOW_GUIDANCE = `# Eidetic Code Search Workflow
 - Stale docs (past TTL) still return results but are flagged \`[STALE]\`
 
 **Persistent memory (cross-session developer knowledge):**
-- \`add_memory(content="...")\` → extracts facts about coding style, tools, architecture, etc.
+- \`add_memory(facts=[{fact:"...", category:"..."}])\` → stores pre-extracted facts about coding style, tools, architecture, etc.
 - \`search_memory(query="...")\` → find relevant memories by semantic search
 - \`list_memories()\` → see all stored memories grouped by category
 - \`delete_memory(id="...")\` → remove a specific memory

package/dist/memory/store.d.ts

@@ -1,6 +1,6 @@
 import type { Embedding } from '../embedding/types.js';
 import type { VectorDB } from '../vectordb/types.js';
-import type { MemoryItem, MemoryAction } from './types.js';
+import type { MemoryItem, MemoryAction, ExtractedFact } from './types.js';
 import { MemoryHistory } from './history.js';
 export declare class MemoryStore {
     private embedding;
@@ -9,12 +9,12 @@ export declare class MemoryStore {
     private initialized;
     constructor(embedding: Embedding, vectordb: VectorDB, history: MemoryHistory);
     private ensureCollection;
-    addMemory(content: string, 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 extractFacts;
+    private bumpAccessCounts;
     private processFact;
 }
 //# sourceMappingURL=store.d.ts.map

package/dist/memory/store.js

@@ -1,15 +1,15 @@
 import { randomUUID } from 'node:crypto';
-import { chatCompletion } from './llm.js';
-import { buildSystemPrompt, buildExtractionPrompt } from './prompts.js';
 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;
@@ -29,26 +29,27 @@ export class MemoryStore {
         }
         this.initialized = true;
     }
-    async addMemory(content, source) {
+    async addMemory(facts, source, project = 'global') {
         await this.ensureCollection();
-        const facts = await this.extractFacts(content);
         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
@@ -60,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, {
@@ -79,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) {
@@ -94,24 +109,26 @@ export class MemoryStore {
     getHistory(memoryId) {
         return this.history.getHistory(memoryId);
     }
-    async extractFacts(content) {
-        const userMessage = buildExtractionPrompt(content);
-        const response = await chatCompletion(buildSystemPrompt(), userMessage);
-        try {
-            const parsed = JSON.parse(response);
-            const facts = parsed.facts;
-            if (!Array.isArray(facts))
-                return [];
-            return facts.filter((f) => typeof f === 'object' &&
-                f !== null &&
-                typeof f.fact === 'string' &&
-                typeof f.category === 'string');
-        }
-        catch {
-            return [];
+    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) {
+    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, {
@@ -139,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,
@@ -153,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,
             });
@@ -164,6 +188,7 @@ export class MemoryStore {
                 previous: decision.existingMemory,
                 category: fact.category,
                 source,
+                project: effectiveProject,
             };
         }
         // ADD
@@ -179,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,
         });
@@ -189,6 +217,7 @@ export class MemoryStore {
             memory: fact.fact,
             category: fact.category,
             source,
+            project: effectiveProject,
         };
     }
 }
@@ -199,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/hook.d.ts

@@ -3,7 +3,7 @@
  * Hook entry point for PreCompact and SessionEnd events.
  *
  * PreCompact: Parses transcript, writes session note, updates index, spawns background indexer.
- * SessionEnd: Same as PreCompact + runs memory extraction pipeline (semantic facts → Qdrant).
+ * SessionEnd: Same as PreCompact (writes session note if not already captured by PreCompact).
  */
 export {};
 //# sourceMappingURL=hook.d.ts.map

package/dist/precompact/hook.js

@@ -3,7 +3,7 @@
  * Hook entry point for PreCompact and SessionEnd events.
  *
  * PreCompact: Parses transcript, writes session note, updates index, spawns background indexer.
- * SessionEnd: Same as PreCompact + runs memory extraction pipeline (semantic facts → Qdrant).
+ * SessionEnd: Same as PreCompact (writes session note if not already captured by PreCompact).
  */
 import { z } from 'zod';
 import path from 'node:path';
@@ -68,14 +68,11 @@ async function main() {
                 updateSessionIndex(notesDir, session, noteFile);
                 spawnBackgroundIndexer(notesDir, INDEX_RUNNER_PATH);
             }
-            // Run memory extraction (best-effort — graceful failure if Qdrant unavailable)
-            const memoryActions = await extractMemories(session);
             outputSuccess({
                 noteFile,
                 skippedNote,
                 filesModified: session.filesModified.length,
                 tasksCreated: session.tasksCreated.length,
-                memoriesExtracted: memoryActions,
             });
         }
         else {
@@ -94,61 +91,6 @@ async function main() {
         outputError(err instanceof Error ? err.message : String(err));
     }
 }
-/**
- * Build content string for memory extraction from an ExtractedSession.
- */
-function buildMemoryContent(session) {
-    const parts = [];
-    if (session.userMessages.length > 0) {
-        parts.push('User messages:');
-        session.userMessages.forEach((msg, i) => {
-            parts.push(`${i + 1}. ${msg}`);
-        });
-    }
-    if (session.filesModified.length > 0) {
-        parts.push(`\nFiles modified: ${session.filesModified.join(', ')}`);
-    }
-    if (session.tasksCreated.length > 0) {
-        parts.push(`Tasks: ${session.tasksCreated.join(', ')}`);
-    }
-    if (session.branch) {
-        parts.push(`Branch: ${session.branch}`);
-    }
-    return parts.join('\n');
-}
-/**
- * Run memory extraction pipeline. Returns count of actions taken.
- * Fails gracefully — logs to stderr if Qdrant or LLM unavailable.
- */
-async function extractMemories(session) {
-    const content = buildMemoryContent(session);
-    if (!content.trim())
-        return 0;
-    try {
-        // Dynamic imports to avoid loading heavy deps on every hook invocation
-        const [{ loadConfig }, { createEmbedding }, { QdrantVectorDB }, { MemoryHistory }, { MemoryStore }, { getMemoryDbPath },] = await Promise.all([
-            import('../config.js'),
-            import('../embedding/factory.js'),
-            import('../vectordb/qdrant.js'),
-            import('../memory/history.js'),
-            import('../memory/store.js'),
-            import('../paths.js'),
-        ]);
-        const config = loadConfig();
-        const embedding = createEmbedding(config);
-        await embedding.initialize();
-        const vectordb = new QdrantVectorDB();
-        const history = new MemoryHistory(getMemoryDbPath());
-        const memoryStore = new MemoryStore(embedding, vectordb, history);
-        const actions = await memoryStore.addMemory(content, 'session-end-hook');
-        process.stderr.write(`[eidetic] Memory extraction: ${actions.length} action(s) (${actions.map((a) => a.event).join(', ') || 'none'})\n`);
-        return actions.length;
-    }
-    catch (err) {
-        process.stderr.write(`[eidetic] Memory extraction failed (non-fatal): ${err instanceof Error ? err.message : String(err)}\n`);
-        return 0;
-    }
-}
 async function readStdin() {
     const chunks = [];
     for await (const chunk of process.stdin) {

package/dist/precompact/memory-inject.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Inject stored memories at SessionStart.
+ * Called by session-start hook to surface previously learned knowledge.
+ *
+ * Outputs markdown to stdout for hook to capture and inject into session.
+ */
+import type { MemoryItem } from '../memory/types.js';
+export declare function formatMemoryContext(memories: MemoryItem[]): string;
+//# sourceMappingURL=memory-inject.d.ts.map

package/dist/precompact/memory-inject.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Inject stored memories at SessionStart.
+ * Called by session-start hook to surface previously learned knowledge.
+ *
+ * Outputs markdown to stdout for hook to capture and inject into session.
+ */
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+async function main() {
+    try {
+        // Get cwd from environment (set by Claude Code) or detect from git
+        const cwd = process.env.CLAUDE_CWD || process.cwd();
+        // Detect project root from git
+        const projectPath = detectProjectRoot(cwd);
+        if (!projectPath) {
+            // Not in a git repo, nothing to inject
+            return;
+        }
+        const projectName = path.basename(projectPath);
+        // Dynamic imports — avoid loading heavy deps if not needed
+        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();
+        // Respect VECTORDB_PROVIDER — connect without bootstrapping (hook assumes DB is already running)
+        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 no memory collection exists
+        const exists = await vectordb.hasCollection('eidetic_memory');
+        if (!exists) {
+            return;
+        }
+        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, undefined, projectName);
+        if (memories.length === 0) {
+            return;
+        }
+        process.stdout.write(formatMemoryContext(memories));
+    }
+    catch (err) {
+        // Write to stderr for debugging, but don't break session start
+        process.stderr.write(`Memory inject failed: ${String(err)}\n`);
+    }
+}
+function detectProjectRoot(cwd) {
+    try {
+        const result = execSync('git rev-parse --show-toplevel', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return result.trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function formatMemoryContext(memories) {
+    const lines = [];
+    lines.push('## Remembered Knowledge');
+    for (const m of memories) {
+        const category = m.category ? `[${m.category}] ` : '';
+        lines.push(`- ${category}${m.memory}`);
+    }
+    lines.push('');
+    lines.push('_search_memory(query) for more. add_memory(facts) to save new findings._');
+    lines.push('');
+    return lines.join('\n');
+}
+void main();
+//# sourceMappingURL=memory-inject.js.map

package/dist/tool-schemas.d.ts

@@ -229,24 +229,43 @@ export declare const TOOL_DEFINITIONS: readonly [{
     };
 }, {
     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 description: "Store pre-extracted developer knowledge facts. Before calling, extract facts yourself from the relevant content. Each fact should be a concise, self-contained statement about coding style, tools, architecture, conventions, debugging insights, or 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 facts: {
+                readonly type: "array";
+                readonly description: "Array of facts to store. Extract these yourself before calling. Each fact must be a concise, self-contained statement.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly fact: {
+                            readonly type: "string";
+                            readonly description: "A concise, self-contained statement of a developer preference or convention.";
+                        };
+                        readonly category: {
+                            readonly type: "string";
+                            readonly description: "Category: coding_style, tools, architecture, conventions, debugging, workflow, or preferences.";
+                            readonly enum: readonly ["coding_style", "tools", "architecture", "conventions", "debugging", "workflow", "preferences"];
+                        };
+                    };
+                    readonly required: readonly ["fact", "category"];
+                };
             };
             readonly source: {
                 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 ["content"];
+        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: {
@@ -265,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: {
@@ -285,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

@@ -289,25 +289,52 @@ export const TOOL_DEFINITIONS = [
     },
     {
         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.',
+        description: 'Store pre-extracted developer knowledge facts. Before calling, extract facts yourself from the relevant content. Each fact should be a concise, self-contained statement about coding style, tools, architecture, conventions, debugging insights, or 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).',
+                facts: {
+                    type: 'array',
+                    description: 'Array of facts to store. Extract these yourself before calling. Each fact must be a concise, self-contained statement.',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            fact: {
+                                type: 'string',
+                                description: 'A concise, self-contained statement of a developer preference or convention.',
+                            },
+                            category: {
+                                type: 'string',
+                                description: 'Category: coding_style, tools, architecture, conventions, debugging, workflow, or preferences.',
+                                enum: [
+                                    'coding_style',
+                                    'tools',
+                                    'architecture',
+                                    'conventions',
+                                    'debugging',
+                                    'workflow',
+                                    'preferences',
+                                ],
+                            },
+                        },
+                        required: ['fact', 'category'],
+                    },
                 },
                 source: {
                     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: ['content'],
+            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: {
@@ -334,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: {
@@ -363,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

@@ -257,12 +257,13 @@ export class ToolHandlers {
     async handleAddMemory(args) {
         if (!this.memoryStore)
             return textResult('Error: Memory system not initialized.');
-        const content = args.content;
-        if (!content)
-            return textResult('Error: "content" is required. Provide text containing developer knowledge to extract.');
+        const facts = args.facts;
+        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(content, 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.3",
+  "version": "0.1.5",
   "description": "Semantic code search MCP server — lean, correct, fast",
   "type": "module",
   "main": "dist/index.js",
@@ -37,7 +37,6 @@
     "release": "bash scripts/release.sh"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.78.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@qdrant/js-client-rest": "^1.13.0",
     "better-sqlite3": "^12.6.2",
@@ -81,7 +80,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/eidetics/claude-eidetic"
+    "url": "https://github.com/eidetics/claude-eidetic.git"
   },
   "license": "MIT"
 }

package/dist/memory/llm.d.ts

@@ -1,2 +0,0 @@
-export declare function chatCompletion(systemPrompt: string, userMessage: string): Promise<string>;
-//# sourceMappingURL=llm.d.ts.map

package/dist/memory/llm.js

@@ -1,56 +0,0 @@
-import OpenAI from 'openai';
-import Anthropic from '@anthropic-ai/sdk';
-import { getConfig } from '../config.js';
-import { MemoryError } from '../errors.js';
-export async function chatCompletion(systemPrompt, userMessage) {
-    const config = getConfig();
-    if (config.memoryLlmProvider === 'anthropic') {
-        const apiKey = config.memoryLlmApiKey ?? config.anthropicApiKey ?? config.openaiApiKey;
-        if (!apiKey) {
-            throw new MemoryError('No API key configured for memory LLM. Set MEMORY_LLM_API_KEY, ANTHROPIC_API_KEY, or OPENAI_API_KEY.');
-        }
-        const client = new Anthropic({ apiKey });
-        try {
-            const response = await client.messages.create({
-                model: config.memoryLlmModel,
-                max_tokens: 2048,
-                system: systemPrompt,
-                messages: [{ role: 'user', content: userMessage }],
-            });
-            const block = response.content[0];
-            return block?.type === 'text' ? block.text : '{}';
-        }
-        catch (err) {
-            throw new MemoryError('Memory LLM call failed', err);
-        }
-    }
-    // OpenAI / Ollama path
-    const apiKey = config.memoryLlmApiKey ?? config.openaiApiKey;
-    if (!apiKey) {
-        throw new MemoryError('No API key configured for memory LLM. Set MEMORY_LLM_API_KEY or OPENAI_API_KEY.');
-    }
-    let baseURL;
-    if (config.memoryLlmBaseUrl) {
-        baseURL = config.memoryLlmBaseUrl;
-    }
-    else if (config.memoryLlmProvider === 'ollama') {
-        baseURL = config.ollamaBaseUrl;
-    }
-    const client = new OpenAI({ apiKey, ...(baseURL ? { baseURL } : {}) });
-    try {
-        const response = await client.chat.completions.create({
-            model: config.memoryLlmModel,
-            messages: [
-                { role: 'system', content: systemPrompt },
-                { role: 'user', content: userMessage },
-            ],
-            temperature: 0,
-            response_format: { type: 'json_object' },
-        });
-        return response.choices[0]?.message?.content ?? '{}';
-    }
-    catch (err) {
-        throw new MemoryError('Memory LLM call failed', err);
-    }
-}
-//# sourceMappingURL=llm.js.map

package/dist/memory/prompts.d.ts

@@ -1,5 +0,0 @@
-export declare const FACT_EXTRACTION_SYSTEM_PROMPT = "You are a developer knowledge extractor. Your job is to extract discrete, factual statements from conversations about software development.\n\nExtract facts about:\n- **coding_style**: Formatting preferences (tabs/spaces, naming conventions, line length), code style rules\n- **tools**: Preferred tools, frameworks, libraries, test runners, bundlers, linters, editors\n- **architecture**: Design patterns, architectural decisions, system design preferences\n- **conventions**: Project conventions, commit message formats, branch naming, PR workflows\n- **debugging**: Solutions to specific bugs, debugging techniques, known issues\n- **workflow**: Development habits, deployment processes, review preferences\n- **preferences**: General preferences, opinions, requirements that don't fit other categories\n\nRules:\n1. Extract only factual, concrete statements \u2014 not vague observations\n2. Each fact should be a single, self-contained statement\n3. Use third person (\"The user prefers...\" or state the fact directly)\n4. If the input contains no extractable facts, return an empty array\n5. Do NOT extract facts about the conversation itself (e.g., \"the user asked about...\")\n6. Do NOT extract temporary or session-specific information\n7. Prefer specific facts over general ones\n\nRespond with JSON: { \"facts\": [{ \"fact\": \"...\", \"category\": \"...\" }] }\n\nCategories: coding_style, tools, architecture, conventions, debugging, workflow, preferences";
-export declare const FACT_EXTRACTION_USER_TEMPLATE = "Extract developer knowledge facts from this text:\n\n<text>\n{content}\n</text>";
-export declare function buildSystemPrompt(): string;
-export declare function buildExtractionPrompt(content: string): string;
-//# sourceMappingURL=prompts.d.ts.map

package/dist/memory/prompts.js

@@ -1,36 +0,0 @@
-export const FACT_EXTRACTION_SYSTEM_PROMPT = `You are a developer knowledge extractor. Your job is to extract discrete, factual statements from conversations about software development.
-
-Extract facts about:
-- **coding_style**: Formatting preferences (tabs/spaces, naming conventions, line length), code style rules
-- **tools**: Preferred tools, frameworks, libraries, test runners, bundlers, linters, editors
-- **architecture**: Design patterns, architectural decisions, system design preferences
-- **conventions**: Project conventions, commit message formats, branch naming, PR workflows
-- **debugging**: Solutions to specific bugs, debugging techniques, known issues
-- **workflow**: Development habits, deployment processes, review preferences
-- **preferences**: General preferences, opinions, requirements that don't fit other categories
-
-Rules:
-1. Extract only factual, concrete statements — not vague observations
-2. Each fact should be a single, self-contained statement
-3. Use third person ("The user prefers..." or state the fact directly)
-4. If the input contains no extractable facts, return an empty array
-5. Do NOT extract facts about the conversation itself (e.g., "the user asked about...")
-6. Do NOT extract temporary or session-specific information
-7. Prefer specific facts over general ones
-
-Respond with JSON: { "facts": [{ "fact": "...", "category": "..." }] }
-
-Categories: coding_style, tools, architecture, conventions, debugging, workflow, preferences`;
-export const FACT_EXTRACTION_USER_TEMPLATE = `Extract developer knowledge facts from this text:
-
-<text>
-{content}
-</text>`;
-export function buildSystemPrompt() {
-    const today = new Date().toISOString().slice(0, 10);
-    return `${FACT_EXTRACTION_SYSTEM_PROMPT}\n- Today's date is ${today}.`;
-}
-export function buildExtractionPrompt(content) {
-    return FACT_EXTRACTION_USER_TEMPLATE.replace('{content}', content);
-}
-//# sourceMappingURL=prompts.js.map