@unbrained/pm-cli 2026.6.23 → 2026.6.30

package/dist/cli-bundle/chunks/chunk-5ABGFWR4.js

@@ -0,0 +1,116 @@
+
+!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]="bf636ecd-87ea-5f64-922e-24b95e830769")}catch(e){}}();
+import {
+  isTerminalStatus,
+  normalizeStatusForRegistry
+} from "./chunk-V3KLX7U7.js";
+
+// dist/core/item/actionability.js
+var BLOCKED_BY_DEPENDENCY_KIND = "blocked_by";
+function normalizeItemId(id) {
+  return id.trim().toLowerCase();
+}
+function collectBlockedByIds(item) {
+  const ids = /* @__PURE__ */ new Set();
+  const scalar = typeof item.blocked_by === "string" ? item.blocked_by.trim() : "";
+  if (scalar.length > 0) {
+    ids.add(scalar);
+  }
+  for (const dependency of item.dependencies ?? []) {
+    if (dependency.kind === BLOCKED_BY_DEPENDENCY_KIND && typeof dependency.id === "string" && dependency.id.trim().length > 0) {
+      ids.add(dependency.id.trim());
+    }
+  }
+  return [...ids].sort((left, right) => left.localeCompare(right));
+}
+function resolveItemBlockers(item, itemsById, statusRegistry) {
+  return collectBlockedByIds(item).map((id) => {
+    const blocker = itemsById.get(normalizeItemId(id));
+    if (!blocker) {
+      return { id, title: null, status: null, resolved: true };
+    }
+    return {
+      id,
+      title: blocker.title,
+      status: blocker.status,
+      resolved: isTerminalStatus(blocker.status, statusRegistry)
+    };
+  });
+}
+function resolveActiveStatusSet(statusRegistry) {
+  return statusRegistry.active_statuses.size > 0 ? statusRegistry.active_statuses : /* @__PURE__ */ new Set([statusRegistry.open_status]);
+}
+function hasOpenDescendant(rootId, childrenByParent, statusRegistry) {
+  const stack = [normalizeItemId(rootId)];
+  const visited = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    for (const child of childrenByParent.get(current) ?? []) {
+      if (!isTerminalStatus(child.status, statusRegistry)) {
+        return true;
+      }
+      stack.push(normalizeItemId(child.id));
+    }
+  }
+  return false;
+}
+function indexCorpus(corpus) {
+  const itemsById = /* @__PURE__ */ new Map();
+  const childrenByParent = /* @__PURE__ */ new Map();
+  const blockedByReverse = /* @__PURE__ */ new Map();
+  for (const item of corpus) {
+    itemsById.set(normalizeItemId(item.id), item);
+    const parent = typeof item.parent === "string" ? item.parent.trim() : "";
+    if (parent.length > 0) {
+      const parentKey = normalizeItemId(parent);
+      const siblings = childrenByParent.get(parentKey) ?? [];
+      siblings.push(item);
+      childrenByParent.set(parentKey, siblings);
+    }
+    for (const blockerId of collectBlockedByIds(item)) {
+      const blockerKey = normalizeItemId(blockerId);
+      const dependents = blockedByReverse.get(blockerKey) ?? [];
+      dependents.push(item.id);
+      blockedByReverse.set(blockerKey, dependents);
+    }
+  }
+  return { itemsById, childrenByParent, blockedByReverse };
+}
+function computeActionabilityReport(candidates, corpus, statusRegistry) {
+  const { itemsById, childrenByParent, blockedByReverse } = indexCorpus(corpus);
+  const activeStatuses = resolveActiveStatusSet(statusRegistry);
+  const nonTerminalIds = new Set(corpus.filter((entry) => !isTerminalStatus(entry.status, statusRegistry)).map((entry) => normalizeItemId(entry.id)));
+  const ready = [];
+  const blocked = [];
+  let activeCount = 0;
+  let containerCount = 0;
+  for (const item of candidates) {
+    if (!activeStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)))
+      continue;
+    activeCount += 1;
+    if (hasOpenDescendant(item.id, childrenByParent, statusRegistry)) {
+      containerCount += 1;
+      continue;
+    }
+    const openBlockers = resolveItemBlockers(item, itemsById, statusRegistry).filter((blocker) => !blocker.resolved);
+    const unblocks = (blockedByReverse.get(normalizeItemId(item.id)) ?? []).filter((dependentId) => nonTerminalIds.has(normalizeItemId(dependentId))).sort((left, right) => left.localeCompare(right));
+    const entry = { item, open_blockers: openBlockers, unblocks };
+    if (openBlockers.length === 0) {
+      ready.push(entry);
+    } else {
+      blocked.push(entry);
+    }
+  }
+  return { ready, blocked, active_count: activeCount, container_count: containerCount };
+}
+
+export {
+  collectBlockedByIds,
+  computeActionabilityReport
+};
+//# sourceMappingURL=chunk-5ABGFWR4.js.map
+
+//# debugId=bf636ecd-87ea-5f64-922e-24b95e830769

