squish-memory 1.1.5 → 1.2.0

package/packages/cli/src/commands/doctor.ts

@@ -0,0 +1,357 @@
+/**
+ * Squish Doctor Command
+ *
+ * Diagnose and fix common Squish issues automatically.
+ *
+ * Usage:
+ *   squish doctor              # Run diagnostics
+ *   squish doctor --fix       # Auto-fix issues
+ *   squish doctor --migrate   # Force run database migrations
+ */
+
+import { Command } from 'commander';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDataDir, config } from '../../../../config.js';
+import { createDb, getDb } from '../../../../db/index.js';
+import { buildHealthState } from '../../../../core/runtime/trust-state.js';
+import { formatHealthReport } from '../../../../core/runtime/trust-report.js';
+
+interface DiagnosticResult {
+  name: string;
+  status: 'ok' | 'degraded' | 'broken';
+  message: string;
+  fix?: string;
+}
+
+export function registerDoctorCommand(program: Command) {
+  program
+    .command('doctor')
+    .description('Diagnose and fix Squish issues')
+    .option('-f, --fix', 'Auto-fix issues when possible')
+    .option('-m, --migrate', 'Force run database migrations')
+    .option('-v, --verbose', 'Show detailed output')
+    .option('-p, --project <project>', 'Project path')
+    .option('--json', 'Emit machine-readable output', false)
+    .action(async (options) => {
+      const previousQuiet = process.env.SQUISH_QUIET;
+      if (options.json) {
+        process.env.SQUISH_QUIET = '1';
+      }
+      try {
+        await runDoctorDiagnostics(options);
+      } finally {
+        if (options.json) {
+          if (previousQuiet === undefined) {
+            delete process.env.SQUISH_QUIET;
+          } else {
+            process.env.SQUISH_QUIET = previousQuiet;
+          }
+        }
+      }
+    });
+}
+
+async function runDoctorDiagnostics(options: { fix?: boolean; migrate?: boolean; verbose?: boolean; project?: string; json?: boolean }) {
+  const results: DiagnosticResult[] = [];
+  const dataDir = getDataDir();
+
+  // Check 1: Data directory exists
+  const diagnostic1 = await checkDataDirectory(dataDir);
+  results.push(diagnostic1);
+  
+  // Check 2: Database file
+  const diagnostic2 = await checkDatabaseFile(dataDir);
+  results.push(diagnostic2);
+  
+  // Check 3: Schema version (if database exists)
+  if (diagnostic2.status !== 'fail') {
+    const diagnostic3 = await checkSchemaVersion(options.migrate || false);
+    results.push(diagnostic3);
+  }
+  
+  // Check 4: Config valid
+  const diagnostic4 = checkConfig();
+  results.push(diagnostic4);
+  
+  // Check 5: bin/ files exist
+  const diagnostic5 = checkBinFiles();
+  results.push(diagnostic5);
+
+  let health;
+  try {
+    health = await buildHealthState(options.project);
+  } catch (error: any) {
+    health = {
+      severity: 'degraded' as const,
+      currentProject: options.project || process.cwd(),
+      checks: [
+        {
+          name: 'runtime health',
+          status: 'degraded' as const,
+          detail: `Skipped until schema is readable: ${error.message}`,
+        },
+      ],
+      nextStep: 'Run `squish doctor --migrate` to repair the local schema, then rerun diagnostics.',
+    };
+  }
+
+  const combinedSeverity = [health.severity, ...results.map((result) => result.status)].includes('broken')
+    ? 'broken'
+    : ([health.severity, ...results.map((result) => result.status)].includes('degraded') ? 'degraded' : 'ok');
+  const nextStep =
+    health.nextStep ??
+    results.find((result) => result.fix)?.fix ??
+    (options.fix ? 'Apply the suggested fixes, then rerun `squish doctor`.' : null);
+
+  const combined = {
+    severity: combinedSeverity as 'ok' | 'degraded' | 'broken',
+    currentProject: health.currentProject,
+    checks: health.checks,
+    diagnostics: results.map((result) => ({
+      name: result.name,
+      status: result.status,
+      detail: result.message,
+      fix: result.fix,
+    })),
+    nextStep,
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify({ ok: combined.severity !== 'broken', ...combined }, null, 2));
+    process.exit(combined.severity === 'broken' ? 1 : 0);
+  }
+
+  console.log('\n=== Squish Doctor v1.2.0 ===\n');
+  console.log(formatHealthReport({
+    severity: combined.severity,
+    currentProject: combined.currentProject,
+    checks: combined.checks,
+    diagnostics: combined.diagnostics,
+    nextStep: combined.nextStep,
+  }));
+
+  if (options.verbose) {
+    console.log('\nDiagnostic detail');
+    for (const result of results) {
+      console.log(`- ${result.name}: ${result.message}`);
+      if (result.fix) {
+        console.log(`  fix: ${result.fix}`);
+      }
+    }
+  }
+
+  process.exit(combined.severity === 'broken' ? 1 : 0);
+}
+
+async function checkDataDirectory(dataDir: string): Promise<DiagnosticResult> {
+  try {
+    if (!fs.existsSync(dataDir)) {
+      // Try to create it
+      fs.mkdirSync(dataDir, { recursive: true });
+      return { name: 'data directory', status: 'ok', message: 'Created data directory' };
+    }
+    return { name: 'data directory', status: 'ok', message: dataDir };
+  } catch (error) {
+    return { name: 'data directory', status: 'broken', message: 'Cannot access data directory', fix: 'Check file permissions' };
+  }
+}
+
+async function checkDatabaseFile(dataDir: string): Promise<DiagnosticResult> {
+  const dbPath = path.join(dataDir, 'squish.db');
+  
+  try {
+    if (!fs.existsSync(dbPath)) {
+      return { name: 'database file', status: 'degraded', message: 'Database not found (will be created on first use)', fix: 'Run any squish command to create the local database.' };
+    }
+    return { name: 'database file', status: 'ok', message: dbPath };
+  } catch (error) {
+    return { name: 'database file', status: 'broken', message: 'Cannot access database file', fix: 'Check file permissions' };
+  }
+}
+
+async function checkSchemaVersion(forceMigrate: boolean): Promise<DiagnosticResult> {
+  let dbClient: any;
+  try {
+    dbClient = await getDb();
+  } catch (error) {
+    if (!config.isTeamMode) {
+      return checkSqliteSchemaDirect(forceMigrate);
+    }
+    return { name: 'schema version', status: 'degraded', message: 'Cannot connect to database (no driver available)' };
+  }
+  if (!dbClient) {
+    return { name: 'schema version', status: 'degraded', message: 'Cannot connect to database (no driver available)' };
+  }
+
+  // Check for required tables
+  const requiredTables = [
+    'memories',
+    'learnings',
+    'projects',
+    'users',
+    'conversations',
+    'messages',
+    'entities',
+    'core_memory',
+    'context_sessions',
+    'memory_associations',
+    'namespaces',
+    'maintenance_jobs',
+    'places',
+    'memory_places',
+    'place_rules',
+    'session_summaries',
+    'beliefs',
+    'belief_memory_sources',
+    'belief_edges',
+  ];
+
+  // Get SQLite vs Postgres client handling
+  const dbAny = dbClient as any;
+  const isSqlite = typeof dbAny.exec === 'function';
+
+  let existingTables: string[] = [];
+  if (isSqlite) {
+    const tables = dbAny.prepare("SELECT name FROM sqlite_master WHERE type='table'").all() as Array<{name: string}>;
+    existingTables = tables.map(t => t.name);
+  } else {
+    // Postgres
+    try {
+      const result = await dbAny.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public'");
+      existingTables = result.rows?.map((r: any) => r.tablename) ?? [];
+    } catch {
+      existingTables = [];
+    }
+  }
+
+  const missingTables = requiredTables.filter(t => !existingTables.includes(t));
+
+  // If forceMigrate or missing tables, run migrations
+  if (forceMigrate || missingTables.length > 0) {
+    try {
+      // Import bootstrap functions
+      const { ensureSqliteSchema } = await import('../../../../db/bootstrap.js');
+      const { getSchemaVersion } = await import('../../../../db/bootstrap.js');
+
+      if (isSqlite) {
+        await ensureSqliteSchema(dbAny);
+        const version = await getSchemaVersion(dbAny);
+        return {
+          name: 'schema version',
+          status: 'ok',
+          message: `Migrations applied. Schema: ${version}`
+        };
+      }
+
+      return { name: 'schema version', status: 'ok', message: 'Database schema OK' };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        name: 'schema version',
+        status: 'degraded',
+        message: `Migration note: ${msg}`,
+        fix: 'Run "squish doctor --migrate" to retry'
+      };
+    }
+  }
+
+  return { name: 'schema version', status: 'ok', message: `Tables OK (${existingTables.length})` };
+}
+
+async function checkSqliteSchemaDirect(forceMigrate: boolean): Promise<DiagnosticResult> {
+  const dbPath = path.join(getDataDir(), 'squish.db');
+
+  try {
+    const sqliteModule = await import('bun:sqlite');
+    const sqlite = new sqliteModule.default(dbPath);
+    try {
+      const tables = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table'").all() as Array<{ name: string }>;
+      const existingTables = tables.map((table) => table.name);
+      const requiredTables = [
+        'memories',
+        'learnings',
+        'projects',
+        'users',
+        'conversations',
+        'messages',
+        'entities',
+        'core_memory',
+        'context_sessions',
+        'memory_associations',
+        'namespaces',
+        'maintenance_jobs',
+        'places',
+        'memory_places',
+        'place_rules',
+        'session_summaries',
+        'beliefs',
+        'belief_memory_sources',
+        'belief_edges',
+      ];
+      const missingTables = requiredTables.filter((table) => !existingTables.includes(table));
+
+      if (forceMigrate || missingTables.length > 0) {
+        const { ensureSqliteSchema, getSchemaVersion } = await import('../../../../db/bootstrap.js');
+        await ensureSqliteSchema(sqlite as any);
+        const version = await getSchemaVersion(sqlite as any);
+        return {
+          name: 'schema version',
+          status: 'ok',
+          message: `Migrations applied. Schema: ${version}`,
+        };
+      }
+
+      return { name: 'schema version', status: 'ok', message: `Tables OK (${existingTables.length})` };
+    } finally {
+      sqlite.close();
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      name: 'schema version',
+      status: 'degraded',
+      message: `Migration note: ${msg}`,
+      fix: 'Run "squish doctor --migrate" to retry',
+    };
+  }
+}
+
+function checkConfig(): DiagnosticResult {
+  try {
+    // Basic config validation
+    const dataDir = getDataDir();
+    const embeddingsProvider = config.embeddingsProvider;
+    
+    return { 
+      name: 'configuration', 
+      status: 'ok', 
+      message: `Provider: ${embeddingsProvider}, Data: ${dataDir}` 
+    };
+  } catch (error) {
+    return { name: 'configuration', status: 'broken', message: 'Config validation failed', fix: 'Check config.ts' };
+  }
+}
+
+function checkBinFiles(): DiagnosticResult {
+  const binDir = path.join(process.cwd(), 'bin');
+  
+  try {
+    const files = ['squish.mjs', 'squish-mcp.mjs', 'install-interactive.mjs'];
+    const missing: string[] = [];
+    
+    for (const file of files) {
+      if (!fs.existsSync(path.join(binDir, file))) {
+        missing.push(file);
+      }
+    }
+    
+    if (missing.length > 0) {
+      return { name: 'cli binaries', status: 'broken', message: `Missing: ${missing.join(', ')}` };
+    }
+    
+    return { name: 'cli binaries', status: 'ok', message: 'All binaries present' };
+  } catch (error) {
+    return { name: 'cli binaries', status: 'broken', message: 'Cannot check binaries', fix: 'Reinstall squish-memory' };
+  }
+}

