@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-XUC7PI2H.js

@@ -0,0 +1,243 @@
+import {
+  hashDocument,
+  toItemRecord
+} from "./chunk-5VAA4YHR.js";
+import {
+  canonicalDocument
+} from "./chunk-NMP5I3I5.js";
+import {
+  orderObject,
+  sha256Hex,
+  stableStringify
+} from "./chunk-SHQY2IDC.js";
+import {
+  FRONT_MATTER_KEY_ORDER
+} from "./chunk-LK6XLOGP.js";
+
+// dist/core/history/replay.js
+import jsonPatch from "fast-json-patch";
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "cf6461d3-7d73-5aa9-afa3-65f14d708e4c");
+  } catch (e2) {
+  }
+})();
+var EMPTY_REPLAY_DOCUMENT = {
+  metadata: {},
+  body: ""
+};
+function cloneEmptyReplayDocument() {
+  return structuredClone(EMPTY_REPLAY_DOCUMENT);
+}
+function replayHash(document) {
+  try {
+    return hashDocument(replayToItemDocument(document));
+  } catch {
+    return sha256Hex(stableStringify({ replay_fallback: true, metadata: document.metadata, body: document.body }));
+  }
+}
+function replayToItemDocument(document) {
+  return {
+    metadata: document.metadata,
+    body: document.body
+  };
+}
+function replayToCanonicalItemDocument(document, options = {}) {
+  return canonicalDocument(replayToItemDocument(document), options);
+}
+function toReplayDocument(document) {
+  if (!document.metadata || Object.keys(document.metadata).length === 0) {
+    return {
+      metadata: {},
+      body: document.body ?? ""
+    };
+  }
+  const canonical = canonicalDocument(document);
+  return {
+    metadata: orderObject(toItemRecord(canonical.metadata), FRONT_MATTER_KEY_ORDER),
+    body: canonical.body
+  };
+}
+function normalizeReplayPatchPath(path) {
+  if (path === "/front_matter") {
+    return "/metadata";
+  }
+  if (path.startsWith("/front_matter/")) {
+    return `/metadata/${path.slice("/front_matter/".length)}`;
+  }
+  return path;
+}
+function isHistoryPatchOp(value) {
+  return typeof value === "object" && value !== null && typeof value.op === "string" && typeof value.path === "string";
+}
+function normalizeReplayPatchOps(patch) {
+  if (!Array.isArray(patch)) {
+    return [];
+  }
+  return patch.filter(isHistoryPatchOp).map((operation) => ({
+    ...operation,
+    path: normalizeReplayPatchPath(operation.path),
+    from: typeof operation.from === "string" ? normalizeReplayPatchPath(operation.from) : void 0
+  }));
+}
+function isReplayDocumentShape(value) {
+  return typeof value === "object" && value !== null && "metadata" in value && "body" in value && typeof value.body === "string" && typeof value.metadata === "object" && value.metadata !== null;
+}
+function tryApplyReplayPatch(current, patch) {
+  try {
+    const normalizedPatch = normalizeReplayPatchOps(patch);
+    const applied = jsonPatch.applyPatch(structuredClone(current), normalizedPatch, true, false).newDocument;
+    if (!isReplayDocumentShape(applied)) {
+      return { ok: false, error: new Error("history_replay_invalid_document_shape") };
+    }
+    return { ok: true, document: { metadata: applied.metadata, body: applied.body } };
+  } catch (error) {
+    return { ok: false, error };
+  }
+}
+function verifyHistoryChain(entries) {
+  let replay = cloneEmptyReplayDocument();
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (replayHash(replay) !== entry.before_hash) {
+      return {
+        ok: false,
+        errors: [`verify_failed:before_hash_mismatch:entry_${index + 1}`]
+      };
+    }
+    const applied = tryApplyReplayPatch(replay, entry.patch);
+    if (!applied.ok) {
+      return {
+        ok: false,
+        errors: [`verify_failed:patch_apply_failed:entry_${index + 1}`]
+      };
+    }
+    replay = applied.document;
+    if (replayHash(replay) !== entry.after_hash) {
+      return {
+        ok: false,
+        errors: [`verify_failed:after_hash_mismatch:entry_${index + 1}`]
+      };
+    }
+  }
+  return { ok: true, errors: [] };
+}
+function tryApplySingleOp(document, op) {
+  try {
+    const applied = jsonPatch.applyPatch(structuredClone(document), [op], true, false).newDocument;
+    return { ok: true, document: applied };
+  } catch {
+    return { ok: false };
+  }
+}
+function lenientApplyReplayPatch(current, patch) {
+  let working = structuredClone(current);
+  let convertedReplaceToAdd = 0;
+  let skippedOps = 0;
+  for (const op of normalizeReplayPatchOps(patch)) {
+    const direct = tryApplySingleOp(working, op);
+    if (direct.ok) {
+      working = direct.document;
+      continue;
+    }
+    if (op.op === "replace") {
+      const asAdd = tryApplySingleOp(working, { ...op, op: "add" });
+      if (asAdd.ok) {
+        working = asAdd.document;
+        convertedReplaceToAdd += 1;
+        continue;
+      }
+    }
+    skippedOps += 1;
+  }
+  const candidate = working;
+  const document = {
+    metadata: typeof candidate.metadata === "object" && candidate.metadata !== null ? candidate.metadata : {},
+    body: typeof candidate.body === "string" ? candidate.body : current.body
+  };
+  return { document, convertedReplaceToAdd, skippedOps };
+}
+function reanchorHistoryEntries(entries) {
+  let replay = cloneEmptyReplayDocument();
+  const rewritten = [];
+  const details = [];
+  let entriesRehashed = 0;
+  let entriesPatchRepaired = 0;
+  let convertedReplaceToAdd = 0;
+  let skippedOps = 0;
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    const beforeHash = replayHash(replay);
+    const strict = tryApplyReplayPatch(replay, entry.patch);
+    let next;
+    let outPatch;
+    let patchRepaired = false;
+    let entryConverted = 0;
+    let entrySkipped = 0;
+    if (strict.ok) {
+      next = strict.document;
+      outPatch = entry.patch;
+    } else {
+      const lenient = lenientApplyReplayPatch(replay, entry.patch);
+      next = lenient.document;
+      outPatch = jsonPatch.compare(replay, next);
+      patchRepaired = true;
+      entryConverted = lenient.convertedReplaceToAdd;
+      entrySkipped = lenient.skippedOps;
+      convertedReplaceToAdd += entryConverted;
+      skippedOps += entrySkipped;
+      entriesPatchRepaired += 1;
+    }
+    const afterHash = replayHash(next);
+    const rehashed = beforeHash !== entry.before_hash || afterHash !== entry.after_hash;
+    if (rehashed) {
+      entriesRehashed += 1;
+    }
+    rewritten.push({
+      ...entry,
+      patch: outPatch,
+      before_hash: beforeHash,
+      after_hash: afterHash
+    });
+    details.push({
+      index: index + 1,
+      rehashed,
+      patch_repaired: patchRepaired,
+      converted_replace_to_add: entryConverted,
+      skipped_ops: entrySkipped
+    });
+    replay = next;
+  }
+  return {
+    entries: rewritten,
+    finalDocument: replay,
+    entriesRehashed,
+    entriesPatchRepaired,
+    convertedReplaceToAdd,
+    skippedOps,
+    details
+  };
+}
+function historyEntriesToRaw(entries) {
+  if (entries.length === 0) {
+    return "";
+  }
+  return `${entries.map((entry) => JSON.stringify(entry)).join("\n")}
+`;
+}
+
+export {
+  EMPTY_REPLAY_DOCUMENT,
+  cloneEmptyReplayDocument,
+  replayHash,
+  replayToItemDocument,
+  replayToCanonicalItemDocument,
+  toReplayDocument,
+  normalizeReplayPatchOps,
+  tryApplyReplayPatch,
+  verifyHistoryChain,
+  reanchorHistoryEntries,
+  historyEntriesToRaw
+};
+//# sourceMappingURL=chunk-XUC7PI2H.js.map

