@memrosetta/cli 0.3.2 → 0.4.0

package/dist/chunk-L6S3TXHR.js

@@ -0,0 +1,326 @@
+// src/integrations/claude-code.ts
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+var CLAUDE_DIR = join(homedir(), ".claude");
+var CLAUDE_SETTINGS_PATH = join(CLAUDE_DIR, "settings.json");
+var CLAUDE_MD_PATH = join(CLAUDE_DIR, "CLAUDE.md");
+function isMemrosettaHook(command) {
+  return command.includes("memrosetta") && (command.includes("on-stop") || command.includes("on-prompt"));
+}
+function readClaudeSettings() {
+  if (!existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(
+      readFileSync(CLAUDE_SETTINGS_PATH, "utf-8")
+    );
+  } catch {
+    return {};
+  }
+}
+function writeClaudeSettings(settings) {
+  if (!existsSync(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 existsSync(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: "npx -y @memrosetta/cli memrosetta-on-stop",
+          timeout: 15
+        }
+      ]
+    }
+  ];
+  writeClaudeSettings(settings);
+  return true;
+}
+function removeClaudeCodeHooks() {
+  if (!existsSync(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 = existsSync(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)
+Every response, check if there is something worth storing. If yes, store immediately.
+No need to specify userId -- it defaults to the system username.
+- **decision**: tech choices, architecture decisions
+- **fact**: key facts about projects or systems
+- **preference**: user preferences
+- **event**: completed work, incidents
+
+Do NOT store:
+- Code itself (that belongs in git)
+- Intermediate steps, debugging attempts
+- Simple confirmations ("yes", "go ahead")
+- Content already in CLAUDE.md
+
+Always include keywords -- they directly affect search quality.
+`;
+  writeFileSync(CLAUDE_MD_PATH, existing + memorySection, "utf-8");
+  return true;
+}
+function removeClaudeMdSection() {
+  if (!existsSync(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 join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+var MCP_CONFIG_PATH = join2(homedir2(), ".mcp.json");
+var SERVER_NAME = "memory-service";
+function readMcpConfig(path) {
+  if (!existsSync2(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() {
+  return {
+    command: "npx",
+    args: ["-y", "@memrosetta/mcp"],
+    env: {
+      MEMROSETTA_EMBEDDINGS: "false"
+    }
+  };
+}
+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 (!existsSync2(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 join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync } from "fs";
+var SERVER_NAME2 = "memory-service";
+var CURSOR_RULES_PATH_GETTER = () => join3(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)
+When you encounter important information, store it immediately.
+No need to specify userId -- it defaults to the system username.
+- **decision**: technical choices, architecture decisions
+- **fact**: key facts about projects or systems
+- **preference**: user preferences and coding style
+- **event**: completed work, deployments, incidents
+
+Do NOT store: code itself, debugging steps, simple confirmations.
+Always include keywords for better search quality.
+
+### 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.
+`;
+function getCursorConfigDir() {
+  return join3(homedir3(), ".cursor");
+}
+function getCursorMcpPath() {
+  return join3(getCursorConfigDir(), "mcp.json");
+}
+function readCursorConfig(path) {
+  if (!existsSync3(path)) return {};
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeCursorConfig(path, config) {
+  const dir = getCursorConfigDir();
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync3(path, JSON.stringify(config, null, 2), "utf-8");
+}
+function mcpServerEntry2() {
+  return {
+    command: "npx",
+    args: ["-y", "@memrosetta/mcp"],
+    env: {
+      MEMROSETTA_EMBEDDINGS: "false"
+    }
+  };
+}
+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() }
+  });
+  updateCursorRules();
+}
+function removeCursorMCP() {
+  const path = getCursorMcpPath();
+  if (!existsSync3(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 = existsSync3(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 (!existsSync3(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;
+}
+
+export {
+  isClaudeCodeInstalled,
+  isClaudeCodeConfigured,
+  registerClaudeCodeHooks,
+  removeClaudeCodeHooks,
+  updateClaudeMd,
+  removeClaudeMdSection,
+  isGenericMCPConfigured,
+  registerGenericMCP,
+  removeGenericMCP,
+  getGenericMCPPath,
+  isCursorConfigured,
+  registerCursorMCP,
+  removeCursorMCP,
+  getCursorMcpConfigPath,
+  getCursorRulesPath,
+  removeCursorRulesSection
+};

package/dist/{chunk-326TFH4F.js → chunk-OCCU5YEG.js}

@@ -9,14 +9,6 @@ import { createRequire } from "module";
 import { join, dirname, resolve } from "path";
 import { existsSync } from "fs";
 import { fileURLToPath } from "url";
-function resolveAbsolutePath(command) {
-  try {
-    const cmd = process.platform === "win32" ? `where ${command}` : `command -v ${command}`;
-    return execSync(cmd, { encoding: "utf-8" }).trim().split("\n")[0] || null;
-  } catch {
-    return null;
-  }
-}
 function isInPath(command) {
   try {
     const cmd = process.platform === "win32" ? `where ${command}` : `command -v ${command}`;
@@ -40,8 +32,7 @@ function findUpwards(startDir, target, maxLevels = 6) {
 var __dirname = dirname(fileURLToPath(import.meta.url));
 function resolveMcpCommand() {
   if (isInPath("memrosetta-mcp")) {
-    const absPath = resolveAbsolutePath("memrosetta-mcp");
-    return { command: absPath ?? "memrosetta-mcp", args: [] };
+    return { command: "memrosetta-mcp", args: [] };
   }
   try {
     const require2 = createRequire(import.meta.url);
@@ -70,7 +61,7 @@ function resolveMcpCommand() {
 }
 function resolveHookCommand(hookName) {
   if (isInPath(hookName)) {
-    return resolveAbsolutePath(hookName) ?? hookName;
+    return hookName;
   }
   const hookFile = hookName === "memrosetta-on-stop" ? "hooks/on-stop.js" : "hooks/on-prompt.js";
   try {
@@ -220,12 +211,6 @@ Do NOT store:
 
 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;
@@ -339,12 +324,6 @@ 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");
@@ -431,20 +410,20 @@ function removeCursorRulesSection() {
 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 SERVER_NAME3 = "memrosetta";
 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.
+MCP server \`memrosetta\` 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 to search (memrosetta_search)
 When you need information not in the current context, search past memories.
 
-### When to store (mcp__memory-service__memrosetta_store)
+### When to store (memrosetta_store)
 
 **After EVERY response, run this checklist:**
 1. Did I encounter a DECISION? (tech choice, approach selection) -> store as "decision"
@@ -464,10 +443,10 @@ Do NOT store:
 - Debugging steps and attempts
 - Simple confirmations or acknowledgments
 
-### When to relate (mcp__memory-service__memrosetta_relate)
+### When to relate (memrosetta_relate)
 When new information updates or contradicts existing memories, create a relation.
 
-### Working memory (mcp__memory-service__memrosetta_working_memory)
+### Working memory (memrosetta_working_memory)
 Call this at the start of complex tasks to load relevant context.
 `;
 function getCodexConfigDir() {
@@ -500,15 +479,6 @@ 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);
@@ -519,11 +489,10 @@ function registerCodexMCP() {
   if (!existsSync5(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
-  let content = readCodexConfig(configPath);
-  if (hasMcpServer(content)) {
-    content = removeMcpServerSection(content);
+  const content = readCodexConfig(configPath);
+  if (!hasMcpServer(content)) {
+    writeFileSync4(configPath, content + buildMcpServerToml(), "utf-8");
   }
-  writeFileSync4(configPath, content + buildMcpServerToml(), "utf-8");
   return updateAgentsMd();
 }
 function removeCodexMCP() {

package/dist/chunk-PW52BB6L.js

@@ -0,0 +1,61 @@
+// src/parser.ts
+var COMMANDS = /* @__PURE__ */ new Set([
+  "store",
+  "search",
+  "ingest",
+  "get",
+  "count",
+  "clear",
+  "relate",
+  "invalidate",
+  "working-memory",
+  "maintain",
+  "compress",
+  "status",
+  "init",
+  "reset",
+  "update"
+]);
+function findFlag(args, flag) {
+  return args.includes(flag);
+}
+function findOption(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return void 0;
+  return args[idx + 1];
+}
+function parseGlobalArgs(args) {
+  const command = args.find((a) => !a.startsWith("-") && COMMANDS.has(a));
+  const db = findOption(args, "--db");
+  const formatRaw = findOption(args, "--format");
+  const format = formatRaw === "text" ? "text" : "json";
+  const noEmbeddings = findFlag(args, "--no-embeddings");
+  const help = findFlag(args, "--help") || findFlag(args, "-h");
+  const version = findFlag(args, "--version") || findFlag(args, "-v");
+  const rest = args.filter((a) => a !== command);
+  return {
+    command,
+    global: { db, format, noEmbeddings, help, version },
+    rest
+  };
+}
+function requireOption(args, flag, name) {
+  const value = findOption(args, flag);
+  if (!value) {
+    throw new Error(`Missing required option: ${name} (${flag})`);
+  }
+  return value;
+}
+function optionalOption(args, flag) {
+  return findOption(args, flag);
+}
+function hasFlag(args, flag) {
+  return findFlag(args, flag);
+}
+
+export {
+  parseGlobalArgs,
+  requireOption,
+  optionalOption,
+  hasFlag
+};