squish-memory 1.0.2 → 1.2.0

package/db/drizzle.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  schema: './drizzle/schema.ts',
+  out: './drizzle/migrations',
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL || 'postgres://squish:squish_dev@localhost:5432/squish',
+  },
+  verbose: true,
+  strict: true,
+});

package/db/index.ts

@@ -0,0 +1,83 @@
+import { createDb } from './adapter.js';
+import { config } from '../config.js';
+import { logger } from '../core/logger.js';
+import { isDatabaseUnavailableError } from '../core/lib/utils.js';
+
+// Use any for db to avoid type conflicts between different drivers
+// The actual type will be determined at runtime based on mode
+let db: any = null;
+let dbError: string | null = null;
+
+export async function getDb() {
+  if (dbError) {
+    throw new Error(dbError);
+  }
+
+if (!db) {
+      try {
+        // Priority: remote (user's Supabase/Neon) > team (PostgreSQL) > local (SQLite)
+        if (config.isRemoteMode) {
+          if (config.remoteBackend === 'neon' && config.neonProjectId && config.neonServiceKey) {
+            const { createNeonClient } = await import('./neon.js');
+            db = await createNeonClient();
+          } else if (config.supabaseUrl && config.supabaseKey) {
+            const { createSupabaseClient } = await import('./supabase.js');
+            db = await createSupabaseClient();
+          } else {
+            throw new Error('Remote backend not configured (need SUPABASE_URL or NEON_PROJECT_ID)');
+          }
+        } else if (config.isTeamMode) {
+          // Team mode: PostgreSQL (or Supabase/Neon if explicitly configured)
+          if (config.teamBackend === 'supabase' && config.supabaseUrl && config.supabaseKey) {
+            const { createSupabaseClient } = await import('./supabase.js');
+            db = await createSupabaseClient();
+          } else if (config.teamBackend === 'neon' && config.neonProjectId && config.neonServiceKey) {
+            const { createNeonClient } = await import('./neon.js');
+            db = await createNeonClient();
+          } else {
+            db = await createDb();
+          }
+        } else {
+          // Local mode: SQLite
+          db = await createDb();
+        }
+      } catch (error) {
+        dbError = error instanceof Error ? error.message : 'Database initialization failed';
+        throw new Error(dbError);
+      }
+    }
+  return db;
+}
+
+export async function checkDatabaseHealth(): Promise<boolean> {
+  try {
+    const database = await getDb();
+
+    const dbClient = (database as any).$client ?? database;
+    if (dbClient && typeof dbClient.query === 'function') {
+      await dbClient.query('SELECT 1');
+    } else if (dbClient && typeof dbClient.exec === 'function') {
+      dbClient.exec('SELECT 1');
+    } else if (dbClient && typeof dbClient.prepare === 'function') {
+      const statement = dbClient.prepare('SELECT 1');
+      if (typeof statement.get === 'function') {
+        statement.get();
+      } else if (typeof statement.step === 'function') {
+        statement.step();
+      }
+      if (typeof statement.free === 'function') {
+        statement.free();
+      }
+    }
+    return true;
+  } catch (error: any) {
+    if (isDatabaseUnavailableError(error)) {
+      return false;
+    }
+    logger.error('Database health check failed', error);
+    return false;
+  }
+}
+
+export { config };
+export { createDb };

package/db/init.sql

@@ -0,0 +1,5 @@
+-- Enable pgvector extension
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- Enable full-text search
+CREATE EXTENSION IF NOT EXISTS pg_trgm;

package/db/migrations/associations.ts

