teleton 0.8.4 → 0.8.6

package/dist/chunk-OMQIAWEU.js

@@ -0,0 +1,273 @@
+import {
+  hashText,
+  serializeEmbedding
+} from "./chunk-Z5WY7BSB.js";
+import {
+  KNOWLEDGE_CHUNK_SIZE
+} from "./chunk-J4WDJ7XS.js";
+
+// src/memory/agent/knowledge.ts
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+var _instance = null;
+function setKnowledgeIndexer(indexer) {
+  _instance = indexer;
+}
+function getKnowledgeIndexer() {
+  return _instance;
+}
+var KnowledgeIndexer = class {
+  constructor(db, workspaceDir, embedder, vectorEnabled) {
+    this.db = db;
+    this.workspaceDir = workspaceDir;
+    this.embedder = embedder;
+    this.vectorEnabled = vectorEnabled;
+  }
+  getEmbedder() {
+    return this.embedder;
+  }
+  async indexAll(options) {
+    const files = this.listMemoryFiles();
+    let indexed = 0;
+    let skipped = 0;
+    for (const file of files) {
+      const wasIndexed = await this.indexFile(file, options?.force);
+      if (wasIndexed) {
+        indexed++;
+      } else {
+        skipped++;
+      }
+    }
+    return { indexed, skipped };
+  }
+  async indexFile(absPath, force) {
+    if (!existsSync(absPath) || !absPath.endsWith(".md")) {
+      return false;
+    }
+    const content = readFileSync(absPath, "utf-8");
+    const relPath = absPath.replace(this.workspaceDir + "/", "");
+    const fileHash = hashText(content);
+    if (!force) {
+      const existing = this.db.prepare(`SELECT hash FROM knowledge WHERE path = ? AND source = 'memory' LIMIT 1`).get(relPath);
+      if (existing?.hash === fileHash) {
+        return false;
+      }
+    }
+    const chunks = this.chunkMarkdown(content, relPath);
+    const texts = chunks.map((c) => c.text);
+    const embeddings = await this.embedder.embedBatch(texts);
+    const chunksToInsert = [];
+    const idsToSupersede = [];
+    if (this.vectorEnabled) {
+      const vecQuery = this.db.prepare(`
+        SELECT kv.id, kv.distance
+        FROM (
+          SELECT id, distance
+          FROM knowledge_vec
+          WHERE embedding MATCH ? AND k = 5
+        ) kv
+        JOIN knowledge k ON k.id = kv.id
+        WHERE k.path != ? AND (k.status = 'active' OR k.status IS NULL)
+        ORDER BY kv.distance
+      `);
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        const embedding = embeddings[i] ?? [];
+        if (embedding.length === 0) {
+          chunksToInsert.push({ chunk, embedding });
+          continue;
+        }
+        let skip = false;
+        try {
+          const similar = vecQuery.all(serializeEmbedding(embedding), relPath);
+          const exactDup = similar.find((r) => r.distance < 0.1);
+          if (exactDup) {
+            skip = true;
+          } else {
+            const nearDup = similar.find((r) => r.distance < 0.15);
+            if (nearDup) {
+              idsToSupersede.push(nearDup.id);
+            }
+          }
+        } catch {
+        }
+        if (!skip) {
+          chunksToInsert.push({ chunk, embedding });
+        }
+      }
+    } else {
+      for (let i = 0; i < chunks.length; i++) {
+        chunksToInsert.push({ chunk: chunks[i], embedding: embeddings[i] ?? [] });
+      }
+    }
+    this.db.transaction(() => {
+      if (this.vectorEnabled) {
+        this.db.prepare(
+          `DELETE FROM knowledge_vec WHERE id IN (
+              SELECT id FROM knowledge WHERE path = ? AND source = 'memory'
+            )`
+        ).run(relPath);
+      }
+      this.db.prepare(`DELETE FROM knowledge WHERE path = ? AND source = 'memory'`).run(relPath);
+      if (idsToSupersede.length > 0) {
+        const placeholders = idsToSupersede.map(() => "?").join(", ");
+        this.db.prepare(
+          `UPDATE knowledge SET status = 'superseded', updated_at = unixepoch() WHERE id IN (${placeholders})`
+        ).run(...idsToSupersede);
+      }
+      const insert = this.db.prepare(`
+        INSERT INTO knowledge (id, source, path, text, embedding, start_line, end_line, hash, status, memory_type)
+        VALUES (?, 'memory', ?, ?, ?, ?, ?, ?, 'active', ?)
+      `);
+      const insertVec = this.vectorEnabled ? this.db.prepare(`INSERT INTO knowledge_vec (id, embedding) VALUES (?, ?)`) : null;
+      const memoryType = this.getMemoryType(relPath);
+      for (const { chunk, embedding } of chunksToInsert) {
+        insert.run(
+          chunk.id,
+          chunk.path,
+          chunk.text,
+          serializeEmbedding(embedding),
+          chunk.startLine,
+          chunk.endLine,
+          fileHash,
+          memoryType
+        );
+        if (insertVec && embedding.length > 0) {
+          insertVec.run(chunk.id, serializeEmbedding(embedding));
+        }
+      }
+    })();
+    return true;
+  }
+  async pruneOrphans() {
+    const paths = this.db.prepare(
+      `SELECT DISTINCT path FROM knowledge WHERE path IS NOT NULL AND source = 'memory'
+         AND (status = 'active' OR status IS NULL)`
+    ).all();
+    let markedInactive = 0;
+    const orphanedPaths = [];
+    for (const { path } of paths) {
+      const absPath = join(this.workspaceDir, path);
+      const archivedPath = join(
+        this.workspaceDir,
+        "memory",
+        "archived",
+        path.replace(/^memory\//, "")
+      );
+      if (!existsSync(absPath) && !existsSync(archivedPath)) {
+        orphanedPaths.push(path);
+      }
+    }
+    if (orphanedPaths.length > 0) {
+      const ph = orphanedPaths.map(() => "?").join(", ");
+      const result = this.db.prepare(
+        `UPDATE knowledge SET status = 'inactive', updated_at = unixepoch()
+           WHERE path IN (${ph}) AND source = 'memory'`
+      ).run(...orphanedPaths);
+      markedInactive = result.changes;
+    }
+    const staleIds = this.db.prepare(
+      `SELECT id FROM knowledge WHERE status = 'inactive' AND updated_at < unixepoch() - ?`
+    ).all(30 * 86400);
+    let deleted = 0;
+    if (staleIds.length > 0) {
+      const ids = staleIds.map((r) => r.id);
+      const placeholders = ids.map(() => "?").join(", ");
+      this.db.transaction(() => {
+        if (this.vectorEnabled) {
+          this.db.prepare(`DELETE FROM knowledge_vec WHERE id IN (${placeholders})`).run(...ids);
+        }
+        this.db.prepare(`DELETE FROM knowledge WHERE id IN (${placeholders})`).run(...ids);
+      })();
+      deleted = ids.length;
+    }
+    return { markedInactive, deleted };
+  }
+  listMemoryFiles() {
+    const files = [];
+    const memoryMd = join(this.workspaceDir, "MEMORY.md");
+    if (existsSync(memoryMd)) {
+      files.push(memoryMd);
+    }
+    const memoryDir = join(this.workspaceDir, "memory");
+    if (existsSync(memoryDir)) {
+      const entries = readdirSync(memoryDir);
+      for (const entry of entries) {
+        const absPath = join(memoryDir, entry);
+        if (statSync(absPath).isFile() && entry.endsWith(".md")) {
+          files.push(absPath);
+        }
+      }
+    }
+    return files;
+  }
+  getMemoryType(relPath) {
+    if (relPath === "MEMORY.md") return "procedural";
+    if (/^memory\/(\d{4}-\d{2}-\d{2}|consolidated-)/.test(relPath)) return "episodic";
+    return "semantic";
+  }
+  /**
+   * Chunk markdown content with structure awareness.
+   * Respects heading boundaries, code blocks, and list groups.
+   * Target: KNOWLEDGE_CHUNK_SIZE chars, hard max: 2x target.
+   */
+  chunkMarkdown(content, path) {
+    const lines = content.split("\n");
+    const chunks = [];
+    const targetSize = KNOWLEDGE_CHUNK_SIZE;
+    const hardMax = targetSize * 2;
+    let currentChunk = "";
+    let startLine = 1;
+    let currentLine = 1;
+    let inCodeBlock = false;
+    let overlapPrefix = "";
+    const flushChunk = () => {
+      const text = currentChunk.trim();
+      if (text.length > 0) {
+        chunks.push({
+          id: hashText(`${path}:${startLine}:${currentLine - 1}`),
+          source: "memory",
+          path,
+          text,
+          startLine,
+          endLine: currentLine - 1,
+          hash: hashText(text)
+        });
+        const nonEmpty = text.split("\n").filter((l) => l.trim());
+        overlapPrefix = nonEmpty.length > 0 ? nonEmpty.slice(-2).join("\n") + "\n" : "";
+      }
+      currentChunk = overlapPrefix;
+      startLine = currentLine;
+    };
+    for (const line of lines) {
+      if (line.trimStart().startsWith("```")) {
+        inCodeBlock = !inCodeBlock;
+      }
+      if (!inCodeBlock && currentChunk.length >= targetSize) {
+        const isHeading = /^#{1,6}\s/.test(line);
+        const isBlankLine = line.trim() === "";
+        const isHorizontalRule = /^(-{3,}|\*{3,}|_{3,})\s*$/.test(line.trim());
+        if (isHeading) {
+          flushChunk();
+        } else if ((isBlankLine || isHorizontalRule) && currentChunk.length >= targetSize) {
+          currentChunk += line + "\n";
+          currentLine++;
+          flushChunk();
+          continue;
+        } else if (currentChunk.length >= hardMax) {
+          flushChunk();
+        }
+      }
+      currentChunk += line + "\n";
+      currentLine++;
+    }
+    flushChunk();
+    return chunks;
+  }
+};
+
+export {
+  setKnowledgeIndexer,
+  getKnowledgeIndexer,
+  KnowledgeIndexer
+};

