@memrosetta/cli 0.5.1 → 0.5.2

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
+};

package/dist/reset-IPOAKTJM.js

@@ -0,0 +1,132 @@
+import {
+  removeAgentsMdSection,
+  removeClaudeCodeHooks,
+  removeClaudeMdSection,
+  removeCodexHooks,
+  removeCodexMCP,
+  removeCursorMCP,
+  removeCursorRulesSection,
+  removeGeminiMCP,
+  removeGeminiMdSection,
+  removeGenericMCP
+} from "./chunk-4LNXT25H.js";
+import {
+  hasFlag
+} from "./chunk-US6CEDMU.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+
+// src/commands/reset.ts
+async function run(options) {
+  const { args, format } = options;
+  const wantClaudeCode = hasFlag(args, "--claude-code");
+  const wantCursor = hasFlag(args, "--cursor");
+  const wantCodex = hasFlag(args, "--codex");
+  const wantGemini = hasFlag(args, "--gemini");
+  const wantMCP = hasFlag(args, "--mcp");
+  const wantAll = hasFlag(args, "--all");
+  const noFlags = !wantClaudeCode && !wantCursor && !wantCodex && !wantGemini && !wantMCP && !wantAll;
+  if (noFlags) {
+    const msg = "Usage: memrosetta reset [--claude-code] [--cursor] [--codex] [--gemini] [--mcp] [--all]\n\nFlags:\n  --claude-code  Remove Claude Code hooks, MCP, and CLAUDE.md section\n  --cursor       Remove Cursor MCP configuration\n  --codex        Remove Codex MCP configuration and AGENTS.md section\n  --gemini       Remove Gemini MCP configuration and GEMINI.md section\n  --mcp          Remove generic MCP configuration (~/.mcp.json)\n  --all          Remove all integrations\n";
+    if (format === "text") {
+      process.stdout.write(msg);
+    } else {
+      output({ error: "No flags specified. Use --claude-code, --cursor, --codex, --gemini, --mcp, or --all." }, format);
+    }
+    return;
+  }
+  const result = {
+    removed: {
+      claudeCodeHooks: false,
+      claudeMd: false,
+      mcp: false,
+      cursor: false,
+      cursorRules: false,
+      codex: false,
+      agentsMd: false,
+      gemini: false,
+      geminiMd: false
+    }
+  };
+  if (wantClaudeCode || wantAll) {
+    const hooksRemoved = removeClaudeCodeHooks();
+    const mdRemoved = removeClaudeMdSection();
+    const mcpRemoved = removeGenericMCP();
+    result.removed.claudeCodeHooks = hooksRemoved;
+    result.removed.claudeMd = mdRemoved;
+    if (!wantMCP) {
+      result.removed.mcp = mcpRemoved;
+    }
+  }
+  if (wantCursor || wantAll) {
+    const removed = removeCursorMCP();
+    result.removed.cursor = removed;
+    const rulesRemoved = removeCursorRulesSection();
+    result.removed.cursorRules = rulesRemoved;
+  }
+  if (wantCodex || wantAll) {
+    const removed = removeCodexMCP();
+    result.removed.codex = removed;
+    const mdRemoved = removeAgentsMdSection();
+    result.removed.agentsMd = mdRemoved;
+    const stopHookRemoved = removeCodexHooks();
+    result.removed.codexStopHook = stopHookRemoved;
+  }
+  if (wantGemini || wantAll) {
+    const removed = removeGeminiMCP();
+    result.removed.gemini = removed;
+    const mdRemoved = removeGeminiMdSection();
+    result.removed.geminiMd = mdRemoved;
+  }
+  if (wantMCP || wantAll) {
+    const removed = removeGenericMCP();
+    result.removed.mcp = removed;
+  }
+  if (format === "text") {
+    printTextOutput(result);
+    return;
+  }
+  output(result, format);
+}
+function printTextOutput(result) {
+  const w = (s) => process.stdout.write(s);
+  const removed = result.removed;
+  if (removed.claudeCodeHooks) {
+    w("Removed Claude Code hooks from ~/.claude/settings.json\n");
+  }
+  if (removed.claudeMd) {
+    w("Removed MemRosetta section from ~/.claude/CLAUDE.md\n");
+  }
+  if (removed.mcp) {
+    w("Removed MCP server from ~/.mcp.json\n");
+  }
+  if (removed.cursor) {
+    w("Removed Cursor MCP from ~/.cursor/mcp.json\n");
+  }
+  if (removed.cursorRules) {
+    w("Removed MemRosetta section from ~/.cursorrules\n");
+  }
+  if (removed.codex) {
+    w("Removed Codex MCP from ~/.codex/config.toml\n");
+  }
+  if (removed.agentsMd) {
+    w("Removed MemRosetta section from AGENTS.md\n");
+  }
+  if (removed.gemini) {
+    w("Removed Gemini MCP from ~/.gemini/settings.json\n");
+  }
+  if (removed.geminiMd) {
+    w("Removed MemRosetta section from GEMINI.md\n");
+  }
+  const anyRemoved = removed.claudeCodeHooks || removed.claudeMd || removed.mcp || removed.cursor || removed.cursorRules || removed.codex || removed.agentsMd || removed.gemini || removed.geminiMd;
+  if (!anyRemoved) {
+    w("Nothing to remove (no integrations were configured).\n");
+  }
+  w(
+    "\nNote: ~/.memrosetta/ directory preserved. Delete manually if needed:\n  rm -rf ~/.memrosetta\n"
+  );
+}
+export {
+  run
+};

