squish-memory 1.0.1 → 1.1.5

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

@@ -1,4 +1,4 @@
-export type MemoryType = 'observation' | 'fact' | 'decision' | 'context' | 'preference';
+export type MemoryType = 'observation' | 'fact' | 'decision' | 'context' | 'preference' | 'note';
 export interface RememberInput {
     content: string;
     type?: MemoryType;
@@ -6,6 +6,12 @@ export interface RememberInput {
     project?: string;
     metadata?: Record<string, unknown>;
     source?: string;
+    reasoning?: string;
+    memoryContext?: string;
+    examples?: string;
+    exceptions?: string;
+    tier?: 'hot' | 'cold';
+    namespaceId?: string;
 }
 export interface SearchInput {
     query: string;
@@ -28,12 +34,14 @@ export interface MemoryRecord {
     recordedAt?: string | null;
     similarity?: number;
     importance?: number;
+    confidenceLevel?: 'certain' | 'speculative' | 'outdated' | null;
 }
 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[]>;
 //# sourceMappingURL=memories.d.ts.map

package/dist/core/memory/memories.js

@@ -1,28 +1,24 @@
 import { randomUUID } from 'crypto';
-import { desc, eq } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
+import { eq } from 'drizzle-orm';
 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';
 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,17 +41,15 @@ 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,
@@ -63,21 +57,81 @@ export async function rememberMemory(input) {
             requiresConflictCheck: signals.implicit.correction,
         },
     };
-    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);
+    // Append to Obsidian vault if enabled and hot tier (NEW)
+    if (config.obsidianEnabled && config.obsidianVaultPath && insertValues.tier === 'hot') {
+        try {
+            const { appendToObsidianVault } = await import('../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}`);
+        }
+    }
+    // Write to external folder memory if enabled and hot tier
+    if (config.externalMemoryEnabled && config.externalMemoryPath && insertValues.tier === 'hot') {
+        try {
+            const { getExternalMemory } = await import('../external-folder/index.js');
+            const externalMemory = getExternalMemory();
+            const memoryRecord = {
+                id,
+                projectId: project?.id ?? null,
+                type,
+                content: input.content,
+                tags,
+                createdAt: insertValues.createdAt?.toISOString(),
+                confidenceLevel: null,
+            };
+            await externalMemory.writeMemory(externalMemory.toMarkdownFormat(memoryRecord));
+        }
+        catch (error) {
+            logger.warn(`[ExternalMemory] Failed to write: ${error}`);
+        }
+    }
     // Resolve contradictions and supersede old memories (async, non-blocking)
     resolveContradictions(input.content, type, project?.id)
         .then(async (result) => {
@@ -92,12 +146,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 +166,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,55 +184,68 @@ 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 setConfidence(id, level) {
+    try {
+        // 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 getRecentMemories(projectPath, limit) {
+export async function getRecent(projectPath, limit) {
     try {
-        const db = createDatabaseClient(await getDb());
-        const schema = await getSchema();
-        const project = await getProjectByPath(projectPath);
-        if (!project)
-            return [];
-        const rows = await db.select().from(schema.memories)
-            .where(eq(schema.memories.projectId, project.id))
-            .orderBy(desc(schema.memories.createdAt))
-            .limit(limit);
+        const { db } = await getDbClient();
+        const sqlite = db.$client;
+        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 ?
+    `).all(project.id, limit);
         return rows.map((row) => normalizeMemory(row));
     }
     catch (error) {
         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);
+    // Get results from database (hybrid search: BM25 + vectors with RRF)
+    let dbResults;
     if (config.isTeamMode) {
-        return await searchMemoriesPostgres(input, tags, limit);
+        dbResults = 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];
+    else {
+        // Use hybrid search for SQLite (BM25 + vectors with RRF)
+        dbResults = await hybridSearchImpl(input, { limit });
     }
-    if (normA === 0 || normB === 0)
-        return 0;
-    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    return dbResults.slice(0, limit);
 }
 /**
  * Parse embedding from SQLite storage
@@ -230,7 +293,7 @@ function parseEmbedding(embeddingData) {
     return null;
 }
 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);
@@ -247,32 +310,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)
@@ -303,7 +364,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}%`);
@@ -317,51 +378,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),
@@ -369,54 +428,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,
@@ -429,6 +443,7 @@ 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,
     };
 }
 //# sourceMappingURL=memories.js.map

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

@@ -0,0 +1,8 @@
+/** Promote a memory to a higher tier (hot -> warm -> cold) */
+export declare function promoteTier(memoryId: string): Promise<void>;
+/** Demote a memory tier or expire it based on decay */
+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

package/dist/core/memory/memory-lifecycle.js

@@ -0,0 +1,55 @@
+import { getDb } from '../../db/index.js';
+import { memories } from '../../db/drizzle/schema.js';
+import { eq } from 'drizzle-orm';
+import { logger } from '../logger.js';
+/** Promote a memory to a higher tier (hot -> warm -> cold) */
+export async function promoteTier(memoryId) {
+    const db = await getDb();
+    // @ts-ignore - drizzle overloads
+    const row = await db.select().from(memories).where(eq(memories.id, memoryId)).limit(1);
+    const mem = row[0];
+    if (!mem)
+        return;
+    let newTier = mem.tier;
+    if (mem.tier === 'warm')
+        newTier = 'hot';
+    else if (mem.tier === 'cold')
+        newTier = 'warm';
+    // @ts-ignore
+    await db.update(memories).set({ tier: newTier }).where(eq(memories.id, memoryId));
+}
+/** Demote a memory tier or expire it based on decay */
+export async function demoteTier(memoryId) {
+    const db = await getDb();
+    // @ts-ignore
+    const row = await db.select().from(memories).where(eq(memories.id, memoryId)).limit(1);
+    const mem = row[0];
+    if (!mem)
+        return;
+    let updates = {};
+    if (mem.tier === 'hot')
+        updates.tier = 'warm';
+    else if (mem.tier === 'warm')
+        updates.tier = 'cold';
+    else
+        updates.status = 'expired';
+    // @ts-ignore
+    await db.update(memories).set(updates).where(eq(memories.id, memoryId));
+}
+export async function expireMemory(memoryId) {
+    const db = await getDb();
+    // @ts-ignore
+    await db.update(memories).set({ status: 'expired' }).where(eq(memories.id, memoryId));
+}
+export async function markMerged(memoryId, targetId) {
+    const db = await getDb();
+    // @ts-ignore
+    await db.update(memories).set({ is_merged: true, merged_into_id: targetId }).where(eq(memories.id, memoryId));
+}
+export async function markSuperseded(memoryId) {
+    const db = await getDb();
+    // @ts-ignore
+    await db.update(memories).set({ is_merged: true }).where(eq(memories.id, memoryId));
+}
+logger.info('Memory lifecycle helpers loaded');
+//# sourceMappingURL=memory-lifecycle.js.map

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

@@ -0,0 +1,21 @@
+/**
+ * Memory Migration Module
+ * Migrate memories between .squish directories/databases
+ */
+export interface MigrateOptions {
+    dryRun?: boolean;
+    deleteSource?: boolean;
+}
+export interface MigrateResult {
+    memoriesCopied: number;
+    observationsCopied: number;
+    associationsCopied: number;
+    projectsMapped: number;
+    sourceDeleted?: boolean;
+    message: string;
+}
+/**
+ * Migrate memories from one .squish directory to another
+ */
+export declare function migrateMemories(sourceDir: string, targetDir: string, options?: MigrateOptions): Promise<MigrateResult>;
+//# sourceMappingURL=migrate.d.ts.map