@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -1,265 +0,0 @@
-import {
-  toNonEmptyStringOrUndefined
-} from "./chunk-5VVUKE3U.js";
-
-// dist/core/governance/metadata-coverage.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] = "f14cd0bc-bf31-5676-8e21-345fb9ecdd0d");
-  } catch (e2) {
-  }
-})();
-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-RX3HQSYG.js.map

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

@@ -1,210 +0,0 @@
-import {
-  verifyHistoryChain
-} from "./chunk-D3UCE7RW.js";
-import {
-  hashDocument
-} from "./chunk-3U3VEWK6.js";
-import {
-  getHistoryPath,
-  writeFileAtomic
-} from "./chunk-5VVUKE3U.js";
-
-// dist/core/history/drift-scan.js
-import fs from "fs/promises";
-import { createHash } from "node:crypto";
-import path from "node:path";
-!(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] = "91c6995a-7219-5402-b2d4-e50227bf0149");
-  } catch (e2) {
-  }
-})();
-var DRIFT_CACHE_VERSION = 3;
-var DRIFT_CACHE_FILENAME = "history-drift-cache.json";
-function getDriftCachePath(pmRoot) {
-  return path.join(pmRoot, "runtime", DRIFT_CACHE_FILENAME);
-}
-async function loadDriftCache(pmRoot) {
-  try {
-    const raw = await fs.readFile(getDriftCachePath(pmRoot), "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== DRIFT_CACHE_VERSION || typeof parsed.entries !== "object" || parsed.entries === null) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function isErrno(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
-}
-function hashContent(raw) {
-  return createHash("sha256").update(raw).digest("hex");
-}
-async function readHistoryContentHash(historyPath) {
-  const raw = await fs.readFile(historyPath, "utf8");
-  return hashContent(raw);
-}
-async function verifyHistoryStream(historyPath) {
-  const raw = await fs.readFile(historyPath, "utf8");
-  const contentHash = hashContent(raw);
-  if (raw.trim().length === 0) {
-    return null;
-  }
-  const entries = [];
-  let latestAfterHash = null;
-  for (const line of raw.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    const parsed = JSON.parse(trimmed);
-    if (typeof parsed.after_hash !== "string" || parsed.after_hash.trim().length === 0) {
-      throw new Error("missing after_hash");
-    }
-    entries.push(parsed);
-    latestAfterHash = parsed.after_hash;
-  }
-  if (!latestAfterHash) {
-    return null;
-  }
-  return {
-    latestAfterHash,
-    chainOk: verifyHistoryChain(entries).ok,
-    contentHash
-  };
-}
-function cacheMetadataMatches(cached, stat) {
-  return cached !== void 0 && cached.mtime_ms === stat.mtimeMs && cached.ctime_ms === stat.ctimeMs && cached.size === stat.size;
-}
-async function loadFreshStreamVerification(itemId, historyPath, accumulator) {
-  try {
-    const loaded = await verifyHistoryStream(historyPath);
-    if (!loaded) {
-      accumulator.missingStreams.push(itemId);
-      return null;
-    }
-    return loaded;
-  } catch {
-    accumulator.unreadableStreams.push(itemId);
-    return null;
-  }
-}
-async function resolveStreamVerification(params) {
-  const cachedContentHash = typeof params.cached?.content_hash === "string" && params.cached.content_hash.length > 0 ? params.cached.content_hash : void 0;
-  const canUseCache = cacheMetadataMatches(params.cached, params.stat) && cachedContentHash !== void 0 && params.cached !== void 0;
-  if (!canUseCache || !params.cached) {
-    return {
-      verification: await loadFreshStreamVerification(params.itemId, params.historyPath, params.accumulator),
-      cacheDirty: true
-    };
-  }
-  let currentContentHash;
-  if (params.verifyCacheHitByContent) {
-    try {
-      currentContentHash = await readHistoryContentHash(params.historyPath);
-    } catch {
-      params.accumulator.unreadableStreams.push(params.itemId);
-      return { verification: null, cacheDirty: false };
-    }
-  } else {
-    currentContentHash = cachedContentHash;
-  }
-  if (!params.verifyCacheHitByContent || currentContentHash === cachedContentHash) {
-    return {
-      verification: {
-        latestAfterHash: params.cached.latest_after_hash,
-        chainOk: params.cached.chain_ok,
-        contentHash: currentContentHash
-      },
-      cacheDirty: false
-    };
-  }
-  return {
-    verification: await loadFreshStreamVerification(params.itemId, params.historyPath, params.accumulator),
-    cacheDirty: true
-  };
-}
-async function scanHistoryDrift(pmRoot, items, options = {}) {
-  const accumulator = {
-    missingStreams: [],
-    unreadableStreams: [],
-    hashMismatches: [],
-    chainMismatches: []
-  };
-  const cache = await loadDriftCache(pmRoot);
-  const previousEntries = cache?.entries ?? {};
-  const nextEntries = {};
-  let cacheDirty = false;
-  const verifyCacheHitByContent = options.cacheHitVerification !== "metadata";
-  for (const item of items) {
-    const historyPath = getHistoryPath(pmRoot, item.id);
-    let stat;
-    try {
-      stat = await fs.stat(historyPath);
-    } catch (error) {
-      if (isErrno(error, "ENOENT")) {
-        accumulator.missingStreams.push(item.id);
-      } else {
-        accumulator.unreadableStreams.push(item.id);
-      }
-      continue;
-    }
-    const cached = previousEntries[item.id];
-    const resolved = await resolveStreamVerification({
-      itemId: item.id,
-      historyPath,
-      stat,
-      cached,
-      verifyCacheHitByContent,
-      accumulator
-    });
-    cacheDirty ||= resolved.cacheDirty;
-    if (!resolved.verification) {
-      continue;
-    }
-    if (!resolved.verification.chainOk) {
-      accumulator.chainMismatches.push(item.id);
-    }
-    nextEntries[item.id] = {
-      mtime_ms: stat.mtimeMs,
-      ctime_ms: stat.ctimeMs,
-      size: stat.size,
-      content_hash: resolved.verification.contentHash,
-      latest_after_hash: resolved.verification.latestAfterHash,
-      chain_ok: resolved.verification.chainOk
-    };
-    const { body, ...frontMatter } = item;
-    const currentHash = hashDocument({
-      metadata: frontMatter,
-      body
-    });
-    if (currentHash !== resolved.verification.latestAfterHash) {
-      accumulator.hashMismatches.push(item.id);
-    }
-  }
-  if (cacheDirty || Object.keys(previousEntries).length !== Object.keys(nextEntries).length) {
-    const cachePath = getDriftCachePath(pmRoot);
-    try {
-      await fs.mkdir(path.dirname(cachePath), { recursive: true });
-      await writeFileAtomic(cachePath, JSON.stringify({ version: DRIFT_CACHE_VERSION, entries: nextEntries }));
-    } catch {
-    }
-  }
-  const driftedItems = [
-    .../* @__PURE__ */ new Set([
-      ...accumulator.missingStreams,
-      ...accumulator.unreadableStreams,
-      ...accumulator.hashMismatches,
-      ...accumulator.chainMismatches
-    ])
-  ].sort((a, b) => a.localeCompare(b));
-  return { ...accumulator, driftedItems };
-}
-
-export {
-  scanHistoryDrift
-};
-//# sourceMappingURL=chunk-S4APD35C.js.map

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

@@ -1,130 +0,0 @@
-
-!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]="f04ac56e-a146-5aa0-90e2-2c783ad2e6ef")}catch(e){}}();
-import {
-  nowIso
-} from "./chunk-FJRKQREY.js";
-import {
-  PmCliError
-} from "./chunk-US3T3W5J.js";
-import {
-  EXIT_CODE,
-  pathExists,
-  toErrorMessage,
-  writeFileAtomic
-} from "./chunk-YD5FML7K.js";
-
-// dist/core/checkpoint/mutation-checkpoint.js
-import { mkdir, readFile } from "node:fs/promises";
-import path from "node:path";
-function normalizeCheckpointId(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    throw new PmCliError("--rollback requires a non-empty checkpoint ID", EXIT_CODE.USAGE);
-  }
-  if (!/^[a-zA-Z0-9._-]+$/.test(trimmed)) {
-    throw new PmCliError("--rollback checkpoint ID must match [a-zA-Z0-9._-]+", EXIT_CODE.USAGE);
-  }
-  return trimmed;
-}
-function createCheckpointId(prefix, nowValue) {
-  const compactTimestamp = nowValue.replace(/[-:.TZ]/g, "").slice(0, 14);
-  const randomSuffix = Math.random().toString(36).slice(2, 8);
-  return `${prefix}-${compactTimestamp}-${randomSuffix}`;
-}
-function checkpointDirectoryPath(pmRoot, subdir) {
-  return path.join(pmRoot, "checkpoints", subdir);
-}
-function checkpointFilePath(pmRoot, subdir, checkpointId) {
-  return path.join(checkpointDirectoryPath(pmRoot, subdir), `${checkpointId}.json`);
-}
-async function writeMutationCheckpoint(pmRoot, subdir, checkpointId, payload) {
-  const checkpointDir = checkpointDirectoryPath(pmRoot, subdir);
-  await mkdir(checkpointDir, { recursive: true });
-  const filePath = checkpointFilePath(pmRoot, subdir, checkpointId);
-  await writeFileAtomic(filePath, `${JSON.stringify(payload, null, 2)}
-`);
-  return filePath;
-}
-function parseCheckpointItems(record, checkpointId) {
-  if (!Array.isArray(record.items)) {
-    throw new PmCliError(`Checkpoint ${checkpointId} is missing items`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  return record.items.map((entry) => {
-    if (!entry || typeof entry !== "object") {
-      throw new PmCliError(`Checkpoint ${checkpointId} contains an invalid item entry`, EXIT_CODE.GENERIC_FAILURE);
-    }
-    const row = entry;
-    if (typeof row.id !== "string" || row.id.trim().length === 0) {
-      throw new PmCliError(`Checkpoint ${checkpointId} contains an item entry without ID`, EXIT_CODE.GENERIC_FAILURE);
-    }
-    if (typeof row.target_updated_at !== "string" || row.target_updated_at.trim().length === 0) {
-      throw new PmCliError(`Checkpoint ${checkpointId} contains an item entry without target_updated_at`, EXIT_CODE.GENERIC_FAILURE);
-    }
-    return { id: row.id.trim(), target_updated_at: row.target_updated_at.trim() };
-  });
-}
-async function loadMutationCheckpoint(pmRoot, subdir, rawCheckpointId, schemaVersion) {
-  const normalizedId = normalizeCheckpointId(rawCheckpointId);
-  const filePath = checkpointFilePath(pmRoot, subdir, normalizedId);
-  if (!await pathExists(filePath)) {
-    throw new PmCliError(`Checkpoint ${normalizedId} not found`, EXIT_CODE.NOT_FOUND);
-  }
-  const raw = await readFile(filePath, "utf8");
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    throw new PmCliError(`Checkpoint ${normalizedId} contains invalid JSON: ${toErrorMessage(error)}`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  if (!parsed || typeof parsed !== "object") {
-    throw new PmCliError(`Checkpoint ${normalizedId} is invalid`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  const record = parsed;
-  if (record.schema_version !== schemaVersion) {
-    throw new PmCliError(`Checkpoint ${normalizedId} has unsupported schema version`, EXIT_CODE.GENERIC_FAILURE);
-  }
-  const items = parseCheckpointItems(record, normalizedId);
-  return {
-    record,
-    items,
-    path: filePath,
-    id: typeof record.id === "string" ? record.id : normalizedId,
-    // Defensive recovery for malformed checkpoint metadata; normal writes
-    // always include these fields, so fallbacks keep rollback inspectable.
-    created_at: typeof record.created_at === "string" ? record.created_at : nowIso(),
-    author: typeof record.author === "string" ? record.author : "unknown"
-  };
-}
-async function restoreCheckpointItems(items, restore) {
-  const rows = [];
-  const restoredIds = [];
-  for (const entry of items) {
-    try {
-      const restored = await restore(entry.id, entry.target_updated_at);
-      rows.push({
-        id: entry.id,
-        status: "restored",
-        changed_fields: restored.changed_fields,
-        warnings: restored.warnings
-      });
-      restoredIds.push(entry.id);
-    } catch (error) {
-      rows.push({ id: entry.id, status: "failed", error: toErrorMessage(error) });
-    }
-  }
-  return {
-    rows,
-    restored_ids: restoredIds,
-    failed_count: rows.filter((row) => row.status === "failed").length
-  };
-}
-
-export {
-  createCheckpointId,
-  writeMutationCheckpoint,
-  loadMutationCheckpoint,
-  restoreCheckpointItems
-};
-//# sourceMappingURL=chunk-S5AYOUT5.js.map
-
-//# debugId=f04ac56e-a146-5aa0-90e2-2c783ad2e6ef