@memrosetta/cli 0.5.1 → 0.5.3

package/dist/init-LHXRCCLX.js

@@ -0,0 +1,210 @@
+import {
+  getAgentsMdPath,
+  getCodexConfigFilePath,
+  getCodexHooksPath,
+  getCursorMcpConfigPath,
+  getCursorRulesPath,
+  getGeminiMdPath,
+  getGeminiSettingsFilePath,
+  getGenericMCPPath,
+  isClaudeCodeInstalled,
+  registerClaudeCodeHooks,
+  registerCodexHooks,
+  registerCodexMCP,
+  registerCursorMCP,
+  registerGeminiMCP,
+  registerGenericMCP,
+  updateClaudeMd
+} from "./chunk-4LNXT25H.js";
+import {
+  hasFlag,
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getDefaultDbPath,
+  getEngine
+} from "./chunk-47SU2YUJ.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getConfig,
+  writeConfig
+} from "./chunk-WYHEAKPC.js";
+
+// src/commands/init.ts
+import { existsSync } from "fs";
+var LANG_FLAG_TO_PRESET = {
+  en: "en",
+  multi: "multilingual",
+  ko: "ko"
+};
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const wantClaudeCode = hasFlag(args, "--claude-code");
+  const wantCursor = hasFlag(args, "--cursor");
+  const wantCodex = hasFlag(args, "--codex");
+  const wantGemini = hasFlag(args, "--gemini");
+  const langFlag = optionalOption(args, "--lang");
+  const embeddingPreset = langFlag ? LANG_FLAG_TO_PRESET[langFlag] : void 0;
+  if (langFlag && !LANG_FLAG_TO_PRESET[langFlag]) {
+    process.stderr.write(
+      `Unknown --lang value: "${langFlag}". Supported: en, multi, ko
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  {
+    const config2 = getConfig();
+    const updates = {};
+    if (db) {
+      updates.dbPath = db;
+    }
+    if (noEmbeddings) {
+      updates.enableEmbeddings = false;
+    }
+    if (embeddingPreset) {
+      updates.embeddingPreset = embeddingPreset;
+    }
+    if (Object.keys(updates).length > 0) {
+      writeConfig({ ...config2, ...updates });
+    }
+  }
+  const config = getConfig();
+  const dbPath = db ?? config.dbPath ?? getDefaultDbPath();
+  const existed = existsSync(dbPath);
+  const engine = await getEngine({ db: dbPath, noEmbeddings });
+  await engine.close();
+  const result = {
+    database: {
+      path: dbPath,
+      created: !existed
+    },
+    integrations: {}
+  };
+  registerGenericMCP();
+  result.integrations.mcp = {
+    registered: true,
+    path: getGenericMCPPath()
+  };
+  if (wantClaudeCode) {
+    const hooksOk = registerClaudeCodeHooks();
+    const claudeMdOk = updateClaudeMd();
+    result.integrations.claudeCode = {
+      hooks: hooksOk,
+      mcp: true,
+      claudeMd: claudeMdOk
+    };
+  }
+  if (wantCursor) {
+    const cursorRulesUpdated = registerCursorMCP();
+    result.integrations.cursor = {
+      mcp: true,
+      path: getCursorMcpConfigPath(),
+      cursorRules: cursorRulesUpdated,
+      cursorRulesPath: getCursorRulesPath()
+    };
+  }
+  if (wantCodex) {
+    const agentsMdUpdated = registerCodexMCP();
+    const hooksRegistered = registerCodexHooks();
+    result.integrations.codex = {
+      mcp: true,
+      path: getCodexConfigFilePath(),
+      agentsMd: agentsMdUpdated,
+      agentsMdPath: getAgentsMdPath(),
+      stopHook: hooksRegistered,
+      stopHookPath: getCodexHooksPath()
+    };
+  }
+  if (wantGemini) {
+    const geminiMdUpdated = registerGeminiMCP();
+    result.integrations.gemini = {
+      mcp: true,
+      path: getGeminiSettingsFilePath(),
+      geminiMd: geminiMdUpdated,
+      geminiMdPath: getGeminiMdPath()
+    };
+  }
+  if (format === "text") {
+    printTextOutput(result, wantClaudeCode, wantCursor, wantCodex, wantGemini);
+    return;
+  }
+  output(result, format);
+}
+function printTextOutput(result, claudeCode, cursor, codex = false, gemini = false) {
+  const w = (s) => process.stdout.write(s);
+  w("\nMemRosetta initialized successfully.\n\n");
+  w("  What was set up:\n");
+  w("  ----------------------------------------\n");
+  w(`  Database:   ${result.database.path}`);
+  w(result.database.created ? " (created)\n" : " (already exists)\n");
+  w(`  MCP Server: ${result.integrations.mcp.path} (always included)
+`);
+  const currentConfig = getConfig();
+  if (currentConfig.embeddingPreset && currentConfig.embeddingPreset !== "en") {
+    const presetLabels = {
+      multilingual: "multilingual (multilingual-e5-small)",
+      ko: "Korean (ko-sroberta-multitask)"
+    };
+    w(`  Embeddings: ${presetLabels[currentConfig.embeddingPreset] ?? currentConfig.embeddingPreset}
+`);
+  }
+  if (claudeCode) {
+    const cc = result.integrations.claudeCode;
+    if (cc.hooks) {
+      w("  Stop Hook:  ~/.claude/settings.json (auto-save on session end)\n");
+    } else if (!isClaudeCodeInstalled()) {
+      w("  Stop Hook:  SKIPPED (Claude Code not found at ~/.claude)\n");
+      w('              Install Claude Code first, then run "memrosetta init --claude-code" again.\n');
+    }
+    if (cc.claudeMd) {
+      w("  CLAUDE.md:  ~/.claude/CLAUDE.md (memory instructions added)\n");
+    } else {
+      w("  CLAUDE.md:  already configured\n");
+    }
+  }
+  if (cursor) {
+    w(`  Cursor MCP: ${result.integrations.cursor.path}
+`);
+    if (result.integrations.cursor.cursorRules) {
+      w(`  .cursorrules: ${result.integrations.cursor.cursorRulesPath} (memory instructions added)
+`);
+    } else {
+      w("  .cursorrules: already configured\n");
+    }
+  }
+  if (codex) {
+    w(`  Codex MCP:  ${result.integrations.codex.path}
+`);
+    if (result.integrations.codex.agentsMd) {
+      w(`  AGENTS.md:  ${result.integrations.codex.agentsMdPath} (memory instructions added)
+`);
+    } else {
+      w("  AGENTS.md:  already configured\n");
+    }
+  }
+  if (gemini) {
+    w(`  Gemini MCP: ${result.integrations.gemini.path}
+`);
+    if (result.integrations.gemini.geminiMd) {
+      w(`  GEMINI.md:  ${result.integrations.gemini.geminiMdPath} (memory instructions added)
+`);
+    } else {
+      w("  GEMINI.md:  already configured\n");
+    }
+  }
+  w("\n");
+  if (!claudeCode && !cursor && !codex && !gemini) {
+    w("  MCP is ready. Add --claude-code, --cursor, --codex, or --gemini for tool-specific setup.\n");
+    w("  Example: memrosetta init --claude-code\n");
+    w("\n");
+  }
+  if (claudeCode) {
+    w("  Restart Claude Code to activate.\n\n");
+  }
+}
+export {
+  run
+};

package/dist/invalidate-ER2TFFWK.js

@@ -0,0 +1,40 @@
+import {
+  buildMemoryInvalidatedOp,
+  openCliSyncContext
+} from "./chunk-GGXC7TAJ.js";
+import {
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-47SU2YUJ.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-WYHEAKPC.js";
+
+// src/commands/invalidate.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const memoryId = args.find((a) => !a.startsWith("-"));
+  if (!memoryId) {
+    outputError("Usage: memrosetta invalidate <memoryId>", format);
+    process.exitCode = 1;
+    return;
+  }
+  const reason = optionalOption(args, "--reason");
+  const engine = await getEngine({ db, noEmbeddings });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await engine.invalidate(memoryId, reason);
+  const sync = await openCliSyncContext(resolveDbPath(db));
+  if (sync.enabled) {
+    sync.enqueue(buildMemoryInvalidatedOp(sync, memoryId, now, reason));
+    sync.close();
+  }
+  output({ memoryId, invalidated: true }, format);
+}
+export {
+  run
+};

package/dist/invalidate-PVHUGAJ6.js

@@ -0,0 +1,40 @@
+import {
+  buildMemoryInvalidatedOp,
+  openCliSyncContext
+} from "./chunk-GZINXXM4.js";
+import {
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-VMGX5FCY.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-RZFCVYTK.js";
+
+// src/commands/invalidate.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const memoryId = args.find((a) => !a.startsWith("-"));
+  if (!memoryId) {
+    outputError("Usage: memrosetta invalidate <memoryId>", format);
+    process.exitCode = 1;
+    return;
+  }
+  const reason = optionalOption(args, "--reason");
+  const engine = await getEngine({ db, noEmbeddings });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await engine.invalidate(memoryId, reason);
+  const sync = await openCliSyncContext(resolveDbPath(db));
+  if (sync.enabled) {
+    sync.enqueue(buildMemoryInvalidatedOp(sync, memoryId, now, reason));
+    sync.close();
+  }
+  output({ memoryId, invalidated: true }, format);
+}
+export {
+  run
+};

package/dist/maintain-NICAXFK6.js

@@ -0,0 +1,37 @@
+import {
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-VMGX5FCY.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-RZFCVYTK.js";
+
+// src/commands/maintain.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const engine = await getEngine({ db, noEmbeddings });
+  const result = await engine.maintain(userId);
+  if (format === "text") {
+    process.stdout.write(`Maintenance completed for user: ${userId}
+`);
+    process.stdout.write(`  Activation scores updated: ${result.activationUpdated}
+`);
+    process.stdout.write(`  Tiers updated: ${result.tiersUpdated}
+`);
+    process.stdout.write(`  Groups compressed: ${result.compressed}
+`);
+    process.stdout.write(`  Memories archived: ${result.removed}
+`);
+    return;
+  }
+  output({ userId, ...result }, format);
+}
+export {
+  run
+};

package/dist/maintain-Q553GBSF.js

@@ -0,0 +1,37 @@
+import {
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-47SU2YUJ.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-WYHEAKPC.js";
+
+// src/commands/maintain.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const engine = await getEngine({ db, noEmbeddings });
+  const result = await engine.maintain(userId);
+  if (format === "text") {
+    process.stdout.write(`Maintenance completed for user: ${userId}
+`);
+    process.stdout.write(`  Activation scores updated: ${result.activationUpdated}
+`);
+    process.stdout.write(`  Tiers updated: ${result.tiersUpdated}
+`);
+    process.stdout.write(`  Groups compressed: ${result.compressed}
+`);
+    process.stdout.write(`  Memories archived: ${result.removed}
+`);
+    return;
+  }
+  output({ userId, ...result }, format);
+}
+export {
+  run
+};

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