@chainlesschain/personal-data-hub 0.1.0

package/lib/kg-derive.js

@@ -0,0 +1,214 @@
+/**
+ * UnifiedSchema → Knowledge Graph triples.
+ *
+ * Mirrors §5.3 of docs/design/Personal_Data_Hub_Architecture.md:
+ *   Event(<id>) --occurred-at--> Time(<ts>)
+ *   Event(<id>) --happened-at--> Place(<id>)
+ *   Event(<id>) --involves--> Person(<id>)   (one per participant)
+ *   Event(<id>) --by--> Person(<actor>)
+ *   Event(<id>) --about--> Item(<id>)
+ *   Event(<id>) --topic--> Topic(<id>)
+ *   Event(<id>) --type--> "<subtype>"
+ *   Event(<id>) --source--> "<adapter>"
+ *
+ * Plus for entities themselves so the KG knows they exist:
+ *   Person(<id>) --rdf:type--> "person"
+ *   Person(<id>) --has-name--> "<name>" (one per name)
+ *   Place(<id>) --located-at--> "lat,lng" (if coordinates)
+ *   Item(<id>)  --priced-at--> "<value> <currency>" (if priced)
+ *   Topic(<id>) --parent--> Topic(<parentId>) (if parented)
+ *
+ * The hub does NOT depend on a specific KG engine. The registry pipes
+ * these triples to a pluggable `kgSink({ subject, predicate, object,
+ * literal })` callback that the desktop wiring binds to ChainlessChain's
+ * existing KG layer (or to /dev/null in tests).
+ *
+ * Triples are plain JS objects so they can serialize to JSON for IPC, KG
+ * persistence, or human inspection.
+ */
+
+"use strict";
+
+/**
+ * @typedef {object} Triple
+ * @property {string} subject   entity id (typed by namespace prefix unless raw)
+ * @property {string} predicate
+ * @property {string} [object]  another entity id (for entity-to-entity edges)
+ * @property {string|number|null} [literal]  primitive value (for leaf edges)
+ */
+
+function triple(subject, predicate, opts) {
+  // opts: { object: "<id>" } or { literal: ... }
+  const out = { subject, predicate };
+  if (opts && opts.object !== undefined && opts.object !== null) {
+    out.object = String(opts.object);
+  } else if (opts && opts.literal !== undefined && opts.literal !== null) {
+    out.literal = opts.literal;
+  }
+  return out;
+}
+
+// ─── Per-entity derivers ────────────────────────────────────────────────
+
+function deriveEventTriples(event) {
+  const out = [];
+  out.push(triple(event.id, "rdf:type", { literal: "event" }));
+  out.push(triple(event.id, "subtype", { literal: event.subtype }));
+  out.push(triple(event.id, "occurred-at", { literal: event.occurredAt }));
+  if (event.source && event.source.adapter) {
+    out.push(triple(event.id, "source", { literal: event.source.adapter }));
+  }
+  if (event.actor) {
+    out.push(triple(event.id, "by", { object: event.actor }));
+  }
+  if (Array.isArray(event.participants)) {
+    for (const p of event.participants) {
+      out.push(triple(event.id, "involves", { object: p }));
+    }
+  }
+  if (event.place) {
+    out.push(triple(event.id, "happened-at", { object: event.place }));
+  }
+  if (Array.isArray(event.items)) {
+    for (const i of event.items) {
+      out.push(triple(event.id, "about", { object: i }));
+    }
+  }
+  if (Array.isArray(event.topics)) {
+    for (const t of event.topics) {
+      out.push(triple(event.id, "topic", { object: t }));
+    }
+  }
+  if (event.content && event.content.amount) {
+    const a = event.content.amount;
+    out.push(triple(event.id, "amount-value", { literal: a.value }));
+    out.push(triple(event.id, "amount-currency", { literal: a.currency }));
+    out.push(triple(event.id, "amount-direction", { literal: a.direction }));
+  }
+  return out;
+}
+
+function derivePersonTriples(person) {
+  const out = [];
+  out.push(triple(person.id, "rdf:type", { literal: "person" }));
+  out.push(triple(person.id, "subtype", { literal: person.subtype }));
+  for (const n of person.names) {
+    out.push(triple(person.id, "has-name", { literal: n }));
+  }
+  if (person.identifiers) {
+    for (const [kind, val] of Object.entries(person.identifiers)) {
+      if (val == null) continue;
+      if (Array.isArray(val)) {
+        for (const v of val) {
+          out.push(triple(person.id, `id:${kind}`, { literal: v }));
+        }
+      } else {
+        out.push(triple(person.id, `id:${kind}`, { literal: val }));
+      }
+    }
+  }
+  if (person.relation) {
+    out.push(triple(person.id, "relation", { literal: person.relation }));
+  }
+  return out;
+}
+
+function derivePlaceTriples(place) {
+  const out = [];
+  out.push(triple(place.id, "rdf:type", { literal: "place" }));
+  out.push(triple(place.id, "has-name", { literal: place.name }));
+  for (const a of place.aliases) {
+    if (a !== place.name) out.push(triple(place.id, "has-alias", { literal: a }));
+  }
+  if (place.coordinates) {
+    out.push(triple(place.id, "located-at", { literal: `${place.coordinates.lat},${place.coordinates.lng}` }));
+  }
+  if (place.address) {
+    out.push(triple(place.id, "address", { literal: place.address }));
+  }
+  if (place.category) {
+    out.push(triple(place.id, "category", { literal: place.category }));
+  }
+  return out;
+}
+
+function deriveItemTriples(item) {
+  const out = [];
+  out.push(triple(item.id, "rdf:type", { literal: "item" }));
+  out.push(triple(item.id, "subtype", { literal: item.subtype }));
+  out.push(triple(item.id, "has-name", { literal: item.name }));
+  if (item.category) out.push(triple(item.id, "category", { literal: item.category }));
+  if (item.price) {
+    out.push(triple(item.id, "priced-at", { literal: `${item.price.value} ${item.price.currency}` }));
+  }
+  if (item.merchant) {
+    out.push(triple(item.id, "sold-by", { object: item.merchant }));
+  }
+  return out;
+}
+
+function deriveTopicTriples(topic) {
+  const out = [];
+  out.push(triple(topic.id, "rdf:type", { literal: "topic" }));
+  out.push(triple(topic.id, "has-name", { literal: topic.name }));
+  if (topic.parentTopic) {
+    out.push(triple(topic.id, "parent", { object: topic.parentTopic }));
+  }
+  if (Array.isArray(topic.derivedFromEvents)) {
+    for (const ev of topic.derivedFromEvents) {
+      out.push(triple(topic.id, "derived-from", { object: ev }));
+    }
+  }
+  return out;
+}
+
+/**
+ * Derive all KG triples for a NormalizedBatch in one call.
+ * Returns a flat array of triples in the order entities appear in the batch.
+ */
+function deriveBatchTriples(batch) {
+  const triples = [];
+  if (!batch || typeof batch !== "object") return triples;
+
+  for (const e of batch.events || []) triples.push(...deriveEventTriples(e));
+  for (const p of batch.persons || []) triples.push(...derivePersonTriples(p));
+  for (const pl of batch.places || []) triples.push(...derivePlaceTriples(pl));
+  for (const i of batch.items || []) triples.push(...deriveItemTriples(i));
+  for (const t of batch.topics || []) triples.push(...deriveTopicTriples(t));
+
+  return triples;
+}
+
+/**
+ * Dispatch a single entity to its appropriate deriver based on .type.
+ * Returns [] for unknown types rather than throwing — the registry uses
+ * this in hot loops where one weird row shouldn't kill the whole batch.
+ */
+function deriveEntityTriples(entity) {
+  if (!entity || typeof entity !== "object") return [];
+  switch (entity.type) {
+    case "event":
+      return deriveEventTriples(entity);
+    case "person":
+      return derivePersonTriples(entity);
+    case "place":
+      return derivePlaceTriples(entity);
+    case "item":
+      return deriveItemTriples(entity);
+    case "topic":
+      return deriveTopicTriples(entity);
+    default:
+      return [];
+  }
+}
+
+module.exports = {
+  triple,
+  deriveEventTriples,
+  derivePersonTriples,
+  derivePlaceTriples,
+  deriveItemTriples,
+  deriveTopicTriples,
+  deriveBatchTriples,
+  deriveEntityTriples,
+};

