@unbrained/pm-cli 2026.6.24 → 2026.7.1

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

@@ -1,657 +0,0 @@
-import {
-  ITEM_TYPE_VALUES,
-  TYPE_TO_FOLDER,
-  normalizeItemTypeDefinition,
-  normalizeItemTypeStringList,
-  strictPolicyCommand
-} from "./chunk-EYPINTFR.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] = "297c9e93-e665-5a35-8315-4b499f702563");
-  } 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",
-  "field"
-];
-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",
-  "field",
-  "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 = toSlugToken(name);
-  if (normalized.length === 0) {
-    return "items";
-  }
-  return normalized.endsWith("s") ? normalized : `${normalized}s`;
-}
-function toSlugToken(value) {
-  const trimmed = value.trim().toLowerCase();
-  let slug = "";
-  let pendingDash = false;
-  for (const character of trimmed) {
-    const code = character.charCodeAt(0);
-    const isAlpha = code >= 97 && code <= 122;
-    const isDigit = code >= 48 && code <= 57;
-    if (isAlpha || isDigit) {
-      if (pendingDash && slug.length > 0) {
-        slug += "-";
-      }
-      slug += character;
-      pendingDash = false;
-      continue;
-    }
-    if (slug.length > 0) {
-      pendingDash = true;
-    }
-  }
-  return slug;
-}
-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) {
-  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 ?? [];
-    const requiredCreateRepeatables = normalizedDefinition.required_create_repeatables ? normalizeItemTypeStringList(normalizedDefinition.required_create_repeatables) : existing?.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);
-  applyTypeDefinitions(collectExtensionTypeDefinitions(extensionRegistrations), byLowerName);
-  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,
-  toDefaultFolder,
-  resolveItemTypeRegistry,
-  resolveTypeName,
-  resolveTypeDefinition,
-  resolveCommandOptionPolicyState,
-  validateTypeOptions
-};
-//# sourceMappingURL=chunk-ZV7IQ23N.js.map