@memrosetta/cli 0.5.0 → 0.5.2

package/dist/migrate-CZL3YNQK.js

@@ -0,0 +1,255 @@
+import {
+  hasFlag,
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  resolveDbPath
+} from "./chunk-47SU2YUJ.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  resolveCanonicalUserId
+} from "./chunk-WYHEAKPC.js";
+
+// src/commands/migrate.ts
+import { createInterface } from "readline";
+var MIGRATION_NAME = "legacy-user-id-to-canonical-v1";
+function scanLegacyImpact(db, canonicalUserId) {
+  const totalRows = db.prepare("SELECT COUNT(*) AS c FROM memories").get().c;
+  const legacyRows = db.prepare("SELECT COUNT(*) AS c FROM memories WHERE user_id != ?").get(canonicalUserId).c;
+  const breakdownRows = db.prepare(
+    `SELECT user_id AS legacyUserId, COUNT(*) AS rows, COUNT(DISTINCT namespace) AS distinctNamespaces
+       FROM memories
+       WHERE user_id != ?
+       GROUP BY user_id
+       ORDER BY rows DESC`
+  ).all(canonicalUserId);
+  const queuePending = hasTable(db, "sync_outbox") ? db.prepare("SELECT COUNT(*) AS c FROM sync_outbox WHERE pushed_at IS NULL").get().c : 0;
+  const crossPartitionDuplicateGroups = db.prepare(
+    `WITH x AS (
+          SELECT content, COUNT(DISTINCT user_id) AS u
+          FROM memories
+          GROUP BY content
+        )
+        SELECT COUNT(*) AS c FROM x WHERE u > 1`
+  ).get().c;
+  const alreadyMigrated = hasTable(db, "migration_version") ? Boolean(
+    db.prepare("SELECT 1 FROM migration_version WHERE name = ?").get(MIGRATION_NAME)
+  ) : false;
+  return {
+    canonicalUserId,
+    totalRows,
+    legacyRows,
+    distinctLegacyUserIds: breakdownRows.length,
+    breakdown: breakdownRows,
+    queuePending,
+    crossPartitionDuplicateGroups,
+    alreadyMigrated
+  };
+}
+function hasTable(db, name) {
+  const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name);
+  return Boolean(row);
+}
+function runLegacyUserIdMigration(db, canonicalUserId) {
+  const run2 = db.transaction(() => {
+    const insert = db.prepare(
+      `INSERT OR IGNORE INTO memory_legacy_scope (
+         memory_id, legacy_user_id, legacy_namespace, migrated_at
+       )
+       SELECT memory_id, user_id, namespace, CURRENT_TIMESTAMP
+       FROM memories
+       WHERE user_id != ?`
+    );
+    const insertInfo = insert.run(canonicalUserId);
+    const legacyScopeRows = insertInfo.changes;
+    const update = db.prepare(
+      "UPDATE memories SET user_id = ? WHERE user_id != ?"
+    );
+    const updateInfo = update.run(canonicalUserId, canonicalUserId);
+    const movedRows = updateInfo.changes;
+    let outboxCleared = 0;
+    let inboxCleared = 0;
+    if (hasTable(db, "sync_outbox")) {
+      outboxCleared = db.prepare("DELETE FROM sync_outbox").run().changes;
+    }
+    if (hasTable(db, "sync_inbox")) {
+      inboxCleared = db.prepare("DELETE FROM sync_inbox").run().changes;
+    }
+    let cursorReset = false;
+    if (hasTable(db, "sync_state")) {
+      const r = db.prepare(
+        `DELETE FROM sync_state WHERE key IN (
+             'last_cursor',
+             'pull_cursor',
+             'last_push_attempt_at',
+             'last_push_success_at',
+             'last_pull_attempt_at',
+             'last_pull_success_at'
+           )`
+      ).run();
+      cursorReset = r.changes > 0;
+    }
+    db.prepare(
+      `INSERT OR IGNORE INTO migration_version (name, applied_at)
+       VALUES (?, CURRENT_TIMESTAMP)`
+    ).run(MIGRATION_NAME);
+    return {
+      movedRows,
+      legacyScopeRows,
+      outboxCleared,
+      inboxCleared,
+      cursorReset
+    };
+  });
+  return run2();
+}
+async function confirmInteractive(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise((resolve) => {
+      rl.question(`${question} [y/N] `, (a) => resolve(a));
+    });
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function run(options) {
+  const { args, format, db: dbOverride } = options;
+  const sub = args[0];
+  if (sub !== "legacy-user-ids") {
+    outputError(
+      "Usage: memrosetta migrate legacy-user-ids [--dry-run] [--canonical <user>] [--yes]",
+      format
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const sliced = args.slice(1);
+  const dryRun = hasFlag(sliced, "--dry-run");
+  const autoYes = hasFlag(sliced, "--yes") || hasFlag(sliced, "-y");
+  const canonicalOverride = optionalOption(sliced, "--canonical");
+  const canonicalUserId = resolveCanonicalUserId(canonicalOverride ?? null);
+  const dbPath = resolveDbPath(dbOverride);
+  const { default: Database } = await import("better-sqlite3");
+  const db = new Database(dbPath);
+  try {
+    const { ensureSchema } = await import("@memrosetta/core");
+    ensureSchema(db, { vectorEnabled: false });
+    const report = scanLegacyImpact(db, canonicalUserId);
+    if (report.alreadyMigrated && report.legacyRows === 0) {
+      output(
+        {
+          status: "noop",
+          reason: `migration ${MIGRATION_NAME} already applied and no legacy rows remain`,
+          report
+        },
+        format
+      );
+      return;
+    }
+    if (report.legacyRows === 0) {
+      output(
+        {
+          status: "noop",
+          reason: "no legacy user_id partitions found",
+          report
+        },
+        format
+      );
+      return;
+    }
+    if (dryRun) {
+      output(
+        {
+          status: "dry-run",
+          canonicalUserId,
+          report,
+          wouldClear: {
+            syncOutbox: true,
+            syncInbox: true,
+            cursorState: true
+          },
+          nextSteps: [
+            "Run without --dry-run to apply the migration.",
+            "After migration: `memrosetta sync backfill` then `memrosetta sync now`."
+          ]
+        },
+        format
+      );
+      return;
+    }
+    if (!autoYes) {
+      printImpactPreview(report, canonicalUserId);
+      const ok = await confirmInteractive(
+        `Apply migration and move ${report.legacyRows} row(s) onto '${canonicalUserId}'?`
+      );
+      if (!ok) {
+        output(
+          {
+            status: "aborted",
+            reason: "user declined or non-interactive session (pass --yes to skip prompt)",
+            report
+          },
+          format
+        );
+        return;
+      }
+    }
+    const result = runLegacyUserIdMigration(db, canonicalUserId);
+    output(
+      {
+        status: "applied",
+        canonicalUserId,
+        migration: MIGRATION_NAME,
+        result,
+        nextSteps: [
+          `Run \`memrosetta sync backfill --user ${canonicalUserId}\` to republish memories onto the canonical partition.`,
+          "Then `memrosetta sync now` to push them to the hub.",
+          "Run `memrosetta duplicates report` to audit cross-partition duplicates before any future dedupe pass."
+        ]
+      },
+      format
+    );
+  } finally {
+    db.close();
+  }
+}
+function printImpactPreview(report, canonicalUserId) {
+  process.stderr.write(
+    [
+      "",
+      "Migration impact preview",
+      "------------------------",
+      `  canonical user            : ${canonicalUserId}`,
+      `  total memories            : ${report.totalRows}`,
+      `  legacy rows to move       : ${report.legacyRows}`,
+      `  distinct legacy partitions: ${report.distinctLegacyUserIds}`,
+      `  sync_outbox pending       : ${report.queuePending}`,
+      `  cross-partition dup groups: ${report.crossPartitionDuplicateGroups}`,
+      "",
+      "Top legacy partitions:",
+      ...report.breakdown.slice(0, 10).map(
+        (r) => `  - ${r.legacyUserId.padEnd(40)} rows=${r.rows}  namespaces=${r.distinctNamespaces}`
+      ),
+      "",
+      "This will:",
+      "  * copy legacy rows into memory_legacy_scope (non-destructive)",
+      "  * rewrite memories.user_id to the canonical user",
+      "  * leave memories.namespace untouched",
+      "  * clear sync_outbox / sync_inbox / sync cursor state",
+      "",
+      "Back up ~/.memrosetta/memories.db before continuing if you have not already.",
+      ""
+    ].join("\n")
+  );
+}
+export {
+  run,
+  runLegacyUserIdMigration,
+  scanLegacyImpact
+};

package/dist/migrate-FI26FSBP.js

@@ -0,0 +1,255 @@
+import {
+  hasFlag,
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  resolveDbPath
+} from "./chunk-VMGX5FCY.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  resolveCanonicalUserId
+} from "./chunk-RZFCVYTK.js";
+
+// src/commands/migrate.ts
+import { createInterface } from "readline";
+var MIGRATION_NAME = "legacy-user-id-to-canonical-v1";
+function scanLegacyImpact(db, canonicalUserId) {
+  const totalRows = db.prepare("SELECT COUNT(*) AS c FROM memories").get().c;
+  const legacyRows = db.prepare("SELECT COUNT(*) AS c FROM memories WHERE user_id != ?").get(canonicalUserId).c;
+  const breakdownRows = db.prepare(
+    `SELECT user_id AS legacyUserId, COUNT(*) AS rows, COUNT(DISTINCT namespace) AS distinctNamespaces
+       FROM memories
+       WHERE user_id != ?
+       GROUP BY user_id
+       ORDER BY rows DESC`
+  ).all(canonicalUserId);
+  const queuePending = hasTable(db, "sync_outbox") ? db.prepare("SELECT COUNT(*) AS c FROM sync_outbox WHERE pushed_at IS NULL").get().c : 0;
+  const crossPartitionDuplicateGroups = db.prepare(
+    `WITH x AS (
+          SELECT content, COUNT(DISTINCT user_id) AS u
+          FROM memories
+          GROUP BY content
+        )
+        SELECT COUNT(*) AS c FROM x WHERE u > 1`
+  ).get().c;
+  const alreadyMigrated = hasTable(db, "migration_version") ? Boolean(
+    db.prepare("SELECT 1 FROM migration_version WHERE name = ?").get(MIGRATION_NAME)
+  ) : false;
+  return {
+    canonicalUserId,
+    totalRows,
+    legacyRows,
+    distinctLegacyUserIds: breakdownRows.length,
+    breakdown: breakdownRows,
+    queuePending,
+    crossPartitionDuplicateGroups,
+    alreadyMigrated
+  };
+}
+function hasTable(db, name) {
+  const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name);
+  return Boolean(row);
+}
+function runLegacyUserIdMigration(db, canonicalUserId) {
+  const run2 = db.transaction(() => {
+    const insert = db.prepare(
+      `INSERT OR IGNORE INTO memory_legacy_scope (
+         memory_id, legacy_user_id, legacy_namespace, migrated_at
+       )
+       SELECT memory_id, user_id, namespace, CURRENT_TIMESTAMP
+       FROM memories
+       WHERE user_id != ?`
+    );
+    const insertInfo = insert.run(canonicalUserId);
+    const legacyScopeRows = insertInfo.changes;
+    const update = db.prepare(
+      "UPDATE memories SET user_id = ? WHERE user_id != ?"
+    );
+    const updateInfo = update.run(canonicalUserId, canonicalUserId);
+    const movedRows = updateInfo.changes;
+    let outboxCleared = 0;
+    let inboxCleared = 0;
+    if (hasTable(db, "sync_outbox")) {
+      outboxCleared = db.prepare("DELETE FROM sync_outbox").run().changes;
+    }
+    if (hasTable(db, "sync_inbox")) {
+      inboxCleared = db.prepare("DELETE FROM sync_inbox").run().changes;
+    }
+    let cursorReset = false;
+    if (hasTable(db, "sync_state")) {
+      const r = db.prepare(
+        `DELETE FROM sync_state WHERE key IN (
+             'last_cursor',
+             'pull_cursor',
+             'last_push_attempt_at',
+             'last_push_success_at',
+             'last_pull_attempt_at',
+             'last_pull_success_at'
+           )`
+      ).run();
+      cursorReset = r.changes > 0;
+    }
+    db.prepare(
+      `INSERT OR IGNORE INTO migration_version (name, applied_at)
+       VALUES (?, CURRENT_TIMESTAMP)`
+    ).run(MIGRATION_NAME);
+    return {
+      movedRows,
+      legacyScopeRows,
+      outboxCleared,
+      inboxCleared,
+      cursorReset
+    };
+  });
+  return run2();
+}
+async function confirmInteractive(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise((resolve) => {
+      rl.question(`${question} [y/N] `, (a) => resolve(a));
+    });
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function run(options) {
+  const { args, format, db: dbOverride } = options;
+  const sub = args[0];
+  if (sub !== "legacy-user-ids") {
+    outputError(
+      "Usage: memrosetta migrate legacy-user-ids [--dry-run] [--canonical <user>] [--yes]",
+      format
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const sliced = args.slice(1);
+  const dryRun = hasFlag(sliced, "--dry-run");
+  const autoYes = hasFlag(sliced, "--yes") || hasFlag(sliced, "-y");
+  const canonicalOverride = optionalOption(sliced, "--canonical");
+  const canonicalUserId = resolveCanonicalUserId(canonicalOverride ?? null);
+  const dbPath = resolveDbPath(dbOverride);
+  const { default: Database } = await import("better-sqlite3");
+  const db = new Database(dbPath);
+  try {
+    const { ensureSchema } = await import("@memrosetta/core");
+    ensureSchema(db, { vectorEnabled: false });
+    const report = scanLegacyImpact(db, canonicalUserId);
+    if (report.alreadyMigrated && report.legacyRows === 0) {
+      output(
+        {
+          status: "noop",
+          reason: `migration ${MIGRATION_NAME} already applied and no legacy rows remain`,
+          report
+        },
+        format
+      );
+      return;
+    }
+    if (report.legacyRows === 0) {
+      output(
+        {
+          status: "noop",
+          reason: "no legacy user_id partitions found",
+          report
+        },
+        format
+      );
+      return;
+    }
+    if (dryRun) {
+      output(
+        {
+          status: "dry-run",
+          canonicalUserId,
+          report,
+          wouldClear: {
+            syncOutbox: true,
+            syncInbox: true,
+            cursorState: true
+          },
+          nextSteps: [
+            "Run without --dry-run to apply the migration.",
+            "After migration: `memrosetta sync backfill` then `memrosetta sync now`."
+          ]
+        },
+        format
+      );
+      return;
+    }
+    if (!autoYes) {
+      printImpactPreview(report, canonicalUserId);
+      const ok = await confirmInteractive(
+        `Apply migration and move ${report.legacyRows} row(s) onto '${canonicalUserId}'?`
+      );
+      if (!ok) {
+        output(
+          {
+            status: "aborted",
+            reason: "user declined or non-interactive session (pass --yes to skip prompt)",
+            report
+          },
+          format
+        );
+        return;
+      }
+    }
+    const result = runLegacyUserIdMigration(db, canonicalUserId);
+    output(
+      {
+        status: "applied",
+        canonicalUserId,
+        migration: MIGRATION_NAME,
+        result,
+        nextSteps: [
+          `Run \`memrosetta sync backfill --user ${canonicalUserId}\` to republish memories onto the canonical partition.`,
+          "Then `memrosetta sync now` to push them to the hub.",
+          "Run `memrosetta duplicates report` to audit cross-partition duplicates before any future dedupe pass."
+        ]
+      },
+      format
+    );
+  } finally {
+    db.close();
+  }
+}
+function printImpactPreview(report, canonicalUserId) {
+  process.stderr.write(
+    [
+      "",
+      "Migration impact preview",
+      "------------------------",
+      `  canonical user            : ${canonicalUserId}`,
+      `  total memories            : ${report.totalRows}`,
+      `  legacy rows to move       : ${report.legacyRows}`,
+      `  distinct legacy partitions: ${report.distinctLegacyUserIds}`,
+      `  sync_outbox pending       : ${report.queuePending}`,
+      `  cross-partition dup groups: ${report.crossPartitionDuplicateGroups}`,
+      "",
+      "Top legacy partitions:",
+      ...report.breakdown.slice(0, 10).map(
+        (r) => `  - ${r.legacyUserId.padEnd(40)} rows=${r.rows}  namespaces=${r.distinctNamespaces}`
+      ),
+      "",
+      "This will:",
+      "  * copy legacy rows into memory_legacy_scope (non-destructive)",
+      "  * rewrite memories.user_id to the canonical user",
+      "  * leave memories.namespace untouched",
+      "  * clear sync_outbox / sync_inbox / sync cursor state",
+      "",
+      "Back up ~/.memrosetta/memories.db before continuing if you have not already.",
+      ""
+    ].join("\n")
+  );
+}
+export {
+  run,
+  runLegacyUserIdMigration,
+  scanLegacyImpact
+};

package/dist/relate-5TN2WEG3.js

@@ -0,0 +1,57 @@
+import {
+  buildRelationCreatedOp,
+  openCliSyncContext
+} from "./chunk-GGXC7TAJ.js";
+import {
+  optionalOption,
+  requireOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-47SU2YUJ.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-WYHEAKPC.js";
+
+// src/commands/relate.ts
+var VALID_RELATION_TYPES = /* @__PURE__ */ new Set([
+  "updates",
+  "extends",
+  "derives",
+  "contradicts",
+  "supports"
+]);
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const src = requireOption(args, "--src", "source memory ID");
+  const dst = requireOption(args, "--dst", "destination memory ID");
+  const relationType = requireOption(args, "--type", "relation type");
+  const reason = optionalOption(args, "--reason");
+  if (!VALID_RELATION_TYPES.has(relationType)) {
+    outputError(
+      `Invalid relation type: ${relationType}. Must be one of: updates, extends, derives, contradicts, supports`,
+      format
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const relation = await engine.relate(
+    src,
+    dst,
+    relationType,
+    reason
+  );
+  const sync = await openCliSyncContext(resolveDbPath(db));
+  if (sync.enabled) {
+    sync.enqueue(buildRelationCreatedOp(sync, relation));
+    sync.close();
+  }
+  output(relation, format);
+}
+export {
+  run
+};

package/dist/relate-KLBMYWB3.js

@@ -0,0 +1,57 @@
+import {
+  buildRelationCreatedOp,
+  openCliSyncContext
+} from "./chunk-GZINXXM4.js";
+import {
+  optionalOption,
+  requireOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-VMGX5FCY.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-RZFCVYTK.js";
+
+// src/commands/relate.ts
+var VALID_RELATION_TYPES = /* @__PURE__ */ new Set([
+  "updates",
+  "extends",
+  "derives",
+  "contradicts",
+  "supports"
+]);
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const src = requireOption(args, "--src", "source memory ID");
+  const dst = requireOption(args, "--dst", "destination memory ID");
+  const relationType = requireOption(args, "--type", "relation type");
+  const reason = optionalOption(args, "--reason");
+  if (!VALID_RELATION_TYPES.has(relationType)) {
+    outputError(
+      `Invalid relation type: ${relationType}. Must be one of: updates, extends, derives, contradicts, supports`,
+      format
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const relation = await engine.relate(
+    src,
+    dst,
+    relationType,
+    reason
+  );
+  const sync = await openCliSyncContext(resolveDbPath(db));
+  if (sync.enabled) {
+    sync.enqueue(buildRelationCreatedOp(sync, relation));
+    sync.close();
+  }
+  output(relation, format);
+}
+export {
+  run
+};