squish-memory 1.0.2 → 1.2.0

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

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

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

package/dist/db/migrations/places.js

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

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

@@ -0,0 +1,3 @@
+import type { Database } from 'better-sqlite3';
+export declare function runProjectMigrations(sqlite: Database): Promise<void>;
+//# sourceMappingURL=projects.d.ts.map

package/dist/db/migrations/projects.js

@@ -0,0 +1,13 @@
+import { migrateTable } from '../schema/generator.js';
+import { projectsSchema, usersSchema } from '../schema/projects.js';
+export async function runProjectMigrations(sqlite) {
+    const projectCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='projects'").get();
+    if (projectCheck) {
+        await migrateTable(sqlite, projectsSchema);
+    }
+    const userCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='users'").get();
+    if (userCheck) {
+        await migrateTable(sqlite, usersSchema);
+    }
+}
+//# sourceMappingURL=projects.js.map

package/dist/db/migrations/tier-conversion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tier conversion migration
+ * Converts deprecated 'warm' tier memories to 'cold'
+ */
+import type { Database } from 'better-sqlite3';
+export declare function runTierConversion(sqlite: Database): Promise<void>;
+//# sourceMappingURL=tier-conversion.d.ts.map

package/dist/db/migrations/tier-conversion.js

@@ -0,0 +1,20 @@
+/**
+ * Tier conversion migration
+ * Converts deprecated 'warm' tier memories to 'cold'
+ */
+import { logger } from '../../core/logger.js';
+export async function runTierConversion(sqlite) {
+    const warmMemories = sqlite.prepare("SELECT COUNT(*) as count FROM memories WHERE tier = 'warm'").get();
+    if (warmMemories && warmMemories.count > 0) {
+        logger.info(`Migration: Converting ${warmMemories.count} warm-tiered memories to cold`);
+        try {
+            sqlite.exec("UPDATE memories SET tier = 'cold' WHERE tier = 'warm'");
+            logger.info('Migration: Tier conversion complete (warm -> cold)');
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.warn(`Migration: Could not convert warm tier: ${msg}`);
+        }
+    }
+}
+//# sourceMappingURL=tier-conversion.js.map

package/dist/db/neon.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Neon client wrapper that returns a Drizzle HTTP client.
+ * Neon HTTP driver is faster for single non-interactive transactions.
+ */
+export declare function createNeonClient(): Promise<import("drizzle-orm/neon-http").NeonHttpDatabase<Record<string, never>> & {
+    $client: import("@neondatabase/serverless").NeonQueryFunction<false, false>;
+}>;
+//# sourceMappingURL=neon.d.ts.map

package/dist/db/neon.js

@@ -0,0 +1,20 @@
+import { config } from '../config.js';
+import { neon } from '@neondatabase/serverless';
+import { drizzle } from 'drizzle-orm/neon-http';
+/**
+ * Neon client wrapper that returns a Drizzle HTTP client.
+ * Neon HTTP driver is faster for single non-interactive transactions.
+ */
+export async function createNeonClient() {
+    if (!config.neonProjectId || !config.neonServiceKey) {
+        throw new Error('Neon configuration missing (NEON_PROJECT_ID or NEON_SERVICE_KEY)');
+    }
+    // Neon HTTP driver - use DATABASE_URL with Neon connection string
+    const connectionString = process.env.DATABASE_URL;
+    if (!connectionString) {
+        throw new Error('DATABASE_URL required for Neon connection');
+    }
+    const sql = neon(connectionString);
+    return drizzle(sql);
+}
+//# sourceMappingURL=neon.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Beliefs table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+import type { TableSchema } from '../generator.js';
+export declare const beliefsSchema: TableSchema;
+export declare const beliefMemorySourcesSchema: TableSchema;
+export declare const beliefEdgesSchema: TableSchema;
+//# sourceMappingURL=beliefs.d.ts.map

package/dist/db/schema/beliefs.js

@@ -0,0 +1,46 @@
+/**
+ * Beliefs table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+export const beliefsSchema = {
+    name: 'beliefs',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        project_id: { type: 'TEXT' },
+        belief_type: { type: 'TEXT' },
+        statement: { type: 'TEXT' },
+        normalized_key: { type: 'TEXT' },
+        confidence: { type: 'REAL', default: '0.5' },
+        belief_decay_rate: { type: 'INTEGER', default: '30' },
+        last_confirmed_at: { type: 'INTEGER' },
+        source_count: { type: 'INTEGER', default: '1' },
+        status: { type: 'TEXT', default: "'active'" },
+        reason: { type: 'TEXT' },
+        context: { type: 'TEXT' },
+        evidence_summary: { type: 'TEXT' },
+        metadata: { type: 'TEXT' },
+        created_at: { type: 'INTEGER' },
+        updated_at: { type: 'INTEGER' },
+    },
+};
+export const beliefMemorySourcesSchema = {
+    name: 'belief_memory_sources',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        belief_id: { type: 'TEXT' },
+        memory_id: { type: 'TEXT' },
+        created_at: { type: 'INTEGER' },
+    },
+};
+export const beliefEdgesSchema = {
+    name: 'belief_edges',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        from_belief_id: { type: 'TEXT' },
+        to_belief_id: { type: 'TEXT' },
+        edge_type: { type: 'TEXT' },
+        metadata: { type: 'TEXT' },
+        created_at: { type: 'INTEGER' },
+    },
+};
+//# sourceMappingURL=beliefs.js.map

package/dist/db/schema/generator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Migration Generator - Creates migrations from schema definitions
+ *
+ * This utility generates ALTER TABLE statements from schema column definitions,
+ * eliminating the need for inline column arrays in migration files.
+ */
+import type { Database } from 'better-sqlite3';
+export interface ColumnDefinition {
+    type: string;
+    primary?: boolean;
+    references?: string;
+    default?: string;
+    notNull?: boolean;
+}
+export interface IndexDefinition {
+    name: string;
+    columns: string[];
+    using?: string;
+    unique?: boolean;
+}
+export interface TableSchema {
+    name: string;
+    columns: Record<string, ColumnDefinition>;
+    indexes?: IndexDefinition[];
+}
+/**
+ * Generate and run column migrations for a table schema
+ */
+export declare function migrateTable(sqlite: Database, schema: TableSchema): Promise<void>;
+/**
+ * Generate and run index migrations
+ */
+export declare function migrateIndexes(sqlite: Database, tableName: string, indexes: IndexDefinition[]): Promise<void>;
+/**
+ * Run all table migrations from schema list
+ */
+export declare function runAllSchemaMigrations(sqlite: Database, schemas: TableSchema[]): Promise<void>;
+//# sourceMappingURL=generator.d.ts.map