package/packages/cli/src/commands/forget.ts

@@ -0,0 +1,72 @@
+/**
+ * Forget Command - Delete memory
+ * 
+ * Usage: squish forget <memoryId> [--confirm] [--older-than "30 days"]
+ */
+
+import { Command } from 'commander';
+import { eq } from 'drizzle-orm';
+import { getDbClient } from '../../../../core/lib/db-client.js';
+import { search } from '../../../../core/memory/memories.js';
+import { filterByDateRange } from '../../../../core/lib/utils.js';
+
+export function registerForgetCommand(program: Command) {
+  program
+    .command('forget <memoryId>')
+    .description('Delete memory (single or bulk with --older-than --search)')
+    .option('--older-than <period>', 'Bulk delete memories older than')
+    .option('--search <query>', 'Search query to match specific memories')
+    .option('--type <type>', 'Filter by memory type')
+    .option('--confirm', 'Actually delete (default is dry-run)', false)
+    .option('-l, --limit <number>', 'Max memories to delete', '100')
+    .option('-p, --project <project>', 'Project path', process.cwd())
+    .action(async (memoryId: string, options: any) => {
+      try {
+        const { db, schema } = await getDbClient();
+        
+        if (memoryId && memoryId !== 'all') {
+          await db.delete(schema.memories).where(eq(schema.memories.id, memoryId));
+          console.log(JSON.stringify({ ok: true, deleted: 1, memoryId }));
+          return;
+        }
+        
+        if (!options.olderThan && !options.search) {
+          console.error(JSON.stringify({ 
+            ok: false, 
+            error: 'Provide memoryId or use --older-than / --search for bulk delete' 
+          }));
+          process.exit(1);
+        }
+        
+        const results = await search({
+          query: options.search || '',
+          project: options.project,
+          limit: parseInt(options.limit) || 100,
+          type: options.type
+        });
+        
+        let filtered = results;
+        if (options.olderThan) {
+          filtered = filterByDateRange(results, '', options.olderThan);
+        }
+        
+        const deleted = [];
+        if (options.confirm) {
+          for (const mem of filtered) {
+            await db.delete(schema.memories).where(eq(schema.memories.id, mem.id));
+            deleted.push(mem.id);
+          }
+        }
+        
+        console.log(JSON.stringify({
+          ok: true,
+          matched: filtered.length,
+          deleted: deleted.length,
+          dryRun: !options.confirm
+        }, null, 2));
+      } catch (error: any) {
+        console.error(JSON.stringify({ ok: false, error: error.message }));
+        process.exit(1);
+      }
+    });
+}

