squish-memory 1.1.5 → 1.2.0

package/core/session/working-set.ts

@@ -0,0 +1,275 @@
+import { randomUUID } from 'crypto';
+import { eq } from 'drizzle-orm';
+import { getDbClient } from '../lib/db-client.js';
+import { ensureProject, getProjectByPath } from '../projects.js';
+import { deserializeMetadata, serializeMetadata } from '../memory/serialization.js';
+
+export interface WorkingSetCommand {
+  command: string;
+  outcome?: string;
+  at: string;
+}
+
+export interface SessionWorkingSet {
+  activeFiles: string[];
+  activePlaces: string[];
+  graphEntities: string[];
+  recentCommands: WorkingSetCommand[];
+  currentHypotheses: string[];
+  recentFailures: string[];
+  recentAttempts: string[];
+  projectPath?: string;
+  sessionId: string;
+  signalStats: {
+    captured: number;
+    suppressed: number;
+    sessionOnly: number;
+    durable: number;
+    durableWithRaw: number;
+    tokensSaved: number;
+    placeRouted: number;
+    graphEnriched: number;
+  };
+  recentEvents: Array<{
+    classification: string;
+    content: string;
+    target?: string;
+    hash?: string;
+    at: string;
+  }>;
+}
+
+const EMPTY_WORKING_SET = (sessionId: string, projectPath?: string): SessionWorkingSet => ({
+  activeFiles: [],
+  activePlaces: [],
+  graphEntities: [],
+  recentCommands: [],
+  currentHypotheses: [],
+  recentFailures: [],
+  recentAttempts: [],
+  projectPath,
+  sessionId,
+  signalStats: {
+    captured: 0,
+    suppressed: 0,
+    sessionOnly: 0,
+    durable: 0,
+    durableWithRaw: 0,
+    tokensSaved: 0,
+    placeRouted: 0,
+    graphEnriched: 0,
+  },
+  recentEvents: [],
+});
+
+function dedupe(items: string[], limit: number): string[] {
+  return [...new Set(items.filter(Boolean))].slice(0, limit);
+}
+
+function normalizeSessionMetadata(metadata: unknown, sessionId: string, projectPath?: string): SessionWorkingSet {
+  const parsed = (metadata ?? {}) as Partial<SessionWorkingSet>;
+  return {
+    ...EMPTY_WORKING_SET(sessionId, projectPath),
+    ...parsed,
+    activeFiles: parsed.activeFiles ?? [],
+    activePlaces: parsed.activePlaces ?? [],
+    graphEntities: parsed.graphEntities ?? [],
+    recentCommands: parsed.recentCommands ?? [],
+    currentHypotheses: parsed.currentHypotheses ?? [],
+    recentFailures: parsed.recentFailures ?? [],
+    recentAttempts: parsed.recentAttempts ?? [],
+    recentEvents: parsed.recentEvents ?? [],
+    signalStats: {
+      ...EMPTY_WORKING_SET(sessionId, projectPath).signalStats,
+      ...(parsed.signalStats ?? {}),
+    },
+  };
+}
+
+async function getOrCreateContextSession(sessionId: string, projectPath: string) {
+  const { db, schema, raw } = await getDbClient();
+  const project = await ensureProject(projectPath);
+
+  const existing = await db
+    .select()
+    .from(schema.contextSessions)
+    .where(eq(schema.contextSessions.sessionId, sessionId))
+    .limit(1);
+
+  if (existing[0]) return { row: existing[0], projectId: project?.id ?? null, db, schema };
+
+  const sqlite = (raw as any).$client;
+  const id = randomUUID();
+  const metadata = serializeMetadata(EMPTY_WORKING_SET(sessionId, projectPath));
+  sqlite.prepare(`
+    INSERT INTO context_sessions (
+      id, session_id, project_id, metadata, token_budget, tokens_used, core_memory_tokens, loaded_memories_tokens, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, 8000, 0, 0, 0, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(id, sessionId, project?.id ?? null, metadata);
+
+  const inserted = await db
+    .select()
+    .from(schema.contextSessions)
+    .where(eq(schema.contextSessions.sessionId, sessionId))
+    .limit(1);
+
+  return { row: inserted[0], projectId: project?.id ?? null, db, schema };
+}
+
+export async function getSessionWorkingSet(sessionId: string, projectPath?: string): Promise<SessionWorkingSet> {
+  const { db, schema } = await getDbClient();
+  const rows = await db
+    .select()
+    .from(schema.contextSessions)
+    .where(eq(schema.contextSessions.sessionId, sessionId))
+    .limit(1);
+
+  if (!rows[0]) return EMPTY_WORKING_SET(sessionId, projectPath);
+  return normalizeSessionMetadata(deserializeMetadata(rows[0].metadata ?? null), sessionId, projectPath);
+}
+
+export async function recordSessionSignal(input: {
+  sessionId: string;
+  projectPath: string;
+  classification: 'discard' | 'session-only' | 'durable-distilled' | 'durable-raw+distilled';
+  distilledContent: string;
+  toolName: string;
+  target?: string;
+  metadata?: Record<string, unknown>;
+}): Promise<SessionWorkingSet> {
+  const { row, db, schema } = await getOrCreateContextSession(input.sessionId, input.projectPath);
+  const current = normalizeSessionMetadata(deserializeMetadata(row.metadata ?? null), input.sessionId, input.projectPath);
+  const meta = input.metadata ?? {};
+  const now = new Date().toISOString();
+
+  const next = normalizeSessionMetadata(current, input.sessionId, input.projectPath);
+  next.activeFiles = dedupe([
+    ...next.activeFiles,
+    ...(((meta.activeFiles as string[]) ?? [])),
+  ], 8);
+  next.activePlaces = dedupe([
+    ...next.activePlaces,
+    ...(((meta.activePlaces as string[]) ?? [])),
+  ], 6);
+  next.graphEntities = dedupe([
+    ...next.graphEntities,
+    ...(((meta.graphEntities as string[]) ?? [])),
+  ], 8);
+
+  const command = typeof meta.command === 'string' ? meta.command : undefined;
+  if (command) {
+    next.recentCommands = [{ command, outcome: typeof meta.outcome === 'string' ? meta.outcome : undefined, at: now }, ...next.recentCommands].slice(0, 8);
+  }
+
+  if (/hypothesis/i.test(input.distilledContent)) {
+    next.currentHypotheses = dedupe([input.distilledContent, ...next.currentHypotheses], 5);
+  }
+
+  if ((typeof meta.outcome === 'string' && meta.outcome === 'failure') || /fail|error|exception/i.test(input.distilledContent)) {
+    next.recentFailures = dedupe([input.target ?? input.distilledContent, ...next.recentFailures], 5);
+  }
+
+  next.recentAttempts = dedupe([input.distilledContent, ...next.recentAttempts], 8);
+  next.recentEvents = [
+    {
+      classification: input.classification,
+      content: input.distilledContent,
+      target: input.target,
+      hash: typeof meta.contentHash === 'string' ? meta.contentHash : undefined,
+      at: now,
+    },
+    ...next.recentEvents,
+  ].slice(0, 20);
+
+  if (input.classification === 'discard') next.signalStats.suppressed += 1;
+  else next.signalStats.captured += 1;
+  if (input.classification === 'session-only') next.signalStats.sessionOnly += 1;
+  if (input.classification === 'durable-distilled') next.signalStats.durable += 1;
+  if (input.classification === 'durable-raw+distilled') next.signalStats.durableWithRaw += 1;
+  next.signalStats.tokensSaved += Number(meta.tokensSaved ?? 0);
+  next.signalStats.placeRouted += meta.placeRouted ? 1 : 0;
+  next.signalStats.graphEnriched += meta.graphEnriched ? 1 : 0;
+
+  await db
+    .update(schema.contextSessions)
+    .set({
+      metadata: serializeMetadata(next),
+      updatedAt: new Date(),
+    })
+    .where(eq(schema.contextSessions.sessionId, input.sessionId));
+
+  return next;
+}
+
+export async function compactSessionWorkingSet(sessionId: string, projectPath?: string): Promise<{ summary: string; workingSet: SessionWorkingSet }> {
+  const workingSet = await getSessionWorkingSet(sessionId, projectPath);
+  const lines: string[] = [];
+
+  if (workingSet.currentHypotheses.length > 0) {
+    lines.push(`Hypotheses: ${dedupe(workingSet.currentHypotheses, 3).join(' | ')}`);
+  }
+  if (workingSet.recentFailures.length > 0) {
+    lines.push(`Failures: ${dedupe(workingSet.recentFailures, 3).join(' | ')}`);
+  }
+  if (workingSet.activeFiles.length > 0) {
+    lines.push(`Active files: ${dedupe(workingSet.activeFiles, 5).join(', ')}`);
+  }
+  if (workingSet.activePlaces.length > 0) {
+    lines.push(`Active places: ${dedupe(workingSet.activePlaces, 4).join(', ')}`);
+  }
+  if (workingSet.graphEntities.length > 0) {
+    lines.push(`Graph entities: ${dedupe(workingSet.graphEntities, 4).join(', ')}`);
+  }
+  if (workingSet.recentCommands.length > 0) {
+    lines.push(`Recent commands: ${dedupe(workingSet.recentCommands.map((entry) => entry.command), 3).join(' | ')}`);
+  }
+
+  return {
+    summary: lines.join('\n'),
+    workingSet,
+  };
+}
+
+export async function getProjectSignalStats(projectPath: string) {
+  const { db, schema } = await getDbClient();
+  const project = await getProjectByPath(projectPath);
+  if (!project) {
+    return EMPTY_WORKING_SET('project-stats', projectPath).signalStats;
+  }
+
+  const rows = await db
+    .select()
+    .from(schema.contextSessions)
+    .where(eq(schema.contextSessions.projectId, project.id));
+
+  return rows.reduce((acc, row) => {
+    const workingSet = normalizeSessionMetadata(deserializeMetadata(row.metadata ?? null), row.sessionId, projectPath);
+    acc.captured += workingSet.signalStats.captured;
+    acc.suppressed += workingSet.signalStats.suppressed;
+    acc.sessionOnly += workingSet.signalStats.sessionOnly;
+    acc.durable += workingSet.signalStats.durable;
+    acc.durableWithRaw += workingSet.signalStats.durableWithRaw;
+    acc.tokensSaved += workingSet.signalStats.tokensSaved;
+    return acc;
+  }, { ...EMPTY_WORKING_SET('project-stats', projectPath).signalStats });
+}
+
+export async function getLatestProjectWorkingSetSummary(projectPath: string): Promise<string> {
+  const { db, schema } = await getDbClient();
+  const project = await getProjectByPath(projectPath);
+  if (!project) return '';
+
+  const rows = await db
+    .select()
+    .from(schema.contextSessions)
+    .where(eq(schema.contextSessions.projectId, project.id));
+
+  const latest = rows.sort((a, b) => {
+    const left = new Date(a.updatedAt ?? a.createdAt ?? 0).getTime();
+    const right = new Date(b.updatedAt ?? b.createdAt ?? 0).getTime();
+    return right - left;
+  })[0];
+
+  if (!latest) return '';
+  return compactSessionWorkingSet(latest.sessionId, projectPath).then((result) => result.summary);
+}

package/core/snapshots/cleanup.ts

@@ -0,0 +1,13 @@
+/**
+ * Snapshot Cleanup Operations
+ * Maintenance and cleanup for snapshot data
+ */
+
+import { cleanupOldMemorySnapshots } from '../utils/cleanup-operations.js';
+
+/**
+ * Delete old snapshots
+ */
+export async function deleteOldSnapshots(olderThanDays: number = 90): Promise<number> {
+  return cleanupOldMemorySnapshots(olderThanDays);
+}

package/core/snapshots/comparison.ts

@@ -0,0 +1,59 @@
+/**
+ * Snapshot Comparison Operations
+ * Functions for comparing and diffing snapshots
+ */
+
+import { getMemorySnapshot } from './retrieval.js';
+import { logger } from '../logger.js';
+
+export interface MemoryDiff {
+  added?: string[];
+  removed?: string[];
+  changed?: Record<string, { from: unknown; to: unknown }>;
+}
+
+export function calculateDiff(before: string, after: string): MemoryDiff {
+  const beforeLines = before === '' ? [] : before.split('\n');
+  const afterLines = after === '' ? [] : after.split('\n');
+
+  const beforeSet = new Set(beforeLines);
+  const afterSet = new Set(afterLines);
+
+  const added = afterLines.filter(line => !beforeSet.has(line));
+  const removed = beforeLines.filter(line => !afterSet.has(line));
+
+  if (added.length === 0 && removed.length === 0 && before !== after) {
+    return {
+      added: afterLines.length > 0 ? afterLines : undefined,
+      removed: beforeLines.length > 0 ? beforeLines : undefined,
+    };
+  }
+
+  return {
+    added: added.length > 0 ? added : undefined,
+    removed: removed.length > 0 ? removed : undefined,
+  };
+}
+
+export async function compareSnapshots(
+  snapshotId1: string,
+  snapshotId2: string
+): Promise<{ diff: MemoryDiff; contextBefore: string; contextAfter: string }> {
+  try {
+    const snap1 = await getMemorySnapshot(snapshotId1);
+    const snap2 = await getMemorySnapshot(snapshotId2);
+
+    if (!snap1 || !snap2) {
+      throw new Error('One or both snapshots not found');
+    }
+
+    return {
+      diff: calculateDiff(snap1.content, snap2.content),
+      contextBefore: snap1.content.substring(0, 200),
+      contextAfter: snap2.content.substring(0, 200),
+    };
+  } catch (error) {
+    logger.error('Error comparing snapshots', error);
+    throw error;
+  }
+}

package/core/snapshots/creation.ts

@@ -0,0 +1,139 @@
+/**
+ * Snapshot Creation Operations
+ * Functions for creating different types of memory snapshots
+ */
+
+import { eq } from 'drizzle-orm';
+import { randomUUID } from 'crypto';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+import { MemoryDiff, calculateDiff } from './comparison.js';
+
+// Re-export for convenience
+export { MemoryDiff, calculateDiff };
+
+export async function createBeforeSnapshot(memoryId: string): Promise<string> {
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    const memory = await (db as any)
+      .select()
+      .from(schema.memories)
+      .where(eq(schema.memories.id, memoryId))
+      .limit(1);
+
+    if (memory.length === 0) {
+      throw new Error('Memory not found: ' + memoryId);
+    }
+
+    const snapshotId = randomUUID();
+
+    await (db as any).insert(schema.memorySnapshots).values({
+      id: snapshotId,
+      memoryId,
+      snapshotType: 'before_update',
+      content: memory[0].content,
+      metadata: extractMetadata(memory[0]),
+      createdAt: new Date(),
+    });
+
+    return snapshotId;
+  } catch (error) {
+    logger.error('Error creating before snapshot', error);
+    throw error;
+  }
+}
+
+export async function createAfterSnapshot(
+  memoryId: string,
+  beforeSnapshotId: string
+): Promise<{ snapshotId: string; diff: MemoryDiff }> {
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    const memory = await (db as any)
+      .select()
+      .from(schema.memories)
+      .where(eq(schema.memories.id, memoryId))
+      .limit(1);
+
+    if (memory.length === 0) {
+      throw new Error('Memory not found');
+    }
+
+    const before = await (db as any)
+      .select()
+      .from(schema.memorySnapshots)
+      .where(eq(schema.memorySnapshots.id, beforeSnapshotId))
+      .limit(1);
+
+    if (before.length === 0) {
+      throw new Error('Before snapshot not found');
+    }
+
+    const diff = calculateDiff(before[0].content, memory[0].content);
+    const snapshotId = randomUUID();
+
+    await (db as any).insert(schema.memorySnapshots).values({
+      id: snapshotId,
+      memoryId,
+      snapshotType: 'after_update',
+      content: memory[0].content,
+      metadata: extractMetadata(memory[0]),
+      diff,
+      createdAt: new Date(),
+    });
+
+    return { snapshotId, diff };
+  } catch (error) {
+    logger.error('Error creating after snapshot', error);
+    throw error;
+  }
+}
+
+export async function createPeriodicSnapshot(memoryId: string): Promise<string> {
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    const memory = await (db as any)
+      .select()
+      .from(schema.memories)
+      .where(eq(schema.memories.id, memoryId))
+      .limit(1);
+
+    if (memory.length === 0) {
+      throw new Error('Memory not found');
+    }
+
+    const snapshotId = randomUUID();
+
+    await (db as any).insert(schema.memorySnapshots).values({
+      id: snapshotId,
+      memoryId,
+      snapshotType: 'periodic',
+      content: memory[0].content,
+      metadata: extractMetadata(memory[0]),
+      createdAt: new Date(),
+    });
+
+    return snapshotId;
+  } catch (error) {
+    logger.error('Error creating periodic snapshot', error);
+    throw error;
+  }
+}
+
+function extractMetadata(memory: any): Record<string, unknown> {
+  return {
+    type: memory.type,
+    sector: memory.sector,
+    confidence: memory.confidence,
+    relevanceScore: memory.relevanceScore,
+    tags: memory.tags,
+    agentId: memory.agentId,
+  };
+}

package/core/snapshots/retrieval.ts

@@ -0,0 +1,44 @@
+/**
+ * Snapshot Retrieval Operations
+ * Functions for retrieving and querying snapshots
+ */
+
+import { eq, desc } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+
+export async function getMemoryHistory(memoryId: string, limit: number = 50): Promise<any[]> {
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    return await (db as any)
+      .select()
+      .from(schema.memorySnapshots)
+      .where(eq(schema.memorySnapshots.memoryId, memoryId))
+      .orderBy(desc(schema.memorySnapshots.createdAt))
+      .limit(limit);
+  } catch (error) {
+    logger.error('Error getting memory history', error);
+    return [];
+  }
+}
+
+export async function getMemorySnapshot(snapshotId: string): Promise<any> {
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    const snapshot = await (db as any)
+      .select()
+      .from(schema.memorySnapshots)
+      .where(eq(schema.memorySnapshots.id, snapshotId))
+      .limit(1);
+
+    return snapshot.length > 0 ? snapshot[0] : null;
+  } catch (error) {
+    logger.error('Error getting snapshot', error);
+    return null;
+  }
+}

package/core/snapshots/stats.ts

@@ -0,0 +1,63 @@
+/**
+ * Snapshot Statistics
+ * Analytics and statistics for snapshot operations
+ */
+
+import { eq } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+
+export async function getSnapshotStats(memoryId?: string): Promise<{
+  totalSnapshots: number;
+  byType: Record<string, number>;
+  oldestSnapshot: Date | null;
+  newestSnapshot: Date | null;
+}> {
+  try {
+    const db = await getDb();
+    const schema = await getSchema();
+
+    const where = memoryId ? eq(schema.memorySnapshots.memoryId, memoryId) : undefined;
+
+    const snapshots = await (db as any)
+      .select()
+      .from(schema.memorySnapshots)
+      .where(where);
+
+    const stats = {
+      totalSnapshots: snapshots.length,
+      byType: {
+        before_update: 0,
+        after_update: 0,
+        periodic: 0,
+      } as Record<string, number>,
+      oldestSnapshot: null as Date | null,
+      newestSnapshot: null as Date | null,
+    };
+
+    let oldest: Date | null = null;
+    let newest: Date | null = null;
+
+    for (const snap of snapshots) {
+      stats.byType[snap.snapshotType]++;
+
+      const date = new Date(snap.createdAt);
+      if (!oldest || date < oldest) oldest = date;
+      if (!newest || date > newest) newest = date;
+    }
+
+    stats.oldestSnapshot = oldest;
+    stats.newestSnapshot = newest;
+
+    return stats;
+  } catch (error) {
+    logger.error('Error getting snapshot stats', error);
+    return {
+      totalSnapshots: 0,
+      byType: {},
+      oldestSnapshot: null,
+      newestSnapshot: null,
+    };
+  }
+}