package/dist/cli-bundle/chunks/chunk-Y46GD4IX.js

@@ -0,0 +1,116 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bf636ecd-87ea-5f64-922e-24b95e830769")}catch(e){}}();
+import {
+  isTerminalStatus,
+  normalizeStatusForRegistry
+} from "./chunk-G24G7ZAV.js";
+
+// dist/core/item/actionability.js
+var BLOCKED_BY_DEPENDENCY_KIND = "blocked_by";
+function normalizeItemId(id) {
+  return id.trim().toLowerCase();
+}
+function collectBlockedByIds(item) {
+  const ids = /* @__PURE__ */ new Set();
+  const scalar = typeof item.blocked_by === "string" ? item.blocked_by.trim() : "";
+  if (scalar.length > 0) {
+    ids.add(scalar);
+  }
+  for (const dependency of item.dependencies ?? []) {
+    if (dependency.kind === BLOCKED_BY_DEPENDENCY_KIND && typeof dependency.id === "string" && dependency.id.trim().length > 0) {
+      ids.add(dependency.id.trim());
+    }
+  }
+  return [...ids].sort((left, right) => left.localeCompare(right));
+}
+function resolveItemBlockers(item, itemsById, statusRegistry) {
+  return collectBlockedByIds(item).map((id) => {
+    const blocker = itemsById.get(normalizeItemId(id));
+    if (!blocker) {
+      return { id, title: null, status: null, resolved: true };
+    }
+    return {
+      id,
+      title: blocker.title,
+      status: blocker.status,
+      resolved: isTerminalStatus(blocker.status, statusRegistry)
+    };
+  });
+}
+function resolveActiveStatusSet(statusRegistry) {
+  return statusRegistry.active_statuses.size > 0 ? statusRegistry.active_statuses : /* @__PURE__ */ new Set([statusRegistry.open_status]);
+}
+function hasOpenDescendant(rootId, childrenByParent, statusRegistry) {
+  const stack = [normalizeItemId(rootId)];
+  const visited = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    for (const child of childrenByParent.get(current) ?? []) {
+      if (!isTerminalStatus(child.status, statusRegistry)) {
+        return true;
+      }
+      stack.push(normalizeItemId(child.id));
+    }
+  }
+  return false;
+}
+function indexCorpus(corpus) {
+  const itemsById = /* @__PURE__ */ new Map();
+  const childrenByParent = /* @__PURE__ */ new Map();
+  const blockedByReverse = /* @__PURE__ */ new Map();
+  for (const item of corpus) {
+    itemsById.set(normalizeItemId(item.id), item);
+    const parent = typeof item.parent === "string" ? item.parent.trim() : "";
+    if (parent.length > 0) {
+      const parentKey = normalizeItemId(parent);
+      const siblings = childrenByParent.get(parentKey) ?? [];
+      siblings.push(item);
+      childrenByParent.set(parentKey, siblings);
+    }
+    for (const blockerId of collectBlockedByIds(item)) {
+      const blockerKey = normalizeItemId(blockerId);
+      const dependents = blockedByReverse.get(blockerKey) ?? [];
+      dependents.push(item.id);
+      blockedByReverse.set(blockerKey, dependents);
+    }
+  }
+  return { itemsById, childrenByParent, blockedByReverse };
+}
+function computeActionabilityReport(candidates, corpus, statusRegistry) {
+  const { itemsById, childrenByParent, blockedByReverse } = indexCorpus(corpus);
+  const activeStatuses = resolveActiveStatusSet(statusRegistry);
+  const nonTerminalIds = new Set(corpus.filter((entry) => !isTerminalStatus(entry.status, statusRegistry)).map((entry) => normalizeItemId(entry.id)));
+  const ready = [];
+  const blocked = [];
+  let activeCount = 0;
+  let containerCount = 0;
+  for (const item of candidates) {
+    if (!activeStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)))
+      continue;
+    activeCount += 1;
+    if (hasOpenDescendant(item.id, childrenByParent, statusRegistry)) {
+      containerCount += 1;
+      continue;
+    }
+    const openBlockers = resolveItemBlockers(item, itemsById, statusRegistry).filter((blocker) => !blocker.resolved);
+    const unblocks = (blockedByReverse.get(normalizeItemId(item.id)) ?? []).filter((dependentId) => nonTerminalIds.has(normalizeItemId(dependentId))).sort((left, right) => left.localeCompare(right));
+    const entry = { item, open_blockers: openBlockers, unblocks };
+    if (openBlockers.length === 0) {
+      ready.push(entry);
+    } else {
+      blocked.push(entry);
+    }
+  }
+  return { ready, blocked, active_count: activeCount, container_count: containerCount };
+}
+
+export {
+  collectBlockedByIds,
+  computeActionabilityReport
+};
+//# sourceMappingURL=chunk-Y46GD4IX.js.map
+
+//# debugId=bf636ecd-87ea-5f64-922e-24b95e830769