@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,426 @@
+
+!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]="652b0f45-5bb7-52ea-967d-44b4e556bc1b")}catch(e){}}();
+import {
+  resolveAuthor
+} from "./chunk-T5RRNDA7.js";
+import {
+  readHistoryEntries
+} from "./chunk-IX5BXEMX.js";
+import {
+  EMPTY_REPLAY_DOCUMENT,
+  normalizeReplayPatchOps,
+  replayHash,
+  replayToCanonicalItemDocument,
+  replayToItemDocument,
+  toReplayDocument
+} from "./chunk-OGWQ2IEP.js";
+import {
+  acquireLock,
+  appendHistoryEntry,
+  createHistoryEntry,
+  enforceHistoryStreamPolicyForItem,
+  locateItem,
+  readLocatedItem
+} from "./chunk-ENGQOEUY.js";
+import {
+  canonicalDocument,
+  normalizeItemId,
+  normalizeRawItemId,
+  serializeItemDocument
+} from "./chunk-G24G7ZAV.js";
+import {
+  nowIso
+} from "./chunk-3GCS5SKL.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  projectAfterCommandItemSnapshot,
+  readSettings,
+  recordAfterCommandAffectedItem,
+  runActiveOnWriteHooks
+} from "./chunk-E3SZTQ4K.js";
+import {
+  EXIT_CODE,
+  getHistoryPath,
+  getItemPath,
+  getSettingsPath,
+  pathExists,
+  readFileIfExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  writeFileAtomic
+} from "./chunk-57NWPFF2.js";
+
+// dist/cli/commands/restore.js
+import jsonPatch from "fast-json-patch";
+import fs from "node:fs/promises";
+function ensureReplayTarget(target, history) {
+  const trimmed = target.trim();
+  if (!trimmed) {
+    throw new PmCliError("Missing restore target. Use a timestamp or version number.", EXIT_CODE.USAGE);
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const version = Number(trimmed);
+    if (!Number.isSafeInteger(version) || version < 1 || version > history.length) {
+      throw new PmCliError(`Restore version must be between 1 and ${history.length} for this item.`, EXIT_CODE.USAGE);
+    }
+    return {
+      kind: "version",
+      raw: trimmed,
+      historyIndex: version - 1
+    };
+  }
+  const parsedTarget = Date.parse(trimmed);
+  if (!Number.isFinite(parsedTarget)) {
+    throw new PmCliError(`Invalid restore target "${target}". Use a positive version number or ISO timestamp.`, EXIT_CODE.USAGE);
+  }
+  let index = -1;
+  for (let i = 0; i < history.length; i += 1) {
+    const entryTimestamp = Date.parse(history[i].ts);
+    if (!Number.isFinite(entryTimestamp)) {
+      throw new PmCliError(`History for this item contains invalid timestamp at entry ${i + 1}.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    if (entryTimestamp <= parsedTarget) {
+      index = i;
+    }
+  }
+  if (index < 0) {
+    throw new PmCliError(`No history entries exist at or before timestamp ${trimmed}.`, EXIT_CODE.USAGE);
+  }
+  return {
+    kind: "timestamp",
+    raw: trimmed,
+    historyIndex: index
+  };
+}
+function extractPatchFailureContext(patch, error) {
+  const context = {};
+  if (error instanceof Error && error.message.trim().length > 0) {
+    context.reason = error.message.trim();
+  }
+  if (typeof error !== "object" || error === null) {
+    return context;
+  }
+  const candidate = error;
+  if (typeof candidate.index === "number" && Number.isInteger(candidate.index) && candidate.index >= 0) {
+    context.patchIndex = candidate.index;
+  }
+  const operationRecord = typeof candidate.operation === "object" && candidate.operation !== null ? candidate.operation : null;
+  enrichPatchFailureContext(context, operationRecord, patch);
+  return context;
+}
+function enrichPatchFailureContext(context, operationRecord, patch) {
+  if (operationRecord && typeof operationRecord.op === "string") {
+    context.op = operationRecord.op;
+  }
+  if (operationRecord && typeof operationRecord.path === "string") {
+    context.path = operationRecord.path;
+  }
+  if (operationRecord && typeof operationRecord.from === "string") {
+    context.from = operationRecord.from;
+  }
+  if ((context.op === void 0 || context.path === void 0) && context.patchIndex !== void 0) {
+    const fallback = patch[context.patchIndex];
+    if (fallback) {
+      context.op = context.op ?? fallback.op;
+      context.path = context.path ?? fallback.path;
+      context.from = context.from ?? fallback.from;
+    }
+  }
+}
+function applyHistoryPatch(current, patch, entryNumber, entryOp) {
+  try {
+    const normalizedPatch = normalizeReplayPatchOps(patch);
+    const applied = jsonPatch.applyPatch(structuredClone(current), normalizedPatch, true, false).newDocument;
+    if (typeof applied !== "object" || applied === null || !("metadata" in applied) || !("body" in applied) || typeof applied.body !== "string" || typeof applied.metadata !== "object" || applied.metadata === null) {
+      throw new PmCliError(`History replay produced an invalid document shape at entry ${entryNumber}.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    const replay = applied;
+    return {
+      metadata: replay.metadata,
+      body: replay.body
+    };
+  } catch (error) {
+    if (error instanceof PmCliError) {
+      throw error;
+    }
+    const failureContext = extractPatchFailureContext(patch, error);
+    const contextTokens = [
+      `history_op=${entryOp}`,
+      /* c8 ignore next -- contextual fields are best-effort and may be absent depending on patch failure shape. */
+      failureContext.patchIndex !== void 0 ? `patch_index=${failureContext.patchIndex}` : null,
+      /* c8 ignore next -- contextual fields are best-effort and may be absent depending on patch failure shape. */
+      failureContext.op ? `op=${failureContext.op}` : null,
+      /* c8 ignore next -- contextual fields are best-effort and may be absent depending on patch failure shape. */
+      failureContext.path ? `path=${failureContext.path}` : null,
+      /* c8 ignore next -- contextual fields are best-effort and may be absent depending on patch failure shape. */
+      failureContext.from ? `from=${failureContext.from}` : null
+    ].filter((token) => token !== null);
+    const reasonSuffix = failureContext.reason ? ` ${failureContext.reason}` : "";
+    throw new PmCliError(`Failed to apply history patch at entry ${entryNumber} (${contextTokens.join(", ")}).${reasonSuffix}`, EXIT_CODE.GENERIC_FAILURE);
+  }
+}
+function replayToTarget(history, targetIndex) {
+  let document = structuredClone(EMPTY_REPLAY_DOCUMENT);
+  for (let i = 0; i <= targetIndex; i += 1) {
+    const entry = history[i];
+    const beforeHash = replayHash(document);
+    if (beforeHash !== entry.before_hash) {
+      throw new PmCliError(`History hash mismatch before replay at entry ${i + 1}.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    document = applyHistoryPatch(document, entry.patch, i + 1, entry.op);
+    const afterHash = replayHash(document);
+    if (afterHash !== entry.after_hash) {
+      throw new PmCliError(`History hash mismatch after replay at entry ${i + 1}.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+  }
+  return document;
+}
+function ensureMaterializedRestoreTarget(replayDocument, target) {
+  if (Object.keys(replayDocument.metadata).length > 0) {
+    return replayDocument;
+  }
+  throw new PmCliError(`Restore target ${target.raw} resolves to a deleted state; choose a version or timestamp where the item exists.`, EXIT_CODE.USAGE);
+}
+function replayCurrentDocument(history) {
+  const currentReplay = replayToTarget(history, history.length - 1);
+  if (Object.keys(currentReplay.metadata).length === 0) {
+    return {
+      metadata: {},
+      body: currentReplay.body
+    };
+  }
+  return canonicalDocument(replayToItemDocument(currentReplay));
+}
+async function resolveRestoreSubject(pmRoot, id, settings, typeToFolder) {
+  const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeToFolder);
+  if (located) {
+    const historyPath = getHistoryPath(pmRoot, located.id);
+    const historyPolicy = await enforceHistoryStreamPolicyForItem({
+      pmRoot,
+      settings,
+      itemId: located.id,
+      commandLabel: "restore"
+    });
+    return {
+      id: located.id,
+      historyPath,
+      located,
+      historyPolicyWarnings: historyPolicy.warnings
+    };
+  }
+  const normalizedId = normalizeItemId(id, settings.id_prefix);
+  const rawNormalizedId = normalizeRawItemId(id);
+  const candidateIds = normalizedId === rawNormalizedId ? [normalizedId] : [normalizedId, rawNormalizedId];
+  for (const candidateId of candidateIds) {
+    const historyPath = getHistoryPath(pmRoot, candidateId);
+    if (await pathExists(historyPath)) {
+      return {
+        id: candidateId,
+        historyPath,
+        located: null,
+        historyPolicyWarnings: []
+      };
+    }
+  }
+  throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
+}
+function changedFields(beforeDocument, afterDocument) {
+  const beforeReplay = toReplayDocument(beforeDocument);
+  const afterReplay = toReplayDocument(afterDocument);
+  const patch = jsonPatch.compare(beforeReplay, afterReplay);
+  const fields = /* @__PURE__ */ new Set();
+  for (const op of patch) {
+    if (op.path === "/body" || op.path.startsWith("/body/")) {
+      fields.add("body");
+      continue;
+    }
+    const segment = op.path.replace(/^\/(?:metadata|front_matter)\/?/, "").split("/")[0];
+    fields.add(segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+  }
+  return Array.from(fields).sort((a, b) => a.localeCompare(b));
+}
+async function loadRestoreStateUnderLock(params) {
+  const historyRawUnderLock = await readFileIfExists(params.subject.historyPath);
+  if (historyRawUnderLock !== params.historyRawBeforeLock) {
+    throw new PmCliError(`History for ${params.resolvedId} changed while waiting for lock; retry restore.`, EXIT_CODE.CONFLICT);
+  }
+  const locatedUnderLock = await locateItem(params.pmRoot, params.resolvedId, params.settings.id_prefix, params.settings.item_format, params.typeToFolder);
+  const loadedItemUnderLock = locatedUnderLock ? await readLocatedItem(locatedUnderLock, { schema: params.settings.schema }) : null;
+  if ((loadedItemUnderLock?.raw ?? null) !== params.currentItemRawBeforeLock) {
+    throw new PmCliError(`Item ${params.resolvedId} changed while waiting for lock; retry restore.`, EXIT_CODE.CONFLICT);
+  }
+  return { loadedItemUnderLock, existingItemPath: locatedUnderLock?.itemPath ?? null };
+}
+function resolveRestoreCurrentState(loadedItemUnderLock, history) {
+  if (loadedItemUnderLock) {
+    return { document: loadedItemUnderLock.document, originalRaw: loadedItemUnderLock.raw };
+  }
+  return { document: replayCurrentDocument(history), originalRaw: null };
+}
+function collectRestoreOwnershipWarnings(params) {
+  const assigned = params.document.metadata.assignee?.trim();
+  const hasOwnershipConflict = assigned && assigned !== params.author && !params.force;
+  if (!hasOwnershipConflict) {
+    return [];
+  }
+  if (params.enforcement === "strict") {
+    throw new PmCliError(`Item ${params.resolvedId} is assigned to ${assigned}. Use --force to override.`, EXIT_CODE.CONFLICT);
+  }
+  return params.enforcement === "warn" ? [`ownership_warning:assignee_conflict:${params.resolvedId}:${assigned}`] : [];
+}
+async function restorePreviousItemAfterHistoryFailure(params) {
+  if (params.existingItemPath && params.resolvedOriginalRaw !== null && params.restoredItemPath !== params.existingItemPath) {
+    await writeFileAtomic(params.existingItemPath, params.resolvedOriginalRaw);
+    await fs.rm(params.restoredItemPath, { force: true });
+    return;
+  }
+  if (params.existingItemPath && params.resolvedOriginalRaw !== null) {
+    await writeFileAtomic(params.existingItemPath, params.resolvedOriginalRaw);
+    return;
+  }
+  await fs.rm(params.restoredItemPath, { force: true });
+}
+async function runRestoreWriteHooks(params) {
+  return [
+    ...await runActiveOnWriteHooks({
+      path: params.restoredItemPath,
+      scope: "project",
+      op: "restore",
+      item_id: params.after.metadata.id,
+      item_type: params.after.metadata.type,
+      before: params.before,
+      after: params.after,
+      changed_fields: ["restored"]
+    }),
+    ...await runActiveOnWriteHooks({
+      path: params.historyPath,
+      scope: "project",
+      op: "restore:history",
+      item_id: params.after.metadata.id,
+      item_type: params.after.metadata.type,
+      before: params.before,
+      after: params.after,
+      changed_fields: ["restored"]
+    })
+  ];
+}
+async function runRestore(id, target, options, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const settings = await readSettings(pmRoot);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const subject = await resolveRestoreSubject(pmRoot, id, settings, typeRegistry.type_to_folder);
+  const resolvedId = subject.id;
+  const historyRawBeforeLock = await readFileIfExists(subject.historyPath);
+  const history = await readHistoryEntries(subject.historyPath, resolvedId);
+  if (history.length === 0) {
+    throw new PmCliError(`No history exists for ${resolvedId}; restore is unavailable.`, EXIT_CODE.NOT_FOUND);
+  }
+  const resolvedTarget = ensureReplayTarget(target, history);
+  const replayDocument = ensureMaterializedRestoreTarget(replayToTarget(history, resolvedTarget.historyIndex), resolvedTarget);
+  const restoredDocument = replayToCanonicalItemDocument(replayDocument, { schema: settings.schema });
+  if (restoredDocument.metadata.id !== resolvedId) {
+    throw new PmCliError(`Restore target resolved to item ${restoredDocument.metadata.id}, expected ${resolvedId}.`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const loadedItemBeforeLock = subject.located ? await readLocatedItem(subject.located, { schema: settings.schema }) : null;
+  const currentItemRawBeforeLock = loadedItemBeforeLock?.raw ?? null;
+  const author = resolveAuthor(options.author, settings.author_default);
+  const releaseLock = await acquireLock(pmRoot, resolvedId, settings.locks.ttl_seconds, author, Boolean(options.force), settings.governance.force_required_for_stale_lock, settings.locks.wait_ms);
+  try {
+    const { loadedItemUnderLock, existingItemPath } = await loadRestoreStateUnderLock({
+      pmRoot,
+      resolvedId,
+      subject,
+      settings,
+      typeToFolder: typeRegistry.type_to_folder,
+      historyRawBeforeLock,
+      currentItemRawBeforeLock
+    });
+    const itemFormat = "toon";
+    const currentState = resolveRestoreCurrentState(loadedItemUnderLock, history);
+    const ownershipWarnings = collectRestoreOwnershipWarnings({
+      document: currentState.document,
+      author,
+      force: options.force,
+      enforcement: settings.governance.ownership_enforcement,
+      resolvedId
+    });
+    const serializedRestore = serializeItemDocument(restoredDocument, { format: itemFormat, schema: settings.schema });
+    const restoredItemPath = getItemPath(pmRoot, restoredDocument.metadata.type, resolvedId, itemFormat, typeRegistry.type_to_folder);
+    await writeFileAtomic(restoredItemPath, serializedRestore);
+    if (existingItemPath && restoredItemPath !== existingItemPath) {
+      await fs.rm(existingItemPath);
+    }
+    const historyEntry = createHistoryEntry({
+      nowIso: nowIso(),
+      author,
+      op: "restore",
+      before: currentState.document,
+      after: restoredDocument,
+      message: options.message
+    });
+    try {
+      await appendHistoryEntry(subject.historyPath, historyEntry);
+    } catch (error) {
+      await restorePreviousItemAfterHistoryFailure({
+        existingItemPath,
+        resolvedOriginalRaw: currentState.originalRaw,
+        restoredItemPath
+      });
+      throw error;
+    }
+    const restoreChangedFields = changedFields(currentState.document, restoredDocument);
+    const hookWarnings = await runRestoreWriteHooks({
+      restoredItemPath,
+      historyPath: subject.historyPath,
+      before: currentState.document,
+      after: restoredDocument
+    });
+    recordAfterCommandAffectedItem({
+      id: restoredDocument.metadata.id,
+      op: "restore",
+      item_type: restoredDocument.metadata.type,
+      previous_status: currentState.document.metadata.status,
+      status: restoredDocument.metadata.status,
+      previous: projectAfterCommandItemSnapshot(currentState.document.metadata, restoreChangedFields),
+      current: projectAfterCommandItemSnapshot(restoredDocument.metadata, restoreChangedFields),
+      changed_fields: restoreChangedFields
+    });
+    const targetEntry = history[resolvedTarget.historyIndex];
+    return {
+      item: restoredDocument.metadata,
+      restored_from: {
+        kind: resolvedTarget.kind,
+        target: resolvedTarget.raw,
+        history_index: resolvedTarget.historyIndex + 1,
+        entry_ts: targetEntry.ts,
+        entry_op: targetEntry.op
+      },
+      changed_fields: restoreChangedFields,
+      warnings: [...subject.historyPolicyWarnings, ...ownershipWarnings, ...hookWarnings]
+    };
+  } finally {
+    await releaseLock();
+  }
+}
+var _testOnlyRestoreCommand = {
+  applyHistoryPatch,
+  changedFields,
+  ensureMaterializedRestoreTarget,
+  ensureReplayTarget,
+  extractPatchFailureContext,
+  replayCurrentDocument,
+  replayToTarget,
+  resolveRestoreSubject
+};
+
+export {
+  runRestore,
+  _testOnlyRestoreCommand
+};
+//# sourceMappingURL=chunk-YN7Y6DQZ.js.map
+
+//# debugId=652b0f45-5bb7-52ea-967d-44b4e556bc1b