package/packages/cli/src/commands/health.ts

@@ -0,0 +1,36 @@
+import { Command } from 'commander';
+import { buildHealthState } from '../../../../core/runtime/trust-state.js';
+import { formatHealthReport } from '../../../../core/runtime/trust-report.js';
+
+export function registerHealthCommand(program: Command) {
+  program
+    .command('health')
+    .description('Show runtime health for the current project')
+    .option('-p, --project <project>', 'Project path')
+    .option('--json', 'Emit machine-readable output', false)
+    .action(async (options: any) => {
+      const previousQuiet = process.env.SQUISH_QUIET;
+      if (options.json) {
+        process.env.SQUISH_QUIET = '1';
+      }
+      try {
+        const health = await buildHealthState(options.project);
+        if (options.json) {
+          console.log(JSON.stringify({ ok: true, ...health }, null, 2));
+          return;
+        }
+        console.log(formatHealthReport(health));
+      } catch (error: any) {
+        console.error(JSON.stringify({ ok: false, error: error.message }));
+        process.exit(1);
+      } finally {
+        if (options.json) {
+          if (previousQuiet === undefined) {
+            delete process.env.SQUISH_QUIET;
+          } else {
+            process.env.SQUISH_QUIET = previousQuiet;
+          }
+        }
+      }
+    });
+}

