@memrosetta/cli 0.4.7 → 0.5.0

package/dist/chunk-VR3TRSC7.js

@@ -0,0 +1,148 @@
+// src/hooks/memory-extractor.ts
+import { userInfo } from "os";
+var KEYWORD_PATTERNS = {
+  typescript: "TypeScript",
+  sqlite: "SQLite",
+  api: "API",
+  benchmark: "benchmark",
+  docker: "Docker",
+  git: "Git",
+  react: "React",
+  hono: "Hono",
+  test: "test",
+  deploy: "deploy",
+  refactor: "refactor",
+  bug: "bug",
+  memrosetta: "MemRosetta",
+  vector: "vector",
+  embedding: "embedding",
+  fts5: "FTS5",
+  search: "search",
+  memory: "memory",
+  database: "database",
+  postgresql: "PostgreSQL",
+  nextjs: "Next.js",
+  "next.js": "Next.js",
+  node: "Node.js",
+  python: "Python",
+  rust: "Rust",
+  kubernetes: "Kubernetes",
+  ci: "CI/CD",
+  security: "security",
+  auth: "authentication",
+  cache: "cache",
+  performance: "performance"
+};
+function classifyTurn(turn) {
+  const lower = turn.content.toLowerCase();
+  if (turn.role === "user") {
+    if (lower.includes("decide") || lower.includes("go with") || lower.includes("let's do") || lower.includes("proceed") || lower.includes("approved")) {
+      return "decision";
+    }
+    if (lower.includes("prefer") || lower.includes("i like") || lower.includes("i want") || lower.includes("i need")) {
+      return "preference";
+    }
+    return "event";
+  }
+  return "fact";
+}
+function extractKeywords(text) {
+  const keywords = /* @__PURE__ */ new Set();
+  const lower = text.toLowerCase();
+  for (const [pattern, keyword] of Object.entries(KEYWORD_PATTERNS)) {
+    if (lower.includes(pattern)) {
+      keywords.add(keyword);
+    }
+  }
+  return [...keywords];
+}
+function resolveUserId(_cwd) {
+  return userInfo().username;
+}
+function extractFirstSentence(text, maxLen = 200) {
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("```")) continue;
+    if (trimmed.startsWith("|")) continue;
+    if (trimmed.startsWith("- [")) continue;
+    if (trimmed.startsWith("> ")) continue;
+    if (trimmed.startsWith("import ") || trimmed.startsWith("export ") || trimmed.startsWith("const ") || trimmed.startsWith("function ")) continue;
+    if (trimmed.startsWith("{") || trimmed.startsWith("}")) continue;
+    if (/^[\s\-=*#]+$/.test(trimmed)) continue;
+    if (trimmed.startsWith("#")) {
+      const headerText = trimmed.replace(/^#+\s*/, "");
+      if (headerText.length > 10) {
+        return headerText.length > maxLen ? headerText.slice(0, maxLen - 3) + "..." : headerText;
+      }
+      continue;
+    }
+    if (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("$")) continue;
+    if (trimmed.length < 15) continue;
+    if (!/[a-zA-Z\uAC00-\uD7AF]{3,}/.test(trimmed)) continue;
+    return trimmed.length > maxLen ? trimmed.slice(0, maxLen - 3) + "..." : trimmed;
+  }
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > maxLen ? clean.slice(0, maxLen - 3) + "..." : clean;
+}
+function isWorthStoring(turn) {
+  const content = turn.content;
+  if (content.length < 30) return false;
+  if (turn.role === "user") {
+    const lower = content.toLowerCase().trim();
+    if (lower.length < 20) return false;
+    if (lower.startsWith("/")) return false;
+    if (/^(y|n|yes|no|ok|ㅇㅇ|ㅋㅋ|ㄱㄱ|네|아니|진행|계속|좋아|해봐)$/i.test(lower)) return false;
+    return true;
+  }
+  const codeBlockCount = (content.match(/```/g) || []).length / 2;
+  if (codeBlockCount >= 2) return false;
+  const toolPatterns = [
+    /^(reading|writing|creating|editing|deleting|running|checking|searching|looking)/i,
+    /^(file|directory|folder) (created|modified|deleted|found)/i,
+    /^(let me|i'll|i will) (read|check|look|search|find|create|write|edit)/i,
+    /^(here('s| is| are) (the|a|an))/i,
+    /^\d+ (files?|tests?|errors?|warnings?) (found|passed|failed|created)/i,
+    /^(done|completed|finished|success|failed|error)/i,
+    /^(installing|building|compiling|running tests)/i
+  ];
+  for (const pattern of toolPatterns) {
+    if (pattern.test(content.trim())) return false;
+  }
+  if (content.length > 2e3) return false;
+  const wordCount = content.split(/\s+/).length;
+  const codeChars = (content.match(/[{}();=<>]/g) || []).length;
+  if (codeChars > wordCount * 0.3) return false;
+  return true;
+}
+function extractMemories(data, userId) {
+  const memories = [];
+  const sessionShort = data.sessionId ? data.sessionId.slice(0, 8) : "unknown";
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < data.turns.length; i++) {
+    const turn = data.turns[i];
+    if (!isWorthStoring(turn)) continue;
+    const content = extractFirstSentence(turn.content);
+    if (seen.has(content)) continue;
+    seen.add(content);
+    memories.push({
+      userId,
+      namespace: `session-${sessionShort}`,
+      memoryType: classifyTurn(turn),
+      content,
+      documentDate: now,
+      sourceId: `cc-${sessionShort}-${i}`,
+      confidence: turn.role === "user" ? 0.9 : 0.8,
+      keywords: extractKeywords(content)
+    });
+  }
+  return memories;
+}
+
+export {
+  classifyTurn,
+  resolveUserId,
+  extractMemories
+};

package/dist/clear-HNVVALWL.js

@@ -0,0 +1,39 @@
+import {
+  hasFlag,
+  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/clear.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const confirm = hasFlag(args, "--confirm");
+  if (!confirm) {
+    outputError(
+      "This will delete all memories for the user. Use --confirm to proceed.",
+      format
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const countBefore = await engine.count(userId);
+  await engine.clear(userId);
+  output(
+    { userId, cleared: countBefore, message: `Cleared ${countBefore} memories` },
+    format
+  );
+}
+export {
+  run
+};

package/dist/compress-VZJHSVJK.js

@@ -0,0 +1,33 @@
+import {
+  optionalOption
+} from "./chunk-SYPVELIW.js";
+import {
+  getEngine
+} from "./chunk-VAVUPQZA.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/compress.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.compress(userId);
+  if (format === "text") {
+    process.stdout.write(`Compression completed for user: ${userId}
+`);
+    process.stdout.write(`  Groups compressed: ${result.compressed}
+`);
+    process.stdout.write(`  Memories archived: ${result.removed}
+`);
+    return;
+  }
+  output({ userId, ...result }, format);
+}
+export {
+  run
+};

package/dist/count-WRCFIWWS.js

@@ -0,0 +1,24 @@
+import {
+  optionalOption
+} from "./chunk-SYPVELIW.js";
+import {
+  getEngine
+} from "./chunk-VAVUPQZA.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/count.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const engine = await getEngine({ db, noEmbeddings });
+  const count = await engine.count(userId);
+  output({ userId, count }, format);
+}
+export {
+  run
+};

package/dist/enforce-PHO4L7C2.js

@@ -0,0 +1,381 @@
+import {
+  resolveUserId
+} from "./chunk-VR3TRSC7.js";
+import {
+  hasFlag,
+  optionalOption,
+  requireOption
+} from "./chunk-SYPVELIW.js";
+import {
+  getEngine
+} from "./chunk-VAVUPQZA.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-SEPYQK3J.js";
+
+// src/commands/enforce.ts
+import { existsSync, readFileSync } from "fs";
+
+// src/hooks/llm-extractor.ts
+var SYSTEM_PROMPT = `You extract atomic long-term memories from a single
+assistant turn in a coding assistant conversation.
+
+Return a JSON object: { "memories": [...] }. Each memory has:
+  - "content": one self-contained, full-sentence fact, decision, preference,
+    or event. Keep proper nouns. Resolve pronouns. Korean stays Korean,
+    English stays English.
+  - "memoryType": one of "decision", "fact", "preference", "event".
+  - "keywords": 2-5 short keywords for search.
+  - "confidence": 0.0 to 1.0.
+
+Only emit memories the user would still care about NEXT WEEK. Ignore:
+  - acknowledgements, greetings, status updates, confirmations
+  - code snippets and diffs (those belong in git)
+  - debugging steps and intermediate reasoning
+  - questions you asked the user
+
+If nothing is worth storing, return { "memories": [] }.`;
+var VALID_TYPES = /* @__PURE__ */ new Set([
+  "decision",
+  "fact",
+  "preference",
+  "event"
+]);
+function safeParseMemories(raw) {
+  const stripped = raw.replace(/^```(?:json)?\s*|\s*```$/g, "").trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(stripped);
+  } catch {
+    return [];
+  }
+  if (!parsed || typeof parsed !== "object") return [];
+  const obj = parsed;
+  if (!Array.isArray(obj.memories)) return [];
+  const out = [];
+  for (const item of obj.memories) {
+    if (!item || typeof item !== "object") continue;
+    const m = item;
+    if (typeof m.content !== "string" || m.content.trim().length === 0) continue;
+    if (!m.memoryType || !VALID_TYPES.has(m.memoryType)) continue;
+    out.push({
+      content: m.content.trim(),
+      memoryType: m.memoryType,
+      keywords: Array.isArray(m.keywords) && m.keywords.every((k) => typeof k === "string") ? m.keywords : void 0,
+      confidence: typeof m.confidence === "number" && m.confidence >= 0 && m.confidence <= 1 ? m.confidence : void 0
+    });
+  }
+  return out;
+}
+function buildUserPrompt(params) {
+  const ctx = params.userPrompt ? `User just asked:
+${params.userPrompt.slice(0, 800)}
+
+` : "";
+  return `${ctx}Assistant turn (client=${params.client}):
+${params.text}`;
+}
+async function extractAnthropic(params) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) return null;
+  try {
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: "claude-haiku-4-5-20251001",
+        max_tokens: 1024,
+        system: SYSTEM_PROMPT,
+        messages: [{ role: "user", content: buildUserPrompt(params) }]
+      })
+    });
+    if (!res.ok) {
+      process.stderr.write(
+        `[enforce] anthropic returned ${res.status} ${res.statusText}
+`
+      );
+      return null;
+    }
+    const body = await res.json();
+    const text = body.content?.find((c) => c.type === "text")?.text?.trim() ?? "";
+    if (!text) return [];
+    return safeParseMemories(text);
+  } catch (err) {
+    process.stderr.write(
+      `[enforce] anthropic call failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+async function extractOpenAI(params) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) return null;
+  try {
+    const res = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: "gpt-4o-mini",
+        max_tokens: 1024,
+        response_format: { type: "json_object" },
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: buildUserPrompt(params) }
+        ]
+      })
+    });
+    if (!res.ok) {
+      process.stderr.write(
+        `[enforce] openai returned ${res.status} ${res.statusText}
+`
+      );
+      return null;
+    }
+    const body = await res.json();
+    const text = body.choices?.[0]?.message?.content?.trim() ?? "";
+    if (!text) return [];
+    return safeParseMemories(text);
+  } catch (err) {
+    process.stderr.write(
+      `[enforce] openai call failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+async function extractPropositionizer(params) {
+  try {
+    const importer = new Function("m", "return import(m)");
+    const mod = await importer("@memrosetta/extractor").catch(() => null);
+    if (!mod?.PropositionizerDecomposer) return null;
+    const decomposer = new mod.PropositionizerDecomposer();
+    const facts = await decomposer.decompose(params.text);
+    if (!Array.isArray(facts) || facts.length === 0) return [];
+    return facts.map((content) => ({
+      content,
+      memoryType: "fact",
+      confidence: 0.6
+    }));
+  } catch (err) {
+    process.stderr.write(
+      `[enforce] propositionizer fallback failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+async function extractWithLLM(params) {
+  const anthropic = await extractAnthropic(params);
+  if (anthropic !== null) {
+    return { memories: anthropic, source: "anthropic", attempted: true };
+  }
+  const openai = await extractOpenAI(params);
+  if (openai !== null) {
+    return { memories: openai, source: "openai", attempted: true };
+  }
+  const local = await extractPropositionizer(params);
+  if (local !== null) {
+    return { memories: local, source: "propositionizer", attempted: true };
+  }
+  return { memories: [], source: "none", attempted: false };
+}
+
+// src/commands/enforce.ts
+var MAX_ATTEMPTS = 2;
+var HEURISTIC_KEYWORDS = [
+  // English
+  "decided",
+  "choose",
+  "chose",
+  "use ",
+  "switch to",
+  "instead of",
+  "conclusion",
+  "agreed",
+  "fixed",
+  "fix:",
+  "released",
+  "deployed",
+  "discovered",
+  "found",
+  "turns out",
+  // Korean
+  "\uACB0\uC815",
+  "\uACB0\uB860",
+  "\uD569\uC758",
+  "\uD655\uC815",
+  "\uC218\uC815",
+  "\uD574\uACB0",
+  "\uBC1C\uACAC",
+  "\uBC30\uD3EC",
+  "\uBC14\uAFE8",
+  "\uBC14\uAFB8\uC790",
+  "\uBCC0\uACBD",
+  "\uAD50\uCCB4"
+];
+function loadEvent(path) {
+  if (!existsSync(path)) {
+    throw new Error(`event-json file not found: ${path}`);
+  }
+  const raw = readFileSync(path, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`event-json is not valid JSON: ${path}`);
+  }
+  const e = parsed;
+  if (!e.client || typeof e.assistantMessage !== "string") {
+    throw new Error(
+      "event-json must include at least { client, assistantMessage }"
+    );
+  }
+  return {
+    client: e.client,
+    turnId: e.turnId,
+    assistantMessage: e.assistantMessage,
+    userPrompt: e.userPrompt,
+    cwd: e.cwd,
+    transcriptPath: e.transcriptPath,
+    attempt: e.attempt ?? 1
+  };
+}
+function looksStorable(text) {
+  const lower = text.toLowerCase();
+  return HEURISTIC_KEYWORDS.some((k) => lower.includes(k.toLowerCase()));
+}
+function buildFooter(result) {
+  if (result.status === "noop") {
+    return "STORED: none (noop)";
+  }
+  if (result.status === "needs-continuation") {
+    return "STORED: pending (needs-continuation)";
+  }
+  if (result.memories.length === 0) {
+    return "STORED: failed";
+  }
+  const items = result.memories.map((m) => `${m.type}(${m.memoryId})`).join(", ");
+  return `STORED: ${items}`;
+}
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const sub = args[0];
+  if (sub !== "stop") {
+    outputError(
+      "Usage: memrosetta enforce stop --client <id> --event-json <path>",
+      format
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const sliced = args.slice(1);
+  let client;
+  let eventPath;
+  try {
+    client = requireOption(sliced, "--client", "client identifier");
+    eventPath = requireOption(sliced, "--event-json", "event JSON path");
+  } catch (err) {
+    outputError(err instanceof Error ? err.message : String(err), format);
+    process.exitCode = 1;
+    return;
+  }
+  const explicitAttempt = optionalOption(sliced, "--attempt");
+  const dryRun = hasFlag(sliced, "--dry-run");
+  let event;
+  try {
+    event = loadEvent(eventPath);
+  } catch (err) {
+    outputError(err instanceof Error ? err.message : String(err), format);
+    process.exitCode = 1;
+    return;
+  }
+  const attempt = explicitAttempt ? Math.max(1, parseInt(explicitAttempt, 10)) : event.attempt ?? 1;
+  if (!event.assistantMessage.trim()) {
+    const result2 = {
+      status: "noop",
+      structuredCount: 0,
+      extractedCount: 0,
+      memories: [],
+      footer: "STORED: none (noop)",
+      attempt,
+      maxAttempts: MAX_ATTEMPTS,
+      reason: "empty assistant message"
+    };
+    output(result2, format);
+    return;
+  }
+  const extractor = await extractWithLLM({
+    text: event.assistantMessage,
+    userPrompt: event.userPrompt,
+    client
+  });
+  const stored = [];
+  if (!dryRun && extractor.memories.length > 0) {
+    try {
+      const engine = await getEngine({ db, noEmbeddings });
+      const userId = resolveUserId(event.cwd ?? process.cwd());
+      for (const m of extractor.memories) {
+        const input = {
+          userId,
+          content: m.content,
+          memoryType: m.memoryType,
+          keywords: m.keywords,
+          confidence: m.confidence
+        };
+        const memory = await engine.store(input);
+        stored.push({ type: memory.memoryType, memoryId: memory.memoryId });
+      }
+    } catch (err) {
+      const reason2 = err instanceof Error ? err.message : String(err);
+      const result2 = {
+        status: "noop",
+        structuredCount: 0,
+        extractedCount: extractor.memories.length,
+        memories: [],
+        footer: "STORED: failed",
+        attempt,
+        maxAttempts: MAX_ATTEMPTS,
+        reason: `engine.store failed: ${reason2}`
+      };
+      output(result2, format);
+      return;
+    }
+  }
+  const extractedCount = stored.length;
+  const structuredCount = 0;
+  let status;
+  let reason;
+  if (extractedCount > 0) {
+    status = "stored";
+  } else if (looksStorable(event.assistantMessage) && attempt < MAX_ATTEMPTS && extractor.attempted) {
+    status = "needs-continuation";
+    reason = "turn looked storable (decision/conclusion keywords present) but extractor returned 0 memories";
+  } else {
+    status = "noop";
+    reason = extractor.attempted ? "extractor returned 0 memories and turn does not look storable" : "no LLM extractor available (set ANTHROPIC_API_KEY / OPENAI_API_KEY or install propositionizer model)";
+  }
+  const partial = {
+    status,
+    structuredCount,
+    extractedCount,
+    memories: stored,
+    attempt,
+    maxAttempts: MAX_ATTEMPTS,
+    reason
+  };
+  const result = { ...partial, footer: buildFooter(partial) };
+  output(result, format);
+}
+export {
+  run
+};

package/dist/feedback-JXSKOFRS.js

@@ -0,0 +1,51 @@
+import {
+  buildFeedbackGivenOp,
+  openCliSyncContext
+} from "./chunk-2MO65JLK.js";
+import {
+  hasFlag
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-VAVUPQZA.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-SEPYQK3J.js";
+
+// src/commands/feedback.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const memoryId = args.find((a) => !a.startsWith("-"));
+  if (!memoryId) {
+    outputError("Usage: memrosetta feedback <memoryId> --helpful | --not-helpful", format);
+    process.exitCode = 1;
+    return;
+  }
+  const helpful = hasFlag(args, "--helpful");
+  const notHelpful = hasFlag(args, "--not-helpful");
+  if (!helpful && !notHelpful) {
+    outputError("Specify --helpful or --not-helpful", format);
+    process.exitCode = 1;
+    return;
+  }
+  if (helpful && notHelpful) {
+    outputError("Specify either --helpful or --not-helpful, not both", format);
+    process.exitCode = 1;
+    return;
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await engine.feedback(memoryId, helpful);
+  const sync = await openCliSyncContext(resolveDbPath(db));
+  if (sync.enabled) {
+    sync.enqueue(buildFeedbackGivenOp(sync, memoryId, helpful, now));
+    sync.close();
+  }
+  output({ memoryId, helpful }, format);
+}
+export {
+  run
+};