@unbrained/pm-cli 2026.6.24 → 2026.7.1

package/dist/cli-bundle/chunks/{chunk-HBAEFWX3.js → chunk-NUHHPVVS.js}

@@ -1,7 +1,13 @@
 import {
-  runClose
-} from "./chunk-PRVTGX64.js";
+  describeAllowedTransitions,
+  evaluateTransition,
+  resolveTypeWorkflows
+} from "./chunk-CZVISY5A.js";
 import {
+  COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR,
+  COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR,
+  COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
+  applyLegacyNoneCollectionNormalizers,
   assertNoLegacyNoneToken,
   assertNoLegacyNoneTokens,
   ensureEnumValue,
@@ -17,8 +23,9 @@ import {
   parseReminderEntries,
   parseTests,
   parseTypeOptionEntries,
-  resolvePriority
-} from "./chunk-XXKV4UWE.js";
+  resolvePriority,
+  resolveRuntimeUnsetFieldDefinition
+} from "./chunk-VARHOHYV.js";
 import {
   applyTagRemovals,
   assertNoUnknownCsvKeys,
@@ -28,255 +35,73 @@ import {
   parseCsvKv,
   parseOptionalNumber,
   parseTags
-} from "./chunk-CZIFFMZI.js";
+} from "./chunk-DDPTYJIM.js";
+import {
+  runClose
+} from "./chunk-RGEMWD6Q.js";
 import {
   normalizeParentReferenceValue,
   validateMissingParentReference,
   validateSprintOrReleaseValue
-} from "./chunk-QOUOMPHO.js";
+} from "./chunk-JPECA746.js";
 import {
   buildInvalidTypeError
-} from "./chunk-DTABLLVE.js";
+} from "./chunk-LB6TP6MC.js";
 import {
   applyRegisteredItemFieldDefaultsAndValidation,
   buildItemNotFoundError,
   collectRegisteredItemFieldNames,
   locateItem,
   mutateItem,
+  normalizeItemId,
   parseRegisteredItemFieldAssignments,
   readLocatedItem,
   toItemRecord
-} from "./chunk-OHDQNKJB.js";
-import {
-  normalizeItemId
-} from "./chunk-B74BP6IS.js";
+} from "./chunk-3K2M5OYU.js";
 import {
   collectRuntimeUpdateFieldValues,
   normalizeStatusInput
-} from "./chunk-C4C3EJCJ.js";
-import {
-  canonicalizeCommandOptionKey,
-  commandOptionFlagLabel,
-  resolveCommandOptionPolicyState,
-  resolveItemTypeRegistry,
-  resolveTypeDefinition,
-  resolveTypeName,
-  validateTypeOptions
-} from "./chunk-ZV7IQ23N.js";
+} from "./chunk-BHO33VBQ.js";
 import {
   resolveIsoOrRelative
-} from "./chunk-I6QMJ2XT.js";
+} from "./chunk-WYDHYJPO.js";
 import {
   DEPENDENCY_KIND_VALUES,
   EXIT_CODE,
   ISSUE_SEVERITY_VALUES,
   PmCliError,
   RISK_VALUES,
+  canonicalizeCommandOptionKey,
+  commandOptionFlagLabel,
   getActiveExtensionRegistrations,
   getSettingsPath,
   pathExists,
   readSettings,
+  resolveCommandOptionPolicyState,
+  resolveItemTypeRegistry,
   resolveItemTypesFilePath,
   resolvePmRoot,
   resolveRuntimeFieldRegistry,
   resolveRuntimeStatusRegistry,
-  stableValueEquals
-} from "./chunk-EYPINTFR.js";
-
-// dist/core/schema/type-workflows.js
-!(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] = "559afda0-2672-52e3-86c1-cf623efb4023");
-  } catch (e2) {
-  }
-})();
-function normalizeStatusToken(value) {
-  return typeof value === "string" ? value.trim().toLowerCase().replaceAll(/[\s-]+/g, "_") : "";
-}
-function normalizeTypeName(value) {
-  return typeof value === "string" ? value.trim().toLowerCase() : "";
-}
-function resolveStatusId(value, statusRegistry) {
-  const token = normalizeStatusToken(value);
-  if (token.length === 0) {
-    return "";
-  }
-  return statusRegistry?.alias_to_id?.get(token) ?? token;
-}
-function resolveTypeWorkflows(schema) {
-  const rawWorkflows = Array.isArray(schema?.type_workflows) ? schema.type_workflows : [];
-  const byType = /* @__PURE__ */ new Map();
-  for (const entry of rawWorkflows) {
-    const type = normalizeTypeName(entry?.type);
-    if (type.length === 0) {
-      continue;
-    }
-    if (!Array.isArray(entry?.allowed_transitions)) {
-      continue;
-    }
-    const pairs = entry.allowed_transitions;
-    const record = byType.get(type) ?? { pairs: [], denyAll: false };
-    if (pairs.length === 0) {
-      record.denyAll = true;
-    }
-    for (const pair of pairs) {
-      if (!Array.isArray(pair) || pair.length !== 2) {
-        continue;
-      }
-      const from = normalizeStatusToken(pair[0]);
-      const to = normalizeStatusToken(pair[1]);
-      if (from.length === 0 || to.length === 0) {
-        continue;
-      }
-      if (record.pairs.some((candidate) => candidate[0] === from && candidate[1] === to)) {
-        continue;
-      }
-      record.pairs.push([from, to]);
-    }
-    byType.set(type, record);
-  }
-  return [...byType.entries()].filter(([, record]) => record.pairs.length > 0 || record.denyAll).map(([type, record]) => ({ type, allowed_transitions: record.pairs })).sort((left, right) => left.type.localeCompare(right.type));
-}
-function evaluateTransition(input) {
-  const typeName = normalizeTypeName(input.typeName);
-  const matched = input.typeWorkflows.find((workflow) => workflow.type === typeName);
-  if (!matched) {
-    return { allowed: true, hasRule: false, allowedTransitions: [] };
-  }
-  const from = resolveStatusId(input.fromStatus, input.statusRegistry);
-  const to = resolveStatusId(input.toStatus, input.statusRegistry);
-  if (from.length > 0 && from === to) {
-    return { allowed: true, hasRule: true, allowedTransitions: matched.allowed_transitions };
-  }
-  const allowed = matched.allowed_transitions.some((pair) => {
-    const ruleFrom = resolveStatusId(pair[0], input.statusRegistry);
-    const ruleTo = resolveStatusId(pair[1], input.statusRegistry);
-    return ruleFrom === from && ruleTo === to;
-  });
-  return { allowed, hasRule: true, allowedTransitions: matched.allowed_transitions };
-}
-function describeAllowedTransitions(allowedTransitions) {
-  if (allowedTransitions.length === 0) {
-    return "(no transitions allowed)";
-  }
-  return allowedTransitions.map((pair) => `${pair[0]} -> ${pair[1]}`).join(", ");
-}
+  resolveTypeDefinition,
+  resolveTypeName,
+  stableValueEquals,
+  validateTypeOptions
+} from "./chunk-RVUALSJF.js";
 
 // dist/cli/commands/update.js
 !(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] = "d2ccc413-72f7-567b-b533-3bfa002cf260");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "17376741-e64e-5a26-9c7e-3f23fee80095");
   } catch (e2) {
   }
 })();
 var UPDATE_UNSET_FIELD_DEFINITIONS = [
-  { canonical: "tags", aliases: ["tags"], optionKey: "tags", frontMatterKey: "tags" },
+  ...COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
   { canonical: "close-reason", aliases: ["close_reason", "close-reason"], optionKey: "closeReason", frontMatterKey: "close_reason" },
-  { canonical: "deadline", aliases: ["deadline"], optionKey: "deadline", frontMatterKey: "deadline" },
-  {
-    canonical: "estimate",
-    aliases: ["estimate", "estimated_minutes", "estimated-minutes"],
-    optionKey: "estimatedMinutes",
-    frontMatterKey: "estimated_minutes"
-  },
-  {
-    canonical: "acceptance-criteria",
-    aliases: ["acceptance_criteria", "acceptance-criteria", "ac"],
-    optionKey: "acceptanceCriteria",
-    frontMatterKey: "acceptance_criteria"
-  },
-  {
-    canonical: "definition-of-ready",
-    aliases: ["definition_of_ready", "definition-of-ready"],
-    optionKey: "definitionOfReady",
-    frontMatterKey: "definition_of_ready"
-  },
-  { canonical: "order", aliases: ["order", "rank"], optionKey: "order", frontMatterKey: "order" },
-  { canonical: "goal", aliases: ["goal"], optionKey: "goal", frontMatterKey: "goal" },
-  { canonical: "objective", aliases: ["objective"], optionKey: "objective", frontMatterKey: "objective" },
-  { canonical: "value", aliases: ["value"], optionKey: "value", frontMatterKey: "value" },
-  { canonical: "impact", aliases: ["impact"], optionKey: "impact", frontMatterKey: "impact" },
-  { canonical: "outcome", aliases: ["outcome"], optionKey: "outcome", frontMatterKey: "outcome" },
-  { canonical: "why-now", aliases: ["why_now", "why-now"], optionKey: "whyNow", frontMatterKey: "why_now" },
-  { canonical: "assignee", aliases: ["assignee"], optionKey: "assignee", frontMatterKey: "assignee" },
-  { canonical: "parent", aliases: ["parent"], optionKey: "parent", frontMatterKey: "parent" },
-  { canonical: "reviewer", aliases: ["reviewer"], optionKey: "reviewer", frontMatterKey: "reviewer" },
-  { canonical: "risk", aliases: ["risk"], optionKey: "risk", frontMatterKey: "risk" },
-  { canonical: "confidence", aliases: ["confidence"], optionKey: "confidence", frontMatterKey: "confidence" },
-  { canonical: "sprint", aliases: ["sprint"], optionKey: "sprint", frontMatterKey: "sprint" },
-  { canonical: "release", aliases: ["release"], optionKey: "release", frontMatterKey: "release" },
-  {
-    canonical: "blocked-by",
-    aliases: ["blocked_by", "blocked-by"],
-    optionKey: "blockedBy",
-    frontMatterKey: "blocked_by"
-  },
-  {
-    canonical: "blocked-reason",
-    aliases: ["blocked_reason", "blocked-reason"],
-    optionKey: "blockedReason",
-    frontMatterKey: "blocked_reason"
-  },
-  {
-    canonical: "unblock-note",
-    aliases: ["unblock_note", "unblock-note"],
-    optionKey: "unblockNote",
-    frontMatterKey: "unblock_note"
-  },
-  { canonical: "reporter", aliases: ["reporter"], optionKey: "reporter", frontMatterKey: "reporter" },
-  { canonical: "severity", aliases: ["severity"], optionKey: "severity", frontMatterKey: "severity" },
-  {
-    canonical: "environment",
-    aliases: ["environment"],
-    optionKey: "environment",
-    frontMatterKey: "environment"
-  },
-  {
-    canonical: "repro-steps",
-    aliases: ["repro_steps", "repro-steps"],
-    optionKey: "reproSteps",
-    frontMatterKey: "repro_steps"
-  },
-  {
-    canonical: "resolution",
-    aliases: ["resolution"],
-    optionKey: "resolution",
-    frontMatterKey: "resolution"
-  },
-  {
-    canonical: "expected-result",
-    aliases: ["expected_result", "expected-result"],
-    optionKey: "expectedResult",
-    frontMatterKey: "expected_result"
-  },
-  {
-    canonical: "actual-result",
-    aliases: ["actual_result", "actual-result"],
-    optionKey: "actualResult",
-    frontMatterKey: "actual_result"
-  },
-  {
-    canonical: "affected-version",
-    aliases: ["affected_version", "affected-version"],
-    optionKey: "affectedVersion",
-    frontMatterKey: "affected_version"
-  },
-  {
-    canonical: "fixed-version",
-    aliases: ["fixed_version", "fixed-version"],
-    optionKey: "fixedVersion",
-    frontMatterKey: "fixed_version"
-  },
-  { canonical: "component", aliases: ["component"], optionKey: "component", frontMatterKey: "component" },
-  { canonical: "regression", aliases: ["regression"], optionKey: "regression", frontMatterKey: "regression" },
-  {
-    canonical: "customer-impact",
-    aliases: ["customer_impact", "customer-impact"],
-    optionKey: "customerImpact",
-    frontMatterKey: "customer_impact"
-  }
+  ...COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR,
+  ...COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR
 ];
 var UPDATE_UNSET_ALIAS_MAP = (() => {
   const map = /* @__PURE__ */ new Map();
@@ -315,12 +140,12 @@ function toAuthor(candidate, defaultAuthor) {
   return trimmed || "unknown";
 }
 var UPDATE_LEGACY_NONE_COLLECTION_NORMALIZERS = [
-  { optionKey: "dep", clearFlagKey: "clearDeps", valueFlag: "--dep", clearFlag: "--clear-deps", disableReplaceFlagKey: "replaceDeps" },
+  { optionKey: "dep", clearFlagKey: "clearDeps", valueFlag: "--dep", clearFlag: "--clear-deps", disableFlagKey: "replaceDeps" },
   { optionKey: "comment", clearFlagKey: "clearComments", valueFlag: "--comment", clearFlag: "--clear-comments" },
   { optionKey: "note", clearFlagKey: "clearNotes", valueFlag: "--note", clearFlag: "--clear-notes" },
   { optionKey: "learning", clearFlagKey: "clearLearnings", valueFlag: "--learning", clearFlag: "--clear-learnings" },
   { optionKey: "file", clearFlagKey: "clearFiles", valueFlag: "--file", clearFlag: "--clear-files" },
-  { optionKey: "test", clearFlagKey: "clearTests", valueFlag: "--test", clearFlag: "--clear-tests", disableReplaceFlagKey: "replaceTests" },
+  { optionKey: "test", clearFlagKey: "clearTests", valueFlag: "--test", clearFlag: "--clear-tests", disableFlagKey: "replaceTests" },
   { optionKey: "doc", clearFlagKey: "clearDocs", valueFlag: "--doc", clearFlag: "--clear-docs" },
   { optionKey: "reminder", clearFlagKey: "clearReminders", valueFlag: "--reminder", clearFlag: "--clear-reminders" },
   { optionKey: "event", clearFlagKey: "clearEvents", valueFlag: "--event", clearFlag: "--clear-events" },
@@ -348,52 +173,7 @@ function normalizeLegacyNoneUpdateOptions(options) {
     appendUnsetTarget(canonicalUnset);
     normalized[optionKey] = void 0;
   }
-  for (const definition of UPDATE_LEGACY_NONE_COLLECTION_NORMALIZERS) {
-    const entries = normalized[definition.optionKey];
-    if (!Array.isArray(entries) || entries.length === 0) {
-      continue;
-    }
-    const hasLegacy = entries.some((entry) => isLegacyNoneToken(entry));
-    if (!hasLegacy) {
-      continue;
-    }
-    const concreteEntries = entries.filter((entry) => !isLegacyNoneToken(entry));
-    if (concreteEntries.length > 0) {
-      throw new PmCliError(`Cannot mix legacy clear token "none"/"null" with concrete ${definition.valueFlag} entries. Use ${definition.clearFlag} to clear or provide explicit entries.`, EXIT_CODE.USAGE);
-    }
-    normalized[definition.optionKey] = void 0;
-    normalized[definition.clearFlagKey] = true;
-    if (definition.disableReplaceFlagKey) {
-      normalized[definition.disableReplaceFlagKey] = false;
-    }
-  }
-  return normalized;
-}
-function resolveRuntimeUnsetDefinition(token, runtimeFieldRegistry) {
-  if (!runtimeFieldRegistry) {
-    return void 0;
-  }
-  for (const definition of runtimeFieldRegistry.definitions) {
-    if (definition.allow_unset === false) {
-      continue;
-    }
-    const candidates = /* @__PURE__ */ new Set([
-      definition.key,
-      definition.metadata_key,
-      definition.cli_flag.replaceAll("-", "_"),
-      definition.cli_flag,
-      ...definition.cli_aliases.map((alias) => alias.replaceAll("-", "_")),
-      ...definition.cli_aliases
-    ]);
-    if (!candidates.has(token)) {
-      continue;
-    }
-    return {
-      optionKey: definition.key,
-      frontMatterKey: definition.metadata_key
-    };
-  }
-  return void 0;
+  return applyLegacyNoneCollectionNormalizers(normalized, UPDATE_LEGACY_NONE_COLLECTION_NORMALIZERS);
 }
 function parseUpdateUnsetTargets(raw, runtimeFieldRegistry, extensionFieldNames = []) {
   const frontMatterKeys = /* @__PURE__ */ new Set();
@@ -413,7 +193,7 @@ function parseUpdateUnsetTargets(raw, runtimeFieldRegistry, extensionFieldNames
       const normalizedFieldName = fieldName.toLowerCase();
       return normalizedFieldName === trimmed || normalizedFieldName.replaceAll("_", "-") === trimmed || normalizedFieldName.replaceAll("-", "_") === trimmed;
     });
-    const definition = UPDATE_UNSET_ALIAS_MAP.get(trimmed) ?? resolveRuntimeUnsetDefinition(trimmed, runtimeFieldRegistry) ?? (extensionFieldName ? { optionKey: "field", frontMatterKey: extensionFieldName } : void 0);
+    const definition = UPDATE_UNSET_ALIAS_MAP.get(trimmed) ?? resolveRuntimeUnsetFieldDefinition(trimmed, "update", runtimeFieldRegistry) ?? (extensionFieldName ? { optionKey: "field", frontMatterKey: extensionFieldName } : void 0);
     if (!definition) {
       throw new PmCliError(`Unsupported --unset field "${entry}". Supported fields: ${UPDATE_UNSET_SUPPORTED_CANONICAL_FIELDS}`, EXIT_CODE.USAGE);
     }
@@ -546,81 +326,31 @@ function enforceAllowAuditUpdateScope(id, options, clearFrontMatterKeys) {
     return;
   }
   const disallowedFlags = [];
-  if (options.status !== void 0) {
-    disallowedFlags.push("--status");
-  }
-  if (options.closeReason !== void 0) {
-    disallowedFlags.push("--close-reason");
-  }
-  if (options.assignee !== void 0) {
-    disallowedFlags.push("--assignee");
-  }
-  if (options.parent !== void 0) {
-    disallowedFlags.push("--parent");
-  }
-  if (options.blockedBy !== void 0) {
-    disallowedFlags.push("--blocked-by");
-  }
-  if (options.blockedReason !== void 0) {
-    disallowedFlags.push("--blocked-reason");
-  }
-  if (options.unblockNote !== void 0) {
-    disallowedFlags.push("--unblock-note");
-  }
-  if (options.dep !== void 0) {
-    disallowedFlags.push("--dep");
-  }
-  if (options.depRemove !== void 0) {
-    disallowedFlags.push("--dep-remove");
-  }
-  if (options.replaceDeps === true) {
-    disallowedFlags.push("--replace-deps");
-  }
-  if (options.replaceTests === true) {
-    disallowedFlags.push("--replace-tests");
-  }
-  if (options.note !== void 0) {
-    disallowedFlags.push("--note");
-  }
-  if (options.learning !== void 0) {
-    disallowedFlags.push("--learning");
-  }
-  if (options.test !== void 0) {
-    disallowedFlags.push("--test");
-  }
-  if (options.reminder !== void 0) {
-    disallowedFlags.push("--reminder");
-  }
-  if (options.event !== void 0) {
-    disallowedFlags.push("--event");
-  }
-  if (options.clearDeps === true) {
-    disallowedFlags.push("--clear-deps");
-  }
-  if (options.clearComments === true) {
-    disallowedFlags.push("--clear-comments");
-  }
-  if (options.clearNotes === true) {
-    disallowedFlags.push("--clear-notes");
-  }
-  if (options.clearLearnings === true) {
-    disallowedFlags.push("--clear-learnings");
-  }
-  if (options.clearFiles === true) {
-    disallowedFlags.push("--clear-files");
-  }
-  if (options.clearTests === true) {
-    disallowedFlags.push("--clear-tests");
-  }
-  if (options.clearDocs === true) {
-    disallowedFlags.push("--clear-docs");
-  }
-  if (options.clearReminders === true) {
-    disallowedFlags.push("--clear-reminders");
-  }
-  if (options.clearEvents === true) {
-    disallowedFlags.push("--clear-events");
-  }
+  pushIf(options.status !== void 0, "--status", disallowedFlags);
+  pushIf(options.closeReason !== void 0, "--close-reason", disallowedFlags);
+  pushIf(options.assignee !== void 0, "--assignee", disallowedFlags);
+  pushIf(options.parent !== void 0, "--parent", disallowedFlags);
+  pushIf(options.blockedBy !== void 0, "--blocked-by", disallowedFlags);
+  pushIf(options.blockedReason !== void 0, "--blocked-reason", disallowedFlags);
+  pushIf(options.unblockNote !== void 0, "--unblock-note", disallowedFlags);
+  pushIf(options.dep !== void 0, "--dep", disallowedFlags);
+  pushIf(options.depRemove !== void 0, "--dep-remove", disallowedFlags);
+  pushIf(options.replaceDeps === true, "--replace-deps", disallowedFlags);
+  pushIf(options.replaceTests === true, "--replace-tests", disallowedFlags);
+  pushIf(options.note !== void 0, "--note", disallowedFlags);
+  pushIf(options.learning !== void 0, "--learning", disallowedFlags);
+  pushIf(options.test !== void 0, "--test", disallowedFlags);
+  pushIf(options.reminder !== void 0, "--reminder", disallowedFlags);
+  pushIf(options.event !== void 0, "--event", disallowedFlags);
+  pushIf(options.clearDeps === true, "--clear-deps", disallowedFlags);
+  pushIf(options.clearComments === true, "--clear-comments", disallowedFlags);
+  pushIf(options.clearNotes === true, "--clear-notes", disallowedFlags);
+  pushIf(options.clearLearnings === true, "--clear-learnings", disallowedFlags);
+  pushIf(options.clearFiles === true, "--clear-files", disallowedFlags);
+  pushIf(options.clearTests === true, "--clear-tests", disallowedFlags);
+  pushIf(options.clearDocs === true, "--clear-docs", disallowedFlags);
+  pushIf(options.clearReminders === true, "--clear-reminders", disallowedFlags);
+  pushIf(options.clearEvents === true, "--clear-events", disallowedFlags);
   const disallowedUnset = [...clearFrontMatterKeys].filter((field) => AUDIT_UPDATE_DISALLOWED_UNSET_FRONT_MATTER_KEYS.has(field)).sort((left, right) => left.localeCompare(right)).map((field) => `--unset ${field.replaceAll("_", "-")}`);
   disallowedFlags.push(...disallowedUnset);
   if (disallowedFlags.length > 0) {
@@ -1799,11 +1529,11 @@ var _testOnlyUpdateCommand = {
   parseDependencyRemovals,
   parseUpdateUnsetTargets,
   reconcileBlockedByDependency,
-  resolveRuntimeUnsetDefinition
+  resolveRuntimeUnsetDefinition: (token, registry) => resolveRuntimeUnsetFieldDefinition(token, "update", registry)
 };
 
 export {
   runUpdate,
   _testOnlyUpdateCommand
 };
-//# sourceMappingURL=chunk-HBAEFWX3.js.map
+//# sourceMappingURL=chunk-NUHHPVVS.js.map