claude-eidetic 0.1.1 → 0.1.2

package/dist/index.js

@@ -9,15 +9,18 @@ console.warn = (...args) => {
 };
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { loadConfig } from './config.js';
 import { createEmbedding } from './embedding/factory.js';
 import { QdrantVectorDB } from './vectordb/qdrant.js';
 import { bootstrapQdrant } from './infra/qdrant-bootstrap.js';
 import { StateManager, cleanupOrphanedSnapshots } from './state/snapshot.js';
-import { ToolHandlers } from './tools.js';
+import { ToolHandlers, handleReadFile } from './tools.js';
 import { TOOL_DEFINITIONS } from './tool-schemas.js';
 import { getSetupErrorMessage } from './setup-message.js';
+import { MemoryStore } from './memory/store.js';
+import { MemoryHistory } from './memory/history.js';
+import { getMemoryDbPath } from './paths.js';
 const WORKFLOW_GUIDANCE = `# Eidetic Code Search Workflow
 
 **Before searching:** Ensure the codebase is indexed.
@@ -33,14 +36,34 @@ const WORKFLOW_GUIDANCE = `# Eidetic Code Search Workflow
 - Use \`project\` param instead of \`path\` for convenience
 - Start with specific queries, broaden if no results
 
+**Reading files efficiently:**
+- \`read_file(path="...")\` → raw content without line-number overhead (~15-20% fewer tokens for code, more for short-line files)
+- Use \`offset\` and \`limit\` to page through large files
+- Add \`lineNumbers=true\` only when you need line references for editing
+
 **After first index:**
 - Re-indexing is incremental (only changed files re-embedded)
 - Use \`project\` param instead of \`path\` for convenience
 - Use \`get_indexing_status\` to check progress during long indexes
+- Use \`cleanup_vectors(path="...", dryRun=true)\` to preview stale vectors, then without dryRun to remove them (no embedding cost)
 
 **Cross-project search:**
 - Index multiple projects, each with its own path
-- Search across any indexed project regardless of current working directory`;
+- Search across any indexed project regardless of current working directory
+
+**Documentation caching (saves ~5K tokens per repeated doc fetch):**
+- After fetching docs via query-docs or WebFetch, cache them: \`index_document(content="...", source="<url>", library="<name>", topic="<topic>")\`
+- Next time you need the same docs: \`search_documents(query="...", library="<name>")\` (~20 tokens/result)
+- Docs are grouped by library — one collection per library, searchable across topics
+- 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.
+- \`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
+- \`memory_history(id="...")\` → view change log for a memory
+- Memories are automatically deduplicated — adding similar facts updates existing ones`;
 async function main() {
     const config = loadConfig();
     console.log(`Config loaded. Provider: ${config.vectordbProvider}, Model: ${config.embeddingModel}`);
@@ -66,24 +89,44 @@ async function main() {
         }
         const state = new StateManager();
         handlers = new ToolHandlers(embedding, vectordb, state);
+        // Initialize memory subsystem
+        try {
+            const memoryHistory = new MemoryHistory(getMemoryDbPath());
+            const memoryStore = new MemoryStore(embedding, vectordb, memoryHistory);
+            handlers.setMemoryStore(memoryStore);
+            console.log('Memory system initialized.');
+        }
+        catch (memErr) {
+            console.warn(`Memory system initialization failed: ${memErr instanceof Error ? memErr.message : String(memErr)}`);
+            console.warn('Memory tools will return errors. Other tools work normally.');
+        }
     }
     catch (err) {
         setupError = err instanceof Error ? err.message : String(err);
         console.warn(`Eidetic initialization failed: ${setupError}`);
         console.warn('Server will start in setup-required mode. All tool calls will return setup instructions.');
     }
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
     const server = new Server({ name: 'claude-eidetic', version: '0.1.0' }, { capabilities: { tools: {} } });
+    // eslint-disable-next-line @typescript-eslint/require-await
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: [...TOOL_DEFINITIONS],
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
+        // Tools that work without initialization (no embedding/vectordb needed)
+        if (name === '__IMPORTANT')
+            return { content: [{ type: 'text', text: WORKFLOW_GUIDANCE }] };
+        if (name === 'read_file')
+            return handleReadFile(args ?? {});
         if (!handlers) {
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: getSetupErrorMessage(setupError ?? 'Unknown error'),
-                    }],
+                    },
+                ],
                 isError: true,
             };
         }
