squish-memory 1.1.5 → 1.2.0

package/dist/db/drizzle/schema.js

@@ -130,7 +130,7 @@ export const memories = pgTable('memories', {
     namespacePath: text('namespace_path'),
     // v1.1.5: Places support (spatial memory organization)
     placeId: uuid('place_id').references(() => places.id, { onDelete: 'set null' }),
-    placeLociIndex: integer('place_loci_index'),
+    placeSortOrder: integer('place_sort_order'),
     // v0.4.3: Layer support
     hasL0Abstract: boolean('has_l0_abstract').default(false),
     hasL1Overview: boolean('has_l1_overview').default(false),
@@ -255,6 +255,24 @@ export const learnings = pgTable('learnings', {
     index('learnings_private_idx').on(table.isPrivate),
     index('learnings_memory_idx').on(table.memoryId),
 ]);
+/**
+ * Agent Preferences - learned agent preferences from learnings
+ * Enables agents to evolve and remember preferences over time
+ */
+export const agentPreferences = pgTable('agent_preferences', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    projectId: uuid('project_id').references(() => projects.id, { onDelete: 'cascade' }).notNull(),
+    key: text('key').notNull(), // e.g., "prefer_bun", "prefer_typescript"
+    value: text('value').notNull(), // e.g., "bun", "true"
+    sourceMemoryId: uuid('source_memory_id').references(() => memories.id, { onDelete: 'set null' }),
+    confidence: numeric('confidence', { precision: 3, scale: 2 }).default('0.5'), // 0.00 to 1.00
+    usageCount: integer('usage_count').default(1),
+    lastUpdated: timestamp('last_updated').defaultNow().notNull(),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+}, (table) => [
+    index('agent_preferences_project_idx').on(table.projectId),
+    index('agent_preferences_key_idx').on(table.key),
+]);
 /**
  * Entities - knowledge graph nodes
  */
@@ -292,7 +310,7 @@ export const namespaces = pgTable('namespaces', {
     index('namespaces_parent_idx').on(table.parentId),
 ]);
 /**
- * Places - Spatial memory organization (Method of Loci)
+ * Places - Spatial memory organization
  */
 export const places = pgTable('places', {
     id: uuid('id').primaryKey().defaultRandom(),
@@ -300,7 +318,7 @@ export const places = pgTable('places', {
     name: text('name').notNull(),
     placeType: text('place_type').notNull(),
     parentId: uuid('parent_id').references(() => places.id, { onDelete: 'set null' }),
-    lociIndex: integer('loci_index').default(0),
+    sortOrder: integer('sort_order').default(0),
     positionX: integer('position_x').default(0),
     positionY: integer('position_y').default(0),
     description: text('description'),
@@ -312,7 +330,7 @@ export const places = pgTable('places', {
     index('places_project_idx').on(table.projectId),
     index('places_type_idx').on(table.placeType),
     index('places_parent_idx').on(table.parentId),
-    index('places_loci_idx').on(table.projectId, table.lociIndex),
+    index('places_sort_order_idx').on(table.projectId, table.sortOrder),
 ]);
 /**
  * Memory-Place assignments
@@ -675,6 +693,16 @@ export const learningsRelations = relations(learnings, ({ one }) => ({
         references: [memories.id],
     }),
 }));
+export const agentPreferencesRelations = relations(agentPreferences, ({ one }) => ({
+    project: one(projects, {
+        fields: [agentPreferences.projectId],
+        references: [projects.id],
+    }),
+    sourceMemory: one(memories, {
+        fields: [agentPreferences.sourceMemoryId],
+        references: [memories.id],
+    }),
+}));
 export const messagesRelations = relations(messages, ({ one }) => ({
     conversation: one(conversations, {
         fields: [messages.conversationId],
@@ -767,4 +795,65 @@ export const memoryHashCacheRelations = relations(memoryHashCache, ({ one }) =>
         references: [projects.id],
     }),
 }));
+// Belief Systems - Derived Beliefs from Memory
+// ============================================================================
+/**
+ * Beliefs - Derived semantic beliefs extracted from memories
+ * Represents inferred decisions, preferences, constraints, failure causes
+ */
+export const beliefs = pgTable('beliefs', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    projectId: uuid('project_id').references(() => projects.id, { onDelete: 'cascade' }),
+    // Belief identification
+    beliefType: text('belief_type').notNull(),
+    statement: text('statement').notNull(),
+    normalizedKey: text('normalized_key').notNull(),
+    // Confidence and decay
+    confidence: integer('confidence').default(50), // 0-100
+    beliefDecayRate: integer('belief_decay_rate').default(30), // days half-life
+    lastConfirmedAt: timestamp('last_confirmed_at'),
+    sourceCount: integer('source_count').default(1),
+    // Status
+    status: text('status').default('active'),
+    // Context and evidence
+    reason: text('reason'),
+    context: text('context'),
+    evidenceSummary: text('evidence_summary'),
+    // Metadata (stores edges, derivation info)
+    metadata: jsonb('metadata'),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    updatedAt: timestamp('updated_at').defaultNow().notNull(),
+}, (table) => [
+    index('beliefs_project_idx').on(table.projectId),
+    index('beliefs_type_idx').on(table.beliefType),
+    index('beliefs_status_idx').on(table.status),
+    index('beliefs_confidence_idx').on(table.confidence),
+    index('beliefs_normalized_key_idx').on(table.normalizedKey),
+]);
+/**
+ * Belief Memory Sources - Links beliefs to source memories
+ */
+export const beliefMemorySources = pgTable('belief_memory_sources', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    beliefId: uuid('belief_id').references(() => beliefs.id, { onDelete: 'cascade' }).notNull(),
+    memoryId: uuid('memory_id').references(() => memories.id, { onDelete: 'cascade' }).notNull(),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+}, (table) => [
+    index('belief_sources_belief_idx').on(table.beliefId),
+    index('belief_sources_memory_idx').on(table.memoryId),
+]);
+/**
+ * Belief Edges - Relationships between beliefs
+ */
+export const beliefEdges = pgTable('belief_edges', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    fromBeliefId: uuid('from_belief_id').references(() => beliefs.id, { onDelete: 'cascade' }).notNull(),
+    toBeliefId: uuid('to_belief_id').references(() => beliefs.id, { onDelete: 'cascade' }).notNull(),
+    edgeType: text('edge_type').notNull(),
+    metadata: jsonb('metadata'),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+}, (table) => [
+    index('belief_edges_from_idx').on(table.fromBeliefId),
+    index('belief_edges_to_idx').on(table.toBeliefId),
+]);
 //# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,29 @@
+/**
+ * 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

@@ -0,0 +1,10 @@
+/**
+ * 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

@@ -0,0 +1,76 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,29 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,52 @@
+/**
+ * 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

@@ -0,0 +1,25 @@
+/**
+ * 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

@@ -0,0 +1,51 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,30 @@
+/**
+ * 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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,26 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,61 @@
+/**
+ * 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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,29 @@
+/**
+ * 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