@lmzhen/dsh-evolution-merge 0.29.0 → 0.30.1

package/lib/types/state.js

@@ -0,0 +1,103 @@
+/**
+ * The one merge-state ledger: <home>/merge/merge-state.json.
+ *
+ * Reads are pure projections (no write, no reconciliation side effect). Every write goes
+ * through mutateMergeState and a single transactIo, so there is no second file and no
+ * incremental writer. A row's queue is always derived from its state on read; a hand-edited
+ * mismatch is repaired by the next write, never by a GET.
+ */
+import { join } from 'node:path';
+import { transactIo } from '@lmzhen/dsh-evolution-core';
+import { MERGE_STATE_VERSION, queueOf, } from "./contracts.js";
+import { parseLedger } from "./domain/ledger.js";
+export function mergeStatePath(home) {
+    return join(home, 'merge', 'merge-state.json');
+}
+function parseState(raw) {
+    const parsed = parseLedger(raw);
+    if (!parsed.ok)
+        return { ok: false, rows: [] };
+    return {
+        ok: true,
+        rows: parsed.ledger.rows,
+        ...(parsed.note === undefined ? {} : { note: parsed.note }),
+    };
+}
+/** Pure read: never writes, never deletes a row. */
+export async function loadMergeState(io, home) {
+    let raw = null;
+    try {
+        raw = await io.readText(mergeStatePath(home));
+    }
+    catch {
+        return { ok: false, state: { schemaVersion: MERGE_STATE_VERSION, rows: [] } };
+    }
+    const parsed = parseState(raw);
+    return {
+        ok: parsed.ok,
+        state: { schemaVersion: MERGE_STATE_VERSION, rows: parsed.rows },
+        ...(parsed.note === undefined ? {} : { note: parsed.note }),
+    };
+}
+/** The ONE write point. The callback returns the whole row set, not a delta. */
+export async function mutateMergeState(io, home, now, fn) {
+    let result;
+    let ran = false;
+    await transactIo(io, mergeStatePath(home), (current) => {
+        ran = true;
+        const parsed = parseState(current);
+        const out = fn(parsed.rows);
+        result = out.result;
+        return JSON.stringify({ schemaVersion: MERGE_STATE_VERSION, rows: out.rows }, null, 2);
+    });
+    // transactIo only returns after fn ran; a skipped write is not a state outcome.
+    void ran;
+    void now;
+    return result;
+}
+export async function upsertRow(io, home, now, row) {
+    await mutateMergeState(io, home, now, (rows) => {
+        const index = rows.findIndex(item => item.pairKey === row.pairKey);
+        const normalized = { ...row, queue: queueOf(row.state) };
+        const next = [...rows];
+        if (index < 0)
+            next.push(normalized);
+        else
+            next[index] = { ...normalized, createdAt: rows[index]?.createdAt ?? normalized.createdAt };
+        return { rows: next, result: undefined };
+    });
+}
+export async function moveRow(io, home, now, id, patch) {
+    return await mutateMergeState(io, home, now, (rows) => {
+        const index = rows.findIndex(item => item.id === id);
+        if (index < 0)
+            return { rows, result: undefined };
+        const current = rows[index];
+        const state = patch.state ?? current.state;
+        const next = {
+            ...current,
+            state,
+            queue: queueOf(state),
+            updatedAt: new Date(now()).toISOString(),
+            ...(patch.failure === undefined ? {} : { failure: patch.failure }),
+            ...(patch.runId === undefined ? {} : { runId: patch.runId }),
+            ...(patch.unitId === undefined ? {} : { unitId: patch.unitId }),
+            ...(patch.origin === undefined ? {} : { origin: patch.origin }),
+            ...(patch.attempts === undefined ? {} : { attempts: patch.attempts }),
+        };
+        const copy = [...rows];
+        copy[index] = next;
+        return { rows: copy, result: next };
+    });
+}
+export async function dropRow(io, home, now, id) {
+    return await mutateMergeState(io, home, now, (rows) => {
+        const next = rows.filter(item => item.id !== id);
+        return { rows: next, result: next.length !== rows.length };
+    });
+}
+export async function rowsOf(io, home, queue) {
+    const loaded = await loadMergeState(io, home);
+    return queue === undefined ? loaded.state.rows : loaded.state.rows.filter(row => row.queue === queue);
+}
+//# sourceMappingURL=state.js.map

package/lib/types/status.d.ts

