wbcli 0.0.1__py3-none-any.whl

tests/conftest.py

@@ -0,0 +1,35 @@
+"""Shared test fixtures."""
+
+import subprocess
+
+import pytest
+
+
+@pytest.fixture
+def git_repo(tmp_path):
+    """Create a temporary git repo with main branch and initial commit."""
+    subprocess.run(
+        ["git", "init", "--initial-branch=main"],
+        cwd=tmp_path,
+        check=True,
+        capture_output=True,
+    )
+    subprocess.run(
+        ["git", "config", "user.email", "test@test.com"],
+        cwd=tmp_path,
+        capture_output=True,
+    )
+    subprocess.run(
+        ["git", "config", "user.name", "Test"],
+        cwd=tmp_path,
+        capture_output=True,
+    )
+    (tmp_path / "README.md").write_text("init")
+    subprocess.run(["git", "add", "."], cwd=tmp_path, capture_output=True)
+    subprocess.run(
+        ["git", "commit", "-m", "init"],
+        cwd=tmp_path,
+        check=True,
+        capture_output=True,
+    )
+    return tmp_path

tests/test_adapters.py

@@ -0,0 +1,233 @@
+"""Tests for agent platform adapters."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from workbench.adapters import (
+    ALLOWED_TOOLS,
+    AgentAdapter,
+    ClaudeAdapter,
+    CodexAdapter,
+    ConfigAdapter,
+    GenericAdapter,
+    get_adapter,
+)
+
+
+class TestClaudeAdapter:
+    def setup_method(self):
+        self.adapter = ClaudeAdapter()
+
+    def test_name(self):
+        assert self.adapter.name == "claude"
+
+    def test_build_command(self, tmp_path):
+        cmd = self.adapter.build_command("do something", tmp_path)
+        assert cmd == [
+            "claude", "-p", "do something",
+            "--output-format", "json",
+            "--allowedTools", ALLOWED_TOOLS,
+        ]
+
+    def test_parse_output_valid_json(self):
+        raw = json.dumps({"result": "done", "cost_usd": {"input": 0.01}})
+        text, cost = self.adapter.parse_output(raw)
+        assert text == "done"
+        assert cost == {"input": 0.01}
+
+    def test_parse_output_missing_keys(self):
+        raw = json.dumps({"other": "data"})
+        text, cost = self.adapter.parse_output(raw)
+        assert text == raw  # falls back to raw when result key missing
+        assert cost == {}
+
+    def test_parse_output_invalid_json(self):
+        raw = "not json at all"
+        text, cost = self.adapter.parse_output(raw)
+        assert text == raw
+        assert cost == {}
+
+    def test_is_agent_adapter(self):
+        assert isinstance(self.adapter, AgentAdapter)
+
+
+class TestCodexAdapter:
+    def setup_method(self):
+        self.adapter = CodexAdapter()
+
+    def test_name(self):
+        assert self.adapter.name == "codex"
+
+    def test_build_command(self, tmp_path):
+        cmd = self.adapter.build_command("fix bug", tmp_path)
+        assert cmd == [
+            "codex", "-q", "--full-auto",
+            "--approval-mode", "full-auto",
+            "fix bug",
+        ]
+
+    def test_parse_output_strips_whitespace(self):
+        text, cost = self.adapter.parse_output("  hello world  \n")
+        assert text == "hello world"
+        assert cost == {}
+
+    def test_is_agent_adapter(self):
+        assert isinstance(self.adapter, AgentAdapter)
+
+
+class TestGenericAdapter:
+    def test_name_matches_cmd(self):
+        adapter = GenericAdapter("my-tool")
+        assert adapter.name == "my-tool"
+
+    def test_build_command(self, tmp_path):
+        adapter = GenericAdapter("my-tool")
+        cmd = adapter.build_command("hello", tmp_path)
+        assert cmd == ["my-tool", "hello"]
+
+    def test_parse_output(self):
+        adapter = GenericAdapter("my-tool")
+        text, cost = adapter.parse_output("  output  \n")
+        assert text == "output"
+        assert cost == {}
+
+    def test_is_agent_adapter(self):
+        assert isinstance(GenericAdapter("x"), AgentAdapter)
+
+
+class TestConfigAdapter:
+    def test_build_command_substitutes_prompt(self, tmp_path):
+        adapter = ConfigAdapter(
+            name="custom",
+            command="my-cli",
+            args=["--headless", "{prompt}", "--verbose"],
+        )
+        cmd = adapter.build_command("do work", tmp_path)
+        assert cmd == ["my-cli", "--headless", "do work", "--verbose"]
+
+    def test_parse_output_text_format(self):
+        adapter = ConfigAdapter(
+            name="custom",
+            command="my-cli",
+            args=["{prompt}"],
+            output_format="text",
+        )
+        text, cost = adapter.parse_output("  some output  \n")
+        assert text == "some output"
+        assert cost == {}
+
+    def test_parse_output_json_format(self):
+        adapter = ConfigAdapter(
+            name="custom",
+            command="my-cli",
+            args=["{prompt}"],
+            output_format="json",
+            json_result_key="answer",
+            json_cost_key="price",
+        )
+        raw = json.dumps({"answer": "42", "price": {"total": 0.05}})
+        text, cost = adapter.parse_output(raw)
+        assert text == "42"
+        assert cost == {"total": 0.05}
+
+    def test_parse_output_json_format_invalid(self):
+        adapter = ConfigAdapter(
+            name="custom",
+            command="my-cli",
+            args=["{prompt}"],
+            output_format="json",
+        )
+        text, cost = adapter.parse_output("not json")
+        assert text == "not json"
+        assert cost == {}
+
+    def test_parse_output_json_missing_keys(self):
+        adapter = ConfigAdapter(
+            name="custom",
+            command="my-cli",
+            args=["{prompt}"],
+            output_format="json",
+            json_result_key="answer",
+            json_cost_key="price",
+        )
+        raw = json.dumps({"unrelated": "data"})
+        text, cost = adapter.parse_output(raw)
+        assert text == raw  # falls back to raw
+        assert cost == {}
+
+    def test_is_agent_adapter(self):
+        adapter = ConfigAdapter(name="x", command="x", args=[])
+        assert isinstance(adapter, AgentAdapter)
+
+
+class TestGetAdapter:
+    def test_returns_claude_adapter(self):
+        adapter = get_adapter("claude")
+        assert isinstance(adapter, ClaudeAdapter)
+
+    def test_returns_codex_adapter(self):
+        adapter = get_adapter("codex")
+        assert isinstance(adapter, CodexAdapter)
+
+    def test_returns_generic_for_unknown(self):
+        adapter = get_adapter("some-random-tool")
+        assert isinstance(adapter, GenericAdapter)
+        assert adapter.name == "some-random-tool"
+
+    def test_config_path_not_exists_falls_through(self, tmp_path):
+        adapter = get_adapter("claude", config_path=tmp_path / "nonexistent.yaml")
+        assert isinstance(adapter, ClaudeAdapter)
+
+    def test_config_adapter_from_yaml(self, tmp_path):
+        config_file = tmp_path / "agents.yaml"
+        config_file.write_text(
+            "agents:\n"
+            "  my-agent:\n"
+            "    command: my-agent-cli\n"
+            "    args:\n"
+            "      - '--headless'\n"
+            "      - '{prompt}'\n"
+            "    output_format: json\n"
+            "    json_result_key: result\n"
+            "    json_cost_key: cost_usd\n"
+        )
+        adapter = get_adapter("my-agent", config_path=config_file)
+        assert isinstance(adapter, ConfigAdapter)
+        assert adapter.name == "my-agent"
+        assert adapter.command == "my-agent-cli"
+        assert adapter.output_format == "json"
+
+        cmd = adapter.build_command("test prompt", tmp_path)
+        assert cmd == ["my-agent-cli", "--headless", "test prompt"]
+
+    def test_config_agent_not_in_yaml_falls_through(self, tmp_path):
+        config_file = tmp_path / "agents.yaml"
+        config_file.write_text("agents:\n  other-agent:\n    command: other\n")
+        adapter = get_adapter("claude", config_path=config_file)
+        assert isinstance(adapter, ClaudeAdapter)
+
+    def test_config_overrides_builtin(self, tmp_path):
+        """Config entry for 'claude' should override the built-in ClaudeAdapter."""
+        config_file = tmp_path / "agents.yaml"
+        config_file.write_text(
+            "agents:\n"
+            "  claude:\n"
+            "    command: custom-claude\n"
+            "    args: ['{prompt}']\n"
+        )
+        adapter = get_adapter("claude", config_path=config_file)
+        assert isinstance(adapter, ConfigAdapter)
+        assert adapter.command == "custom-claude"
+
+    def test_config_defaults(self, tmp_path):
+        """Minimal config entry should get sensible defaults."""
+        config_file = tmp_path / "agents.yaml"
+        config_file.write_text("agents:\n  minimal:\n    command: min-cli\n")
+        adapter = get_adapter("minimal", config_path=config_file)
+        assert isinstance(adapter, ConfigAdapter)
+        assert adapter.args == ["{prompt}"]
+        assert adapter.output_format == "text"
+        assert adapter.json_result_key == "result"
+        assert adapter.json_cost_key == "cost_usd"

tests/test_agents.py

@@ -0,0 +1,138 @@
+"""Tests for the agents module — spawning, prompts, and result parsing."""
+
+import asyncio
+import json
+from unittest.mock import AsyncMock, patch, MagicMock
+
+import pytest
+
+from workbench.agents import AgentResult, Role, TaskStatus, build_prompt, run_agent
+from workbench.plan_parser import Task
+from workbench.worktree import Worktree
+
+
+@pytest.fixture
+def sample_task():
+    return Task(id="task-1", title="Test Task", description="Do something", files=["src/foo.py"])
+
+
+@pytest.fixture
+def sample_worktree(tmp_path):
+    return Worktree(path=tmp_path, branch="wb/test-task", task_id="task-1")
+
+
+class TestRunAgentTmux:
+    def test_run_agent_success_tmux(self, sample_task, sample_worktree, tmp_path):
+        """Mock run_in_tmux returning (0, json), verify AgentResult.status == DONE."""
+        output = json.dumps({"result": "all good", "cost_usd": {"input": 0.01}})
+        with patch("workbench.agents.run_in_tmux", new_callable=AsyncMock, return_value=(0, output)), \
+             patch("workbench.agents.get_main_branch", return_value="main"), \
+             patch("workbench.agents.get_diff", return_value=""):
+            result = asyncio.run(run_agent(
+                role=Role.IMPLEMENTOR,
+                task=sample_task,
+                worktree=sample_worktree,
+                repo=tmp_path,
+                agent_cmd="claude",
+                use_tmux=True,
+            ))
+
+        assert result.status == TaskStatus.DONE
+        assert result.task_id == "task-1"
+
+    def test_run_agent_failure_tmux(self, sample_task, sample_worktree, tmp_path):
+        """Mock returning (1, "error"), verify FAILED."""
+        with patch("workbench.agents.run_in_tmux", new_callable=AsyncMock, return_value=(1, "error")), \
+             patch("workbench.agents.get_main_branch", return_value="main"), \
+             patch("workbench.agents.get_diff", return_value=""):
+            result = asyncio.run(run_agent(
+                role=Role.IMPLEMENTOR,
+                task=sample_task,
+                worktree=sample_worktree,
+                repo=tmp_path,
+                agent_cmd="claude",
+                use_tmux=True,
+            ))
+
+        assert result.status == TaskStatus.FAILED
+
+
+class TestRunAgentSubprocess:
+    def test_run_agent_no_tmux(self, sample_task, sample_worktree, tmp_path):
+        """use_tmux=False, mock create_subprocess_exec, verify it's called."""
+        mock_proc = AsyncMock()
+        mock_proc.communicate.return_value = (b"done", b"")
+        mock_proc.returncode = 0
+
+        with patch("workbench.agents.asyncio.create_subprocess_exec", new_callable=AsyncMock, return_value=mock_proc) as mock_exec, \
+             patch("workbench.agents.get_main_branch", return_value="main"), \
+             patch("workbench.agents.get_diff", return_value=""):
+            result = asyncio.run(run_agent(
+                role=Role.IMPLEMENTOR,
+                task=sample_task,
+                worktree=sample_worktree,
+                repo=tmp_path,
+                agent_cmd="claude",
+                use_tmux=False,
+            ))
+
+        mock_exec.assert_called_once()
+        assert result.status == TaskStatus.DONE
+
+
+class TestPromptBuilding:
+    def test_implementor_prompt_has_branch(self, sample_task, sample_worktree):
+        """Capture the prompt passed to adapter, verify branch name present."""
+        with patch("workbench.agents.get_diff", return_value=""):
+            prompt = build_prompt(
+                role=Role.IMPLEMENTOR,
+                task=sample_task,
+                worktree=sample_worktree,
+                base_branch="main",
+            )
+        assert "wb/test-task" in prompt
+
+    def test_fixer_prompt_has_branch(self, sample_task, sample_worktree):
+        """Same for fixer role."""
+        with patch("workbench.agents.get_diff", return_value="some diff"):
+            prompt = build_prompt(
+                role=Role.FIXER,
+                task=sample_task,
+                worktree=sample_worktree,
+                base_branch="main",
+            )
+        assert "wb/test-task" in prompt
+
+
+class TestAgentResult:
+    def test_agent_result_passed(self):
+        """AgentResult with 'VERDICT: PASS' → .passed == True."""
+        result = AgentResult(
+            task_id="task-1",
+            role=Role.TESTER,
+            status=TaskStatus.DONE,
+            output="All tests passed.\nVERDICT: PASS",
+        )
+        assert result.passed is True
+
+    def test_agent_result_failed_verdict(self):
+        """'VERDICT: FAIL' → .passed == False."""
+        result = AgentResult(
+            task_id="task-1",
+            role=Role.TESTER,
+            status=TaskStatus.DONE,
+            output="Some tests failed.\nVERDICT: FAIL",
+        )
+        assert result.passed is False
+
+    def test_agent_result_feedback(self):
+        """Text before VERDICT line extracted by .feedback."""
+        result = AgentResult(
+            task_id="task-1",
+            role=Role.REVIEWER,
+            status=TaskStatus.DONE,
+            output="Missing error handling in foo().\nNeeds type hints.\nVERDICT: FAIL",
+        )
+        assert "Missing error handling" in result.feedback
+        assert "Needs type hints" in result.feedback
+        assert "VERDICT" not in result.feedback