@memrosetta/cli 0.4.5 → 0.4.7

package/dist/init-US5IURGE.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-NU5ZJJXP.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
+};

package/dist/invalidate-WXFGQHOK.js

@@ -0,0 +1,40 @@
+import {
+  buildMemoryInvalidatedOp,
+  openCliSyncContext
+} from "./chunk-KPASMEV7.js";
+import {
+  optionalOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-VAVUPQZA.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-SEPYQK3J.js";
+
+// src/commands/invalidate.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const memoryId = args.find((a) => !a.startsWith("-"));
+  if (!memoryId) {
+    outputError("Usage: memrosetta invalidate <memoryId>", format);
+    process.exitCode = 1;
+    return;
+  }
+  const reason = optionalOption(args, "--reason");
+  const engine = await getEngine({ db, noEmbeddings });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await engine.invalidate(memoryId, reason);
+  const sync = await openCliSyncContext(resolveDbPath(db));
+  if (sync.enabled) {
+    sync.enqueue(buildMemoryInvalidatedOp(sync, memoryId, now, reason));
+    sync.close();
+  }
+  output({ memoryId, invalidated: true }, format);
+}
+export {
+  run
+};

package/dist/maintain-5QUJACCJ.js

@@ -0,0 +1,37 @@
+import {
+  optionalOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-VAVUPQZA.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/maintain.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const engine = await getEngine({ db, noEmbeddings });
+  const result = await engine.maintain(userId);
+  if (format === "text") {
+    process.stdout.write(`Maintenance completed for user: ${userId}
+`);
+    process.stdout.write(`  Activation scores updated: ${result.activationUpdated}
+`);
+    process.stdout.write(`  Tiers updated: ${result.tiersUpdated}
+`);
+    process.stdout.write(`  Groups compressed: ${result.compressed}
+`);
+    process.stdout.write(`  Memories archived: ${result.removed}
+`);
+    return;
+  }
+  output({ userId, ...result }, format);
+}
+export {
+  run
+};

package/dist/relate-BQVTTMLF.js

