squish-memory 1.1.5 → 1.2.1

package/core/memory/migrate.ts

@@ -0,0 +1,173 @@
+/**
+ * Memory Migration Module
+ * Migrate memories between .squish directories/databases
+ */
+
+import { randomUUID } from 'crypto';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getDbClient } from '../lib/db-client.js';
+
+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 async function migrateMemories(
+  sourceDir: string,
+  targetDir: string,
+  options: MigrateOptions = {}
+): Promise<MigrateResult> {
+  const { dryRun = false, deleteSource = false } = options;
+  
+  const sourceDbPath = join(sourceDir, 'squish.db');
+  const targetDbPath = join(targetDir, 'squish.db');
+  
+  if (!existsSync(sourceDbPath)) {
+    throw new Error(`Source database not found: ${sourceDbPath}`);
+  }
+  if (!existsSync(targetDbPath)) {
+    throw new Error(`Target database not found: ${targetDbPath}`);
+  }
+
+  // Use bun:sqlite for direct source DB access
+  // @ts-ignore - bun:sqlite module not found in types but works at runtime
+  const SqliteDatabase = (await import('bun:sqlite')).default;
+  const sourceDb = new SqliteDatabase(sourceDbPath, { readonly: true });
+  
+  // Get target DB through the app's existing mechanism
+  const { db: targetDb, schema } = await getDbClient();
+
+  // Get all projects from source
+  const sourceProjects = sourceDb.query('SELECT * FROM projects').all() as any[];
+  
+  // Map old project IDs to new project IDs
+  const projectIdMap = new Map<string, string>();
+  
+  for (const project of sourceProjects) {
+    // Check if project with same path exists in target
+    const existing = await targetDb.select()
+      .from(schema.projects)
+      .where((tbl: any, { eq }: any) => eq(tbl.path, project.path))
+      .limit(1);
+    
+    if (existing.length > 0) {
+      projectIdMap.set(project.id, existing[0].id);
+    } else {
+      // Create new project in target
+      const newId = randomUUID();
+      await targetDb.insert(schema.projects).values({
+        id: newId,
+        path: project.path,
+        name: project.name || 'migrated',
+        createdAt: new Date(),
+      });
+      projectIdMap.set(project.id, newId);
+    }
+  }
+
+  // Migrate memories
+  const sourceMemories = sourceDb.query('SELECT * FROM memories').all() as any[];
+  let memoriesCopied = 0;
+  
+  for (const mem of sourceMemories) {
+    const oldProjectId = mem.project_id;
+    const newProjectId = projectIdMap.get(oldProjectId);
+    
+    if (!newProjectId) {
+      console.warn(`Skipping memory ${mem.id}: no project mapping found`);
+      continue;
+    }
+    
+    if (!dryRun) {
+      // Add 'imported' tag to track migrated memories
+      const existingTags = mem.tags ? JSON.parse(mem.tags) : [];
+      const newTags = [...existingTags, 'imported'];
+      
+      await targetDb.insert(schema.memories).values({
+        id: randomUUID(),
+        projectId: newProjectId,
+        type: mem.type,
+        content: mem.content,
+        summary: mem.summary,
+        source: mem.source || 'migrated',
+        confidence: mem.confidence ?? 50,
+        confidenceLevel: mem.confidence_level || 'speculative',
+        tags: newTags,
+        metadata: { ...mem.metadata, migratedAt: new Date().toISOString(), originalId: mem.id },
+        isActive: mem.is_active ?? 1,
+        createdAt: mem.created_at ? new Date(mem.created_at * 1000) : new Date(),
+        updatedAt: new Date(),
+      });
+    }
+    memoriesCopied++;
+  }
+
+  // Migrate learnings (renamed from observations)
+  const sourceLearnings = sourceDb.query('SELECT * FROM learnings').all() as any[];
+  let learningsCopied = 0;
+  
+  for (const learn of sourceLearnings) {
+    const oldProjectId = learn.project_id;
+    const newProjectId = projectIdMap.get(oldProjectId);
+    
+    if (!newProjectId) continue;
+    
+    if (!dryRun) {
+      // Add is_imported flag to track migrated learnings
+      await targetDb.insert(schema.learnings).values({
+        id: randomUUID(),
+        projectId: newProjectId,
+        type: learn.type,
+        action: learn.action,
+        summary: learn.summary,
+        target: learn.target,
+        details: learn.details,
+        isImported: true,
+        createdAt: new Date(),
+      });
+    }
+    learningsCopied++;
+  }
+
+  // Migrate memory associations (simplified - skip for now)
+  const sourceAssoc = sourceDb.query('SELECT * FROM memory_associations').all() as any[];
+  let associationsCopied = 0;
+  
+  if (!dryRun && sourceAssoc.length > 0) {
+    console.warn(`Note: ${sourceAssoc.length} associations not migrated (requires ID mapping)`);
+  }
+
+  // Close source DB
+  sourceDb.close();
+
+  // Delete source if requested
+  let sourceDeleted = false;
+  if (!dryRun && deleteSource && memoriesCopied > 0) {
+    // Implementation would delete the file
+    console.warn('Source deletion not implemented - requires manual removal');
+  }
+
+  return {
+    memoriesCopied,
+    observationsCopied: learningsCopied,
+    associationsCopied,
+    projectsMapped: projectIdMap.size,
+    sourceDeleted,
+    message: dryRun 
+      ? 'Dry run complete - no changes made'
+      : `Successfully migrated ${memoriesCopied} memories, ${learningsCopied} learnings`
+  };
+}

