squish-memory 1.0.2 → 1.2.0

package/dist/core/memory/memories.d.ts

@@ -1,4 +1,4 @@
-export type MemoryType = 'observation' | 'fact' | 'decision' | 'context' | 'preference';
+import { MemoryRecord, MemoryType } from '../lib/types.js';
 export interface RememberInput {
     content: string;
     type?: MemoryType;
@@ -6,6 +6,15 @@ export interface RememberInput {
     project?: string;
     metadata?: Record<string, unknown>;
     source?: string;
+    reasoning?: string;
+    memoryContext?: string;
+    examples?: string;
+    exceptions?: string;
+    tier?: 'hot' | 'cold';
+    namespaceId?: string;
+    sessionId?: string;
+    sessionStartTime?: string;
+    toolName?: string;
 }
 export interface SearchInput {
     query: string;
@@ -13,27 +22,22 @@ export interface SearchInput {
     tags?: string[];
     limit?: number;
     project?: string;
-}
-export interface MemoryRecord {
-    id: string;
-    projectId?: string | null;
-    type: MemoryType;
-    content: string;
-    summary?: string | null;
-    tags: string[];
-    metadata?: Record<string, unknown> | null;
-    createdAt?: string | null;
-    validFrom?: string | null;
-    validTo?: string | null;
-    recordedAt?: string | null;
-    similarity?: number;
-    importance?: number;
+    placeId?: string;
+    placeType?: string;
+    sessionId?: string;
+    sessionStartTime?: string;
 }
 export interface SearchResult extends MemoryRecord {
     similarity: number;
 }
 export declare function rememberMemory(input: RememberInput): Promise<MemoryRecord>;
-export declare function getMemoryById(id: string, incrementAccess?: boolean): Promise<MemoryRecord | null>;
-export declare function getRecentMemories(projectPath: string, limit: number): Promise<MemoryRecord[]>;
-export declare function searchMemories(input: SearchInput): Promise<SearchResult[]>;
+export declare function getMemory(id: string, incrementAccess?: boolean): Promise<MemoryRecord | null>;
+export declare function setConfidence(id: string, level: 'certain' | 'speculative' | 'outdated'): Promise<boolean>;
+export declare function getRecent(projectPath: string, limit: number): Promise<MemoryRecord[]>;
+export declare function search(input: SearchInput): Promise<SearchResult[]>;
+/**
+ * Find similar memories to prevent duplicates
+ * Returns memories with similarity >= threshold
+ */
+export declare function findSimilarMemories(content: string, threshold?: number, limit?: number): Promise<SearchResult[]>;
 //# sourceMappingURL=memories.d.ts.map

package/dist/core/memory/memories.js

@@ -1,28 +1,30 @@
 import { randomUUID } from 'crypto';
 import { eq } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
 import { config } from '../../config.js';
-import { ensureProject, getProjectByPath } from '../../core/projects.js';
+import { logger } from '../../core/logger.js';
+import { getOrCreateProject, requireProject } from '../../core/projects.js';
 import { getEmbedding } from '../../core/embeddings.js';
-import { fromSqliteJson, fromSqliteTags, normalizeTags, toSqliteJson, toSqliteTags } from '../../core/memory/serialization.js';
-import { createDatabaseClient } from '../../core/database.js';
-import { clampLimit, prepareEmbedding } from '../../core/utils.js';
+import { normalizeTags, serializeTags, deserializeTags, serializeMetadata, deserializeMetadata } from '../../core/memory/serialization.js';
+import { normalizeTimestamp, clampLimit, prepareEmbedding } from '../lib/utils.js';
+import { requireUuid } from '../lib/validation.js';
+import { cosineSimilarity } from '../utils/vector-operations.js';
 import { hybridSearch as hybridSearchImpl } from './hybrid-search.js';
 import { calculateImportance } from './importance.js';
 import { detectMemorySignals } from './trigger-detector.js';
 import { resolveContradictions, applySupersession } from './contradiction-resolver.js';
+import { encrypt, decrypt } from '../security/encrypt.js';
+import { estimateTokens } from '../context/context-window.js';
+import { getDbClient } from '../lib/db-client.js';
+import { extractBeliefsFromMemory } from '../beliefs/extractor.js';
+import { upsertBeliefsForMemory } from '../beliefs/store.js';
+import { extractEntityNames } from './entity-extractor.js';
+import { autoLinkByEntities } from '../associations.js';
+import { addMemoryToGraph } from '../graph/graph-builder.js';
+import { parseEmbedding } from '../lib/parse-embedding.js';
 export async function rememberMemory(input) {
-    let db;
-    try {
-        db = createDatabaseClient(await getDb());
-    }
-    catch (error) {
-        throw new Error(`Database unavailable: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const tags = normalizeTags(input.tags);
-    const project = await ensureProject(input.project);
+    const project = await getOrCreateProject(input.project);
     const embedding = await getEmbedding(input.content);
     const id = randomUUID();
     const signals = detectMemorySignals(input.content);
@@ -45,39 +47,131 @@ export async function rememberMemory(input) {
         isImmutable: false,
     });
     const embeddingValues = prepareEmbedding(embedding);
-    let tagsValue;
-    if (config.isTeamMode) {
-        tagsValue = tags.length ? tags : null;
-    }
-    else {
-        tagsValue = toSqliteTags(tags);
-    }
-    let metadataValue;
-    // Build enriched metadata with memory signals
+    const tokensEstimate = estimateTokens(input.content);
+    let tagsValue = serializeTags(tags);
     const enrichedMetadata = {
         ...(input.metadata ?? {}),
+        // Rich context fields (Agent 4 feedback)
+        reasoning: input.reasoning,
+        memoryContext: input.memoryContext,
+        examples: input.examples,
+        exceptions: input.exceptions,
         memorySignals: {
             explicitTriggers: signals.explicitTriggers,
             implicit: signals.implicit,
             priority: signals.priority,
             requiresConflictCheck: signals.implicit.correction,
         },
+        // Session metadata for temporal queries (Task 1)
+        sessionMetadata: {
+            sessionId: input.sessionId,
+            sessionStartTime: input.sessionStartTime,
+            toolName: input.toolName,
+        },
     };
-    if (config.isTeamMode) {
-        metadataValue = enrichedMetadata;
-    }
-    else {
-        metadataValue = toSqliteJson(enrichedMetadata);
-    }
-    await db.insert(schema.memories).values({
+    let metadataValue = serializeMetadata(enrichedMetadata);
+    // Prepare fields for insertion, handling optional encryption
+    let insertValues = {
         ...baseValues,
         tags: tagsValue,
         metadata: metadataValue,
         ...embeddingValues,
         importanceScore: importance.score,
         lastImportanceRecalc: new Date(),
+        tokensEstimate,
         createdAt: new Date(),
-    });
+        status: 'active',
+        tier: input.tier || 'hot', // Default to hot tier
+    };
+    // Add namespace if specified
+    if (input.namespaceId) {
+        insertValues.namespaceId = input.namespaceId;
+    }
+    // For cold tier, store original content in metadata
+    if (input.tier === 'cold') {
+        enrichedMetadata.originalContent = input.content;
+    }
+    if (config.clientEncryptionEnabled) {
+        const { ciphertext, nonce } = encrypt(input.content);
+        insertValues.encrypted_content = ciphertext;
+        insertValues.encryption_nonce = nonce;
+        insertValues.is_encrypted = true;
+        // Store empty placeholder for plain content
+        insertValues.content = '';
+    }
+    else {
+        insertValues.content = input.content;
+        insertValues.is_encrypted = false;
+    }
+    await db.insert(schema.memories).values(insertValues);
+    if (project?.id) {
+        try {
+            const beliefs = extractBeliefsFromMemory({
+                memoryId: id,
+                content: input.content,
+                type,
+                metadata: enrichedMetadata,
+            });
+            if (beliefs.length > 0) {
+                await upsertBeliefsForMemory({
+                    projectId: project.id,
+                    memoryId: id,
+                    beliefs,
+                });
+            }
+        }
+        catch (beliefError) {
+            logger.warn(`[Beliefs] Failed to derive beliefs for memory ${id}: ${beliefError}`);
+        }
+    }
+    // Auto-link by entity overlap (synchronous - Task 5)
+    // Now memories are immediately findable via associations after storage
+    const entityNames = extractEntityNames(input.content);
+    if (entityNames.length > 0 && project?.id) {
+        try {
+            const linked = await autoLinkByEntities(id, entityNames, project.id);
+            if (linked > 0)
+                logger.debug(`[AutoLink] Linked memory ${id} to ${linked} related memories`);
+        }
+        catch (err) {
+            logger.debug(`[AutoLink] Failed: ${err}`);
+        }
+    }
+    // Build graph for this memory (auto-build if enabled)
+    // This populates the entity_entities and entity_relations tables
+    if (config.graphAutoBuild && project?.id) {
+        try {
+            const graphResult = await addMemoryToGraph(id, {
+                preferLLM: config.llmEnabled,
+            });
+            if (graphResult.entitiesCreated > 0 || graphResult.relationsCreated > 0) {
+                logger.debug(`[Graph] Built graph for memory ${id}: ${graphResult.entitiesCreated} entities, ${graphResult.relationsCreated} relations`);
+            }
+        }
+        catch (graphError) {
+            logger.debug(`[Graph] Failed to build graph for memory ${id}: ${graphError}`);
+        }
+    }
+    // Append to Obsidian vault if enabled and hot tier (NEW)
+    if (config.obsidianEnabled && config.obsidianVaultPath && insertValues.tier === 'hot') {
+        try {
+            const { appendToObsidianVault } = await import('../integrations/obsidian-vault.js');
+            await appendToObsidianVault({
+                content: input.content,
+                id,
+                type,
+                tags,
+                reasoning: input.reasoning,
+                memoryContext: input.memoryContext,
+                examples: input.examples,
+                exceptions: input.exceptions,
+                source: input.source,
+            }, config.obsidianVaultPath);
+        }
+        catch (error) {
+            logger.warn(`[Obsidian] Failed to append to vault: ${error}`);
+        }
+    }
     // Resolve contradictions and supersede old memories (async, non-blocking)
     resolveContradictions(input.content, type, project?.id)
         .then(async (result) => {
@@ -92,12 +186,7 @@ export async function rememberMemory(input) {
                     reason: result.reason,
                 },
             };
-            if (config.isTeamMode) {
-                metadataValue = updatedMetadata;
-            }
-            else {
-                metadataValue = toSqliteJson(updatedMetadata);
-            }
+            metadataValue = serializeMetadata(updatedMetadata);
         }
     })
         .catch((error) => {
@@ -117,10 +206,11 @@ export async function rememberMemory(input) {
     };
     return memoryRecord;
 }
-export async function getMemoryById(id, incrementAccess = true) {
+export async function getMemory(id, incrementAccess = true) {
     try {
-        const db = createDatabaseClient(await getDb());
-        const schema = await getSchema();
+        // Validate UUID
+        requireUuid(id);
+        const { db, schema } = await getDbClient();
         const rows = await db.select().from(schema.memories).where(eq(schema.memories.id, id)).limit(1);
         const row = rows[0];
         if (!row)
@@ -134,25 +224,48 @@ export async function getMemoryById(id, incrementAccess = true) {
             })
                 .where(eq(schema.memories.id, id));
         }
-        return normalizeMemory(row);
+        let content = row.content;
+        if (row.is_encrypted) {
+            try {
+                content = decrypt(row.encrypted_content, row.encryption_nonce);
+            }
+            catch (e) {
+                console.warn('Failed to decrypt memory', e);
+                content = row.content; // fall back to stored content
+            }
+        }
+        const decryptedRow = { ...row, content };
+        return normalizeMemory(decryptedRow);
     }
     catch (error) {
         throw error;
     }
 }
-export async function getRecentMemories(projectPath, limit) {
+export async function setConfidence(id, level) {
     try {
-        const db = createDatabaseClient(await getDb());
+        // Validate UUID
+        requireUuid(id);
+        const { db, schema } = await getDbClient();
+        await db.update(schema.memories)
+            .set({ confidenceLevel: level, updatedAt: new Date() })
+            .where(eq(schema.memories.id, id));
+        return true;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+export async function getRecent(projectPath, limit) {
+    try {
+        const { db } = await getDbClient();
         const sqlite = db.$client;
-        const project = await getProjectByPath(projectPath);
-        if (!project)
-            return [];
+        const project = await requireProject(projectPath);
         // Use raw SQL to avoid drizzle column name issues
-        const rows = sqlite.prepare(`
-      SELECT * FROM memories 
-      WHERE project_id = ? 
-      ORDER BY created_at DESC 
-      LIMIT ?
+        const rows = sqlite.prepare(`
+      SELECT * FROM memories 
+      WHERE project_id = ? 
+      ORDER BY created_at DESC 
+      LIMIT ?
     `).all(project.id, limit);
         return rows.map((row) => normalizeMemory(row));
     }
@@ -160,80 +273,17 @@ export async function getRecentMemories(projectPath, limit) {
         throw error;
     }
 }
-export async function searchMemories(input) {
+export async function search(input) {
     const limit = clampLimit(input.limit, 10, 1, 100);
     const tags = normalizeTags(input.tags);
-    if (config.isTeamMode) {
-        return await searchMemoriesPostgres(input, tags, limit);
-    }
-    // Use hybrid search for SQLite (BM25 + vectors with RRF)
-    return await hybridSearchImpl(input, { limit });
-}
-/**
- * Calculate cosine similarity between two vectors
- */
-function cosineSimilarity(a, b) {
-    if (a.length !== b.length)
-        return 0;
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dotProduct += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    if (normA === 0 || normB === 0)
-        return 0;
-    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-}
-/**
- * Parse embedding from SQLite storage
- */
-function parseEmbedding(embeddingData) {
-    if (!embeddingData)
-        return null;
-    // If it's already an array
-    if (Array.isArray(embeddingData))
-        return embeddingData;
-    // If it's a Buffer/Uint8Array
-    if (embeddingData instanceof Uint8Array || Buffer.isBuffer(embeddingData)) {
-        // Try to parse as JSON first
-        try {
-            const json = JSON.parse(embeddingData.toString());
-            if (Array.isArray(json))
-                return json;
-        }
-        catch {
-            // Not JSON, try Float32Array
-            try {
-                const buffer = embeddingData.buffer;
-                const arrayBuffer = buffer instanceof ArrayBuffer
-                    ? buffer
-                    : buffer;
-                const floatArray = new Float32Array(arrayBuffer);
-                return Array.from(floatArray);
-            }
-            catch {
-                return null;
-            }
-        }
-    }
-    // If it's a string
-    if (typeof embeddingData === 'string') {
-        try {
-            const parsed = JSON.parse(embeddingData);
-            if (Array.isArray(parsed))
-                return parsed;
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
+    // Always use hybrid search for both SQLite and PostgreSQL
+    // Graph boost requires hybrid path for proper scoring
+    const dbResults = await hybridSearchImpl(input, { limit });
+    return dbResults.slice(0, limit);
 }
+// parseEmbedding imported from ../lib/parse-embedding.js
 async function searchMemoriesSqlite(input, tags, limit) {
-    const db = createDatabaseClient(await getDb());
+    const { db } = await getDbClient();
     const sqlite = db.$client;
     // Get embedding for the query (for semantic search)
     const queryEmbedding = await getEmbedding(input.query);
@@ -250,32 +300,30 @@ async function searchMemoriesSqlite(input, tags, limit) {
     }
     let projectId = null;
     if (input.project) {
-        const project = await getProjectByPath(input.project);
-        if (project) {
-            projectId = project.id;
-            conditions.push('m.project_id = ?');
-            params.push(project.id);
-        }
+        const project = await requireProject(input.project);
+        projectId = project.id;
+        conditions.push('m.project_id = ?');
+        params.push(project.id);
     }
     const whereClause = conditions.length > 0 ? 'WHERE ' + conditions.join(' AND ') : '';
     // Fetch memories with embeddings for semantic search
     const fetchLimit = Math.max(limit * 3, 50); // Fetch more for re-ranking
-    const statement = sqlite.prepare(`
-    SELECT
-      m.id as id,
-      m.project_id as projectId,
-      m.type as type,
-      m.content as content,
-      m.summary as summary,
-      m.tags as tags,
-      m.metadata as metadata,
-      m.embedding as embedding,
-      m.embedding_json as embeddingJson,
-      m.created_at as createdAt
-    FROM memories m
-    ${whereClause}
-    ORDER BY m.created_at DESC
-    LIMIT ?
+    const statement = sqlite.prepare(`
+    SELECT
+      m.id as id,
+      m.project_id as projectId,
+      m.type as type,
+      m.content as content,
+      m.summary as summary,
+      m.tags as tags,
+      m.metadata as metadata,
+      m.embedding as embedding,
+      m.embedding_json as embeddingJson,
+      m.created_at as createdAt
+    FROM memories m
+    ${whereClause}
+    ORDER BY m.created_at DESC
+    LIMIT ?
   `);
     const rows = statement.all(...params, fetchLimit);
     if (rows.length === 0)
@@ -306,7 +354,7 @@ async function searchMemoriesSqlite(input, tags, limit) {
     }));
 }
 async function searchMemoriesPostgres(input, tags, limit) {
-    const db = createDatabaseClient(await getDb());
+    const { db } = await getDbClient();
     const values = [];
     const whereParts = [];
     values.push(`%${input.query}%`);
@@ -320,51 +368,49 @@ async function searchMemoriesPostgres(input, tags, limit) {
         whereParts.push(`tags && $${values.length}::text[]`);
     }
     if (input.project) {
-        const project = await getProjectByPath(input.project);
-        if (project) {
-            values.push(project.id);
-            whereParts.push(`project_id = $${values.length}`);
-        }
+        const project = await requireProject(input.project);
+        values.push(project.id);
+        whereParts.push(`project_id = $${values.length}`);
     }
     const whereClause = whereParts.length ? `WHERE ${whereParts.join(' AND ')}` : '';
     const embedding = await getEmbedding(input.query);
     if (embedding) {
-        const rows = await db.$client.query(`SELECT
-       id,
-       project_id as "projectId",
-       type,
-       content,
-       summary,
-       tags,
-       metadata,
-       created_at as "createdAt",
-       valid_from as "validFrom",
-       valid_to as "validTo",
-       recorded_at as "recordedAt"
-     FROM memories
-     ${whereClause}
-     ORDER BY created_at DESC
+        const rows = await db.$client.query(`SELECT
+       id,
+       project_id as "projectId",
+       type,
+       content,
+       summary,
+       tags,
+       metadata,
+       created_at as "createdAt",
+       valid_from as "validFrom",
+       valid_to as "validTo",
+       recorded_at as "recordedAt"
+     FROM memories
+     ${whereClause}
+     ORDER BY created_at DESC
      LIMIT $${values.length + 1}`, [...values, limit]);
         return rows.rows.map((row) => ({
             ...normalizeMemory(row),
             similarity: row.similarity ?? 0,
         }));
     }
-    const rows = await db.$client.query(`SELECT
-       id,
-       project_id as "projectId",
-       type,
-       content,
-       summary,
-       tags,
-       metadata,
-       created_at as "createdAt",
-       valid_from as "validFrom",
-       valid_to as "validTo",
-       recorded_at as "recordedAt"
-     FROM memories
-     ${whereClause}
-     ORDER BY created_at DESC
+    const rows = await db.$client.query(`SELECT
+       id,
+       project_id as "projectId",
+       type,
+       content,
+       summary,
+       tags,
+       metadata,
+       created_at as "createdAt",
+       valid_from as "validFrom",
+       valid_to as "validTo",
+       recorded_at as "recordedAt"
+     FROM memories
+     ${whereClause}
+     ORDER BY created_at DESC
      LIMIT $${values.length + 1}`, [...values, limit]);
     return rows.rows.map((row) => ({
         ...normalizeMemory(row),
@@ -372,54 +418,9 @@ async function searchMemoriesPostgres(input, tags, limit) {
     }));
 }
 function normalizeMemory(row) {
-    let tags;
-    if (config.isTeamMode) {
-        tags = row.tags ?? [];
-    }
-    else {
-        tags = fromSqliteTags(row.tags ?? null);
-    }
-    let metadata;
-    if (config.isTeamMode) {
-        metadata = row.metadata;
-    }
-    else {
-        metadata = fromSqliteJson(row.metadata ?? null);
-    }
-    const createdAt = row.createdAt ?? row.created_at;
-    let createdAtStr = null;
-    if (createdAt !== undefined && createdAt !== null) {
-        try {
-            if (createdAt instanceof Date && !isNaN(createdAt.getTime())) {
-                createdAtStr = createdAt.toISOString();
-            }
-            else if (typeof createdAt === 'number') {
-                // Handle different timestamp formats
-                // Microseconds: > 100000000000000 (e.g., 170000000000000)
-                // Milliseconds: > 1000000000000 (e.g., 1700000000000)
-                // Seconds: <= 1000000000000 (e.g., 1700000000)
-                if (createdAt > 100000000000000) {
-                    createdAtStr = new Date(createdAt / 1000).toISOString();
-                }
-                else if (createdAt > 1000000000000) {
-                    createdAtStr = new Date(createdAt).toISOString();
-                }
-                else if (createdAt >= 0) {
-                    // Unix timestamp in seconds - convert to milliseconds
-                    createdAtStr = new Date(createdAt * 1000).toISOString();
-                }
-            }
-            else if (typeof createdAt === 'string' && createdAt.trim()) {
-                const parsed = new Date(createdAt);
-                if (!isNaN(parsed.getTime())) {
-                    createdAtStr = parsed.toISOString();
-                }
-            }
-        }
-        catch {
-            // Keep null on parse error
-        }
-    }
+    const tags = deserializeTags(row.tags ?? null);
+    const metadata = deserializeMetadata(row.metadata ?? null);
+    const createdAtStr = normalizeTimestamp(row.createdAt ?? row.created_at);
     return {
         id: row.id,
         projectId: row.projectId ?? row.project_id ?? null,
@@ -432,6 +433,20 @@ function normalizeMemory(row) {
         validFrom: row.validFrom ?? row.valid_from ?? null,
         validTo: row.validTo ?? row.valid_to ?? null,
         recordedAt: row.recordedAt ?? row.recorded_at ?? null,
+        confidenceLevel: row.confidenceLevel ?? row.confidence_level ?? null,
     };
 }
+/**
+ * Find similar memories to prevent duplicates
+ * Returns memories with similarity >= threshold
+ */
+export async function findSimilarMemories(content, threshold = 0.85, limit = 5) {
+    // Use search with high similarity
+    const results = await search({
+        query: content,
+        limit,
+    });
+    // Filter by similarity threshold
+    return results.filter(r => (r.similarity ?? 0) >= threshold);
+}
 //# sourceMappingURL=memories.js.map

package/dist/core/memory/memory-lifecycle.d.ts

@@ -0,0 +1,8 @@
+/** Promote a memory to a higher tier (cold -> hot only, simplified from warm hierarchy) */
+export declare function promoteTier(memoryId: string): Promise<void>;
+/** Demote a memory tier or expire it based on decay (simplified: hot -> cold only) */
+export declare function demoteTier(memoryId: string): Promise<void>;
+export declare function expireMemory(memoryId: string): Promise<void>;
+export declare function markMerged(memoryId: string, targetId: string): Promise<void>;
+export declare function markSuperseded(memoryId: string): Promise<void>;
+//# sourceMappingURL=memory-lifecycle.d.ts.map