@memrosetta/cli 0.4.7 → 0.5.0

package/dist/chunk-2MO65JLK.js

@@ -0,0 +1,139 @@
+import {
+  getConfig
+} from "./chunk-SEPYQK3J.js";
+
+// src/sync/cli-sync.ts
+import { createHash, randomUUID } from "crypto";
+import { userInfo } from "os";
+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 = 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 {
+  deterministicOpId,
+  openCliSyncContext,
+  buildMemoryCreatedOp,
+  buildRelationCreatedOp,
+  buildMemoryInvalidatedOp,
+  buildFeedbackGivenOp
+};