package/lib/llm-client.js

@@ -0,0 +1,171 @@
+/**
+ * LLMClient — pluggable LLM backend interface used by the AnalysisEngine.
+ *
+ * Mirrors §8.4 of docs/design/Personal_Data_Hub_Architecture.md. The hub
+ * doesn't pick an LLM SDK; consumers inject one of:
+ *
+ *   - OllamaClient   — HTTP, local-only, default for the privacy promise
+ *   - MockLLMClient  — deterministic, for tests and skill development
+ *   - (later)          vLLM / Llama.cpp / cloud — explicit user opt-in only
+ *
+ * Contract: a single async chat(messages, opts) -> { text, usage?, model? }.
+ * Messages are { role: "system"|"user"|"assistant", content: string }.
+ *
+ *   `isLocal`  MUST accurately report whether the backend keeps data on the
+ *              user's machine. The AnalysisEngine refuses to run with a
+ *              non-local LLM unless `acceptNonLocal: true` is explicitly
+ *              passed by the caller. Architecture-doc §11.2 invariant.
+ *
+ *   `name`     human-readable label surfaced in audit logs.
+ *
+ * Implementations should treat the messages array as opaque — the hub
+ * stitches together (system prompt) + (user question with embedded facts)
+ * and hands them off. No silent rewriting.
+ */
+
+"use strict";
+
+// ─── MockLLMClient ───────────────────────────────────────────────────────
+
+/**
+ * MockLLMClient — deterministic, no network.
+ *
+ * Constructor takes one of:
+ *   { reply: string }                          — always returns the same text
+ *   { reply: (messages) => string }            — function of input
+ *   { replies: string[] }                      — returns one per call, errors after exhaustion
+ *
+ * Useful for testing AnalysisEngine end-to-end without an Ollama install.
+ */
+class MockLLMClient {
+  constructor(opts = {}) {
+    this.name = opts.name || "mock-llm";
+    this.isLocal = true;
+    this.calls = []; // each call recorded as { messages, opts } for asserting prompt shape
+
+    if (typeof opts.reply === "function") {
+      this._reply = opts.reply;
+    } else if (typeof opts.reply === "string") {
+      this._reply = () => opts.reply;
+    } else if (Array.isArray(opts.replies)) {
+      let i = 0;
+      this._reply = () => {
+        if (i >= opts.replies.length) {
+          throw new Error(`MockLLMClient: exhausted replies (${opts.replies.length} provided)`);
+        }
+        return opts.replies[i++];
+      };
+    } else {
+      this._reply = () => "(mock empty reply)";
+    }
+  }
+
+  async chat(messages, opts = {}) {
+    this.calls.push({ messages: messages.slice(), opts: { ...opts } });
+    const text = this._reply(messages, opts);
+    return {
+      text,
+      model: this.name,
+      usage: {
+        promptTokens: messages.reduce((n, m) => n + (m.content ? m.content.length : 0), 0) / 4 | 0,
+        completionTokens: (text || "").length / 4 | 0,
+        totalTokens: 0, // sum below
+      },
+    };
+  }
+}
+
+// ─── OllamaClient ────────────────────────────────────────────────────────
+
+/**
+ * OllamaClient — talks to a local Ollama HTTP server.
+ *
+ * Default endpoint http://localhost:11434, default model qwen2.5:7b-instruct
+ * (per §8.4 recommendation). Uses /api/chat which expects:
+ *
+ *   POST /api/chat
+ *   { "model": "...", "messages": [...], "stream": false, "options": { ... } }
+ *
+ * Response: { message: { role: "assistant", content: "..." }, ... }
+ *
+ * No external dep — uses global fetch (Node 22+). If a request fails (network
+ * error / Ollama not running / model not pulled) the error surfaces to the
+ * caller with `cause` preserved, never silently downgrades to cloud.
+ */
+class OllamaClient {
+  constructor(opts = {}) {
+    this.baseUrl = (opts.baseUrl || "http://localhost:11434").replace(/\/$/, "");
+    this.model = opts.model || "qwen2.5:7b-instruct";
+    this.name = opts.name || `ollama:${this.model}`;
+    this.isLocal = true; // Ollama is always local-only by construction
+    this.timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : 60_000;
+    this._fetch = opts.fetch || (typeof fetch !== "undefined" ? fetch : null);
+    if (!this._fetch) {
+      throw new Error("OllamaClient: no fetch available. Node 22+ required, or pass opts.fetch.");
+    }
+  }
+
+  async chat(messages, opts = {}) {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), this.timeoutMs);
+
+    let resp;
+    try {
+      resp = await this._fetch(`${this.baseUrl}/api/chat`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          model: this.model,
+          messages,
+          stream: false,
+          options: {
+            temperature: typeof opts.temperature === "number" ? opts.temperature : 0.2,
+            ...(opts.numCtx ? { num_ctx: opts.numCtx } : {}),
+          },
+        }),
+        signal: ctrl.signal,
+      });
+    } catch (err) {
+      clearTimeout(t);
+      const wrapped = new Error(`OllamaClient.chat: request failed — ${err && err.message ? err.message : err}`);
+      wrapped.cause = err;
+      throw wrapped;
+    }
+    clearTimeout(t);
+
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`OllamaClient.chat: HTTP ${resp.status} ${resp.statusText} — ${body.slice(0, 200)}`);
+    }
+
+    const json = await resp.json();
+    const text = json && json.message && typeof json.message.content === "string"
+      ? json.message.content
+      : "";
+    return {
+      text,
+      model: this.model,
+      usage: {
+        promptTokens: json.prompt_eval_count || 0,
+        completionTokens: json.eval_count || 0,
+        totalTokens: (json.prompt_eval_count || 0) + (json.eval_count || 0),
+      },
+      raw: json,
+    };
+  }
+
+  /** Lightweight health check — pings /api/tags. */
+  async health() {
+    try {
+      const ctrl = new AbortController();
+      const t = setTimeout(() => ctrl.abort(), 5000);
+      const resp = await this._fetch(`${this.baseUrl}/api/tags`, { signal: ctrl.signal });
+      clearTimeout(t);
+      return { ok: resp.ok, status: resp.status };
+    } catch (err) {
+      return { ok: false, error: err && err.message ? err.message : String(err) };
+    }
+  }
+}
+
+module.exports = { MockLLMClient, OllamaClient };

