@memrosetta/cli 0.4.8 → 0.5.0

package/dist/hooks/enforce-claude-code.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import {
+  isValidTranscriptPath
+} from "../chunk-IKIJVRHU.js";
+
+// src/hooks/enforce-claude-code.ts
+import { spawnSync } from "child_process";
+import { mkdtempSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+function readStdinSync() {
+  try {
+    return readFileSync(0, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function parseEvent(raw) {
+  if (!raw.trim()) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function normalizeContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === "string") return part;
+      if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+        return part.text;
+      }
+      return "";
+    }).filter((s) => s.length > 0).join("\n");
+  }
+  return "";
+}
+function findLastAssistantMessage(transcriptPath) {
+  if (!isValidTranscriptPath(transcriptPath) || !existsSync(transcriptPath)) {
+    return { assistantMessage: "" };
+  }
+  const lines = readFileSync(transcriptPath, "utf-8").split("\n").filter((l) => l.trim().length > 0);
+  let lastAssistant = "";
+  let userPromptBeforeAssistant = "";
+  let pendingUserPrompt = "";
+  for (const line of lines) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const role = parsed.role ?? parsed.message?.role;
+    const content = normalizeContent(parsed.message?.content);
+    if (!role || !content) continue;
+    if (role === "user") {
+      pendingUserPrompt = content;
+    } else if (role === "assistant") {
+      lastAssistant = content;
+      userPromptBeforeAssistant = pendingUserPrompt;
+    }
+  }
+  return {
+    assistantMessage: lastAssistant,
+    userPrompt: userPromptBeforeAssistant || void 0
+  };
+}
+function resolveMemrosettaCli() {
+  return process.env.MEMROSETTA_BIN ?? "memrosetta";
+}
+function main() {
+  try {
+    const stdin = readStdinSync();
+    const event = parseEvent(stdin);
+    if (!event.transcript_path) {
+      process.stdout.write("{}\n");
+      return;
+    }
+    const turn = findLastAssistantMessage(event.transcript_path);
+    if (!turn.assistantMessage) {
+      process.stdout.write("{}\n");
+      return;
+    }
+    const dir = mkdtempSync(join(tmpdir(), "mr-enforce-"));
+    const eventFile = join(dir, "event.json");
+    writeFileSync(
+      eventFile,
+      JSON.stringify({
+        client: "claude-code",
+        turnId: event.session_id,
+        assistantMessage: turn.assistantMessage,
+        userPrompt: turn.userPrompt,
+        cwd: event.cwd,
+        transcriptPath: event.transcript_path,
+        attempt: 1
+      }),
+      "utf-8"
+    );
+    const cli = resolveMemrosettaCli();
+    const res = spawnSync(
+      cli,
+      ["enforce", "stop", "--client", "claude-code", "--event-json", eventFile, "--format", "json"],
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }
+    );
+    if (res.stdout) {
+      process.stdout.write(res.stdout);
+    }
+    if (res.stderr) {
+      process.stderr.write(res.stderr);
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[memrosetta enforce wrapper] ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+main();

package/dist/hooks/on-prompt.js

@@ -1,16 +1,20 @@
 #!/usr/bin/env node
 import {
   closeEngine,
-  getEngineWithTimeout,
+  getEngineWithTimeout
+} from "../chunk-TSA67QME.js";
+import {
   isValidTranscriptPath,
   sanitizeSessionId
-} from "../chunk-MISLIVUL.js";
+} from "../chunk-IKIJVRHU.js";
 import {
-  extractMemories,
   parseTranscript,
-  resolveUserId,
   stripSystemReminders
-} from "../chunk-KR63XYFW.js";
+} from "../chunk-UKGD7QXV.js";
+import {
+  extractMemories,
+  resolveUserId
+} from "../chunk-VR3TRSC7.js";
 import {
   getConfig
 } from "../chunk-SEPYQK3J.js";

package/dist/hooks/on-stop.js

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
 import {
   closeEngine,
-  getEngine,
+  getEngine
+} from "../chunk-TSA67QME.js";
+import {
   isValidTranscriptPath,
   sanitizeSessionId
-} from "../chunk-MISLIVUL.js";
+} from "../chunk-IKIJVRHU.js";
+import {
+  parseTranscript
+} from "../chunk-UKGD7QXV.js";
 import {
   extractMemories,
-  parseTranscript,
   resolveUserId
-} from "../chunk-KR63XYFW.js";
+} from "../chunk-VR3TRSC7.js";
 import {
   getConfig
 } from "../chunk-SEPYQK3J.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   parseGlobalArgs
-} from "./chunk-NU5ZJJXP.js";
+} from "./chunk-SYPVELIW.js";
 import {
   closeEngine
 } from "./chunk-VAVUPQZA.js";
@@ -33,6 +33,7 @@ Commands:
   compress         Run compression only
   update           Update to latest version
   sync             Manage multi-device sync (enable/disable/status/now/device-id)
+  enforce          Run the enforce backend for client Stop hooks (advanced)
 
 Init Options:
   (no flag)           Initialize DB + MCP server (base setup)
