@memrosetta/cli 0.4.7 → 0.5.0

package/dist/chunk-SYPVELIW.js

@@ -0,0 +1,64 @@
+// src/parser.ts
+var COMMANDS = /* @__PURE__ */ new Set([
+  "store",
+  "search",
+  "ingest",
+  "get",
+  "count",
+  "clear",
+  "relate",
+  "invalidate",
+  "working-memory",
+  "maintain",
+  "compress",
+  "status",
+  "init",
+  "reset",
+  "update",
+  "feedback",
+  "sync",
+  "enforce"
+]);
+function findFlag(args, flag) {
+  return args.includes(flag);
+}
+function findOption(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return void 0;
+  return args[idx + 1];
+}
+function parseGlobalArgs(args) {
+  const command = args.find((a) => !a.startsWith("-") && COMMANDS.has(a));
+  const db = findOption(args, "--db");
+  const formatRaw = findOption(args, "--format");
+  const format = formatRaw === "json" ? "json" : "text";
+  const noEmbeddings = findFlag(args, "--no-embeddings");
+  const help = findFlag(args, "--help") || findFlag(args, "-h");
+  const version = findFlag(args, "--version") || findFlag(args, "-v");
+  const rest = args.filter((a) => a !== command);
+  return {
+    command,
+    global: { db, format, noEmbeddings, help, version },
+    rest
+  };
+}
+function requireOption(args, flag, name) {
+  const value = findOption(args, flag);
+  if (!value) {
+    throw new Error(`Missing required option: ${name} (${flag})`);
+  }
+  return value;
+}
+function optionalOption(args, flag) {
+  return findOption(args, flag);
+}
+function hasFlag(args, flag) {
+  return findFlag(args, flag);
+}
+
+export {
+  parseGlobalArgs,
+  requireOption,
+  optionalOption,
+  hasFlag
+};

package/dist/chunk-TSA67QME.js

@@ -0,0 +1,56 @@
+import {
+  ensureDir,
+  getConfig
+} from "./chunk-SEPYQK3J.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((resolve) => {
+    timer = setTimeout(() => resolve(null), timeoutMs);
+  });
+  const result = await Promise.race([enginePromise, timeoutPromise]);
+  clearTimeout(timer);
+  return result;
+}
+
+export {
+  getEngine,
+  closeEngine,
+  getEngineWithTimeout
+};

package/dist/chunk-UKGD7QXV.js

@@ -0,0 +1,81 @@
+// 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
+  };
+}
+
+export {
+  stripSystemReminders,
+  parseTranscript,
+  parseTranscriptContent
+};