@@ -0,0 +1,35 @@
+/**
+ * Memory associations table migrations
+ */
+
+import type { Database } from 'better-sqlite3';
+import { logger } from '../../core/logger.js';
+
+export async function runAssociationsMigrations(sqlite: Database): Promise<void> {
+  const associationsTableCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='memory_associations'"
+  ).get() as { name: string } | undefined;
+
+  if (!associationsTableCheck) return;
+
+  const associationsInfo = sqlite.prepare("PRAGMA table_info(memory_associations)").all() as Array<{ name: string }>;
+  const existingAssociationsColumns = new Set(associationsInfo.map(col => col.name));
+
+  const associationsMigrations = [
+    { col: 'metadata', sql: 'ALTER TABLE memory_associations ADD COLUMN metadata TEXT' },
+  ];
+
+  for (const migration of associationsMigrations) {
+    if (!existingAssociationsColumns.has(migration.col)) {
+      try {
+        sqlite.exec(migration.sql);
+        logger.info(`Migration: Added column ${migration.col} to memory_associations table`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (!msg.includes('duplicate column name')) {
+          throw new Error(`Migration failed for memory_associations.${migration.col}: ${msg}`);
+        }
+      }
+    }
+  }
+}

package/db/migrations/beliefs.ts

@@ -0,0 +1,89 @@
+/**
+ * Beliefs table migrations
+ * Uses schema definitions to generate migrations
+ * 
+ * For existing databases without beliefs table (pre-v1.2.0), creates the table.
+ * Then runs column migrations for all belief-related tables.
+ */
+
+import type { Database } from 'better-sqlite3';
+import { migrateTable } from '../schema/generator.js';
+import { beliefsSchema, beliefMemorySourcesSchema, beliefEdgesSchema } from '../schema/beliefs.js';
+import { logger } from '../../core/logger.js';
+
+export async function runBeliefMigrations(sqlite: Database): Promise<void> {
+  // Check if beliefs table exists at all (for existing databases pre-v1.2.0)
+  const beliefsCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='beliefs'"
+  ).get() as { name: string } | undefined;
+
+  if (!beliefsCheck) {
+    // Create beliefs table for existing databases upgrading to v1.2.0
+    logger.info('Migration: Creating beliefs table for existing database');
+    try {
+      sqlite.exec(`
+        CREATE TABLE IF NOT EXISTS beliefs (
+          id TEXT PRIMARY KEY,
+          project_id TEXT,
+          belief_type TEXT NOT NULL,
+          statement TEXT NOT NULL,
+          normalized_key TEXT NOT NULL,
+          confidence REAL DEFAULT 0.5,
+          belief_decay_rate INTEGER DEFAULT 30,
+          last_confirmed_at INTEGER,
+          source_count INTEGER DEFAULT 1,
+          status TEXT DEFAULT 'active',
+          reason TEXT,
+          context TEXT,
+          evidence_summary TEXT,
+          metadata TEXT,
+          created_at INTEGER,
+          updated_at INTEGER,
+          UNIQUE(project_id, normalized_key)
+        )
+      `);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.warn(`Migration: Could not create beliefs table: ${msg}`);
+    }
+  }
+
+  const beliefSourcesCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='belief_memory_sources'"
+  ).get() as { name: string } | undefined;
+
+  if (!beliefSourcesCheck) {
+    sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS belief_memory_sources (
+        id TEXT PRIMARY KEY,
+        belief_id TEXT,
+        memory_id TEXT,
+        created_at INTEGER,
+        UNIQUE(belief_id, memory_id)
+      )
+    `);
+  }
+
+  const beliefEdgesCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='belief_edges'"
+  ).get() as { name: string } | undefined;
+
+  if (!beliefEdgesCheck) {
+    sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS belief_edges (
+        id TEXT PRIMARY KEY,
+        from_belief_id TEXT,
+        to_belief_id TEXT,
+        edge_type TEXT NOT NULL,
+        metadata TEXT,
+        created_at INTEGER,
+        UNIQUE(from_belief_id, to_belief_id, edge_type)
+      )
+    `);
+  }
+
+  // Run column migrations - adds missing columns to existing tables
+  await migrateTable(sqlite, beliefsSchema);
+  await migrateTable(sqlite, beliefMemorySourcesSchema);
+  await migrateTable(sqlite, beliefEdgesSchema);
+}

package/db/migrations/core-memory.ts

