squish-memory 1.2.0 → 1.2.1

package/dist/db/drizzle.config.d.ts

@@ -1,3 +0,0 @@
-declare const _default: import("drizzle-kit").Config;
-export default _default;
-//# sourceMappingURL=drizzle.config.d.ts.map

package/dist/db/drizzle.config.js

@@ -1,12 +0,0 @@
-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,
-});
-//# sourceMappingURL=drizzle.config.js.map

package/dist/db/index.d.ts

@@ -1,7 +0,0 @@
-import { createDb } from './adapter.js';
-import { config } from '../config.js';
-export declare function getDb(): Promise<any>;
-export declare function checkDatabaseHealth(): Promise<boolean>;
-export { config };
-export { createDb };
-//# sourceMappingURL=index.d.ts.map

package/dist/db/index.js

@@ -1,89 +0,0 @@
-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 = null;
-let dbError = 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() {
-    try {
-        const database = await getDb();
-        const dbClient = database.$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) {
-        if (isDatabaseUnavailableError(error)) {
-            return false;
-        }
-        logger.error('Database health check failed', error);
-        return false;
-    }
-}
-export { config };
-export { createDb };
-//# sourceMappingURL=index.js.map

package/dist/db/migrations/associations.d.ts

@@ -1,6 +0,0 @@
-/**
- * Memory associations table migrations
- */
-import type { Database } from 'better-sqlite3';
-export declare function runAssociationsMigrations(sqlite: Database): Promise<void>;
-//# sourceMappingURL=associations.d.ts.map

package/dist/db/migrations/associations.js

@@ -1,29 +0,0 @@
-/**
- * Memory associations table migrations
- */
-import { logger } from '../../core/logger.js';
-export async function runAssociationsMigrations(sqlite) {
-    const associationsTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memory_associations'").get();
-    if (!associationsTableCheck)
-        return;
-    const associationsInfo = sqlite.prepare("PRAGMA table_info(memory_associations)").all();
-    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}`);
-                }
-            }
-        }
-    }
-}
-//# sourceMappingURL=associations.js.map

package/dist/db/migrations/beliefs.d.ts

@@ -1,10 +0,0 @@
-/**
- * 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';
-export declare function runBeliefMigrations(sqlite: Database): Promise<void>;
-//# sourceMappingURL=beliefs.d.ts.map

package/dist/db/migrations/beliefs.js

@@ -1,76 +0,0 @@
-/**
- * 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 { migrateTable } from '../schema/generator.js';
-import { beliefsSchema, beliefMemorySourcesSchema, beliefEdgesSchema } from '../schema/beliefs.js';
-import { logger } from '../../core/logger.js';
-export async function runBeliefMigrations(sqlite) {
-    // 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();
-    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();
-    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();
-    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);
-}
-//# sourceMappingURL=beliefs.js.map

package/dist/db/migrations/core-memory.d.ts

@@ -1,6 +0,0 @@
-/**
- * Core memory table migrations
- */
-import type { Database } from 'better-sqlite3';
-export declare function runCoreMemoryMigrations(sqlite: Database): Promise<void>;
-//# sourceMappingURL=core-memory.d.ts.map

package/dist/db/migrations/core-memory.js

@@ -1,29 +0,0 @@
-/**
- * Core memory table migrations
- */
-import { logger } from '../../core/logger.js';
-export async function runCoreMemoryMigrations(sqlite) {
-    const coreMemoryTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='core_memory'").get();
-    if (!coreMemoryTableCheck)
-        return;
-    const coreMemoryInfo = sqlite.prepare("PRAGMA table_info(core_memory)").all();
-    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}`);
-                }
-            }
-        }
-    }
-}
-//# sourceMappingURL=core-memory.js.map

package/dist/db/migrations/fts.d.ts

@@ -1,6 +0,0 @@
-/**
- * FTS (Full-Text Search) table migrations
- */
-import type { Database } from 'better-sqlite3';
-export declare function runFtsMigrations(sqlite: Database): Promise<void>;
-//# sourceMappingURL=fts.d.ts.map

package/dist/db/migrations/fts.js

@@ -1,52 +0,0 @@
-/**
- * FTS (Full-Text Search) table migrations
- */
-import { logger } from '../../core/logger.js';
-export async function runFtsMigrations(sqlite) {
-    const ftsTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
-    if (!ftsTableCheck)
-        return;
-    const ftsInfo = sqlite.prepare("PRAGMA table_info(memories_fts)").all();
-    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}`);
-        }
-    }
-}
-//# sourceMappingURL=fts.js.map

package/dist/db/migrations/index.d.ts

@@ -1,25 +0,0 @@
-/**
- * Migration runner - imports and runs all migrations
- *
- * Usage:
- *   import { runAllMigrations } from './migrations/index.js';
- *   await runAllMigrations(sqlite);
- */
-import type { Database } from 'better-sqlite3';
-/**
- * Run all v1.2.0 migrations in order
- */
-export declare function runAllMigrations(sqlite: Database): Promise<void>;
-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';
-//# sourceMappingURL=index.d.ts.map

package/dist/db/migrations/index.js

@@ -1,51 +0,0 @@
-/**
- * Migration runner - imports and runs all migrations
- *
- * Usage:
- *   import { runAllMigrations } from './migrations/index.js';
- *   await runAllMigrations(sqlite);
- */
-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) {
-    // 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';
-//# sourceMappingURL=index.js.map

package/dist/db/migrations/indexes.d.ts

@@ -1,6 +0,0 @@
-/**
- * Learnings index migrations
- */
-import type { Database } from 'better-sqlite3';
-export declare function runIndexMigrations(sqlite: Database): Promise<void>;
-//# sourceMappingURL=indexes.d.ts.map

package/dist/db/migrations/indexes.js

@@ -1,30 +0,0 @@
-/**
- * Learnings index migrations
- */
-import { logger } from '../../core/logger.js';
-export async function runIndexMigrations(sqlite) {
-    const learningsTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='learnings'").get();
-    if (!learningsTableCheck)
-        return;
-    const existingIndexes = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='learnings'").all();
-    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}`);
-            }
-        }
-    }
-}
-//# sourceMappingURL=indexes.js.map

