@memrosetta/sync-client 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -19,6 +19,37 @@ declare class Inbox {
     markApplied(opIds: readonly string[]): void;
 }
 
+/**
+ * Applies pulled sync ops to the local SQLite `memories` + `memory_relations`
+ * tables.
+ *
+ * Intentionally separate from `SyncClient` / `Inbox` so the transport layer
+ * stays ignorant of the engine schema. Anything that pulls ops from an inbox
+ * can call `applyInboxOps(db, ops)` to fold them into the local memory graph.
+ *
+ * All writes are idempotent:
+ *   - `memory_created`  INSERT OR IGNORE on `memory_id`
+ *   - `relation_created` INSERT OR IGNORE on the (src, dst, type) PK
+ *   - `memory_invalidated` UPDATE of `invalidated_at`
+ *   - `feedback_given`  additive UPDATE of `use_count` / `success_count`
+ *                      plus the same salience recompute rule used by core
+ *   - `memory_tier_set` UPDATE of `tier`
+ */
+interface ApplyResult {
+    readonly applied: readonly string[];
+    readonly skipped: readonly {
+        readonly opId: string;
+        readonly reason: string;
+    }[];
+}
+/**
+ * Apply a batch of pulled ops into the local memories/relations tables.
+ *
+ * The caller is responsible for passing only ops that have not been applied
+ * yet. `Inbox.getPending()` returns exactly that set.
+ */
+declare function applyInboxOps(db: Database.Database, ops: readonly SyncPulledOp[]): ApplyResult;
+
 /**
  * Minimal config required by SyncClient at runtime.
  * serverUrl and apiKey are required (unlike the optional SyncConfig
@@ -61,6 +92,8 @@ declare class SyncClient {
     getStatus(): SyncClientStatus;
     push(): Promise<SyncClientPushResponse>;
     pull(): Promise<number>;
+    /** For tests / advanced callers: apply currently-pending inbox ops manually. */
+    applyPendingInbox(): ApplyResult;
     getState(key: string): string | null;
     setState(key: string, value: string): void;
     private getCursor;