@@ -0,0 +1,35 @@
+/**
+ * Core memory table migrations
+ */
+
+import type { Database } from 'better-sqlite3';
+import { logger } from '../../core/logger.js';
+
+export async function runCoreMemoryMigrations(sqlite: Database): Promise<void> {
+  const coreMemoryTableCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='core_memory'"
+  ).get() as { name: string } | undefined;
+
+  if (!coreMemoryTableCheck) return;
+
+  const coreMemoryInfo = sqlite.prepare("PRAGMA table_info(core_memory)").all() as Array<{ name: string }>;
+  const existingCoreMemoryColumns = new Set(coreMemoryInfo.map(col => col.name));
+
+  const coreMemoryMigrations = [
+    { col: 'tokens_estimate', sql: 'ALTER TABLE core_memory ADD COLUMN tokens_estimate INTEGER DEFAULT 0 NOT NULL' },
+  ];
+
+  for (const migration of coreMemoryMigrations) {
+    if (!existingCoreMemoryColumns.has(migration.col)) {
+      try {
+        sqlite.exec(migration.sql);
+        logger.info(`Migration: Added column ${migration.col} to core_memory table`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (!msg.includes('duplicate column name')) {
+          throw new Error(`Migration failed for core_memory.${migration.col}: ${msg}`);
+        }
+      }
+    }
+  }
+}

package/db/migrations/fts.ts

