@memrosetta/cli 0.5.0 → 0.5.2

package/dist/chunk-RZFCVYTK.js

@@ -0,0 +1,71 @@
+// 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 resolveCanonicalUserId(explicit) {
+  if (explicit && explicit.trim().length > 0) {
+    return explicit.trim();
+  }
+  const config = getConfig();
+  if (config.syncUserId && config.syncUserId.trim().length > 0) {
+    return config.syncUserId.trim();
+  }
+  return userInfo().username;
+}
+function getDefaultUserId() {
+  return resolveCanonicalUserId();
+}
+
+export {
+  getDefaultDbPath,
+  ensureDir,
+  getConfig,
+  writeConfig,
+  resolveCanonicalUserId,
+  getDefaultUserId
+};

package/dist/chunk-US6CEDMU.js

@@ -0,0 +1,66 @@
+// 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",
+  "migrate",
+  "duplicates"
+]);
+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-VMGX5FCY.js

@@ -0,0 +1,64 @@
+import {
+  getConfig
+} from "./chunk-RZFCVYTK.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;
+}
+function resolveDbPath(dbOverride) {
+  const config = getConfig();
+  return dbOverride ?? config.dbPath ?? DEFAULT_DB;
+}
+async function closeEngine() {
+  if (cachedEngine) {
+    await cachedEngine.close();
+    cachedEngine = null;
+    cachedDbPath = null;
+  }
+}
+
+export {
+  getEngine,
+  getDefaultDbPath,
+  resolveDbPath,
+  closeEngine
+};

package/dist/chunk-WYHEAKPC.js

@@ -0,0 +1,71 @@
+// 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 resolveCanonicalUserId(explicit, configLoader = getConfig) {
+  if (explicit && explicit.trim().length > 0) {
+    return explicit.trim();
+  }
+  const config = configLoader();
+  if (config.syncUserId && config.syncUserId.trim().length > 0) {
+    return config.syncUserId.trim();
+  }
+  return userInfo().username;
+}
+function getDefaultUserId() {
+  return resolveCanonicalUserId();
+}
+
+export {
+  getDefaultDbPath,
+  ensureDir,
+  getConfig,
+  writeConfig,
+  resolveCanonicalUserId,
+  getDefaultUserId
+};

package/dist/clear-32Y3U2WR.js

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

@@ -0,0 +1,39 @@
+import {
+  hasFlag,
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-VMGX5FCY.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-RZFCVYTK.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-CL5D4VVJ.js

@@ -0,0 +1,33 @@
+import {
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-VMGX5FCY.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-RZFCVYTK.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-UUEO7WCU.js

@@ -0,0 +1,33 @@
+import {
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-47SU2YUJ.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-WYHEAKPC.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-U2ML5ZON.js

@@ -0,0 +1,24 @@
+import {
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-VMGX5FCY.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-RZFCVYTK.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-VVOGYSM7.js

@@ -0,0 +1,24 @@
+import {
+  optionalOption
+} from "./chunk-US6CEDMU.js";
+import {
+  getEngine
+} from "./chunk-47SU2YUJ.js";
+import {
+  output
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-WYHEAKPC.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/duplicates-CEJ7WSGW.js

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