@memrosetta/cli 0.4.0 → 0.4.2

package/dist/init-LK4UQISR.js

@@ -0,0 +1,205 @@
+import {
+  getAgentsMdPath,
+  getCodexConfigFilePath,
+  getCursorMcpConfigPath,
+  getCursorRulesPath,
+  getGeminiMdPath,
+  getGeminiSettingsFilePath,
+  getGenericMCPPath,
+  isClaudeCodeInstalled,
+  registerClaudeCodeHooks,
+  registerCodexMCP,
+  registerCursorMCP,
+  registerGeminiMCP,
+  registerGenericMCP,
+  updateClaudeMd
+} from "./chunk-IS4IKWPL.js";
+import {
+  hasFlag,
+  optionalOption
+} from "./chunk-VZQURGWB.js";
+import {
+  getDefaultDbPath,
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getConfig,
+  writeConfig
+} from "./chunk-SEPYQK3J.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();
+    result.integrations.codex = {
+      mcp: true,
+      path: getCodexConfigFilePath(),
+      agentsMd: agentsMdUpdated,
+      agentsMdPath: getAgentsMdPath()
+    };
+  }
+  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-BY5VNFSE.js

@@ -0,0 +1,25 @@
+import {
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-SEPYQK3J.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 engine = await getEngine({ db, noEmbeddings });
+  await engine.invalidate(memoryId);
+  output({ memoryId, invalidated: true }, format);
+}
+export {
+  run
+};

package/dist/maintain-SGM56XKE.js

@@ -0,0 +1,37 @@
+import {
+  optionalOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.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-VX2VWB2L.js

@@ -0,0 +1,37 @@
+import {
+  optionalOption
+} from "./chunk-VZQURGWB.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.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/relate-L5464WV5.js

@@ -0,0 +1,47 @@
+import {
+  optionalOption,
+  requireOption
+} from "./chunk-VZQURGWB.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-SEPYQK3J.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
+  );
+  output(relation, format);
+}
+export {
+  run
+};

package/dist/relate-SGZLG7JU.js

@@ -0,0 +1,47 @@
+import {
+  optionalOption,
+  requireOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-SEPYQK3J.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
+  );
+  output(relation, format);
+}
+export {
+  run
+};

package/dist/reset-CYY4KYAB.js

@@ -0,0 +1,129 @@
+import {
+  removeAgentsMdSection,
+  removeClaudeCodeHooks,
+  removeClaudeMdSection,
+  removeCodexMCP,
+  removeCursorMCP,
+  removeCursorRulesSection,
+  removeGeminiMCP,
+  removeGeminiMdSection,
+  removeGenericMCP
+} from "./chunk-IS4IKWPL.js";
+import {
+  hasFlag
+} from "./chunk-NU5ZJJXP.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;
+  }
+  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-BJ2YV5IS.js

@@ -0,0 +1,48 @@
+import {
+  optionalOption,
+  requireOption
+} from "./chunk-VZQURGWB.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.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-PT4POELX.js

@@ -0,0 +1,48 @@
+import {
+  optionalOption,
+  requireOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.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
+};