@memrosetta/cli 0.4.6 → 0.4.7

package/dist/chunk-KPASMEV7.js

@@ -0,0 +1,134 @@
+import {
+  getConfig
+} from "./chunk-SEPYQK3J.js";
+
+// src/sync/cli-sync.ts
+import { randomUUID } from "crypto";
+import { userInfo } from "os";
+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 = config.syncUserId ?? userInfo().username;
+  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 {
+  openCliSyncContext,
+  buildMemoryCreatedOp,
+  buildRelationCreatedOp,
+  buildMemoryInvalidatedOp,
+  buildFeedbackGivenOp
+};

package/dist/chunk-VAVUPQZA.js

@@ -0,0 +1,64 @@
+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;
+}
+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/clear-XVW4R7ZD.js

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

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

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

@@ -0,0 +1,51 @@
+import {
+  buildFeedbackGivenOp,
+  openCliSyncContext
+} from "./chunk-KPASMEV7.js";
+import {
+  hasFlag
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine,
+  resolveDbPath
+} from "./chunk-VAVUPQZA.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 });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await engine.feedback(memoryId, helpful);
+  const sync = await openCliSyncContext(resolveDbPath(db));
+  if (sync.enabled) {
+    sync.enqueue(buildFeedbackGivenOp(sync, memoryId, helpful, now));
+    sync.close();
+  }
+  output({ memoryId, helpful }, format);
+}
+export {
+  run
+};

package/dist/get-Q77SEO5A.js

@@ -0,0 +1,30 @@
+import {
+  getEngine
+} from "./chunk-VAVUPQZA.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/index.js

@@ -4,7 +4,7 @@ import {
 } from "./chunk-NU5ZJJXP.js";
 import {
   closeEngine
-} from "./chunk-72IW6TAV.js";
+} from "./chunk-VAVUPQZA.js";
 import {
   outputError
 } from "./chunk-ET6TNQOJ.js";
@@ -71,6 +71,9 @@ Sync Subcommands:
   memrosetta sync status                   # Show sync state + pending ops
   memrosetta sync now [--push-only | --pull-only]
   memrosetta sync device-id                # Print current device id
+  memrosetta sync backfill [--user <id>] [--namespace <ns>] [--memories-only] [--dry-run]
+                                           # Enqueue existing local memories
+                                           # + relations into the outbox.
 
 Examples:
   memrosetta init                          # DB + MCP server
