@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,112 @@
+import {
+  normalizeItemId
+} from "./chunk-NMP5I3I5.js";
+import {
+  PmCliError
+} from "./chunk-SHQY2IDC.js";
+import {
+  EXIT_CODE
+} from "./chunk-LK6XLOGP.js";
+
+// dist/core/item/parent-reference-policy.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] = "a8ef1b95-7cd2-572b-b1c3-9c782616bdf3");
+  } catch (e2) {
+  }
+})();
+var PLACEHOLDER_REFERENCE_TOKENS = /* @__PURE__ */ new Set(["none", "null", "undefined"]);
+function normalizeParentReferencePolicy(value) {
+  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
+  if (normalized === "warn" || normalized === "strict_error") {
+    return normalized;
+  }
+  if (normalized === "strict") {
+    return "strict_error";
+  }
+  throw new PmCliError("Config set parent-reference-policy requires --policy with one of: warn, strict_error (alias: strict)", EXIT_CODE.USAGE);
+}
+function normalizeParentReferenceValue(rawValue) {
+  if (typeof rawValue !== "string") {
+    throw new PmCliError("--parent must be a string. Use --unset parent to clear this field.", EXIT_CODE.USAGE);
+  }
+  const value = rawValue.trim();
+  if (value.length === 0) {
+    throw new PmCliError("--parent must not be empty. Use --parent none to unset.", EXIT_CODE.USAGE);
+  }
+  if (isPlaceholderReferenceToken(value)) {
+    throw new PmCliError(`--parent must not use placeholder token "${value}". Use --unset parent to clear this field.`, EXIT_CODE.USAGE);
+  }
+  return value;
+}
+function isPlaceholderReferenceToken(value) {
+  return PLACEHOLDER_REFERENCE_TOKENS.has(value.trim().toLowerCase());
+}
+function validateMissingParentReference(parentId, policy) {
+  if (policy === "strict_error") {
+    throw new PmCliError(`Parent item "${parentId}" was not found. Create it first or use --parent none.`, EXIT_CODE.USAGE);
+  }
+  return {
+    warnings: [`validation_warning:parent_reference_missing:${parentId}`]
+  };
+}
+function assertParentReferenceIsNotSelf(itemId, parentId, prefix) {
+  const normalizedItemId = normalizeItemId(itemId, prefix);
+  const normalizedParentId = normalizeItemId(parentId, prefix);
+  if (normalizedItemId !== normalizedParentId) {
+    return;
+  }
+  const normalizationDetail = parentId !== normalizedParentId || itemId !== normalizedItemId ? ` (normalized from parent "${parentId}" and item "${itemId}")` : "";
+  throw new PmCliError(`Parent item "${normalizedParentId}" cannot be the same as item "${normalizedItemId}"${normalizationDetail}. Use --unset parent to clear this field.`, EXIT_CODE.USAGE);
+}
+
+// dist/core/item/sprint-release-format.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] = "3865b1aa-2d38-5d91-af30-f31cc99f453d");
+  } catch (e2) {
+  }
+})();
+var SPRINT_RELEASE_VALUE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+var SPRINT_RELEASE_MAX_LENGTH = 64;
+function normalizeSprintReleaseFormatPolicy(value) {
+  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
+  if (normalized === "warn" || normalized === "strict_error") {
+    return normalized;
+  }
+  if (normalized === "strict") {
+    return "strict_error";
+  }
+  throw new PmCliError("Config set sprint-release-format-policy requires --policy with one of: warn, strict_error (alias: strict)", EXIT_CODE.USAGE);
+}
+function validateSprintOrReleaseValue(field, rawValue, policy) {
+  const value = rawValue.trim();
+  if (value.length === 0) {
+    throw new PmCliError(`--${field} must not be empty. Use --${field} none to unset.`, EXIT_CODE.USAGE);
+  }
+  const isValid = value.length <= SPRINT_RELEASE_MAX_LENGTH && SPRINT_RELEASE_VALUE_PATTERN.test(value);
+  if (isValid) {
+    return { value, warnings: [] };
+  }
+  const guidance = "Expected 1-64 characters matching [A-Za-z0-9][A-Za-z0-9._/-]* (no spaces).";
+  if (policy === "strict_error") {
+    throw new PmCliError(`Invalid --${field} value "${value}". ${guidance}`, EXIT_CODE.USAGE);
+  }
+  return {
+    value,
+    warnings: [`validation_warning:${field}_format:${value}`]
+  };
+}
+
+export {
+  normalizeParentReferencePolicy,
+  normalizeParentReferenceValue,
+  isPlaceholderReferenceToken,
+  validateMissingParentReference,
+  assertParentReferenceIsNotSelf,
+  normalizeSprintReleaseFormatPolicy,
+  validateSprintOrReleaseValue
+};
+//# sourceMappingURL=chunk-ALFPSEWO.js.map

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

