midsummer-sol 0.1.2 → 0.1.3

package/index.js

@@ -1359,6 +1359,182 @@ function localTarget(r) {
     }
   };
 }
+// src/converge.ts
+var EMPTY_TREE2 = { kind: "tree", entries: {} };
+function buildAncestry(ops) {
+  const parents = new Map;
+  const add = (child, parent) => {
+    if (!child || !parent || parent === child)
+      return;
+    let s = parents.get(child);
+    if (!s)
+      parents.set(child, s = new Set);
+    s.add(parent);
+  };
+  let prevRoot;
+  for (const op of ops) {
+    if (op.type === "checkpoint") {
+      add(op.rootAfter, op.parent);
+      add(op.rootAfter, op.parent2);
+    } else {
+      add(op.rootAfter, op.parent ?? prevRoot);
+    }
+    prevRoot = op.rootAfter;
+  }
+  return parents;
+}
+function ancestorsOf(head, parents) {
+  const seen = new Set;
+  const stack = [head];
+  while (stack.length) {
+    const h = stack.pop();
+    if (seen.has(h))
+      continue;
+    seen.add(h);
+    for (const p of parents.get(h) ?? [])
+      stack.push(p);
+  }
+  return seen;
+}
+function mergeBase(a, b, parents) {
+  if (a === b)
+    return a;
+  const bAnc = ancestorsOf(b, parents);
+  const seen = new Set;
+  let frontier = [a];
+  while (frontier.length) {
+    const next = [];
+    for (const h of frontier) {
+      if (seen.has(h))
+        continue;
+      seen.add(h);
+      if (bAnc.has(h))
+        return h;
+      for (const p of parents.get(h) ?? [])
+        next.push(p);
+    }
+    frontier = next;
+  }
+  return;
+}
+async function hydrate(src, dst, root) {
+  if (!root)
+    return dst.put(EMPTY_TREE2);
+  const stack = [root];
+  const seen = new Set;
+  while (stack.length) {
+    const h = stack.pop();
+    if (seen.has(h))
+      continue;
+    seen.add(h);
+    const node = await src.get(h);
+    if (!node)
+      continue;
+    dst.put(node);
+    if (node.kind === "tree")
+      for (const e of Object.values(node.entries))
+        stack.push(e.hash);
+  }
+  return root;
+}
+async function persist(sync, dst, root) {
+  const stack = [root];
+  const seen = new Set;
+  while (stack.length) {
+    const h = stack.pop();
+    if (seen.has(h))
+      continue;
+    seen.add(h);
+    const node = sync.get(h);
+    if (!node)
+      continue;
+    if (!await dst.has(h))
+      await dst.put(node);
+    if (node.kind === "tree")
+      for (const e of Object.values(node.entries))
+        stack.push(e.hash);
+  }
+}
+async function converge(local, input) {
+  const at = input.at ?? Date.now();
+  const actor = input.actor ?? "system";
+  for (const node of input.nodes)
+    await local.store.put(node);
+  const priorHead = await local.log.head();
+  const incomingHead = input.incomingHead ?? input.ops[input.ops.length - 1]?.rootAfter;
+  const sinceSeq = await local.log.seq();
+  const existing = await local.log.history();
+  const priorAncestry = buildAncestry(existing);
+  const knownByEntry = new Map(existing.filter((o) => o.entryHash).map((o) => [o.entryHash, o]));
+  const knownByTuple = new Map(existing.map((o) => [`${o.type}\x00${o.path}\x00${o.rootAfter}`, o]));
+  const incoming = [...input.ops].sort((a, b) => a.seq - b.seq);
+  let forkBase = input.base ?? priorHead;
+  if (input.base === undefined) {
+    for (const op of incoming) {
+      const k = op.entryHash ? knownByEntry.get(op.entryHash) : knownByTuple.get(`${op.type}\x00${op.path}\x00${op.rootAfter}`);
+      if (k)
+        forkBase = k.rootAfter;
+    }
+  }
+  let applied = 0;
+  for (const op of incoming) {
+    if (op.entryHash && knownByEntry.has(op.entryHash))
+      continue;
+    if (!op.entryHash && knownByTuple.has(`${op.type}\x00${op.path}\x00${op.rootAfter}`))
+      continue;
+    const stamped = applied === 0 && op.type !== "checkpoint" && op.parent === undefined ? { ...op, parent: forkBase } : { ...op };
+    await local.log.append({ ...stamped, seq: await local.log.seq() + 1 });
+    applied++;
+  }
+  let head = await local.log.head() ?? priorHead ?? await local.store.put(EMPTY_TREE2);
+  let merged = false;
+  let conflicts = [];
+  if (priorHead && incomingHead && priorHead !== incomingHead) {
+    const parents = buildAncestry(await local.log.history());
+    for (const [c, ps] of priorAncestry) {
+      let s = parents.get(c);
+      if (!s)
+        parents.set(c, s = new Set);
+      for (const p of ps)
+        s.add(p);
+    }
+    const priorIsAncestor = ancestorsOf(incomingHead, parents).has(priorHead);
+    const incomingIsAncestor = ancestorsOf(priorHead, parents).has(incomingHead);
+    if (incomingIsAncestor) {
+      if (await local.log.head() !== priorHead)
+        await appendHeadMove(local, priorHead, priorHead, incomingHead, actor, at, "converge: keep ahead-of-incoming head");
+      head = priorHead;
+    } else if (!priorIsAncestor) {
+      const base = input.base ?? mergeBase(priorHead, incomingHead, parents);
+      const sync = new Store;
+      const baseRoot = await hydrate(local.store, sync, base);
+      const oursRoot = await hydrate(local.store, sync, priorHead);
+      const theirsRoot = await hydrate(local.store, sync, incomingHead);
+      const result = merge({ store: sync }, baseRoot, oursRoot, theirsRoot);
+      conflicts = result.conflicts;
+      await persist(sync, local.store, result.head);
+      await local.log.append({
+        seq: await local.log.seq() + 1,
+        type: "checkpoint",
+        path: "",
+        rootAfter: result.head,
+        at,
+        by: actor,
+        message: conflicts.length ? `converge merge (${conflicts.length} conflict(s) kept with markers)` : "converge merge",
+        parent: priorHead,
+        parent2: incomingHead
+      });
+      head = result.head;
+      merged = true;
+    }
+  }
+  const finalOps = await local.log.history();
+  const missingOps = finalOps.filter((o) => o.seq > sinceSeq);
+  return { head, applied, merged, conflicts, missingOps };
+}
+async function appendHeadMove(local, head, parent, parent2, by, at, message) {
+  await local.log.append({ seq: await local.log.seq() + 1, type: "checkpoint", path: "", rootAfter: head, at, by, message, parent, parent2 });
+}
 // src/diff.ts
 function diffTrees(store, aHead, bHead) {
   const aPaths = new Set(listAll(store, aHead));
@@ -2004,6 +2180,7 @@ export {
   diffTrees,
   diffFile,
   deleteFile,
+  converge,
   compact,
   clone,
   ciphertextOf,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midsummer-sol",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Sol — agent-native version control (a new git). CLI, MCP server, and no-filesystem SDK.",
   "bin": {
     "sol": "./sol.js",