prodc 0.3.63__tar.gz → 0.3.64__tar.gz

{prodc-0.3.63 → prodc-0.3.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: prodc
-Version: 0.3.63
+Version: 0.3.64
 Summary: Product management as code: roles, flows, and features traced to evidence.
 Project-URL: Homepage, https://gitlab.com/jorgeecardona/prodc
 Project-URL: Repository, https://gitlab.com/jorgeecardona/prodc

{prodc-0.3.63 → prodc-0.3.64}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "prodc"
-version = "0.3.63"
+version = "0.3.64"
 description = "Product management as code: roles, flows, and features traced to evidence."
 readme = "README.md"
 requires-python = ">=3.12"

{prodc-0.3.63 → prodc-0.3.64}/src/prodc/cli.py

@@ -49,6 +49,7 @@ from .model import (
     NeedState,
     Release,
     Role,
+    board_needs,
     ears_shape,
 )
 from .report import render_markdown
@@ -541,8 +542,7 @@ def _cmd_status(args: argparse.Namespace) -> int:
     # Draft needs (#60) are staged: kept off the counted board (and coverage, recurrence,
     # orphans) until promoted with `set <id> draft=false`, unless --include-drafts is passed.
     draft_count = sum(1 for n in needs if n.draft)
-    if not args.include_drafts:
-        needs = [n for n in needs if not n.draft]
+    needs = board_needs(needs, include_drafts=args.include_drafts)
     # Scoped coverage (#49): restrict the board + coverage to a subset, so the number people
     # act on (this client, this goal) isn't diluted by the whole mixed board.
     if args.client:
@@ -858,9 +858,7 @@ def _cmd_plan(args: argparse.Namespace) -> int:
     if loaded is None:
         return 2
     cfg, model = loaded
-    needs = list(model.needs)
-    if not args.include_drafts:
-        needs = [n for n in needs if not n.draft]  # drafts aren't backlog until promoted (#60)
+    needs = board_needs(list(model.needs), include_drafts=args.include_drafts)  # drafts off (#60)
     results = resolve(needs, cfg.adapters, cfg.source_adapters)
     recurrence_counts = {rec.baseline.id: rec.count for rec in recurrence(needs)}
     print(

{prodc-0.3.63 → prodc-0.3.64}/src/prodc/model.py

@@ -194,6 +194,43 @@ class Need:
         kinds = {s.kind for s in self.sources}
         return next((k for k in order if k in kinds), None)
 
+    @property
+    def counts_toward_coverage(self) -> bool:
+        """Whether this need is a unit of product coverage — what :func:`~prodc.status.summarize`
+        counts.
+
+        A leaf product need. A flow (a need with ``children``) is a roll-up of its leaves, so
+        counting it too would double-count (#43); a non-product need (infra/NFR/internal) is
+        excluded from product coverage (#48). Draft staging is a separate, upstream filter
+        (:func:`board_needs`), not part of this rule — so a draft still counts once promoted onto
+        the board (e.g. under ``--include-drafts``).
+        """
+        return not self.children and self.product
+
+    @property
+    def excluded_reason(self) -> str | None:
+        """Why this need is off the counted board, or ``None`` when it is on it.
+
+        The single home for the lifecycle exclusions, so a new state lands here once: ``"draft"``
+        (staged, not yet promoted, #60) and ``"nonproduct"`` (infra/NFR/internal, #48). A flow is
+        not excluded — it is a roll-up row on the board — so ``children`` is not a reason here
+        (that axis is :attr:`counts_toward_coverage`).
+        """
+        if self.draft:
+            return "draft"
+        if not self.product:
+            return "nonproduct"
+        return None
+
+
+def board_needs(needs: list[Need], *, include_drafts: bool) -> list[Need]:
+    """The needs on the counted board: a draft (#60) is staged off it until promoted.
+
+    ``include_drafts`` keeps them on (the ``--include-drafts`` flag). The one place the
+    draft-staging rule lives, shared by ``status`` and ``plan`` so the two never diverge.
+    """
+    return list(needs) if include_drafts else [n for n in needs if not n.draft]
+
 
 class ArgKind(StrEnum):
     """A node type in the assurance argument (GSN: Goal Structuring Notation)."""

{prodc-0.3.63 → prodc-0.3.64}/src/prodc/status.py

@@ -251,7 +251,7 @@ def summarize(results: list[NeedResult]) -> Summary:
     denominator too would double-count every flow (#43). Coverage is the leaves; a flow's own
     state is reported separately, never added on top of the children it aggregates.
     """
-    leaves = [r for r in results if not r.need.children and r.need.product]
+    leaves = [r for r in results if r.need.counts_toward_coverage]
     by_state = {s: sum(1 for r in leaves if r.state is s) for s in NeedState}
     return Summary(
         total=len(leaves),