evo-cli 0.29.2__tar.gz → 0.31.0__tar.gz

{evo_cli-0.29.2 → evo_cli-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.29.2
+Version: 0.31.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli
@@ -415,7 +415,11 @@ evo harness serve      # dashboard on http://127.0.0.1:8788
 evo harness repos      # repos in the manifest, with branch and dirty state
 evo harness seams      # contract seams; --graph for the owner -> consumer DAG
 evo harness plans      # progress across every exec-plan
-evo harness show <plan>
+evo harness show <plan>                 # every section, open questions with status and blocking
+evo harness show <plan> --step 3        # one step in full: what, verify, note, acceptance, evidence
+evo harness show <plan> --section acceptance  # each criterion in full: id, criterion, verify, steps naming it
+evo harness show <plan> --section non_goals   # each non-goal in full
+evo harness step <plan> --no-input      # the step board: repo, status, depends_on, title
 evo harness check <plan> [--fetch]      # what the plan claims vs what git says
 evo harness graph <plan>:steps          # the same DAG as an adjacency list
 evo harness clone      # clone every declared repo into its declared path

{evo_cli-0.29.2 → evo_cli-0.31.0}/README.md

@@ -382,7 +382,11 @@ evo harness serve      # dashboard on http://127.0.0.1:8788
 evo harness repos      # repos in the manifest, with branch and dirty state
 evo harness seams      # contract seams; --graph for the owner -> consumer DAG
 evo harness plans      # progress across every exec-plan
-evo harness show <plan>
+evo harness show <plan>                 # every section, open questions with status and blocking
+evo harness show <plan> --step 3        # one step in full: what, verify, note, acceptance, evidence
+evo harness show <plan> --section acceptance  # each criterion in full: id, criterion, verify, steps naming it
+evo harness show <plan> --section non_goals   # each non-goal in full
+evo harness step <plan> --no-input      # the step board: repo, status, depends_on, title
 evo harness check <plan> [--fetch]      # what the plan claims vs what git says
 evo harness graph <plan>:steps          # the same DAG as an adjacency list
 evo harness clone      # clone every declared repo into its declared path

evo_cli-0.31.0/evo_cli/VERSION

@@ -0,0 +1 @@
+0.31.0

{evo_cli-0.29.2 → evo_cli-0.31.0}/evo_cli/commands/harness/__init__.py

@@ -18,7 +18,7 @@ def harness_group():
     evo harness repos              repos in the manifest, with git state
     evo harness seams              contract seams: owner, consumers, verify command
     evo harness plans              progress across every exec-plan
-    evo harness show <plan>        read one plan
+    evo harness show <plan>        read one plan (--step <id>, --section acceptance|non_goals: in full)
     evo harness graph <plan>       print a DAG as an adjacency list
     evo harness check <plan>       check what the plan claims against real git
     evo harness step <plan> 3 done mark a step (--evidence and --note append)

{evo_cli-0.29.2 → evo_cli-0.31.0}/evo_cli/commands/harness/_dag.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import itertools
 from pathlib import Path
 
+import rich_click as click
+
 from evo_cli.commands.harness._model import Plan, cluster, load_seams, step_title, tone_of
 
 CLUSTER_REPO = "__cluster__"
@@ -285,6 +287,17 @@ def step_key(entry: dict, index: int) -> str:
     return str(index)
 
 
+def resolve_step(plan: Plan, key) -> int:
+    """Index of the step whose key is KEY. An unknown key fails with every key the plan holds."""
+    entries = plan.items("steps")
+    wanted = str(key)
+    for index, entry in enumerate(entries):
+        if step_key(entry, index) == wanted:
+            return index
+    known = ", ".join(step_key(e, i) for i, e in enumerate(entries)) or "(the plan has no steps)"
+    raise click.ClickException(f"No step {wanted!r} in {plan.id}. Available: {known}")
+
+
 def _as_list(value) -> list:
     if value is None:
         return []
@@ -293,6 +306,16 @@ def _as_list(value) -> list:
     return [value]
 
 
+def step_depends(entry: dict) -> list[str]:
+    """Keys of the steps this one waits on, in written order, from every spelling the step graph reads."""
+    found: list[str] = []
+    for name in FORWARD_KEYS:
+        for raw in _as_list(entry.get(name)):
+            if str(raw) not in found:
+                found.append(str(raw))
+    return found
+
+
 def plan_step_graph(plan: Plan) -> dict:
     steps = plan.items("steps")
     repo_entries = plan.items("repos")

{evo_cli-0.29.2 → evo_cli-0.31.0}/evo_cli/commands/harness/_render.py

@@ -31,6 +31,40 @@ def one_line(value: object, width: int) -> str:
     return text if len(text) <= width else text[: max(1, width - 3)] + "..."
 
 
+def as_text(value: object) -> str:
+    """A plan value the way YAML spells it: booleans as true/false, lists joined, nothing as `-`."""
+    if value is None or value == "" or value == []:
+        return "-"
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (list, tuple)):
+        return ", ".join(as_text(v) for v in value)
+    return str(value)
+
+
+def key_runs(keys: list[str]) -> str:
+    """Step keys in written order, with a run of three or more consecutive integers shown as `first-last`."""
+    parts: list[str] = []
+    run: list[int] = []
+
+    def flush() -> None:
+        parts.extend([f"{run[0]}-{run[-1]}"] if len(run) >= 3 else [str(n) for n in run])
+        run.clear()
+
+    for key in keys:
+        number = int(key) if key.isascii() and key.isdigit() and str(int(key)) == key else None
+        if number is not None and run and number == run[-1] + 1:
+            run.append(number)
+            continue
+        flush()
+        if number is None:
+            parts.append(key)
+        else:
+            run.append(number)
+    flush()
+    return ", ".join(parts) or "-"
+
+
 def title_width(reserved: int = 26) -> int:
     return max(28, min(console.width, 140) - reserved)
 