package/dist/db/migrations/learnings.d.ts

@@ -1,7 +0,0 @@
-/**
- * Learnings table migrations
- * Uses schema definitions to generate migrations
- */
-import type { Database } from 'better-sqlite3';
-export declare function runLearningsMigrations(sqlite: Database): Promise<void>;
-//# sourceMappingURL=learnings.d.ts.map

package/dist/db/migrations/learnings.js

@@ -1,26 +0,0 @@
-/**
- * Learnings table migrations
- * Uses schema definitions to generate migrations
- */
-import { migrateTable } from '../schema/generator.js';
-import { learningsSchema } from '../schema/learnings.js';
-import { logger } from '../../core/logger.js';
-export async function runLearningsMigrations(sqlite) {
-    // Handle table rename: observations -> learnings
-    const observationsCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='observations'").get();
-    const learningsCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='learnings'").get();
-    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);
-}
-//# sourceMappingURL=learnings.js.map

package/dist/db/migrations/maintenance.d.ts

@@ -1,6 +0,0 @@
-/**
- * Maintenance jobs table migrations
- */
-import type { Database } from 'better-sqlite3';
-export declare function runMaintenanceMigrations(sqlite: Database): Promise<void>;
-//# sourceMappingURL=maintenance.d.ts.map

package/dist/db/migrations/maintenance.js

@@ -1,61 +0,0 @@
-/**
- * Maintenance jobs table migrations
- */
-import { logger } from '../../core/logger.js';
-export async function runMaintenanceMigrations(sqlite) {
-    const maintenanceJobsTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='maintenance_jobs'").get();
-    if (!maintenanceJobsTableCheck)
-        return;
-    const maintenanceJobsInfo = sqlite.prepare("PRAGMA table_info(maintenance_jobs)").all();
-    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}`);
-                }
-            }
-        }
-    }
-}
-//# sourceMappingURL=maintenance.js.map

package/dist/db/migrations/memories.d.ts

@@ -1,7 +0,0 @@
-/**
- * Memories table migrations
- * Uses schema definitions to generate migrations
- */
-import type { Database } from 'better-sqlite3';
-export declare function runMemoriesMigrations(sqlite: Database): Promise<void>;
-//# sourceMappingURL=memories.d.ts.map

package/dist/db/migrations/memories.js

@@ -1,16 +0,0 @@
-/**
- * Memories table migrations
- * Uses schema definitions to generate migrations
- */
-import { migrateTable } from '../schema/generator.js';
-import { memoriesSchema } from '../schema/memories.js';
-import { logger } from '../../core/logger.js';
-export async function runMemoriesMigrations(sqlite) {
-    const tableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories'").get();
-    if (!tableCheck) {
-        logger.debug('Memories table does not exist yet, skipping migrations');
-        return;
-    }
-    await migrateTable(sqlite, memoriesSchema);
-}
-//# sourceMappingURL=memories.js.map

package/dist/db/migrations/memory-places.d.ts

@@ -1,6 +0,0 @@
-/**
- * Memory places table migrations
- */
-import type { Database } from 'better-sqlite3';
-export declare function runMemoryPlacesMigrations(sqlite: Database): Promise<void>;
-//# sourceMappingURL=memory-places.d.ts.map

package/dist/db/migrations/memory-places.js

@@ -1,29 +0,0 @@
-/**
- * Memory places table migrations
- */
-import { logger } from '../../core/logger.js';
-export async function runMemoryPlacesMigrations(sqlite) {
-    const memoryPlacesTableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memory_places'").get();
-    if (!memoryPlacesTableCheck)
-        return;
-    const memoryPlacesInfo = sqlite.prepare("PRAGMA table_info(memory_places)").all();
-    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}`);
-                }
-            }
-        }
-    }
-}
-//# sourceMappingURL=memory-places.js.map

package/dist/db/migrations/places.d.ts

@@ -1,6 +0,0 @@
-/**
- * Places table migrations
- */
-import type { Database } from 'better-sqlite3';
-export declare function runPlacesMigrations(sqlite: Database): Promise<void>;
-//# sourceMappingURL=places.d.ts.map