@@ -4,8 +4,9 @@
  */
 import type { MergeQueue, MergeRow } from './contracts.ts';
 export interface MergeCounts {
+    readonly verify: number;
     readonly pending: number;
-    readonly retry: number;
+    readonly fuse: number;
     readonly skipped: number;
 }
 export declare function countRows(rows: readonly MergeRow[]): MergeCounts;

package/lib/types/status.js

@@ -0,0 +1,28 @@
+import { queueOf, stageOf } from "./contracts.js";
+export function countRows(rows) {
+    const counts = { verify: 0, pending: 0, fuse: 0, skipped: 0 };
+    for (const row of rows)
+        counts[queueOf(row.state)] += 1;
+    return counts;
+}
+function describe(row) {
+    const stage = stageOf(row.state);
+    const target = row.decision?.shouldMerge === true ? ' → ' + row.decision.target : '';
+    return row.a + ' + ' + row.b + ' [' + row.state + (stage === null ? '' : '/' + stage) + ']' + target + (row.failure === undefined ? '' : ' — ' + row.failure.message);
+}
+export function formatStatus(rows) {
+    const counts = countRows(rows);
+    const lines = [
+        'merge: verify ' + String(counts.verify) + ', pending ' + String(counts.pending) + ', fuse ' + String(counts.fuse) + ', skipped ' + String(counts.skipped),
+    ];
+    for (const row of rows)
+        lines.push('- ' + describe(row));
+    return lines.join('\n');
+}
+export function formatQueue(rows, queue) {
+    const selected = rows.filter(row => queueOf(row.state) === queue);
+    if (selected.length === 0)
+        return 'merge ' + queue + ': empty';
+    return ['merge ' + queue + ': ' + String(selected.length)].concat(selected.map(row => '- ' + describe(row))).join('\n');
+}
+//# sourceMappingURL=status.js.map

package/lib/types/supersede.js

@@ -0,0 +1,14 @@
+export function mergeRunIdsToSupersede(runs) {
+    return runs.filter(run => run.kind === 'merge' && run.supersededAt === undefined).map(run => run.id);
+}
+export async function supersedeMergeRuns(registry) {
+    const shared = registry.supersedeKind;
+    if (typeof shared === 'function')
+        return await shared.call(registry, 'merge');
+    const ids = mergeRunIdsToSupersede(registry.runs());
+    if (ids.length === 0)
+        return 0;
+    await registry.supersede(ids);
+    return ids.length;
+}
+//# sourceMappingURL=supersede.js.map

package/lib/types/undo-merge.js

@@ -0,0 +1,23 @@
+import { executeUnitUndo, planUnitUndoAcross } from '@lmzhen/dsh-evolution-core';
+export async function undoMergeReceipt(receipt, port) {
+    const targetVersions = (await port.listVersions(receipt.target)).filter(entry => entry.unitId === receipt.unitId);
+    if (targetVersions.length === 0) {
+        return { ok: false, message: 'unit ' + receipt.unitId + ' is not in the target history; refusing to guess', reverted: [] };
+    }
+    const members = [{ skill: receipt.target, entries: targetVersions, status: 'live', ...(receipt.create ? { createdInUnit: true } : {}) }];
+    for (const source of receipt.sources) {
+        const live = await port.readSkill(source);
+        members.push({
+            skill: source,
+            entries: (await port.listVersions(source)).filter(entry => entry.unitId === receipt.unitId),
+            status: live === null ? 'archived' : 'live',
+            ...(live === null ? { archivedPath: 'archive' } : {}),
+        });
+    }
+    const plan = planUnitUndoAcross(members);
+    if (plan.refusals.length > 0) {
+        return { ok: false, message: 'merge undo preflight refused: ' + plan.refusals.join('; '), reverted: [] };
+    }
+    return await executeUnitUndo(plan, port);
+}
+//# sourceMappingURL=undo-merge.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-merge",
   "description": "Skill auto-merge domain: screening, two-round authoring, queues and commit orchestration (community build)",
-  "version": "0.29.0",
+  "version": "0.30.1",
   "publishConfig": {
     "access": "public"
   },
@@ -21,14 +21,14 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "lib/*.js",
+    "lib/**/*.js",
     "lib/types/**/*.d.ts"
   ],
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.5",
-    "@lmzhen/dsh-evolution-core": "^0.29.0",
-    "@lmzhen/dsh-evolution-merge-engine": "^0.29.0"
+    "@lmzhen/dsh-evolution-core": "^0.30.1",
+    "@lmzhen/dsh-evolution-merge-engine": "^0.30.1"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.5"