codee-agent 0.4.0__tar.gz → 0.4.1__tar.gz

{codee_agent-0.4.0 → codee_agent-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codee-agent
-Version: 0.4.0
+Version: 0.4.1
 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,automation
 Author: Denis Kibalko

{codee_agent-0.4.0 → codee_agent-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codee-agent"
-version = "0.4.0"
+version = "0.4.1"
 description = "A virtual co-worker that picks up Jira and Azure DevOps tasks and solves them with coding agents."
 readme = "README.md"
 license = "MIT"
@@ -47,6 +47,12 @@ codee-init = "codee.init_cli:main"
 codee-admin = "codee.admin_cli:main"
 codee-executor = "codee.executor:main"
 
+[tool.pytest.ini_options]
+# The provider and agent packages keep their suites in `test.py`, which pytest's
+# default `test_*.py` pattern skips — without this, `pytest src` silently ran
+# 61 fewer tests than the repo has.
+python_files = ["test_*.py", "test.py"]
+
 [tool.uv.build-backend]
 module-name = [
     "codee",

{codee_agent-0.4.0 → codee_agent-0.4.1}/src/codee/admin.py

@@ -8,7 +8,8 @@ import reflex as rx
 from pydantic import BaseModel
 
 from codee.admin_api import api_app
-from codee.admin_service import AGENTS_FILE, AdminService, ISSUE_TYPES, SKILL_TYPES
+from codee.admin_service import (
+    AGENTS_FILE, TASKS_CHECKS, AdminService, ISSUE_TYPES, SKILL_TYPES)
 from codee.workflow_graph import workflow_graph
 
 SERVICE = AdminService()
@@ -60,6 +61,35 @@ class ActiveJob(BaseModel):
     viewer_url: str
 
 
+class CheckResult(BaseModel):
+    """One line of the tasks-provider check list on the settings page.
+
+    ``status`` is where it is rather than how it went: a check has to be on
+    screen before it has an answer, so "waiting" and "running" are states of the
+    same row that later becomes ``ok`` or ``failed``.
+    """
+
+    name: str
+    status: str
+    message: str = ""
+
+
+def pending_checks(done: list[CheckResult]) -> list[CheckResult]:
+    """The finished checks, then the running one, then the ones still to come."""
+    rows = list(done)
+    for position, name in enumerate(TASKS_CHECKS[len(done):], start=len(done)):
+        rows.append(CheckResult(
+            name=name,
+            status="running" if position == len(done) else "waiting"))
+    return rows
+
+
+def check_result(check: dict[str, Any]) -> CheckResult:
+    return CheckResult(name=check["name"],
+                       status="ok" if check["ok"] else "failed",
+                       message=check["message"])
+
+
 class RunRecord(BaseModel):
     skill_name: str
     trigger_type: str
@@ -143,6 +173,11 @@ class AdminState(rx.State):
     azure_account: str = ""
     azure_expires_label: str = ""
     azure_redirect_uri: str = ""
+    tasks_verifying: bool = False
+    tasks_checks: list[CheckResult] = []
+    mcp_setup_ok: bool = False
+    mcp_setup_message: str = ""
+    mcp_configured: bool = False
 
     @rx.var
     def filtered_skills(self) -> list[SkillSummary]:
@@ -541,9 +576,15 @@ class AdminState(rx.State):
         self.azure_tenant_id = azure.get("tenant_id", "")
         self.azure_client_id = azure.get("client_id", "")
         self.azure_client_secret = azure.get("client_secret", "")
+        self._drop_provider_results()
+        self.load_mcp_status()
         self.load_azure_connection()
         return self._azure_callback_toast()
 
+    def load_mcp_status(self) -> None:
+        """Read back whether the selected provider's MCP server is already installed."""
+        self.mcp_configured = SERVICE.tasks_mcp_configured(self.tasks_provider)
+
     def load_azure_connection(self) -> None:
         connection = SERVICE.azure_connection()
         self.azure_connected = connection["connected"]
@@ -562,8 +603,17 @@ class AdminState(rx.State):
             return rx.toast.success(message or "Connected to Azure DevOps")
         return rx.toast.error(message or "Could not connect to Azure DevOps")
 
+    def _drop_provider_results(self) -> None:
+        """Forget the last checks and MCP setup: they spoke for credentials that just changed."""
+        self.tasks_verifying = False
+        self.tasks_checks = []
+        self.mcp_setup_ok = False
+        self.mcp_setup_message = ""
+
     def set_tasks_provider(self, value: str) -> None:
         self.tasks_provider = value
+        self._drop_provider_results()
+        self.load_mcp_status()
 
     def set_coding_agent(self, value: str) -> None:
         self.coding_agent = value
@@ -573,27 +623,35 @@ class AdminState(rx.State):
 
     def set_jira_base_url(self, value: str) -> None:
         self.jira_base_url = value
+        self._drop_provider_results()
 
     def set_jira_account_email(self, value: str) -> None:
         self.jira_account_email = value
+        self._drop_provider_results()
 
     def set_jira_api_token(self, value: str) -> None:
         self.jira_api_token = value
+        self._drop_provider_results()
 
     def set_jira_project(self, value: str) -> None:
         self.jira_project = value
+        self._drop_provider_results()
 
     def set_azure_organization_url(self, value: str) -> None:
         self.azure_organization_url = value
+        self._drop_provider_results()
 
     def set_azure_tenant_id(self, value: str) -> None:
         self.azure_tenant_id = value
+        self._drop_provider_results()
 
     def set_azure_client_id(self, value: str) -> None:
         self.azure_client_id = value
+        self._drop_provider_results()
 
     def set_azure_client_secret(self, value: str) -> None:
         self.azure_client_secret = value
+        self._drop_provider_results()
 
     @rx.var
     def azure_can_connect(self) -> bool:
@@ -602,6 +660,101 @@ class AdminState(rx.State):
             self.azure_organization_url,
             self.azure_client_id, self.azure_client_secret))
 
+    @rx.var
+    def tasks_can_verify(self) -> bool:
+        """Whether a real pull is worth attempting with what's on the form.
+
+        Every field the provider reads has to be filled in, and Azure DevOps
+        additionally needs the OAuth consent — without it the check could only
+        ever report "not connected", which the status line above already says.
+        """
+        if self.tasks_provider == "jira":
+            return all(value.strip() for value in (
+                self.jira_base_url, self.jira_account_email,
+                self.jira_api_token, self.jira_project))
+        return self.azure_can_connect and self.azure_connected
+
+    @rx.var
+    def mcp_can_setup(self) -> bool:
+        """Whether the selected provider can describe its MCP server yet.
+
+        Less than the pull needs in both cases. mcp-atlassian doesn't take a
+        project key — the agent searches and updates issues wherever they live
+        rather than polling one project — and the Azure DevOps server takes only
+        the organization, since it signs in through the Azure CLI rather than
+        through the app registration.
+        """
+        if self.tasks_provider == "jira":
+            return all(value.strip() for value in (
+                self.jira_base_url, self.jira_account_email,
+                self.jira_api_token))
+        return bool(self.azure_organization_url.strip())
+
+    @rx.var
+    def mcp_provider_label(self) -> str:
+        return ("Azure DevOps" if self.tasks_provider == "azure_devops"
+                else "Jira")
+
+    @rx.var
+    def mcp_button_label(self) -> str:
+        """Re-running is how stale credentials in the file get replaced."""
+        return (f"Setup {self.mcp_provider_label} MCP again"
+                if self.mcp_configured
+                else f"Setup {self.mcp_provider_label} MCP")
+
+    @rx.var
+    def mcp_missing_hint(self) -> str:
+        if self.tasks_provider == "jira":
+            return "Fill in base URL, account email and API token first."
+        return "Fill in the organization URL first."
+
+    def setup_tasks_mcp(self) -> None:
+        """Write the provider's MCP server into the project's .mcp.json.
+
+        Synchronous, unlike the connection check: this only touches a local file,
+        and the result should be on screen by the time the click lands.
+        """
+        self.mcp_setup_ok, self.mcp_setup_message = SERVICE.setup_tasks_mcp(
+            self.tasks_provider, self._credentials())
+        self.load_mcp_status()
+
+    @rx.event(background=True)
+    async def verify_tasks_connection(self) -> Any:
+        """Run the provider checks with the credentials on the form.
+
+        In the background because none of it is quick: the provider allows
+        itself 30s per request, and the MCP check runs a whole coding agent. The
+        whole list goes up at once and each row is filled in as its check
+        finishes, so the wait is spent looking at what is still running rather
+        than at nothing. Nothing is saved — verifying shouldn't commit anything.
+        """
+        async with self:
+            if self.tasks_verifying or not self.tasks_can_verify:
+                return
+            self.tasks_verifying = True
+            self.tasks_checks = pending_checks([])
+            provider, credentials = self.tasks_provider, self._credentials()
+
+        # A generator, so nothing has run yet: each next() is one check, and the
+        # thread keeps the page responsive while it does.
+        checks = SERVICE.verify_tasks_connection(provider, credentials)
+        done: list[CheckResult] = []
+        failure = ""
+        try:
+            while (result := await asyncio.to_thread(next, checks, None)) is not None:
+                done.append(check_result(result))
+                async with self:
+                    self.tasks_checks = pending_checks(done)
+        except Exception as error:
+            failure = str(error)
+        async with self:
+            self.tasks_verifying = False
+            # Whatever the generator stopped short of is dropped rather than
+            # left spinning: a run that yielded one check has only one to show.
+            self.tasks_checks = done + ([CheckResult(
+                name="Verification failed", status="failed", message=failure)]
+                if failure else [])
+
     def connect_azure_devops(self) -> Any:
         """Save the app registration, then hand the browser to Entra ID for consent.
 
@@ -622,35 +775,37 @@ class AdminState(rx.State):
 
     def disconnect_azure_devops(self) -> Any:
         SERVICE.disconnect_azure()
+        self._drop_provider_results()
         self.load_azure_connection()
         return rx.toast.success("Disconnected from Azure DevOps")
 
+    def _credentials(self) -> dict[str, str]:
+        """The selected provider's credentials as they stand on the form."""
+        if self.tasks_provider == "jira":
+            return {
+                "base_url": self.jira_base_url,
+                "account_email": self.jira_account_email,
+                "api_token": self.jira_api_token,
+                "project": self.jira_project,
+            }
+        return {
+            "organization_url": self.azure_organization_url,
+            "tenant_id": self.azure_tenant_id,
+            "client_id": self.azure_client_id,
+            "client_secret": self.azure_client_secret,
+        }
+
     def _persist_settings(self) -> str:
         """Write the settings to disk. Returns an error message, or '' when saved."""
         try:
             parallel_agents = int(self.max_parallel_agents)
         except ValueError:
             return "Max parallel tasks must be a number"
-        credentials = (
-            {
-                "base_url": self.jira_base_url,
-                "account_email": self.jira_account_email,
-                "api_token": self.jira_api_token,
-                "project": self.jira_project,
-            }
-            if self.tasks_provider == "jira"
-            else {
-                "organization_url": self.azure_organization_url,
-                "tenant_id": self.azure_tenant_id,
-                "client_id": self.azure_client_id,
-                "client_secret": self.azure_client_secret,
-            }
-        )
         SERVICE.save_settings(
             self.tasks_provider,
             self.coding_agent,
             parallel_agents,
-            credentials,
+            self._credentials(),
         )
         return ""
 
@@ -1627,6 +1782,105 @@ def azure_fields() -> rx.Component:
         spacing="4", width="100%")
 
 
