@unbrained/pm-cli 2026.7.14 → 2026.7.15

package/dist/cli-bundle/chunks/{chunk-FTQLW4JD.js → chunk-GOSLKLFE.js}

@@ -1,34 +1,33 @@
 
-!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]="5fcd4453-ef12-5c65-8c44-65b8af0cd97f")}catch(e){}}();
+!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]="19224557-a97b-5405-9dc9-894cdbf821fc")}catch(e){}}();
 import {
   resolveAuthor
 } from "./chunk-CUFW7ITY.js";
-import {
-  EMPTY_REPLAY_DOCUMENT,
-  historyEntriesToRaw,
-  readHistoryEntries,
-  replayHash,
-  replayToItemDocument,
-  tryApplyReplayPatch,
-  verifyHistoryChain
-} from "./chunk-2GA3NK35.js";
 import {
   acquireLock,
   canonicalDocument,
   createHistoryEntry,
+  findFirstMergeConflictMarker,
   getActiveExtensionRegistrations,
+  hashDocument,
   locateItem,
   normalizeItemId,
   normalizeRawItemId,
   nowIso,
+  orderObject,
   readLocatedItem,
   readSettings,
   resolveGovernanceKnobs,
+  runActiveOnReadHooks,
   runActiveOnWriteHooks,
-  serializeItemDocument
-} from "./chunk-GSEADLRH.js";
+  serializeItemDocument,
+  sha256Hex,
+  stableStringify,
+  toItemRecord
+} from "./chunk-Q7A43DS4.js";
 import {
   EXIT_CODE,
+  ITEM_METADATA_KEY_ORDER,
   PmCliError,
   getHistoryPath,
   getItemPath,
@@ -38,9 +37,395 @@ import {
   resolveItemTypeRegistry,
   resolvePmRoot,
   writeFileAtomic
-} from "./chunk-GXXC7QSK.js";
+} from "./chunk-QKECXBBG.js";
+
+// dist/core/history/replay.js
+import jsonPatch from "fast-json-patch";
+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), ITEM_METADATA_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")}
+`;
+}
 
-// dist/cli/commands/history-redact.js
+// dist/core/history/projection.js
+function findHistoryIndexAtTimestamp(history, parsedTarget) {
+  let historyIndex = -1;
+  history.forEach((entry, index) => {
+    const entryTimestamp = Date.parse(entry.ts);
+    if (!Number.isFinite(entryTimestamp)) {
+      throw new PmCliError(`History for this item contains invalid timestamp at entry ${index + 1}.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    if (entryTimestamp <= parsedTarget) {
+      historyIndex = index;
+    }
+  });
+  return historyIndex;
+}
+function buildHistoryTargetGuidance(history) {
+  const firstTimestamp = history[0]?.ts ?? null;
+  const lastTimestamp = history.at(-1)?.ts ?? null;
+  const guidance = {
+    code: "history_target_out_of_range",
+    required: "Choose a target within the available item history.",
+    why: "Point-in-time reads and restores can only reconstruct recorded versions.",
+    examples: [],
+    nextSteps: [
+      "Run pm history <id> to inspect available versions and timestamps."
+    ],
+    valid_range: {
+      first_version: null,
+      last_version: null,
+      first_timestamp: firstTimestamp,
+      last_timestamp: lastTimestamp
+    }
+  };
+  if (lastTimestamp !== null) {
+    guidance.examples = ["1", String(history.length), lastTimestamp];
+    guidance.valid_range.first_version = 1;
+    guidance.valid_range.last_version = history.length;
+  }
+  return { guidance, lastTimestamp };
+}
+function extractPatchFailureContext(patch, error) {
+  const failure = {};
+  if (error instanceof Error && error.message.trim().length > 0) {
+    failure.reason = error.message.trim();
+  }
+  if (typeof error !== "object" || error === null) {
+    return failure;
+  }
+  const candidate = error;
+  if (typeof candidate.index === "number" && Number.isInteger(candidate.index) && candidate.index >= 0) {
+    failure.patchIndex = candidate.index;
+  }
+  if (typeof candidate.operation === "object" && candidate.operation !== null) {
+    const operation = candidate.operation;
+    Object.assign(failure, Object.fromEntries(["op", "path", "from"].flatMap((field) => {
+      const value = operation[field];
+      return typeof value === "string" ? [[field, value]] : [];
+    })));
+  }
+  if (failure.patchIndex !== void 0) {
+    const fallback = patch[failure.patchIndex];
+    if (fallback) {
+      failure.op ??= fallback.op;
+      failure.path ??= fallback.path;
+      failure.from ??= fallback.from;
+    }
+  }
+  return failure;
+}
+function resolveHistoryTarget(target, history, options = {}) {
+  const trimmed = target.trim();
+  const errorSubject = options.errorSubject ?? "history";
+  const errorSubjectTitle = errorSubject === "restore" ? "Restore" : "History";
+  const { guidance, lastTimestamp } = buildHistoryTargetGuidance(history);
+  if (!trimmed) {
+    throw new PmCliError(`Missing ${errorSubject} target. Use a timestamp or version number.`, EXIT_CODE.USAGE, guidance);
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const version = Number(trimmed);
+    if (!Number.isSafeInteger(version) || version < 1 || version > history.length) {
+      throw new PmCliError(`${errorSubjectTitle} version must be between 1 and ${history.length} for this item.`, EXIT_CODE.USAGE, guidance);
+    }
+    return { kind: "version", raw: trimmed, historyIndex: version - 1 };
+  }
+  const parsedTarget = Date.parse(trimmed);
+  if (!Number.isFinite(parsedTarget)) {
+    throw new PmCliError(`Invalid ${errorSubject} target "${target}". Use a positive version number or ISO timestamp.`, EXIT_CODE.USAGE, guidance);
+  }
+  const historyIndex = findHistoryIndexAtTimestamp(history, parsedTarget);
+  if (historyIndex < 0 || options.allowFutureTimestamp !== true && parsedTarget > Date.parse(lastTimestamp)) {
+    throw new PmCliError(errorSubject === "restore" ? `No history entries exist at or before timestamp ${trimmed}.` : `No history entry exists at timestamp ${trimmed}.`, EXIT_CODE.USAGE, guidance);
+  }
+  return { kind: "timestamp", raw: trimmed, historyIndex };
+}
+function applyHistoryPatch(current, patch, entryNumber, entryOp) {
+  const applied = tryApplyReplayPatch(current, patch);
+  if (applied.ok) {
+    return applied.document;
+  }
+  const failure = extractPatchFailureContext(patch, applied.error);
+  const tokens = [
+    `history_op=${entryOp}`,
+    failure.patchIndex === void 0 ? null : `patch_index=${failure.patchIndex}`,
+    failure.op ? `op=${failure.op}` : null,
+    failure.path ? `path=${failure.path}` : null,
+    failure.from ? `from=${failure.from}` : null
+  ].filter((token) => token !== null);
+  throw new PmCliError(`Failed to apply history patch at entry ${entryNumber} (${tokens.join(", ")}). ${failure.reason ?? String(applied.error)}`, EXIT_CODE.GENERIC_FAILURE);
+}
+function replayHistoryToTarget(history, targetIndex) {
+  let document = structuredClone(EMPTY_REPLAY_DOCUMENT);
+  for (let index = 0; index <= targetIndex; index += 1) {
+    const entry = history[index];
+    if (!entry) {
+      throw new PmCliError(`History target entry ${index + 1} does not exist.`, EXIT_CODE.USAGE);
+    }
+    if (replayHash(document) !== entry.before_hash) {
+      throw new PmCliError(`History hash mismatch before replay at entry ${index + 1}.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    document = applyHistoryPatch(document, entry.patch, index + 1, entry.op);
+    if (replayHash(document) !== entry.after_hash) {
+      throw new PmCliError(`History hash mismatch after replay at entry ${index + 1}.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+  }
+  return document;
+}
+function ensureMaterializedHistoryTarget(replayDocument, target) {
+  if (Object.keys(replayDocument.metadata).length > 0) {
+    return replayDocument;
+  }
+  throw new PmCliError(`History target ${target.raw} resolves to a deleted state; choose a version or timestamp where the item exists.`, EXIT_CODE.USAGE);
+}
+
+// dist/core/history/read.js
+async function readHistoryEntries(historyPath, itemId) {
+  const raw = await readFileIfExists(historyPath);
+  if (raw === null) {
+    return [];
+  }
+  await runActiveOnReadHooks({ path: historyPath, scope: "project" });
+  if (raw.trim() === "") {
+    return [];
+  }
+  const conflictMarker = findFirstMergeConflictMarker(raw);
+  if (conflictMarker) {
+    throw new PmCliError(`History for ${itemId} contains merge conflict markers at line ${conflictMarker.line} (${conflictMarker.marker}). Resolve <<<<<<< ======= >>>>>>> markers and retry.`, EXIT_CODE.GENERIC_FAILURE, {
+      code: "history_merge_conflict_markers_detected",
+      required: "Repair the history stream by resolving merge-conflict markers.",
+      why: "Conflict markers break JSONL parsing and invalidate deterministic audit history.",
+      examples: [
+        `pm history ${itemId}`,
+        `pm restore ${itemId} <timestamp-or-version>`
+      ],
+      nextSteps: ["Resolve or restore the history file, then rerun the command."]
+    });
+  }
+  const entries = [];
+  for (const [index, rawLine] of raw.split(/\r?\n/).entries()) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      throw new PmCliError(`History for ${itemId} contains invalid JSON at line ${index + 1}. Repair or restore the history stream and retry.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+  }
+  return entries;
+}
+
+// dist/sdk/history-redact.js
 import fs2 from "node:fs/promises";
 
 // dist/core/history/history-rewrite.js
@@ -124,7 +509,7 @@ async function executeHistoryRewrite(params) {
   }
 }
 
-// dist/cli/commands/history-redact.js
+// dist/sdk/history-redact.js
 function normalizeStringArrayInput(value) {
   if (Array.isArray(value)) {
     return value;
@@ -279,13 +664,6 @@ function redactUnknownValue(value, rules, replacement) {
     replacements: 0
   };
 }
-function applyHistoryPatch(current, patch, entryNumber, op) {
-  const result = tryApplyReplayPatch(current, patch);
-  if (!result.ok) {
-    throw new PmCliError(`history-redact failed to apply patch at entry ${entryNumber} (op=${op}): ${result.error instanceof Error ? result.error.message : String(result.error)}`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  return result.document;
-}
 function inspectHistoryIntegrity(entries) {
   let replay = structuredClone(EMPTY_REPLAY_DOCUMENT);
   let hashMismatchesBefore = 0;
@@ -638,12 +1016,28 @@ var _testOnly = {
 };
 
 export {
+  cloneEmptyReplayDocument,
+  replayHash,
+  replayToItemDocument,
+  replayToCanonicalItemDocument,
+  toReplayDocument,
+  normalizeReplayPatchOps,
+  tryApplyReplayPatch,
+  verifyHistoryChain,
+  reanchorHistoryEntries,
+  historyEntriesToRaw,
+  extractPatchFailureContext,
+  resolveHistoryTarget,
+  applyHistoryPatch,
+  replayHistoryToTarget,
+  ensureMaterializedHistoryTarget,
+  readHistoryEntries,
   writeHistoryRawWithRollback,
   executeHistoryRewrite,
   resolveHistorySubject,
   runHistoryRedact,
   _testOnly
 };
-//# sourceMappingURL=chunk-FTQLW4JD.js.map
+//# sourceMappingURL=chunk-GOSLKLFE.js.map
 
-//# debugId=5fcd4453-ef12-5c65-8c44-65b8af0cd97f
+//# debugId=19224557-a97b-5405-9dc9-894cdbf821fc