@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,262 @@
+
+!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]="1f86aff5-7cfc-566c-8c4b-af6365719945")}catch(e){}}();
+import {
+  toNonEmptyStringOrUndefined
+} from "./chunk-57NWPFF2.js";
+
+// dist/core/governance/metadata-coverage.js
+function normalizeStatus(status, registry) {
+  const trimmed = status.trim().toLowerCase();
+  return registry.alias_to_id.get(trimmed) ?? trimmed;
+}
+function lifecycleClassifierFromStatusRegistry(registry) {
+  return {
+    isTerminal(status) {
+      return registry.terminal_statuses.has(normalizeStatus(status, registry));
+    },
+    classify(status) {
+      const id = normalizeStatus(status, registry);
+      if (registry.terminal_canceled_statuses.has(id)) {
+        return "canceled";
+      }
+      if (registry.terminal_statuses.has(id)) {
+        return "closed";
+      }
+      if (registry.blocked_statuses.has(id)) {
+        return "blocked";
+      }
+      if (registry.draft_statuses.has(id)) {
+        return "draft";
+      }
+      if (id === registry.open_status) {
+        return "open";
+      }
+      if (registry.active_statuses.has(id)) {
+        return "in_progress";
+      }
+      return "other";
+    }
+  };
+}
+function isAcMissing(item) {
+  return toNonEmptyStringOrUndefined(item.acceptance_criteria) === void 0;
+}
+function isEstimateMissing(item) {
+  return !Number.isFinite(item.estimated_minutes);
+}
+function isResolutionMissing(item, classifier) {
+  if (!classifier.isTerminal(item.status)) {
+    return false;
+  }
+  return toNonEmptyStringOrUndefined(item.resolution) === void 0;
+}
+function isReviewerMissing(item) {
+  return toNonEmptyStringOrUndefined(item.reviewer) === void 0;
+}
+function isRiskMissing(item) {
+  return toNonEmptyStringOrUndefined(item.risk) === void 0;
+}
+function isConfidenceMissing(item) {
+  if (typeof item.confidence === "number") {
+    return !Number.isFinite(item.confidence);
+  }
+  return toNonEmptyStringOrUndefined(item.confidence) === void 0;
+}
+function isSprintMissing(item) {
+  return toNonEmptyStringOrUndefined(item.sprint) === void 0;
+}
+function isReleaseMissing(item) {
+  return toNonEmptyStringOrUndefined(item.release) === void 0;
+}
+function hasMissingMetadataFilter(filters) {
+  return Boolean(filters.acMissing || filters.estimatesMissing || filters.resolutionMissing || filters.reviewerMissing || filters.riskMissing || filters.confidenceMissing || filters.sprintMissing || filters.releaseMissing || filters.metadataMissing);
+}
+function itemMatchesSpecificMetadataFilters(item, filters, classifier) {
+  const checks = [
+    [filters.acMissing, isAcMissing(item)],
+    [filters.estimatesMissing, isEstimateMissing(item)],
+    [filters.resolutionMissing, isResolutionMissing(item, classifier)],
+    [filters.reviewerMissing, isReviewerMissing(item)],
+    [filters.riskMissing, isRiskMissing(item)],
+    [filters.confidenceMissing, isConfidenceMissing(item)],
+    [filters.sprintMissing, isSprintMissing(item)],
+    [filters.releaseMissing, isReleaseMissing(item)]
+  ];
+  return checks.every(([requested, matched]) => requested !== true || matched);
+}
+function itemMatchesCoreMetadataMissingUnion(item, classifier) {
+  return isAcMissing(item) || isEstimateMissing(item) || isResolutionMissing(item, classifier);
+}
+function itemMatchesMissingMetadata(item, filters, classifier) {
+  if (!hasMissingMetadataFilter(filters)) {
+    return true;
+  }
+  if (!itemMatchesSpecificMetadataFilters(item, filters, classifier)) {
+    return false;
+  }
+  if (filters.metadataMissing && !itemMatchesCoreMetadataMissingUnion(item, classifier)) {
+    return false;
+  }
+  return true;
+}
+var COVERAGE_FIELD_ORDER = [
+  "acceptance_criteria",
+  "estimated_minutes",
+  "resolution",
+  "tags",
+  "parent"
+];
+function isFieldPresent(item, field) {
+  switch (field) {
+    case "acceptance_criteria":
+      return !isAcMissing(item);
+    case "estimated_minutes":
+      return !isEstimateMissing(item);
+    case "resolution":
+      return toNonEmptyStringOrUndefined(item.resolution) !== void 0;
+    case "tags":
+      return Array.isArray(item.tags) && item.tags.length > 0;
+    default:
+      return toNonEmptyStringOrUndefined(item.parent) !== void 0;
+  }
+}
+function isFieldApplicable(item, field, classifier) {
+  if (field === "resolution") {
+    return classifier.isTerminal(item.status);
+  }
+  return true;
+}
+function roundPercent(present, applicable) {
+  if (applicable === 0) {
+    return 100;
+  }
+  return Math.round(present / applicable * 1e3) / 10;
+}
+function emptyFieldCoverage() {
+  const record = {};
+  for (const field of COVERAGE_FIELD_ORDER) {
+    record[field] = { present: 0, applicable: 0, percent: 100 };
+  }
+  return record;
+}
+function accumulateCoverage(target, item, classifier) {
+  for (const field of COVERAGE_FIELD_ORDER) {
+    if (!isFieldApplicable(item, field, classifier)) {
+      continue;
+    }
+    const entry = target[field];
+    entry.applicable += 1;
+    if (isFieldPresent(item, field)) {
+      entry.present += 1;
+    }
+  }
+}
+function finalizePercentages(record) {
+  for (const field of COVERAGE_FIELD_ORDER) {
+    const entry = record[field];
+    entry.percent = roundPercent(entry.present, entry.applicable);
+  }
+}
+function computeMetadataCoverage(items, classifier) {
+  const overall = emptyFieldCoverage();
+  const byType = {};
+  for (const item of items) {
+    accumulateCoverage(overall, item, classifier);
+    const typeRecord = byType[item.type] ?? (byType[item.type] = emptyFieldCoverage());
+    accumulateCoverage(typeRecord, item, classifier);
+  }
+  finalizePercentages(overall);
+  for (const typeRecord of Object.values(byType)) {
+    finalizePercentages(typeRecord);
+  }
+  return { overall, by_type: byType };
+}
+var EMPTY_GROUP_LABELS = {
+  assignee: "(unassigned)",
+  priority: "(no priority)",
+  tag: "(untagged)",
+  parent: "(unparented)",
+  type: "(untyped)",
+  status: "(no status)"
+};
+function emptyGroupLabel(dimension) {
+  return EMPTY_GROUP_LABELS[dimension];
+}
+function emptyBuckets() {
+  return {
+    open: 0,
+    in_progress: 0,
+    blocked: 0,
+    draft: 0,
+    closed: 0,
+    canceled: 0,
+    other: 0
+  };
+}
+function groupKeysForItem(item, dimension, options) {
+  switch (dimension) {
+    case "assignee":
+      return [toNonEmptyStringOrUndefined(item.assignee) ?? null];
+    case "parent":
+      return [toNonEmptyStringOrUndefined(item.parent) ?? null];
+    case "type":
+      return [toNonEmptyStringOrUndefined(item.type) ?? null];
+    case "status":
+      return [toNonEmptyStringOrUndefined(item.status) ?? null];
+    case "priority":
+      return [typeof item.priority === "number" ? `P${item.priority}` : null];
+    default: {
+      const prefix = options.tagPrefix?.trim();
+      const tags = Array.isArray(item.tags) ? item.tags : [];
+      const matching = tags.filter((tag) => typeof tag === "string" && tag.length > 0 && (!prefix || tag.startsWith(prefix)));
+      return matching.length > 0 ? matching : [null];
+    }
+  }
+}
+function groupItemsByDimension(items, dimension, classifier, options = {}) {
+  const rows = /* @__PURE__ */ new Map();
+  let totalItems = 0;
+  for (const item of items) {
+    totalItems += 1;
+    const bucket = classifier.classify(item.status);
+    for (const key of groupKeysForItem(item, dimension, options)) {
+      const mapKey = key ?? "\0empty";
+      let row = rows.get(mapKey);
+      if (!row) {
+        row = {
+          label: key ?? emptyGroupLabel(dimension),
+          key,
+          buckets: emptyBuckets(),
+          total: 0
+        };
+        rows.set(mapKey, row);
+      }
+      row.buckets[bucket] += 1;
+      row.total += 1;
+    }
+  }
+  const sorted = [...rows.values()].sort((left, right) => {
+    if (right.total !== left.total) {
+      return right.total - left.total;
+    }
+    if (left.key === null) {
+      return 1;
+    }
+    if (right.key === null) {
+      return -1;
+    }
+    return left.label.localeCompare(right.label);
+  });
+  return { dimension, rows: sorted, total_items: totalItems };
+}
+
+export {
+  lifecycleClassifierFromStatusRegistry,
+  hasMissingMetadataFilter,
+  itemMatchesMissingMetadata,
+  computeMetadataCoverage,
+  groupItemsByDimension
+};
+//# sourceMappingURL=chunk-MVYWGY2A.js.map
+
+//# debugId=1f86aff5-7cfc-566c-8c4b-af6365719945