@memrosetta/cli 0.5.0 → 0.5.2

package/dist/chunk-4LNXT25H.js

@@ -0,0 +1,891 @@
+// 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 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}`;
+    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")) {
+    const absPath = resolveAbsolutePath("memrosetta-mcp");
+    return { command: absPath ?? "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 resolveAbsolutePath(hookName) ?? hookName;
+  }
+  const hookFile = hookName === "memrosetta-on-stop" ? "hooks/on-stop.js" : hookName === "memrosetta-on-prompt" ? "hooks/on-prompt.js" : hookName === "memrosetta-enforce-claude-code" ? "hooks/enforce-claude-code.js" : "hooks/enforce-codex.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("enforce-claude-code") || 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-enforce-claude-code"),
+          timeout: 30
+        }
+      ]
+    }
+  ];
+  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 LEGACY_SERVER_NAMES = ["memrosetta"];
+var CODEX_CONFIG_PATH_GETTER = () => join5(homedir4(), ".codex", "config.toml");
+var CODEX_HOOKS_PATH_GETTER = () => join5(homedir4(), ".codex", "hooks.json");
+var AGENTS_MD_MARKER = "## MemRosetta (Long-term Memory)";
+var CODEX_HOOKS_FEATURE_MARKER = "[features]";
+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 tomlLiteral(s) {
+  if (!s.includes("'")) {
+    return `'${s}'`;
+  }
+  const escaped = s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+function buildMcpServerToml() {
+  const { command, args } = resolveMcpCommand();
+  const argsLine = args.length > 0 ? `
+args = [${args.map(tomlLiteral).join(", ")}]` : "";
+  return `
+[mcp_servers.${SERVER_NAME3}]
+command = ${tomlLiteral(command)}${argsLine}
+`;
+}
+function hasMcpServer(content) {
+  return content.includes(`[mcp_servers.${SERVER_NAME3}]`);
+}
+function stripSection(content, name) {
+  const marker = `[mcp_servers.${name}]`;
+  const idx = content.indexOf(marker);
+  if (idx === -1) return content;
+  const afterMarker = content.slice(idx + marker.length);
+  const nextSectionMatch = afterMarker.match(/\n\[/);
+  const endIdx = nextSectionMatch ? idx + marker.length + (nextSectionMatch.index ?? afterMarker.length) : content.length;
+  const trimmedHead = content.slice(0, idx).trimEnd();
+  const tail = content.slice(endIdx);
+  return `${trimmedHead}
+${tail}`.trim() + "\n";
+}
+function removeMcpServerSection(content) {
+  let next = stripSection(content, SERVER_NAME3);
+  for (const legacy of LEGACY_SERVER_NAMES) {
+    next = stripSection(next, legacy);
+  }
+  return next;
+}
+function isCodexInstalled() {
+  return existsSync5(getCodexConfigDir());
+}
+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);
+  content = removeMcpServerSection(content);
+  writeFileSync4(configPath, content + buildMcpServerToml(), "utf-8");
+  return updateAgentsMd();
+}
+function removeCodexMCP() {
+  const configPath = getCodexConfigPath();
+  if (!existsSync5(configPath)) return false;
+  const original = readCodexConfig(configPath);
+  const cleaned = removeMcpServerSection(original);
+  if (cleaned === original) {
+    removeAgentsMdSection();
+    return false;
+  }
+  writeFileSync4(configPath, cleaned, "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 isMemrosettaCodexHook(command) {
+  return command.includes("memrosetta") && (command.includes("enforce-codex") || command.includes("enforce-claude-code") || command.includes("on-stop"));
+}
+function readCodexHooksFile() {
+  const path = CODEX_HOOKS_PATH_GETTER();
+  if (!existsSync5(path)) return {};
+  try {
+    const raw = readFileSync4(path, "utf-8");
+    if (!raw.trim()) return {};
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeCodexHooksFile(contents) {
+  const dir = getCodexConfigDir();
+  if (!existsSync5(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  writeFileSync4(
+    CODEX_HOOKS_PATH_GETTER(),
+    JSON.stringify(contents, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function stripMemrosettaHooks(file) {
+  if (!file.hooks) return file;
+  const cleaned = {};
+  for (const [event, configs] of Object.entries(file.hooks)) {
+    const filtered = configs.map((cfg) => ({
+      ...cfg,
+      hooks: cfg.hooks.filter((h) => !isMemrosettaCodexHook(h.command))
+    })).filter((cfg) => cfg.hooks.length > 0);
+    if (filtered.length > 0) {
+      cleaned[event] = filtered;
+    }
+  }
+  return { ...file, hooks: cleaned };
+}
+function ensureHooksFeatureFlag(content) {
+  if (/^\s*codex_hooks\s*=\s*true/m.test(content)) return content;
+  if (content.includes(CODEX_HOOKS_FEATURE_MARKER)) {
+    if (/^\s*codex_hooks\s*=\s*false/m.test(content)) {
+      return content.replace(
+        /^\s*codex_hooks\s*=\s*false\s*$/m,
+        "codex_hooks = true"
+      );
+    }
+    return content.replace(
+      CODEX_HOOKS_FEATURE_MARKER,
+      `${CODEX_HOOKS_FEATURE_MARKER}
+codex_hooks = true`
+    );
+  }
+  const trimmed = content.replace(/\n+$/, "");
+  return `${trimmed}
+
+[features]
+codex_hooks = true
+`;
+}
+function stripHooksFeatureFlag(content) {
+  if (!/^\s*codex_hooks\s*=\s*true/m.test(content)) return content;
+  return content.replace(/^\s*codex_hooks\s*=\s*true\s*\n?/m, "");
+}
+function isCodexHooksConfigured() {
+  const file = readCodexHooksFile();
+  const stopHooks = file.hooks?.Stop ?? [];
+  return stopHooks.some(
+    (cfg) => cfg.hooks.some((h) => isMemrosettaCodexHook(h.command))
+  );
+}
+function getCodexHooksPath() {
+  return CODEX_HOOKS_PATH_GETTER();
+}
+function registerCodexHooks() {
+  if (process.platform === "win32") return false;
+  if (!isCodexInstalled()) return false;
+  const file = stripMemrosettaHooks(readCodexHooksFile());
+  const newHooks = { ...file.hooks ?? {} };
+  const existingStop = newHooks.Stop ?? [];
+  newHooks.Stop = [
+    ...existingStop,
+    {
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: resolveHookCommand("memrosetta-enforce-codex"),
+          timeout: 30,
+          statusMessage: "memrosetta: enforcing memory capture"
+        }
+      ]
+    }
+  ];
+  writeCodexHooksFile({ ...file, hooks: newHooks });
+  const configPath = getCodexConfigPath();
+  const configContent = readCodexConfig(configPath);
+  const updated = ensureHooksFeatureFlag(configContent);
+  if (updated !== configContent) {
+    writeFileSync4(configPath, updated, "utf-8");
+  }
+  return true;
+}
+function removeCodexHooks() {
+  const hadHook = isCodexHooksConfigured();
+  const file = readCodexHooksFile();
+  const cleaned = stripMemrosettaHooks(file);
+  const anyOtherHooks = Object.values(cleaned.hooks ?? {}).some(
+    (cfgs) => cfgs.length > 0
+  );
+  if (hadHook) {
+    if (anyOtherHooks) {
+      writeCodexHooksFile(cleaned);
+    } else {
+      const hooksPath = CODEX_HOOKS_PATH_GETTER();
+      if (existsSync5(hooksPath)) {
+        writeCodexHooksFile({});
+      }
+    }
+  }
+  if (!anyOtherHooks) {
+    const configPath = getCodexConfigPath();
+    if (existsSync5(configPath)) {
+      const configContent = readCodexConfig(configPath);
+      const stripped = stripHooksFeatureFlag(configContent);
+      if (stripped !== configContent) {
+        writeFileSync4(configPath, stripped, "utf-8");
+      }
+    }
+  }
+  return hadHook;
+}
+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;
+}
+
+// src/integrations/gemini.ts
+import { join as join6 } from "path";
+import { homedir as homedir5 } from "os";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync3 } from "fs";
+var SERVER_NAME4 = "memory-service";
+var GEMINI_CONFIG_PATH_GETTER = () => join6(homedir5(), ".gemini", "settings.json");
+var GEMINI_MD_MARKER = "## MemRosetta (Long-term Memory)";
+var MEMROSETTA_GEMINI_MD = `
+
+${GEMINI_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 (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 getGeminiConfigDir() {
+  return join6(homedir5(), ".gemini");
+}
+function getGeminiSettingsPath() {
+  return GEMINI_CONFIG_PATH_GETTER();
+}
+function readGeminiSettings(path) {
+  if (!existsSync6(path)) return {};
+  const raw = readFileSync5(path, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `Failed to parse ${path}. Fix or delete the file before running init.`
+    );
+  }
+}
+function writeGeminiSettings(path, settings) {
+  const dir = getGeminiConfigDir();
+  if (!existsSync6(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  writeFileSync5(path, JSON.stringify(settings, null, 2), "utf-8");
+}
+function mcpServerEntry3() {
+  const { command, args } = resolveMcpCommand();
+  return { command, args };
+}
+function isGeminiConfigured() {
+  const path = getGeminiSettingsPath();
+  const settings = readGeminiSettings(path);
+  return !!settings.mcpServers?.[SERVER_NAME4];
+}
+function registerGeminiMCP() {
+  const path = getGeminiSettingsPath();
+  const settings = readGeminiSettings(path);
+  const servers = settings.mcpServers ?? {};
+  writeGeminiSettings(path, {
+    ...settings,
+    mcpServers: { ...servers, [SERVER_NAME4]: mcpServerEntry3() }
+  });
+  return updateGeminiMd();
+}
+function removeGeminiMCP() {
+  const path = getGeminiSettingsPath();
+  if (!existsSync6(path)) return false;
+  const settings = readGeminiSettings(path);
+  if (!settings.mcpServers?.[SERVER_NAME4]) return false;
+  const { [SERVER_NAME4]: _, ...rest } = settings.mcpServers;
+  writeGeminiSettings(path, { ...settings, mcpServers: rest });
+  return true;
+}
+function getGeminiSettingsFilePath() {
+  return getGeminiSettingsPath();
+}
+function getGeminiMdPath() {
+  return join6(process.cwd(), "GEMINI.md");
+}
+function updateGeminiMd() {
+  const geminiMdPath = getGeminiMdPath();
+  const existing = existsSync6(geminiMdPath) ? readFileSync5(geminiMdPath, "utf-8") : "";
+  if (existing.includes(GEMINI_MD_MARKER)) return false;
+  writeFileSync5(geminiMdPath, existing + MEMROSETTA_GEMINI_MD, "utf-8");
+  return true;
+}
+function removeGeminiMdSection() {
+  const geminiMdPath = getGeminiMdPath();
+  if (!existsSync6(geminiMdPath)) return false;
+  const content = readFileSync5(geminiMdPath, "utf-8");
+  const markerIdx = content.indexOf(GEMINI_MD_MARKER);
+  if (markerIdx === -1) return false;
+  const afterMarker = content.slice(
+    markerIdx + GEMINI_MD_MARKER.length
+  );
+  const nextHeadingMatch = afterMarker.match(/\n## (?!MemRosetta)/);
+  const endIdx = nextHeadingMatch ? markerIdx + GEMINI_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";
+  writeFileSync5(geminiMdPath, 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,
+  getCodexHooksPath,
+  registerCodexHooks,
+  removeCodexHooks,
+  removeAgentsMdSection,
+  isGeminiConfigured,
+  registerGeminiMCP,
+  removeGeminiMCP,
+  getGeminiSettingsFilePath,
+  getGeminiMdPath,
+  removeGeminiMdSection
+};