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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.29.2
+Version: 0.30.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,9 @@ 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 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.30.0}/README.md

@@ -382,7 +382,9 @@ 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 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.30.0/evo_cli/VERSION

@@ -0,0 +1 @@
+0.30.0

{evo_cli-0.29.2 → evo_cli-0.30.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> prints one step 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.30.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.30.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.30.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.30.0/evo_cli/commands/harness/show.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+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, 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",
+}
+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 = "    "
+
+
+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 ""))
+
+
+@click.command("show", help="Read one exec-plan in the terminal, or one of its steps in full with --step.")
+@harness_option
+@click.argument("plan_id")
+@click.option("--section", "sections", multiple=True, type=click.Choice(SECTIONS), help="Only print some sections.")
+@click.option("--full", is_flag=True, help="Print notes verbatim instead of clipping to one line.")
+@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 SECTIONS:
+        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)

{evo_cli-0.29.2 → evo_cli-0.30.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.30.0}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.29.2
+Version: 0.30.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,9 @@ 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 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.30.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

evo_cli-0.30.0/tests/test_harness_show.py

@@ -0,0 +1,267 @@
+"""`evo harness show --step`, the open questions `show` lists, and the depends_on column of the step board."""
+
+from __future__ import annotations
+
+import re
+import textwrap
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from evo_cli.cli import cli
+from evo_cli.commands.harness._dag import step_depends
+from evo_cli.commands.harness._render import key_runs
+
+MIRROR_FIXTURE = Path(__file__).parent / "fixtures" / "hub" / "mirror-demo.yaml"
+
+LONG_WHAT = (
+    "A long folded sentence that runs on well past any terminal width, so the step view has to print it whole "
+    "rather than cut it at the end of the line, with tiếng Việt có dấu đầy đủ at the very end."
+)
+VERIFY = (
+    "V=$(git -C ~/github/alpha show origin/main:alpha/__init__.py | sed -n 's/x/\\1/p') "
+    '&& test "$(curl -fsS https://example.test/health | jq -r .version)" = "$V"'
+)
+PLAN = textwrap.dedent(
+    """\
+    id: demo
+    goal: A plan to read one step at a time.
+    steps:
+      - id: 1
+        title: First
+        repo: alpha
+        what: Start.
+        status: done
+        done_at: '2026-10-01'
+        evidence: 'alpha@abc1234: 12 passed'
+      - id: 2
+        title: Second
+        repo: alpha
+        what: Two.
+        status: done
+      - id: 3
+        title: Third
+        repo: beta
+        what: Three.
+        depends_on: [1, 2]
+        status: done
+      - id: 4
+        title: Wrap up
+        repo: beta
+        what: >
+          A long folded sentence that runs on well past any terminal width, so the step view has to print it
+          whole rather than cut it at the end of the line, with tiếng Việt có dấu đầy đủ at the very end.
+        depends_on: [1, 2, 3]
+        verify: >
+          VERIFY_HERE
+        status: pending
+        blocking: true
+        note: |
+          First line of the note.
+            Indented second line [bold]not markup[/bold].
+        acceptance:
+          - The first criterion.
+          - |
+            A criterion over
+            two lines.
+        why: Because the board needs it.
+        links: {pr: 12, commits: [abc1234]}
+      - id: 5
+        title: Optional polish
+        repo: beta
+        what: Polish.
+        depends_on: [4]
+        status: pending
+        blocking: false
+    open_questions:
+      - issue: Should the board show blocking?
+        status: open
+        blocking: false
+        note: Only when it is the exception.
+      - issue: Which width is enough?
+        status: answered
+    """
+).replace("VERIFY_HERE", VERIFY)
+
+
+def _harness(tmp_path: Path, body: str = PLAN, name: str = "demo", hub: bool = False) -> Path:
+    root = tmp_path / "cluster"
+    (root / "plans" / "active").mkdir(parents=True)
+    project = "hub:\n  project: demo\n" if hub else ""
+    (root / "harness.yaml").write_text(f"name: test-cluster\nrepos:\n  - name: alpha\n{project}", encoding="utf-8")
+    (root / "plans" / "active" / f"{name}.yaml").write_text(body, encoding="utf-8")
+    return root
+
+
+def _run(*args: str, columns: int = 80, env: dict | None = None):
+    return CliRunner().invoke(cli, ["harness", *args], env={"COLUMNS": str(columns), **(env or {})})
+
+
+def _lines(output: str) -> list[str]:
+    """Output lines with rich's colour codes taken out (CI makes rich colour even under CliRunner)."""
+    return re.sub(r"\x1b\[[0-9;]*[A-Za-z]", "", output).splitlines()
+
+
+def _flat(output: str) -> str:
+    return " ".join(re.sub(r"[─-╿]", " ", "\n".join(_lines(output))).split())
+
+
+# show --step
+
+
+def test_show_step_prints_every_field_of_one_step_without_clipping_or_wrapping(tmp_path):
+    root = _harness(tmp_path)
+
+    result = _run("show", "demo", "--step", "4", "--harness", str(root), columns=60)
+
+    assert result.exit_code == 0, result.output
+    lines = _lines(result.output)
+    assert lines[0].startswith("demo step 4")
+    head = [line.split(":", 1)[0] for line in lines[1:9]]
+    assert head == ["id", "title", "status", "repo", "depends_on", "blocking", "done_at", "why"]
+    assert any(line.split() == ["depends_on:", "1,", "2,", "3"] for line in lines)
+    assert any(line.split() == ["blocking:", "true"] for line in lines)
+    assert any(line.split() == ["done_at:", "-"] for line in lines)
+    assert any(line.split() == ["why:", "Because", "the", "board", "needs", "it."] for line in lines)
+
+    body = [line for line in lines if line.endswith(":") and not line.startswith(" ")]
+    assert body == ["what:", "verify:", "note:", "acceptance:", "evidence:", "links:"]
+    # Longer than the 60 columns rich was given, yet each sits on one line, whole.
+    assert "    " + VERIFY in lines
+    assert "    " + LONG_WHAT in lines
+    # A literal block keeps its line breaks and indentation, and brackets are not read as markup.
+    note = lines.index("note:")
+    assert lines[note + 1 : note + 3] == [
+        "    First line of the note.",
+        "      Indented second line [bold]not markup[/bold].",
+    ]
+    acceptance = lines.index("acceptance:")
+    assert lines[acceptance + 1 : acceptance + 4] == [
+        "    - The first criterion.",
+        "    - A criterion over",
+        "      two lines.",
+    ]
+    assert lines[lines.index("evidence:") + 1] == "    -"
+    # A key outside the schema is printed as well, a mapping as the YAML it is.
+    assert lines[lines.index("links:") + 1 :] == ["    pr: 12", "    commits:", "    - abc1234"]
+
+
+def test_show_step_prints_the_evidence_and_done_at_a_finished_step_carries(tmp_path):
+    root = _harness(tmp_path)
+
+    result = _run("show", "demo", "--step", "1", "--harness", str(root))
+
+    assert result.exit_code == 0, result.output
+    lines = _lines(result.output)
+    assert any(line.split() == ["done_at:", "2026-10-01"] for line in lines)
+    assert any(line.split() == ["depends_on:", "-"] for line in lines)
+    assert lines[lines.index("evidence:") + 1] == "    alpha@abc1234: 12 passed"
+
+
+def test_show_step_with_an_unknown_id_names_the_ids_the_plan_holds(tmp_path):
+    root = _harness(tmp_path)
+
+    result = _run("show", "demo", "--step", "99", "--harness", str(root), columns=2000)
+
+    assert result.exit_code == 1
+    assert "No step '99' in demo. Available: 1, 2, 3, 4, 5" in _flat(result.output)
+
+
+def test_show_step_refuses_to_mix_with_section(tmp_path):
+    root = _harness(tmp_path)
+
+    result = _run("show", "demo", "--step", "1", "--section", "steps", "--harness", str(root), columns=2000)
+
+    assert result.exit_code == 2
+    assert "--step prints one step; leave out --section." in _flat(result.output)
+
+
+def test_show_step_reads_the_copy_of_a_hub_plan_without_calling_the_hub(tmp_path):
+    # The copy evo-agents wrote, with its hub key and digest, in a harness whose plans live on the hub.
+    root = _harness(tmp_path, body=MIRROR_FIXTURE.read_text(encoding="utf-8"), name="mirror-demo", hub=True)
+    empty = tmp_path / "no-tools"
+    empty.mkdir()
+
+    # Nothing on PATH, so a call out to evo-agents could not succeed.
+    result = _run("show", "mirror-demo", "--step", "2", "--harness", str(root), env={"PATH": str(empty)})
+
+    assert result.exit_code == 0, result.output
+    lines = _lines(result.output)
+    assert lines[0].startswith("mirror-demo step 2")
+    assert any(line.split() == ["title:", "Ghi", "chú", "nhiều", "dòng"] for line in lines)
+    assert any(line.split() == ["depends_on:", "1"] for line in lines)
+    note = lines.index("note:")
+    assert lines[note + 1 : note + 3] == [
+        "    First line of the note.",
+        "    Second line: \"quoted\" and 'single'.",
+    ]
+
+
+# show lists the open questions
+
+
+def test_show_lists_each_open_question_with_its_status_and_blocking_once(tmp_path):
+    root = _harness(tmp_path)
+
+    result = _run("show", "demo", "--harness", str(root), columns=2000)
+
+    assert result.exit_code == 0, result.output
+    lines = [line.strip() for line in _lines(result.output)]
+    start = lines.index("Open questions (2)")
+    assert lines[start + 1 :] == [
+        "0 Should the board show blocking?  open",
+        "blocking: false",
+        "note: Only when it is the exception.",
+        "1 Which width is enough?  answered",
+        "blocking: -",
+    ]
+
+
+def test_show_has_no_open_questions_heading_for_a_plan_without_any(tmp_path):
+    root = _harness(
+        tmp_path, body="id: bare\ngoal: Nothing open.\nsteps:\n  - id: 1\n    what: Only step.\n", name="bare"
+    )
+
+    result = _run("show", "bare", "--harness", str(root), columns=2000)
+
+    assert result.exit_code == 0, result.output
+    assert "Open questions" not in result.output
+
+
+# The step board
+
+
+def test_step_board_shows_what_each_step_depends_on_and_marks_a_non_blocking_step(tmp_path):
+    root = _harness(tmp_path)
+
+    result = _run("step", "demo", "--no-input", "--harness", str(root), columns=200)
+
+    assert result.exit_code == 0, result.output
+    rows = {line.split()[0]: line.split() for line in _lines(result.output)[2:] if line.strip()}
+    assert _lines(result.output)[1].split() == ["#", "REPO", "STATUS", "DEPENDS", "ON", "STEP"]
+    assert rows["1"] == ["1", "alpha", "done", "-", "First"]
+    assert rows["3"] == ["3", "beta", "done", "1,", "2", "Third"]
+    assert rows["4"] == ["4", "beta", "pending", "1-3", "Wrap", "up"]
+    assert rows["5"] == ["5", "beta", "pending", "4", "Optional", "polish", "(non-blocking)"]
+
+
+def test_key_runs_collapses_only_runs_of_three_or_more_consecutive_integers():
+    assert key_runs([]) == "-"
+    assert key_runs(["11"]) == "11"
+    assert key_runs(["1", "2"]) == "1, 2"
+    assert key_runs(["1", "2", "3", "5"]) == "1-3, 5"
+    assert key_runs(["5", "6", "8", "9", "10"]) == "5, 6, 8-10"
+    assert key_runs(["3", "2", "1"]) == "3, 2, 1"
+    assert key_runs(["07", "8", "9"]) == "07, 8, 9"
+    assert key_runs(["a", "1", "2", "3", "b"]) == "a, 1-3, b"
+
+
+def test_step_depends_reads_every_forward_spelling_once_in_written_order():
+    assert step_depends({}) == []
+    assert step_depends({"depends_on": 3}) == ["3"]
+    assert step_depends({"depends_on": [2, 1], "depends_on_step": [1, 4], "blocked_by": "x", "blocks": [9]}) == [
+        "2",
+        "1",
+        "4",
+        "x",
+    ]

evo_cli-0.29.2/evo_cli/VERSION

@@ -1 +0,0 @@
-0.29.2