{evo_cli-0.29.2 → evo_cli-0.31.0}/evo_cli/commands/harness/edit.py

@@ -5,7 +5,7 @@ from datetime import datetime
 import rich_click as click
 from rich.markup import escape
 
-from evo_cli.commands.harness._dag import step_key
+from evo_cli.commands.harness._dag import resolve_step, step_key
 from evo_cli.commands.harness._model import find_plan, step_title, tone_of
 from evo_cli.commands.harness._mutate import update_item
 from evo_cli.commands.harness._paths import find_manifest, harness_option
@@ -70,16 +70,6 @@ def _write(manifest_path, plan_id, section, index, status, note, no_date, eviden
         console.print(f"      [yellow]note:[/] {escape(text)}")
 
 
-def _resolve_step(item, key) -> int:
-    entries = item.items("steps")
-    wanted = str(key)
-    for index, entry in enumerate(entries):
-        if step_key(entry, index) == wanted:
-            return index
-    known = ", ".join(step_key(e, i) for i, e in enumerate(entries))
-    raise click.ClickException(f"No step {wanted!r} in {item.id}. Available: {known}")
-
-
 def _pick(item, key, status):
     """Interactive picker, but only when questionary is installed and we own a real terminal."""
     try:
@@ -104,7 +94,7 @@ def _pick(item, key, status):
             raise click.Abort()
 
     if status is None:
-        index = _resolve_step(item, key)
+        index = resolve_step(item, key)
         current = str(entries[index].get("status") or "")
         suggested = NEXT_STATUS.get(current, STEP_STATUS[0])
         status = questionary.select(
@@ -150,7 +140,7 @@ def step(harness_path, plan_id, key, status, note, evidence, no_date, no_input):
         if key is None or status is None:
             return
 
-    _write(manifest_path, plan_id, "steps", _resolve_step(item, key), status, note, no_date, evidence)
+    _write(manifest_path, plan_id, "steps", resolve_step(item, key), status, note, no_date, evidence)
     console.print()
     step_board(find_plan(manifest_path, plan_id), highlight=key)
 

evo_cli-0.31.0/evo_cli/commands/harness/show.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import re
+
+import rich_click as click
+import yaml
+from rich.panel import Panel
+from rich.text import Text
+
+from evo_cli.commands.harness._dag import resolve_step, step_key
+from evo_cli.commands.harness._model import SECTIONS, find_plan, plain, tone_of
+from evo_cli.commands.harness._paths import find_manifest, harness_option
+from evo_cli.commands.harness._render import TONE_STYLE, as_text, bar, key_runs, one_line, title_width
+from evo_cli.console import console
+
+SECTION_TITLES = {
+    "references": "References",
+    "repos": "Repos and merge order",
+    "steps": "Steps",
+    "decisions": "Decisions",
+    "tech_debt": "Tech debt",
+    "open_questions": "Open questions",
+    "acceptance": "Acceptance",
+    "non_goals": "Non-goals",
+}
+# Plan-level lists `show` prints whole. They stay out of SECTIONS, which also shapes the
+# dashboard's plan detail, where both are still read from `extra`.
+PLAN_LISTS = ("acceptance", "non_goals")
+SHOW_SECTIONS = (*SECTIONS, *PLAN_LISTS)
+HIDE_KEYS = {"status", "order", "what", "repo", "id"}
+# Every open question says whether it blocks, even one whose author left the key out.
+ALWAYS_SHOWN = {"open_questions": ("blocking",)}
+
+STEP_HEAD = ("id", "title", "status", "repo", "depends_on", "blocking", "done_at")
+STEP_BODY = ("what", "verify", "note", "acceptance", "evidence")
+INDENT = "    "
+FIELD_INDENT = "      "
+# A step's `acceptance` names criteria by id, as a list or as text like "a1; a9"; prose around them is not an id.
+CRITERION_ID = re.compile(r"^a\d+$")
+CRITERION_TEXT = ("criterion", "what")
+
+
+def _render_item(section: str, index: int, item: dict, full: bool) -> None:
+    status = item.get("status")
+    style = TONE_STYLE[tone_of(section, status)]
+    authored = item.get("title")
+    titled = isinstance(authored, str) and bool(authored.strip())
+    if titled:
+        head, hidden = authored.strip(), (HIDE_KEYS - {"what"}) | {"title"}
+    else:
+        head = item.get("what") or item.get("repo") or item.get("issue") or "?"
+        hidden = HIDE_KEYS | ({"issue"} if head == item.get("issue") else set())
+    label = item.get("id", item.get("order", index))
+    badge = f"[{style}]{status}[/]" if status else ""
+    if not full:
+        head = one_line(head, title_width(reserved=18))
+    console.print(f"  [bold]{label:>3}[/] {head}  {badge}")
+    fields = {**item, **{key: item.get(key) for key in ALWAYS_SHOWN.get(section, ())}}
+    for key, value in fields.items():
+        if key in hidden:
+            continue
+        if isinstance(value, list):
+            value = "; ".join(as_text(v) for v in value) or "-"
+        text = " ".join(as_text(value).split())
+        console.print(f"      [dim]{key}:[/] {text if full else one_line(text, title_width(reserved=18))}")
+
+
+def _block(value: object) -> list[str]:
+    """Lines of a value printed under its key: text keeps its line breaks, a list becomes `- ` items."""
+    if value is None or value == "" or value == []:
+        return ["-"]
+    if isinstance(value, list):
+        lines = []
+        for entry in value:
+            first, *rest = _block(entry)
+            lines.append(f"- {first}")
+            lines.extend(f"  {line}" if line else "" for line in rest)
+        return lines
+    if isinstance(value, dict):
+        dumped = yaml.safe_dump(plain(value), allow_unicode=True, sort_keys=False, width=1_000_000)
+        return dumped.rstrip("\n").split("\n")
+    return as_text(value).rstrip("\n").split("\n")
+
+
+def _is_short(value: object) -> bool:
+    nested = isinstance(value, dict) or (isinstance(value, list) and any(isinstance(v, (dict, list)) for v in value))
+    text = as_text(value)
+    return not nested and "\n" not in text and len(text) <= 80
+
+
+def _print(text: Text) -> None:
+    # Soft wrap: rich never breaks a line itself, so a verify command stays one copyable line.
+    console.print(text, soft_wrap=True)
+
+
+def _print_step(item, key: str) -> None:
+    index = resolve_step(item, key)
+    entry = item.items("steps")[index]
+    key = step_key(entry, index)
+    _print(Text.assemble((item.id, "bold cyan"), " step ", (key, "bold"), (f"  ({item.area})", "dim")))
+
+    # Any other key the step carries is printed too: short scalars beside the head, the rest as blocks.
+    extra = [k for k in entry if k not in STEP_HEAD and k not in STEP_BODY]
+    inline = [k for k in extra if _is_short(entry[k])]
+    head = [*STEP_HEAD, *inline]
+    width = max(len(k) for k in head) + 1
+    for name in head:
+        value = as_text(entry.get(name))
+        style = TONE_STYLE[tone_of("steps", value)] if name == "status" and value != "-" else ""
+        _print(Text.assemble((f"{name + ':':<{width}} ", "dim"), (value, style)))
+
+    for name in [*STEP_BODY, *(k for k in extra if k not in inline)]:
+        _print(Text())
+        _print(Text(f"{name}:", style="bold"))
+        for line in _block(entry.get(name)):
+            _print(Text(INDENT + line if line else ""))
+
+
+def _plan_list(item, name: str) -> list:
+    """A plan-level list as written: `acceptance` holds mappings or plain strings, `non_goals` mostly strings."""
+    value = item.raw.get(name)
+    if value is None or value == "" or value == []:
+        return []
+    return [entry for entry in (value if isinstance(value, list) else [value]) if entry is not None]
+
+
+def criterion_refs(value: object) -> list[str]:
+    """The criterion ids a step's `acceptance` names, once each, in written order."""
+    found: list[str] = []
+    for entry in value if isinstance(value, list) else [value]:
+        if entry is None or isinstance(entry, (dict, list)):
+            continue
+        for token in re.split(r"[\s,;]+", as_text(entry)):
+            if CRITERION_ID.match(token) and token not in found:
+                found.append(token)
+    return found
+
+
+def _steps_by_criterion(item) -> dict[str, list[str]]:
+    named: dict[str, list[str]] = {}
+    for index, entry in enumerate(item.items("steps")):
+        for ref in criterion_refs(entry.get("acceptance")):
+            named.setdefault(ref, []).append(step_key(entry, index))
+    return named
+
+
+def _print_whole(label: str, value: object, fields: list[tuple[str, object]], badge: Text | None = None) -> None:
+    """One entry laid out as the board lays it out, label then text then `key: value` lines, but nothing clipped."""
+    first, *rest = _block(value)
+    _print(Text.assemble("  ", (f"{label:>3}", "bold"), " ", first, *(("  ", badge) if badge else ())))
+    for line in rest:
+        _print(Text(FIELD_INDENT + line if line else ""))
+    for key, field in fields:
+        lines = _block(field)
+        if len(lines) == 1:
+            _print(Text.assemble(FIELD_INDENT, (f"{key}:", "dim"), " ", lines[0]))
+            continue
+        _print(Text.assemble(FIELD_INDENT, (f"{key}:", "dim")))
+        for line in lines:
+            _print(Text(FIELD_INDENT + INDENT + line if line else ""))
+
+
+def _render_acceptance(item, asked: bool) -> None:
+    criteria = _plan_list(item, "acceptance")
+    named = _steps_by_criterion(item)
+    if not criteria and not asked:
+        return
+    count = f"({len(criteria)})" if criteria else "(none in this plan)"
+    _print(Text.assemble("\n", ("Acceptance", "bold cyan"), " ", (count, "dim")))
+    ids: set[str] = set()
+    for index, entry in enumerate(criteria):
+        if not isinstance(entry, dict):
+            _print_whole(str(index), entry, [])
+            continue
+        text_key = next((key for key in CRITERION_TEXT if key in entry), None)
+        status = entry.get("status")
+        badge = Text(as_text(status), style=TONE_STYLE[tone_of("acceptance", as_text(status))]) if status else None
+        rest = [(key, value) for key, value in entry.items() if key not in ("id", "status", text_key)]
+        # verify first, the way a reader checks a criterion; any other key after it, as written.
+        fields = sorted(rest, key=lambda pair: pair[0] != "verify")
+        label = str(index) if entry.get("id") is None else str(entry["id"])
+        if entry.get("id") is not None:
+            ids.add(label)
+            fields.append(("steps", key_runs(named.get(label, []))))
+        _print_whole(label, entry.get(text_key) if text_key else "?", fields, badge)
+    unknown = [f"{ref} (step {key_runs(keys)})" for ref, keys in named.items() if ref not in ids]
+    if unknown:
+        _print(Text.assemble(("  steps name criteria this plan does not have: ", "yellow"), "; ".join(unknown)))
+
+
+def _render_non_goals(item, asked: bool) -> None:
+    goals = _plan_list(item, "non_goals")
+    if not goals and not asked:
+        return
+    count = f"({len(goals)})" if goals else "(none in this plan)"
+    _print(Text.assemble("\n", ("Non-goals", "bold cyan"), " ", (count, "dim")))
+    for index, entry in enumerate(goals):
+        _print_whole(str(index), entry, [])
+
+
+def _count_plan_lists(item) -> None:
+    """The board stays short: one line per plan-level list, saying how to print it whole."""
+    for name in PLAN_LISTS:
+        entries = _plan_list(item, name)
+        if entries:
+            _print(
+                Text.assemble(
+                    "\n", (SECTION_TITLES[name], "bold cyan"), (f" ({len(entries)})  in full: --section {name}", "dim")
+                )
+            )
+
+
+@click.command(
+    "show",
+    help="Read one exec-plan in the terminal, or one of its steps in full with --step. "
+    "The board counts the plan's acceptance criteria and non-goals; --section acceptance or "
+    "--section non_goals prints them in full.",
+)
+@harness_option
+@click.argument("plan_id")
+@click.option(
+    "--section",
+    "sections",
+    multiple=True,
+    type=click.Choice(SHOW_SECTIONS),
+    help="Only print some sections. acceptance prints each criterion whole (id, criterion, verify, the steps "
+    "naming it); non_goals prints each non-goal whole.",
+)
+@click.option(
+    "--full",
+    is_flag=True,
+    help="Print notes verbatim instead of clipping to one line, and acceptance and non_goals in full.",
+)
+@click.option(
+    "--step",
+    "step_id",
+    metavar="ID",
+    help="Print only this step, every field as written: what, verify, note, acceptance and evidence unclipped.",
+)
+def show(harness_path, plan_id, sections, full, step_id):
+    item = find_plan(find_manifest(harness_path), plan_id)
+    if step_id is not None:
+        if sections:
+            raise click.UsageError("--step prints one step; leave out --section.")
+        _print_step(item, step_id)
+        return
+
+    p = item.progress()
+
+    console.print(
+        Panel(
+            " ".join(str(item.raw.get("goal") or "").split()),
+            title=f"[bold]{item.id}[/] [dim]({item.area})[/]",
+            subtitle=f"{bar(p['steps_done'], p['steps_total'])} {p['steps_done']}/{p['steps_total']} steps  "
+            f"debt: {p['debt_open']}  questions: {p['questions_open']}",
+            border_style="cyan",
+        )
+    )
+
+    for name in sections or (SHOW_SECTIONS if full else SECTIONS):
+        if name == "acceptance":
+            _render_acceptance(item, asked=bool(sections))
+            continue
+        if name == "non_goals":
+            _render_non_goals(item, asked=bool(sections))
+            continue
+        entries = item.items(name)
+        if not entries:
+            continue
+        console.print(f"\n[bold cyan]{SECTION_TITLES[name]}[/] [dim]({len(entries)})[/]")
+        for index, entry in enumerate(entries):
+            _render_item(name, index, entry, full)
+    if not sections and not full:
+        _count_plan_lists(item)

{evo_cli-0.29.2 → evo_cli-0.31.0}/evo_cli/commands/harness/views.py

@@ -2,12 +2,13 @@ from __future__ import annotations
 
 import rich_click as click
 
-from evo_cli.commands.harness._dag import plan_repo_graph, plan_step_graph, seam_graph, step_key
+from evo_cli.commands.harness._dag import plan_repo_graph, plan_step_graph, seam_graph, step_depends, step_key
 from evo_cli.commands.harness._model import cluster, find_plan, load_plans, load_seams, step_title, tone_of
 from evo_cli.commands.harness._paths import find_manifest, git, harness_option
 from evo_cli.commands.harness._render import (
     TONE_STYLE,
     bar,
+    key_runs,
     one_line,
     print_graph,
     print_warnings,
@@ -144,18 +145,21 @@ def step_board(item, highlight=None) -> None:
         console.print("[dim]  This plan has no steps yet.[/]")
         return
 
-    width = title_width()
-    grid = table("", "#", "REPO", "STATUS", "STEP")
+    width = title_width(reserved=38)
+    grid = table("", "#", "REPO", "STATUS", "DEPENDS ON", "STEP")
     for index, entry in enumerate(steps):
         status = entry.get("status")
         style = TONE_STYLE[tone_of("steps", status)]
         key = step_key(entry, index)
         marker = "[bold cyan]>[/]" if highlight is not None and key == str(highlight) else " "
+        # Nearly every step is blocking, so only the exception is marked.
+        optional = "  [dim](non-blocking)[/]" if entry.get("blocking") is False else ""
         grid.add_row(
             marker,
             f"[bold]{key}[/]",
             str(entry.get("repo") or "-"),
             f"[{style}]{status or '-'}[/]",
-            step_title(entry, width),
+            key_runs(step_depends(entry)),
+            step_title(entry, width) + optional,
         )
     console.print(grid)

{evo_cli-0.29.2 → evo_cli-0.31.0}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.29.2
+Version: 0.31.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli
@@ -415,7 +415,11 @@ evo harness serve      # dashboard on http://127.0.0.1:8788
 evo harness repos      # repos in the manifest, with branch and dirty state
 evo harness seams      # contract seams; --graph for the owner -> consumer DAG
 evo harness plans      # progress across every exec-plan
-evo harness show <plan>
+evo harness show <plan>                 # every section, open questions with status and blocking
+evo harness show <plan> --step 3        # one step in full: what, verify, note, acceptance, evidence
+evo harness show <plan> --section acceptance  # each criterion in full: id, criterion, verify, steps naming it
+evo harness show <plan> --section non_goals   # each non-goal in full
+evo harness step <plan> --no-input      # the step board: repo, status, depends_on, title
 evo harness check <plan> [--fetch]      # what the plan claims vs what git says
 evo harness graph <plan>:steps          # the same DAG as an adjacency list
 evo harness clone      # clone every declared repo into its declared path

{evo_cli-0.29.2 → evo_cli-0.31.0}/evo_cli.egg-info/SOURCES.txt

@@ -133,6 +133,7 @@ tests/test_harness.py
 tests/test_harness_clone.py
 tests/test_harness_dag.py
 tests/test_harness_hub.py
+tests/test_harness_show.py
 tests/test_image.py
 tests/test_mcp.py
 tests/test_ngrok.py