@@ -0,0 +1,57 @@
+import {
+  buildRelationCreatedOp,
+  openCliSyncContext
+} from "./chunk-KPASMEV7.js";
+import {
+  optionalOption,
+  requireOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-VAVUPQZA.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-SEPYQK3J.js";
+
+// src/commands/relate.ts
+var VALID_RELATION_TYPES = /* @__PURE__ */ new Set([
+  "updates",
+  "extends",
+  "derives",
+  "contradicts",
+  "supports"
+]);
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const src = requireOption(args, "--src", "source memory ID");
+  const dst = requireOption(args, "--dst", "destination memory ID");
+  const relationType = requireOption(args, "--type", "relation type");
+  const reason = optionalOption(args, "--reason");
+  if (!VALID_RELATION_TYPES.has(relationType)) {
+    outputError(
+      `Invalid relation type: ${relationType}. Must be one of: updates, extends, derives, contradicts, supports`,
+      format
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const relation = await engine.relate(
+    src,
+    dst,
+    relationType,
+    reason
+  );
+  const sync = await openCliSyncContext(resolveDbPath(db));
+  if (sync.enabled) {
+    sync.enqueue(buildRelationCreatedOp(sync, relation));
+    sync.close();
+  }
+  output(relation, format);
+}
+export {
+  run
+};

package/dist/search-TVOCWXRB.js

@@ -0,0 +1,48 @@
+import {
+  optionalOption,
+  requireOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-VAVUPQZA.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/search.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const query = requireOption(args, "--query", "query");
+  const limitRaw = optionalOption(args, "--limit");
+  const namespace = optionalOption(args, "--namespace");
+  const typesRaw = optionalOption(args, "--types");
+  const minConfidenceRaw = optionalOption(args, "--min-confidence");
+  const limit = limitRaw ? parseInt(limitRaw, 10) : 5;
+  if (isNaN(limit) || limit < 1) {
+    outputError("Invalid limit value", format);
+    process.exitCode = 1;
+    return;
+  }
+  const memoryTypes = typesRaw ? typesRaw.split(",") : void 0;
+  const minConfidence = minConfidenceRaw ? parseFloat(minConfidenceRaw) : void 0;
+  const engine = await getEngine({ db, noEmbeddings });
+  const response = await engine.search({
+    userId,
+    query,
+    namespace,
+    limit,
+    filters: {
+      memoryTypes,
+      minConfidence
+    }
+  });
+  output(response, format);
+}
+export {
+  run
+};

package/dist/status-RSXRXD7C.js

@@ -0,0 +1,184 @@
+import {
+  isClaudeCodeConfigured,
+  isCodexConfigured,
+  isCursorConfigured,
+  isGeminiConfigured,
+  isGenericMCPConfigured
+} from "./chunk-IS4IKWPL.js";
+import {
+  resolveCliVersion
+} from "./chunk-YXK6FDB6.js";
+import {
+  getDefaultDbPath
+} from "./chunk-VAVUPQZA.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getConfig
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/status.ts
+import { existsSync, statSync } from "fs";
+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 geminiStatus = isGeminiConfigured();
+  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(
+      `  Gemini:        ${geminiStatus ? "configured (MCP)" : "not configured"}
+`
+    );
+    process.stdout.write(
+      `  MCP (generic): ${mcpStatus ? "configured" : "not configured"}
+`
+    );
+    return;
+  }
+  output(
+    {
+      version: resolveCliVersion(),
+      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,
+        gemini: geminiStatus,
+        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/dist/store-UL35UYIV.js

@@ -0,0 +1,101 @@
+import {
+  buildMemoryCreatedOp,
+  openCliSyncContext
+} from "./chunk-KPASMEV7.js";
+import {
+  hasFlag,
+  optionalOption,
+  requireOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-VAVUPQZA.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/store.ts
+var VALID_TYPES = /* @__PURE__ */ new Set(["fact", "preference", "decision", "event"]);
+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;
+  let input;
+  if (hasFlag(args, "--stdin")) {
+    const raw = await readStdin();
+    try {
+      const parsed = JSON.parse(raw);
+      if (!parsed.content || !parsed.memoryType) {
+        outputError(
+          "stdin JSON must have content and memoryType",
+          format
+        );
+        process.exitCode = 1;
+        return;
+      }
+      input = {
+        userId: parsed.userId ? String(parsed.userId) : getDefaultUserId(),
+        content: String(parsed.content),
+        memoryType: String(parsed.memoryType),
+        namespace: parsed.namespace ? String(parsed.namespace) : void 0,
+        keywords: Array.isArray(parsed.keywords) ? parsed.keywords : void 0,
+        confidence: typeof parsed.confidence === "number" ? parsed.confidence : void 0,
+        sourceId: parsed.sourceId ? String(parsed.sourceId) : void 0
+      };
+    } catch {
+      outputError("Invalid JSON from stdin", format);
+      process.exitCode = 1;
+      return;
+    }
+  } else {
+    const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+    const content = requireOption(args, "--content", "content");
+    const memoryType = requireOption(args, "--type", "type");
+    if (!VALID_TYPES.has(memoryType)) {
+      outputError(
+        `Invalid type: ${memoryType}. Must be one of: fact, preference, decision, event`,
+        format
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const namespace = optionalOption(args, "--namespace");
+    const keywordsRaw = optionalOption(args, "--keywords");
+    const confidenceRaw = optionalOption(args, "--confidence");
+    const sourceId = optionalOption(args, "--source-id");
+    const eventStart = optionalOption(args, "--event-start");
+    const eventEnd = optionalOption(args, "--event-end");
+    input = {
+      userId,
+      content,
+      memoryType,
+      namespace,
+      keywords: keywordsRaw ? keywordsRaw.split(",") : void 0,
+      confidence: confidenceRaw ? parseFloat(confidenceRaw) : void 0,
+      sourceId,
+      eventDateStart: eventStart,
+      eventDateEnd: eventEnd
+    };
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const memory = await engine.store(input);
+  const sync = await openCliSyncContext(resolveDbPath(db));
+  if (sync.enabled) {
+    sync.enqueue(buildMemoryCreatedOp(sync, memory));
+    sync.close();
+  }
+  output(memory, format);
+}
+export {
+  run
+};