package/dist/search-AYZBKRXF.js

@@ -0,0 +1,48 @@
+import {
+  optionalOption,
+  requireOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-47SU2YUJ.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-WYHEAKPC.js";
+
+// src/commands/search.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const query = requireOption(args, "--query", "query");
+  const limitRaw = optionalOption(args, "--limit");
+  const namespace = optionalOption(args, "--namespace");
+  const typesRaw = optionalOption(args, "--types");
+  const minConfidenceRaw = optionalOption(args, "--min-confidence");
+  const limit = limitRaw ? parseInt(limitRaw, 10) : 5;
+  if (isNaN(limit) || limit < 1) {
+    outputError("Invalid limit value", format);
+    process.exitCode = 1;
+    return;
+  }
+  const memoryTypes = typesRaw ? typesRaw.split(",") : void 0;
+  const minConfidence = minConfidenceRaw ? parseFloat(minConfidenceRaw) : void 0;
+  const engine = await getEngine({ db, noEmbeddings });
+  const response = await engine.search({
+    userId,
+    query,
+    namespace,
+    limit,
+    filters: {
+      memoryTypes,
+      minConfidence
+    }
+  });
+  output(response, format);
+}
+export {
+  run
+};

package/dist/search-JQ3MLRKS.js

@@ -0,0 +1,48 @@
+import {
+  optionalOption,
+  requireOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-VMGX5FCY.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-RZFCVYTK.js";
+
+// src/commands/search.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const query = requireOption(args, "--query", "query");
+  const limitRaw = optionalOption(args, "--limit");
+  const namespace = optionalOption(args, "--namespace");
+  const typesRaw = optionalOption(args, "--types");
+  const minConfidenceRaw = optionalOption(args, "--min-confidence");
+  const limit = limitRaw ? parseInt(limitRaw, 10) : 5;
+  if (isNaN(limit) || limit < 1) {
+    outputError("Invalid limit value", format);
+    process.exitCode = 1;
+    return;
+  }
+  const memoryTypes = typesRaw ? typesRaw.split(",") : void 0;
+  const minConfidence = minConfidenceRaw ? parseFloat(minConfidenceRaw) : void 0;
+  const engine = await getEngine({ db, noEmbeddings });
+  const response = await engine.search({
+    userId,
+    query,
+    namespace,
+    limit,
+    filters: {
+      memoryTypes,
+      minConfidence
+    }
+  });
+  output(response, format);
+}
+export {
+  run
+};