@@ -0,0 +1,59 @@
+/**
+ * FTS (Full-Text Search) table migrations
+ */
+
+import type { Database } from 'better-sqlite3';
+import { logger } from '../../core/logger.js';
+
+export async function runFtsMigrations(sqlite: Database): Promise<void> {
+  const ftsTableCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'"
+  ).get() as { name: string } | undefined;
+
+  if (!ftsTableCheck) return;
+
+  const ftsInfo = sqlite.prepare("PRAGMA table_info(memories_fts)").all() as Array<{ name: string }>;
+  const existingFtsColumns = new Set(ftsInfo.map(col => col.name));
+
+  if (!existingFtsColumns.has('summary') && existingFtsColumns.has('tags')) {
+    logger.info('Migration: Recreating memories_fts table to add summary column...');
+    try {
+      sqlite.exec('DROP TRIGGER IF EXISTS memories_ai');
+      sqlite.exec('DROP TRIGGER IF EXISTS memories_ad');
+      sqlite.exec('DROP TRIGGER IF EXISTS memories_au');
+      sqlite.exec('DROP TABLE IF EXISTS memories_fts');
+
+      sqlite.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+          content,
+          tags,
+          summary,
+          content='memories',
+          content_rowid='rowid'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+          INSERT INTO memories_fts(rowid, content, tags, summary)
+          VALUES (new.rowid, new.content, COALESCE(new.tags, ''), COALESCE(new.summary, ''));
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, content, tags, summary)
+          VALUES ('delete', old.rowid, old.content, COALESCE(old.tags, ''), COALESCE(old.summary, ''));
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, content, tags, summary)
+          VALUES ('delete', old.rowid, old.content, COALESCE(old.tags, ''), COALESCE(old.summary, ''));
+          INSERT INTO memories_fts(rowid, content, tags, summary)
+          VALUES (new.rowid, new.content, COALESCE(new.tags, ''), COALESCE(new.summary, ''));
+        END;
+      `);
+
+      logger.info('Migration: Recreated memories_fts table with summary column');
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.warn(`Migration: Could not recreate memories_fts table: ${msg}`);
+    }
+  }
+}

package/db/migrations/index.ts

@@ -0,0 +1,54 @@
+/**
+ * Migration runner - imports and runs all migrations
+ * 
+ * Usage:
+ *   import { runAllMigrations } from './migrations/index.js';
+ *   await runAllMigrations(sqlite);
+ */
+
+import type { Database } from 'better-sqlite3';
+import { runPlacesMigrations } from './places.js';
+import { runProjectMigrations } from './projects.js';
+import { runMemoriesMigrations } from './memories.js';
+import { runLearningsMigrations } from './learnings.js';
+import { runCoreMemoryMigrations } from './core-memory.js';
+import { runAssociationsMigrations } from './associations.js';
+import { runMemoryPlacesMigrations } from './memory-places.js';
+import { runIndexMigrations } from './indexes.js';
+import { runFtsMigrations } from './fts.js';
+import { runMaintenanceMigrations } from './maintenance.js';
+import { runBeliefMigrations } from './beliefs.js';
+import { runTierConversion } from './tier-conversion.js';
+
+/**
+ * Run all v1.2.0 migrations in order
+ */
+export async function runAllMigrations(sqlite: Database): Promise<void> {
+  // Run each migration in dependency order
+  await runProjectMigrations(sqlite);
+  await runPlacesMigrations(sqlite);
+  await runMemoriesMigrations(sqlite);
+  await runLearningsMigrations(sqlite);
+  await runCoreMemoryMigrations(sqlite);
+  await runAssociationsMigrations(sqlite);
+  await runMemoryPlacesMigrations(sqlite);
+  await runIndexMigrations(sqlite);
+  await runFtsMigrations(sqlite);
+  await runMaintenanceMigrations(sqlite);
+  await runBeliefMigrations(sqlite);
+  await runTierConversion(sqlite);
+}
+
+// Re-export for direct usage if needed
+export { runPlacesMigrations } from './places.js';
+export { runProjectMigrations } from './projects.js';
+export { runMemoriesMigrations } from './memories.js';
+export { runLearningsMigrations } from './learnings.js';
+export { runCoreMemoryMigrations } from './core-memory.js';
+export { runAssociationsMigrations } from './associations.js';
+export { runMemoryPlacesMigrations } from './memory-places.js';
+export { runIndexMigrations } from './indexes.js';
+export { runFtsMigrations } from './fts.js';
+export { runMaintenanceMigrations } from './maintenance.js';
+export { runBeliefMigrations } from './beliefs.js';
+export { runTierConversion } from './tier-conversion.js';

package/db/migrations/indexes.ts

@@ -0,0 +1,36 @@
+/**
+ * Learnings index migrations
+ */
+
+import type { Database } from 'better-sqlite3';
+import { logger } from '../../core/logger.js';
+
+export async function runIndexMigrations(sqlite: Database): Promise<void> {
+  const learningsTableCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='learnings'"
+  ).get() as { name: string } | undefined;
+
+  if (!learningsTableCheck) return;
+
+  const existingIndexes = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='learnings'").all() as Array<{ name: string }>;
+  const existingIndexNames = new Set(existingIndexes.map(idx => idx.name));
+
+  const indexMigrations = [
+    { name: 'learnings_folder_idx', sql: 'CREATE INDEX IF NOT EXISTS learnings_folder_idx ON learnings(folder_path)' },
+    { name: 'learnings_relevance_idx', sql: 'CREATE INDEX IF NOT EXISTS learnings_relevance_idx ON learnings(relevance_score)' },
+    { name: 'learnings_private_idx', sql: 'CREATE INDEX IF NOT EXISTS learnings_private_idx ON learnings(is_private)' },
+    { name: 'learnings_memory_idx', sql: 'CREATE INDEX IF NOT EXISTS learnings_memory_idx ON learnings(memory_id)' },
+  ];
+
+  for (const idx of indexMigrations) {
+    if (!existingIndexNames.has(idx.name)) {
+      try {
+        sqlite.exec(idx.sql);
+        logger.info(`Migration: Added index ${idx.name} to learnings table`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.warn(`Index migration note for ${idx.name}: ${msg}`);
+      }
+    }
+  }
+}

package/db/migrations/learnings.ts

@@ -0,0 +1,34 @@
+/**
+ * Learnings table migrations
+ * Uses schema definitions to generate migrations
+ */
+
+import type { Database } from 'better-sqlite3';
+import { migrateTable } from '../schema/generator.js';
+import { learningsSchema } from '../schema/learnings.js';
+import { logger } from '../../core/logger.js';
+
+export async function runLearningsMigrations(sqlite: Database): Promise<void> {
+  // Handle table rename: observations -> learnings
+  const observationsCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='observations'"
+  ).get() as { name: string } | undefined;
+
+  const learningsCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='learnings'"
+  ).get() as { name: string } | undefined;
+
+  if (observationsCheck && !learningsCheck) {
+    try {
+      sqlite.exec("ALTER TABLE observations RENAME TO learnings");
+      logger.info('Migration: Renamed observations table to learnings');
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.warn(`Migration: Could not rename observations to learnings: ${msg}`);
+    }
+  }
+
+  if (!learningsCheck) return;
+
+  await migrateTable(sqlite, learningsSchema);
+}

package/db/migrations/maintenance.ts

@@ -0,0 +1,68 @@
+/**
+ * Maintenance jobs table migrations
+ */
+
+import type { Database } from 'better-sqlite3';
+import { logger } from '../../core/logger.js';
+
+export async function runMaintenanceMigrations(sqlite: Database): Promise<void> {
+  const maintenanceJobsTableCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='maintenance_jobs'"
+  ).get() as { name: string } | undefined;
+
+  if (!maintenanceJobsTableCheck) return;
+
+  const maintenanceJobsInfo = sqlite.prepare("PRAGMA table_info(maintenance_jobs)").all() as Array<{ name: string }>;
+  const existingMaintenanceJobsColumns = new Set(maintenanceJobsInfo.map(col => col.name));
+
+  // Check if table has wrong schema (camelCase columns from bug in earlier version)
+  const hasCamelCaseColumns = existingMaintenanceJobsColumns.has('jobName') ||
+                              existingMaintenanceJobsColumns.has('jobType') ||
+                              existingMaintenanceJobsColumns.has('cronExpression');
+
+  if (hasCamelCaseColumns) {
+    logger.warn('Maintenance jobs table has incorrect schema (camelCase columns). Recreating...');
+    try {
+      sqlite.exec('DROP TABLE IF EXISTS maintenance_jobs');
+      logger.info('Dropped malformed maintenance_jobs table. It will be recreated with correct schema.');
+    } catch (error) {
+      logger.error('Failed to recreate maintenance_jobs table:', error);
+    }
+    return;
+  }
+
+  const maintenanceJobsMigrations = [
+    { col: 'schedule', sql: 'ALTER TABLE maintenance_jobs DROP COLUMN schedule' },
+    { col: 'cron_expression', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN cron_expression TEXT' },
+    { col: 'last_run_at', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN last_run_at INTEGER' },
+    { col: 'last_run_duration', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN last_run_duration INTEGER' },
+    { col: 'last_run_status', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN last_run_status TEXT' },
+    { col: 'last_run_error', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN last_run_error TEXT' },
+    { col: 'total_runs', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN total_runs INTEGER DEFAULT 0' },
+    { col: 'success_count', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN success_count INTEGER DEFAULT 0' },
+    { col: 'failure_count', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN failure_count INTEGER DEFAULT 0' },
+    { col: 'job_config', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN job_config TEXT' },
+    { col: 'next_run_at', sql: 'ALTER TABLE maintenance_jobs ADD COLUMN next_run_at INTEGER' },
+    { col: 'run_count', sql: 'ALTER TABLE maintenance_jobs DROP COLUMN run_count' },
+  ];
+
+  for (const migration of maintenanceJobsMigrations) {
+    const shouldRun = migration.sql.startsWith('ALTER TABLE maintenance_jobs DROP COLUMN')
+      ? existingMaintenanceJobsColumns.has(migration.col)
+      : !existingMaintenanceJobsColumns.has(migration.col);
+
+    if (shouldRun) {
+      try {
+        sqlite.exec(migration.sql);
+        logger.info(`Migration: ${migration.col} on maintenance_jobs table`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes('duplicate column name') || msg.includes('no such column')) {
+          logger.debug(`Migration skipped for ${migration.col}: ${msg.includes('duplicate column name') ? 'column already exists' : 'column does not exist'}`);
+        } else {
+          throw new Error(`Migration failed for maintenance_jobs.${migration.col}: ${msg}`);
+        }
+      }
+    }
+  }
+}

package/db/migrations/memories.ts

@@ -0,0 +1,22 @@
+/**
+ * Memories table migrations
+ * Uses schema definitions to generate migrations
+ */
+
+import type { Database } from 'better-sqlite3';
+import { migrateTable } from '../schema/generator.js';
+import { memoriesSchema } from '../schema/memories.js';
+import { logger } from '../../core/logger.js';
+
+export async function runMemoriesMigrations(sqlite: Database): Promise<void> {
+  const tableCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='memories'"
+  ).get() as { name: string } | undefined;
+
+  if (!tableCheck) {
+    logger.debug('Memories table does not exist yet, skipping migrations');
+    return;
+  }
+
+  await migrateTable(sqlite, memoriesSchema);
+}

package/db/migrations/memory-places.ts

@@ -0,0 +1,35 @@
+/**
+ * Memory places table migrations
+ */
+
+import type { Database } from 'better-sqlite3';
+import { logger } from '../../core/logger.js';
+
+export async function runMemoryPlacesMigrations(sqlite: Database): Promise<void> {
+  const memoryPlacesTableCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='memory_places'"
+  ).get() as { name: string } | undefined;
+
+  if (!memoryPlacesTableCheck) return;
+
+  const memoryPlacesInfo = sqlite.prepare("PRAGMA table_info(memory_places)").all() as Array<{ name: string }>;
+  const existingMemoryPlacesColumns = new Set(memoryPlacesInfo.map(col => col.name));
+
+  const memoryPlacesMigrations = [
+    { col: 'place_sort_order', sql: 'ALTER TABLE memory_places ADD COLUMN place_sort_order INTEGER DEFAULT 0' },
+  ];
+
+  for (const migration of memoryPlacesMigrations) {
+    if (!existingMemoryPlacesColumns.has(migration.col)) {
+      try {
+        sqlite.exec(migration.sql);
+        logger.info(`Migration: Added column ${migration.col} to memory_places table`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (!msg.includes('duplicate column name')) {
+          logger.warn(`Migration note for memory_places.${migration.col}: ${msg}`);
+        }
+      }
+    }
+  }
+}

package/db/migrations/places.ts

@@ -0,0 +1,49 @@
+/**
+ * Places table migrations
+ */
+
+import type { Database } from 'better-sqlite3';
+import { logger } from '../../core/logger.js';
+
+export async function runPlacesMigrations(sqlite: Database): Promise<void> {
+  const placesTableCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='places'"
+  ).get() as { name: string } | undefined;
+
+  if (!placesTableCheck) return;
+
+  const placesInfo = sqlite.prepare("PRAGMA table_info(places)").all() as Array<{ name: string }>;
+  const placesColumns = new Set(placesInfo.map(col => col.name));
+
+  const placesMigrations = [
+    { col: 'sort_order', sql: 'ALTER TABLE places ADD COLUMN sort_order INTEGER DEFAULT 0' },
+    { col: 'loci_index', sql: '' },
+  ];
+
+  for (const migration of placesMigrations) {
+    if (migration.col === 'loci_index') {
+      if (placesColumns.has('loci_index') && !placesColumns.has('sort_order')) {
+        try {
+          sqlite.exec("UPDATE places SET sort_order = loci_index WHERE sort_order = 0 OR sort_order IS NULL");
+          logger.info('Migration: Copied loci_index data to sort_order');
+        } catch (error) {
+          const errMsg = error instanceof Error ? error.message : String(error);
+          logger.warn(`Migration: Could not copy loci_index data: ${errMsg}`);
+        }
+      }
+      continue;
+    }
+
+    if (!placesColumns.has(migration.col)) {
+      try {
+        sqlite.exec(migration.sql);
+        logger.info(`Migration: Added column ${migration.col} to places table`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (!msg.includes('duplicate column name')) {
+          throw new Error(`Migration failed for places.${migration.col}: ${msg}`);
+        }
+      }
+    }
+  }
+}

package/db/migrations/projects.ts

@@ -0,0 +1,21 @@
+import type { Database } from 'better-sqlite3';
+import { migrateTable } from '../schema/generator.js';
+import { projectsSchema, usersSchema } from '../schema/projects.js';
+
+export async function runProjectMigrations(sqlite: Database): Promise<void> {
+  const projectCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='projects'"
+  ).get() as { name: string } | undefined;
+
+  if (projectCheck) {
+    await migrateTable(sqlite, projectsSchema);
+  }
+
+  const userCheck = sqlite.prepare(
+    "SELECT name FROM sqlite_master WHERE type='table' AND name='users'"
+  ).get() as { name: string } | undefined;
+
+  if (userCheck) {
+    await migrateTable(sqlite, usersSchema);
+  }
+}