@@ -116,17 +117,17 @@ async function main() {
   try {
     switch (command) {
       case "store": {
-        const mod = await import("./store-V7I5RJ6Y.js");
+        const mod = await import("./store-DTN3PTFQ.js");
         await mod.run(commandOptions);
         break;
       }
       case "search": {
-        const mod = await import("./search-TVOCWXRB.js");
+        const mod = await import("./search-IXV43G2C.js");
         await mod.run(commandOptions);
         break;
       }
       case "ingest": {
-        const mod = await import("./ingest-PQFTEAFQ.js");
+        const mod = await import("./ingest-JWLBIFEI.js");
         await mod.run(commandOptions);
         break;
       }
@@ -136,57 +137,57 @@ async function main() {
         break;
       }
       case "count": {
-        const mod = await import("./count-KSE5XYCT.js");
+        const mod = await import("./count-WRCFIWWS.js");
         await mod.run(commandOptions);
         break;
       }
       case "clear": {
-        const mod = await import("./clear-XVW4R7ZD.js");
+        const mod = await import("./clear-HNVVALWL.js");
         await mod.run(commandOptions);
         break;
       }
       case "relate": {
-        const mod = await import("./relate-MIOQYWTI.js");
+        const mod = await import("./relate-TEZ3GIIY.js");
         await mod.run(commandOptions);
         break;
       }
       case "invalidate": {
-        const mod = await import("./invalidate-QPOV2E5U.js");
+        const mod = await import("./invalidate-VUHHNZUX.js");
         await mod.run(commandOptions);
         break;
       }
       case "feedback": {
-        const mod = await import("./feedback-JXSKOFRS.js");
+        const mod = await import("./feedback-O6NKG46O.js");
         await mod.run(commandOptions);
         break;
       }
       case "working-memory": {
-        const mod = await import("./working-memory-LJ2XMUE2.js");
+        const mod = await import("./working-memory-CH524PJA.js");
         await mod.run(commandOptions);
         break;
       }
       case "maintain": {
-        const mod = await import("./maintain-5QUJACCJ.js");
+        const mod = await import("./maintain-UUZ76QET.js");
         await mod.run(commandOptions);
         break;
       }
       case "compress": {
-        const mod = await import("./compress-LYRY4WUY.js");
+        const mod = await import("./compress-VZJHSVJK.js");
         await mod.run(commandOptions);
         break;
       }
       case "status": {
-        const mod = await import("./status-RSXRXD7C.js");
+        const mod = await import("./status-IHYARQXU.js");
         await mod.run(commandOptions);
         break;
       }
       case "init": {
-        const mod = await import("./init-US5IURGE.js");
+        const mod = await import("./init-LIWL7Y3H.js");
         await mod.run(commandOptions);
         break;
       }
       case "reset": {
-        const mod = await import("./reset-CYY4KYAB.js");
+        const mod = await import("./reset-HQFOMYVP.js");
         await mod.run(commandOptions);
         break;
       }
@@ -196,7 +197,12 @@ async function main() {
         break;
       }
       case "sync": {
-        const mod = await import("./sync-UJBD7575.js");
+        const mod = await import("./sync-EHYMBZHE.js");
+        await mod.run(commandOptions);
+        break;
+      }
+      case "enforce": {
+        const mod = await import("./enforce-PHO4L7C2.js");
         await mod.run(commandOptions);
         break;
       }

package/dist/ingest-JWLBIFEI.js

@@ -0,0 +1,97 @@
+import {
+  parseTranscriptContent
+} from "./chunk-UKGD7QXV.js";
+import {
+  classifyTurn
+} from "./chunk-VR3TRSC7.js";
+import {
+  optionalOption
+} from "./chunk-SYPVELIW.js";
+import {
+  getEngine
+} from "./chunk-VAVUPQZA.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/ingest.ts
+import { readFileSync } from "fs";
+function turnsToMemories(turns, userId, namespace, sessionShort) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const memories = [];
+  for (let i = 0; i < turns.length; i++) {
+    const turn = turns[i];
+    if (turn.content.length < 20) continue;
+    const content = turn.content.length > 500 ? turn.content.slice(0, 497) + "..." : turn.content;
+    memories.push({
+      userId,
+      namespace: namespace ?? `session-${sessionShort}`,
+      memoryType: classifyTurn(turn),
+      content,
+      documentDate: now,
+      sourceId: `cc-${sessionShort}-${i}`,
+      confidence: turn.role === "user" ? 0.9 : 0.8
+    });
+  }
+  return memories;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8").trim();
+}
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const file = optionalOption(args, "--file");
+  const namespace = optionalOption(args, "--namespace");
+  let content;
+  if (file) {
+    try {
+      content = readFileSync(file, "utf-8");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      outputError(`Failed to read file: ${msg}`, format);
+      process.exitCode = 1;
+      return;
+    }
+  } else {
+    content = await readStdin();
+  }
+  if (!content) {
+    outputError("No transcript content provided", format);
+    process.exitCode = 1;
+    return;
+  }
+  const parsed = parseTranscriptContent(content);
+  const sessionShort = parsed.sessionId ? parsed.sessionId.slice(0, 8) : "unknown";
+  const memories = turnsToMemories(
+    parsed.turns,
+    userId,
+    namespace,
+    sessionShort
+  );
+  if (memories.length === 0) {
+    output({ stored: 0, message: "No memories extracted from transcript" }, format);
+    return;
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const stored = await engine.storeBatch(memories);
+  output(
+    {
+      stored: stored.length,
+      sessionId: parsed.sessionId || void 0,
+      namespace: namespace ?? `session-${sessionShort}`
+    },
+    format
+  );
+}
+export {
+  run
+};

package/dist/init-ARU2CIOH.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-SYPVELIW.js";
+import {
+  getDefaultDbPath,
+  getEngine
+} from "./chunk-VAVUPQZA.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
+};