code-coordinator 0.5.111__tar.gz → 0.5.112__tar.gz

{code_coordinator-0.5.111 → code_coordinator-0.5.112}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.111
+Version: 0.5.112
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.111 → code_coordinator-0.5.112}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.111
+Version: 0.5.112
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.111 → code_coordinator-0.5.112}/code_coordinator.egg-info/SOURCES.txt

@@ -786,6 +786,7 @@ tests/acceptance/ms-example/mocks/home-active.html
 tests/fixtures/board-pipeline-basic.json
 tests/fixtures/board-pipeline-terminal-gates.json
 tests/fixtures/opencode_run_failure_sample.jsonl
+tests/fixtures/opencode_run_length_sample.jsonl
 tests/fixtures/opencode_run_sample.jsonl
 tests/fixtures/playwright/all_pass.json
 tests/fixtures/playwright/global_setup_crash.json

{code_coordinator-0.5.111 → code_coordinator-0.5.112}/code_coordinator.egg-info/scm_file_list.json

@@ -433,6 +433,7 @@
     "tests/fixtures/board-pipeline-basic.json",
     "tests/fixtures/board-pipeline-terminal-gates.json",
     "tests/fixtures/opencode_run_failure_sample.jsonl",
+    "tests/fixtures/opencode_run_length_sample.jsonl",
     "tests/fixtures/opencode_run_sample.jsonl",
     "tests/fixtures/playwright/all_pass.json",
     "tests/fixtures/playwright/global_setup_crash.json",

{code_coordinator-0.5.111 → code_coordinator-0.5.112}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.111",
+  "tag": "0.5.112",
   "distance": 0,
-  "node": "g0bbfb660d44f1e03dcf6d5ded5b11f804d43aae9",
+  "node": "g6173265320032222560fcd77419a9f74fc98d14e",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-16"

{code_coordinator-0.5.111 → code_coordinator-0.5.112}/coord/worker_events.py

@@ -462,7 +462,15 @@ def _tool_name_from_event(event: WorkerEvent) -> str | None:
     """Try a few plausible field paths for the tool name."""
     raw = event.raw
     if event.type == "tool_use":
-        return raw.get("name") or raw.get("tool") or raw.get("tool_name")
+        name = raw.get("name") or raw.get("tool") or raw.get("tool_name")
+        if name:
+            return name
+        # #2315: opencode's `tool_use` events carry the name one level down,
+        # at `part.tool` — {"type":"tool_use","part":{"tool":"bash",...}} —
+        # not at any of the top-level keys above, which is why every opencode
+        # tool call used to render `[tool] ?`.
+        tool, _ = _opencode_tool_input(raw)
+        return tool
     # Assistant events may embed a tool_use block in `message.content[*]`.
     if event.type == "assistant":
         message = raw.get("message") or {}
@@ -472,6 +480,29 @@ def _tool_name_from_event(event: WorkerEvent) -> str | None:
     return None
 
 
+def _opencode_tool_input(raw: dict) -> tuple[str | None, dict | None]:
+    """Pull ``(tool_name, input_dict)`` out of an opencode ``tool_use``
+    event's nested ``part`` (#2315).
+
+    opencode's wire shape is ``{"type":"tool_use","part":{"tool":"bash",
+    "state":{"input":{"command":"..."},...}}}`` — see
+    :meth:`coord.providers.opencode.OpenCodeProvider.parse_log`'s docstring,
+    which this mirrors (the provider's own parser already reads this
+    correctly; this is the same lookup for the render side). Returns
+    ``(None, None)`` for anything else — missing/malformed ``part``, or a
+    ``state.input`` that isn't a dict.
+    """
+    part = raw.get("part")
+    if not isinstance(part, dict):
+        return None, None
+    tool = part.get("tool")
+    tool = tool if isinstance(tool, str) and tool else None
+    state = part.get("state")
+    input_obj = state.get("input") if isinstance(state, dict) else None
+    input_obj = input_obj if isinstance(input_obj, dict) else None
+    return tool, input_obj
+
+
 def _iter_content_blocks(message: dict) -> Iterable[dict]:
     """Yield content blocks from an Anthropic-style message payload."""
     content = message.get("content")
@@ -493,6 +524,12 @@ def _bash_command_from_event(event: WorkerEvent) -> str | None:
         for block in _iter_content_blocks(message):
             if block.get("type") == "tool_use" and block.get("name") == "Bash":
                 return _command_from_input(block.get("input"))
