@memrosetta/cli 0.3.0 → 0.3.1

package/dist/chunk-CATBN3ZT.js

@@ -0,0 +1,596 @@
+// src/integrations/claude-code.ts
+import { join as join2 } from "path";
+import { homedir } from "os";
+import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+
+// src/integrations/resolve-command.ts
+import { execSync } from "child_process";
+import { createRequire } from "module";
+import { join, dirname, resolve } from "path";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+function isInPath(command) {
+  try {
+    const cmd = process.platform === "win32" ? `where ${command}` : `command -v ${command}`;
+    execSync(cmd, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findUpwards(startDir, target, maxLevels = 6) {
+  let dir = startDir;
+  for (let i = 0; i < maxLevels; i++) {
+    const candidate = join(dir, target);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function resolveMcpCommand() {
+  if (isInPath("memrosetta-mcp")) {
+    return { command: "memrosetta-mcp", args: [] };
+  }
+  try {
+    const require2 = createRequire(import.meta.url);
+    const mcpPkgPath = dirname(
+      require2.resolve("@memrosetta/mcp/package.json")
+    );
+    const entryPoint = join(mcpPkgPath, "dist", "index.js");
+    if (existsSync(entryPoint)) {
+      return { command: "node", args: [entryPoint] };
+    }
+  } catch {
+  }
+  const workspaceRoot = findUpwards(__dirname, "pnpm-workspace.yaml");
+  if (workspaceRoot) {
+    const rootDir = dirname(workspaceRoot);
+    const mcpEntry = join(rootDir, "adapters", "mcp", "dist", "index.js");
+    if (existsSync(mcpEntry)) {
+      return { command: "node", args: [mcpEntry] };
+    }
+    const mcpSrc = join(rootDir, "adapters", "mcp", "src", "index.ts");
+    if (existsSync(mcpSrc)) {
+      return { command: "npx", args: ["tsx", mcpSrc] };
+    }
+  }
+  return { command: "memrosetta-mcp", args: [] };
+}
+function resolveHookCommand(hookName) {
+  if (isInPath(hookName)) {
+    return hookName;
+  }
+  const hookFile = hookName === "memrosetta-on-stop" ? "hooks/on-stop.js" : "hooks/on-prompt.js";
+  try {
+    const require2 = createRequire(import.meta.url);
+    const cliPkgPath = dirname(
+      require2.resolve("@memrosetta/cli/package.json")
+    );
+    const entryPoint = join(cliPkgPath, "dist", hookFile);
+    if (existsSync(entryPoint)) {
+      return `node "${entryPoint}"`;
+    }
+  } catch {
+  }
+  const distHook = resolve(__dirname, "..", "..", "dist", hookFile);
+  if (existsSync(distHook)) {
+    return `node "${distHook}"`;
+  }
+  const workspaceRoot = findUpwards(__dirname, "pnpm-workspace.yaml");
+  if (workspaceRoot) {
+    const rootDir = dirname(workspaceRoot);
+    const hookEntry = join(rootDir, "packages", "cli", "dist", hookFile);
+    if (existsSync(hookEntry)) {
+      return `node "${hookEntry}"`;
+    }
+  }
+  return hookName;
+}
+
+// src/integrations/claude-code.ts
+var CLAUDE_DIR = join2(homedir(), ".claude");
+var CLAUDE_SETTINGS_PATH = join2(CLAUDE_DIR, "settings.json");
+var CLAUDE_MD_PATH = join2(CLAUDE_DIR, "CLAUDE.md");
+function isMemrosettaHook(command) {
+  return command.includes("memrosetta") && (command.includes("on-stop") || command.includes("on-prompt"));
+}
+function readClaudeSettings() {
+  if (!existsSync2(CLAUDE_SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(
+      readFileSync(CLAUDE_SETTINGS_PATH, "utf-8")
+    );
+  } catch {
+    return {};
+  }
+}
+function writeClaudeSettings(settings) {
+  if (!existsSync2(CLAUDE_DIR)) {
+    throw new Error(
+      "~/.claude directory does not exist. Is Claude Code installed?"
+    );
+  }
+  writeFileSync(
+    CLAUDE_SETTINGS_PATH,
+    JSON.stringify(settings, null, 2),
+    "utf-8"
+  );
+}
+function removeMemrosettaHooksFromSettings(settings) {
+  if (!settings.hooks) return settings;
+  const cleaned = {};
+  for (const [eventType, hookConfigs] of Object.entries(settings.hooks)) {
+    const filtered = hookConfigs.filter(
+      (hc) => !hc.hooks.some((h) => isMemrosettaHook(h.command))
+    );
+    cleaned[eventType] = filtered;
+  }
+  return { ...settings, hooks: cleaned };
+}
+function isClaudeCodeInstalled() {
+  return existsSync2(CLAUDE_DIR);
+}
+function isClaudeCodeConfigured() {
+  const settings = readClaudeSettings();
+  const stopHooks = settings.hooks?.["Stop"] || [];
+  return stopHooks.some(
+    (hc) => hc.hooks.some((h) => isMemrosettaHook(h.command))
+  );
+}
+function registerClaudeCodeHooks() {
+  if (!isClaudeCodeInstalled()) return false;
+  let settings = readClaudeSettings();
+  if (!settings.hooks) {
+    settings = { ...settings, hooks: {} };
+  }
+  settings = removeMemrosettaHooksFromSettings(settings);
+  const stopHookConfigs = settings.hooks["Stop"] || [];
+  settings.hooks["Stop"] = [
+    ...stopHookConfigs,
+    {
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: resolveHookCommand("memrosetta-on-stop"),
+          timeout: 15
+        }
+      ]
+    }
+  ];
+  writeClaudeSettings(settings);
+  return true;
+}
+function removeClaudeCodeHooks() {
+  if (!existsSync2(CLAUDE_SETTINGS_PATH)) return false;
+  const settings = readClaudeSettings();
+  if (!settings.hooks) return false;
+  const cleaned = removeMemrosettaHooksFromSettings(settings);
+  writeClaudeSettings(cleaned);
+  return true;
+}
+function updateClaudeMd() {
+  if (!isClaudeCodeInstalled()) return false;
+  const marker = "## MemRosetta (Long-term Memory)";
+  const existing = existsSync2(CLAUDE_MD_PATH) ? readFileSync(CLAUDE_MD_PATH, "utf-8") : "";
+  if (existing.includes(marker)) return false;
+  const memorySection = `
+
+${marker}
+
+MCP server \`memory-service\` provides long-term memory across sessions.
+userId defaults to the system username -- no need to specify it.
+
+### Search (mcp__memory-service__memrosetta_search)
+When you need information not in the current context, search past memories.
+No need to specify userId -- it defaults to the system username.
+
+### Store (mcp__memory-service__memrosetta_store)
+
+**After EVERY response, run this checklist (zero extra cost):**
+1. Did I encounter a DECISION? (tech choice, approach selection) -> store as "decision"
+2. Did I learn a new FACT? (config, architecture, project info) -> store as "fact"
+3. Did the user state a PREFERENCE? (style, tool choice, pattern) -> store as "preference"
+4. Did we COMPLETE something? (deploy, migration, fix) -> store as "event"
+5. None of the above? -> skip, do not store.
+
+Always include 2-3 keywords. Example:
+  content: "Decided to use OAuth2 with PKCE for auth"
+  type: "decision"
+  keywords: "auth, oauth2, pkce"
+
+Do NOT store:
+- Code itself (belongs in git)
+- File operations ("Created file X", "Modified Y")
+- Debugging steps and attempts
+- Simple confirmations or acknowledgments
+- Implementation details (HOW you did it -- only WHAT)
+
+This checklist ensures nothing important is lost, including the last response before session ends.
+No need to specify userId -- it defaults to the system username.
+
+### Feedback (mcp__memory-service__memrosetta_feedback)
+After using a retrieved memory, report whether it was helpful:
+- Memory was accurate and useful -> feedback(memoryId, helpful=true)
+- Memory was outdated or wrong -> feedback(memoryId, helpful=false)
+This improves future search ranking automatically.
+`;
+  writeFileSync(CLAUDE_MD_PATH, existing + memorySection, "utf-8");
+  return true;
+}
+function removeClaudeMdSection() {
+  if (!existsSync2(CLAUDE_MD_PATH)) return false;
+  const content = readFileSync(CLAUDE_MD_PATH, "utf-8");
+  const marker = "## MemRosetta (Long-term Memory)";
+  const markerIdx = content.indexOf(marker);
+  if (markerIdx === -1) return false;
+  const afterMarker = content.slice(markerIdx + marker.length);
+  const nextHeadingMatch = afterMarker.match(/\n## (?!MemRosetta)/);
+  const endIdx = nextHeadingMatch ? markerIdx + marker.length + (nextHeadingMatch.index ?? afterMarker.length) : content.length;
+  const before = content.slice(0, markerIdx).replace(/\n+$/, "");
+  const after = content.slice(endIdx);
+  const updated = (before + after).trimEnd() + "\n";
+  writeFileSync(CLAUDE_MD_PATH, updated, "utf-8");
+  return true;
+}
+
+// src/integrations/mcp.ts
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+var MCP_CONFIG_PATH = join3(homedir2(), ".mcp.json");
+var SERVER_NAME = "memory-service";
+function readMcpConfig(path) {
+  if (!existsSync3(path)) return {};
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeMcpConfig(path, config) {
+  writeFileSync2(path, JSON.stringify(config, null, 2), "utf-8");
+}
+function mcpServerEntry() {
+  const { command, args } = resolveMcpCommand();
+  return { command, args };
+}
+function isGenericMCPConfigured() {
+  const config = readMcpConfig(MCP_CONFIG_PATH);
+  return !!config.mcpServers?.[SERVER_NAME];
+}
+function registerGenericMCP() {
+  const config = readMcpConfig(MCP_CONFIG_PATH);
+  const servers = config.mcpServers ?? {};
+  writeMcpConfig(MCP_CONFIG_PATH, {
+    ...config,
+    mcpServers: { ...servers, [SERVER_NAME]: mcpServerEntry() }
+  });
+}
+function removeGenericMCP() {
+  if (!existsSync3(MCP_CONFIG_PATH)) return false;
+  const config = readMcpConfig(MCP_CONFIG_PATH);
+  if (!config.mcpServers?.[SERVER_NAME]) return false;
+  const { [SERVER_NAME]: _, ...rest } = config.mcpServers;
+  writeMcpConfig(MCP_CONFIG_PATH, { ...config, mcpServers: rest });
+  return true;
+}
+function getGenericMCPPath() {
+  return MCP_CONFIG_PATH;
+}
+
+// src/integrations/cursor.ts
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync } from "fs";
+var SERVER_NAME2 = "memory-service";
+var CURSOR_RULES_PATH_GETTER = () => join4(homedir3(), ".cursorrules");
+var MEMROSETTA_CURSOR_RULES_MARKER = "## MemRosetta (Long-term Memory)";
+var MEMROSETTA_CURSOR_RULES = `
+
+${MEMROSETTA_CURSOR_RULES_MARKER}
+
+MCP server \`memory-service\` provides persistent memory across sessions.
+userId defaults to the system username -- no need to specify it.
+
+### When to search (memrosetta_search)
+When you need information not in the current context, search past memories.
+No need to specify userId -- it defaults to the system username.
+
+### When to store (memrosetta_store)
+
+**After EVERY response, run this checklist (zero extra cost):**
+1. Did I encounter a DECISION? (tech choice, approach selection) -> store as "decision"
+2. Did I learn a new FACT? (config, architecture, project info) -> store as "fact"
+3. Did the user state a PREFERENCE? (style, tool choice, pattern) -> store as "preference"
+4. Did we COMPLETE something? (deploy, migration, fix) -> store as "event"
+5. None of the above? -> skip, do not store.
+
+Always include 2-3 keywords. Example:
+  content: "Decided to use OAuth2 with PKCE for auth"
+  type: "decision"
+  keywords: "auth, oauth2, pkce"
+
+Do NOT store:
+- Code itself (belongs in git)
+- File operations ("Created file X", "Modified Y")
+- Debugging steps and attempts
+- Simple confirmations or acknowledgments
+- Implementation details (HOW you did it -- only WHAT)
+
+This checklist ensures nothing important is lost, including the last response before session ends.
+No need to specify userId -- it defaults to the system username.
+
+### When to relate (memrosetta_relate)
+When new information updates or contradicts existing memories, create a relation.
+
+### Working memory (memrosetta_working_memory)
+Call this at the start of complex tasks to load relevant context.
+No need to specify userId -- it defaults to the system username.
+
+### Feedback (memrosetta_feedback)
+After using a retrieved memory, report whether it was helpful:
+- Memory was accurate and useful -> feedback(memoryId, helpful=true)
+- Memory was outdated or wrong -> feedback(memoryId, helpful=false)
+This improves future search ranking automatically.
+`;
+function getCursorConfigDir() {
+  return join4(homedir3(), ".cursor");
+}
+function getCursorMcpPath() {
+  return join4(getCursorConfigDir(), "mcp.json");
+}
+function readCursorConfig(path) {
+  if (!existsSync4(path)) return {};
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeCursorConfig(path, config) {
+  const dir = getCursorConfigDir();
+  if (!existsSync4(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync3(path, JSON.stringify(config, null, 2), "utf-8");
+}
+function mcpServerEntry2() {
+  const { command, args } = resolveMcpCommand();
+  return { command, args };
+}
+function isCursorConfigured() {
+  const path = getCursorMcpPath();
+  const config = readCursorConfig(path);
+  return !!config.mcpServers?.[SERVER_NAME2];
+}
+function registerCursorMCP() {
+  const path = getCursorMcpPath();
+  const config = readCursorConfig(path);
+  const servers = config.mcpServers ?? {};
+  writeCursorConfig(path, {
+    ...config,
+    mcpServers: { ...servers, [SERVER_NAME2]: mcpServerEntry2() }
+  });
+  return updateCursorRules();
+}
+function removeCursorMCP() {
+  const path = getCursorMcpPath();
+  if (!existsSync4(path)) return false;
+  const config = readCursorConfig(path);
+  if (!config.mcpServers?.[SERVER_NAME2]) return false;
+  const { [SERVER_NAME2]: _, ...rest } = config.mcpServers;
+  writeCursorConfig(path, { ...config, mcpServers: rest });
+  removeCursorRulesSection();
+  return true;
+}
+function getCursorMcpConfigPath() {
+  return getCursorMcpPath();
+}
+function getCursorRulesPath() {
+  return CURSOR_RULES_PATH_GETTER();
+}
+function updateCursorRules() {
+  const rulesPath = CURSOR_RULES_PATH_GETTER();
+  const existing = existsSync4(rulesPath) ? readFileSync3(rulesPath, "utf-8") : "";
+  if (existing.includes(MEMROSETTA_CURSOR_RULES_MARKER)) return false;
+  writeFileSync3(rulesPath, existing + MEMROSETTA_CURSOR_RULES, "utf-8");
+  return true;
+}
+function removeCursorRulesSection() {
+  const rulesPath = CURSOR_RULES_PATH_GETTER();
+  if (!existsSync4(rulesPath)) return false;
+  const content = readFileSync3(rulesPath, "utf-8");
+  const markerIdx = content.indexOf(MEMROSETTA_CURSOR_RULES_MARKER);
+  if (markerIdx === -1) return false;
+  const afterMarker = content.slice(
+    markerIdx + MEMROSETTA_CURSOR_RULES_MARKER.length
+  );
+  const nextHeadingMatch = afterMarker.match(/\n## (?!MemRosetta)/);
+  const endIdx = nextHeadingMatch ? markerIdx + MEMROSETTA_CURSOR_RULES_MARKER.length + (nextHeadingMatch.index ?? afterMarker.length) : content.length;
+  const before = content.slice(0, markerIdx).replace(/\n+$/, "");
+  const after = content.slice(endIdx);
+  const updated = (before + after).trimEnd() + "\n";
+  writeFileSync3(rulesPath, updated, "utf-8");
+  return true;
+}
+
+// src/integrations/codex.ts
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2 } from "fs";
+var SERVER_NAME3 = "memory-service";
+var CODEX_CONFIG_PATH_GETTER = () => join5(homedir4(), ".codex", "config.toml");
+var AGENTS_MD_MARKER = "## MemRosetta (Long-term Memory)";
+var MEMROSETTA_AGENTS_MD = `
+
+${AGENTS_MD_MARKER}
+
+MCP server \`memory-service\` provides persistent memory across sessions.
+userId defaults to the system username -- no need to specify it.
+
+### When to search (mcp__memory-service__memrosetta_search)
+When you need information not in the current context, search past memories.
+
+### When to store (mcp__memory-service__memrosetta_store)
+
+**After EVERY response, run this checklist:**
+1. Did I encounter a DECISION? (tech choice, approach selection) -> store as "decision"
+2. Did I learn a new FACT? (config, architecture, project info) -> store as "fact"
+3. Did the user state a PREFERENCE? (style, tool choice, pattern) -> store as "preference"
+4. Did we COMPLETE something? (deploy, migration, fix) -> store as "event"
+5. None of the above? -> skip, do not store.
+
+Always include 2-3 keywords. Example:
+  content: "Decided to use OAuth2 with PKCE for auth"
+  type: "decision"
+  keywords: "auth, oauth2, pkce"
+
+Do NOT store:
+- Code itself (belongs in git)
+- File operations ("Created file X", "Modified Y")
+- Debugging steps and attempts
+- Simple confirmations or acknowledgments
+
+### When to relate (mcp__memory-service__memrosetta_relate)
+When new information updates or contradicts existing memories, create a relation.
+
+### Working memory (mcp__memory-service__memrosetta_working_memory)
+Call this at the start of complex tasks to load relevant context.
+`;
+function getCodexConfigDir() {
+  return join5(homedir4(), ".codex");
+}
+function getCodexConfigPath() {
+  return CODEX_CONFIG_PATH_GETTER();
+}
+function readCodexConfig(path) {
+  if (!existsSync5(path)) return "";
+  try {
+    return readFileSync4(path, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function escapeTomlString(s) {
+  return s.replace(/\\/g, "\\\\");
+}
+function buildMcpServerToml() {
+  const { command, args } = resolveMcpCommand();
+  const escapedCommand = escapeTomlString(command);
+  const argsLine = args.length > 0 ? `
+args = [${args.map((a) => `"${escapeTomlString(a)}"`).join(", ")}]` : "";
+  return `
+[mcp_servers.${SERVER_NAME3}]
+command = "${escapedCommand}"${argsLine}
+`;
+}
+function hasMcpServer(content) {
+  return content.includes(`[mcp_servers.${SERVER_NAME3}]`);
+}
+function removeMcpServerSection(content) {
+  const marker = `[mcp_servers.${SERVER_NAME3}]`;
+  const idx = content.indexOf(marker);
+  if (idx === -1) return content;
+  const afterMarker = content.slice(idx + marker.length);
+  const nextSectionMatch = afterMarker.match(/\n\[(?!mcp_servers\.memrosetta)/);
+  const endIdx = nextSectionMatch ? idx + marker.length + (nextSectionMatch.index ?? afterMarker.length) : content.length;
+  return (content.slice(0, idx).trimEnd() + "\n" + content.slice(endIdx)).trim() + "\n";
+}
+function isCodexConfigured() {
+  const content = readCodexConfig(getCodexConfigPath());
+  return hasMcpServer(content);
+}
+function registerCodexMCP() {
+  const configPath = getCodexConfigPath();
+  const dir = getCodexConfigDir();
+  if (!existsSync5(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  let content = readCodexConfig(configPath);
+  if (hasMcpServer(content)) {
+    content = removeMcpServerSection(content);
+  }
+  writeFileSync4(configPath, content + buildMcpServerToml(), "utf-8");
+  return updateAgentsMd();
+}
+function removeCodexMCP() {
+  const configPath = getCodexConfigPath();
+  if (!existsSync5(configPath)) return false;
+  const content = readCodexConfig(configPath);
+  if (!hasMcpServer(content)) return false;
+  const lines = content.split("\n");
+  const filtered = [];
+  let skipping = false;
+  for (const line of lines) {
+    if (line.trim() === `[mcp_servers.${SERVER_NAME3}]`) {
+      skipping = true;
+      continue;
+    }
+    if (skipping && line.trim().startsWith("[")) {
+      skipping = false;
+    }
+    if (!skipping) {
+      filtered.push(line);
+    }
+  }
+  writeFileSync4(configPath, filtered.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n", "utf-8");
+  removeAgentsMdSection();
+  return true;
+}
+function getCodexConfigFilePath() {
+  return getCodexConfigPath();
+}
+function getAgentsMdPath() {
+  return join5(process.cwd(), "AGENTS.md");
+}
+function updateAgentsMd() {
+  const agentsPath = getAgentsMdPath();
+  const existing = existsSync5(agentsPath) ? readFileSync4(agentsPath, "utf-8") : "";
+  if (existing.includes(AGENTS_MD_MARKER)) return false;
+  writeFileSync4(agentsPath, existing + MEMROSETTA_AGENTS_MD, "utf-8");
+  return true;
+}
+function removeAgentsMdSection() {
+  const agentsPath = getAgentsMdPath();
+  if (!existsSync5(agentsPath)) return false;
+  const content = readFileSync4(agentsPath, "utf-8");
+  const markerIdx = content.indexOf(AGENTS_MD_MARKER);
+  if (markerIdx === -1) return false;
+  const afterMarker = content.slice(markerIdx + AGENTS_MD_MARKER.length);
+  const nextHeadingMatch = afterMarker.match(/\n## (?!MemRosetta)/);
+  const endIdx = nextHeadingMatch ? markerIdx + AGENTS_MD_MARKER.length + (nextHeadingMatch.index ?? afterMarker.length) : content.length;
+  const before = content.slice(0, markerIdx).replace(/\n+$/, "");
+  const after = content.slice(endIdx);
+  const updated = (before + after).trimEnd() + "\n";
+  writeFileSync4(agentsPath, updated, "utf-8");
+  return true;
+}
+
+export {
+  isClaudeCodeInstalled,
+  isClaudeCodeConfigured,
+  registerClaudeCodeHooks,
+  removeClaudeCodeHooks,
+  updateClaudeMd,
+  removeClaudeMdSection,
+  isGenericMCPConfigured,
+  registerGenericMCP,
+  removeGenericMCP,
+  getGenericMCPPath,
+  isCursorConfigured,
+  registerCursorMCP,
+  removeCursorMCP,
+  getCursorMcpConfigPath,
+  getCursorRulesPath,
+  removeCursorRulesSection,
+  isCodexConfigured,
+  registerCodexMCP,
+  removeCodexMCP,
+  getCodexConfigFilePath,
+  getAgentsMdPath,
+  removeAgentsMdSection
+};

package/dist/index.js

@@ -150,17 +150,17 @@ async function main() {
         break;
       }
       case "status": {
-        const mod = await import("./status-5FUFYHIN.js");
+        const mod = await import("./status-PYD6U7U7.js");
         await mod.run(commandOptions);
         break;
       }
       case "init": {
-        const mod = await import("./init-4PD4HS3N.js");
+        const mod = await import("./init-C335O4TX.js");
         await mod.run(commandOptions);
         break;
       }
       case "reset": {
-        const mod = await import("./reset-6YEE3G6N.js");
+        const mod = await import("./reset-P63V46RN.js");
         await mod.run(commandOptions);
         break;
       }

package/dist/init-C335O4TX.js

@@ -0,0 +1,182 @@
+import {
+  getAgentsMdPath,
+  getCodexConfigFilePath,
+  getCursorMcpConfigPath,
+  getCursorRulesPath,
+  getGenericMCPPath,
+  isClaudeCodeInstalled,
+  registerClaudeCodeHooks,
+  registerCodexMCP,
+  registerCursorMCP,
+  registerGenericMCP,
+  updateClaudeMd
+} from "./chunk-CATBN3ZT.js";
+import {
+  hasFlag,
+  optionalOption
+} from "./chunk-VZQURGWB.js";
+import {
+  getDefaultDbPath,
+  getEngine
+} from "./chunk-POK32V2J.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getConfig,
+  writeConfig
+} from "./chunk-TU5EHSDE.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 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 (format === "text") {
+    printTextOutput(result, wantClaudeCode, wantCursor, wantCodex);
+    return;
+  }
+  output(result, format);
+}
+function printTextOutput(result, claudeCode, cursor, codex = 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");
+    }
+  }
+  w("\n");
+  if (!claudeCode && !cursor && !codex) {
+    w("  MCP is ready. Add --claude-code, --cursor, or --codex 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/reset-P63V46RN.js

@@ -0,0 +1,112 @@
+import {
+  removeAgentsMdSection,
+  removeClaudeCodeHooks,
+  removeClaudeMdSection,
+  removeCodexMCP,
+  removeCursorMCP,
+  removeCursorRulesSection,
+  removeGenericMCP
+} from "./chunk-CATBN3ZT.js";
+import {
+  hasFlag
+} from "./chunk-VZQURGWB.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 wantMCP = hasFlag(args, "--mcp");
+  const wantAll = hasFlag(args, "--all");
+  const noFlags = !wantClaudeCode && !wantCursor && !wantCodex && !wantMCP && !wantAll;
+  if (noFlags) {
+    const msg = "Usage: memrosetta reset [--claude-code] [--cursor] [--codex] [--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  --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, --mcp, or --all." }, format);
+    }
+    return;
+  }
+  const result = {
+    removed: {
+      claudeCodeHooks: false,
+      claudeMd: false,
+      mcp: false,
+      cursor: false,
+      cursorRules: false,
+      codex: false,
+      agentsMd: 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 (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");
+  }
+  const anyRemoved = removed.claudeCodeHooks || removed.claudeMd || removed.mcp || removed.cursor || removed.cursorRules || removed.codex || removed.agentsMd;
+  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/status-PYD6U7U7.js

@@ -0,0 +1,211 @@
+import {
+  isClaudeCodeConfigured,
+  isCodexConfigured,
+  isCursorConfigured,
+  isGenericMCPConfigured
+} from "./chunk-CATBN3ZT.js";
+import {
+  getDefaultDbPath
+} from "./chunk-POK32V2J.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getConfig
+} from "./chunk-TU5EHSDE.js";
+
+// src/commands/status.ts
+import { existsSync, statSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+function getVersion() {
+  const strategies = [
+    // 1. Relative to source (dev/source checkout via tsx)
+    () => {
+      const require2 = createRequire(import.meta.url);
+      return require2("../../package.json").version;
+    },
+    // 2. Resolve from npm package
+    () => {
+      const require2 = createRequire(import.meta.url);
+      return require2("@memrosetta/cli/package.json").version;
+    },
+    // 3. Walk up to find package.json from current file location
+    () => {
+      const dir = dirname(fileURLToPath(import.meta.url));
+      for (let d = dir, i = 0; i < 5; i++) {
+        const candidate = join(d, "package.json");
+        if (existsSync(candidate)) {
+          const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+          if (pkg.name?.includes("memrosetta") && pkg.version) return pkg.version;
+        }
+        d = dirname(d);
+      }
+      throw new Error("not found");
+    }
+  ];
+  for (const strategy of strategies) {
+    try {
+      return strategy();
+    } catch {
+    }
+  }
+  return "unknown";
+}
+async function run(options) {
+  const { format, db, noEmbeddings } = options;
+  const config = getConfig();
+  const dbPath = db ?? config.dbPath ?? getDefaultDbPath();
+  const exists = existsSync(dbPath);
+  let sizeBytes = 0;
+  let sizeFormatted = "0B";
+  let memoryCount = 0;
+  let userList = [];
+  let qualityFresh = 0;
+  let qualityInvalidated = 0;
+  let qualityWithRelations = 0;
+  let qualityAvgActivation = 0;
+  const embeddingsEnabled = !noEmbeddings && config.enableEmbeddings !== false;
+  if (exists) {
+    const stat = statSync(dbPath);
+    sizeBytes = stat.size;
+    sizeFormatted = formatSize(sizeBytes);
+    try {
+      const Database = (await import("better-sqlite3")).default;
+      const dbConn = new Database(dbPath);
+      dbConn.pragma("journal_mode = WAL");
+      const countRow = dbConn.prepare("SELECT COUNT(*) as count FROM memories").get();
+      memoryCount = countRow.count;
+      const userRows = dbConn.prepare("SELECT DISTINCT user_id FROM memories ORDER BY user_id").all();
+      userList = userRows.map((r) => r.user_id);
+      const freshRow = dbConn.prepare(
+        "SELECT COUNT(*) as c FROM memories WHERE is_latest = 1 AND invalidated_at IS NULL"
+      ).get();
+      qualityFresh = freshRow.c;
+      const invalidatedRow = dbConn.prepare(
+        "SELECT COUNT(*) as c FROM memories WHERE invalidated_at IS NOT NULL"
+      ).get();
+      qualityInvalidated = invalidatedRow.c;
+      const relationsRow = dbConn.prepare(
+        "SELECT COUNT(DISTINCT src_memory_id) + COUNT(DISTINCT dst_memory_id) as c FROM memory_relations"
+      ).get();
+      qualityWithRelations = relationsRow.c;
+      const avgRow = dbConn.prepare(
+        "SELECT AVG(activation_score) as avg FROM memories WHERE is_latest = 1"
+      ).get();
+      qualityAvgActivation = avgRow.avg ?? 0;
+      dbConn.close();
+    } catch {
+    }
+  }
+  const claudeCodeStatus = isClaudeCodeConfigured();
+  const cursorStatus = isCursorConfigured();
+  const codexStatus = isCodexConfigured();
+  const mcpStatus = isGenericMCPConfigured();
+  if (format === "text") {
+    process.stdout.write("MemRosetta Status\n");
+    process.stdout.write(`${"=".repeat(40)}
+
+`);
+    process.stdout.write(
+      `Database: ${dbPath} (${exists ? `exists, ${sizeFormatted}` : "not found"})
+`
+    );
+    process.stdout.write(`Memories: ${memoryCount}
+`);
+    if (userList.length > 0) {
+      process.stdout.write(
+        `Users: ${userList.length} (${userList.join(", ")})
+`
+      );
+    } else {
+      process.stdout.write("Users: 0\n");
+    }
+    const embeddingModelLabel = getEmbeddingModelLabel();
+    process.stdout.write(
+      `Embeddings: ${embeddingsEnabled ? `enabled (${embeddingModelLabel})` : "disabled"}
+`
+    );
+    if (memoryCount > 0) {
+      process.stdout.write("\nQuality:\n");
+      process.stdout.write(
+        `  Fresh (is_latest=1):    ${qualityFresh} / ${memoryCount}
+`
+      );
+      process.stdout.write(`  Invalidated:            ${qualityInvalidated}
+`);
+      process.stdout.write(`  With relations:         ${qualityWithRelations}
+`);
+      process.stdout.write(
+        `  Avg activation:         ${qualityAvgActivation.toFixed(2)}
+`
+      );
+    }
+    process.stdout.write("\nIntegrations:\n");
+    process.stdout.write(
+      `  Claude Code:   ${claudeCodeStatus ? "configured (hooks + MCP)" : "not configured"}
+`
+    );
+    process.stdout.write(
+      `  Cursor:        ${cursorStatus ? "configured (MCP)" : "not configured"}
+`
+    );
+    process.stdout.write(
+      `  Codex:         ${codexStatus ? "configured (MCP)" : "not configured"}
+`
+    );
+    process.stdout.write(
+      `  MCP (generic): ${mcpStatus ? "configured" : "not configured"}
+`
+    );
+    return;
+  }
+  output(
+    {
+      version: getVersion(),
+      database: {
+        path: dbPath,
+        exists,
+        sizeBytes,
+        sizeFormatted
+      },
+      memories: memoryCount,
+      users: userList,
+      quality: {
+        fresh: qualityFresh,
+        invalidated: qualityInvalidated,
+        withRelations: qualityWithRelations,
+        avgActivation: qualityAvgActivation
+      },
+      embeddings: embeddingsEnabled,
+      embeddingModel: getEmbeddingModelLabel(),
+      embeddingPreset: getConfig().embeddingPreset ?? "en",
+      integrations: {
+        claudeCode: claudeCodeStatus,
+        cursor: cursorStatus,
+        codex: codexStatus,
+        mcp: mcpStatus
+      }
+    },
+    format
+  );
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+var PRESET_MODEL_LABELS = {
+  en: "bge-small-en-v1.5",
+  multilingual: "multilingual-e5-small",
+  ko: "ko-sroberta-multitask"
+};
+function getEmbeddingModelLabel() {
+  const config = getConfig();
+  const preset = config.embeddingPreset ?? "en";
+  return PRESET_MODEL_LABELS[preset] ?? preset;
+}
+export {
+  run
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memrosetta/cli",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
@@ -16,8 +16,8 @@
   "dependencies": {
     "better-sqlite3": "^11.0.0",
     "@memrosetta/core": "0.3.0",
-    "@memrosetta/embeddings": "0.3.0",
-    "@memrosetta/types": "0.3.0"
+    "@memrosetta/types": "0.3.0",
+    "@memrosetta/embeddings": "0.3.0"
   },
   "optionalDependencies": {
     "@memrosetta/llm": "0.3.0"