@memrosetta/cli 0.5.1 → 0.5.2

package/dist/enforce-TC5SDPEZ.js

@@ -0,0 +1,381 @@
+import {
+  resolveUserId
+} from "./chunk-C4ANKSCI.js";
+import {
+  hasFlag,
+  optionalOption,
+  requireOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-VMGX5FCY.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-RZFCVYTK.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-3PJTTEOD.js

@@ -0,0 +1,51 @@
+import {
+  buildFeedbackGivenOp,
+  openCliSyncContext
+} from "./chunk-GZINXXM4.js";
+import {
+  hasFlag
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-VMGX5FCY.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-RZFCVYTK.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
+};

package/dist/feedback-IB7BHIRP.js

@@ -0,0 +1,51 @@
+import {
+  buildFeedbackGivenOp,
+  openCliSyncContext
+} from "./chunk-GGXC7TAJ.js";
+import {
+  hasFlag
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-47SU2YUJ.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-WYHEAKPC.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
+};

package/dist/get-TQ2U7HCD.js

@@ -0,0 +1,30 @@
+import {
+  getEngine
+} from "./chunk-VMGX5FCY.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-RZFCVYTK.js";
+
+// src/commands/get.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const memoryId = args.find((a) => !a.startsWith("-") && a !== "get");
+  if (!memoryId) {
+    outputError("Missing memory ID. Usage: memrosetta get <memory-id>", format);
+    process.exitCode = 1;
+    return;
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const memory = await engine.getById(memoryId);
+  if (!memory) {
+    outputError(`Memory not found: ${memoryId}`, format);
+    process.exitCode = 1;
+    return;
+  }
+  output(memory, format);
+}
+export {
+  run
+};

package/dist/get-WPZIHQKW.js

@@ -0,0 +1,30 @@
+import {
+  getEngine
+} from "./chunk-47SU2YUJ.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-WYHEAKPC.js";
+
+// src/commands/get.ts
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const memoryId = args.find((a) => !a.startsWith("-") && a !== "get");
+  if (!memoryId) {
+    outputError("Missing memory ID. Usage: memrosetta get <memory-id>", format);
+    process.exitCode = 1;
+    return;
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const memory = await engine.getById(memoryId);
+  if (!memory) {
+    outputError(`Memory not found: ${memoryId}`, format);
+    process.exitCode = 1;
+    return;
+  }
+  output(memory, format);
+}
+export {
+  run
+};

package/dist/hooks/on-prompt.js

@@ -2,7 +2,7 @@
 import {
   closeEngine,
   getEngineWithTimeout
-} from "../chunk-TSA67QME.js";
+} from "../chunk-GRNZVSAF.js";
 import {
   isValidTranscriptPath,
   sanitizeSessionId
@@ -14,10 +14,10 @@ import {
 import {
   extractMemories,
   resolveUserId
-} from "../chunk-VR3TRSC7.js";
+} from "../chunk-CEHRM6IW.js";
 import {
   getConfig
-} from "../chunk-SEPYQK3J.js";
+} from "../chunk-WYHEAKPC.js";
 
 // src/hooks/on-prompt.ts
 import { existsSync, statSync } from "fs";

package/dist/hooks/on-stop.js

@@ -2,7 +2,7 @@
 import {
   closeEngine,
   getEngine
-} from "../chunk-TSA67QME.js";
+} from "../chunk-GRNZVSAF.js";
 import {
   isValidTranscriptPath,
   sanitizeSessionId
@@ -13,10 +13,10 @@ import {
 import {
   extractMemories,
   resolveUserId
-} from "../chunk-VR3TRSC7.js";
+} from "../chunk-CEHRM6IW.js";
 import {
   getConfig
-} from "../chunk-SEPYQK3J.js";
+} from "../chunk-WYHEAKPC.js";
 
 // src/hooks/on-stop.ts
 import { existsSync } from "fs";