@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-6LLVNJXT.js

@@ -0,0 +1,429 @@
+import {
+  resolveAuthor
+} from "./chunk-WW4E2DC3.js";
+import {
+  readHistoryEntries
+} from "./chunk-L5PSPMZ4.js";
+import {
+  EMPTY_REPLAY_DOCUMENT,
+  normalizeReplayPatchOps,
+  replayHash,
+  replayToCanonicalItemDocument,
+  replayToItemDocument,
+  toReplayDocument
+} from "./chunk-XUC7PI2H.js";
+import {
+  acquireLock,
+  appendHistoryEntry,
+  createHistoryEntry,
+  enforceHistoryStreamPolicyForItem,
+  locateItem,
+  readLocatedItem
+} from "./chunk-5VAA4YHR.js";
+import {
+  canonicalDocument,
+  normalizeItemId,
+  normalizeRawItemId,
+  serializeItemDocument
+} from "./chunk-NMP5I3I5.js";
+import {
+  nowIso
+} from "./chunk-FLZSGSQR.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  projectAfterCommandItemSnapshot,
+  readSettings,
+  recordAfterCommandAffectedItem,
+  runActiveOnWriteHooks
+} from "./chunk-SHQY2IDC.js";
+import {
+  EXIT_CODE,
+  getHistoryPath,
+  getItemPath,
+  getSettingsPath,
+  pathExists,
+  readFileIfExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  writeFileAtomic
+} from "./chunk-LK6XLOGP.js";
+
+// dist/cli/commands/restore.js
+import jsonPatch from "fast-json-patch";
+import fs from "node:fs/promises";
+!(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] = "2be864e5-8a8d-5052-8aab-673ef91c2b0b");
+  } catch (e2) {
+  }
+})();
+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, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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-6LLVNJXT.js.map

package/dist/cli-bundle/chunks/chunk-6QBJLYBP.js