@@ -69,4 +102,4 @@ declare class SyncClient {
 
 declare function ensureSyncSchema(db: Database.Database): void;
 
-export { Inbox, Outbox, SyncClient, type SyncClientConfig, type SyncClientPushResponse, type SyncClientStatus, type SyncStatusTimestamps, ensureSyncSchema };
+export { type ApplyResult, Inbox, Outbox, SyncClient, type SyncClientConfig, type SyncClientPushResponse, type SyncClientStatus, type SyncStatusTimestamps, applyInboxOps, ensureSyncSchema };

package/dist/index.js

@@ -48,7 +48,7 @@ var Outbox = class {
   addOp(op) {
     const payloadStr = typeof op.payload === "string" ? op.payload : JSON.stringify(op.payload);
     this.db.prepare(
-      `INSERT INTO sync_outbox (op_id, op_type, device_id, user_id, payload, created_at, pushed_at)
+      `INSERT OR IGNORE INTO sync_outbox (op_id, op_type, device_id, user_id, payload, created_at, pushed_at)
          VALUES (?, ?, ?, ?, ?, ?, ?)`
     ).run(op.opId, op.opType, op.deviceId, op.userId, payloadStr, op.createdAt, null);
   }
@@ -112,6 +112,140 @@ var Inbox = class {
   }
 };
 
+// src/applier.ts
+function parsePayload(payload) {
+  if (typeof payload === "string") {
+    return JSON.parse(payload);
+  }
+  return payload;
+}
+function serializeKeywords(keywords) {
+  if (!keywords || keywords.length === 0) return null;
+  return keywords.join(" ");
+}
+function applyMemoryCreated(db, op) {
+  const p = parsePayload(op.payload);
+  const stmt = db.prepare(
+    `INSERT OR IGNORE INTO memories (
+       memory_id, user_id, namespace, memory_type, content, raw_text,
+       document_date, learned_at, source_id, confidence, salience,
+       is_latest, keywords, event_date_start, event_date_end,
+       invalidated_at, tier, activation_score, access_count,
+       use_count, success_count
+     ) VALUES (
+       @memory_id, @user_id, @namespace, @memory_type, @content, @raw_text,
+       @document_date, @learned_at, @source_id, @confidence, @salience,
+       1, @keywords, @event_date_start, @event_date_end,
+       @invalidated_at, 'warm', 1.0, 0,
+       0, 0
+     )`
+  );
+  stmt.run({
+    memory_id: p.memoryId,
+    user_id: p.userId,
+    namespace: p.namespace ?? null,
+    memory_type: p.memoryType,
+    content: p.content,
+    raw_text: p.rawText ?? null,
+    document_date: p.documentDate ?? null,
+    learned_at: p.learnedAt,
+    source_id: p.sourceId ?? null,
+    confidence: p.confidence ?? 1,
+    salience: p.salience ?? 1,
+    keywords: serializeKeywords(p.keywords),
+    event_date_start: p.eventDateStart ?? null,
+    event_date_end: p.eventDateEnd ?? null,
+    invalidated_at: p.invalidatedAt ?? null
+  });
+}
+function applyRelationCreated(db, op) {
+  const p = parsePayload(op.payload);
+  db.prepare(
+    `INSERT OR IGNORE INTO memory_relations (
+       src_memory_id, dst_memory_id, relation_type, created_at, reason
+     ) VALUES (?, ?, ?, ?, ?)`
+  ).run(p.srcMemoryId, p.dstMemoryId, p.relationType, p.createdAt, p.reason ?? null);
+  if (p.relationType === "updates") {
+    db.prepare("UPDATE memories SET is_latest = 0 WHERE memory_id = ?").run(
+      p.dstMemoryId
+    );
+  }
+}
+function applyMemoryInvalidated(db, op) {
+  const p = parsePayload(op.payload);
+  db.prepare(
+    "UPDATE memories SET invalidated_at = ? WHERE memory_id = ?"
+  ).run(p.invalidatedAt, p.memoryId);
+}
+function applyFeedbackGiven(db, op) {
+  const p = parsePayload(op.payload);
+  if (p.helpful) {
+    db.prepare(
+      "UPDATE memories SET use_count = use_count + 1, success_count = success_count + 1 WHERE memory_id = ?"
+    ).run(p.memoryId);
+  } else {
+    db.prepare(
+      "UPDATE memories SET use_count = use_count + 1 WHERE memory_id = ?"
+    ).run(p.memoryId);
+  }
+  const row = db.prepare(
+    "SELECT use_count, success_count FROM memories WHERE memory_id = ?"
+  ).get(p.memoryId);
+  if (row && row.use_count > 0) {
+    const successRate = row.success_count / row.use_count;
+    const newSalience = Math.min(1, Math.max(0.1, 0.5 + 0.5 * successRate));
+    db.prepare("UPDATE memories SET salience = ? WHERE memory_id = ?").run(
+      newSalience,
+      p.memoryId
+    );
+  }
+}
+function applyMemoryTierSet(db, op) {
+  const p = parsePayload(op.payload);
+  db.prepare("UPDATE memories SET tier = ? WHERE memory_id = ?").run(
+    p.tier,
+    p.memoryId
+  );
+}
+function applyInboxOps(db, ops) {
+  const applied = [];
+  const skipped = [];
+  const runAll = db.transaction((batch) => {
+    for (const op of batch) {
+      try {
+        switch (op.opType) {
+          case "memory_created":
+            applyMemoryCreated(db, op);
+            break;
+          case "relation_created":
+            applyRelationCreated(db, op);
+            break;
+          case "memory_invalidated":
+            applyMemoryInvalidated(db, op);
+            break;
+          case "feedback_given":
+            applyFeedbackGiven(db, op);
+            break;
+          case "memory_tier_set":
+            applyMemoryTierSet(db, op);
+            break;
+          default:
+            skipped.push({ opId: op.opId, reason: `unknown op type: ${op.opType}` });
+            continue;
+        }
+        applied.push(op.opId);
+      } catch (err) {
+        skipped.push({
+          opId: op.opId,
+          reason: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  });
+  runAll(ops);
+  return { applied, skipped };
+}
+
 // src/sync-client.ts
 var SyncClient = class {
   db;
@@ -210,14 +344,45 @@ var SyncClient = class {
       throw new Error(`Pull failed: ${response.status} ${response.statusText}`);
     }
     const body = await response.json();
-    const { ops, nextCursor, hasMore } = body.data;
+    const { ops, nextCursor } = body.data;
     if (ops.length > 0) {
       this.inbox.addOps(ops);
     }
+    const pending = this.inbox.getPending();
+    let skippedCount = 0;
+    if (pending.length > 0) {
+      const result = applyInboxOps(this.db, pending);
+      if (result.applied.length > 0) {
+        this.inbox.markApplied(result.applied);
+      }
+      skippedCount = result.skipped.length;
+      if (skippedCount > 0) {
+        for (const s of result.skipped) {
+          process.stderr.write(
+            `[sync] apply skipped op ${s.opId}: ${s.reason}
+`
+          );
+        }
+      }
+    }
     this.setCursor(nextCursor);
-    this.setState("last_pull_success_at", (/* @__PURE__ */ new Date()).toISOString());
+    if (skippedCount === 0) {
+      this.setState("last_pull_success_at", (/* @__PURE__ */ new Date()).toISOString());
+    }
     return ops.length;
   }
+  /** For tests / advanced callers: apply currently-pending inbox ops manually. */
+  applyPendingInbox() {
+    const pending = this.inbox.getPending();
+    if (pending.length === 0) {
+      return { applied: [], skipped: [] };
+    }
+    const result = applyInboxOps(this.db, pending);
+    if (result.applied.length > 0) {
+      this.inbox.markApplied(result.applied);
+    }
+    return result;
+  }
   getState(key) {
     const row = this.db.prepare("SELECT value FROM sync_state WHERE key = ?").get(key);
     return row?.value ?? null;
@@ -239,5 +404,6 @@ export {
   Inbox,
   Outbox,
   SyncClient,
+  applyInboxOps,
   ensureSyncSchema
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memrosetta/sync-client",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Local-first sync client for MemRosetta (outbox/inbox, push/pull)",
   "type": "module",
   "main": "./dist/index.js",