+    if event.type == "tool_use":
+        # #2315: opencode's bash call — command lives at `part.state.input.
+        # command`, tool name (lowercase) at `part.tool`.
+        tool, input_obj = _opencode_tool_input(raw)
+        if tool == "bash":
+            return _command_from_input(input_obj)
     return None
 
 
@@ -506,13 +543,24 @@ def _command_from_input(input_obj: object) -> str | None:
 
 
 def _file_path_from_event(event: WorkerEvent) -> str | None:
-    """Pull file_path out of an Edit/Write tool_use, if present."""
+    """Pull file_path out of an Edit/Write tool_use, if present.
+
+    Name matching is case-insensitive so this covers both claude's
+    ``Edit``/``Write``/``NotebookEdit`` and opencode's lowercase ``edit``/
+    ``write`` (#2315).
+    """
     raw = event.raw
     name = _tool_name_from_event(event)
-    if name not in ("Edit", "Write", "NotebookEdit"):
+    if not name or name.lower() not in ("edit", "write", "notebookedit"):
         return None
     if event.type == "tool_use":
-        return _file_from_input(raw.get("input"))
+        input_obj = raw.get("input")
+        if input_obj is not None:
+            return _file_from_input(input_obj)
+        # #2315: opencode carries the input nested under `part.state.input`
+        # rather than a top-level `input` key.
+        _, opencode_input = _opencode_tool_input(raw)
+        return _file_from_input(opencode_input)
     if event.type == "assistant":
         message = raw.get("message") or {}
         for block in _iter_content_blocks(message):
@@ -528,7 +576,8 @@ def _file_path_from_event(event: WorkerEvent) -> str | None:
 def _file_from_input(input_obj: object) -> str | None:
     if not isinstance(input_obj, dict):
         return None
-    for key in ("file_path", "path", "notebook_path"):
+    # `filePath` is opencode's key (#2315); the rest are claude's.
+    for key in ("file_path", "path", "notebook_path", "filePath"):
         v = input_obj.get(key)
         if isinstance(v, str):
             return v
@@ -1012,10 +1061,15 @@ def render_event(event: WorkerEvent, *, turn_counter: list[int] | None = None) -
 
     if event.type == "tool_use":
         name = _tool_name_from_event(event) or "?"
-        if name == "Bash":
+        # Case-insensitive: claude's tool names are `Bash`/`Edit`/`Write`/
+        # `NotebookEdit`; opencode's equivalents are lowercase (#2315). The
+        # original casing from *name* is kept in the rendered line either
+        # way — only the branch dispatch is case-insensitive.
+        name_lower = name.lower()
+        if name_lower == "bash":
             cmd = _bash_command_from_event(event) or ""
-            return f"[tool] Bash: {_truncate(cmd, 100)}"
-        if name in ("Edit", "Write", "NotebookEdit"):
+            return f"[tool] {name}: {_truncate(cmd, 100)}"
+        if name_lower in ("edit", "write", "notebookedit"):
             fp = _file_path_from_event(event)
             return f"[tool] {name}: {fp or '?'}"
         return f"[tool] {name}"
@@ -1027,6 +1081,44 @@ def render_event(event: WorkerEvent, *, turn_counter: list[int] | None = None) -
         tag = " error" if is_error else ""
         return f"[tool_result{tag}] {tool_use_id}"
 
+    if event.type == "step_finish":
+        # opencode's per-turn completion event (#2315) — claude has no
+        # equivalent. `part.reason` is `"tool-calls"` for every turn but the
+        # last one (which is always followed by another `step_start`);
+        # anything else — `"stop"` (normal completion), `"length"` (ran out
+        # of output budget mid-turn), `"error"`, or any other value — means
+        # the run ended on THIS step, because opencode never emits a
+        # terminal event of its own the way claude's `result` event above
+        # does (see OpenCodeProvider.parse_log's docstring). So a
+        # non-"tool-calls" reason also gets an appended `[result]` line —
+        # the only place `coord log` ever prints a stop reason for an
+        # opencode run. Cost/tokens here are this step's own figures (there
+        # is no cumulative-total field anywhere in opencode's stream, so a
+        # single event can't report a running total — see the same
+        # docstring), which is still the diagnostic fact that matters: e.g.
+        # `reason=length out=32000 $0.145` says outright that the model
+        # spent its whole output budget on one turn and got cut off.
+        part = raw.get("part")
+        part = part if isinstance(part, dict) else {}
+        # `reason_raw` (as opposed to `reason`, the display value with the
+        # `?` placeholder substituted in) drives the terminality check below
+        # — a genuinely absent/malformed reason must NOT be treated as
+        # terminal just because the placeholder string happens to differ
+        # from `"tool-calls"`.
+        reason_raw = part.get("reason")
+        reason_raw = reason_raw if isinstance(reason_raw, str) and reason_raw else None
+        reason = reason_raw or "?"
+        tokens = part.get("tokens")
+        tokens = tokens if isinstance(tokens, dict) else {}
+        out_tok = tokens.get("output")
+        out_str = str(out_tok) if isinstance(out_tok, int) else "?"
+        cost = part.get("cost")
+        cost_str = f"${float(cost):.3f}" if isinstance(cost, (int, float)) else "$?"
+        line = f"[step_finish] reason={reason} out={out_str} {cost_str}"
+        if reason_raw is not None and reason_raw != "tool-calls":
+            line += f"\n[result] stop={reason_raw}, {cost_str}"
+        return line
+
     if event.type == "rate_limit_event":
         status, resets = _rate_limit_info(raw)
         return f"[rate_limit] status={status or '?'} resets_at={resets if resets is not None else '?'}"