package/packages/cli/src/commands/inspect.ts

@@ -0,0 +1,41 @@
+import { Command } from 'commander';
+import { buildInspectState } from '../../../../core/runtime/trust-state.js';
+import { formatInspectReport } from '../../../../core/runtime/trust-report.js';
+
+export function registerInspectCommand(program: Command) {
+  program
+    .command('inspect <id>')
+    .description('Inspect how and why a memory was stored')
+    .option('-P, --pretty', 'Human-friendly output', false)
+    .option('--json', 'Emit machine-readable output', false)
+    .action(async (id: string, options: any) => {
+      const previousQuiet = process.env.SQUISH_QUIET;
+      if (options.json) {
+        process.env.SQUISH_QUIET = '1';
+      }
+      try {
+        const inspection = await buildInspectState(id);
+        if (!inspection) {
+          console.error(JSON.stringify({ ok: false, error: 'Memory not found' }));
+          process.exit(1);
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify({ ok: true, inspection }, null, 2));
+        } else {
+          console.log(formatInspectReport(inspection));
+        }
+      } catch (error: any) {
+        console.error(JSON.stringify({ ok: false, error: error.message }));
+        process.exit(1);
+      } finally {
+        if (options.json) {
+          if (previousQuiet === undefined) {
+            delete process.env.SQUISH_QUIET;
+          } else {
+            process.env.SQUISH_QUIET = previousQuiet;
+          }
+        }
+      }
+    });
+}

package/packages/cli/src/commands/link.ts

@@ -0,0 +1,50 @@
+/**
+ * Link Command - Manage memory associations
+ * 
+ * Usage: squish link find <memoryId> [--depth 2]
+ *        squish link add <fromId> <toId> [--type relates_to]
+ */
+
+import { Command } from 'commander';
+import { createAssociation, getRelatedMemories } from '../../../../core/associations.js';
+
+export function registerLinkCommand(program: Command) {
+  program
+    .command('link <action> [args...]')
+    .description('Manage links (find/add/list)')
+    .option('-d, --depth <number>', 'Graph traversal depth', '2')
+    .option('-t, --type <type>', 'Association type', 'relates_to')
+    .option('-w, --weight <number>', 'Association weight', '0.5')
+    .action(async (action: string, args: string[], options: any) => {
+      try {
+        if (action === 'find' && args[0]) {
+          const related = await getRelatedMemories(args[0], options.depth * 5);
+          console.log(JSON.stringify({ ok: true, count: related.length, related }, null, 2));
+        } else if (action === 'add' && args[0] && args[1]) {
+          await createAssociation(args[0], args[1], options.type as any, options.weight);
+          
+          // Auto-update knowledge graph (fire-and-forget)
+          try {
+            const { addMemoryToGraph } = await import('../../../../core/graph/graph-builder.js');
+            const [result1, result2] = await Promise.all([
+              addMemoryToGraph(args[0]).catch(() => null),
+              addMemoryToGraph(args[1]).catch(() => null)
+            ]);
+            if (result1 || result2) {
+              console.error(`[Graph] Updated graph for linked memories`);
+            }
+          } catch (e) {
+            // Ignore graph errors
+          }
+          
+          console.log(JSON.stringify({ ok: true, action: 'created', from: args[0], to: args[1], type: options.type }));
+        } else {
+          console.log(JSON.stringify({ ok: false, error: 'Usage: squish link find <id> OR squish link add <from> <to>' }));
+          process.exit(1);
+        }
+      } catch (error: any) {
+        console.error(JSON.stringify({ ok: false, error: error.message }));
+        process.exit(1);
+      }
+    });
+}

