@memrosetta/cli 0.4.0 → 0.4.2

package/dist/chunk-72IW6TAV.js

@@ -0,0 +1,59 @@
+import {
+  getConfig
+} from "./chunk-SEPYQK3J.js";
+
+// src/engine.ts
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { mkdirSync, existsSync } from "fs";
+var DEFAULT_DB = join(homedir(), ".memrosetta", "memories.db");
+var cachedEngine = null;
+var cachedDbPath = null;
+async function createEngineInstance(options) {
+  const config = getConfig();
+  const dbPath = options.db ?? config.dbPath ?? DEFAULT_DB;
+  const dir = dirname(dbPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const { SqliteMemoryEngine } = await import("@memrosetta/core");
+  let embedder;
+  if (!options.noEmbeddings && config.enableEmbeddings !== false) {
+    try {
+      const { HuggingFaceEmbedder } = await import("@memrosetta/embeddings");
+      const preset = options.embeddingPreset ?? config.embeddingPreset ?? "en";
+      embedder = new HuggingFaceEmbedder({ preset });
+      await embedder.initialize();
+    } catch {
+    }
+  }
+  const engine = new SqliteMemoryEngine({ dbPath, embedder });
+  await engine.initialize();
+  return engine;
+}
+async function getEngine(options) {
+  const config = getConfig();
+  const dbPath = options.db ?? config.dbPath ?? DEFAULT_DB;
+  if (cachedEngine && cachedDbPath === dbPath) {
+    return cachedEngine;
+  }
+  cachedEngine = await createEngineInstance(options);
+  cachedDbPath = dbPath;
+  return cachedEngine;
+}
+function getDefaultDbPath() {
+  return DEFAULT_DB;
+}
+async function closeEngine() {
+  if (cachedEngine) {
+    await cachedEngine.close();
+    cachedEngine = null;
+    cachedDbPath = null;
+  }
+}
+
+export {
+  getEngine,
+  getDefaultDbPath,
+  closeEngine
+};

package/dist/chunk-MISLIVUL.js

@@ -0,0 +1,70 @@
+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((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-NU5ZJJXP.js

@@ -0,0 +1,63 @@
+// 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"
+]);
+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-SEPYQK3J.js

@@ -0,0 +1,60 @@
+// src/hooks/config.ts
+import { join } from "path";
+import { homedir, userInfo } from "os";
+import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync } from "fs";
+var MEMROSETTA_DIR = join(homedir(), ".memrosetta");
+var CONFIG_PATH = join(MEMROSETTA_DIR, "config.json");
+var DB_PATH = join(MEMROSETTA_DIR, "memories.db");
+var DEFAULT_CONFIG = {
+  dbPath: DB_PATH,
+  enableEmbeddings: true,
+  maxRecallResults: 5,
+  minQueryLength: 5,
+  maxContextChars: 2e3
+};
+function getDefaultDbPath() {
+  return DB_PATH;
+}
+function ensureDir() {
+  if (!existsSync(MEMROSETTA_DIR)) {
+    mkdirSync(MEMROSETTA_DIR, { recursive: true, mode: 448 });
+  }
+  try {
+    chmodSync(MEMROSETTA_DIR, 448);
+  } catch {
+  }
+}
+function getConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      ...DEFAULT_CONFIG,
+      ...parsed
+    };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+function writeConfig(config) {
+  ensureDir();
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+  try {
+    chmodSync(CONFIG_PATH, 384);
+  } catch {
+  }
+}
+function getDefaultUserId() {
+  return userInfo().username;
+}
+
+export {
+  getDefaultDbPath,
+  ensureDir,
+  getConfig,
+  writeConfig,
+  getDefaultUserId
+};

package/dist/clear-47OFIDME.js

@@ -0,0 +1,39 @@
+import {
+  hasFlag,
+  optionalOption
+} from "./chunk-VZQURGWB.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.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/clear-5SZVGYBX.js

@@ -0,0 +1,39 @@
+import {
+  hasFlag,
+  optionalOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.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-SEFTKZMU.js

@@ -0,0 +1,33 @@
+import {
+  optionalOption
+} from "./chunk-VZQURGWB.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.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/compress-YNY6YNFU.js

@@ -0,0 +1,33 @@
+import {
+  optionalOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.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-AMSEVDWR.js

@@ -0,0 +1,24 @@
+import {
+  optionalOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.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/count-Z67KBEMV.js

@@ -0,0 +1,24 @@
+import {
+  optionalOption
+} from "./chunk-VZQURGWB.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.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/feedback-QDOWDWHM.js

@@ -0,0 +1,40 @@
+import {
+  hasFlag
+} from "./chunk-VZQURGWB.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.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 });
+  await engine.feedback(memoryId, helpful);
+  output({ memoryId, helpful }, format);
+}
+export {
+  run
+};

package/dist/feedback-XGBKFQXC.js

@@ -0,0 +1,40 @@
+import {
+  hasFlag
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-72IW6TAV.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 });
+  await engine.feedback(memoryId, helpful);
+  output({ memoryId, helpful }, format);
+}
+export {
+  run
+};

package/dist/get-NY5H3MUA.js

@@ -0,0 +1,30 @@
+import {
+  getEngine
+} from "./chunk-72IW6TAV.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import "./chunk-SEPYQK3J.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

@@ -4,7 +4,7 @@ import {
   getEngineWithTimeout,
   isValidTranscriptPath,
   sanitizeSessionId
-} from "../chunk-XL6EHACB.js";
+} from "../chunk-MISLIVUL.js";
 import {
   extractMemories,
   parseTranscript,
@@ -13,7 +13,7 @@ import {
 } from "../chunk-KR63XYFW.js";
 import {
   getConfig
-} from "../chunk-TU5EHSDE.js";
+} from "../chunk-SEPYQK3J.js";
 
 // src/hooks/on-prompt.ts
 import { existsSync, statSync } from "fs";

package/dist/hooks/on-stop.js

@@ -4,7 +4,7 @@ import {
   getEngine,
   isValidTranscriptPath,
   sanitizeSessionId
-} from "../chunk-XL6EHACB.js";
+} from "../chunk-MISLIVUL.js";
 import {
   extractMemories,
   parseTranscript,
@@ -12,7 +12,7 @@ import {
 } from "../chunk-KR63XYFW.js";
 import {
   getConfig
-} from "../chunk-TU5EHSDE.js";
+} from "../chunk-SEPYQK3J.js";
 
 // src/hooks/on-stop.ts
 import { existsSync } from "fs";