chapterhouse 0.9.2 → 0.10.0

package/dist/store/migrations.js

@@ -0,0 +1,460 @@
+function hasColumn(database, table, column) {
+    return database.prepare(`PRAGMA table_info(${table})`).all().some((entry) => entry.name === column);
+}
+function memoryTierCase(tableAlias = "") {
+    const prefix = tableAlias ? `${tableAlias}.` : "";
+    return `
+    CASE
+      WHEN ${prefix}archived_at IS NOT NULL OR ${prefix}superseded_by IS NOT NULL THEN 'cold'
+      WHEN ${prefix}tier = 'glacier' THEN 'cold'
+      WHEN ${prefix}tier IN ('hot', 'warm', 'cold') THEN ${prefix}tier
+      ELSE 'warm'
+    END
+  `;
+}
+function entityTierCase(tableAlias = "") {
+    const prefix = tableAlias ? `${tableAlias}.` : "";
+    return `
+    CASE
+      WHEN ${prefix}tier = 'glacier' THEN 'cold'
+      WHEN ${prefix}tier IN ('hot', 'warm', 'cold') THEN ${prefix}tier
+      WHEN ${prefix}confidence > 0.7 AND datetime(${prefix}updated_at) >= datetime('now', '-30 days') THEN 'hot'
+      ELSE 'warm'
+    END
+  `;
+}
+function tableCreateSql(database, table) {
+    const row = database.prepare(`
+    SELECT sql
+    FROM sqlite_master
+    WHERE type = 'table' AND name = ?
+  `).get(table);
+    return row?.sql ?? "";
+}
+function migrateMemActionItemsCreatedAtType(database) {
+    const columns = database.prepare(`PRAGMA table_info(mem_action_items)`).all();
+    const createdAt = columns.find((column) => column.name === "created_at");
+    if (!createdAt || createdAt.type.toUpperCase() === "DATETIME") {
+        return;
+    }
+    database.pragma("foreign_keys = OFF");
+    try {
+        database.transaction(() => {
+            database.exec(`DROP TRIGGER IF EXISTS mem_action_items_ai`);
+            database.exec(`DROP TRIGGER IF EXISTS mem_action_items_ad`);
+            database.exec(`DROP TRIGGER IF EXISTS mem_action_items_au`);
+            database.exec(`
+        CREATE TABLE mem_action_items_new (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+          entity_id INTEGER REFERENCES mem_entities(id),
+          title TEXT NOT NULL,
+          detail TEXT,
+          status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open', 'done', 'dropped', 'snoozed')),
+          due_at TEXT,
+          snooze_until TEXT,
+          source TEXT,
+          created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+          resolved_at TEXT,
+          resolution_reason TEXT,
+          tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'cold')),
+          tier_pinned_at TEXT,
+          tier_reason TEXT,
+          last_recalled_at TEXT
+        )
+      `);
+            database.exec(`
+        INSERT INTO mem_action_items_new (
+          id, scope_id, entity_id, title, detail, status, due_at, snooze_until, source,
+          created_at, updated_at, resolved_at, resolution_reason, tier, tier_pinned_at, tier_reason, last_recalled_at
+        )
+        SELECT
+          id, scope_id, entity_id, title, detail, status, due_at, snooze_until, source,
+          datetime(created_at), updated_at, resolved_at, resolution_reason, tier, tier_pinned_at, tier_reason, last_recalled_at
+        FROM mem_action_items
+      `);
+            database.exec(`DROP TABLE mem_action_items`);
+            database.exec(`ALTER TABLE mem_action_items_new RENAME TO mem_action_items`);
+        })();
+    }
+    finally {
+        database.pragma("foreign_keys = ON");
+    }
+    ensureMemoryIndexes(database);
+}
+function rebuildMemoryTierTables(database) {
+    const needsRebuild = ["mem_entities", "mem_observations", "mem_decisions"]
+        .some((table) => tableCreateSql(database, table).includes("'glacier'"));
+    if (!needsRebuild) {
+        return;
+    }
+    database.pragma("foreign_keys = OFF");
+    try {
+        database.transaction(() => {
+            database.exec(`ALTER TABLE mem_entities RENAME TO mem_entities_legacy_tier`);
+            database.exec(`
+        CREATE TABLE mem_entities (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+          slug TEXT,
+          kind TEXT NOT NULL,
+          name TEXT NOT NULL,
+          summary TEXT,
+          tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'cold')),
+          confidence REAL NOT NULL DEFAULT 1.0,
+          tier_pinned_at DATETIME,
+          tier_reason TEXT,
+          last_recalled_at DATETIME,
+          created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+          updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            database.exec(`
+        INSERT INTO mem_entities (id, scope_id, slug, kind, name, summary, tier, confidence, created_at, updated_at)
+        SELECT id, scope_id, NULL, kind, name, summary, ${entityTierCase()}, confidence, created_at, updated_at
+        FROM mem_entities_legacy_tier
+      `);
+            database.exec(`DROP TABLE mem_entities_legacy_tier`);
+            database.exec(`ALTER TABLE mem_observations RENAME TO mem_observations_legacy_tier`);
+            database.exec(`
+        CREATE TABLE mem_observations (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+          entity_id INTEGER REFERENCES mem_entities(id),
+          content TEXT NOT NULL,
+          source TEXT NOT NULL,
+          tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'cold')),
+          confidence REAL NOT NULL DEFAULT 1.0,
+          embedding BLOB,
+          superseded_by INTEGER REFERENCES mem_observations(id) ON DELETE SET NULL,
+          archived_at DATETIME,
+          tier_pinned_at DATETIME,
+          tier_reason TEXT,
+          last_recalled_at DATETIME,
+          created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            database.exec(`
+        INSERT INTO mem_observations (
+          id, scope_id, entity_id, content, source, tier, confidence, embedding, superseded_by, archived_at, created_at
+        )
+        SELECT id, scope_id, entity_id, content, source, ${memoryTierCase()}, confidence, embedding, superseded_by, archived_at, created_at
+        FROM mem_observations_legacy_tier
+      `);
+            database.exec(`DROP TABLE mem_observations_legacy_tier`);
+            database.exec(`ALTER TABLE mem_decisions RENAME TO mem_decisions_legacy_tier`);
+            database.exec(`
+        CREATE TABLE mem_decisions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          scope_id INTEGER NOT NULL REFERENCES mem_scopes(id),
+          entity_id INTEGER REFERENCES mem_entities(id),
+          title TEXT NOT NULL,
+          rationale TEXT NOT NULL,
+          decided_at TEXT NOT NULL,
+          source TEXT,
+          tier TEXT NOT NULL DEFAULT 'warm' CHECK(tier IN ('hot', 'warm', 'cold')),
+          superseded_by INTEGER REFERENCES mem_decisions(id) ON DELETE SET NULL,
+          archived_at DATETIME,
+          tier_pinned_at DATETIME,
+          tier_reason TEXT,
+          last_recalled_at DATETIME,
+          created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            database.exec(`
+        INSERT INTO mem_decisions (
+          id, scope_id, entity_id, title, rationale, decided_at, source, tier, superseded_by, archived_at, created_at
+        )
+        SELECT id, scope_id, entity_id, title, rationale, decided_at, NULL, ${memoryTierCase()}, superseded_by, archived_at, created_at
+        FROM mem_decisions_legacy_tier
+      `);
+            database.exec(`DROP TABLE mem_decisions_legacy_tier`);
+        })();
+    }
+    finally {
+        database.pragma("foreign_keys = ON");
+    }
+}
+function ensureMemoryTierColumns(database) {
+    for (const table of ["mem_entities", "mem_observations", "mem_decisions", "mem_action_items"]) {
+        if (!hasColumn(database, table, "tier")) {
+            database.exec(`ALTER TABLE ${table} ADD COLUMN tier TEXT DEFAULT 'warm'`);
+        }
+        if (!hasColumn(database, table, "tier_pinned_at")) {
+            database.exec(`ALTER TABLE ${table} ADD COLUMN tier_pinned_at DATETIME`);
+        }
+        if (!hasColumn(database, table, "tier_reason")) {
+            database.exec(`ALTER TABLE ${table} ADD COLUMN tier_reason TEXT`);
+        }
+        if (!hasColumn(database, table, "last_recalled_at")) {
+            database.exec(`ALTER TABLE ${table} ADD COLUMN last_recalled_at DATETIME`);
+        }
+    }
+    database.exec(`
+    UPDATE mem_entities
+    SET tier = CASE
+      WHEN tier = 'glacier' THEN 'cold'
+      WHEN tier IN ('hot', 'warm', 'cold') THEN tier
+      WHEN confidence > 0.7 AND datetime(updated_at) >= datetime('now', '-30 days') THEN 'hot'
+      ELSE 'warm'
+    END
+  `);
+    database.exec(`
+    UPDATE mem_observations
+    SET tier = CASE
+      WHEN archived_at IS NOT NULL OR superseded_by IS NOT NULL THEN 'cold'
+      WHEN tier = 'glacier' THEN 'cold'
+      WHEN tier IN ('hot', 'warm', 'cold') THEN tier
+      WHEN confidence > 0.7 AND datetime(created_at) >= datetime('now', '-30 days') THEN 'hot'
+      ELSE 'warm'
+    END
+  `);
+    database.exec(`
+    UPDATE mem_decisions
+    SET tier = CASE
+      WHEN archived_at IS NOT NULL OR superseded_by IS NOT NULL THEN 'cold'
+      WHEN tier = 'glacier' THEN 'cold'
+      WHEN tier IN ('hot', 'warm', 'cold') THEN tier
+      WHEN datetime(COALESCE(decided_at, created_at)) >= datetime('now', '-30 days') THEN 'hot'
+      ELSE 'warm'
+    END
+  `);
+    database.exec(`
+    UPDATE mem_action_items
+    SET tier = CASE
+      WHEN status IN ('done', 'dropped') THEN 'cold'
+      WHEN tier = 'glacier' THEN 'cold'
+      WHEN tier IN ('hot', 'warm', 'cold') THEN tier
+      WHEN status = 'open' AND due_at IS NOT NULL AND datetime(due_at) <= datetime('now', '+7 days') THEN 'hot'
+      ELSE 'warm'
+    END
+  `);
+}
+function ensureMemoryIndexes(database) {
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_entities_scope_kind_idx ON mem_entities(scope_id, kind)`);
+    database.exec(`CREATE UNIQUE INDEX IF NOT EXISTS mem_entities_scope_kind_name_idx ON mem_entities(scope_id, kind, name)`);
+    database.exec(`CREATE UNIQUE INDEX IF NOT EXISTS mem_entities_scope_slug_idx ON mem_entities(scope_id, slug) WHERE slug IS NOT NULL`);
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_observations_scope_idx ON mem_observations(scope_id)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_observations_scope_superseded_by_idx ON mem_observations(scope_id, superseded_by)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_decisions_scope_idx ON mem_decisions(scope_id)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS mem_decisions_scope_superseded_by_idx ON mem_decisions(scope_id, superseded_by)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS idx_mem_action_items_scope_status ON mem_action_items(scope_id, status)`);
+    database.exec(`CREATE INDEX IF NOT EXISTS idx_mem_action_items_due ON mem_action_items(status, due_at)`);
+}
+export const DB_MIGRATIONS = [
+    { version: 1, name: "conversation-log-agent-completion-role", up: migrateConversationLogAgentCompletionRole },
+    { version: 2, name: "copilot-sessions-agent-mode", up: migrateCopilotSessionsAgentMode },
+    { version: 3, name: "conversation-log-metadata-columns", up: migrateConversationLogMetadataColumns },
+    { version: 4, name: "agent-tasks-session-source-prompt", up: migrateAgentTaskColumns },
+    { version: 5, name: "agent-task-events-text-status", up: migrateAgentTaskEventsTextStatus },
+    { version: 6, name: "agent-tasks-event-seq", up: migrateAgentTasksEventSeq },
+    { version: 7, name: "memory-entity-slug", up: migrateMemoryEntitySlug },
+    { version: 8, name: "wiki-sources-status-session", up: migrateWikiSourceColumns },
+    { version: 9, name: "memory-decisions-source-archive", up: migrateMemoryDecisionColumns },
+    { version: 10, name: "memory-tier-and-action-item-schema", up: migrateMemoryTierAndActionItems },
+];
+function ensureMigrationsTable(database) {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS __db_migrations (
+      version INTEGER PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      applied_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+}
+function hasMigration(database, migration) {
+    const row = database.prepare(`SELECT version FROM __db_migrations WHERE version = ?`).get(migration.version);
+    return row !== undefined;
+}
+function recordMigration(database, migration) {
+    database.prepare(`
+    INSERT OR IGNORE INTO __db_migrations (version, name)
+    VALUES (?, ?)
+  `).run(migration.version, migration.name);
+}
+export function applyMigrations(database, throughVersion = Number.POSITIVE_INFINITY) {
+    ensureMigrationsTable(database);
+    for (const migration of DB_MIGRATIONS) {
+        if (migration.version > throughVersion) {
+            continue;
+        }
+        if (hasMigration(database, migration)) {
+            continue;
+        }
+        migration.up(database);
+        recordMigration(database, migration);
+    }
+}
+function migrateConversationLogAgentCompletionRole(database) {
+    try {
+        database.prepare(`INSERT INTO conversation_log (role, content, source) VALUES ('agent_completion', '__migration_test__', 'test')`).run();
+        database.prepare(`DELETE FROM conversation_log WHERE content = '__migration_test__'`).run();
+    }
+    catch {
+        database.exec(`ALTER TABLE conversation_log RENAME TO conversation_log_old`);
+        const oldConvCols = database.prepare(`PRAGMA table_info(conversation_log_old)`).all();
+        const oldConvColNames = new Set(oldConvCols.map((column) => column.name));
+        const sessionKeySelect = oldConvColNames.has("session_key") ? "session_key" : "'default'";
+        const turnIdSelect = oldConvColNames.has("turn_id") ? "turn_id" : "NULL";
+        const agentSlugSelect = oldConvColNames.has("agent_slug") ? "agent_slug" : "NULL";
+        const agentDisplayNameSelect = oldConvColNames.has("agent_display_name") ? "agent_display_name" : "NULL";
+        const runIdSelect = oldConvColNames.has("run_id") ? "run_id" : "NULL";
+        database.exec(`
+      CREATE TABLE conversation_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system', 'agent_completion')),
+        content TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'unknown',
+        session_key TEXT NOT NULL DEFAULT 'default',
+        turn_id TEXT,
+        agent_slug TEXT,
+        agent_display_name TEXT,
+        run_id TEXT,
+        ts DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        database.exec(`
+      INSERT INTO conversation_log (role, content, source, session_key, turn_id, agent_slug, agent_display_name, run_id, ts)
+      SELECT role, content, source, ${sessionKeySelect}, ${turnIdSelect}, ${agentSlugSelect}, ${agentDisplayNameSelect}, ${runIdSelect}, ts FROM conversation_log_old
+    `);
+        database.exec(`DROP TABLE conversation_log_old`);
+    }
+}
+function migrateCopilotSessionsAgentMode(database) {
+    try {
+        database.prepare(`
+      INSERT INTO copilot_sessions (session_key, mode, copilot_session_id)
+      VALUES ('__mode_probe__', 'agent', '__probe__')
+    `).run();
+        database.prepare(`DELETE FROM copilot_sessions WHERE session_key = '__mode_probe__'`).run();
+    }
+    catch {
+        database.exec(`ALTER TABLE copilot_sessions RENAME TO copilot_sessions_old`);
+        database.exec(`
+      CREATE TABLE copilot_sessions (
+        session_key TEXT PRIMARY KEY,
+        mode TEXT NOT NULL CHECK(mode IN ('default', 'project', 'agent')),
+        project_root TEXT,
+        copilot_session_id TEXT NOT NULL,
+        model TEXT,
+        updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        database.exec(`
+      INSERT INTO copilot_sessions (session_key, mode, project_root, copilot_session_id, model, updated_at)
+      SELECT session_key, mode, project_root, copilot_session_id, model, updated_at
+      FROM copilot_sessions_old
+    `);
+        database.exec(`DROP TABLE copilot_sessions_old`);
+    }
+}
+function migrateConversationLogMetadataColumns(database) {
+    const convCols = database.prepare(`PRAGMA table_info(conversation_log)`).all();
+    if (!convCols.some((c) => c.name === 'session_key')) {
+        database.exec(`ALTER TABLE conversation_log ADD COLUMN session_key TEXT NOT NULL DEFAULT 'default'`);
+    }
+    if (!convCols.some((c) => c.name === 'turn_id')) {
+        database.exec(`ALTER TABLE conversation_log ADD COLUMN turn_id TEXT`);
+    }
+    if (!convCols.some((c) => c.name === 'agent_slug')) {
+        database.exec(`ALTER TABLE conversation_log ADD COLUMN agent_slug TEXT`);
+    }
+    if (!convCols.some((c) => c.name === 'agent_display_name')) {
+        database.exec(`ALTER TABLE conversation_log ADD COLUMN agent_display_name TEXT`);
+    }
+    if (!convCols.some((c) => c.name === "run_id")) {
+        database.exec(`ALTER TABLE conversation_log ADD COLUMN run_id TEXT`);
+    }
+    database.exec(`CREATE INDEX IF NOT EXISTS idx_conversation_log_session_run ON conversation_log(session_key, run_id, id)`);
+}
+function migrateAgentTaskColumns(database) {
+    const taskCols = database.prepare(`PRAGMA table_info(agent_tasks)`).all();
+    if (!taskCols.some((c) => c.name === 'session_key')) {
+        database.exec(`ALTER TABLE agent_tasks ADD COLUMN session_key TEXT NOT NULL DEFAULT 'default'`);
+    }
+    if (!taskCols.some((c) => c.name === 'source')) {
+        database.exec(`ALTER TABLE agent_tasks ADD COLUMN source TEXT NOT NULL DEFAULT 'adhoc'`);
+    }
+    if (!taskCols.some((c) => c.name === "prompt")) {
+        database.exec(`ALTER TABLE agent_tasks ADD COLUMN prompt TEXT`);
+    }
+}
+function migrateAgentTaskEventsTextStatus(database) {
+    const taskEventCols = database.prepare(`PRAGMA table_info(agent_task_events)`).all();
+    if (!taskEventCols.some((c) => c.name === "text") || !taskEventCols.some((c) => c.name === "status")) {
+        database.exec(`ALTER TABLE agent_task_events RENAME TO agent_task_events_old`);
+        database.exec(`
+      CREATE TABLE agent_task_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL REFERENCES agent_tasks(task_id) ON DELETE CASCADE,
+        seq INTEGER NOT NULL,
+        ts INTEGER NOT NULL,
+        kind TEXT NOT NULL CHECK(kind IN ('tool_start', 'tool_complete', 'output_delta', 'task_status')),
+        tool_name TEXT,
+        summary TEXT,
+        text TEXT,
+        status TEXT
+      )
+    `);
+        database.exec(`
+      INSERT INTO agent_task_events (id, task_id, seq, ts, kind, tool_name, summary)
+      SELECT id, task_id, seq, ts, kind, tool_name, summary FROM agent_task_events_old
+    `);
+        database.exec(`DROP TABLE agent_task_events_old`);
+        database.exec(`CREATE INDEX IF NOT EXISTS idx_agent_task_events_task_id ON agent_task_events(task_id, seq)`);
+    }
+}
+function migrateAgentTasksEventSeq(database) {
+    const taskColsNow = database.prepare(`PRAGMA table_info(agent_tasks)`).all();
+    if (!taskColsNow.some((c) => c.name === 'event_seq')) {
+        database.exec(`ALTER TABLE agent_tasks ADD COLUMN event_seq INTEGER NOT NULL DEFAULT 0`);
+    }
+}
+function migrateMemoryEntitySlug(database) {
+    const entityCols = database.prepare(`PRAGMA table_info(mem_entities)`).all();
+    if (!entityCols.some((column) => column.name === "slug")) {
+        database.exec(`ALTER TABLE mem_entities ADD COLUMN slug TEXT`);
+    }
+    database.exec(`
+    DELETE FROM mem_entities
+    WHERE id NOT IN (
+      SELECT MIN(id)
+      FROM mem_entities
+      GROUP BY scope_id, kind, name
+    )
+  `);
+    database.exec(`CREATE UNIQUE INDEX IF NOT EXISTS mem_entities_scope_kind_name_idx ON mem_entities(scope_id, kind, name)`);
+    database.exec(`CREATE UNIQUE INDEX IF NOT EXISTS mem_entities_scope_slug_idx ON mem_entities(scope_id, slug) WHERE slug IS NOT NULL`);
+}
+function migrateWikiSourceColumns(database) {
+    const wikiSourceCols = database.prepare(`PRAGMA table_info(wiki_sources)`).all();
+    if (!wikiSourceCols.some((column) => column.name === "status")) {
+        database.exec(`ALTER TABLE wiki_sources ADD COLUMN status TEXT NOT NULL DEFAULT 'active'`);
+    }
+    if (!wikiSourceCols.some((column) => column.name === "session_id")) {
+        database.exec(`ALTER TABLE wiki_sources ADD COLUMN session_id TEXT`);
+    }
+    if (!wikiSourceCols.some((column) => column.name === "session_name")) {
+        database.exec(`ALTER TABLE wiki_sources ADD COLUMN session_name TEXT`);
+    }
+}
+function migrateMemoryDecisionColumns(database) {
+    const decisionCols = database.prepare(`PRAGMA table_info(mem_decisions)`).all();
+    if (!decisionCols.some((column) => column.name === "superseded_by")) {
+        database.exec(`ALTER TABLE mem_decisions ADD COLUMN superseded_by INTEGER REFERENCES mem_decisions(id) ON DELETE SET NULL`);
+    }
+    if (!decisionCols.some((column) => column.name === "archived_at")) {
+        database.exec(`ALTER TABLE mem_decisions ADD COLUMN archived_at DATETIME`);
+    }
+    if (!decisionCols.some((column) => column.name === "source")) {
+        database.exec(`ALTER TABLE mem_decisions ADD COLUMN source TEXT`);
+    }
+}
+function migrateMemoryTierAndActionItems(database) {
+    rebuildMemoryTierTables(database);
+    ensureMemoryTierColumns(database);
+    migrateMemActionItemsCreatedAtType(database);
+    ensureMemoryIndexes(database);
+}
+//# sourceMappingURL=migrations.js.map