code_coordinator-0.5.112/tests/fixtures/opencode_run_length_sample.jsonl

@@ -0,0 +1,5 @@
+{"type":"step_start","timestamp":1785788589000,"sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","part":{"id":"prt_2315len001peaLrUkvfXkzF4","messageID":"msg_2315len001B2TN1bVanhA48U","sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","snapshot":"40c925c779fe9cd39801d60400818aa70d6a49b0","type":"step-start"}}
+{"type":"tool_use","timestamp":1785788589900,"sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","part":{"type":"tool","tool":"bash","callID":"call_2315len_01","state":{"status":"completed","input":{"command":"git status"},"output":"On branch issue-2315\nnothing to commit, working tree clean\n","metadata":{},"title":"","time":{"start":1785788589850,"end":1785788589890}},"id":"prt_2315len002D1oKOLzO3u64k1","sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","messageID":"msg_2315len001B2TN1bVanhA48U"}}
+{"type":"step_finish","timestamp":1785788589950,"sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","part":{"id":"prt_2315len003QbgfV5ZEEm7pIO","reason":"tool-calls","snapshot":"40c925c779fe9cd39801d60400818aa70d6a49b0","messageID":"msg_2315len001B2TN1bVanhA48U","sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","type":"step-finish","tokens":{"total":520,"input":440,"output":80,"reasoning":0,"cache":{"write":0,"read":0}},"cost":0.002}}
+{"type":"step_start","timestamp":1785788590600,"sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","part":{"id":"prt_2315len004abWeGE97E8opKR","messageID":"msg_2315len004XNhYw1dBJxV99P","sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","snapshot":"40c925c779fe9cd39801d60400818aa70d6a49b0","type":"step-start"}}
+{"type":"step_finish","timestamp":1785788969600,"sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","part":{"id":"prt_2315len005pw1TMWsekKMlNS","reason":"length","snapshot":"40c925c779fe9cd39801d60400818aa70d6a49b0","messageID":"msg_2315len004XNhYw1dBJxV99P","sessionID":"ses_2315len4ffeIOILOMFtWVIoOb","type":"step-finish","tokens":{"total":32410,"input":410,"output":32000,"reasoning":32000,"cache":{"write":0,"read":0}},"cost":0.145}}

{code_coordinator-0.5.111 → code_coordinator-0.5.112}/tests/test_worker_events.py

@@ -98,6 +98,50 @@ def _rate_limit_event(
     }
 
 
+def _opencode_tool_use_event(
+    tool: str, tool_input: dict, *, session_id: str = "ses_test", status: str = "completed"
+) -> dict:
+    """opencode's real ``tool_use`` wire shape (#2315): the tool name and its
+    input live nested under ``part``/``part.state.input``, not at the
+    top-level keys claude's stream-json uses — see
+    ``tests/fixtures/opencode_run_sample.jsonl`` for a verbatim capture of
+    the same shape."""
+    return {
+        "type": "tool_use",
+        "sessionID": session_id,
+        "part": {
+            "type": "tool",
+            "tool": tool,
+            "state": {"status": status, "input": tool_input},
+        },
+    }
+
+
+def _opencode_step_finish_event(
+    reason: str,
+    *,
+    output_tokens: int = 10,
+    cost: float = 0.0,
+    session_id: str = "ses_test",
+) -> dict:
+    """opencode's real ``step_finish`` wire shape (#2315): one per completed
+    turn/step, ``part.reason`` is ``"tool-calls"`` for every turn but the
+    last."""
+    return {
+        "type": "step_finish",
+        "sessionID": session_id,
+        "part": {
+            "reason": reason,
+            "tokens": {
+                "input": 5,
+                "output": output_tokens,
+                "cache": {"write": 0, "read": 0},
+            },
+            "cost": cost,
+        },
+    }
+
+
 # ── parse_event ────────────────────────────────────────────────────────────
 
 