package/packages/cli/src/commands/migrate.ts

@@ -0,0 +1,93 @@
+/**
+ * Migrate Command - Migrate memories between .squish directories
+ * 
+ * Usage: squish migrate <source-path> [--target <path>] [--delete-source] [--dry-run]
+ */
+
+import { Command } from 'commander';
+import { migrateMemories, type MigrateResult } from '../../../../core/memory/migrate.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+export function registerMigrateCommand(program: Command) {
+  program
+    .command('migrate <source>')
+    .description('Migrate memories from one .squish directory to another (unify multiple .squish folders)')
+    .option('-t, --target <path>', 'Target .squish directory (default: current directory)', process.cwd())
+    .option('-d, --delete-source', 'Delete source directory after successful migration (requires --yes)')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .option('-n, --dry-run', 'Preview migration without making changes', false)
+    .action(async (source: string, options: any) => {
+      const target = options.target || process.cwd();
+      const dryRun = options.dryRun || false;
+      const deleteSource = options.deleteSource || false;
+      const confirmed = options.yes || false;
+
+      // Validate paths
+      if (!existsSync(source)) {
+        console.error(`Error: Source directory does not exist: ${source}`);
+        process.exit(1);
+      }
+
+      const sourceDbPath = join(source, 'squish.db');
+      const targetDbPath = join(target, 'squish.db');
+
+      if (!existsSync(sourceDbPath)) {
+        console.error(`Error: Source is not a .squish directory (no squish.db found): ${source}`);
+        process.exit(1);
+      }
+
+      if (!existsSync(targetDbPath)) {
+        console.error(`Error: Target is not a .squish directory (no squish.db found): ${target}`);
+        process.exit(1);
+      }
+
+      // Show plan
+      console.log('\n=== Migration Plan ===');
+      console.log(`Source:      ${source}`);
+      console.log(`Target:      ${target}`);
+      console.log(`Dry-run:     ${dryRun ? 'YES (no changes)' : 'NO'}`);
+      console.log(`Delete source: ${deleteSource ? 'YES (after success)' : 'NO'}`);
+
+      if (!confirmed && !dryRun) {
+        console.log('\nThis will copy ALL memories from source to target.');
+        console.log('The source directory will NOT be deleted unless you also pass --delete-source');
+        console.log('Use --yes to confirm or --dry-run to preview.\n');
+        process.exit(1);
+      }
+
+      try {
+        console.log('\nMigrating...\n');
+        
+        const result: MigrateResult = await migrateMemories(source, target, {
+          dryRun,
+          deleteSource,
+        });
+
+        console.log('=== Migration Result ===');
+        console.log(`Memories copied:    ${result.memoriesCopied}`);
+        console.log(`Learnings copied:   ${result.observationsCopied}`);
+        console.log(`Associations copied: ${result.associationsCopied}`);
+        console.log(`Projects mapped:    ${result.projectsMapped}`);
+        
+        if (deleteSource && !dryRun && result.sourceDeleted) {
+          console.log(`Source deleted:     YES`);
+        } else if (deleteSource && !dryRun && !result.sourceDeleted) {
+          console.log(`Source deleted:     NO (manual deletion required)`);
+        } else if (deleteSource && dryRun) {
+          console.log(`Source would be deleted after confirmation`);
+        }
+
+        console.log(`\n${result.message}`);
+
+        if (result.memoriesCopied > 0 && !dryRun) {
+          console.log('\nTip: After verifying the migration worked, you can manually delete the source directory:');
+          console.log(`  rm -rf ${source}`);
+        }
+
+      } catch (error) {
+        console.error(`Migration failed:`, error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+}