refactor: move format_count from _IterationPanel to _output module

format_count is a pure utility function that doesn't depend on any class
state — it was a @staticmethod on _IterationPanel but logically belongs
next to format_duration in _output.py, where both serve as "format a
number for human display" utilities. This removes the class coupling and
moves tests to test_output.py alongside the other formatting tests.

Co-authored-by: Ralphify <noreply@ralphify.co>

Author: 2 people

src/ralphify/_console_emitter.py

@@ -41,7 +41,7 @@
 )
 from ralphify import _brand
 from ralphify._agent import CLAUDE_BINARY
-from ralphify._output import format_duration
+from ralphify._output import format_count, format_duration
 
 _ICON_SUCCESS = "✓"
 _ICON_FAILURE = "✗"
@@ -182,14 +182,6 @@ def _extract_tool_arg(name: str, tool_input: dict[str, Any]) -> str:
     return ", ".join(sorted(tool_input.keys()))
 
 
-def _format_tool_summary(name: str, tool_input: dict[str, Any]) -> str:
-    """Return a compact one-liner describing a tool call."""
-    arg = _extract_tool_arg(name, tool_input)
-    if arg:
-        return f"{name}  {arg}"
-    return name
-
-
 # ── Helpers ───────────────────────────────────────────────────────────
 
 
@@ -502,23 +494,11 @@ def _format_tokens(self) -> str:
         parts: list[str] = []
         total_in = self._input_tokens
         if total_in > 0:
-            parts.append(f"ctx {self._format_count(total_in)}")
+            parts.append(f"ctx {format_count(total_in)}")
         if self._output_tokens > 0:
-            parts.append(f"out {self._format_count(self._output_tokens)}")
+            parts.append(f"out {format_count(self._output_tokens)}")
         return " · ".join(parts)
 
-    @staticmethod
-    def _format_count(n: int) -> str:
-        if n >= 1_000_000:
-            return f"{n / 1_000_000:.1f}M"
-        if n >= 1_000:
-            # Use rounded value to avoid "1000.0k" when rounding crosses
-            # into the next unit (same guard as format_duration's 59.95→1m).
-            if round(n / 1_000, 1) >= 1_000:
-                return f"{n / 1_000_000:.1f}M"
-            return f"{n / 1_000:.1f}k"
-        return str(n)
-
     def _format_categories(self) -> str:
         if not self._tool_categories:
             return ""

src/ralphify/_output.py

@@ -87,6 +87,28 @@ def warn(message: str) -> None:
     print(f"ralphify: warning: {message}", file=sys.stderr)
 
 
+def format_count(n: int) -> str:
+    """Format *n* as a compact human-readable count string.
+
+    Returns ``"500"`` for sub-thousand, ``"1.5k"`` for sub-million,
+    and ``"1.5M"`` for larger values.  Used in console rendering for
+    token counts and similar metrics.
+
+    Handles the boundary where rounding ``k`` crosses into ``M`` —
+    e.g. 999_950 → ``"1.0M"`` instead of ``"1000.0k"`` (same guard
+    as :func:`format_duration`'s 59.95 → ``"1m 0s"``).
+    """
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f}M"
+    if n >= 1_000:
+        # Use rounded value to avoid "1000.0k" when rounding crosses
+        # into the next unit (same guard as format_duration's 59.95→1m).
+        if round(n / 1_000, 1) >= 1_000:
+            return f"{n / 1_000_000:.1f}M"
+        return f"{n / 1_000:.1f}k"
+    return str(n)
+
+
 _SECONDS_PER_MINUTE = 60
 _MINUTES_PER_HOUR = 60
 

tests/test_console_emitter.py

@@ -1410,17 +1410,6 @@ def test_format_tokens_does_not_double_count_cached_input(self):
             f"Expected ctx 1.0k (input_tokens already includes cache), got: {result!r}"
         )
 
-    def test_format_count(self):
-        assert _IterationPanel._format_count(500) == "500"
-        assert _IterationPanel._format_count(1500) == "1.5k"
-        assert _IterationPanel._format_count(1_500_000) == "1.5M"
-
-    def test_format_count_boundary_k_to_m(self):
-        """Values that round up to 1000.0k should display as 1.0M instead."""
-        assert _IterationPanel._format_count(999_949) == "999.9k"
-        assert _IterationPanel._format_count(999_950) == "1.0M"
-        assert _IterationPanel._format_count(999_999) == "1.0M"
-
     def test_apply_stores_scroll_lines_in_buffer(self):
         """apply() stores scroll lines in the internal buffer."""
         panel = _IterationPanel()

tests/test_output.py

@@ -1,8 +1,14 @@
-"""Tests for ralphify._output — ProcessResult, output collection, and duration formatting."""
+"""Tests for ralphify._output — ProcessResult, output collection, and formatting utilities."""
 
 import pytest
 
-from ralphify._output import ProcessResult, collect_output, ensure_str, format_duration
+from ralphify._output import (
+    ProcessResult,
+    collect_output,
+    ensure_str,
+    format_count,
+    format_duration,
+)
 
 
 class TestProcessResult:
@@ -136,3 +142,25 @@ def test_hours(self):
 
     def test_multi_day(self):
         assert format_duration(90000) == "25h 0m"
+
+
+class TestFormatCount:
+    def test_sub_thousand(self):
+        assert format_count(0) == "0"
+        assert format_count(500) == "500"
+        assert format_count(999) == "999"
+
+    def test_thousands(self):
+        assert format_count(1000) == "1.0k"
+        assert format_count(1500) == "1.5k"
+        assert format_count(10_000) == "10.0k"
+
+    def test_millions(self):
+        assert format_count(1_000_000) == "1.0M"
+        assert format_count(1_500_000) == "1.5M"
+
+    def test_boundary_k_to_m(self):
+        """Values that round up to 1000.0k should display as 1.0M instead."""
+        assert format_count(999_949) == "999.9k"
+        assert format_count(999_950) == "1.0M"
+        assert format_count(999_999) == "1.0M"