@@ -98,10 +141,26 @@ async function main() {
                 return handlers.handleGetIndexingStatus(args ?? {});
             case 'list_indexed':
                 return handlers.handleListIndexed();
-            case '__IMPORTANT':
-                return {
-                    content: [{ type: 'text', text: WORKFLOW_GUIDANCE }],
-                };
+            case 'index_document':
+                return handlers.handleIndexDocument(args ?? {});
+            case 'search_documents':
+                return handlers.handleSearchDocuments(args ?? {});
+            case 'add_memory':
+                return handlers.handleAddMemory(args ?? {});
+            case 'search_memory':
+                return handlers.handleSearchMemory(args ?? {});
+            case 'list_memories':
+                return handlers.handleListMemories(args ?? {});
+            case 'delete_memory':
+                return handlers.handleDeleteMemory(args ?? {});
+            case 'memory_history':
+                return handlers.handleMemoryHistory(args ?? {});
+            case 'cleanup_vectors':
+                return handlers.handleCleanupVectors(args ?? {});
+            case 'browse_structure':
+                return handlers.handleBrowseStructure(args ?? {});
+            case 'list_symbols':
+                return handlers.handleListSymbols(args ?? {});
             default:
                 return {
                     content: [{ type: 'text', text: `Unknown tool: ${name}` }],

package/dist/infra/qdrant-bootstrap.js

@@ -30,12 +30,18 @@ export async function bootstrapQdrant() {
         const dataDir = path.join(getDataDir(), 'qdrant-data').replace(/\\/g, '/');
         console.log(`Creating new Qdrant container "${CONTAINER_NAME}"...`);
         execFileSync('docker', [
-            'run', '-d',
-            '--name', CONTAINER_NAME,
-            '--restart', 'unless-stopped',
-            '-p', '6333:6333',
-            '-p', '6334:6334',
-            '-v', `${dataDir}:/qdrant/storage`,
+            'run',
+            '-d',
+            '--name',
+            CONTAINER_NAME,
+            '--restart',
+            'unless-stopped',
+            '-p',
+            '6333:6333',
+            '-p',
+            '6334:6334',
+            '-v',
+            `${dataDir}:/qdrant/storage`,
             'qdrant/qdrant',
         ], { stdio: 'pipe' });
     }
@@ -67,11 +73,7 @@ function isDockerAvailable() {
 }
 function getContainerState() {
     try {
-        const output = execFileSync('docker', [
-            'ps', '-a',
-            '--filter', `name=^/${CONTAINER_NAME}$`,
-            '--format', '{{.State}}',
-        ], { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        const output = execFileSync('docker', ['ps', '-a', '--filter', `name=^/${CONTAINER_NAME}$`, '--format', '{{.State}}'], { encoding: 'utf-8', stdio: 'pipe' }).trim();
         if (!output)
             return 'none';
         if (output === 'running')
@@ -87,7 +89,7 @@ async function waitForHealth(url, timeoutMs) {
     while (Date.now() - start < timeoutMs) {
         if (await isQdrantHealthy(url))
             return true;
-        await new Promise(r => setTimeout(r, HEALTH_POLL_MS));
+        await new Promise((r) => setTimeout(r, HEALTH_POLL_MS));
     }
     return false;
 }

package/dist/memory/history.d.ts

@@ -0,0 +1,19 @@
+import type { MemoryEvent } from './types.js';
+export interface HistoryEntry {
+    id: number;
+    memory_id: string;
+    previous_value: string | null;
+    new_value: string | null;
+    event: MemoryEvent;
+    created_at: string;
+    updated_at: string | null;
+    source: string | null;
+}
+export declare class MemoryHistory {
+    private db;
+    constructor(dbPath: string);
+    log(memoryId: string, event: MemoryEvent, newValue: string | null, previousValue?: string | null, source?: string | null, updatedAt?: string | null): void;
+    getHistory(memoryId: string): HistoryEntry[];
+    close(): void;
+}
+//# sourceMappingURL=history.d.ts.map

package/dist/memory/history.js

@@ -0,0 +1,40 @@
+import Database from 'better-sqlite3';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export class MemoryHistory {
+    db;
+    constructor(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memory_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        memory_id TEXT NOT NULL,
+        previous_value TEXT,
+        new_value TEXT,
+        event TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT,
+        source TEXT
+      )
+    `);
+    }
+    log(memoryId, event, newValue, previousValue = null, source = null, updatedAt = null) {
+        this.db
+            .prepare(`
+      INSERT INTO memory_history (memory_id, previous_value, new_value, event, created_at, updated_at, source)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `)
+            .run(memoryId, previousValue, newValue, event, new Date().toISOString(), updatedAt, source);
+    }
+    getHistory(memoryId) {
+        return this.db
+            .prepare('SELECT * FROM memory_history WHERE memory_id = ? ORDER BY created_at ASC')
+            .all(memoryId);
+    }
+    close() {
+        this.db.close();
+    }
+}
+//# sourceMappingURL=history.js.map

package/dist/memory/llm.d.ts

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

package/dist/memory/llm.js

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,36 @@
+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

package/dist/memory/reconciler.d.ts

@@ -0,0 +1,12 @@
+import type { ReconcileResult } from './types.js';
+export declare function hashMemory(text: string): string;
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+export interface ExistingMatch {
+    id: string;
+    memory: string;
+    hash: string;
+    vector: number[];
+    score: number;
+}
+export declare function reconcile(newHash: string, newVector: number[], candidates: ExistingMatch[]): ReconcileResult;
+//# sourceMappingURL=reconciler.d.ts.map

package/dist/memory/reconciler.js

@@ -0,0 +1,36 @@
+import { createHash } from 'node:crypto';
+const SIMILARITY_THRESHOLD = 0.92;
+export function hashMemory(text) {
+    return createHash('md5').update(text.trim().toLowerCase()).digest('hex');
+}
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return 0;
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dot / denom;
+}
+export function reconcile(newHash, newVector, candidates) {
+    // Check for exact hash match first
+    for (const candidate of candidates) {
+        if (candidate.hash === newHash) {
+            return { action: 'NONE', existingId: candidate.id, existingMemory: candidate.memory };
+        }
+    }
+    // Check cosine similarity for semantic near-duplicates
+    for (const candidate of candidates) {
+        const sim = cosineSimilarity(newVector, candidate.vector);
+        if (sim >= SIMILARITY_THRESHOLD) {
+            return { action: 'UPDATE', existingId: candidate.id, existingMemory: candidate.memory };
+        }
+    }
+    return { action: 'ADD' };
+}
+//# sourceMappingURL=reconciler.js.map

package/dist/memory/store.d.ts

@@ -0,0 +1,20 @@
+import type { Embedding } from '../embedding/types.js';
+import type { VectorDB } from '../vectordb/types.js';
+import type { MemoryItem, MemoryAction } from './types.js';
+import { MemoryHistory } from './history.js';
+export declare class MemoryStore {
+    private embedding;
+    private vectordb;
+    private history;
+    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[]>;
+    deleteMemory(id: string): Promise<boolean>;
+    getHistory(memoryId: string): import("./history.js").HistoryEntry[];
+    private extractFacts;
+    private processFact;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/memory/store.js

@@ -0,0 +1,206 @@
+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;
+// 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
+export class MemoryStore {
+    embedding;
+    vectordb;
+    history;
+    initialized = false;
+    constructor(embedding, vectordb, history) {
+        this.embedding = embedding;
+        this.vectordb = vectordb;
+        this.history = history;
+    }
+    async ensureCollection() {
+        if (this.initialized)
+            return;
+        const exists = await this.vectordb.hasCollection(COLLECTION_NAME);
+        if (!exists) {
+            await this.vectordb.createCollection(COLLECTION_NAME, this.embedding.dimension);
+        }
+        this.initialized = true;
+    }
+    async addMemory(content, source) {
+        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);
+            if (action)
+                actions.push(action);
+        }
+        return actions;
+    }
+    async searchMemory(query, limit = 10, category) {
+        await this.ensureCollection();
+        const queryVector = await this.embedding.embed(query);
+        const results = await this.vectordb.search(COLLECTION_NAME, {
+            queryVector,
+            queryText: query,
+            limit,
+            ...(category ? { extensionFilter: [category] } : {}),
+        });
+        // Enrich with full payload from getById
+        const items = [];
+        for (const r of results) {
+            const id = r.relativePath; // memory UUID stored in relativePath
+            const point = await this.vectordb.getById(COLLECTION_NAME, id);
+            if (!point)
+                continue;
+            items.push(payloadToMemoryItem(id, point.payload));
+        }
+        return items;
+    }
+    async listMemories(category, limit = 50) {
+        await this.ensureCollection();
+        const queryVector = await this.embedding.embed('developer knowledge');
+        const results = await this.vectordb.search(COLLECTION_NAME, {
+            queryVector,
+            queryText: '',
+            limit,
+            ...(category ? { extensionFilter: [category] } : {}),
+        });
+        const items = [];
+        for (const r of results) {
+            const id = r.relativePath;
+            const point = await this.vectordb.getById(COLLECTION_NAME, id);
+            if (!point)
+                continue;
+            items.push(payloadToMemoryItem(id, point.payload));
+        }
+        return items;
+    }
+    async deleteMemory(id) {
+        await this.ensureCollection();
+        const existing = await this.vectordb.getById(COLLECTION_NAME, id);
+        if (!existing)
+            return false;
+        const memory = String(existing.payload.memory ?? existing.payload.content ?? '');
+        await this.vectordb.deleteByPath(COLLECTION_NAME, id);
+        this.history.log(id, 'DELETE', null, memory);
+        return true;
+    }
+    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 processFact(fact, source) {
+        const hash = hashMemory(fact.fact);
+        const vector = await this.embedding.embed(fact.fact);
+        const searchResults = await this.vectordb.search(COLLECTION_NAME, {
+            queryVector: vector,
+            queryText: fact.fact,
+            limit: SEARCH_CANDIDATES,
+        });
+        const candidates = [];
+        for (const result of searchResults) {
+            const id = result.relativePath;
+            if (!id)
+                continue;
+            const point = await this.vectordb.getById(COLLECTION_NAME, id);
+            if (!point)
+                continue;
+            candidates.push({
+                id,
+                memory: result.content,
+                hash: String(point.payload.hash ?? ''),
+                vector: point.vector,
+                score: result.score,
+            });
+        }
+        const decision = reconcile(hash, vector, candidates);
+        if (decision.action === 'NONE')
+            return null;
+        const now = new Date().toISOString();
+        if (decision.action === 'UPDATE' && decision.existingId) {
+            const existingPoint = await this.vectordb.getById(COLLECTION_NAME, decision.existingId);
+            const createdAt = String(existingPoint?.payload.created_at ?? now);
+            await this.vectordb.updatePoint(COLLECTION_NAME, decision.existingId, vector, {
+                content: fact.fact,
+                relativePath: decision.existingId,
+                fileExtension: fact.category,
+                language: source ?? '',
+                startLine: 0,
+                endLine: 0,
+                hash,
+                memory: fact.fact,
+                category: fact.category,
+                source: source ?? '',
+                created_at: createdAt,
+                updated_at: now,
+            });
+            this.history.log(decision.existingId, 'UPDATE', fact.fact, decision.existingMemory, source, now);
+            return {
+                event: 'UPDATE',
+                id: decision.existingId,
+                memory: fact.fact,
+                previous: decision.existingMemory,
+                category: fact.category,
+                source,
+            };
+        }
+        // ADD
+        const id = randomUUID();
+        await this.vectordb.updatePoint(COLLECTION_NAME, id, vector, {
+            content: fact.fact,
+            relativePath: id,
+            fileExtension: fact.category,
+            language: source ?? '',
+            startLine: 0,
+            endLine: 0,
+            hash,
+            memory: fact.fact,
+            category: fact.category,
+            source: source ?? '',
+            created_at: now,
+            updated_at: now,
+        });
+        this.history.log(id, 'ADD', fact.fact, null, source, now);
+        return {
+            event: 'ADD',
+            id,
+            memory: fact.fact,
+            category: fact.category,
+            source,
+        };
+    }
+}
+function payloadToMemoryItem(id, payload) {
+    return {
+        id,
+        memory: String(payload.memory ?? payload.content ?? ''),
+        hash: String(payload.hash ?? ''),
+        category: String(payload.category ?? payload.fileExtension ?? ''),
+        source: String(payload.source ?? payload.language ?? ''),
+        created_at: String(payload.created_at ?? ''),
+        updated_at: String(payload.updated_at ?? ''),
+    };
+}
+//# sourceMappingURL=store.js.map

package/dist/memory/types.d.ts

@@ -0,0 +1,28 @@
+export interface MemoryItem {
+    id: string;
+    memory: string;
+    hash: string;
+    category: string;
+    source: string;
+    created_at: string;
+    updated_at: string;
+}
+export type MemoryEvent = 'ADD' | 'UPDATE' | 'DELETE';
+export interface MemoryAction {
+    event: MemoryEvent;
+    id: string;
+    memory: string;
+    previous?: string;
+    category?: string;
+    source?: string;
+}
+export interface ReconcileResult {
+    action: 'ADD' | 'UPDATE' | 'NONE';
+    existingId?: string;
+    existingMemory?: string;
+}
+export interface ExtractedFact {
+    fact: string;
+    category: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/memory/types.js

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