@memrosetta/cli 0.5.0 → 0.5.2

package/dist/duplicates-IBUS7CJS.js

@@ -0,0 +1,149 @@
+import {
+  hasFlag,
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  resolveDbPath
+} from "./chunk-VMGX5FCY.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  resolveCanonicalUserId
+} from "./chunk-RZFCVYTK.js";
+
+// src/commands/duplicates.ts
+var PREVIEW_LIMIT = 200;
+var MAX_GROUPS_IN_TEXT = 20;
+function scanDuplicates(db, canonicalUserId, limit) {
+  const groups = db.prepare(
+    `SELECT
+         content,
+         memory_type     AS memoryType,
+         COUNT(*)        AS totalRows,
+         COUNT(DISTINCT user_id) AS distinctUsers,
+         GROUP_CONCAT(DISTINCT user_id) AS users
+       FROM memories
+       GROUP BY content, memory_type
+       HAVING totalRows > 1
+       ORDER BY totalRows DESC
+       LIMIT ?`
+  ).all(limit);
+  const memberStmt = db.prepare(
+    `SELECT
+       memory_id     AS memoryId,
+       user_id       AS userId,
+       namespace,
+       learned_at    AS learnedAt,
+       use_count     AS useCount,
+       success_count AS successCount
+     FROM memories
+     WHERE content = ? AND memory_type = ?
+     ORDER BY learned_at DESC`
+  );
+  return groups.map((g) => {
+    const members = memberStmt.all(g.content, g.memoryType);
+    const sorted = [...members].sort((a, b) => scoreMember(b, canonicalUserId) - scoreMember(a, canonicalUserId));
+    return {
+      content: g.content,
+      memoryType: g.memoryType,
+      totalRows: g.totalRows,
+      distinctUsers: g.distinctUsers,
+      users: (g.users ?? "").split(","),
+      members,
+      recommendedKeep: sorted[0]?.memoryId ?? null
+    };
+  });
+}
+function scoreMember(row, canonicalUserId) {
+  let score = 0;
+  if (row.userId === canonicalUserId) score += 1e6;
+  score += (row.successCount ?? 0) * 100;
+  score += (row.useCount ?? 0) * 10;
+  const ms = Date.parse(row.learnedAt);
+  if (!Number.isNaN(ms)) score += ms / 1e6;
+  return score;
+}
+async function run(options) {
+  const { args, format, db: dbOverride } = options;
+  const sub = args[0];
+  if (sub !== "report") {
+    outputError(
+      "Usage: memrosetta duplicates report [--format json|text] [--limit <n>] [--canonical <user>]",
+      format
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const sliced = args.slice(1);
+  const limitRaw = optionalOption(sliced, "--limit");
+  const limit = limitRaw ? Math.max(1, parseInt(limitRaw, 10)) : PREVIEW_LIMIT;
+  const verbose = hasFlag(sliced, "--verbose");
+  const canonicalOverride = optionalOption(sliced, "--canonical");
+  const canonicalUserId = resolveCanonicalUserId(canonicalOverride ?? null);
+  const dbPath = resolveDbPath(dbOverride);
+  const { default: Database } = await import("better-sqlite3");
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const groups = scanDuplicates(db, canonicalUserId, limit);
+    const totalGroups = groups.length;
+    const crossUserGroups = groups.filter((g) => g.distinctUsers > 1).length;
+    const totalDuplicateRows = groups.reduce((sum, g) => sum + g.totalRows, 0);
+    if (format === "text") {
+      printText(groups, canonicalUserId, {
+        totalGroups,
+        crossUserGroups,
+        totalDuplicateRows,
+        verbose
+      });
+      return;
+    }
+    output(
+      {
+        canonicalUserId,
+        totalGroups,
+        crossUserGroups,
+        totalDuplicateRows,
+        groups
+      },
+      format
+    );
+  } finally {
+    db.close();
+  }
+}
+function printText(groups, canonicalUserId, summary) {
+  const lines = [];
+  lines.push(`Duplicate audit (canonical='${canonicalUserId}')`);
+  lines.push("=".repeat(60));
+  lines.push(`  duplicate groups         : ${summary.totalGroups}`);
+  lines.push(`  cross-user groups        : ${summary.crossUserGroups}`);
+  lines.push(`  total duplicate rows     : ${summary.totalDuplicateRows}`);
+  lines.push("");
+  const shown = groups.slice(0, summary.verbose ? groups.length : MAX_GROUPS_IN_TEXT);
+  for (const group of shown) {
+    const excerpt = group.content.length > 80 ? group.content.slice(0, 80) + "\u2026" : group.content;
+    lines.push(`- [${group.memoryType}] rows=${group.totalRows} users=${group.distinctUsers}`);
+    lines.push(`  content: ${excerpt}`);
+    lines.push(`  users: ${group.users.join(", ")}`);
+    if (group.recommendedKeep) {
+      lines.push(`  recommended keep: ${group.recommendedKeep}`);
+    }
+    if (summary.verbose) {
+      for (const m of group.members) {
+        lines.push(
+          `    - ${m.memoryId} user=${m.userId} use=${m.useCount} success=${m.successCount} learned=${m.learnedAt}`
+        );
+      }
+    }
+    lines.push("");
+  }
+  if (!summary.verbose && groups.length > MAX_GROUPS_IN_TEXT) {
+    lines.push(`(+${groups.length - MAX_GROUPS_IN_TEXT} more groups \u2014 pass --verbose to list all)`);
+  }
+  process.stdout.write(lines.join("\n") + "\n");
+}
+export {
+  run
+};

package/dist/enforce-T7AS4PVD.js

@@ -0,0 +1,381 @@
+import {
+  resolveUserId
+} from "./chunk-CEHRM6IW.js";
+import {
+  hasFlag,
+  optionalOption,
+  requireOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-47SU2YUJ.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-WYHEAKPC.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
+};