@@ -113,72 +116,72 @@ async function main() {
   try {
     switch (command) {
       case "store": {
-        const mod = await import("./store-2USP33HQ.js");
+        const mod = await import("./store-UL35UYIV.js");
         await mod.run(commandOptions);
         break;
       }
       case "search": {
-        const mod = await import("./search-PT4POELX.js");
+        const mod = await import("./search-TVOCWXRB.js");
         await mod.run(commandOptions);
         break;
       }
       case "ingest": {
-        const mod = await import("./ingest-GSJMWDV5.js");
+        const mod = await import("./ingest-PQFTEAFQ.js");
         await mod.run(commandOptions);
         break;
       }
       case "get": {
-        const mod = await import("./get-NY5H3MUA.js");
+        const mod = await import("./get-Q77SEO5A.js");
         await mod.run(commandOptions);
         break;
       }
       case "count": {
-        const mod = await import("./count-AMSEVDWR.js");
+        const mod = await import("./count-KSE5XYCT.js");
         await mod.run(commandOptions);
         break;
       }
       case "clear": {
-        const mod = await import("./clear-5SZVGYBX.js");
+        const mod = await import("./clear-XVW4R7ZD.js");
         await mod.run(commandOptions);
         break;
       }
       case "relate": {
-        const mod = await import("./relate-SGZLG7JU.js");
+        const mod = await import("./relate-BQVTTMLF.js");
         await mod.run(commandOptions);
         break;
       }
       case "invalidate": {
-        const mod = await import("./invalidate-BY5VNFSE.js");
+        const mod = await import("./invalidate-WXFGQHOK.js");
         await mod.run(commandOptions);
         break;
       }
       case "feedback": {
-        const mod = await import("./feedback-XGBKFQXC.js");
+        const mod = await import("./feedback-Z7YIFV6D.js");
         await mod.run(commandOptions);
         break;
       }
       case "working-memory": {
-        const mod = await import("./working-memory-UYVEJJYW.js");
+        const mod = await import("./working-memory-LJ2XMUE2.js");
         await mod.run(commandOptions);
         break;
       }
       case "maintain": {
-        const mod = await import("./maintain-SGM56XKE.js");
+        const mod = await import("./maintain-5QUJACCJ.js");
         await mod.run(commandOptions);
         break;
       }
       case "compress": {
-        const mod = await import("./compress-YNY6YNFU.js");
+        const mod = await import("./compress-LYRY4WUY.js");
         await mod.run(commandOptions);
         break;
       }
       case "status": {
-        const mod = await import("./status-HLKL32NP.js");
+        const mod = await import("./status-RSXRXD7C.js");
         await mod.run(commandOptions);
         break;
       }
       case "init": {
-        const mod = await import("./init-GRVRJ6RO.js");
+        const mod = await import("./init-US5IURGE.js");
         await mod.run(commandOptions);
         break;
       }
@@ -193,7 +196,7 @@ async function main() {
         break;
       }
       case "sync": {
-        const mod = await import("./sync-JSEQ4AM3.js");
+        const mod = await import("./sync-QJQYXJIV.js");
         await mod.run(commandOptions);
         break;
       }

package/dist/ingest-PQFTEAFQ.js

@@ -0,0 +1,95 @@
+import {
+  classifyTurn,
+  parseTranscriptContent
+} from "./chunk-KR63XYFW.js";
+import {
+  optionalOption
+} from "./chunk-NU5ZJJXP.js";
+import {
+  getEngine
+} from "./chunk-VAVUPQZA.js";
+import {
+  output,
+  outputError
+} from "./chunk-ET6TNQOJ.js";
+import {
+  getDefaultUserId
+} from "./chunk-SEPYQK3J.js";
+
+// src/commands/ingest.ts
+import { readFileSync } from "fs";
+function turnsToMemories(turns, userId, namespace, sessionShort) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const memories = [];
+  for (let i = 0; i < turns.length; i++) {
+    const turn = turns[i];
+    if (turn.content.length < 20) continue;
+    const content = turn.content.length > 500 ? turn.content.slice(0, 497) + "..." : turn.content;
+    memories.push({
+      userId,
+      namespace: namespace ?? `session-${sessionShort}`,
+      memoryType: classifyTurn(turn),
+      content,
+      documentDate: now,
+      sourceId: `cc-${sessionShort}-${i}`,
+      confidence: turn.role === "user" ? 0.9 : 0.8
+    });
+  }
+  return memories;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8").trim();
+}
+async function run(options) {
+  const { args, format, db, noEmbeddings } = options;
+  const userId = optionalOption(args, "--user") ?? getDefaultUserId();
+  const file = optionalOption(args, "--file");
+  const namespace = optionalOption(args, "--namespace");
+  let content;
+  if (file) {
+    try {
+      content = readFileSync(file, "utf-8");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      outputError(`Failed to read file: ${msg}`, format);
+      process.exitCode = 1;
+      return;
+    }
+  } else {
+    content = await readStdin();
+  }
+  if (!content) {
+    outputError("No transcript content provided", format);
+    process.exitCode = 1;
+    return;
+  }
+  const parsed = parseTranscriptContent(content);
+  const sessionShort = parsed.sessionId ? parsed.sessionId.slice(0, 8) : "unknown";
+  const memories = turnsToMemories(
+    parsed.turns,
+    userId,
+    namespace,
+    sessionShort
+  );
+  if (memories.length === 0) {
+    output({ stored: 0, message: "No memories extracted from transcript" }, format);
+    return;
+  }
+  const engine = await getEngine({ db, noEmbeddings });
+  const stored = await engine.storeBatch(memories);
+  output(
+    {
+      stored: stored.length,
+      sessionId: parsed.sessionId || void 0,
+      namespace: namespace ?? `session-${sessionShort}`
+    },
+    format
+  );
+}
+export {
+  run
+};