@memrosetta/cli 0.5.1 → 0.5.3

package/dist/chunk-GZINXXM4.js

@@ -0,0 +1,139 @@
+import {
+  getConfig,
+  resolveCanonicalUserId
+} from "./chunk-RZFCVYTK.js";
+
+// src/sync/cli-sync.ts
+import { createHash, randomUUID } from "crypto";
+function deterministicOpId(kind, key) {
+  const hash = createHash("sha256").update(`${kind}:${key}`).digest("hex");
+  return `op-${hash.slice(0, 16)}`;
+}
+var DISABLED = {
+  enabled: false,
+  userId: "",
+  deviceId: "",
+  enqueue() {
+  },
+  close() {
+  }
+};
+async function openCliSyncContext(dbPath) {
+  const config = getConfig();
+  if (!config.syncEnabled || !config.syncServerUrl || !config.syncApiKey || !config.syncDeviceId) {
+    return DISABLED;
+  }
+  const userId = resolveCanonicalUserId();
+  const deviceId = config.syncDeviceId;
+  try {
+    const { default: Database } = await import("better-sqlite3");
+    const { SyncClient, ensureSyncSchema } = await import("@memrosetta/sync-client");
+    const db = new Database(dbPath);
+    ensureSyncSchema(db);
+    const client = new SyncClient(db, {
+      serverUrl: config.syncServerUrl,
+      apiKey: config.syncApiKey,
+      deviceId,
+      userId
+    });
+    const outbox = client.getOutbox();
+    return {
+      enabled: true,
+      userId,
+      deviceId,
+      enqueue(op) {
+        try {
+          outbox.addOp(op);
+        } catch (err) {
+          process.stderr.write(
+            `[sync] enqueue failed: ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        }
+      },
+      close() {
+        try {
+          db.close();
+        } catch {
+        }
+      }
+    };
+  } catch (err) {
+    process.stderr.write(
+      `[sync] disabled for this command: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return DISABLED;
+  }
+}
+function buildMemoryCreatedOp(ctx, memory) {
+  return {
+    opId: randomUUID(),
+    opType: "memory_created",
+    deviceId: ctx.deviceId,
+    userId: ctx.userId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    payload: {
+      memoryId: memory.memoryId,
+      userId: memory.userId,
+      namespace: memory.namespace,
+      memoryType: memory.memoryType,
+      content: memory.content,
+      rawText: memory.rawText,
+      documentDate: memory.documentDate,
+      sourceId: memory.sourceId,
+      confidence: memory.confidence,
+      salience: memory.salience,
+      keywords: memory.keywords,
+      eventDateStart: memory.eventDateStart,
+      eventDateEnd: memory.eventDateEnd,
+      invalidatedAt: memory.invalidatedAt,
+      learnedAt: memory.learnedAt
+    }
+  };
+}
+function buildRelationCreatedOp(ctx, relation) {
+  return {
+    opId: randomUUID(),
+    opType: "relation_created",
+    deviceId: ctx.deviceId,
+    userId: ctx.userId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    payload: {
+      srcMemoryId: relation.srcMemoryId,
+      dstMemoryId: relation.dstMemoryId,
+      relationType: relation.relationType,
+      reason: relation.reason,
+      createdAt: relation.createdAt
+    }
+  };
+}
+function buildMemoryInvalidatedOp(ctx, memoryId, invalidatedAt, reason) {
+  return {
+    opId: randomUUID(),
+    opType: "memory_invalidated",
+    deviceId: ctx.deviceId,
+    userId: ctx.userId,
+    createdAt: invalidatedAt,
+    payload: { memoryId, invalidatedAt, reason }
+  };
+}
+function buildFeedbackGivenOp(ctx, memoryId, helpful, recordedAt) {
+  return {
+    opId: randomUUID(),
+    opType: "feedback_given",
+    deviceId: ctx.deviceId,
+    userId: ctx.userId,
+    createdAt: recordedAt,
+    payload: { memoryId, helpful, recordedAt }
+  };
+}
+
+export {
+  deterministicOpId,
+  openCliSyncContext,
+  buildMemoryCreatedOp,
+  buildRelationCreatedOp,
+  buildMemoryInvalidatedOp,
+  buildFeedbackGivenOp
+};

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
+};