@memrosetta/cli 0.3.2 → 0.4.0

package/dist/chunk-RDUU53MG.js

@@ -0,0 +1,343 @@
+// src/integrations/claude-code.ts
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+var CLAUDE_DIR = join(homedir(), ".claude");
+var CLAUDE_SETTINGS_PATH = join(CLAUDE_DIR, "settings.json");
+var CLAUDE_MD_PATH = join(CLAUDE_DIR, "CLAUDE.md");
+function isMemrosettaHook(command) {
+  return command.includes("memrosetta") && (command.includes("on-stop") || command.includes("on-prompt"));
+}
+function readClaudeSettings() {
+  if (!existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(
+      readFileSync(CLAUDE_SETTINGS_PATH, "utf-8")
+    );
+  } catch {
+    return {};
+  }
+}
+function writeClaudeSettings(settings) {
+  if (!existsSync(CLAUDE_DIR)) {
+    throw new Error(
+      "~/.claude directory does not exist. Is Claude Code installed?"
+    );
+  }
+  writeFileSync(
+    CLAUDE_SETTINGS_PATH,
+    JSON.stringify(settings, null, 2),
+    "utf-8"
+  );
+}
+function removeMemrosettaHooksFromSettings(settings) {
+  if (!settings.hooks) return settings;
+  const cleaned = {};
+  for (const [eventType, hookConfigs] of Object.entries(settings.hooks)) {
+    const filtered = hookConfigs.filter(
+      (hc) => !hc.hooks.some((h) => isMemrosettaHook(h.command))
+    );
+    cleaned[eventType] = filtered;
+  }
+  return { ...settings, hooks: cleaned };
+}
+function isClaudeCodeInstalled() {
+  return existsSync(CLAUDE_DIR);
+}
+function isClaudeCodeConfigured() {
+  const settings = readClaudeSettings();
+  const stopHooks = settings.hooks?.["Stop"] || [];
+  return stopHooks.some(
+    (hc) => hc.hooks.some((h) => isMemrosettaHook(h.command))
+  );
+}
+function registerClaudeCodeHooks() {
+  if (!isClaudeCodeInstalled()) return false;
+  let settings = readClaudeSettings();
+  if (!settings.hooks) {
+    settings = { ...settings, hooks: {} };
+  }
+  settings = removeMemrosettaHooksFromSettings(settings);
+  const stopHookConfigs = settings.hooks["Stop"] || [];
+  settings.hooks["Stop"] = [
+    ...stopHookConfigs,
+    {
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: "npx -y @memrosetta/cli memrosetta-on-stop",
+          timeout: 15
+        }
+      ]
+    }
+  ];
+  writeClaudeSettings(settings);
+  return true;
+}
+function removeClaudeCodeHooks() {
+  if (!existsSync(CLAUDE_SETTINGS_PATH)) return false;
+  const settings = readClaudeSettings();
+  if (!settings.hooks) return false;
+  const cleaned = removeMemrosettaHooksFromSettings(settings);
+  writeClaudeSettings(cleaned);
+  return true;
+}
+function updateClaudeMd() {
+  if (!isClaudeCodeInstalled()) return false;
+  const marker = "## MemRosetta (Long-term Memory)";
+  const existing = existsSync(CLAUDE_MD_PATH) ? readFileSync(CLAUDE_MD_PATH, "utf-8") : "";
+  if (existing.includes(marker)) return false;
+  const memorySection = `
+
+${marker}
+
+MCP server \`memory-service\` provides long-term memory across sessions.
+userId defaults to the system username -- no need to specify it.
+
+### Search (mcp__memory-service__memrosetta_search)
+When you need information not in the current context, search past memories.
+No need to specify userId -- it defaults to the system username.
+
+### Store (mcp__memory-service__memrosetta_store)
+You MUST store the following immediately when encountered:
+- **Decisions**: Any technical choice ("We decided to use X", "Going with approach B")
+- **Facts**: Key project facts ("API runs on port 8080", "Database is PostgreSQL")
+- **Preferences**: User preferences ("I prefer functional style", "Always use TypeScript")
+- **Events**: Completed milestones ("Auth system deployed", "Migration completed")
+
+Always include 2-3 keywords. Example:
+  content: "Decided to use OAuth2 with PKCE for auth"
+  type: "decision"
+  keywords: "auth, oauth2, pkce"
+
+Do NOT store:
+- Code itself (belongs in git)
+- File operations ("Created file X", "Modified Y")
+- Debugging steps and attempts
+- Simple confirmations or acknowledgments
+- Implementation details (HOW you did it)
+
+Focus on WHAT was decided, learned, or achieved -- not HOW.
+No need to specify userId -- it defaults to the system username.
+`;
+  writeFileSync(CLAUDE_MD_PATH, existing + memorySection, "utf-8");
+  return true;
+}
+function removeClaudeMdSection() {
+  if (!existsSync(CLAUDE_MD_PATH)) return false;
+  const content = readFileSync(CLAUDE_MD_PATH, "utf-8");
+  const marker = "## MemRosetta (Long-term Memory)";
+  const markerIdx = content.indexOf(marker);
+  if (markerIdx === -1) return false;
+  const afterMarker = content.slice(markerIdx + marker.length);
+  const nextHeadingMatch = afterMarker.match(/\n## (?!MemRosetta)/);
+  const endIdx = nextHeadingMatch ? markerIdx + marker.length + (nextHeadingMatch.index ?? afterMarker.length) : content.length;
+  const before = content.slice(0, markerIdx).replace(/\n+$/, "");
+  const after = content.slice(endIdx);
+  const updated = (before + after).trimEnd() + "\n";
+  writeFileSync(CLAUDE_MD_PATH, updated, "utf-8");
+  return true;
+}
+
+// src/integrations/mcp.ts
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+var MCP_CONFIG_PATH = join2(homedir2(), ".mcp.json");
+var SERVER_NAME = "memory-service";
+function readMcpConfig(path) {
+  if (!existsSync2(path)) return {};
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeMcpConfig(path, config) {
+  writeFileSync2(path, JSON.stringify(config, null, 2), "utf-8");
+}
+function mcpServerEntry() {
+  return {
+    command: "npx",
+    args: ["-y", "@memrosetta/mcp"],
+    env: {
+      MEMROSETTA_EMBEDDINGS: "false"
+    }
+  };
+}
+function isGenericMCPConfigured() {
+  const config = readMcpConfig(MCP_CONFIG_PATH);
+  return !!config.mcpServers?.[SERVER_NAME];
+}
+function registerGenericMCP() {
+  const config = readMcpConfig(MCP_CONFIG_PATH);
+  const servers = config.mcpServers ?? {};
+  writeMcpConfig(MCP_CONFIG_PATH, {
+    ...config,
+    mcpServers: { ...servers, [SERVER_NAME]: mcpServerEntry() }
+  });
+}
+function removeGenericMCP() {
+  if (!existsSync2(MCP_CONFIG_PATH)) return false;
+  const config = readMcpConfig(MCP_CONFIG_PATH);
+  if (!config.mcpServers?.[SERVER_NAME]) return false;
+  const { [SERVER_NAME]: _, ...rest } = config.mcpServers;
+  writeMcpConfig(MCP_CONFIG_PATH, { ...config, mcpServers: rest });
+  return true;
+}
+function getGenericMCPPath() {
+  return MCP_CONFIG_PATH;
+}
+
+// src/integrations/cursor.ts
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync } from "fs";
+var SERVER_NAME2 = "memory-service";
+var CURSOR_RULES_PATH_GETTER = () => join3(homedir3(), ".cursorrules");
+var MEMROSETTA_CURSOR_RULES_MARKER = "## MemRosetta (Long-term Memory)";
+var MEMROSETTA_CURSOR_RULES = `
+
+${MEMROSETTA_CURSOR_RULES_MARKER}
+
+MCP server \`memory-service\` provides persistent memory across sessions.
+userId defaults to the system username -- no need to specify it.
+
+### When to search (memrosetta_search)
+When you need information not in the current context, search past memories.
+No need to specify userId -- it defaults to the system username.
+
+### When to store (memrosetta_store)
+You MUST store the following immediately when encountered:
+- **Decisions**: Any technical choice ("We decided to use X", "Going with approach B")
+- **Facts**: Key project facts ("API runs on port 8080", "Database is PostgreSQL")
+- **Preferences**: User preferences ("I prefer functional style", "Always use TypeScript")
+- **Events**: Completed milestones ("Auth system deployed", "Migration completed")
+
+Always include 2-3 keywords. Example:
+  content: "Decided to use OAuth2 with PKCE for auth"
+  type: "decision"
+  keywords: "auth, oauth2, pkce"
+
+Do NOT store:
+- Code itself (belongs in git)
+- File operations ("Created file X", "Modified Y")
+- Debugging steps and attempts
+- Simple confirmations or acknowledgments
+- Implementation details (HOW you did it)
+
+Focus on WHAT was decided, learned, or achieved -- not HOW.
+No need to specify userId -- it defaults to the system username.
+
+### When to relate (memrosetta_relate)
+When new information updates or contradicts existing memories, create a relation.
+
+### Working memory (memrosetta_working_memory)
+Call this at the start of complex tasks to load relevant context.
+No need to specify userId -- it defaults to the system username.
+`;
+function getCursorConfigDir() {
+  return join3(homedir3(), ".cursor");
+}
+function getCursorMcpPath() {
+  return join3(getCursorConfigDir(), "mcp.json");
+}
+function readCursorConfig(path) {
+  if (!existsSync3(path)) return {};
+  try {
+    return JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeCursorConfig(path, config) {
+  const dir = getCursorConfigDir();
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync3(path, JSON.stringify(config, null, 2), "utf-8");
+}
+function mcpServerEntry2() {
+  return {
+    command: "npx",
+    args: ["-y", "@memrosetta/mcp"],
+    env: {
+      MEMROSETTA_EMBEDDINGS: "false"
+    }
+  };
+}
+function isCursorConfigured() {
+  const path = getCursorMcpPath();
+  const config = readCursorConfig(path);
+  return !!config.mcpServers?.[SERVER_NAME2];
+}
+function registerCursorMCP() {
+  const path = getCursorMcpPath();
+  const config = readCursorConfig(path);
+  const servers = config.mcpServers ?? {};
+  writeCursorConfig(path, {
+    ...config,
+    mcpServers: { ...servers, [SERVER_NAME2]: mcpServerEntry2() }
+  });
+  updateCursorRules();
+}
+function removeCursorMCP() {
+  const path = getCursorMcpPath();
+  if (!existsSync3(path)) return false;
+  const config = readCursorConfig(path);
+  if (!config.mcpServers?.[SERVER_NAME2]) return false;
+  const { [SERVER_NAME2]: _, ...rest } = config.mcpServers;
+  writeCursorConfig(path, { ...config, mcpServers: rest });
+  removeCursorRulesSection();
+  return true;
+}
+function getCursorMcpConfigPath() {
+  return getCursorMcpPath();
+}
+function getCursorRulesPath() {
+  return CURSOR_RULES_PATH_GETTER();
+}
+function updateCursorRules() {
+  const rulesPath = CURSOR_RULES_PATH_GETTER();
+  const existing = existsSync3(rulesPath) ? readFileSync3(rulesPath, "utf-8") : "";
+  if (existing.includes(MEMROSETTA_CURSOR_RULES_MARKER)) return false;
+  writeFileSync3(rulesPath, existing + MEMROSETTA_CURSOR_RULES, "utf-8");
+  return true;
+}
+function removeCursorRulesSection() {
+  const rulesPath = CURSOR_RULES_PATH_GETTER();
+  if (!existsSync3(rulesPath)) return false;
+  const content = readFileSync3(rulesPath, "utf-8");
+  const markerIdx = content.indexOf(MEMROSETTA_CURSOR_RULES_MARKER);
+  if (markerIdx === -1) return false;
+  const afterMarker = content.slice(
+    markerIdx + MEMROSETTA_CURSOR_RULES_MARKER.length
+  );
+  const nextHeadingMatch = afterMarker.match(/\n## (?!MemRosetta)/);
+  const endIdx = nextHeadingMatch ? markerIdx + MEMROSETTA_CURSOR_RULES_MARKER.length + (nextHeadingMatch.index ?? afterMarker.length) : content.length;
+  const before = content.slice(0, markerIdx).replace(/\n+$/, "");
+  const after = content.slice(endIdx);
+  const updated = (before + after).trimEnd() + "\n";
+  writeFileSync3(rulesPath, updated, "utf-8");
+  return true;
+}
+
+export {
+  isClaudeCodeInstalled,
+  isClaudeCodeConfigured,
+  registerClaudeCodeHooks,
+  removeClaudeCodeHooks,
+  updateClaudeMd,
+  removeClaudeMdSection,
+  isGenericMCPConfigured,
+  registerGenericMCP,
+  removeGenericMCP,
+  getGenericMCPPath,
+  isCursorConfigured,
+  registerCursorMCP,
+  removeCursorMCP,
+  getCursorMcpConfigPath,
+  getCursorRulesPath,
+  removeCursorRulesSection
+};

package/dist/chunk-RYPYJJ2K.js

@@ -0,0 +1,70 @@
+import {
+  ensureDir,
+  getConfig
+} from "./chunk-JGE6RXXH.js";
+
+// src/hooks/engine-manager.ts
+import { SqliteMemoryEngine } from "@memrosetta/core";
+var engineInstance = null;
+async function getEngine() {
+  if (engineInstance) return engineInstance;
+  const config = getConfig();
+  ensureDir();
+  let embedder;
+  if (config.enableEmbeddings) {
+    try {
+      const { HuggingFaceEmbedder } = await import("@memrosetta/embeddings");
+      const preset = config.embeddingPreset ?? "en";
+      embedder = new HuggingFaceEmbedder({ preset });
+      await embedder.initialize();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(
+        `[memrosetta] Failed to load embeddings, continuing without: ${message}
+`
+      );
+    }
+  }
+  engineInstance = new SqliteMemoryEngine({
+    dbPath: config.dbPath,
+    embedder
+  });
+  await engineInstance.initialize();
+  return engineInstance;
+}
+async function closeEngine() {
+  if (engineInstance) {
+    await engineInstance.close();
+    engineInstance = null;
+  }
+}
+async function getEngineWithTimeout(timeoutMs) {
+  let timer;
+  const enginePromise = getEngine();
+  const timeoutPromise = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2(null), timeoutMs);
+  });
+  const result = await Promise.race([enginePromise, timeoutPromise]);
+  clearTimeout(timer);
+  return result;
+}
+
+// src/hooks/path-validation.ts
+import { resolve } from "path";
+import { homedir } from "os";
+var CLAUDE_DIR = resolve(homedir(), ".claude");
+function isValidTranscriptPath(p) {
+  const resolved = resolve(p);
+  return resolved.startsWith(CLAUDE_DIR) && resolved.endsWith(".jsonl");
+}
+function sanitizeSessionId(sessionId) {
+  return sessionId.replace(/[^a-zA-Z0-9_-]/g, "");
+}
+
+export {
+  getEngine,
+  closeEngine,
+  getEngineWithTimeout,
+  isValidTranscriptPath,
+  sanitizeSessionId
+};

package/dist/{chunk-CATBN3ZT.js → chunk-TQOH7ZXN.js}

@@ -211,12 +211,6 @@ Do NOT store:
 
 This checklist ensures nothing important is lost, including the last response before session ends.
 No need to specify userId -- it defaults to the system username.
-
-### Feedback (mcp__memory-service__memrosetta_feedback)
-After using a retrieved memory, report whether it was helpful:
-- Memory was accurate and useful -> feedback(memoryId, helpful=true)
-- Memory was outdated or wrong -> feedback(memoryId, helpful=false)
-This improves future search ranking automatically.
 `;
   writeFileSync(CLAUDE_MD_PATH, existing + memorySection, "utf-8");
   return true;
@@ -330,12 +324,6 @@ When new information updates or contradicts existing memories, create a relation
 ### Working memory (memrosetta_working_memory)
 Call this at the start of complex tasks to load relevant context.
 No need to specify userId -- it defaults to the system username.
-
-### Feedback (memrosetta_feedback)
-After using a retrieved memory, report whether it was helpful:
-- Memory was accurate and useful -> feedback(memoryId, helpful=true)
-- Memory was outdated or wrong -> feedback(memoryId, helpful=false)
-This improves future search ranking automatically.
 `;
 function getCursorConfigDir() {
   return join4(homedir3(), ".cursor");
@@ -422,20 +410,20 @@ function removeCursorRulesSection() {
 import { join as join5 } from "path";
 import { homedir as homedir4 } from "os";
 import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync2 } from "fs";
-var SERVER_NAME3 = "memory-service";
+var SERVER_NAME3 = "memrosetta";
 var CODEX_CONFIG_PATH_GETTER = () => join5(homedir4(), ".codex", "config.toml");
 var AGENTS_MD_MARKER = "## MemRosetta (Long-term Memory)";
 var MEMROSETTA_AGENTS_MD = `
 
 ${AGENTS_MD_MARKER}
 
-MCP server \`memory-service\` provides persistent memory across sessions.
+MCP server \`memrosetta\` provides persistent memory across sessions.
 userId defaults to the system username -- no need to specify it.
 
-### When to search (mcp__memory-service__memrosetta_search)
+### When to search (memrosetta_search)
 When you need information not in the current context, search past memories.
 
-### When to store (mcp__memory-service__memrosetta_store)
+### When to store (memrosetta_store)
 
 **After EVERY response, run this checklist:**
 1. Did I encounter a DECISION? (tech choice, approach selection) -> store as "decision"
@@ -455,10 +443,10 @@ Do NOT store:
 - Debugging steps and attempts
 - Simple confirmations or acknowledgments
 
-### When to relate (mcp__memory-service__memrosetta_relate)
+### When to relate (memrosetta_relate)
 When new information updates or contradicts existing memories, create a relation.
 
-### Working memory (mcp__memory-service__memrosetta_working_memory)
+### Working memory (memrosetta_working_memory)
 Call this at the start of complex tasks to load relevant context.
 `;
 function getCodexConfigDir() {

package/dist/chunk-Y6NH6K27.js

@@ -0,0 +1,209 @@
+// src/hooks/transcript-parser.ts
+import { readFileSync } from "fs";
+function stripSystemReminders(text) {
+  let result = text;
+  while (result.includes("<system-reminder>") && result.includes("</system-reminder>")) {
+    const start = result.indexOf("<system-reminder>");
+    const end = result.indexOf("</system-reminder>") + "</system-reminder>".length;
+    result = result.slice(0, start) + result.slice(end);
+  }
+  return result.trim();
+}
+function extractAssistantText(content) {
+  if (typeof content === "string") {
+    return content.trim();
+  }
+  if (Array.isArray(content)) {
+    return content.filter(
+      (block) => block !== null && typeof block === "object" && block.type === "text" && typeof block.text === "string"
+    ).map((block) => block.text).join("\n").trim();
+  }
+  return "";
+}
+function deduplicateTurns(turns) {
+  const result = [];
+  for (const turn of turns) {
+    if (result.length === 0 || result[result.length - 1].content !== turn.content) {
+      result.push(turn);
+    }
+  }
+  return result;
+}
+function parseTranscript(transcriptPath) {
+  const content = readFileSync(transcriptPath, "utf-8");
+  return parseTranscriptContent(content);
+}
+function parseTranscriptContent(content) {
+  const lines = content.split("\n").filter((l) => l.trim());
+  let cwd = "";
+  let sessionId = "";
+  const turns = [];
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!cwd && entry.cwd) {
+      cwd = entry.cwd;
+    }
+    if (!sessionId && entry.sessionId) {
+      sessionId = entry.sessionId;
+    }
+    const msg = entry.message;
+    if (!msg || !msg.role) continue;
+    if (msg.role === "user" && typeof msg.content === "string") {
+      const clean = stripSystemReminders(msg.content);
+      if (clean && clean.length > 5) {
+        turns.push({ role: "user", content: clean });
+      }
+    } else if (msg.role === "assistant" && msg.content !== void 0) {
+      const text = extractAssistantText(
+        msg.content
+      );
+      if (text && text.length > 10) {
+        turns.push({ role: "assistant", content: text });
+      }
+    }
+  }
+  return {
+    turns: deduplicateTurns(turns),
+    cwd,
+    sessionId
+  };
+}
+
+// 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("#")) {
+      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("> ")) continue;
+    if (trimmed.length < 10) 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 < 15) 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;
+  const textLines = content.split("\n").filter((l) => {
+    const t = l.trim();
+    return t && !t.startsWith("```") && !t.startsWith("|") && !t.startsWith("- [");
+  });
+  if (codeBlockCount > 3 && textLines.length < 5) 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 {
+  stripSystemReminders,
+  parseTranscript,
+  parseTranscriptContent,
+  classifyTurn,
+  resolveUserId,
+  extractMemories
+};