package/lib/migrations.js

@@ -0,0 +1,246 @@
+/**
+ * LocalVault schema migrations.
+ *
+ * Each migration is a `{ version, up(db) }` record. Applied in order, idempotent.
+ * The current version is recorded in the `_meta` table so re-opening a vault
+ * runs only the missing migrations.
+ *
+ * Design notes:
+ *   - Each UnifiedSchema entity type gets its own table. Cross-entity references
+ *     (Event.actor → Person.id, Event.topics → Topic.id[]) are *string IDs*,
+ *     not FKs — adapters often produce entities out of order (event refs a
+ *     person we'll insert next batch), so FKs would force two-pass ingest.
+ *   - JSON columns (participants, items, topics, identifiers, content, extra)
+ *     keep the schemaless tail intact. SQLite's json_extract enables indexed
+ *     queries on common fields without a rigid schema upgrade per adapter.
+ *   - source.adapter + source.originalId are extracted to indexed virtual
+ *     columns for fast (adapter, originalId) dedup lookups during sync.
+ *   - WAL mode is set at vault open, not here, so it survives re-opens.
+ */
+
+"use strict";
+
+const INITIAL_DDL = [
+  // ── _meta: schema version + vault-level state ───────────────────────────
+  `CREATE TABLE IF NOT EXISTS _meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`,
+
+  // ── events ──────────────────────────────────────────────────────────────
+  `CREATE TABLE IF NOT EXISTS events (
+    id TEXT PRIMARY KEY,
+    subtype TEXT NOT NULL,
+    occurred_at INTEGER NOT NULL,
+    duration_ms INTEGER,
+    actor TEXT,
+    participants TEXT,
+    place TEXT,
+    items TEXT,
+    topics TEXT,
+    content TEXT NOT NULL,
+    source_adapter TEXT NOT NULL,
+    source_original_id TEXT,
+    source TEXT NOT NULL,
+    extra TEXT,
+    ingested_at INTEGER NOT NULL,
+    confidence REAL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_events_subtype ON events(subtype)`,
+  `CREATE INDEX IF NOT EXISTS idx_events_occurred ON events(occurred_at)`,
+  `CREATE INDEX IF NOT EXISTS idx_events_actor ON events(actor)`,
+  `CREATE INDEX IF NOT EXISTS idx_events_place ON events(place)`,
+  `CREATE INDEX IF NOT EXISTS idx_events_adapter ON events(source_adapter)`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS uniq_events_source ON events(source_adapter, source_original_id)
+    WHERE source_original_id IS NOT NULL`,
+
+  // ── persons ─────────────────────────────────────────────────────────────
+  `CREATE TABLE IF NOT EXISTS persons (
+    id TEXT PRIMARY KEY,
+    subtype TEXT NOT NULL,
+    names TEXT NOT NULL,
+    identifiers TEXT,
+    relation TEXT,
+    notes TEXT,
+    source_adapter TEXT NOT NULL,
+    source_original_id TEXT,
+    source TEXT NOT NULL,
+    extra TEXT,
+    ingested_at INTEGER NOT NULL,
+    confidence REAL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_persons_subtype ON persons(subtype)`,
+  `CREATE INDEX IF NOT EXISTS idx_persons_adapter ON persons(source_adapter)`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS uniq_persons_source ON persons(source_adapter, source_original_id)
+    WHERE source_original_id IS NOT NULL`,
+
+  // ── places ──────────────────────────────────────────────────────────────
+  `CREATE TABLE IF NOT EXISTS places (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    coordinates_lat REAL,
+    coordinates_lng REAL,
+    address TEXT,
+    category TEXT,
+    aliases TEXT NOT NULL,
+    source_adapter TEXT NOT NULL,
+    source_original_id TEXT,
+    source TEXT NOT NULL,
+    extra TEXT,
+    ingested_at INTEGER NOT NULL,
+    confidence REAL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_places_name ON places(name)`,
+  `CREATE INDEX IF NOT EXISTS idx_places_category ON places(category)`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS uniq_places_source ON places(source_adapter, source_original_id)
+    WHERE source_original_id IS NOT NULL`,
+
+  // ── items ───────────────────────────────────────────────────────────────
+  `CREATE TABLE IF NOT EXISTS items (
+    id TEXT PRIMARY KEY,
+    subtype TEXT NOT NULL,
+    name TEXT NOT NULL,
+    category TEXT,
+    price_value REAL,
+    price_currency TEXT,
+    merchant TEXT,
+    external_url TEXT,
+    thumbnail_local_path TEXT,
+    source_adapter TEXT NOT NULL,
+    source_original_id TEXT,
+    source TEXT NOT NULL,
+    extra TEXT,
+    ingested_at INTEGER NOT NULL,
+    confidence REAL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_items_subtype ON items(subtype)`,
+  `CREATE INDEX IF NOT EXISTS idx_items_merchant ON items(merchant)`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS uniq_items_source ON items(source_adapter, source_original_id)
+    WHERE source_original_id IS NOT NULL`,
+
+  // ── topics ──────────────────────────────────────────────────────────────
+  `CREATE TABLE IF NOT EXISTS topics (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    parent_topic TEXT,
+    derived_from_events TEXT,
+    source_adapter TEXT NOT NULL,
+    source_original_id TEXT,
+    source TEXT NOT NULL,
+    extra TEXT,
+    ingested_at INTEGER NOT NULL,
+    confidence REAL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_topics_name ON topics(name)`,
+  `CREATE INDEX IF NOT EXISTS idx_topics_parent ON topics(parent_topic)`,
+
+  // ── sync_watermarks ─────────────────────────────────────────────────────
+  // Per-adapter (and optional scope) progress markers so re-syncs are incremental.
+  // Examples of scope:
+  //   email-imap: "<accountId>:INBOX"
+  //   wechat:     "<talker-wxid>"
+  //   alipay:     "" (single global)
+  `CREATE TABLE IF NOT EXISTS sync_watermarks (
+    adapter TEXT NOT NULL,
+    scope TEXT NOT NULL DEFAULT '',
+    watermark TEXT,
+    last_synced_at INTEGER,
+    last_status TEXT,
+    last_error TEXT,
+    PRIMARY KEY (adapter, scope)
+  )`,
+
+  // ── audit_log ───────────────────────────────────────────────────────────
+  // Every read of personal data + every adapter sync + every key rotation
+  // gets a row here. UI surfaces this for the "data lineage" view promised
+  // in the architecture doc §11.1.
+  `CREATE TABLE IF NOT EXISTS audit_log (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    at INTEGER NOT NULL,
+    action TEXT NOT NULL,
+    target TEXT,
+    details TEXT
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_audit_at ON audit_log(at)`,
+  `CREATE INDEX IF NOT EXISTS idx_audit_action ON audit_log(action)`,
+
+  // ── raw_events ──────────────────────────────────────────────────────────
+  // Verbatim adapter payload, primary key (adapter, originalId). Lets us
+  // re-derive UnifiedSchema rows without re-syncing if normalization logic
+  // changes (e.g. parser upgrade).
+  `CREATE TABLE IF NOT EXISTS raw_events (
+    adapter TEXT NOT NULL,
+    original_id TEXT NOT NULL,
+    captured_at INTEGER NOT NULL,
+    payload TEXT NOT NULL,
+    PRIMARY KEY (adapter, original_id)
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_raw_captured ON raw_events(captured_at)`,
+];
+
+const MIGRATIONS = [
+  {
+    version: 1,
+    description: "Initial UnifiedSchema tables + sync_watermarks + audit_log + raw_events",
+    up(db) {
+      for (const sql of INITIAL_DDL) db.exec(sql);
+    },
+  },
+];
+
+const TARGET_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;
+
+/**
+ * Apply all pending migrations. Reads the current version from `_meta`,
+ * runs each subsequent migration in a transaction, then updates `_meta`.
+ * Idempotent — calling on an up-to-date vault is a no-op.
+ *
+ * Throws if a migration fails (caller should treat as fatal — partial vault
+ * state is recoverable from raw_events but is the user's call to make).
+ */
+function applyMigrations(db) {
+  // Bootstrap _meta in its own statement — every subsequent migration assumes
+  // it exists. Idempotent: CREATE TABLE IF NOT EXISTS.
+  db.exec(`CREATE TABLE IF NOT EXISTS _meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`);
+
+  const row = db.prepare("SELECT value FROM _meta WHERE key = 'schema_version'").get();
+  const current = row ? parseInt(row.value, 10) : 0;
+
+  for (const m of MIGRATIONS) {
+    if (m.version <= current) continue;
+
+    const runMigration = db.transaction(() => {
+      m.up(db);
+      const now = Date.now();
+      db.prepare(
+        `INSERT INTO _meta (key, value, updated_at) VALUES ('schema_version', ?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+      ).run(String(m.version), now);
+    });
+
+    runMigration();
+  }
+
+  return { previous: current, current: TARGET_VERSION };
+}
+
+function getSchemaVersion(db) {
+  try {
+    const row = db.prepare("SELECT value FROM _meta WHERE key = 'schema_version'").get();
+    return row ? parseInt(row.value, 10) : 0;
+  } catch (_err) {
+    return 0;
+  }
+}
+
+module.exports = {
+  MIGRATIONS,
+  TARGET_VERSION,
+  applyMigrations,
+  getSchemaVersion,
+};