package/dist/cli-bundle/chunks/chunk-5ABGFWR4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../core/item/actionability.ts"],"sourcesContent":["/**\n * @module core/item/actionability\n *\n * Pure, dependency-aware actionability model shared by the `pm next` command and\n * the close-time auto-unblock sweep. It answers \"what is ready to work on now?\"\n * without any I/O: given a candidate set and the surrounding corpus it partitions\n * work into READY items (active, leaf, no open blockers) and BLOCKED items (active\n * leaf waiting on at least one open blocker). Keeping the logic here — rather than\n * inside a CLI command — makes it trivially testable and reusable, and gives the\n * `blocked_by` resolution a single source of truth.\n */\nimport { isTerminalStatus, normalizeStatusForRegistry } from \"./status.js\";\nimport type { RuntimeStatusRegistry } from \"../schema/runtime-schema.js\";\nimport type { ItemFrontMatter, ItemStatus } from \"../../types/index.js\";\n\n/** Dependency kind that marks \"this item is blocked by the referenced item\". */\nconst BLOCKED_BY_DEPENDENCY_KIND = \"blocked_by\";\n\n/**\n * Normalizes an item id / parent reference / blocker id to its canonical\n * comparison key (trimmed, lowercased). pm ids are canonically lowercase, but\n * resolving case-insensitively — as {@link collectSubtreeIds} does — keeps a\n * hand-edited mixed-case reference from being silently treated as missing.\n */\nfunction normalizeItemId(id: string): string {\n  return id.trim().toLowerCase();\n}\n\n/**\n * Collects the blocker item ids declared by an item: the legacy scalar\n * `blocked_by` field plus every `blocked_by` dependency edge. Ids are trimmed,\n * de-duplicated, and returned in stable lexicographic order. This is the single\n * source of truth for \"what must close before this item can proceed\", shared by\n * `pm next` readiness classification and the close-time auto-unblock sweep.\n */\nexport function collectBlockedByIds(item: Pick<ItemFrontMatter, \"blocked_by\" | \"dependencies\">): string[] {\n  const ids = new Set<string>();\n  const scalar = typeof item.blocked_by === \"string\" ? item.blocked_by.trim() : \"\";\n  if (scalar.length > 0) {\n    ids.add(scalar);\n  }\n  for (const dependency of item.dependencies ?? []) {\n    if (\n      dependency.kind === BLOCKED_BY_DEPENDENCY_KIND &&\n      typeof dependency.id === \"string\" &&\n      dependency.id.trim().length > 0\n    ) {\n      ids.add(dependency.id.trim());\n    }\n  }\n  return [...ids].sort((left, right) => left.localeCompare(right));\n}\n\n/** A blocker reference resolved against the corpus and annotated with its state. */\nexport interface ResolvedBlocker {\n  id: string;\n  title: string | null;\n  status: ItemStatus | null;\n  /** True when the blocker no longer gates work: its id is unknown or terminal. */\n  resolved: boolean;\n}\n\n/**\n * Resolves an item's declared blockers against a corpus index, annotating each\n * with the blocker's title/status and whether it still gates work. A blocker is\n * treated as resolved when its id is unknown (a dangling reference cannot be\n * waited on) or the referenced item is terminal — mirroring the close-time\n * auto-unblock rule, which only clears a dependent once its blocker is terminal.\n */\nexport function resolveItemBlockers(\n  item: Pick<ItemFrontMatter, \"blocked_by\" | \"dependencies\">,\n  itemsById: Map<string, ItemFrontMatter>,\n  statusRegistry: RuntimeStatusRegistry,\n): ResolvedBlocker[] {\n  return collectBlockedByIds(item).map((id) => {\n    const blocker = itemsById.get(normalizeItemId(id));\n    if (!blocker) {\n      return { id, title: null, status: null, resolved: true };\n    }\n    return {\n      id,\n      title: blocker.title,\n      status: blocker.status,\n      resolved: isTerminalStatus(blocker.status, statusRegistry),\n    };\n  });\n}\n\n/** A classified actionable item plus the context an agent needs to act on it. */\nexport interface ActionableEntry {\n  item: ItemFrontMatter;\n  /** Blockers that still gate the item (resolved blockers are filtered out). */\n  open_blockers: ResolvedBlocker[];\n  /** Ids of non-terminal items whose `blocked_by` points at this item. */\n  unblocks: string[];\n}\n\n/** Result of partitioning a candidate set into ready vs blocked leaf work. */\nexport interface ActionabilityReport {\n  /** Active leaves with no open blockers — ready to work on now. */\n  ready: ActionableEntry[];\n  /** Active leaves with at least one open blocker — waiting to become ready. */\n  blocked: ActionableEntry[];\n  /** Active candidates considered before the leaf/blocker split. */\n  active_count: number;\n  /** Active candidates skipped because they still have open descendants. */\n  container_count: number;\n}\n\n/**\n * Resolves the registry's active status set, falling back to just the canonical\n * open status when a custom schema declares none — the same safety net `pm\n * context` applies so the report never misclassifies every item as inactive.\n */\nfunction resolveActiveStatusSet(statusRegistry: RuntimeStatusRegistry): Set<string> {\n  /* c8 ignore start -- fallback applies only to custom schemas that intentionally define zero active statuses */\n  return statusRegistry.active_statuses.size > 0 ? statusRegistry.active_statuses : new Set<string>([statusRegistry.open_status]);\n  /* c8 ignore stop */\n}\n\n/**\n * Returns whether an item has any non-terminal descendant by walking the\n * parent→children index depth-first, short-circuiting on the first one found.\n * Such an item is a container (its real work lives in its children), so `pm next`\n * skips it and recommends a leaf instead. Cycle-safe via a visited set.\n */\nfunction hasOpenDescendant(\n  rootId: string,\n  childrenByParent: Map<string, ItemFrontMatter[]>,\n  statusRegistry: RuntimeStatusRegistry,\n): boolean {\n  const stack = [normalizeItemId(rootId)];\n  const visited = new Set<string>();\n  while (stack.length > 0) {\n    const current = stack.pop() as string;\n    /* c8 ignore start -- defensive cycle-guard: unreachable for active roots (an open child returns before any node is revisited, and single-parent graphs cannot form a root-reachable cycle excluding the root), retained for safety */\n    if (visited.has(current)) continue;\n    /* c8 ignore stop */\n    visited.add(current);\n    for (const child of childrenByParent.get(current) ?? []) {\n      if (!isTerminalStatus(child.status, statusRegistry)) {\n        return true;\n      }\n      stack.push(normalizeItemId(child.id));\n    }\n  }\n  return false;\n}\n\n/**\n * Indexes the corpus into a by-id map, a parent→children map, and a reverse\n * blocker map (blocker id → ids of items it blocks). Built once per report so\n * blocker resolution, descendant counting, and downstream \"unblocks\" lookups\n * share the same passes over the corpus.\n */\nfunction indexCorpus(corpus: ItemFrontMatter[]): {\n  itemsById: Map<string, ItemFrontMatter>;\n  childrenByParent: Map<string, ItemFrontMatter[]>;\n  blockedByReverse: Map<string, string[]>;\n} {\n  const itemsById = new Map<string, ItemFrontMatter>();\n  const childrenByParent = new Map<string, ItemFrontMatter[]>();\n  const blockedByReverse = new Map<string, string[]>();\n  for (const item of corpus) {\n    // Index keys are normalized (lowercased) for case-insensitive resolution;\n    // stored values keep the item's original-case id for display.\n    itemsById.set(normalizeItemId(item.id), item);\n    const parent = typeof item.parent === \"string\" ? item.parent.trim() : \"\";\n    if (parent.length > 0) {\n      const parentKey = normalizeItemId(parent);\n      const siblings = childrenByParent.get(parentKey) ?? [];\n      siblings.push(item);\n      childrenByParent.set(parentKey, siblings);\n    }\n    for (const blockerId of collectBlockedByIds(item)) {\n      const blockerKey = normalizeItemId(blockerId);\n      const dependents = blockedByReverse.get(blockerKey) ?? [];\n      dependents.push(item.id);\n      blockedByReverse.set(blockerKey, dependents);\n    }\n  }\n  return { itemsById, childrenByParent, blockedByReverse };\n}\n\n/**\n * Partitions a candidate set into ready vs blocked leaf work using the corpus to\n * resolve blockers, descendants, and downstream dependents.\n *\n * An item qualifies when its status is active. Containers — items with at least\n * one non-terminal descendant — are excluded from both lists because the real\n * work is the leaf beneath them. A leaf with no open blockers is READY; a leaf\n * with one or more open blockers is BLOCKED, annotated with the unresolved\n * blockers and the non-terminal items it would unblock. Returned lists preserve\n * the candidate order so the caller can apply its own ranking.\n */\nexport function computeActionabilityReport(\n  candidates: ItemFrontMatter[],\n  corpus: ItemFrontMatter[],\n  statusRegistry: RuntimeStatusRegistry,\n): ActionabilityReport {\n  const { itemsById, childrenByParent, blockedByReverse } = indexCorpus(corpus);\n  const activeStatuses = resolveActiveStatusSet(statusRegistry);\n  // Ids of corpus items still in flight, used to keep only the non-terminal\n  // dependents in each item's downstream \"unblocks\" list.\n  const nonTerminalIds = new Set(\n    corpus.filter((entry) => !isTerminalStatus(entry.status, statusRegistry)).map((entry) => normalizeItemId(entry.id)),\n  );\n  const ready: ActionableEntry[] = [];\n  const blocked: ActionableEntry[] = [];\n  let activeCount = 0;\n  let containerCount = 0;\n  for (const item of candidates) {\n    if (!activeStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry))) continue;\n    activeCount += 1;\n    if (hasOpenDescendant(item.id, childrenByParent, statusRegistry)) {\n      containerCount += 1;\n      continue;\n    }\n    const openBlockers = resolveItemBlockers(item, itemsById, statusRegistry).filter((blocker) => !blocker.resolved);\n    const unblocks = (blockedByReverse.get(normalizeItemId(item.id)) ?? [])\n      .filter((dependentId) => nonTerminalIds.has(normalizeItemId(dependentId)))\n      .sort((left, right) => left.localeCompare(right));\n    const entry: ActionableEntry = { item, open_blockers: openBlockers, unblocks };\n    if (openBlockers.length === 0) {\n      ready.push(entry);\n    } else {\n      blocked.push(entry);\n    }\n  }\n  return { ready, blocked, active_count: activeCount, container_count: containerCount };\n}\n"],"names":[],"mappings":";;;;;;;;AAgBA,IAAM,6BAA6B;AAQnC,SAAS,gBAAgB,IAAU;AACjC,SAAO,GAAG,KAAI,EAAG,YAAW;AAC9B;AASM,SAAU,oBAAoB,MAA0D;AAC5F,QAAM,MAAM,oBAAI,IAAG;AACnB,QAAM,SAAS,OAAO,KAAK,eAAe,WAAW,KAAK,WAAW,KAAI,IAAK;AAC9E,MAAI,OAAO,SAAS,GAAG;AACrB,QAAI,IAAI,MAAM;EAChB;AACA,aAAW,cAAc,KAAK,gBAAgB,CAAA,GAAI;AAChD,QACE,WAAW,SAAS,8BACpB,OAAO,WAAW,OAAO,YACzB,WAAW,GAAG,KAAI,EAAG,SAAS,GAC9B;AACA,UAAI,IAAI,WAAW,GAAG,KAAI,CAAE;IAC9B;EACF;AACA,SAAO,CAAC,GAAG,GAAG,EAAE,KAAK,CAAC,MAAM,UAAU,KAAK,cAAc,KAAK,CAAC;AACjE;AAkBM,SAAU,oBACd,MACA,WACA,gBAAqC;AAErC,SAAO,oBAAoB,IAAI,EAAE,IAAI,CAAC,OAAM;AAC1C,UAAM,UAAU,UAAU,IAAI,gBAAgB,EAAE,CAAC;AACjD,QAAI,CAAC,SAAS;AACZ,aAAO,EAAE,IAAI,OAAO,MAAM,QAAQ,MAAM,UAAU,KAAI;IACxD;AACA,WAAO;MACL;MACA,OAAO,QAAQ;MACf,QAAQ,QAAQ;MAChB,UAAU,iBAAiB,QAAQ,QAAQ,cAAc;;EAE7D,CAAC;AACH;AA4BA,SAAS,uBAAuB,gBAAqC;AAEnE,SAAO,eAAe,gBAAgB,OAAO,IAAI,eAAe,kBAAkB,oBAAI,IAAY,CAAC,eAAe,WAAW,CAAC;AAEhI;AAQA,SAAS,kBACP,QACA,kBACA,gBAAqC;AAErC,QAAM,QAAQ,CAAC,gBAAgB,MAAM,CAAC;AACtC,QAAM,UAAU,oBAAI,IAAG;AACvB,SAAO,MAAM,SAAS,GAAG;AACvB,UAAM,UAAU,MAAM,IAAG;AAEzB,QAAI,QAAQ,IAAI,OAAO;AAAG;AAE1B,YAAQ,IAAI,OAAO;AACnB,eAAW,SAAS,iBAAiB,IAAI,OAAO,KAAK,CAAA,GAAI;AACvD,UAAI,CAAC,iBAAiB,MAAM,QAAQ,cAAc,GAAG;AACnD,eAAO;MACT;AACA,YAAM,KAAK,gBAAgB,MAAM,EAAE,CAAC;IACtC;EACF;AACA,SAAO;AACT;AAQA,SAAS,YAAY,QAAyB;AAK5C,QAAM,YAAY,oBAAI,IAAG;AACzB,QAAM,mBAAmB,oBAAI,IAAG;AAChC,QAAM,mBAAmB,oBAAI,IAAG;AAChC,aAAW,QAAQ,QAAQ;AAGzB,cAAU,IAAI,gBAAgB,KAAK,EAAE,GAAG,IAAI;AAC5C,UAAM,SAAS,OAAO,KAAK,WAAW,WAAW,KAAK,OAAO,KAAI,IAAK;AACtE,QAAI,OAAO,SAAS,GAAG;AACrB,YAAM,YAAY,gBAAgB,MAAM;AACxC,YAAM,WAAW,iBAAiB,IAAI,SAAS,KAAK,CAAA;AACpD,eAAS,KAAK,IAAI;AAClB,uBAAiB,IAAI,WAAW,QAAQ;IAC1C;AACA,eAAW,aAAa,oBAAoB,IAAI,GAAG;AACjD,YAAM,aAAa,gBAAgB,SAAS;AAC5C,YAAM,aAAa,iBAAiB,IAAI,UAAU,KAAK,CAAA;AACvD,iBAAW,KAAK,KAAK,EAAE;AACvB,uBAAiB,IAAI,YAAY,UAAU;IAC7C;EACF;AACA,SAAO,EAAE,WAAW,kBAAkB,iBAAgB;AACxD;AAaM,SAAU,2BACd,YACA,QACA,gBAAqC;AAErC,QAAM,EAAE,WAAW,kBAAkB,iBAAgB,IAAK,YAAY,MAAM;AAC5E,QAAM,iBAAiB,uBAAuB,cAAc;AAG5D,QAAM,iBAAiB,IAAI,IACzB,OAAO,OAAO,CAAC,UAAU,CAAC,iBAAiB,MAAM,QAAQ,cAAc,CAAC,EAAE,IAAI,CAAC,UAAU,gBAAgB,MAAM,EAAE,CAAC,CAAC;AAErH,QAAM,QAA2B,CAAA;AACjC,QAAM,UAA6B,CAAA;AACnC,MAAI,cAAc;AAClB,MAAI,iBAAiB;AACrB,aAAW,QAAQ,YAAY;AAC7B,QAAI,CAAC,eAAe,IAAI,2BAA2B,KAAK,QAAQ,cAAc,CAAC;AAAG;AAClF,mBAAe;AACf,QAAI,kBAAkB,KAAK,IAAI,kBAAkB,cAAc,GAAG;AAChE,wBAAkB;AAClB;IACF;AACA,UAAM,eAAe,oBAAoB,MAAM,WAAW,cAAc,EAAE,OAAO,CAAC,YAAY,CAAC,QAAQ,QAAQ;AAC/G,UAAM,YAAY,iBAAiB,IAAI,gBAAgB,KAAK,EAAE,CAAC,KAAK,CAAA,GACjE,OAAO,CAAC,gBAAgB,eAAe,IAAI,gBAAgB,WAAW,CAAC,CAAC,EACxE,KAAK,CAAC,MAAM,UAAU,KAAK,cAAc,KAAK,CAAC;AAClD,UAAM,QAAyB,EAAE,MAAM,eAAe,cAAc,SAAQ;AAC5E,QAAI,aAAa,WAAW,GAAG;AAC7B,YAAM,KAAK,KAAK;IAClB,OAAO;AACL,cAAQ,KAAK,KAAK;IACpB;EACF;AACA,SAAO,EAAE,OAAO,SAAS,cAAc,aAAa,iBAAiB,eAAc;AACrF","debugId":"bf636ecd-87ea-5f64-922e-24b95e830769"}