+def mcp_setup_button() -> rx.Component:
+    """The setup button, built fresh per branch so each can sit in its own row."""
+    return rx.button(
+        rx.icon("file-cog", size=16), AdminState.mcp_button_label,
+        type="button", variant="outline",
+        disabled=~AdminState.mcp_can_setup,
+        on_click=AdminState.setup_tasks_mcp)
+
+
+def tasks_mcp_setup() -> rx.Component:
+    """Hand the provider's credentials to the coding agent as an MCP server."""
+    return rx.vstack(
+        rx.cond(
+            AdminState.mcp_configured,
+            # Already installed: the state is the sentence, and the button that
+            # rewrites it with whatever the fields now say sits beside it.
+            rx.hstack(
+                rx.icon("circle-check", size=16, color="var(--green-9)"),
+                rx.text("MCP config already set up.", font_size="0.85rem"),
+                mcp_setup_button(),
+                spacing="3", align="center", width="100%"),
+            rx.hstack(
+                mcp_setup_button(),
+                rx.cond(
+                    AdminState.mcp_can_setup,
+                    rx.text("Writes .mcp.json so the coding agent can read and "
+                            "update tasks itself.",
+                            color=MUTED, font_size="0.8rem"),
+                    rx.text(AdminState.mcp_missing_hint,
+                            color=MUTED, font_size="0.8rem")),
+                spacing="3", align="center", width="100%")),
+        rx.cond(
+            AdminState.mcp_setup_message != "",
+            rx.cond(
+                AdminState.mcp_setup_ok,
+                rx.callout(AdminState.mcp_setup_message, icon="circle-check",
+                           size="1", color_scheme="green", width="100%"),
+                rx.callout(AdminState.mcp_setup_message, icon="circle-alert",
+                           size="1", color_scheme="red", width="100%")),
+        ),
+        spacing="3", width="100%")
+
+
+def tasks_check_row(check: CheckResult) -> rx.Component:
+    """One check: where it stands as an icon, its name, and what it found."""
+    marker = {"flex_shrink": "0", "margin_top": "0.15rem"}
+    return rx.hstack(
+        rx.match(
+            check.status,
+            ("running", rx.spinner(size="2", **marker)),
+            ("ok", rx.icon("circle-check", size=16,
+                           color="var(--green-9)", **marker)),
+            ("failed", rx.icon("circle-alert", size=16,
+                               color="var(--red-9)", **marker)),
+            # Still queued: named so the list is complete from the first frame,
+            # but visibly not its turn yet.
+            rx.icon("circle-dashed", size=16, color=MUTED, **marker)),
+        rx.vstack(
+            rx.text(check.name, font_size="0.85rem", weight="medium",
+                    color=rx.cond(check.status == "waiting", MUTED, TEXT)),
+            rx.cond(
+                check.message != "",
+                rx.text(check.message, color=MUTED, font_size="0.8rem")),
+            spacing="1", align="start", width="100%"),
+        spacing="2", align="start", width="100%")
+
+
+def tasks_verification() -> rx.Component:
+    """Run the provider checks and print what each one found."""
+    return rx.vstack(
+        rx.hstack(
+            rx.button(
+                rx.cond(AdminState.tasks_verifying,
+                        rx.spinner(size="2"), rx.icon("plug-zap", size=16)),
+                rx.cond(AdminState.tasks_verifying,
+                        "Verifying…", "Verify connection"),
+                type="button", variant="outline",
+                disabled=AdminState.tasks_verifying | ~AdminState.tasks_can_verify,
+                on_click=AdminState.verify_tasks_connection),
+            rx.cond(
+                AdminState.tasks_can_verify,
+                # Worth saying up front: the second check spends a coding-agent
+                # run and leaves a closed task behind in the real backend.
+                rx.text("Pulls tasks, then has the coding agent create and "
+                        "close one task through MCP. Takes a minute.",
+                        color=MUTED, font_size="0.8rem"),
+                rx.text("Fill in every field above to check the connection.",
+                        color=MUTED, font_size="0.8rem")),
+            spacing="3", align="center", width="100%"),
+        rx.cond(
+            AdminState.tasks_checks,
+            rx.vstack(rx.foreach(AdminState.tasks_checks, tasks_check_row),
+                      spacing="3", width="100%",
+                      padding="0.85rem", border=BORDER,
+                      background=PAGE_BACKGROUND),
+        ),
+        spacing="3", width="100%")
+
+
 def settings_page() -> rx.Component:
     jira_fields = rx.vstack(
         field("Base URL", rx.input(value=AdminState.jira_base_url,
@@ -1657,6 +1911,8 @@ def settings_page() -> rx.Component:
                                         on_change=AdminState.set_tasks_provider, width="100%")),
             rx.box(rx.cond(AdminState.tasks_provider == "jira",
                    jira_fields, azure_fields()), margin_top="1rem"),
+            rx.box(tasks_mcp_setup(), margin_top="1.25rem"),
+            rx.box(tasks_verification(), margin_top="1.25rem"),
             padding="1.25rem", background=SURFACE, border=BORDER, width="100%"),
         rx.button(rx.icon("save", size=16), "Save settings",
                   on_click=AdminState.save_settings),

