@withone/cli 1.42.0 → 1.43.2

package/dist/chunk-AD4QM6R5.js

@@ -0,0 +1,762 @@
+import {
+  getByDotPath
+} from "./chunk-44CV5IMX.js";
+import {
+  isAgentMode,
+  note,
+  okJson,
+  requireMemoryInit
+} from "./chunk-MRGKKO54.js";
+import {
+  getBackend,
+  upsertRecord
+} from "./chunk-5TT27ORC.js";
+
+// src/commands/mem/migrate.ts
+import fs4 from "fs";
+import path4 from "path";
+import * as p from "@clack/prompts";
+
+// src/lib/memory/sync/profile.ts
+import fs from "fs";
+import path from "path";
+var PROFILES_DIR = path.join(".one", "sync", "profiles");
+function profilePath(platform, model) {
+  return path.join(PROFILES_DIR, `${platform}_${model}.json`);
+}
+function readProfile(platform, model) {
+  const filePath = profilePath(platform, model);
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeProfile(profile) {
+  const required = ["platform", "model", "actionId", "idField", "pagination"];
+  for (const field of required) {
+    if (!profile[field]) {
+      throw new Error(`Missing required field: ${field}`);
+    }
+  }
+  const hasKey = !!profile.connectionKey;
+  const hasRef = !!profile.connection?.platform;
+  if (hasKey && hasRef) {
+    throw new Error(
+      "Profile has both `connectionKey` and `connection` \u2014 set exactly one. Prefer `connection: { platform, tag? }` so re-auth doesn't break the profile."
+    );
+  }
+  if (!hasKey && !hasRef) {
+    throw new Error(
+      'Missing connection: set `connection: { platform: "<name>" }` (or legacy `connectionKey: "<key>"`).'
+    );
+  }
+  if (profile.resultsPath === void 0) {
+    throw new Error('Missing required field: resultsPath (use "" or "$" for root-array responses)');
+  }
+  if (!profile.pagination.type) {
+    throw new Error("Missing required field: pagination.type");
+  }
+  fs.mkdirSync(PROFILES_DIR, { recursive: true });
+  const filePath = profilePath(profile.platform, profile.model);
+  fs.writeFileSync(filePath, JSON.stringify(profile, null, 2));
+}
+async function resolveProfileConnectionKey(api, profile, cache) {
+  if (profile.connectionKey) return profile.connectionKey;
+  if (!profile.connection?.platform) {
+    throw new Error(
+      `Profile ${profile.platform}/${profile.model} has no connectionKey or connection ref.`
+    );
+  }
+  const conn = await api.resolveConnection(profile.connection, cache);
+  return conn.key;
+}
+function writeDraftProfile(platform, model, draft) {
+  fs.mkdirSync(PROFILES_DIR, { recursive: true });
+  const filePath = profilePath(platform, model);
+  fs.writeFileSync(filePath, JSON.stringify(draft, null, 2));
+}
+function listProfiles(platform) {
+  if (!fs.existsSync(PROFILES_DIR)) return [];
+  const files = fs.readdirSync(PROFILES_DIR).filter((f) => f.endsWith(".json"));
+  const profiles = [];
+  for (const file of files) {
+    try {
+      const raw = fs.readFileSync(path.join(PROFILES_DIR, file), "utf-8");
+      const profile = JSON.parse(raw);
+      if (!platform || profile.platform === platform) {
+        profiles.push(profile);
+      }
+    } catch {
+    }
+  }
+  return profiles;
+}
+function generateTemplate(platform, model, actionId) {
+  return {
+    platform,
+    model,
+    // Late-bound ref — survives re-auth. Use { platform, tag } when the
+    // platform has multiple connections (e.g. multiple Gmail accounts).
+    connection: { platform },
+    actionId: actionId ?? "FILL_IN",
+    resultsPath: "FILL_IN",
+    idField: "FILL_IN",
+    pagination: {
+      type: "FILL_IN (cursor | token | offset | id | link | none)",
+      nextPath: "FILL_IN",
+      passAs: "FILL_IN (query:name | body:name | header:name)"
+    }
+    // Optional. Set to "body" for POST-body list endpoints (e.g. Notion /v1/search).
+    // limitLocation: "query",
+    // Optional. Page size param name. Set to "" to disable sending any page size.
+    // limitParam: "limit",
+    // Optional. Default page size (100).
+    // defaultLimit: 100,
+  };
+}
+
+// src/lib/memory/sync/builtin-profiles.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function getProfilesDir() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = path2.dirname(thisFile);
+  for (let i = 1; i <= 4; i++) {
+    const candidate = path2.resolve(thisDir, ...Array(i).fill(".."), "profiles");
+    if (fs2.existsSync(candidate)) return candidate;
+  }
+  return "";
+}
+function loadBuiltinProfile(platform, model) {
+  const dir = getProfilesDir();
+  if (!dir) return null;
+  const filePath = path2.join(dir, platform, `${model}.json`);
+  try {
+    if (!fs2.existsSync(filePath)) return null;
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function listBuiltinProfiles(platform) {
+  const dir = getProfilesDir();
+  if (!dir) return [];
+  const profiles = [];
+  try {
+    const platforms = platform ? [platform] : fs2.readdirSync(dir).filter((f) => {
+      try {
+        return fs2.statSync(path2.join(dir, f)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    for (const plat of platforms) {
+      const platDir = path2.join(dir, plat);
+      if (!fs2.existsSync(platDir)) continue;
+      const files = fs2.readdirSync(platDir).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        try {
+          const raw = fs2.readFileSync(path2.join(platDir, file), "utf-8");
+          const profile = JSON.parse(raw);
+          profiles.push(profile);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return profiles;
+}
+
+// src/lib/memory/sync/db.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/lib/memory/sync/sqlite-loader.ts
+var cached = null;
+async function loadSqlite() {
+  if (cached) return cached;
+  try {
+    const modName = "better-sqlite3";
+    const mod = await import(modName);
+    cached = mod.default;
+    return cached;
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `The local sync engine (better-sqlite3) is not installed.
+
+Install it with:
+  one sync install
+
+Or manually:
+  npm install -g better-sqlite3
+
+Underlying error: ${detail}`
+    );
+  }
+}
+async function isSqliteAvailable() {
+  try {
+    await loadSqlite();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/memory/sync/db.ts
+var DATA_DIR = path3.join(".one", "sync", "data");
+function listSyncedPlatforms() {
+  if (!fs3.existsSync(DATA_DIR)) return [];
+  return fs3.readdirSync(DATA_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(/\.db$/, ""));
+}
+async function openDatabase(platform, opts = {}) {
+  const Database = await loadSqlite();
+  fs3.mkdirSync(DATA_DIR, { recursive: true });
+  const dbPath = path3.join(DATA_DIR, `${platform}.db`);
+  if (opts.readonly) {
+    return new Database(dbPath, { readonly: true, fileMustExist: true });
+  }
+  let db;
+  try {
+    db = new Database(dbPath);
+  } catch {
+    const backupPath = dbPath + ".bak";
+    if (fs3.existsSync(dbPath)) {
+      fs3.renameSync(dbPath, backupPath);
+      process.stderr.write(`Database corrupted, starting fresh. Backup saved at ${backupPath}
+`);
+    }
+    db = new Database(dbPath);
+  }
+  db.pragma("journal_mode = WAL");
+  db.pragma("busy_timeout = 15000");
+  db.pragma("foreign_keys = OFF");
+  return db;
+}
+function getDatabasePath(platform) {
+  return path3.join(DATA_DIR, `${platform}.db`);
+}
+function getDatabaseSize(platform) {
+  const dbPath = getDatabasePath(platform);
+  if (!fs3.existsSync(dbPath)) return "0 B";
+  const stats = fs3.statSync(dbPath);
+  const bytes = stats.size;
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function detectColumnType(value) {
+  if (value === null || value === void 0) return "TEXT";
+  if (typeof value === "string") return "TEXT";
+  if (typeof value === "boolean") return "INTEGER";
+  if (typeof value === "number") return Number.isInteger(value) ? "INTEGER" : "REAL";
+  if (typeof value === "object") return "TEXT";
+  return "TEXT";
+}
+function sanitizeTableName(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function getTableColumns(db, model) {
+  const table = sanitizeTableName(model);
+  const rows = db.prepare(`PRAGMA table_info("${table}")`).all();
+  return rows.map((r) => ({ name: r.name, type: r.type }));
+}
+function tableExists(db, model) {
+  const table = sanitizeTableName(model);
+  const row = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(table);
+  return !!row;
+}
+function ensureTable(db, model, firstRecord, idField) {
+  const table = sanitizeTableName(model);
+  if (tableExists(db, model)) {
+    return getTableColumns(db, model).map((c) => c.name);
+  }
+  const columns = [];
+  const colDefs = [];
+  for (const [key, value] of Object.entries(firstRecord)) {
+    const colType = detectColumnType(value);
+    colDefs.push(`"${key}" ${colType}`);
+    columns.push(key);
+  }
+  if (!columns.includes("_synced_at")) {
+    colDefs.push('"_synced_at" TEXT');
+    columns.push("_synced_at");
+  }
+  db.exec(`CREATE TABLE IF NOT EXISTS "${table}" (${colDefs.join(", ")})`);
+  const safeIdField = idField.replace(/"/g, '""');
+  db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS "idx_${table}_${sanitizeTableName(idField)}" ON "${table}" ("${safeIdField}")`);
+  return columns;
+}
+function rebuildFtsIndex(db, model) {
+  const table = sanitizeTableName(model);
+  const ftsTable = `${table}_fts`;
+  const columns = getTableColumns(db, model);
+  const textCols = columns.filter((c) => c.type === "TEXT" && c.name !== "_synced_at").map((c) => c.name);
+  if (textCols.length === 0) return;
+  const quotedCols = textCols.map((c) => `"${c}"`).join(", ");
+  db.exec(`DROP TABLE IF EXISTS "${ftsTable}"`);
+  db.exec(`DROP TRIGGER IF EXISTS "${table}_ai"`);
+  db.exec(`DROP TRIGGER IF EXISTS "${table}_au"`);
+  db.exec(`CREATE VIRTUAL TABLE "${ftsTable}" USING fts5(${quotedCols})`);
+  db.exec(`INSERT INTO "${ftsTable}"(rowid, ${quotedCols}) SELECT rowid, ${quotedCols} FROM "${table}"`);
+}
+function evolveSchema(db, model, record) {
+  const table = sanitizeTableName(model);
+  const existingCols = new Set(getTableColumns(db, model).map((c) => c.name));
+  for (const [key, value] of Object.entries(record)) {
+    if (!existingCols.has(key)) {
+      const colType = detectColumnType(value);
+      db.exec(`ALTER TABLE "${table}" ADD COLUMN "${key}" ${colType}`);
+    }
+  }
+}
+function prepareValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return value;
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function upsertRecords(db, model, records, idField) {
+  if (records.length === 0) return 0;
+  const table = sanitizeTableName(model);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existingCols = getTableColumns(db, model).map((c) => c.name);
+  const insertMany = db.transaction((recs) => {
+    let count = 0;
+    for (const record of recs) {
+      const recordKeys = Object.keys(record);
+      const newKeys = recordKeys.filter((k) => !existingCols.includes(k));
+      if (newKeys.length > 0) {
+        for (const key of newKeys) {
+          const colType = detectColumnType(record[key]);
+          db.exec(`ALTER TABLE "${table}" ADD COLUMN "${key}" ${colType}`);
+          existingCols.push(key);
+        }
+      }
+      const fullRecord = { ...record, _synced_at: now };
+      const cols = Object.keys(fullRecord).filter((k) => existingCols.includes(k) || k === "_synced_at");
+      const quotedCols = cols.map((c) => `"${c}"`).join(", ");
+      const placeholders = cols.map(() => "?").join(", ");
+      const values = cols.map((c) => prepareValue(fullRecord[c]));
+      const safeIdField = idField.replace(/"/g, '""');
+      const updateCols = cols.filter((c) => c !== idField).map((c) => `"${c}" = excluded."${c}"`).join(", ");
+      db.prepare(
+        `INSERT INTO "${table}" (${quotedCols}) VALUES (${placeholders}) ON CONFLICT("${safeIdField}") DO UPDATE SET ${updateCols}`
+      ).run(...values);
+      count++;
+    }
+    return count;
+  });
+  return insertMany(records);
+}
+function deleteRecords(db, model, where, params) {
+  const table = sanitizeTableName(model);
+  const result = db.prepare(`DELETE FROM "${table}" WHERE ${where}`).run(...params);
+  return result.changes;
+}
+function dropTable(db, model) {
+  const table = sanitizeTableName(model);
+  db.exec(`DROP TABLE IF EXISTS "${table}_fts"`);
+  db.exec(`DROP TRIGGER IF EXISTS "${table}_ai"`);
+  db.exec(`DROP TRIGGER IF EXISTS "${table}_au"`);
+  db.exec(`DROP TABLE IF EXISTS "${table}"`);
+}
+function listTables(db) {
+  const rows = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '%_fts%' AND name NOT LIKE 'sqlite_%'`).all();
+  return rows.map((r) => r.name);
+}
+function countRecords(db, model) {
+  const table = sanitizeTableName(model);
+  if (!tableExists(db, model)) return 0;
+  const row = db.prepare(`SELECT COUNT(*) as count FROM "${table}"`).get();
+  return row.count;
+}
+function deleteDatabase(platform) {
+  const dbPath = getDatabasePath(platform);
+  if (fs3.existsSync(dbPath)) fs3.unlinkSync(dbPath);
+  if (fs3.existsSync(dbPath + "-wal")) fs3.unlinkSync(dbPath + "-wal");
+  if (fs3.existsSync(dbPath + "-shm")) fs3.unlinkSync(dbPath + "-shm");
+}
+
+// src/commands/mem/migrate.ts
+async function memMigrateCommand(flags) {
+  requireMemoryInit();
+  const backend = await getBackend();
+  const platforms = flags.platform ? [flags.platform] : listSyncedPlatforms();
+  if (platforms.length === 0) {
+    okJson({ status: "noop", reason: "no legacy .one/sync/data/*.db files found" });
+    return;
+  }
+  const canPredict = backend.capabilities().rawSql && typeof backend.raw === "function";
+  const keyExists = async (keys) => {
+    if (!canPredict || keys.length === 0) return false;
+    try {
+      const res = await backend.raw(
+        `SELECT 1 FROM mem_records WHERE keys && $1::text[] LIMIT 1`,
+        [keys]
+      );
+      return res.rowCount > 0;
+    } catch {
+      return false;
+    }
+  };
+  const reports = [];
+  for (const platform of platforms) {
+    const db = await openDatabase(platform, { readonly: true });
+    try {
+      const tables = listTables(db).filter((t) => !t.endsWith("_fts"));
+      for (const model of tables) {
+        const total = countRecords(db, model);
+        const rows = db.prepare(`SELECT * FROM "${model}"`).all();
+        const report = {
+          platform,
+          model,
+          rowsSeen: total,
+          inserted: 0,
+          updated: 0,
+          mergedByIdentity: 0,
+          skipped: 0,
+          skippedUnresolvedId: 0,
+          skippedError: 0
+        };
+        const profile = readProfile(platform, model);
+        const builtin = loadBuiltinProfile(platform, model);
+        const idField = profile?.idField;
+        const healEnabled = flags.heal !== false;
+        const builtinIdField = healEnabled && typeof builtin?.idField === "string" && builtin.idField !== idField ? builtin.idField : void 0;
+        const builtinNewer = isBuiltinNewerThanInstalled(platform, model);
+        const identityKey = profile?.identityKey;
+        const type = `${platform}/${model}`;
+        try {
+          report.activeBefore = await backend.count(type, { status: "active" });
+        } catch {
+        }
+        const identityMap = await buildIdentityMap(backend, type, identityKey);
+        for (const row of rows) {
+          const hydrated = reviveStringifiedJson(row);
+          let activeIdField = idField;
+          let externalRaw = idField ? getByDotPath(hydrated, idField) : void 0;
+          if (builtinIdField && (externalRaw === void 0 || externalRaw === null || externalRaw === "" || typeof externalRaw === "object")) {
+            const healed2 = getByDotPath(hydrated, builtinIdField);
+            if (healed2 !== void 0 && healed2 !== null && healed2 !== "" && typeof healed2 !== "object") {
+              activeIdField = builtinIdField;
+              externalRaw = healed2;
+              if (!report.healedIdField) {
+                report.healedIdField = builtinIdField;
+                report.originalIdField = idField;
+                report.builtinNewerThanInstalled = builtinNewer;
+              }
+            }
+          }
+          if (!activeIdField || externalRaw === void 0 || externalRaw === null || externalRaw === "" || typeof externalRaw === "object") {
+            report.skippedUnresolvedId++;
+            report.skipped++;
+            if (!isAgentMode() && report.skippedUnresolvedId <= 3) {
+              const hint = !activeIdField ? "no profile found" : typeof externalRaw === "object" ? `idField "${activeIdField}" resolved to a nested object (stringifies to [object Object]) \u2014 profile needs a dotted path` : `idField "${activeIdField}" resolved to undefined/empty`;
+              process.stderr.write(`  skip row ${report.skippedUnresolvedId}: ${hint}
+`);
+            }
+            continue;
+          }
+          const external = String(externalRaw);
+          const sourceKey = `${platform}/${model}:${external}`;
+          const keys = [sourceKey];
+          let identityValueNorm = null;
+          if (identityKey) {
+            const idValue = getByDotPath(hydrated, identityKey);
+            if (idValue !== void 0 && idValue !== null && idValue !== "" && typeof idValue !== "object") {
+              identityValueNorm = String(idValue).toLowerCase().trim();
+              keys.push(`${deriveIdentityPrefix(identityKey)}:${identityValueNorm}`);
+            }
+          }
+          let mergeTarget = false;
+          if (identityValueNorm && identityMap.has(identityValueNorm)) {
+            const hit = identityMap.get(identityValueNorm);
+            for (const k of hit.keys) keys.push(k);
+            mergeTarget = true;
+          }
+          const data = { ...hydrated };
+          for (const k of Object.keys(data)) {
+            if (k.startsWith("_") || k === "rowid") delete data[k];
+          }
+          if (flags.dryRun) {
+            if (await keyExists(keys)) {
+              if (mergeTarget) report.mergedByIdentity++;
+              else report.updated++;
+            } else {
+              report.inserted++;
+            }
+            continue;
+          }
+          try {
+            const res = await upsertRecord(
+              {
+                type,
+                data,
+                keys,
+                sources: {
+                  [sourceKey]: {
+                    last_synced_at: row._synced_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+                    metadata: { migrated_from: "legacy-sqlite" }
+                  }
+                },
+                tags: ["synced", platform],
+                embed: false
+              },
+              // `replace: true` — legacy .db is the declared source of
+              // truth for the run. Without this, identity-merged rows
+              // keep their garbage stringified-JSON `data` shape from
+              // the pre-fix migrate because the merge would union the
+              // hydrated payload with the stringified one.
+              { embed: false, replace: true }
+            );
+            if (res.action === "inserted") report.inserted++;
+            else if (mergeTarget) report.mergedByIdentity++;
+            else report.updated++;
+          } catch (err) {
+            report.skippedError++;
+            report.skipped++;
+            if (!isAgentMode()) {
+              const msg = err instanceof Error ? err.message : String(err);
+              process.stderr.write(`  skip ${sourceKey}: ${msg}
+`);
+            }
+          }
+        }
+        try {
+          report.activeAfter = await backend.count(type, { status: "active" });
+        } catch {
+        }
+        reports.push(report);
+        if (!isAgentMode()) {
+          const skipDetail = report.skipped > 0 ? ` skipped (${report.skippedUnresolvedId} unresolved id, ${report.skippedError} errors)` : " skipped";
+          const mergedSuffix = report.mergedByIdentity > 0 ? `, ${report.mergedByIdentity} merged by identity` : "";
+          process.stderr.write(
+            `  ${platform}/${model}: ${report.inserted} inserted, ${report.updated} updated${mergedSuffix}, ${report.skipped}${skipDetail} (${report.rowsSeen} seen)
+`
+          );
+          if (report.skippedUnresolvedId === report.rowsSeen && report.rowsSeen > 0) {
+            process.stderr.write(
+              `    \u26A0  Every row skipped \u2014 profile for ${platform}/${model} is missing or its idField doesn't resolve on legacy rows.
+`
+            );
+          }
+          if (report.healedIdField) {
+            process.stderr.write(
+              `    \u21AA  Self-healed stale idField "${idField}" \u2192 "${report.healedIdField}" for ${type} (installed profile is out of date \u2014 refresh with \`one sync init ${platform} ${model} --force\`).
+`
+            );
+          }
+          const before = report.activeBefore ?? 0;
+          const after = report.activeAfter ?? 0;
+          const growth = after - before;
+          const expectedMaxGrowth = report.inserted;
+          if (before > 10 && growth > expectedMaxGrowth + 2) {
+            process.stderr.write(
+              `    \u26A0  Memory for ${type} grew from ${before} \u2192 ${after} (+${growth}) but only ${report.inserted} new inserts were logged. Likely a re-migrate under a different idField created duplicates. Inspect with:
+      one mem sql "SELECT jsonb_typeof(data->'id') t, COUNT(*) FROM mem_records WHERE type='${type}' GROUP BY 1"
+    Rows where t='string' are the pre-fix cohort and can be dropped.
+`
+            );
+          }
+        }
+      }
+    } finally {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+  }
+  const dataDir = path4.join(".one", "sync", "data");
+  let cleanupFiles = [];
+  if (flags.cleanup && fs4.existsSync(dataDir)) {
+    cleanupFiles = fs4.readdirSync(dataDir).map((f) => path4.join(dataDir, f));
+  }
+  let cleanupDeleted = false;
+  if (flags.cleanup) {
+    if (!flags.dryRun) {
+      const confirm2 = flags.yes ?? await p.confirm({
+        message: `Delete ${cleanupFiles.length} legacy .one/sync/data/* file(s) now?`,
+        initialValue: false
+      });
+      if (p.isCancel(confirm2) || !confirm2) {
+        note("Leaving legacy files in place. Run with --cleanup --yes to force.", "one mem migrate");
+      } else {
+        for (const full of cleanupFiles) {
+          try {
+            fs4.unlinkSync(full);
+          } catch {
+          }
+        }
+        cleanupDeleted = true;
+      }
+    }
+  }
+  const healed = reports.filter((r) => r.healedIdField).map((r) => {
+    let note2;
+    if (r.builtinNewerThanInstalled === true) {
+      note2 = "Installed profile was older than the built-in; safely healed against the current built-in. Run `one sync init <platform> <model> --force` to update the installed profile permanently.";
+    } else if (r.builtinNewerThanInstalled === false) {
+      note2 = "Installed profile is newer than the built-in but its idField did not resolve on legacy rows. Healing was applied because the data required it, but you may have intentional customizations \u2014 verify the result and consider `one sync init <platform> <model> --force` to refresh.";
+    } else {
+      note2 = "Healed using the built-in profile, but the mtime comparison between the installed and built-in profiles could not be made. Verify the result and consider `one sync init <platform> <model> --force` to refresh the installed profile.";
+    }
+    return {
+      type: `${r.platform}/${r.model}`,
+      originalIdField: r.originalIdField ?? null,
+      healedTo: r.healedIdField,
+      builtinNewerThanInstalled: r.builtinNewerThanInstalled ?? null,
+      note: note2
+    };
+  });
+  okJson({
+    status: flags.dryRun ? "dry-run" : "ok",
+    reports,
+    totals: {
+      inserted: reports.reduce((a, r) => a + r.inserted, 0),
+      updated: reports.reduce((a, r) => a + r.updated, 0),
+      mergedByIdentity: reports.reduce((a, r) => a + r.mergedByIdentity, 0),
+      skipped: reports.reduce((a, r) => a + r.skipped, 0),
+      skippedUnresolvedId: reports.reduce((a, r) => a + r.skippedUnresolvedId, 0),
+      skippedError: reports.reduce((a, r) => a + r.skippedError, 0),
+      seen: reports.reduce((a, r) => a + r.rowsSeen, 0)
+    },
+    ...healed.length > 0 ? { healedProfiles: healed } : {},
+    ...flags.cleanup ? {
+      cleanup: {
+        files: cleanupFiles,
+        deleted: cleanupDeleted,
+        ...flags.dryRun ? { dryRun: true } : {}
+      }
+    } : {}
+  });
+}
+async function buildIdentityMap(backend, type, identityKey) {
+  const map = /* @__PURE__ */ new Map();
+  if (!identityKey || !backend.capabilities().rawSql || typeof backend.raw !== "function") {
+    return map;
+  }
+  const jsonbExpr = dotPathToJsonbExpr(identityKey);
+  if (!jsonbExpr) return map;
+  try {
+    const res = await backend.raw(
+      `SELECT id, keys, (${jsonbExpr}) AS ident
+       FROM mem_records
+       WHERE type = $1 AND status = 'active'`,
+      [type]
+    );
+    for (const row of res.rows) {
+      const ident = row.ident;
+      if (ident === null || ident === void 0 || typeof ident !== "string") continue;
+      const norm = ident.toLowerCase().trim();
+      if (!norm) continue;
+      if (!map.has(norm)) {
+        map.set(norm, {
+          id: String(row.id),
+          keys: Array.isArray(row.keys) ? row.keys : []
+        });
+      }
+    }
+  } catch {
+  }
+  return map;
+}
+function dotPathToJsonbExpr(dotPath) {
+  const parts = dotPath.split(".").flatMap((p2) => {
+    const match = p2.match(/^([^[]+)\[(\d+)\]$/);
+    if (match) return [match[1], match[2]];
+    return [p2];
+  });
+  if (parts.length === 0) return null;
+  let expr = "data";
+  for (let i = 0; i < parts.length; i++) {
+    const seg = parts[i];
+    const isLast = i === parts.length - 1;
+    if (/^\d+$/.test(seg)) {
+      expr += (isLast ? "->>" : "->") + seg;
+    } else if (/^\w+$/.test(seg)) {
+      expr += (isLast ? "->>'" : "->'") + seg + "'";
+    } else {
+      return null;
+    }
+  }
+  return expr;
+}
+function reviveStringifiedJson(row) {
+  const out = { ...row };
+  for (const [key, value] of Object.entries(out)) {
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    if (!(trimmed.startsWith("{") || trimmed.startsWith("["))) continue;
+    try {
+      out[key] = JSON.parse(trimmed);
+    } catch {
+    }
+  }
+  return out;
+}
+function isBuiltinNewerThanInstalled(platform, model) {
+  try {
+    const installed = path4.join(".one", "sync", "profiles", `${platform}_${model}.json`);
+    if (!fs4.existsSync(installed)) return void 0;
+    const installedStat = fs4.statSync(installed);
+    const builtinPath = resolveBuiltinProfilePath(platform, model);
+    if (!builtinPath) return void 0;
+    const builtinStat = fs4.statSync(builtinPath);
+    return builtinStat.mtimeMs > installedStat.mtimeMs;
+  } catch {
+    return void 0;
+  }
+}
+function resolveBuiltinProfilePath(platform, model) {
+  const dir = getProfilesDir();
+  if (!dir) return null;
+  const candidate = path4.join(dir, platform, `${model}.json`);
+  return fs4.existsSync(candidate) ? candidate : null;
+}
+function deriveIdentityPrefix(path5) {
+  const lower = path5.toLowerCase();
+  if (lower.includes("email")) return "email";
+  if (lower.includes("phone")) return "phone";
+  if (lower.includes("domain")) return "domain";
+  return "id";
+}
+
+export {
+  readProfile,
+  writeProfile,
+  resolveProfileConnectionKey,
+  writeDraftProfile,
+  listProfiles,
+  generateTemplate,
+  loadSqlite,
+  isSqliteAvailable,
+  openDatabase,
+  getDatabaseSize,
+  sanitizeTableName,
+  tableExists,
+  ensureTable,
+  rebuildFtsIndex,
+  evolveSchema,
+  upsertRecords,
+  deleteRecords,
+  dropTable,
+  countRecords,
+  deleteDatabase,
+  loadBuiltinProfile,
+  listBuiltinProfiles,
+  memMigrateCommand,
+  buildIdentityMap,
+  dotPathToJsonbExpr,
+  reviveStringifiedJson
+};