package/core/memory/normalization.ts

@@ -0,0 +1,30 @@
+/**
+ * Memory normalization utilities
+ * Shared between memories.ts and loader.ts to avoid circular dependencies
+ */
+
+import { deserializeTags, deserializeMetadata } from './serialization.js';
+import { normalizeTimestamp } from '../lib/utils.js';
+import type { MemoryRecord } from '../lib/types.js';
+
+export function normalizeMemory(row: any): MemoryRecord {
+  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,
+    type: row.type,
+    content: row.content,
+    summary: row.summary ?? null,
+    tags,
+    metadata,
+    createdAt: createdAtStr,
+    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,
+  };
+}

package/core/memory/path-strengthener.ts

@@ -0,0 +1,211 @@
+/**
+ * Path Strengthener
+ * 
+ * Strengthens association paths that led to successful retrievals and
+ * weakens paths that led to irrelevant results. This implements the
+ * "optimize" concept: the graph develops its own sense of relevance
+ * over time based on actual usage patterns.
+ * 
+ * A customer support agent's graph naturally strengthens paths through
+ * product docs and refund policies while letting rarely-queried HR
+ * edges decay.
+ */
+
+import { eq, and, or, sql, desc } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+
+export interface PathStrengthResult {
+  strengthened: number;
+  weakened: number;
+  pruned: number;
+}
+
+/**
+ * Strengthen the association path between memories that were
+ * retrieved together and found useful.
+ */
+export async function strengthenPath(
+  memoryIds: string[],
+  boostAmount: number = 2
+): Promise<number> {
+  if (memoryIds.length < 2) return 0;
+
+  const db = await getDb();
+  const schema = await getSchema();
+  let strengthened = 0;
+
+  // Generate all pairs
+  for (let i = 0; i < memoryIds.length; i++) {
+    for (let j = i + 1; j < memoryIds.length; j++) {
+      try {
+        // Check if association exists
+        const existing = await (db as any)
+          .select()
+          .from(schema.memoryAssociations)
+          .where(
+            or(
+              and(
+                eq(schema.memoryAssociations.fromMemoryId, memoryIds[i]),
+                eq(schema.memoryAssociations.toMemoryId, memoryIds[j])
+              ),
+              and(
+                eq(schema.memoryAssociations.fromMemoryId, memoryIds[j]),
+                eq(schema.memoryAssociations.toMemoryId, memoryIds[i])
+              )
+            )
+          )
+          .limit(1);
+
+        if (existing.length > 0) {
+          // Strengthen existing association
+          await (db as any)
+            .update(schema.memoryAssociations)
+            .set({
+              weight: sql`${schema.memoryAssociations.weight} + ${boostAmount}`,
+              coactivationCount: sql`${schema.memoryAssociations.coactivationCount} + 1`,
+              lastCoactivatedAt: new Date(),
+            })
+            .where(eq(schema.memoryAssociations.id, existing[0].id));
+        } else {
+          // Create new association
+          await (db as any).insert(schema.memoryAssociations).values({
+            fromMemoryId: memoryIds[i],
+            toMemoryId: memoryIds[j],
+            associationType: 'co_occurred',
+            weight: boostAmount,
+            coactivationCount: 1,
+            lastCoactivatedAt: new Date(),
+          });
+        }
+
+        strengthened++;
+      } catch (error) {
+        logger.debug('Error strengthening path', {
+          from: memoryIds[i],
+          to: memoryIds[j],
+          error: error as Error,
+        });
+      }
+    }
+  }
+
+  return strengthened;
+}
+
+/**
+ * Weaken association paths that led to irrelevant results.
+ */
+export async function weakenPath(
+  memoryIds: string[],
+  decayAmount: number = 0.5
+): Promise<number> {
+  if (memoryIds.length < 2) return 0;
+
+  const db = await getDb();
+  const schema = await getSchema();
+  let weakened = 0;
+
+  for (let i = 0; i < memoryIds.length; i++) {
+    for (let j = i + 1; j < memoryIds.length; j++) {
+      try {
+        const existing = await (db as any)
+          .select()
+          .from(schema.memoryAssociations)
+          .where(
+            or(
+              and(
+                eq(schema.memoryAssociations.fromMemoryId, memoryIds[i]),
+                eq(schema.memoryAssociations.toMemoryId, memoryIds[j])
+              ),
+              and(
+                eq(schema.memoryAssociations.fromMemoryId, memoryIds[j]),
+                eq(schema.memoryAssociations.toMemoryId, memoryIds[i])
+              )
+            )
+          )
+          .limit(1);
+
+        if (existing.length > 0) {
+          // Weaken but don't remove (minimum weight of 1)
+          await (db as any)
+            .update(schema.memoryAssociations)
+            .set({
+              weight: sql`GREATEST(${schema.memoryAssociations.weight} - ${decayAmount}, 1)`,
+            })
+            .where(eq(schema.memoryAssociations.id, existing[0].id));
+          weakened++;
+        }
+      } catch (error) {
+        logger.debug('Error weakening path', {
+          from: memoryIds[i],
+          to: memoryIds[j],
+          error: error as Error,
+        });
+      }
+    }
+  }
+
+  return weakened;
+}
+
+/**
+ * Prune associations that have decayed below a threshold.
+ */
+export async function pruneWeakAssociations(
+  minWeight: number = 2,
+  maxAge: number = 90 // days
+): Promise<number> {
+  const db = await getDb();
+  const schema = await getSchema();
+
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - maxAge);
+
+  try {
+    // Delete associations that are weak AND old
+    const result = await (db as any)
+      .delete(schema.memoryAssociations)
+      .where(
+        and(
+          sql`${schema.memoryAssociations.weight} < ${minWeight}`,
+          sql`${schema.memoryAssociations.lastCoactivatedAt} < ${cutoffDate}`
+        )
+      );
+
+    const pruned = result?.rowCount ?? 0;
+    logger.info('Pruned weak associations', { pruned, minWeight, maxAge });
+    return pruned;
+  } catch (error) {
+    logger.error('Error pruning weak associations', { error: error as Error });
+    return 0;
+  }
+}
+
+/**
+ * Run a full optimize cycle: strengthen useful paths, weaken unused ones,
+ * prune dead associations, and derive implicit facts.
+ */
+export async function runPruneCycle(
+  options?: {
+    minWeight?: number;
+    maxAge?: number;
+  }
+): Promise<PathStrengthResult> {
+  const { minWeight = 2, maxAge = 90 } = options || {};
+
+  logger.info('Starting prune cycle', { minWeight, maxAge });
+
+  // Step 1: Prune weak associations
+  const pruned = await pruneWeakAssociations(minWeight, maxAge);
+
+  logger.info('Prune cycle completed', { pruned });
+
+  return {
+    strengthened: 0, // Strengthening happens via retrieval feedback
+    weakened: 0,     // Weakening happens via retrieval feedback
+    pruned,
+  };
+}
+