{codee_agent-0.4.0 → codee_agent-0.4.1}/src/codee/admin_cli.py

@@ -4,7 +4,7 @@ import os
 import sys
 from pathlib import Path
 
-from codee.admin_service import DEFAULT_ADMIN_PORT
+from codee.admin_service import DEFAULT_ADMIN_PORT, public_base_url
 from codee_main_context.context import data_dir, project_root
 from codee_main_context.logging import (
     configure_logging, enable_debug, get_logger, verbose_debug_enabled)
@@ -34,6 +34,16 @@ config = rx.Config(
 """
 
 
+def _api_url(port: int) -> str:
+    """Origin the browser uses for the backend websocket and uploads.
+
+    Reflex bakes this into the compiled frontend, so behind a reverse proxy it
+    has to be the public origin rather than the loopback address the server
+    binds to -- otherwise the page loads and then fails to open its socket.
+    """
+    return public_base_url() or f"http://127.0.0.1:{port}"
+
+
 def _runtime_directory(root: Path) -> Path:
     runtime = data_dir(root) / "reflex"
     runtime.mkdir(parents=True, exist_ok=True)
@@ -59,7 +69,7 @@ def main() -> int:
     codee_data = data_dir(root).resolve()
     os.environ["CODEE_PROJECT_ROOT"] = str(root)
     os.environ["CODEE_DATA_DIR"] = str(codee_data)
-    os.environ["REFLEX_API_URL"] = f"http://127.0.0.1:{arguments.port}"
+    os.environ["REFLEX_API_URL"] = _api_url(arguments.port)
     os.chdir(_runtime_directory(root))
 
     from reflex.reflex import cli