@unbrained/pm-cli 2026.5.29 → 2026.5.31

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

@@ -0,0 +1,632 @@
+import {
+  ITEM_TYPE_VALUES,
+  TYPE_TO_FOLDER,
+  normalizeItemTypeDefinition,
+  normalizeItemTypeStringList,
+  strictPolicyCommand
+} from "./chunk-LSXGH6NE.js";
+
+// dist/core/item/type-registry.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] = "3a95db0f-9c6e-5a39-bffe-30ff5e40da57");
+  } catch (e2) {
+  }
+})();
+var DEFAULT_REQUIRED_CREATE_FIELDS = [
+  "title",
+  "description",
+  "status",
+  "priority",
+  "tags",
+  "body",
+  "deadline",
+  "estimatedMinutes",
+  "acceptanceCriteria",
+  "author",
+  "message",
+  "assignee"
+];
+var DEFAULT_REQUIRED_CREATE_REPEATABLES = ["dep", "comment", "note", "learning", "file", "test", "doc"];
+var CREATE_COMMAND_OPTION_KEYS = [
+  "title",
+  "description",
+  "type",
+  "status",
+  "priority",
+  "tags",
+  "body",
+  "deadline",
+  "estimatedMinutes",
+  "acceptanceCriteria",
+  "definitionOfReady",
+  "order",
+  "goal",
+  "objective",
+  "value",
+  "impact",
+  "outcome",
+  "whyNow",
+  "author",
+  "message",
+  "assignee",
+  "parent",
+  "reviewer",
+  "risk",
+  "confidence",
+  "sprint",
+  "release",
+  "blockedBy",
+  "blockedReason",
+  "unblockNote",
+  "reporter",
+  "severity",
+  "environment",
+  "reproSteps",
+  "resolution",
+  "expectedResult",
+  "actualResult",
+  "affectedVersion",
+  "fixedVersion",
+  "component",
+  "regression",
+  "customerImpact",
+  "dep",
+  "comment",
+  "note",
+  "learning",
+  "file",
+  "test",
+  "doc",
+  "reminder",
+  "event",
+  "typeOption"
+];
+var UPDATE_COMMAND_OPTION_KEYS = [
+  "title",
+  "description",
+  "body",
+  "status",
+  "closeReason",
+  "priority",
+  "type",
+  "tags",
+  "deadline",
+  "estimatedMinutes",
+  "acceptanceCriteria",
+  "definitionOfReady",
+  "order",
+  "goal",
+  "objective",
+  "value",
+  "impact",
+  "outcome",
+  "whyNow",
+  "author",
+  "message",
+  "assignee",
+  "parent",
+  "reviewer",
+  "risk",
+  "confidence",
+  "sprint",
+  "release",
+  "blockedBy",
+  "blockedReason",
+  "unblockNote",
+  "reporter",
+  "severity",
+  "environment",
+  "reproSteps",
+  "resolution",
+  "expectedResult",
+  "actualResult",
+  "affectedVersion",
+  "fixedVersion",
+  "component",
+  "regression",
+  "customerImpact",
+  "comment",
+  "note",
+  "learning",
+  "file",
+  "test",
+  "doc",
+  "reminder",
+  "event",
+  "typeOption",
+  "allowAuditUpdate",
+  "force"
+];
+var SHARED_COMMAND_OPTION_ALIASES = {
+  "close-reason": "closeReason",
+  close_reason: "closeReason",
+  "estimated-minutes": "estimatedMinutes",
+  estimated_minutes: "estimatedMinutes",
+  estimate: "estimatedMinutes",
+  "acceptance-criteria": "acceptanceCriteria",
+  acceptance_criteria: "acceptanceCriteria",
+  ac: "acceptanceCriteria",
+  "definition-of-ready": "definitionOfReady",
+  definition_of_ready: "definitionOfReady",
+  rank: "order",
+  "why-now": "whyNow",
+  why_now: "whyNow",
+  "blocked-by": "blockedBy",
+  blocked_by: "blockedBy",
+  "blocked-reason": "blockedReason",
+  blocked_reason: "blockedReason",
+  "unblock-note": "unblockNote",
+  unblock_note: "unblockNote",
+  "repro-steps": "reproSteps",
+  repro_steps: "reproSteps",
+  "expected-result": "expectedResult",
+  expected_result: "expectedResult",
+  "actual-result": "actualResult",
+  actual_result: "actualResult",
+  "affected-version": "affectedVersion",
+  affected_version: "affectedVersion",
+  "fixed-version": "fixedVersion",
+  fixed_version: "fixedVersion",
+  "customer-impact": "customerImpact",
+  customer_impact: "customerImpact",
+  "type-option": "typeOption",
+  type_option: "typeOption",
+  type_options: "typeOption"
+};
+var CREATE_COMMAND_OPTION_ALIASES = {
+  ...SHARED_COMMAND_OPTION_ALIASES
+};
+var UPDATE_COMMAND_OPTION_ALIASES = {
+  ...SHARED_COMMAND_OPTION_ALIASES,
+  "allow-audit-update": "allowAuditUpdate",
+  allow_audit_update: "allowAuditUpdate"
+};
+var CREATE_COMMAND_OPTION_FLAG_LABELS = {
+  title: "--title",
+  description: "--description",
+  type: "--type",
+  status: "--status",
+  priority: "--priority",
+  tags: "--tags",
+  body: "--body",
+  deadline: "--deadline",
+  estimatedMinutes: "--estimate/--estimated-minutes",
+  acceptanceCriteria: "--acceptance-criteria/--ac",
+  definitionOfReady: "--definition-of-ready",
+  order: "--order/--rank",
+  goal: "--goal",
+  objective: "--objective",
+  value: "--value",
+  impact: "--impact",
+  outcome: "--outcome",
+  whyNow: "--why-now",
+  author: "--author",
+  message: "--message",
+  assignee: "--assignee",
+  parent: "--parent",
+  reviewer: "--reviewer",
+  risk: "--risk",
+  confidence: "--confidence",
+  sprint: "--sprint",
+  release: "--release",
+  blockedBy: "--blocked-by",
+  blockedReason: "--blocked-reason",
+  unblockNote: "--unblock-note",
+  reporter: "--reporter",
+  severity: "--severity",
+  environment: "--environment",
+  reproSteps: "--repro-steps",
+  resolution: "--resolution",
+  expectedResult: "--expected-result",
+  actualResult: "--actual-result",
+  affectedVersion: "--affected-version",
+  fixedVersion: "--fixed-version",
+  component: "--component",
+  regression: "--regression",
+  customerImpact: "--customer-impact",
+  dep: "--dep",
+  comment: "--comment",
+  note: "--note",
+  learning: "--learning",
+  file: "--file",
+  test: "--test",
+  doc: "--doc",
+  reminder: "--reminder",
+  event: "--event",
+  typeOption: "--type-option"
+};
+var UPDATE_COMMAND_OPTION_FLAG_LABELS = {
+  title: "--title",
+  description: "--description",
+  body: "--body",
+  status: "--status",
+  closeReason: "--close-reason",
+  priority: "--priority",
+  type: "--type",
+  tags: "--tags",
+  deadline: "--deadline",
+  estimatedMinutes: "--estimate/--estimated-minutes",
+  acceptanceCriteria: "--acceptance-criteria/--ac",
+  definitionOfReady: "--definition-of-ready",
+  order: "--order/--rank",
+  goal: "--goal",
+  objective: "--objective",
+  value: "--value",
+  impact: "--impact",
+  outcome: "--outcome",
+  whyNow: "--why-now",
+  assignee: "--assignee",
+  parent: "--parent",
+  reviewer: "--reviewer",
+  risk: "--risk",
+  confidence: "--confidence",
+  sprint: "--sprint",
+  release: "--release",
+  blockedBy: "--blocked-by",
+  blockedReason: "--blocked-reason",
+  unblockNote: "--unblock-note",
+  reporter: "--reporter",
+  severity: "--severity",
+  environment: "--environment",
+  reproSteps: "--repro-steps",
+  resolution: "--resolution",
+  expectedResult: "--expected-result",
+  actualResult: "--actual-result",
+  affectedVersion: "--affected-version",
+  fixedVersion: "--fixed-version",
+  component: "--component",
+  regression: "--regression",
+  customerImpact: "--customer-impact",
+  comment: "--comment",
+  note: "--note",
+  learning: "--learning",
+  file: "--file",
+  test: "--test",
+  doc: "--doc",
+  reminder: "--reminder",
+  event: "--event",
+  typeOption: "--type-option",
+  allowAuditUpdate: "--allow-audit-update",
+  author: "--author",
+  message: "--message",
+  force: "--force"
+};
+function normalizeCommandOptionToken(value) {
+  return value.trim().replace(/^--+/, "").toLowerCase();
+}
+function commandOptionKeys(command) {
+  return command === "create" ? CREATE_COMMAND_OPTION_KEYS : UPDATE_COMMAND_OPTION_KEYS;
+}
+function commandOptionAliases(command) {
+  return command === "create" ? CREATE_COMMAND_OPTION_ALIASES : UPDATE_COMMAND_OPTION_ALIASES;
+}
+function canonicalizeCommandOptionKey(command, rawOption) {
+  const normalizedToken = normalizeCommandOptionToken(rawOption);
+  if (normalizedToken.length === 0) {
+    return void 0;
+  }
+  const aliased = commandOptionAliases(command)[normalizedToken];
+  if (aliased) {
+    return aliased;
+  }
+  return commandOptionKeys(command).find((candidate) => candidate.toLowerCase() === normalizedToken);
+}
+function commandOptionFlagLabel(command, optionKey) {
+  const labels = command === "create" ? CREATE_COMMAND_OPTION_FLAG_LABELS : UPDATE_COMMAND_OPTION_FLAG_LABELS;
+  return labels[optionKey] ?? `--${optionKey.replace(/([A-Z])/g, "-$1").toLowerCase()}`;
+}
+function toDefaultFolder(name) {
+  const normalized = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (normalized.length === 0) {
+    return "items";
+  }
+  return normalized.endsWith("s") ? normalized : `${normalized}s`;
+}
+function normalizeTypeDefinition(definition) {
+  return normalizeItemTypeDefinition(definition, { resolvePolicyCommand: strictPolicyCommand });
+}
+function coerceTypeDefinitionFromUnknown(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return null;
+  }
+  const record = raw;
+  const name = typeof record.name === "string" ? record.name : "";
+  if (name.trim().length === 0) {
+    return null;
+  }
+  const folder = typeof record.folder === "string" ? record.folder : void 0;
+  const description = typeof record.description === "string" ? record.description : void 0;
+  const defaultStatus = typeof record.default_status === "string" ? record.default_status : void 0;
+  const aliases = Array.isArray(record.aliases) ? record.aliases.filter((value) => typeof value === "string") : void 0;
+  const requiredCreateFields = Array.isArray(record.required_create_fields) ? record.required_create_fields.filter((value) => typeof value === "string") : void 0;
+  const requiredCreateRepeatables = Array.isArray(record.required_create_repeatables) ? record.required_create_repeatables.filter((value) => typeof value === "string") : void 0;
+  let options;
+  if (Array.isArray(record.options)) {
+    options = [];
+    for (const entry of record.options) {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        continue;
+      }
+      const optionRecord = entry;
+      if (typeof optionRecord.key !== "string") {
+        continue;
+      }
+      options.push({
+        key: optionRecord.key,
+        values: Array.isArray(optionRecord.values) ? optionRecord.values.filter((value) => typeof value === "string") : [],
+        required: optionRecord.required === void 0 ? void 0 : Boolean(optionRecord.required),
+        aliases: Array.isArray(optionRecord.aliases) ? optionRecord.aliases.filter((value) => typeof value === "string") : void 0,
+        description: typeof optionRecord.description === "string" ? optionRecord.description : void 0
+      });
+    }
+  }
+  let commandOptionPolicies;
+  if (Array.isArray(record.command_option_policies)) {
+    commandOptionPolicies = [];
+    for (const entry of record.command_option_policies) {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        continue;
+      }
+      const policyRecord = entry;
+      if (typeof policyRecord.command !== "string" || typeof policyRecord.option !== "string") {
+        continue;
+      }
+      const normalizedCommand = policyRecord.command.trim().toLowerCase();
+      if (normalizedCommand !== "create" && normalizedCommand !== "update") {
+        continue;
+      }
+      commandOptionPolicies.push({
+        command: normalizedCommand,
+        option: policyRecord.option,
+        required: policyRecord.required === void 0 ? void 0 : Boolean(policyRecord.required),
+        visible: policyRecord.visible === void 0 ? void 0 : Boolean(policyRecord.visible),
+        enabled: policyRecord.enabled === void 0 ? void 0 : Boolean(policyRecord.enabled)
+      });
+    }
+  }
+  return {
+    name,
+    description,
+    default_status: defaultStatus,
+    folder,
+    aliases,
+    required_create_fields: requiredCreateFields,
+    required_create_repeatables: requiredCreateRepeatables,
+    options,
+    command_option_policies: commandOptionPolicies
+  };
+}
+function applyTypeDefinitions(source, target, preserveBuiltinDefaults) {
+  for (const rawDefinition of source) {
+    const normalizedDefinition = normalizeTypeDefinition(rawDefinition);
+    if (!normalizedDefinition) {
+      continue;
+    }
+    const lowerName = normalizedDefinition.name.toLowerCase();
+    const existing = target.get(lowerName);
+    const keepName = existing?.name ?? normalizedDefinition.name;
+    const folder = normalizedDefinition.folder ?? existing?.folder ?? toDefaultFolder(keepName);
+    const aliases = normalizeItemTypeStringList([
+      ...existing?.aliases ?? [],
+      ...normalizedDefinition.aliases ?? []
+    ]);
+    const requiredCreateFields = normalizedDefinition.required_create_fields ? normalizeItemTypeStringList(normalizedDefinition.required_create_fields) : existing?.required_create_fields ?? (preserveBuiltinDefaults ? [...DEFAULT_REQUIRED_CREATE_FIELDS] : []);
+    const requiredCreateRepeatables = normalizedDefinition.required_create_repeatables ? normalizeItemTypeStringList(normalizedDefinition.required_create_repeatables) : existing?.required_create_repeatables ?? (preserveBuiltinDefaults ? [...DEFAULT_REQUIRED_CREATE_REPEATABLES] : []);
+    const options = normalizedDefinition.options ? normalizedDefinition.options : existing?.options ? [...existing.options] : [];
+    const commandOptionPolicies = normalizedDefinition.command_option_policies ? normalizedDefinition.command_option_policies : existing?.command_option_policies ? [...existing.command_option_policies] : [];
+    const defaultStatus = normalizedDefinition.default_status ?? existing?.default_status;
+    const description = normalizedDefinition.description ?? existing?.description;
+    target.set(lowerName, {
+      name: keepName,
+      ...description ? { description } : {},
+      ...defaultStatus ? { default_status: defaultStatus } : {},
+      folder,
+      aliases,
+      required_create_fields: requiredCreateFields,
+      required_create_repeatables: requiredCreateRepeatables,
+      options,
+      command_option_policies: commandOptionPolicies
+    });
+  }
+}
+function collectExtensionTypeDefinitions(registrations) {
+  if (!registrations) {
+    return [];
+  }
+  const definitions = [];
+  for (const registration of registrations.item_types ?? []) {
+    const typeDefinitionsRaw = registration.types;
+    if (!Array.isArray(typeDefinitionsRaw)) {
+      continue;
+    }
+    for (const rawDefinition of typeDefinitionsRaw) {
+      const normalized = coerceTypeDefinitionFromUnknown(rawDefinition);
+      if (normalized) {
+        definitions.push(normalized);
+      }
+    }
+  }
+  return definitions;
+}
+function resolveItemTypeRegistry(settings, extensionRegistrations = null) {
+  const byLowerName = /* @__PURE__ */ new Map();
+  for (const builtin of ITEM_TYPE_VALUES) {
+    byLowerName.set(builtin.toLowerCase(), {
+      name: builtin,
+      folder: TYPE_TO_FOLDER[builtin],
+      aliases: [],
+      required_create_fields: [...DEFAULT_REQUIRED_CREATE_FIELDS],
+      required_create_repeatables: [...DEFAULT_REQUIRED_CREATE_REPEATABLES],
+      options: [],
+      command_option_policies: []
+    });
+  }
+  applyTypeDefinitions(settings.item_types?.definitions ?? [], byLowerName, false);
+  applyTypeDefinitions(collectExtensionTypeDefinitions(extensionRegistrations), byLowerName, false);
+  const definitions = [...byLowerName.values()].sort((left, right) => left.name.localeCompare(right.name));
+  const byType = {};
+  const aliasToType = {};
+  const typeToFolder = {};
+  for (const definition of definitions) {
+    byType[definition.name] = definition;
+    typeToFolder[definition.name] = definition.folder;
+    aliasToType[definition.name.toLowerCase()] = definition.name;
+    for (const alias of definition.aliases) {
+      aliasToType[alias.toLowerCase()] = definition.name;
+    }
+  }
+  const folders = [...new Set(definitions.map((definition) => definition.folder))].sort((left, right) => left.localeCompare(right));
+  return {
+    types: definitions.map((definition) => definition.name),
+    folders,
+    type_to_folder: typeToFolder,
+    by_type: byType,
+    alias_to_type: aliasToType
+  };
+}
+function resolveTypeName(rawType, registry) {
+  if (rawType === void 0) {
+    return void 0;
+  }
+  return registry.alias_to_type[rawType.trim().toLowerCase()];
+}
+function resolveTypeDefinition(typeName, registry) {
+  const resolvedName = resolveTypeName(typeName, registry);
+  if (!resolvedName) {
+    return void 0;
+  }
+  return registry.by_type[resolvedName];
+}
+function resolveCommandOptionPolicyState(typeDefinition, command, baseRequiredOptions) {
+  const errors = [];
+  const required = /* @__PURE__ */ new Set();
+  const hidden = /* @__PURE__ */ new Set();
+  const disabled = /* @__PURE__ */ new Set();
+  for (const rawBase of baseRequiredOptions) {
+    const canonical = canonicalizeCommandOptionKey(command, rawBase);
+    if (!canonical) {
+      errors.push(`Unsupported base required option "${rawBase}" for command "${command}" on type "${typeDefinition.name}"`);
+      continue;
+    }
+    required.add(canonical);
+  }
+  for (const policy of typeDefinition.command_option_policies) {
+    if (policy.command !== command) {
+      continue;
+    }
+    const canonical = canonicalizeCommandOptionKey(command, policy.option);
+    if (!canonical) {
+      errors.push(`Unsupported command_option_policies option "${policy.option}" for command "${command}" on type "${typeDefinition.name}"`);
+      continue;
+    }
+    if (policy.required !== void 0) {
+      if (policy.required) {
+        required.add(canonical);
+      } else {
+        required.delete(canonical);
+      }
+    }
+    if (policy.visible !== void 0) {
+      if (policy.visible) {
+        hidden.delete(canonical);
+      } else {
+        hidden.add(canonical);
+      }
+    }
+    if (policy.enabled !== void 0) {
+      if (policy.enabled) {
+        disabled.delete(canonical);
+      } else {
+        disabled.add(canonical);
+      }
+    }
+  }
+  for (const option of required) {
+    if (disabled.has(option)) {
+      errors.push(`Option "${option}" cannot be both required and disabled for command "${command}" on type "${typeDefinition.name}"`);
+    }
+  }
+  return {
+    required: [...required],
+    hidden: [...hidden].sort((left, right) => left.localeCompare(right)),
+    disabled: [...disabled].sort((left, right) => left.localeCompare(right)),
+    errors
+  };
+}
+function validateTypeOptions(typeName, rawTypeOptions, registry) {
+  const typeDefinition = resolveTypeDefinition(typeName, registry);
+  if (!typeDefinition) {
+    return {
+      normalized: void 0,
+      errors: [`Unknown type "${typeName}"`]
+    };
+  }
+  const errors = [];
+  const optionByAlias = /* @__PURE__ */ new Map();
+  for (const option of typeDefinition.options) {
+    optionByAlias.set(option.key.toLowerCase(), option);
+    for (const alias of option.aliases ?? []) {
+      optionByAlias.set(alias.toLowerCase(), option);
+    }
+  }
+  const normalized = {};
+  for (const [rawKey, rawValue] of Object.entries(rawTypeOptions ?? {})) {
+    const trimmedKey = rawKey.trim();
+    const trimmedValue = rawValue.trim();
+    if (trimmedKey.length === 0) {
+      errors.push("type option keys must not be empty");
+      continue;
+    }
+    if (trimmedValue.length === 0) {
+      errors.push(`type option "${trimmedKey}" must not be empty`);
+      continue;
+    }
+    const optionDefinition = optionByAlias.get(trimmedKey.toLowerCase());
+    if (!optionDefinition) {
+      const allowed = typeDefinition.options.map((option) => option.key).join(", ");
+      errors.push(typeDefinition.options.length > 0 ? `Unknown type option "${trimmedKey}" for type "${typeDefinition.name}". Allowed: ${allowed}` : `Type "${typeDefinition.name}" does not define any configurable type options`);
+      continue;
+    }
+    const allowedValues = optionDefinition.values;
+    let resolvedValue = trimmedValue;
+    if (allowedValues.length > 0) {
+      const valueLookup = new Map(allowedValues.map((value) => [value.toLowerCase(), value]));
+      const canonical = valueLookup.get(trimmedValue.toLowerCase());
+      if (!canonical) {
+        errors.push(`Invalid value "${trimmedValue}" for type option "${optionDefinition.key}". Allowed: ${allowedValues.join(", ")}`);
+        continue;
+      }
+      resolvedValue = canonical;
+    }
+    normalized[optionDefinition.key] = resolvedValue;
+  }
+  for (const option of typeDefinition.options) {
+    if (option.required && !(option.key in normalized)) {
+      errors.push(`Missing required type option "${option.key}" for type "${typeDefinition.name}"`);
+    }
+  }
+  const sortedKeys = Object.keys(normalized).sort((left, right) => left.localeCompare(right));
+  if (sortedKeys.length === 0) {
+    return {
+      normalized: void 0,
+      errors
+    };
+  }
+  return {
+    normalized: Object.fromEntries(sortedKeys.map((key) => [key, normalized[key]])),
+    errors
+  };
+}
+
+export {
+  canonicalizeCommandOptionKey,
+  commandOptionFlagLabel,
+  resolveItemTypeRegistry,
+  resolveTypeName,
+  resolveTypeDefinition,
+  resolveCommandOptionPolicyState,
+  validateTypeOptions
+};
+//# sourceMappingURL=chunk-WDPXDQFG.js.map