@@ -0,0 +1,120 @@
+
+!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]="c9f8b6c3-9354-591e-a33f-9ca8e1234722")}catch(e){}}();
+import {
+  parseAnnotationTextInput,
+  runAnnotationCommand
+} from "./chunk-EKFNL33R.js";
+import {
+  createStdinTokenResolver
+} from "./chunk-IWVU4C2F.js";
+import {
+  PmCliError
+} from "./chunk-E3SZTQ4K.js";
+import {
+  EXIT_CODE
+} from "./chunk-57NWPFF2.js";
+
+// dist/cli/commands/comments.js
+import { readFile } from "node:fs/promises";
+function isErrnoError(error) {
+  return typeof error === "object" && error !== null && "code" in error;
+}
+async function resolveCommentTextSource(options, stdinResolver) {
+  const hasAdd = options.add !== void 0;
+  const hasStdin = options.stdin === true;
+  const hasFile = typeof options.file === "string";
+  const sourceCount = Number(hasAdd) + Number(hasStdin) + Number(hasFile);
+  if (sourceCount === 0) {
+    return void 0;
+  }
+  if (sourceCount > 1) {
+    throw new PmCliError("Specify comment text using only one input source: --add, --stdin, or --file", EXIT_CODE.USAGE);
+  }
+  if (hasAdd) {
+    const addInput = await stdinResolver.resolveValue(options.add, "--add");
+    return { value: addInput ?? "", emptyFlag: "--add" };
+  }
+  if (hasStdin) {
+    const stdinInput = await stdinResolver.resolveValue("-", "--stdin");
+    return { value: stdinInput ?? "", emptyFlag: "--stdin" };
+  }
+  const filePath = options.file.trim();
+  if (!filePath) {
+    throw new PmCliError("--file path cannot be empty", EXIT_CODE.USAGE);
+  }
+  try {
+    const fileInput = await readFile(filePath, "utf8");
+    return { value: fileInput, emptyFlag: "--file" };
+  } catch (error) {
+    if (isErrnoError(error) && error.code === "ENOENT") {
+      throw new PmCliError(`--file path not found: ${filePath}`, EXIT_CODE.USAGE);
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new PmCliError(`Failed to read --file path "${filePath}": ${detail}`, EXIT_CODE.USAGE);
+  }
+}
+async function resolveCommentInput(options, stdinResolver) {
+  const hasEdit = options.edit !== void 0;
+  const hasDelete = options.delete !== void 0;
+  if (hasEdit && hasDelete) {
+    throw new PmCliError("Specify only one of --edit or --delete", EXIT_CODE.USAGE);
+  }
+  if (hasDelete) {
+    const textSource2 = await resolveCommentTextSource(options, stdinResolver);
+    if (textSource2 !== void 0) {
+      throw new PmCliError("--delete does not take comment text", EXIT_CODE.USAGE);
+    }
+    return { mode: "delete", index: options.delete };
+  }
+  if (hasEdit) {
+    const textSource2 = await resolveCommentTextSource(options, stdinResolver);
+    if (textSource2 === void 0) {
+      throw new PmCliError("--edit requires replacement text via positional [text], --add, --stdin, or --file", EXIT_CODE.USAGE);
+    }
+    return {
+      mode: "edit",
+      index: options.edit,
+      value: textSource2.value,
+      emptyFlag: textSource2.emptyFlag
+    };
+  }
+  const textSource = await resolveCommentTextSource(options, stdinResolver);
+  if (textSource === void 0) {
+    return { mode: "list" };
+  }
+  const mode = textSource.emptyFlag === "--add" ? "add" : textSource.emptyFlag === "--stdin" ? "stdin" : "file";
+  return { mode, value: textSource.value, emptyFlag: textSource.emptyFlag };
+}
+async function runComments(id, options, global) {
+  const stdinResolver = createStdinTokenResolver();
+  const commentInput = await resolveCommentInput(options, stdinResolver);
+  const shouldParseText = commentInput.mode === "add" || commentInput.mode === "edit";
+  const rawValue = commentInput.value ?? "";
+  return runAnnotationCommand(id, options, global, {
+    input: {
+      ...commentInput,
+      value: shouldParseText ? parseAnnotationTextInput(rawValue, { stripPlainTextPrefix: true }) : rawValue
+    },
+    collectionKey: "comments",
+    op: "comment_add",
+    editOp: "comment_edit",
+    deleteOp: "comment_delete",
+    parseText: (raw) => raw,
+    allowAuditBypass: Boolean(options.allowAuditComment),
+    conflictGuidance: {
+      required: "For append-only comment audits on another owner's item, prefer --allow-audit-comment before considering --force.",
+      examples: ['pm comments pm-a1b2 --add "audit note" --author "reviewer" --allow-audit-comment'],
+      nextSteps: [
+        "Retry with --allow-audit-comment for append-only audits that do not mutate item metadata beyond comments.",
+        "Use --force only when an ownership override is explicitly approved."
+      ]
+    }
+  });
+}
+
+export {
+  runComments
+};
+//# sourceMappingURL=chunk-6QBJLYBP.js.map
+
+//# debugId=c9f8b6c3-9354-591e-a33f-9ca8e1234722

package/dist/cli-bundle/chunks/chunk-6QBJLYBP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../cli/commands/comments.ts"],"sourcesContent":["/**\n * @module cli/commands/comments\n *\n * Implements the pm comments command surface and its agent-facing runtime behavior.\n */\nimport { readFile } from \"node:fs/promises\";\nimport { EXIT_CODE } from \"../../core/shared/constants.js\";\nimport type { GlobalOptions } from \"../../core/shared/command-types.js\";\nimport { PmCliError } from \"../../core/shared/errors.js\";\nimport { createStdinTokenResolver } from \"../../core/item/parse.js\";\nimport type { Comment } from \"../../types/index.js\";\nimport { parseAnnotationTextInput, runAnnotationCommand } from \"./annotation-command.js\";\n\n/**\n * Documents the comments command options payload exchanged by command, SDK, and package integrations.\n */\nexport interface CommentsCommandOptions {\n  add?: string;\n  stdin?: boolean;\n  file?: string;\n  edit?: number;\n  delete?: number;\n  limit?: string;\n  includeMeta?: boolean;\n  author?: string;\n  message?: string;\n  force?: boolean;\n  allowAuditComment?: boolean;\n}\n\n/**\n * Documents the comments result payload exchanged by command, SDK, and package integrations.\n */\nexport interface CommentsResult {\n  id: string;\n  comments: Comment[];\n  count: number;\n  total_count?: number;\n  returned_count?: number;\n  has_more?: boolean;\n  limit?: number;\n}\n\ninterface ResolvedCommentInput {\n  mode: \"list\" | \"add\" | \"stdin\" | \"file\" | \"edit\" | \"delete\";\n  value?: string;\n  emptyFlag?: string;\n  index?: number;\n}\n\nfunction isErrnoError(error: unknown): error is NodeJS.ErrnoException {\n  return typeof error === \"object\" && error !== null && \"code\" in error;\n}\n\nasync function resolveCommentTextSource(\n  options: CommentsCommandOptions,\n  stdinResolver: ReturnType<typeof createStdinTokenResolver>,\n): Promise<{ value: string; emptyFlag: string } | undefined> {\n  const hasAdd = options.add !== undefined;\n  const hasStdin = options.stdin === true;\n  const hasFile = typeof options.file === \"string\";\n  const sourceCount = Number(hasAdd) + Number(hasStdin) + Number(hasFile);\n  if (sourceCount === 0) {\n    return undefined;\n  }\n  if (sourceCount > 1) {\n    throw new PmCliError(\"Specify comment text using only one input source: --add, --stdin, or --file\", EXIT_CODE.USAGE);\n  }\n  if (hasAdd) {\n    const addInput = await stdinResolver.resolveValue(options.add, \"--add\");\n    return { value: addInput ?? \"\", emptyFlag: \"--add\" };\n  }\n  if (hasStdin) {\n    const stdinInput = await stdinResolver.resolveValue(\"-\", \"--stdin\");\n    return { value: stdinInput ?? \"\", emptyFlag: \"--stdin\" };\n  }\n  const filePath = (options.file as string).trim();\n  if (!filePath) {\n    throw new PmCliError(\"--file path cannot be empty\", EXIT_CODE.USAGE);\n  }\n  try {\n    const fileInput = await readFile(filePath, \"utf8\");\n    return { value: fileInput, emptyFlag: \"--file\" };\n  } catch (error: unknown) {\n    if (isErrnoError(error) && error.code === \"ENOENT\") {\n      throw new PmCliError(`--file path not found: ${filePath}`, EXIT_CODE.USAGE);\n    }\n    const detail = error instanceof Error ? error.message : String(error);\n    throw new PmCliError(`Failed to read --file path \"${filePath}\": ${detail}`, EXIT_CODE.USAGE);\n  }\n}\n\nasync function resolveCommentInput(\n  options: CommentsCommandOptions,\n  stdinResolver: ReturnType<typeof createStdinTokenResolver>,\n): Promise<ResolvedCommentInput> {\n  const hasEdit = options.edit !== undefined;\n  const hasDelete = options.delete !== undefined;\n  if (hasEdit && hasDelete) {\n    throw new PmCliError(\"Specify only one of --edit or --delete\", EXIT_CODE.USAGE);\n  }\n\n  if (hasDelete) {\n    const textSource = await resolveCommentTextSource(options, stdinResolver);\n    if (textSource !== undefined) {\n      throw new PmCliError(\"--delete does not take comment text\", EXIT_CODE.USAGE);\n    }\n    return { mode: \"delete\", index: options.delete };\n  }\n\n  if (hasEdit) {\n    const textSource = await resolveCommentTextSource(options, stdinResolver);\n    if (textSource === undefined) {\n      throw new PmCliError(\n        \"--edit requires replacement text via positional [text], --add, --stdin, or --file\",\n        EXIT_CODE.USAGE,\n      );\n    }\n    return {\n      mode: \"edit\",\n      index: options.edit,\n      value: textSource.value,\n      emptyFlag: textSource.emptyFlag,\n    };\n  }\n\n  const textSource = await resolveCommentTextSource(options, stdinResolver);\n  if (textSource === undefined) {\n    return { mode: \"list\" };\n  }\n  // Map the single resolved input source back to its add/stdin/file mode so the\n  // caller still knows whether to run plain-text markdown parsing (add-only).\n  const mode = textSource.emptyFlag === \"--add\" ? \"add\" : textSource.emptyFlag === \"--stdin\" ? \"stdin\" : \"file\";\n  return { mode, value: textSource.value, emptyFlag: textSource.emptyFlag };\n}\n\n/**\n * Implements run comments for the public runtime surface of this module.\n */\nexport async function runComments(id: string, options: CommentsCommandOptions, global: GlobalOptions): Promise<CommentsResult> {\n  const stdinResolver = createStdinTokenResolver();\n  const commentInput = await resolveCommentInput(options, stdinResolver);\n\n  const shouldParseText = commentInput.mode === \"add\" || commentInput.mode === \"edit\";\n  // list/delete carry no text (value undefined → \"\"); add/edit/stdin/file always\n  // resolve to a string. Normalize once so neither branch below is unreachable.\n  const rawValue = commentInput.value ?? \"\";\n  return runAnnotationCommand<\"comments\", Comment>(id, options, global, {\n    input: {\n      ...commentInput,\n      value: shouldParseText ? parseAnnotationTextInput(rawValue, { stripPlainTextPrefix: true }) : rawValue,\n    },\n    collectionKey: \"comments\",\n    op: \"comment_add\",\n    editOp: \"comment_edit\",\n    deleteOp: \"comment_delete\",\n    parseText: (raw) => raw,\n    allowAuditBypass: Boolean(options.allowAuditComment),\n    conflictGuidance: {\n      required:\n        \"For append-only comment audits on another owner's item, prefer --allow-audit-comment before considering --force.\",\n      examples: ['pm comments pm-a1b2 --add \"audit note\" --author \"reviewer\" --allow-audit-comment'],\n      nextSteps: [\n        \"Retry with --allow-audit-comment for append-only audits that do not mutate item metadata beyond comments.\",\n        \"Use --force only when an ownership override is explicitly approved.\",\n      ],\n    },\n  });\n}\n"],"names":["textSource"],"mappings":"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","debugId":"c9f8b6c3-9354-591e-a33f-9ca8e1234722"}