@@ -560,6 +604,171 @@ class TestRender:
         assert any("result" in l for l in lines)
 
 
+# ── opencode rendering (#2315) ───────────────────────────────────────────
+#
+# `coord log` rendered an opencode worker's NDJSON through the claude-only
+# schema, dropping the tool name, the step_finish payload (reason/tokens/
+# cost), and any terminal stop-reason line. These tests pin the fix at the
+# `render_event` level — the same function `coord log` calls per line for
+# both providers — using opencode's REAL wire shape (nested under `part`,
+# see `tests/fixtures/opencode_run_sample.jsonl`), not claude's.
+
+
+class TestOpenCodeRendering:
+    def test_bash_tool_use_resolves_name_and_command_from_nested_part(self) -> None:
+        """#2315: opencode's tool name/command live at `part.tool` /
+        `part.state.input.command`, not any top-level key — previously this
+        rendered the useless `[tool] ?`."""
+        e = parse_event(json.dumps(_opencode_tool_use_event("bash", {"command": "git status"})))
+        out = render_event(e)
+        assert out is not None
+        assert "[tool] ?" not in out
+        assert "bash" in out
+        assert "git status" in out
+
+    def test_edit_tool_use_resolves_file_path_from_nested_part(self) -> None:
+        """#2315: opencode's edit/write tool input carries `filePath`
+        (camelCase) nested under `part.state.input`, and the tool name
+        itself is lowercase (`edit`, not `Edit`)."""
+        e = parse_event(
+            json.dumps(_opencode_tool_use_event("edit", {"filePath": "/tmp/math_utils.py"}))
+        )
+        out = render_event(e)
+        assert out is not None
+        assert "[tool] ?" not in out
+        assert "edit" in out
+        assert "/tmp/math_utils.py" in out
+
+    def test_write_tool_use_resolves_file_path(self) -> None:
+        e = parse_event(
+            json.dumps(_opencode_tool_use_event("write", {"filePath": "/tmp/new_file.py"}))
+        )
+        out = render_event(e)
+        assert out is not None
+        assert "write" in out
+        assert "/tmp/new_file.py" in out
+
+    def test_non_bash_tool_still_renders_name_only(self) -> None:
+        """A tool with no dedicated branch (e.g. opencode's `glob`/`read`)
+        still resolves its name from the nested `part` and doesn't crash on
+        the missing input — it just has no extra detail to show."""
+        e = parse_event(
+            json.dumps(_opencode_tool_use_event("glob", {"pattern": "**/math_utils.py"}))
+        )
+        out = render_event(e)
+        assert out == "[tool] glob"
+
+    def test_step_finish_intermediate_reason_has_no_terminal_line(self) -> None:
+        """A `step_finish` with `reason="tool-calls"` is not the run's last
+        step (opencode always follows it with another `step_start`), so no
+        `[result]` line should be appended."""
+        e = parse_event(
+            json.dumps(_opencode_step_finish_event("tool-calls", output_tokens=48, cost=0.0))
+        )
+        out = render_event(e)
+        assert out is not None
+        assert out == "[step_finish] reason=tool-calls out=48 $0.000"
+        assert "[result]" not in out
+
+    def test_step_finish_stop_reason_appends_terminal_result_line(self) -> None:
+        """A `step_finish` with `reason="stop"` is opencode's normal
+        completion signal — the last step of a successful run — and must
+        get the `[result] stop=...` line claude gets from its own `result`
+        event, since opencode never emits one (#2315)."""
+        e = parse_event(
+            json.dumps(_opencode_step_finish_event("stop", output_tokens=19, cost=0.02))
+        )
+        out = render_event(e)
+        assert out is not None
+        lines = out.split("\n")
+        assert lines[0] == "[step_finish] reason=stop out=19 $0.020"
+        assert lines[1] == "[result] stop=stop, $0.020"
+
+    def test_step_finish_length_reason_is_diagnostic_and_terminal(self) -> None:
+        """#2315's own reproduction case: the model spends its whole output
+        budget reasoning and is cut off (`reason="length"`) before it ever
+        calls a tool. This is the single most diagnostic line in the log and
+        must be impossible to miss — both the raw reason/tokens/cost and a
+        terminal `stop=length` line."""
+        e = parse_event(
+            json.dumps(_opencode_step_finish_event("length", output_tokens=32000, cost=0.145))
+        )
+        out = render_event(e)
+        assert out is not None
+        assert "reason=length" in out
+        assert "out=32000" in out
+        assert "$0.145" in out
+        assert "[result] stop=length" in out
+
+    def test_step_finish_missing_fields_render_placeholders_not_crash(self) -> None:
+        """A `step_finish` with no `part` at all (or a malformed one) must
+        never raise — it renders `?` placeholders, same policy as every
+        other defensive accessor in this module."""
+        e = parse_event(json.dumps({"type": "step_finish"}))
+        out = render_event(e)
+        assert out == "[step_finish] reason=? out=? $?"
+
+    def test_claude_bash_tool_use_unaffected(self) -> None:
+        """Byte-identical regression guard: claude's `Bash` (capitalized,
+        top-level `name`/`input`) must render exactly as before — the
+        opencode fallback must never shadow it."""
+        e = parse_event(json.dumps(_tool_use_event("Bash", {"command": "git push origin HEAD"})))
+        out = render_event(e)
+        assert out == "[tool] Bash: git push origin HEAD"
+
+    def test_claude_edit_tool_use_unaffected(self) -> None:
+        e = parse_event(json.dumps(_tool_use_event("Edit", {"file_path": "coord/cli.py"})))
+        out = render_event(e)
+        assert out == "[tool] Edit: coord/cli.py"
+
+    def test_success_fixture_renders_every_tool_name_and_a_terminal_stop_line(self) -> None:
+        """End-to-end over `opencode_run_sample.jsonl` (#1703's verbatim
+        successful capture): every tool call must resolve a real name — no
+        `[tool] ?` anywhere — and the log must end with a stop reason, which
+        it never did before #2315."""
+        fixture = Path(__file__).parent / "fixtures" / "opencode_run_sample.jsonl"
+        assert fixture.exists(), "opencode_run_sample.jsonl fixture is missing"
+        lines = list(render_log(fixture))
+        assert not any("[tool] ?" in l for l in lines)
+        # The fixture's tool calls, in order, are glob -> read -> edit; the
+        # first two have no dedicated branch (name-only), edit resolves its
+        # `filePath`.
+        assert any(l == "[tool] glob" for l in lines)
+        assert any(l == "[tool] read" for l in lines)
+        assert any(
+            l.startswith("[tool] edit:") and "math_utils.py" in l for l in lines
+        )
+        assert any("[result] stop=stop" in l for l in lines)
+
+    def test_failure_fixture_has_no_spurious_terminal_line(self) -> None:
+        """`opencode_run_failure_sample.jsonl` (#1703's verbatim failing
+        capture) has exactly one `step_finish`, with `reason="tool-calls"`
+        — not terminal — followed by a top-level `error` event instead. No
+        `[result] stop=...` line must appear for it; the fixture predates
+        this issue's scope of fixing the `error` event's own rendering."""
+        fixture = Path(__file__).parent / "fixtures" / "opencode_run_failure_sample.jsonl"
+        assert fixture.exists(), "opencode_run_failure_sample.jsonl fixture is missing"
+        lines = list(render_log(fixture))
+        assert not any("[result]" in l for l in lines)
+        assert any(l == "[step_finish] reason=tool-calls out=56 $0.000" for l in lines)
+
+    def test_length_fixture_surfaces_the_diagnostic_line(self) -> None:
+        """The #2315 reproduction fixture: a truncated reasoning-only final
+        step (no tool call between its `step_start` and `step_finish`).
+        `coord log` must show a resolved bash tool name for the earlier
+        step AND the diagnostic `reason=length`/`out=32000`/cost line AND a
+        terminal stop line — none of which rendered before this fix."""
+        fixture = Path(__file__).parent / "fixtures" / "opencode_run_length_sample.jsonl"
+        assert fixture.exists(), "opencode_run_length_sample.jsonl fixture is missing"
+        lines = list(render_log(fixture))
+        assert not any("[tool] ?" in l for l in lines)
+        assert any(l.startswith("[tool] bash:") and "git status" in l for l in lines)
+        assert any(
+            l.startswith("[step_finish] reason=length out=32000 $0.145") for l in lines
+        )
+        assert any("[result] stop=length" in l for l in lines)
+
+
 # ── format_important_event ───────────────────────────────────────────────