@@ -0,0 +1,361 @@
+import {
+  PmCliError
+} from "./chunk-SHQY2IDC.js";
+import {
+  EXIT_CODE
+} from "./chunk-LK6XLOGP.js";
+
+// dist/core/item/parse.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] = "ce7f866a-e3ab-5814-aa07-011ecc34fd0e");
+  } catch (e2) {
+  }
+})();
+var STDIN_TOKEN = "-";
+var CONTINUABLE_VALUE_KEYS = /* @__PURE__ */ new Set([
+  "actual_result",
+  "body",
+  "cmd",
+  "command",
+  "customer_impact",
+  "description",
+  "environment",
+  "expected_result",
+  "impact",
+  "location",
+  "message",
+  "note",
+  "outcome",
+  "repro_steps",
+  "resolution",
+  "text",
+  "title",
+  "unblock_note",
+  "value",
+  "why_now"
+]);
+function parseTags(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    return [];
+  }
+  const source = coerceJsonTagArray(trimmed) ?? trimmed;
+  const tags = source.split(",").map((tag) => tag.trim()).filter(Boolean).map((tag) => tag.toLowerCase());
+  return Array.from(new Set(tags)).sort((a, b) => a.localeCompare(b));
+}
+function collectTagFlagValues(values) {
+  if (!Array.isArray(values) || values.length === 0) {
+    return [];
+  }
+  const collected = [];
+  for (const raw of values) {
+    if (typeof raw !== "string") {
+      continue;
+    }
+    for (const tag of parseTags(raw)) {
+      collected.push(tag);
+    }
+  }
+  return Array.from(new Set(collected)).sort((a, b) => a.localeCompare(b));
+}
+function normalizeBaseTags(baseTags) {
+  if (!Array.isArray(baseTags)) {
+    return [];
+  }
+  return baseTags.filter((tag) => typeof tag === "string").map((tag) => tag.trim().toLowerCase()).filter(Boolean);
+}
+function mergeAdditiveTags(baseTags, add) {
+  const normalizedBase = normalizeBaseTags(baseTags);
+  if (!add || add.length === 0) {
+    return Array.from(new Set(normalizedBase)).sort((a, b) => a.localeCompare(b));
+  }
+  const merged = new Set(normalizedBase);
+  for (const tag of collectTagFlagValues(add)) {
+    merged.add(tag);
+  }
+  return Array.from(merged).sort((a, b) => a.localeCompare(b));
+}
+function applyTagRemovals(baseTags, remove) {
+  const normalizedBase = Array.from(new Set(normalizeBaseTags(baseTags))).sort((a, b) => a.localeCompare(b));
+  if (!remove || remove.length === 0) {
+    return normalizedBase;
+  }
+  const removeSet = new Set(collectTagFlagValues(remove));
+  if (removeSet.size === 0) {
+    return normalizedBase;
+  }
+  return normalizedBase.filter((tag) => !removeSet.has(tag));
+}
+function coerceJsonTagArray(trimmed) {
+  if (!trimmed.startsWith("[")) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  const parsedArray = parsed;
+  return parsedArray.map((entry) => typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean" ? String(entry).replace(/,/g, " ") : "").filter((entry) => entry.length > 0).join(",");
+}
+function normalizeLineEndings(value) {
+  return value.replace(/\r\n/g, "\n");
+}
+function stripCodeFenceEnvelope(value) {
+  const normalized = normalizeLineEndings(value).trim();
+  if (!normalized.startsWith("```")) {
+    return value;
+  }
+  const lines = normalized.split("\n");
+  if (lines.length < 2) {
+    return value;
+  }
+  if (lines.at(-1)?.trim() !== "```") {
+    return value;
+  }
+  return lines.slice(1, -1).join("\n");
+}
+function splitCsvSegments(raw) {
+  const segments = [];
+  let current = "";
+  let inQuotes = false;
+  let escaped = false;
+  for (const char of raw) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      current += char;
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      current += char;
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      segments.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) {
+    segments.push(current.trim());
+  }
+  return segments;
+}
+function unquoteValue(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1).replace(/\\"/g, '"');
+  }
+  return value;
+}
+function findKeyValueDelimiter(segment) {
+  const equalsIndex = segment.indexOf("=");
+  const colonIndex = segment.indexOf(":");
+  const hasEquals = equalsIndex > 0;
+  const hasColon = colonIndex > 0;
+  if (hasEquals && hasColon) {
+    return Math.min(equalsIndex, colonIndex);
+  }
+  if (hasEquals) {
+    return equalsIndex;
+  }
+  if (hasColon) {
+    return colonIndex;
+  }
+  return -1;
+}
+function buildOptionSpecificKvGuidance(raw, optionName) {
+  if (optionName === "--add" || optionName === "--add-glob") {
+    const looksLikePath = /[./\\]/.test(raw) || /\.[a-z]{1,6}$/i.test(raw.trim());
+    if (looksLikePath) {
+      return "For file/doc paths use: path=<file-path>[,scope=project|global]. The scope field is optional and defaults to project (example: path=src/api.ts or path=README.md,scope=project). ";
+    }
+  }
+  if (optionName !== "--event") {
+    return "";
+  }
+  const lowered = raw.toLowerCase();
+  const recurrenceHint = lowered.includes("recur_") || lowered.includes("recurrence") ? ' Recurrence list values must stay in one field and use "|" delimiters (for example recur_by_weekday=mon|wed or recur_by_month_day=1|15).' : "";
+  const weekdayAliasHint = lowered.includes("recur_byweekday") ? " Use recur_by_weekday (with underscores) for weekday recurrence filters." : "";
+  return `${recurrenceHint}${weekdayAliasHint}`;
+}
+function buildInvalidKvMessage(raw, optionName) {
+  const condensed = raw.replaceAll(/\s+/g, " ").trim();
+  const preview = condensed.length > 160 ? `${condensed.slice(0, 157)}...` : condensed;
+  const optionSpecificGuidance = buildOptionSpecificKvGuidance(raw, optionName);
+  return `Invalid ${optionName} value "${preview}". Expected key=value entries separated by commas. ` + optionSpecificGuidance + `Also accepts markdown-style key/value lines (for example "- path: README.md"). Use ${optionName} ${STDIN_TOKEN} to read piped stdin input.`;
+}
+function parseMarkdownKeyValueLines(raw) {
+  const normalized = stripCodeFenceEnvelope(raw).trim();
+  if (normalized.length === 0) {
+    return null;
+  }
+  if (!normalized.includes("\n") && !normalized.startsWith("-") && !normalized.startsWith("*") && !normalized.startsWith("+")) {
+    return null;
+  }
+  const result = {};
+  let activeKey;
+  const lines = normalizeLineEndings(normalized).split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  for (const line of lines) {
+    const match = line.match(/^(?:[-*+]\s+)?([a-zA-Z0-9_.-]+)\s*(=|:)\s*(.*)$/);
+    if (match) {
+      const key = match[1].trim();
+      result[key] = unquoteValue(match[3].trim());
+      activeKey = key;
+      continue;
+    }
+    if (activeKey && CONTINUABLE_VALUE_KEYS.has(activeKey.toLowerCase())) {
+      result[activeKey] = `${result[activeKey]}
+${line}`;
+      continue;
+    }
+    return null;
+  }
+  return result;
+}
+function parseCsvKv(raw, optionName) {
+  const trimmed = stripCodeFenceEnvelope(raw).trim();
+  if (!trimmed) {
+    throw new PmCliError(`${optionName} cannot be empty`, EXIT_CODE.USAGE);
+  }
+  const markdownStyle = parseMarkdownKeyValueLines(trimmed);
+  if (markdownStyle) {
+    return markdownStyle;
+  }
+  const result = {};
+  let activeKey;
+  const segments = splitCsvSegments(trimmed);
+  for (const segment of segments) {
+    const delimiterIndex = findKeyValueDelimiter(segment);
+    if (delimiterIndex > 0) {
+      const key = segment.slice(0, delimiterIndex).trim();
+      const value = unquoteValue(segment.slice(delimiterIndex + 1).trim());
+      result[key] = value;
+      activeKey = key;
+      continue;
+    }
+    if (activeKey && CONTINUABLE_VALUE_KEYS.has(activeKey.toLowerCase())) {
+      result[activeKey] = `${result[activeKey]},${segment.trim()}`;
+      continue;
+    }
+    throw new PmCliError(buildInvalidKvMessage(raw, optionName), EXIT_CODE.USAGE);
+  }
+  return result;
+}
+var WINDOWS_ABSOLUTE_PATH_PATTERN = /^[A-Za-z]:[\\/]/;
+var GENERIC_LEADING_KV_KEY_PATTERN = /^(?:[-*+]\s+)?[A-Za-z_][A-Za-z0-9_.-]*\s*=/;
+function looksLikeGenericKeyValueEntry(raw) {
+  const trimmed = raw.trim();
+  if (WINDOWS_ABSOLUTE_PATH_PATTERN.test(trimmed)) {
+    return false;
+  }
+  return GENERIC_LEADING_KV_KEY_PATTERN.test(trimmed);
+}
+function assertNoUnknownCsvKeys(kv, optionName, allowedKeys) {
+  const allowed = new Set(allowedKeys.map((key) => key.toLowerCase()));
+  const unknownKeys = Object.keys(kv).filter((key) => !allowed.has(key.toLowerCase()));
+  if (unknownKeys.length > 0) {
+    throw new PmCliError(`${optionName} does not recognize key${unknownKeys.length > 1 ? "s" : ""} ${unknownKeys.map((key) => `"${key}"`).join(", ")}. Allowed keys: ${allowedKeys.join(", ")}.`, EXIT_CODE.USAGE);
+  }
+  for (const key of Object.keys(kv)) {
+    const normalizedKey = key.toLowerCase();
+    if (normalizedKey === key) {
+      continue;
+    }
+    if (Object.hasOwn(kv, normalizedKey)) {
+      throw new PmCliError(`${optionName} provides key "${key}" more than once after case normalization.`, EXIT_CODE.USAGE);
+    }
+    kv[normalizedKey] = kv[key];
+    delete kv[key];
+  }
+}
+async function readStdinText(optionName) {
+  if (process.stdin.isTTY === true) {
+    throw new PmCliError(`${optionName} value "${STDIN_TOKEN}" requires piped stdin input. Pipe content into the command, or end manual stdin with Ctrl+D (Unix/macOS) or Ctrl+Z then Enter (Windows).`, EXIT_CODE.USAGE);
+  }
+  process.stdin.setEncoding("utf8");
+  return await new Promise((resolve, reject) => {
+    let input = "";
+    process.stdin.on("data", (chunk) => {
+      input += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve(normalizeLineEndings(input));
+    });
+    process.stdin.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+function createStdinTokenResolver() {
+  let stdinValuePromise;
+  let stdinConsumerOption;
+  const consumeStdin = async (optionName) => {
+    if (stdinConsumerOption && stdinConsumerOption !== optionName) {
+      throw new PmCliError(`Only one option may use "${STDIN_TOKEN}" stdin token per command invocation. Already used by ${stdinConsumerOption}.`, EXIT_CODE.USAGE);
+    }
+    stdinConsumerOption = optionName;
+    if (!stdinValuePromise) {
+      stdinValuePromise = readStdinText(optionName);
+    }
+    return await stdinValuePromise;
+  };
+  const resolveValue = async (value, optionName) => {
+    if (value === void 0) {
+      return void 0;
+    }
+    if (value.trim() !== STDIN_TOKEN) {
+      return value;
+    }
+    return await consumeStdin(optionName);
+  };
+  const resolveList = async (values, optionName) => {
+    if (!values) {
+      return void 0;
+    }
+    const tokenIndexes = values.map((entry, index) => entry.trim() === STDIN_TOKEN ? index : -1).filter((index) => index >= 0);
+    if (tokenIndexes.length === 0) {
+      return values;
+    }
+    if (tokenIndexes.length > 1) {
+      throw new PmCliError(`${optionName} accepts "${STDIN_TOKEN}" stdin token at most once per command invocation`, EXIT_CODE.USAGE);
+    }
+    const stdinValue = await consumeStdin(optionName);
+    const next = [...values];
+    next[tokenIndexes[0]] = stdinValue;
+    return next;
+  };
+  return {
+    resolveValue,
+    resolveList
+  };
+}
+function parseOptionalNumber(raw, optionName) {
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    throw new PmCliError(`Invalid ${optionName} value "${raw}"`, EXIT_CODE.USAGE);
+  }
+  return value;
+}
+
+export {
+  parseTags,
+  mergeAdditiveTags,
+  applyTagRemovals,
+  parseCsvKv,
+  looksLikeGenericKeyValueEntry,
+  assertNoUnknownCsvKeys,
+  createStdinTokenResolver,
+  parseOptionalNumber
+};
+//# sourceMappingURL=chunk-AZYGZGGI.js.map