codee-agent 0.6.9__tar.gz → 0.7.0__tar.gz

{codee_agent-0.6.9 → codee_agent-0.7.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: codee-agent
-Version: 0.6.9
+Version: 0.7.0
 Summary: A virtual co-worker that picks up Jira and Azure DevOps tasks and solves them with coding agents.
-Keywords: ai,agent,jira,azure-devops,claude-code,github-copilot,codex,automation
+Keywords: ai,agent,jira,azure-devops,claude-code,github-copilot,codex,opencode,automation
 Author: Denis Kibalko
 Author-email: Denis Kibalko <denis.kibalko@nimbusweb.me>
 License-Expression: MIT
@@ -39,7 +39,7 @@ The goal of this project is to provide an assistant that will integrate into you
 
 Codee works with Jira and Azure DevOps as tasks providers, new providers are quite easy to create, PRs are welcome.
 
-As agents it currently works with Claude Code, Github Copilot and Codex.
+As agents it currently works with Claude Code, GitHub Copilot, Codex and OpenCode.
 
 ## Documentation
 

{codee_agent-0.6.9 → codee_agent-0.7.0}/README.md

@@ -4,7 +4,7 @@ The goal of this project is to provide an assistant that will integrate into you
 
 Codee works with Jira and Azure DevOps as tasks providers, new providers are quite easy to create, PRs are welcome.
 
-As agents it currently works with Claude Code, Github Copilot and Codex.
+As agents it currently works with Claude Code, GitHub Copilot, Codex and OpenCode.
 
 ## Documentation
 

{codee_agent-0.6.9 → codee_agent-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codee-agent"
-version = "0.6.9"
+version = "0.7.0"
 description = "A virtual co-worker that picks up Jira and Azure DevOps tasks and solves them with coding agents."
 readme = "README.md"
 license = "MIT"
@@ -9,7 +9,7 @@ requires-python = ">=3.12"
 authors = [
     { name = "Denis Kibalko", email = "denis.kibalko@nimbusweb.me" },
 ]
-keywords = ["ai", "agent", "jira", "azure-devops", "claude-code", "github-copilot", "codex", "automation"]
+keywords = ["ai", "agent", "jira", "azure-devops", "claude-code", "github-copilot", "codex", "opencode", "automation"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Environment :: Console",
@@ -77,6 +77,7 @@ module-name = [
     "codee_agent_claude_code",
     "codee_agent_github_copilot",
     "codee_agent_codex",
+    "codee_agent_opencode",
     "codee_tasks_abstract",
     "codee_tasks_jira",
     "codee_tasks_azure_devops",

{codee_agent-0.6.9 → codee_agent-0.7.0}/src/codee/admin.py

@@ -270,6 +270,8 @@ class RunRecord(BaseModel):
     status: str
     error: str
     started_at: str
+    ended_at: str
+    duration_label: str
     session_id: str
     message: str
     user_message: str
@@ -334,6 +336,8 @@ class AdminState(rx.State):
     runs: list[RunRecord] = []
     runs_has_more: bool = False
     runs_loading: bool = False
+    runs_query: str = ""
+    runs_watch: int = 0
     session_viewer: str = SERVICE.session_viewer
 
     workflow_sections: list[WorkflowSection] = []
@@ -841,12 +845,14 @@ class AdminState(rx.State):
                                                  for account in measured]
             await asyncio.sleep(USAGE_POLL_INTERVAL)
 
-    def _fetch_runs_page(self, offset: int) -> list[RunRecord]:
+    def _fetch_runs_page(self, offset: int,
+                         limit: int = RUNS_PAGE_SIZE) -> list[RunRecord]:
         """One page of runs. Reads one row past the page to learn whether more exist."""
-        rows = SERVICE.recent_runs(RUNS_PAGE_SIZE + 1, offset)
-        self.runs_has_more = len(rows) > RUNS_PAGE_SIZE
+        rows = SERVICE.recent_runs(
+            limit + 1, offset, self.runs_query)
+        self.runs_has_more = len(rows) > limit
         records = []
-        for run in rows[:RUNS_PAGE_SIZE]:
+        for run in rows[:limit]:
             message = (run.get("message") or "").strip()
             preview = message.splitlines()[0] if message else "No message"
             records.append(RunRecord(
@@ -855,6 +861,8 @@ class AdminState(rx.State):
                 status=run["status"],
                 error=run.get("error") or "",
                 started_at=run["started_at"],
+                ended_at=run["ended_at"],
+                duration_label=run["duration_label"],
                 session_id=run.get("session_id") or "",
                 message=message,
                 user_message=(run.get("user_message") or message).strip(),
@@ -871,6 +879,11 @@ class AdminState(rx.State):
         self.runs_loading = False
         self.runs = self._fetch_runs_page(0)
 
+    def search_runs(self, value: str) -> None:
+        self.runs_query = value
+        self.runs_loading = False
+        self.runs = self._fetch_runs_page(0)
+
     def load_more_runs(self) -> None:
         if self.runs_loading or not self.runs_has_more:
             return
@@ -880,6 +893,23 @@ class AdminState(rx.State):
         finally:
             self.runs_loading = False
 
+    @rx.event(background=True)
+    async def poll_runs(self) -> None:
+        """Keep recent runs current while the Runs page is on screen."""
+        async with self:
+            self.runs_watch += 1
+            watch = self.runs_watch
+        while True:
+            async with self:
+                if self.runs_watch != watch or self.active_route != "/runs":
+                    return
+                try:
+                    visible_count = max(RUNS_PAGE_SIZE, len(self.runs))
+                    self.runs = self._fetch_runs_page(0, visible_count)
+                except Exception as error:
+                    print(f"[admin] Failed to refresh runs: {error}")
+            await asyncio.sleep(1)
+
     @rx.event(background=True)
     async def load_workflow(self, force: bool = False) -> None:
         """Show the workflow, attaching to a generation already under way.
@@ -2542,7 +2572,10 @@ def run_row(run: RunRecord) -> rx.Component:
         rx.flex(
             rx.vstack(rx.hstack(rx.text(run.skill_name, font_weight="600"),
                                 rx.badge(run.status, color_scheme=rx.cond(run.status == "succeeded", "green", "red"))),
-                      rx.text(local_datetime(run.started_at), color=MUTED,
+                      rx.text(local_datetime(run.ended_at), color=MUTED,
+                              font_size="0.8rem",
+                              font_family="IBM Plex Mono, monospace"),
+                      rx.text("Duration: ", run.duration_label, color=MUTED,
                               font_size="0.8rem",
                               font_family="IBM Plex Mono, monospace"),
                       rx.text("Thread ID: ", run.session_id, color=MUTED,
@@ -2570,7 +2603,7 @@ def run_row(run: RunRecord) -> rx.Component:
                         rx.text(run.debug_logs, white_space="pre-wrap",
                                 font_family="IBM Plex Mono, monospace",
                                 font_size="0.8rem"))),
-                spacing="2", align="start", width="100%"), value=run.started_at),
+                spacing="2", align="start", width="100%"), value=run.ended_at),
             collapsible=True, width="100%")),
         padding="1rem", background=SURFACE, border=BORDER, width="100%")
 
@@ -2586,8 +2619,15 @@ def runs_page() -> rx.Component:
                           on_click=AdminState.load_more_runs)),
         spacing="3", width="100%")
     return shell(rx.vstack(page_header("Runs", "Recent trigger executions and outcomes."),
+                           rx.input(placeholder="Search prompts and LLM responses",
+                                    type="search", value=AdminState.runs_query,
+                                    on_change=AdminState.search_runs,
+                                    debounce_timeout=300, width="100%"),
                            rx.cond(AdminState.runs.length() > 0, listing,
-                                   empty_state("history", "No runs recorded yet.")),
+                                   rx.cond(AdminState.runs_query != "",
+                                           empty_state(
+                                               "search-x", "No runs match your search."),
+                                           empty_state("history", "No runs recorded yet."))),
                            align="start", width="100%"))
 
 
@@ -3545,7 +3585,7 @@ def settings_page() -> rx.Component:
                 field("Default agent",
                       rx.grid(
                           rx.select(
-                              ["claude_code", "github_copilot", "codex"],
+                              list(AGENT_NAMES),
                               value=AdminState.coding_agent,
                               on_change=AdminState.set_coding_agent,
                               width="100%"),
@@ -3800,7 +3840,7 @@ app.add_page(repositories_page, route="/repositories",
              title="Repositories | Codee",
              on_load=AdminState.load_repositories)
 app.add_page(runs_page, route="/runs", title="Runs | Codee",
-             on_load=AdminState.load_runs)
+             on_load=AdminState.poll_runs)
 app.add_page(sessions_page, route="/sessions",
              title="Sessions | Codee", on_load=AdminState.load_settings)
 app.add_page(settings_page, route="/settings",

{codee_agent-0.6.9 → codee_agent-0.7.0}/src/codee/admin_service.py

@@ -2046,8 +2046,18 @@ class AdminService:
 
         return url
 
-    def recent_runs(self, limit: int = 100, offset: int = 0) -> list[dict[str, Any]]:
-        return runs_db.recent_runs(limit, offset, main_context=self.context)
+    def recent_runs(self, limit: int = 100, offset: int = 0,
+                    search: str = "") -> list[dict[str, Any]]:
+        rows = runs_db.recent_runs(
+            limit, offset, search=search, main_context=self.context)
+        for row in rows:
+            try:
+                elapsed = (datetime.fromisoformat(row["ended_at"])
+                           - datetime.fromisoformat(row["started_at"])).total_seconds()
+            except (TypeError, ValueError):
+                elapsed = 0
+            row["duration_label"] = runs_db.fmt_elapsed(max(int(elapsed), 0))
+        return rows
 
     def load_settings(self) -> Settings:
         self.context.settings = load_settings(self.data_dir)

{codee_agent-0.6.9 → codee_agent-0.7.0}/src/codee/coding_agents.py

@@ -11,6 +11,7 @@ from codee_agent_abstract.provider import AbstractCodingAgent
 from codee_agent_claude_code.provider import ClaudeCodeAgent
 from codee_agent_codex.provider import CodexAgent
 from codee_agent_github_copilot.provider import GitHubCopilotAgent
+from codee_agent_opencode.provider import OpenCodeAgent
 from codee_main_context.context import CodingAgent, Settings
 
 # Concrete coding agents, keyed by the agent selected in settings.
@@ -18,6 +19,7 @@ CODING_AGENTS: dict[CodingAgent, type[AbstractCodingAgent]] = {
     CodingAgent.CLAUDE_CODE: ClaudeCodeAgent,
     CodingAgent.GITHUB_COPILOT: GitHubCopilotAgent,
     CodingAgent.CODEX: CodexAgent,
+    CodingAgent.OPENCODE: OpenCodeAgent,
 }
 
 

{codee_agent-0.6.9 → codee_agent-0.7.0}/src/codee/executor.py

@@ -12,6 +12,7 @@ from codee_agent_claude_code.provider import ClaudeCodeAgent
 from codee_agent_codex.provider import CodexAgent
 from codee_agent_github_copilot.provider import (
     COPILOT_DEBUG_ENV_VAR, GitHubCopilotAgent)
+from codee_agent_opencode.provider import OpenCodeAgent
 from codee_main_context.context import (
     CodeeMainContext, CodingAgent, Settings, codee_issue_types, data_dir,
     load_settings, project_root)
@@ -39,6 +40,7 @@ _CODING_AGENTS: dict[CodingAgent, type[AbstractCodingAgent]] = {
     CodingAgent.CLAUDE_CODE: ClaudeCodeAgent,
     CodingAgent.GITHUB_COPILOT: GitHubCopilotAgent,
     CodingAgent.CODEX: CodexAgent,
+    CodingAgent.OPENCODE: OpenCodeAgent,
 }
 
 POLL_INTERVAL = 60  # 1 minute

{codee_agent-0.6.9 → codee_agent-0.7.0}/src/codee/lib/runs_db.py

@@ -11,7 +11,8 @@ from codee_main_context.context import CodeeMainContext
 from codee_database.database import get_db_connection
 
 _COLUMNS = ("id", "skill_name", "trigger_type", "session_id", "status", "error",
-            "started_at", "message", "user_message", "response", "debug_logs")
+            "started_at", "ended_at", "message", "user_message", "response",
+            "debug_logs")
 
 # Codee names a session before the agent runs, but not every agent runs under
 # the name it was given: Codex mints its own thread id and reports it back mid
@@ -50,6 +51,7 @@ def init(main_context: CodeeMainContext) -> None:
                 status TEXT NOT NULL,
                 error TEXT,
                 started_at TEXT NOT NULL,
+                ended_at TEXT NOT NULL,
                 message TEXT,
                 user_message TEXT,
                 response TEXT,
@@ -68,6 +70,12 @@ def init(main_context: CodeeMainContext) -> None:
             conn.execute("ALTER TABLE runs ADD COLUMN user_message TEXT")
         if "debug_logs" not in cols:
             conn.execute("ALTER TABLE runs ADD COLUMN debug_logs TEXT")
+        if "ended_at" not in cols:
+            conn.execute("ALTER TABLE runs ADD COLUMN ended_at TEXT")
+            conn.execute(
+                "UPDATE runs SET ended_at = started_at WHERE ended_at IS NULL")
+        conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_runs_ended_at ON runs(ended_at DESC)")
         # In-flight claude runs; a row lives only while its subprocess is running.
         conn.execute(
             """CREATE TABLE IF NOT EXISTS active_jobs (
@@ -90,7 +98,7 @@ def init(main_context: CodeeMainContext) -> None:
 
 def record_run(skill_name, trigger_type, session_id, status, error=None, started_at=None,
                message=None, user_message=None, response=None, debug_logs=None,
-               *, main_context: CodeeMainContext) -> None:
+               ended_at=None, *, main_context: CodeeMainContext) -> None:
     """Insert one run row. Never raises to the caller (FR-009)."""
     try:
         init(main_context)
@@ -99,30 +107,43 @@ def record_run(skill_name, trigger_type, session_id, status, error=None, started
             debug_logs = getattr(response, "debug_logs", None)
         if started_at is None:
             started_at = datetime.now(timezone.utc).isoformat()
+        if ended_at is None:
+            ended_at = datetime.now(timezone.utc).isoformat()
         with get_db_connection(main_context) as conn:
             conn.execute(
                 "INSERT INTO runs (skill_name, trigger_type, session_id, status, error,"
-                " started_at, message, user_message, response, debug_logs)"
-                " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                " started_at, ended_at, message, user_message, response, debug_logs)"
+                " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                 (skill_name, trigger_type, session_id,
-                 status, error, started_at, message, user_message, response,
+                 status, error, started_at, ended_at, message, user_message, response,
                  debug_logs),
             )
     except Exception as exc:  # ponytail: a logging miss must never abort the skill run
         print(f"[runs_db] Failed to record run for {skill_name}: {exc}")
 
 
-def recent_runs(limit: int = 100, offset: int = 0, *,
+def recent_runs(limit: int = 100, offset: int = 0, *, search: str = "",
                 main_context: CodeeMainContext) -> list[dict]:
-    """Most recent runs newest-first as dicts, skipping `offset` rows; [] on empty/missing DB (FR-006)."""
+    """Return matching runs newest-first; [] on an empty or missing DB."""
     try:
         init(main_context)
+        query = search.strip()
+        where = ""
+        params: list = []
+        if query:
+            where = (
+                " WHERE COALESCE(message, '') LIKE ?"
+                " OR COALESCE(user_message, '') LIKE ?"
+                " OR COALESCE(response, '') LIKE ?"
+            )
+            params.extend([f"%{query}%"] * 3)
+        params.extend((limit, max(offset, 0)))
         with get_db_connection(main_context) as conn:
             rows = conn.execute(
                 "SELECT id, skill_name, trigger_type, session_id, status, error,"
-                " started_at, message, user_message, response, debug_logs"
-                " FROM runs ORDER BY started_at DESC, id DESC LIMIT ? OFFSET ?",
-                (limit, max(offset, 0)),
+                " started_at, ended_at, message, user_message, response, debug_logs"
+                f" FROM runs{where} ORDER BY ended_at DESC, id DESC LIMIT ? OFFSET ?",
+                params,
             ).fetchall()
         return [dict(zip(_COLUMNS, row)) for row in rows]
     except Exception as exc:

{codee_agent-0.6.9 → codee_agent-0.7.0}/src/codee/lib/test_runs_db.py

@@ -25,17 +25,20 @@ def _db_file(data_dir: Path) -> Path:
 def test_round_trip_newest_first(tmp_path):
     ctx = _ctx(tmp_path)
     runs_db.record_run("skill-a", "cron", "sid-1", "succeeded",
-                       started_at="2026-06-27T10:00:00+00:00", main_context=ctx)
+                       started_at="2026-06-27T10:00:00+00:00",
+                       ended_at="2026-06-27T12:00:00+00:00", main_context=ctx)
     runs_db.record_run("skill-b", "email", "sid-2", "failed", error="boom",
-                       started_at="2026-06-27T11:00:00+00:00", main_context=ctx)
+                       started_at="2026-06-27T11:00:00+00:00",
+                       ended_at="2026-06-27T11:30:00+00:00", main_context=ctx)
 
     rows = runs_db.recent_runs(main_context=ctx)
     assert [r["skill_name"] for r in rows] == [
-        "skill-b", "skill-a"]  # newest first
-    assert rows[0]["trigger_type"] == "email"
-    assert rows[0]["status"] == "failed"
-    assert rows[0]["error"] == "boom"
-    assert rows[0]["session_id"] == "sid-2"
+        "skill-a", "skill-b"]  # latest completion first
+    assert rows[0]["ended_at"] == "2026-06-27T12:00:00+00:00"
+    assert rows[1]["trigger_type"] == "email"
+    assert rows[1]["status"] == "failed"
+    assert rows[1]["error"] == "boom"
+    assert rows[1]["session_id"] == "sid-2"
 
 
 def test_empty_db_returns_empty_list(tmp_path):
@@ -58,6 +61,24 @@ def test_limit_and_offset_page_through_runs(tmp_path):
     assert runs_db.recent_runs(2, 5, main_context=ctx) == []
 
 
+def test_search_matches_prompt_and_response_before_pagination(tmp_path):
+    ctx = _ctx(tmp_path)
+    runs_db.record_run("a", "cron", "sid-a", "succeeded",
+                       message="Summarize invoices", response="Nothing relevant",
+                       ended_at="2026-06-27T10:00:00+00:00", main_context=ctx)
+    runs_db.record_run("b", "cron", "sid-b", "succeeded",
+                       user_message="Unrelated prompt", response="Invoice summary ready",
+                       ended_at="2026-06-27T11:00:00+00:00", main_context=ctx)
+    runs_db.record_run("c", "cron", "sid-c", "succeeded",
+                       message="Unrelated", response="No match",
+                       ended_at="2026-06-27T12:00:00+00:00", main_context=ctx)
+
+    rows = runs_db.recent_runs(1, search="invoice", main_context=ctx)
+    assert [row["session_id"] for row in rows] == ["sid-b"]
+    rows = runs_db.recent_runs(1, 1, search="invoice", main_context=ctx)
+    assert [row["session_id"] for row in rows] == ["sid-a"]
+
+
 def test_record_run_never_raises_on_bad_path(tmp_path):
     # An unopenable db path must be swallowed (FR-009).
     runs_db.record_run("skill", "cron", "sid", "succeeded",
@@ -272,6 +293,7 @@ def test_migration_adds_run_detail_columns_without_data_loss(tmp_path):
     assert rows[0]["message"] is None  # pre-feature row reads as NULL
     assert rows[0]["user_message"] is None
     assert rows[0]["response"] is None
+    assert rows[0]["ended_at"] == rows[0]["started_at"]
 
     # New writes carry both details; the upgraded DB round-trips them.
     runs_db.record_run("new", "cron", "sid-new", "succeeded", message="m",

{codee_agent-0.6.9 → codee_agent-0.7.0}/src/codee/test_admin_service.py

@@ -60,6 +60,24 @@ def _write_issue_skill(root: Path) -> Path:
     return skills_dir
 
 
+class RecentRunsTest(unittest.TestCase):
+    def test_formats_duration_from_start_and_end_times(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            context = CodeeMainContext(data_dir=Path(directory))
+            runs_db.record_run(
+                "skill", "cron", "sid", "succeeded",
+                started_at="2026-06-27T10:00:00+00:00",
+                ended_at="2026-06-27T10:02:05+00:00",
+                main_context=context,
+            )
+            service = AdminService.__new__(AdminService)
+            service.context = context
+
+            run, = service.recent_runs()
+
+        self.assertEqual(run["duration_label"], "2m 5s")
+
+
 class NormalizeWorkItemsTest(unittest.TestCase):
     """What the settings form's mapping rows have to satisfy before they save."""
 
@@ -2575,6 +2593,7 @@ class AdminServiceAgentModelsTest(unittest.TestCase):
             {"code": "claude_code", "name": "Claude Code"},
             {"code": "github_copilot", "name": "GitHub Copilot"},
             {"code": "codex", "name": "Codex"},
+            {"code": "opencode", "name": "OpenCode"},
         ])
 
     def test_an_agent_that_cannot_be_asked_yields_an_empty_list(self) -> None:

{codee_agent-0.6.9 → codee_agent-0.7.0}/src/codee/test_coding_agents.py

@@ -2,6 +2,7 @@ import unittest
 
 from codee_agent_claude_code.provider import ClaudeCodeAgent
 from codee_agent_codex.provider import CodexAgent
+from codee_agent_opencode.provider import OpenCodeAgent
 from codee_main_context.context import CodingAgent, Settings
 
 from codee.coding_agents import (
@@ -15,6 +16,7 @@ class ResolveAgentCodeTest(unittest.TestCase):
         self.assertEqual(resolve_agent_code("codex"), CodingAgent.CODEX)
         self.assertEqual(resolve_agent_code("github_copilot"),
                          CodingAgent.GITHUB_COPILOT)
+        self.assertEqual(resolve_agent_code("opencode"), CodingAgent.OPENCODE)
 
     def test_a_hand_written_code_resolves_whatever_its_shape(self) -> None:
         # The field is written by hand as often as by the admin UI.
@@ -46,12 +48,20 @@ class BuildCodingAgentTest(unittest.TestCase):
 
         self.assertIsInstance(agent, CodexAgent)
 
+    def test_opencode_can_be_built(self) -> None:
+        settings = Settings(coding_agent=CodingAgent.OPENCODE)
+
+        agent = build_coding_agent(settings, cwd=None)
+
+        self.assertIsInstance(agent, OpenCodeAgent)
+
 
 class AgentLabelTest(unittest.TestCase):
     def test_agents_are_labelled_by_their_display_name(self) -> None:
         self.assertEqual(agent_label(CodingAgent.CLAUDE_CODE), "Claude Code")
         self.assertEqual(agent_label(CodingAgent.GITHUB_COPILOT),
                          "GitHub Copilot")
+        self.assertEqual(agent_label(CodingAgent.OPENCODE), "OpenCode")
 
 
 if __name__ == "__main__":

codee_agent-0.7.0/src/codee_agent_opencode/__init__.py

@@ -0,0 +1 @@
+"""OpenCode coding-agent integration."""

codee_agent-0.7.0/src/codee_agent_opencode/provider.py

@@ -0,0 +1,225 @@
+import json
+import os
+import subprocess
+import threading
+from collections.abc import Callable
+from pathlib import Path
+
+from codee_agent_abstract.provider import AbstractCodingAgent, AgentModel
+from codee_main_context.context import Settings
+from codee_main_context.logging import get_logger
+
+from codee.lib.mcp_config import read_mcp_servers
+
+
+log = get_logger(__name__)
+
+
+class OpenCodeAgent(AbstractCodingAgent):
+    """Runs the ``opencode`` CLI non-interactively in a fresh session."""
+
+    DISPLAY_NAME = "OpenCode"
+    CLI_COMMAND = "opencode"
+    TIMEOUT_SECONDS = 7200  # 2 hours
+
+    def __init__(self, settings: Settings, cwd: Path):
+        super().__init__(settings, cwd)
+
+    @classmethod
+    def list_models(cls) -> list[AgentModel]:
+        try:
+            result = subprocess.run(
+                [cls.CLI_COMMAND, "models"],
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=60,
+            )
+            if result.returncode != 0:
+                raise RuntimeError(result.stderr.strip())
+            models = []
+            for line in result.stdout.splitlines():
+                model = line.strip()
+                if model:
+                    models.append(AgentModel(model, model))
+            return models
+        except Exception as exc:
+            log.warning("Could not read the opencode model catalog: %s", exc)
+            return []
+
+    def skill_prompt(self, slug: str, path: Path, argument: str = "",
+                     argument_name: str = "") -> str:
+        prompt = f"Read {_relative(path, self._cwd)} and follow its instructions exactly."
+        if argument:
+            prompt += f" {argument_name or 'ARGUMENT'} = {argument}"
+        return prompt
+
+    def run(self, user_message: str, session_id: str, model: str = "",
+            on_session_id: Callable[[str], None] | None = None) -> str:
+        return self._run(user_message, model, on_session_id)
+
+    def continue_conversation(
+        self,
+        user_message: str,
+        session_id: str,
+        model: str = "",
+        on_session_id: Callable[[str], None] | None = None,
+    ) -> str:
+        return self._run(user_message, model, on_session_id, session_id)
+
+    def _run(self, user_message: str, model: str,
+             on_session_id: Callable[[str], None] | None,
+             resume_session_id: str = "") -> str:
+        cmd = [self.CLI_COMMAND, "run", "--format", "json", "--auto"]
+        if resume_session_id:
+            cmd += ["--session", resume_session_id]
+        if model:
+            cmd += ["--model", model]
+        cmd += ["--", user_message]
+
+        log.info("Running opencode with message: %s", user_message)
+        log.debug("cwd=%s cmd=%s", self._cwd, " ".join(cmd))
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            bufsize=1,
+            cwd=self._cwd,
+            stdin=subprocess.DEVNULL,
+            env=_environment(self._cwd),
+        )
+        out: list[str] = []
+        err: list[str] = []
+        readers = [
+            threading.Thread(target=_collect, daemon=True,
+                             args=(process.stdout, out, on_session_id)),
+            threading.Thread(target=_collect, daemon=True,
+                             args=(process.stderr, err, None)),
+        ]
+        for reader in readers:
+            reader.start()
+        try:
+            process.wait(timeout=self.TIMEOUT_SECONDS)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait()
+            raise RuntimeError("OpenCode CLI timed out after 2 hours")
+        finally:
+            for reader in readers:
+                reader.join(timeout=5)
+
+        result = subprocess.CompletedProcess(
+            cmd, process.returncode, "".join(out), "".join(err))
+
+        reply, opened_session, errors, recognized = _parse_events(
+            result.stdout)
+        detail = "; ".join(errors) or result.stderr.strip()[:500]
+        if result.returncode != 0:
+            raise RuntimeError(
+                f"OpenCode CLI exited {result.returncode}: {detail}")
+        if errors:
+            raise RuntimeError(f"OpenCode run errored: {detail}")
+        if not recognized:
+            log.warning(
+                "opencode produced no recognized events; returning raw output")
+            return result.stdout
+        if not reply:
+            raise RuntimeError(
+                f"OpenCode run produced no response: {detail or 'no detail'}")
+        return reply
+
+
+def _collect(stream, lines: list[str],
+             on_session_id: Callable[[str], None] | None) -> None:
+    reported = False
+    for line in stream:
+        lines.append(line)
+        if reported or on_session_id is None:
+            continue
+        _, session_id, _, recognized = _parse_events(line)
+        if recognized and session_id:
+            reported = True
+            try:
+                on_session_id(session_id)
+            except Exception as exc:
+                log.warning("Could not report opencode session %s: %s",
+                            session_id, exc)
+    stream.close()
+
+
+def _relative(path: Path, cwd: Path) -> str:
+    try:
+        return str(path.relative_to(cwd))
+    except ValueError:
+        return str(path)
+
+
+def _environment(root: Path) -> dict[str, str]:
+    """Process environment with the project's MCP servers translated for OpenCode."""
+    environment = os.environ.copy()
+    raw = environment.get("OPENCODE_CONFIG_CONTENT", "").strip()
+    try:
+        config = json.loads(raw) if raw else {}
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(
+            "OPENCODE_CONFIG_CONTENT is not valid JSON") from exc
+    if not isinstance(config, dict):
+        raise RuntimeError("OPENCODE_CONFIG_CONTENT must hold a JSON object")
+
+    servers = read_mcp_servers(root)
+    if servers:
+        mcp = config.get("mcp") or {}
+        if not isinstance(mcp, dict):
+            raise RuntimeError(
+                "OPENCODE_CONFIG_CONTENT.mcp must hold a JSON object")
+        for name, server in servers.items():
+            entry = {
+                "type": "local",
+                "command": [server["command"], *server["args"]],
+                "enabled": True,
+            }
+            if server["env"]:
+                entry["environment"] = server["env"]
+            mcp[name] = entry
+        config["mcp"] = mcp
+    environment["OPENCODE_CONFIG_CONTENT"] = json.dumps(config)
+    return environment
+
+
+def _parse_events(output: str) -> tuple[str, str, list[str], bool]:
+    replies: list[str] = []
+    errors: list[str] = []
+    session_id = ""
+    recognized = False
+    for line in output.splitlines():
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(event, dict):
+            continue
+        event_type = event.get("type")
+        if event_type not in {"text", "error", "tool_use", "step_start",
+                              "step_finish", "reasoning"}:
+            continue
+        recognized = True
+        session_id = session_id or str(event.get("sessionID", "")).strip()
+        if event_type == "text":
+            part = event.get("part") or {}
+            text = str(part.get("text", "")).strip(
+            ) if isinstance(part, dict) else ""
+            if text:
+                replies.append(text)
+        elif event_type == "error":
+            error = event.get("error")
+            if isinstance(error, dict):
+                data = error.get("data") or {}
+                error = data.get("message") if isinstance(
+                    data, dict) else error
+            if error:
+                errors.append(str(error))
+    return "\n\n".join(replies), session_id, errors, recognized

codee_agent-0.7.0/src/codee_agent_opencode/test.py

@@ -0,0 +1,153 @@
+import io
+import json
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+from codee_agent_opencode.provider import OpenCodeAgent, _environment
+from codee_main_context.context import Settings
+
+
+SESSION = "ses_01k123"
+
+
+def _event(kind: str, **fields) -> str:
+    return json.dumps({"type": kind, "sessionID": SESSION, **fields})
+
+
+class _FakeProcess:
+    def __init__(self, stdout: str, stderr: str, returncode: int,
+                 timeout: bool = False):
+        self.stdout = io.StringIO(stdout)
+        self.stderr = io.StringIO(stderr)
+        self.returncode = returncode
+        self.timeout = timeout
+
+    def wait(self, timeout=None):
+        if self.timeout:
+            raise subprocess.TimeoutExpired("opencode", timeout or 0)
+        return self.returncode
+
+    def kill(self):
+        self.timeout = False
+
+
+def _completed(stdout: str = "", stderr: str = "", returncode: int = 0,
+               timeout: bool = False) -> _FakeProcess:
+    return _FakeProcess(stdout, stderr, returncode, timeout)
+
+
+class OpenCodeRunTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.root = Path("/repo")
+        self.agent = OpenCodeAgent(Settings(), self.root)
+
+    def _run(self, result: Mock, model: str = "") -> str:
+        self.reported = []
+        with patch("subprocess.Popen", return_value=result) as run:
+            self.captured = run
+            return self.agent.run("/do-it CORE-1", "unused", model,
+                                  self.reported.append)
+
+    def test_returns_text_and_reports_the_opened_session(self) -> None:
+        stdout = "\n".join([
+            _event("step_start", part={"type": "step-start"}),
+            _event("text", part={"type": "text", "text": "Done."}),
+        ])
+
+        self.assertEqual(self._run(_completed(stdout)), "Done.")
+        self.assertEqual(self.reported, [SESSION])
+
+    def test_runs_headless_with_permissions_and_model(self) -> None:
+        self._run(_completed(_event(
+            "text", part={"type": "text", "text": "Done."})),
+            "anthropic/claude-opus-4-1")
+
+        cmd = self.captured.call_args.args[0]
+        self.assertEqual(cmd[:2], ["opencode", "run"])
+        self.assertIn("--auto", cmd)
+        self.assertEqual(cmd[cmd.index("--format") + 1], "json")
+        self.assertEqual(cmd[cmd.index("--model") + 1],
+                         "anthropic/claude-opus-4-1")
+        self.assertEqual(cmd[-2:], ["--", "/do-it CORE-1"])
+        self.assertEqual(self.captured.call_args.kwargs["cwd"], self.root)
+        self.assertEqual(self.captured.call_args.kwargs["stdin"],
+                         subprocess.DEVNULL)
+
+    def test_project_mcp_servers_are_translated_into_inline_config(self) -> None:
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            (root / ".mcp.json").write_text(json.dumps({
+                "mcpServers": {
+                    "jira": {
+                        "command": "uvx",
+                        "args": ["mcp-atlassian"],
+                        "env": {"JIRA_URL": "https://acme.example"},
+                    },
+                },
+            }))
+            with patch.dict("os.environ", {
+                    "OPENCODE_CONFIG_CONTENT": '{"model":"openai/gpt-5"}'},
+                    clear=True):
+                config = json.loads(_environment(root)[
+                    "OPENCODE_CONFIG_CONTENT"])
+
+        self.assertEqual(config["model"], "openai/gpt-5")
+        self.assertEqual(config["mcp"]["jira"], {
+            "type": "local",
+            "command": ["uvx", "mcp-atlassian"],
+            "enabled": True,
+            "environment": {"JIRA_URL": "https://acme.example"},
+        })
+
+    def test_continuing_resumes_the_opencode_session(self) -> None:
+        result = _completed(_event(
+            "text", part={"type": "text", "text": "Continued."}))
+        with patch("subprocess.Popen", return_value=result) as run:
+            response = self.agent.continue_conversation("And now?", SESSION)
+
+        self.assertEqual(response, "Continued.")
+        cmd = run.call_args.args[0]
+        self.assertEqual(cmd[cmd.index("--session") + 1], SESSION)
+
+    def test_cli_and_stream_errors_raise(self) -> None:
+        error = _event("error", error={"data": {"message": "bad model"}})
+        with self.assertRaisesRegex(RuntimeError, "bad model"):
+            self._run(_completed(error, returncode=1))
+        with self.assertRaisesRegex(RuntimeError, "bad model"):
+            self._run(_completed(error))
+
+    def test_plain_successful_output_is_returned(self) -> None:
+        self.assertEqual(self._run(_completed(
+            "plain output\n")), "plain output\n")
+
+    def test_timeout_raises(self) -> None:
+        with patch("subprocess.Popen", return_value=_completed(timeout=True)):
+            with self.assertRaisesRegex(RuntimeError, "timed out"):
+                self.agent.run("do it", "unused")
+
+    def test_skill_prompt_names_the_skill_file(self) -> None:
+        prompt = self.agent.skill_prompt(
+            "task-developer", self.root / ".claude/skills/task-developer/SKILL.md",
+            "CORE-1", "TASK_ID")
+
+        self.assertEqual(
+            prompt,
+            "Read .claude/skills/task-developer/SKILL.md and follow its "
+            "instructions exactly. TASK_ID = CORE-1",
+        )
+
+    def test_models_come_from_the_cli(self) -> None:
+        result = Mock(returncode=0, stderr="", stdout=(
+            "anthropic/claude-opus-4-1\nopenai/gpt-5\n"))
+        with patch("subprocess.run", return_value=result):
+            models = OpenCodeAgent.list_models()
+
+        self.assertEqual([model.id for model in models], [
+            "anthropic/claude-opus-4-1", "openai/gpt-5"])
+
+
+if __name__ == "__main__":
+    unittest.main()

{codee_agent-0.6.9 → codee_agent-0.7.0}/src/codee_main_context/context.py

@@ -40,6 +40,7 @@ class CodingAgent(str, Enum):
     CLAUDE_CODE = "claude_code"
     GITHUB_COPILOT = "github_copilot"
     CODEX = "codex"
+    OPENCODE = "opencode"
 
 
 @dataclass(frozen=True)