refactor: inline _render_context into resolve_contexts to simplify data flow

The private _render_context() helper was used exactly once and added an
unnecessary level of indirection. Inlining it makes the rendering-to-
resolution flow visible in a single function. Tests now exercise
rendering through the public API instead of importing a private symbol.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 2 people

src/ralphify/contexts.py

@@ -95,24 +95,13 @@ def run_all_contexts(contexts: list[Context], project_root: Path) -> list[Contex
     return [run_context(ctx, project_root) for ctx in contexts]
 
 
-def _render_context(result: ContextResult) -> str:
-    """Render a single context result into text for prompt injection."""
-    parts = []
-
-    if result.context.static_content:
-        parts.append(result.context.static_content)
-
-    output = truncate_output(result.output)
-
-    if output.strip():
-        parts.append(output.strip())
-
-    return "\n".join(parts)
-
-
 def resolve_contexts(prompt: str, results: list[ContextResult]) -> str:
     """Replace context placeholders in a prompt string.
 
+    Each context result is rendered by combining its static content (if any)
+    with its truncated command output, then injected into the prompt via
+    :func:`resolve_placeholders`.
+
     Callers are responsible for passing only the results they want
     resolved (the engine pre-filters via ``_discover_enabled_primitives``).
 
@@ -122,7 +111,13 @@ def resolve_contexts(prompt: str, results: list[ContextResult]) -> str:
     """
     available: dict[str, str] = {}
     for r in results:
-        rendered = _render_context(r)
+        parts = []
+        if r.context.static_content:
+            parts.append(r.context.static_content)
+        output = truncate_output(r.output)
+        if output.strip():
+            parts.append(output.strip())
+        rendered = "\n".join(parts)
         if rendered:
             available[r.context.name] = rendered
 

tests/test_contexts.py

@@ -10,7 +10,6 @@
     resolve_contexts,
     run_context,
     run_all_contexts,
-    _render_context,
 )
 
 _MOCK_SUBPROCESS = "ralphify._runner.subprocess.run"
@@ -260,41 +259,45 @@ def test_runs_all_contexts(self, mock_run):
         assert mock_run.call_count == 2
 
 
-class TestRenderContext:
-    def _make_result(self, static_content="", output="", success=True):
+class TestContextRendering:
+    """Test context rendering (static content + command output) via resolve_contexts."""
+
+    def _make_result(self, name="test", static_content="", output="", success=True):
         ctx = Context(
-            name="test",
+            name=name,
             path=Path("/fake"),
             command="echo",
             static_content=static_content,
         )
         return ContextResult(context=ctx, output=output, success=success)
 
+    def _render_via_resolve(self, static_content="", output=""):
+        """Render a context through resolve_contexts with a named placeholder."""
+        result = self._make_result(static_content=static_content, output=output)
+        return resolve_contexts("{{ contexts.test }}", [result])
+
     def test_static_and_output(self):
-        result = self._make_result(static_content="Header:", output="data\n")
-        rendered = _render_context(result)
+        rendered = self._render_via_resolve(static_content="Header:", output="data\n")
         assert "Header:" in rendered
         assert "data" in rendered
 
     def test_static_only(self):
-        result = self._make_result(static_content="Just static.", output="")
-        rendered = _render_context(result)
+        rendered = self._render_via_resolve(static_content="Just static.", output="")
         assert rendered == "Just static."
 
     def test_output_only(self):
-        result = self._make_result(static_content="", output="dynamic output\n")
-        rendered = _render_context(result)
+        rendered = self._render_via_resolve(static_content="", output="dynamic output\n")
         assert rendered == "dynamic output"
 
-    def test_empty_context(self):
+    def test_empty_context_not_injected(self):
         result = self._make_result(static_content="", output="")
-        rendered = _render_context(result)
-        assert rendered == ""
+        prompt = "Base prompt."
+        rendered = resolve_contexts(prompt, [result])
+        assert rendered == prompt
 
     def test_output_truncation(self):
         long_output = "x" * (MAX_OUTPUT_LEN + 1000)
-        result = self._make_result(output=long_output)
-        rendered = _render_context(result)
+        rendered = self._render_via_resolve(output=long_output)
         assert "truncated" in rendered
         assert len(rendered) < len(long_output)