package/dist/chunk-PCT7GYBP.js

@@ -0,0 +1,274 @@
+import {
+  ALLOWED_EXTENSIONS,
+  WORKSPACE_PATHS,
+  WORKSPACE_ROOT
+} from "./chunk-L653KKCR.js";
+import {
+  createLogger
+} from "./chunk-V3S3NXBQ.js";
+
+// src/memory/daily-logs.ts
+import { existsSync as existsSync2, mkdirSync, appendFileSync, readFileSync, readdirSync as readdirSync2, unlinkSync } from "fs";
+import { join } from "path";
+
+// src/workspace/validator.ts
+import { existsSync, lstatSync, readdirSync } from "fs";
+import { resolve, normalize, relative, extname, basename } from "path";
+import { homedir } from "os";
+var WorkspaceSecurityError = class extends Error {
+  constructor(message, attemptedPath) {
+    super(message);
+    this.attemptedPath = attemptedPath;
+    this.name = "WorkspaceSecurityError";
+  }
+};
+function decodeRecursive(str) {
+  let decoded = str;
+  let prev = "";
+  let iterations = 0;
+  const maxIterations = 10;
+  while (decoded !== prev && iterations < maxIterations) {
+    prev = decoded;
+    try {
+      decoded = decodeURIComponent(decoded);
+    } catch {
+      break;
+    }
+    iterations++;
+  }
+  return decoded;
+}
+function validatePath(inputPath, allowCreate = false) {
+  if (!inputPath || inputPath.trim() === "") {
+    throw new WorkspaceSecurityError("Path cannot be empty.", inputPath);
+  }
+  const trimmedPath = inputPath.trim().replace(/\\/g, "/");
+  const decodedPath = decodeRecursive(trimmedPath);
+  let absolutePath;
+  if (decodedPath.startsWith("/")) {
+    absolutePath = resolve(normalize(decodedPath));
+  } else if (decodedPath.startsWith("~/")) {
+    const expanded = decodedPath.replace(/^~(?=$|[\\/])/, homedir());
+    absolutePath = resolve(expanded);
+  } else {
+    absolutePath = resolve(WORKSPACE_ROOT, normalize(decodedPath));
+  }
+  const relativePath = relative(WORKSPACE_ROOT, absolutePath);
+  if (relativePath.startsWith("..") || relativePath.startsWith("/")) {
+    throw new WorkspaceSecurityError(
+      `Access denied: Path '${inputPath}' is outside the workspace. Only files in ~/.teleton/workspace/ are accessible.`,
+      inputPath
+    );
+  }
+  const exists = existsSync(absolutePath);
+  if (!exists && !allowCreate) {
+    throw new WorkspaceSecurityError(
+      `File not found: '${inputPath}' does not exist in workspace.`,
+      inputPath
+    );
+  }
+  if (exists) {
+    const stats = lstatSync(absolutePath);
+    if (stats.isSymbolicLink()) {
+      throw new WorkspaceSecurityError(
+        `Access denied: Symbolic links are not allowed for security reasons.`,
+        inputPath
+      );
+    }
+  }
+  return {
+    absolutePath,
+    relativePath,
+    exists,
+    isDirectory: exists ? lstatSync(absolutePath).isDirectory() : false,
+    extension: extname(absolutePath).toLowerCase(),
+    filename: basename(absolutePath)
+  };
+}
+function validateReadPath(inputPath) {
+  const validated = validatePath(inputPath, false);
+  if (validated.isDirectory) {
+    throw new WorkspaceSecurityError(`Cannot read directory as file: '${inputPath}'`, inputPath);
+  }
+  return validated;
+}
+var IMMUTABLE_FILES = ["SOUL.md", "STRATEGY.md", "SECURITY.md"];
+function validateWritePath(inputPath, fileType) {
+  const validated = validatePath(inputPath, true);
+  if (IMMUTABLE_FILES.includes(validated.filename)) {
+    throw new WorkspaceSecurityError(
+      `Cannot write to ${validated.filename}. This file is configured by the owner. Use memory_write instead.`,
+      inputPath
+    );
+  }
+  if (fileType && ALLOWED_EXTENSIONS[fileType]) {
+    const allowedExts = ALLOWED_EXTENSIONS[fileType];
+    if (!allowedExts.includes(validated.extension)) {
+      throw new WorkspaceSecurityError(
+        `Invalid file type: '${validated.extension}' is not allowed for ${fileType}. Allowed: ${allowedExts.join(", ")}`,
+        inputPath
+      );
+    }
+  }
+  return validated;
+}
+function validateDirectory(inputPath) {
+  const validated = validatePath(inputPath, true);
+  if (validated.exists && !validated.isDirectory) {
+    throw new WorkspaceSecurityError(
+      `Path exists but is not a directory: '${inputPath}'`,
+      inputPath
+    );
+  }
+  return validated;
+}
+
+// src/memory/daily-logs.ts
+var log = createLogger("Memory");
+var MEMORY_DIR = WORKSPACE_PATHS.MEMORY_DIR;
+function formatDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function getDailyLogPath(date = /* @__PURE__ */ new Date()) {
+  return join(MEMORY_DIR, `${formatDate(date)}.md`);
+}
+function ensureMemoryDir() {
+  if (!existsSync2(MEMORY_DIR)) {
+    mkdirSync(MEMORY_DIR, { recursive: true });
+  }
+}
+function appendToDailyLog(content, date = /* @__PURE__ */ new Date()) {
+  try {
+    ensureMemoryDir();
+    const logPath = getDailyLogPath(date);
+    const timestamp = date.toLocaleTimeString("en-US", { hour12: false });
+    if (!existsSync2(logPath)) {
+      const header = `# Daily Log - ${formatDate(date)}
+
+`;
+      appendFileSync(logPath, header, { encoding: "utf-8", mode: 384 });
+    }
+    const entry = `## ${timestamp}
+
+${content}
+
+---
+
+`;
+    appendFileSync(logPath, entry, "utf-8");
+    log.info(`Daily log updated: ${logPath}`);
+  } catch (error) {
+    log.error({ err: error }, "Failed to write daily log");
+  }
+}
+function readDailyLog(date = /* @__PURE__ */ new Date()) {
+  try {
+    const logPath = getDailyLogPath(date);
+    if (!existsSync2(logPath)) return null;
+    return readFileSync(logPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+var DAILY_LOG_LINE_LIMIT = 100;
+function truncateDailyLog(content) {
+  const lines = content.split("\n");
+  if (lines.length <= DAILY_LOG_LINE_LIMIT) return content;
+  const truncated = lines.slice(-DAILY_LOG_LINE_LIMIT).join("\n");
+  const dropped = lines.length - DAILY_LOG_LINE_LIMIT;
+  return `_[... ${dropped} earlier lines omitted]_
+
+${truncated}`;
+}
+function readRecentMemory() {
+  const today = /* @__PURE__ */ new Date();
+  const yesterday = new Date(today);
+  yesterday.setDate(yesterday.getDate() - 1);
+  const parts = [];
+  const yesterdayLog = readDailyLog(yesterday);
+  if (yesterdayLog) {
+    parts.push(`## Yesterday (${formatDate(yesterday)})
+
+${truncateDailyLog(yesterdayLog)}`);
+  }
+  const todayLog = readDailyLog(today);
+  if (todayLog) {
+    parts.push(`## Today (${formatDate(today)})
+
+${truncateDailyLog(todayLog)}`);
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return `# Recent Memory
+
+${parts.join("\n\n---\n\n")}`;
+}
+function writeSessionEndSummary(summary, reason) {
+  const content = `### Session End (${reason})
+
+${summary}`;
+  appendToDailyLog(content);
+}
+function writeSummaryToDailyLog(summary) {
+  appendToDailyLog(`### Memory Flush (Pre-Compaction)
+
+${summary}`);
+}
+function cleanupOldDailyLogs(maxAgeDays = 60) {
+  if (!existsSync2(MEMORY_DIR)) return 0;
+  const cutoffMs = Date.now() - maxAgeDays * 864e5;
+  const datePattern = /^(\d{4}-\d{2}-\d{2})\.md$/;
+  let deleted = 0;
+  try {
+    const files = readdirSync2(MEMORY_DIR);
+    for (const file of files) {
+      const match = datePattern.exec(file);
+      if (!match) continue;
+      const fileDate = new Date(match[1]).getTime();
+      if (Number.isNaN(fileDate)) continue;
+      if (fileDate < cutoffMs) {
+        try {
+          unlinkSync(join(MEMORY_DIR, file));
+          deleted++;
+        } catch (innerError) {
+          log.warn({ err: innerError, file }, "Failed to delete old daily log");
+        }
+      }
+    }
+  } catch (error) {
+    log.error({ err: error }, "Failed to list memory directory for cleanup");
+  }
+  if (deleted > 0) {
+    log.info(`Cleaned up ${deleted} daily log file(s) older than ${maxAgeDays} days`);
+  }
+  return deleted;
+}
+function writeConversationMilestone(chatId, topic, details) {
+  const content = `### Conversation Milestone
+
+**Chat**: ${chatId}
+**Topic**: ${topic}
+
+${details}`;
+  appendToDailyLog(content);
+}
+
+export {
+  WorkspaceSecurityError,
+  validatePath,
+  validateReadPath,
+  validateWritePath,
+  validateDirectory,
+  getDailyLogPath,
+  appendToDailyLog,
+  readDailyLog,
+  readRecentMemory,
+  writeSessionEndSummary,
+  writeSummaryToDailyLog,
+  cleanupOldDailyLogs,
+  writeConversationMilestone
+};

package/dist/chunk-QYZBWU2D.js

@@ -0,0 +1,139 @@
+import {
+  TELETON_ROOT
+} from "./chunk-L653KKCR.js";
+import {
+  createLogger
+} from "./chunk-V3S3NXBQ.js";
+
+// src/utils/module-db.ts
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync, chmodSync } from "fs";
+import { dirname, join } from "path";
+var log = createLogger("Utils");
+var JOURNAL_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS journal (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
+    type TEXT NOT NULL CHECK(type IN ('trade', 'gift', 'middleman', 'kol')),
+    action TEXT NOT NULL,
+    asset_from TEXT,
+    asset_to TEXT,
+    amount_from REAL,
+    amount_to REAL,
+    price_ton REAL,
+    counterparty TEXT,
+    platform TEXT,
+    reasoning TEXT,
+    outcome TEXT CHECK(outcome IN ('pending', 'profit', 'loss', 'neutral', 'cancelled')),
+    pnl_ton REAL,
+    pnl_pct REAL,
+    tx_hash TEXT,
+    tool_used TEXT,
+    chat_id TEXT,
+    user_id INTEGER,
+    closed_at INTEGER,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_journal_type ON journal(type);
+  CREATE INDEX IF NOT EXISTS idx_journal_timestamp ON journal(timestamp DESC);
+  CREATE INDEX IF NOT EXISTS idx_journal_asset_from ON journal(asset_from);
+  CREATE INDEX IF NOT EXISTS idx_journal_outcome ON journal(outcome);
+  CREATE INDEX IF NOT EXISTS idx_journal_type_timestamp ON journal(type, timestamp DESC);
+`;
+var USED_TRANSACTIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS used_transactions (
+    tx_hash TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    amount REAL NOT NULL,
+    game_type TEXT NOT NULL,
+    used_at INTEGER NOT NULL DEFAULT (unixepoch())
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_used_tx_user ON used_transactions(user_id);
+  CREATE INDEX IF NOT EXISTS idx_used_tx_used_at ON used_transactions(used_at);
+`;
+function openModuleDb(path) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const db = new Database(path);
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+  db.pragma("journal_mode = WAL");
+  return db;
+}
+function createDbWrapper(getDb, moduleName) {
+  return function withDb(executor) {
+    return (params, context) => {
+      const moduleDb = getDb();
+      if (!moduleDb) {
+        return Promise.resolve({
+          success: false,
+          error: `${moduleName} module not started`
+        });
+      }
+      return executor(params, { ...context, db: moduleDb });
+    };
+  };
+}
+var MAIN_DB_PATH = join(TELETON_ROOT, "memory.db");
+function migrateFromMainDb(moduleDb, tables) {
+  let totalMigrated = 0;
+  for (const table of tables) {
+    if (!/^[a-z_]+$/.test(table)) {
+      throw new Error(`Invalid table name for migration: "${table}"`);
+    }
+  }
+  for (const table of tables) {
+    try {
+      const row = moduleDb.prepare(`SELECT COUNT(*) as c FROM ${table}`).get();
+      if (row.c > 0) return 0;
+    } catch {
+      continue;
+    }
+  }
+  if (!existsSync(MAIN_DB_PATH)) return 0;
+  try {
+    moduleDb.exec(`ATTACH DATABASE '${MAIN_DB_PATH}' AS main_db`);
+    for (const table of tables) {
+      try {
+        const exists = moduleDb.prepare(`SELECT name FROM main_db.sqlite_master WHERE type='table' AND name=?`).get(table);
+        if (!exists) continue;
+        const src = moduleDb.prepare(`SELECT COUNT(*) as c FROM main_db.${table}`).get();
+        if (src.c === 0) continue;
+        const dstCols = moduleDb.prepare(`PRAGMA table_info(${table})`).all().map((r) => r.name);
+        const srcCols = moduleDb.prepare(`PRAGMA main_db.table_info(${table})`).all().map((r) => r.name);
+        const shared = dstCols.filter((c) => srcCols.includes(c));
+        if (shared.length === 0) continue;
+        const cols = shared.join(", ");
+        moduleDb.exec(
+          `INSERT OR IGNORE INTO ${table} (${cols}) SELECT ${cols} FROM main_db.${table}`
+        );
+        totalMigrated += src.c;
+        log.info(`Migrated ${src.c} rows from memory.db \u2192 ${table}`);
+      } catch (innerError) {
+        log.warn({ err: innerError }, `Could not migrate table ${table}`);
+      }
+    }
+    moduleDb.exec(`DETACH DATABASE main_db`);
+  } catch (error) {
+    log.warn({ err: error }, `Migration from memory.db failed`);
+    try {
+      moduleDb.exec(`DETACH DATABASE main_db`);
+    } catch {
+    }
+  }
+  return totalMigrated;
+}
+
+export {
+  JOURNAL_SCHEMA,
+  USED_TRANSACTIONS_SCHEMA,
+  openModuleDb,
+  createDbWrapper,
+  migrateFromMainDb
+};