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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "codee-agent"
-version = "0.3.0"
+version = "0.4.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"

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

@@ -48,6 +48,12 @@ class MemoryEntry(BaseModel):
     matched: bool
 
 
+class RepositorySummary(BaseModel):
+    name: str
+    url: str
+    default_branch: str
+
+
 class ActiveJob(BaseModel):
     message: str
     elapsed_label: str
@@ -95,6 +101,10 @@ class AdminState(rx.State):
     selected_memory: str = ""
     memory_content: str = ""
 
+    repositories: list[RepositorySummary] = []
+    new_repository_url: str = ""
+    adding_repository: bool = False
+
     active_jobs: list[ActiveJob] = []
     total_runs: int = 0
     last_24h_runs: int = 0
@@ -325,6 +335,11 @@ class AdminState(rx.State):
         self.agents_content = SERVICE.load_agents()
         self.editing_agents = True
 
+    def open_agents_editor(self) -> Any:
+        """Open the AGENTS.md editor from a page that isn't Skills."""
+        self.edit_agents()
+        return rx.redirect("/skills")
+
     def set_agents_content(self, value: str) -> None:
         self.agents_content = value
 
@@ -335,7 +350,7 @@ class AdminState(rx.State):
         return _save_toast(*SERVICE.save_agents(self.agents_content))
 
     def load_memories(self) -> None:
-        self.coding_agent = SERVICE.load_settings().coding_agent.value
+        self.load_coding_agent()
         if self.coding_agent == "github_copilot":
             self.memories = []
             self.selected_memory = ""
@@ -367,6 +382,33 @@ class AdminState(rx.State):
         self.load_memories()
         return _save_toast(deleted, pushed, message)
 
+    def load_repositories(self) -> None:
+        self.repositories = [RepositorySummary(**repository)
+                             for repository in SERVICE.list_repositories()]
+
+    def set_new_repository_url(self, value: str) -> None:
+        self.new_repository_url = value
+
+    @rx.event(background=True)
+    async def add_repository(self) -> Any:
+        """Clone in the background: a first clone can take minutes."""
+        async with self:
+            if self.adding_repository:
+                return
+            url = self.new_repository_url.strip()
+            self.adding_repository = True
+        try:
+            added, message, _ = await asyncio.to_thread(
+                SERVICE.add_repository, url)
+        except Exception as error:
+            added, message = False, str(error)
+        async with self:
+            self.adding_repository = False
+            if added:
+                self.new_repository_url = ""
+                self.load_repositories()
+        yield rx.toast.success(message) if added else rx.toast.error(message)
+
     def _refresh_dashboard(self) -> None:
         dashboard = SERVICE.dashboard()
         self.active_jobs = [
@@ -476,6 +518,14 @@ class AdminState(rx.State):
         self.edit_skill(slug)
         return rx.redirect("/skills")
 
+    def load_coding_agent(self) -> None:
+        """Refresh the agent the sidebar keys off, on every page load.
+
+        Without this the default sticks until a page that reads settings is
+        opened, so the Sessions link shows for Github Copilot.
+        """
+        self.coding_agent = SERVICE.load_settings().coding_agent.value
+
     def load_settings(self) -> Any:
         settings = SERVICE.load_settings()
         self.tasks_provider = settings.tasks_provider.value
@@ -682,6 +732,8 @@ def shell(content: rx.Component) -> rx.Component:
                         nav_link("Skills", "blocks", "/skills"),
                         nav_link("Workflow", "git-branch", "/workflow"),
                         nav_link("Memory", "notebook-text", "/memory"),
+                        nav_link("Repositories", "folder-git-2",
+                                 "/repositories"),
                         nav_link("Runs", "history", "/runs"),
                         rx.cond(
                             AdminState.coding_agent == "claude_code",
@@ -762,7 +814,8 @@ def live_dot(size: str = "0.6rem") -> rx.Component:
     return rx.box(
         rx.box(position="absolute", inset="0", border_radius="50%", background=ACCENT,
                animation="codee-ping 1.8s cubic-bezier(0, 0, 0.2, 1) infinite"),
-        rx.box(position="absolute", inset="0", border_radius="50%", background=ACCENT),
+        rx.box(position="absolute", inset="0",
+               border_radius="50%", background=ACCENT),
         class_name="codee-live-dot",
         position="relative",
         width=size,
@@ -774,7 +827,8 @@ def live_dot(size: str = "0.6rem") -> rx.Component:
 def elapsed_pill(label: rx.Var | str) -> rx.Component:
     return rx.hstack(
         rx.icon("timer", size=14, color=ACCENT),
-        rx.text(label, font_family=MONO, font_size="0.85rem", font_weight="500"),
+        rx.text(label, font_family=MONO,
+                font_size="0.85rem", font_weight="500"),
         spacing="2",
         align="center",
         flex_shrink="0",
@@ -1201,7 +1255,7 @@ def memory_page() -> rx.Component:
                       rx.vstack(rx.foreach(AdminState.memories,
                                 memory_row), spacing="3", width="100%"),
                       empty_state("notebook-text", "No memories yet."))
-    return shell(rx.vstack(page_header("Memory", "Review and maintain durable project context."),
+    return shell(rx.vstack(page_header("Memory", "Manage agent provider's memory."),
                            rx.cond(AdminState.coding_agent == "github_copilot",
                                    empty_state(
                                        "notebook-text",
@@ -1211,6 +1265,63 @@ def memory_page() -> rx.Component:
                            align="start", width="100%"))
 
 
+def repository_row(repository: RepositorySummary) -> rx.Component:
+    return rx.flex(
+        rx.icon("folder-git-2", size=18, color=SUBTLE_ICON),
+        rx.vstack(
+            rx.hstack(rx.text(repository.name, font_weight="600"),
+                      rx.cond(repository.default_branch != "",
+                              rx.badge(rx.icon("house", size=12),
+                                       repository.default_branch,
+                                       color_scheme="blue", variant="soft",
+                                       custom_attrs={"title": "Default branch"})),
+                      spacing="2", align="center"),
+            rx.cond(repository.url != "",
+                    rx.text(repository.url, color=MUTED, font_family=MONO,
+                            font_size="0.8rem")),
+            spacing="2", align="start", flex="1", min_width="0"),
+        gap="0.85rem", align="start", padding="1rem", background=SURFACE,
+        border=BORDER, width="100%")
+
+
+def repositories_page() -> rx.Component:
+    listing = rx.cond(
+        AdminState.repositories.length() > 0,
+        rx.vstack(rx.foreach(AdminState.repositories, repository_row),
+                  spacing="3", width="100%"),
+        empty_state("folder-git-2", "No repositories cloned yet."))
+    return shell(rx.vstack(
+        page_header("Repositories",
+                    "Repositories the coding agents work in."),
+        rx.box(
+            rx.flex(
+                rx.input(placeholder="git@github.com:org/repo.git",
+                         value=AdminState.new_repository_url,
+                         on_change=AdminState.set_new_repository_url,
+                         flex="1"),
+                rx.button(rx.icon("plus", size=16), "Add repository",
+                          loading=AdminState.adding_repository,
+                          on_click=AdminState.add_repository),
+                gap="0.75rem", width="100%"),
+            rx.text("Clones a bare repository into repositories/<name>/.bare "
+                    "and checks out its default branch as a worktree beside it. "
+                    "A first clone can take a few minutes.",
+                    color=MUTED, font_size="0.82rem", margin_top="0.75rem"),
+            padding="1.25rem", background=SURFACE, border=BORDER, width="100%"),
+        rx.callout(
+            rx.fragment(
+                "The agents work better when they know what each repository "
+                "is for: describe them in ",
+                rx.link(AGENTS_FILE, on_click=AdminState.open_agents_editor,
+                        color=ACCENT, cursor="pointer",
+                        text_decoration="underline"),
+                ".",
+            ),
+            icon="info", size="1", color_scheme="gray", width="100%"),
+        listing,
+        spacing="5", align="start", width="100%"))
+
+
 def run_row(run: RunRecord) -> rx.Component:
     return rx.box(
         rx.flex(
@@ -1529,7 +1640,7 @@ def settings_page() -> rx.Component:
         spacing="4", width="100%")
     return shell(rx.vstack(
         page_header(
-            "Settings", "Choose providers and control executor concurrency."),
+            "Settings", ""),
         rx.box(
             rx.heading("Coding agent", size="4", margin_bottom="1rem"),
             rx.grid(
@@ -1665,15 +1776,20 @@ app = rx.App(
     api_transformer=api_app,
 )
 app.add_page(dashboard_page, route="/", title="Dashboard | Codee",
-             on_load=AdminState.poll_dashboard)
+             on_load=[AdminState.load_coding_agent, AdminState.poll_dashboard])
 app.add_page(skills_page, route="/skills", title="Skills | Codee",
-             on_load=[AdminState.load_skills, AdminState.load_agent_models])
+             on_load=[AdminState.load_coding_agent, AdminState.load_skills,
+                      AdminState.load_agent_models])
 app.add_page(workflow_page, route="/workflow", title="Workflow | Codee",
-             on_load=AdminState.load_workflow)
+             on_load=[AdminState.load_coding_agent, AdminState.load_workflow])
 app.add_page(memory_page, route="/memory", title="Memory | Codee",
              on_load=AdminState.load_memories)
+app.add_page(repositories_page, route="/repositories",
+             title="Repositories | Codee",
+             on_load=[AdminState.load_coding_agent,
+                      AdminState.load_repositories])
 app.add_page(runs_page, route="/runs", title="Runs | Codee",
-             on_load=AdminState.load_runs)
+             on_load=[AdminState.load_coding_agent, AdminState.load_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.3.0 → codee_agent-0.4.0}/src/codee/admin_service.py

@@ -57,6 +57,20 @@ MANAGED = {
     "x-codee-aws-sqs-queue",
 }
 AGENTS_FILE = "AGENTS.md"
+# Layout the coding agents are told to expect (see the AGENTS.md template):
+# `repositories/<repo>/.bare` holds the bare clone, `repositories/<repo>/.git`
+# points git at it, and every branch is checked out as its own worktree
+# directory beside them.
+REPOSITORIES_DIR = "repositories"
+BARE_DIR = ".bare"
+# Cloning happens on a worker thread with nobody to answer a prompt, so git is
+# told to fail instead of blocking on an unknown host key or missing credentials.
+GIT_NON_INTERACTIVE_ENV = {
+    "GIT_TERMINAL_PROMPT": "0",
+    "GIT_SSH_COMMAND": "ssh -o BatchMode=yes",
+}
+GIT_TIMEOUT = 60
+GIT_NETWORK_TIMEOUT = 900
 SKILL_TYPES = [
     "knowledge",
     "slash command",
@@ -115,6 +129,22 @@ def slugify(value: str) -> str:
     return re.sub(r"[^a-z0-9-]+", "-", value.strip().lower()).strip("-")
 
 
+def repository_name(url: str) -> str:
+    """Directory a clone URL lands in: its last path segment, without `.git`.
+
+    Handles the scp-style SSH form (`git@host:org/repo.git`) too, which has no
+    scheme for ``urlparse`` to read.
+    """
+    text = url.strip().rstrip("/")
+    if not text:
+        return ""
+    path = urlparse(text).path if "://" in text else text.rsplit(":", 1)[-1]
+    name = path.rstrip("/").rsplit("/", 1)[-1]
+    if name.endswith(".git"):
+        name = name[: -len(".git")]
+    return re.sub(r"[^A-Za-z0-9._-]+", "-", name).strip("-.")
+
+
 def parse_skill(text: str) -> tuple[dict[str, Any], str]:
     match = FM_RE.match(text)
     if not match:
@@ -256,6 +286,7 @@ class AdminService:
         self.agents_file = self.root / AGENTS_FILE
         self.memory_dir = memory_dir(self.root)
         self.memory_index = self.memory_dir / "MEMORY.md"
+        self.repositories_dir = self.root / REPOSITORIES_DIR
         self.data_dir = data_dir(self.root)
         self.session_viewer = os.environ.get("CODEE_SESSION_VIEWER_URL", "")
         self.skills_dir.mkdir(parents=True, exist_ok=True)
@@ -947,6 +978,118 @@ class AdminService:
             return True, True, f"Deleted {filename}"
         return True, False, f"Deleted {filename} locally, but Git push failed: {output}"
 
+    # --- Repositories -------------------------------------------------------
+
+    def _run_git(
+        self,
+        arguments: list[str],
+        cwd: Path,
+        timeout: int = GIT_TIMEOUT,
+    ) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            ["git", *arguments],
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            env={**os.environ, **GIT_NON_INTERACTIVE_ENV},
+        )
+
+    def _git_output(self, arguments: list[str], cwd: Path) -> str:
+        """One-line git output, or '' when the command fails. Never raises."""
+        try:
+            result = self._run_git(arguments, cwd)
+        except (OSError, subprocess.SubprocessError):
+            return ""
+        return result.stdout.strip() if result.returncode == 0 else ""
+
+    def list_repositories(self) -> list[dict[str, Any]]:
+        """The repositories under `repositories/`, in name order.
+
+        Only directories carrying a bare clone are listed: `repositories/` is
+        the agents' working area, so anything else in it is scratch.
+        """
+        if not self.repositories_dir.is_dir():
+            return []
+        repositories = []
+        for directory in sorted(self.repositories_dir.iterdir()):
+            if not (directory / BARE_DIR).is_dir():
+                continue
+            repositories.append({
+                "name": directory.name,
+                "url": self._git_output(
+                    ["remote", "get-url", "origin"], directory),
+                "default_branch": self._git_output(
+                    ["symbolic-ref", "--short", "HEAD"], directory),
+            })
+        return repositories
+
+    def add_repository(self, url: str) -> tuple[bool, str, str]:
+        """Clone `url` into the bare-plus-worktree layout the agents expect.
+
+        Leaves behind `repositories/<name>/.bare`, a `.git` file pointing at it,
+        and a worktree for whichever branch the remote calls its default. A
+        failure anywhere removes the half-built directory so a retry is clean.
+        """
+        url = url.strip()
+        if not url:
+            return False, "Enter a repository URL", ""
+        name = repository_name(url)
+        if not name:
+            return False, f"Could not work out a folder name from {url}", ""
+        directory = self.repositories_dir / name
+        if directory.exists():
+            return False, f"{REPOSITORIES_DIR}/{name} already exists", name
+
+        directory.mkdir(parents=True)
+        try:
+            self._clone_repository(url, directory)
+            branch = self._git_output(
+                ["symbolic-ref", "--short", "HEAD"], directory)
+            if not branch:
+                raise RuntimeError(
+                    "Cloned, but the remote names no default branch")
+            self._check(
+                self._run_git(["worktree", "add", branch], directory),
+                f"Could not create the {branch} worktree",
+            )
+        except Exception as error:
+            shutil.rmtree(directory, ignore_errors=True)
+            return False, str(error), name
+        return True, f"Cloned {name} and checked out {branch}", name
+
+    def _clone_repository(self, url: str, directory: Path) -> None:
+        """Bare clone plus the wiring that makes the directory usable as a repo."""
+        self._check(
+            self._run_git(["clone", "--bare", url, BARE_DIR], directory,
+                          timeout=GIT_NETWORK_TIMEOUT),
+            f"Could not clone {url}",
+        )
+        # Makes git treat the repository directory itself as the repo, so the
+        # worktree commands in AGENTS.md run from there without pointing at
+        # `.bare` every time.
+        (directory / ".git").write_text(f"gitdir: ./{BARE_DIR}\n")
+        # A bare clone fetches straight into `refs/heads/*` and configures no
+        # remote-tracking refspec, so without this `origin/<branch>` never
+        # exists and later worktrees have nothing to branch off.
+        self._check(
+            self._run_git(["config", "remote.origin.fetch",
+                           "+refs/heads/*:refs/remotes/origin/*"], directory),
+            "Could not configure the origin refspec",
+        )
+        self._check(
+            self._run_git(["fetch", "origin"], directory,
+                          timeout=GIT_NETWORK_TIMEOUT),
+            "Could not fetch from origin",
+        )
+
+    @staticmethod
+    def _check(result: subprocess.CompletedProcess[str], message: str) -> None:
+        if result.returncode != 0:
+            detail = (result.stderr.strip() or result.stdout.strip()
+                      or f"git exited with {result.returncode}")
+            raise RuntimeError(f"{message}: {detail}")
+
     def dashboard(self) -> dict[str, Any]:
         return {
             "active": [

{codee_agent-0.3.0 → codee_agent-0.4.0}/src/codee/test_admin_service.py

@@ -1,4 +1,5 @@
 import os
+import subprocess
 import tempfile
 import threading
 import unittest
@@ -10,7 +11,8 @@ from codee_agent_abstract.provider import AgentModel
 from codee_agent_claude_code.provider import ClaudeCodeAgent
 from codee_agent_github_copilot.provider import GitHubCopilotAgent
 
-from codee.admin_service import AdminService, azure_oauth, parse_skill
+from codee.admin_service import (
+    AdminService, azure_oauth, parse_skill, repository_name)
 from codee_main_context.context import (
     CodeeMainContext, CodingAgent, Settings, TasksProvider, save_settings)
 
@@ -880,6 +882,120 @@ class AdminServiceAgentsFileTest(unittest.TestCase):
             self.assertIn(str(root / "AGENTS.md"), with_agents)
 
 
+class AdminServiceRepositoriesTest(unittest.TestCase):
+    """Clones run for real against a local source repo: no network needed."""
+
+    def _service(self, root: Path) -> AdminService:
+        service = AdminService.__new__(AdminService)
+        service.root = root
+        service.repositories_dir = root / "repositories"
+        return service
+
+    def _source_repository(self, path: Path, branch: str) -> Path:
+        """A one-commit repository whose default branch is ``branch``."""
+        path.mkdir(parents=True)
+        self._git(path, "init", "-b", branch)
+        (path / "README.md").write_text("source\n")
+        self._git(path, "add", "README.md")
+        self._git(path, "-c", "user.email=codee@example.com",
+                  "-c", "user.name=Codee", "-c", "commit.gpgsign=false",
+                  "commit", "-m", "initial")
+        return path
+
+    def _git(self, cwd: Path, *arguments: str) -> str:
+        result = subprocess.run(["git", "-C", str(cwd), *arguments],
+                                capture_output=True, text=True, check=True)
+        return result.stdout.strip()
+
+    def test_name_is_taken_from_every_url_form(self) -> None:
+        self.assertEqual(repository_name("git@github.com:org/codee.git"), "codee")
+        self.assertEqual(repository_name("ssh://git@github.com/org/codee.git"),
+                         "codee")
+        self.assertEqual(repository_name("https://github.com/org/codee/"), "codee")
+        self.assertEqual(repository_name("  "), "")
+
+    def test_add_builds_the_bare_and_worktree_layout(self) -> None:
+        for branch in ("main", "master"):
+            with self.subTest(branch=branch), \
+                    tempfile.TemporaryDirectory() as temporary_directory:
+                root = Path(temporary_directory)
+                source = self._source_repository(root / "source", branch)
+                service = self._service(root)
+
+                added, message, name = service.add_repository(str(source))
+
+                repository = root / "repositories" / "source"
+                self.assertTrue(added, message)
+                self.assertEqual(name, "source")
+                self.assertIn(branch, message)
+                self.assertTrue((repository / ".bare").is_dir())
+                self.assertEqual((repository / ".git").read_text(),
+                                 "gitdir: ./.bare\n")
+                # The branch is checked out beside `.bare`, as its own worktree.
+                self.assertTrue((repository / branch / "README.md").is_file())
+                self.assertEqual(
+                    self._git(repository / branch, "rev-parse",
+                              "--abbrev-ref", "HEAD"),
+                    branch)
+
+    def test_add_fetches_remote_tracking_refs_for_later_worktrees(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            source = self._source_repository(root / "source", "main")
+            service = self._service(root)
+
+            service.add_repository(str(source))
+
+            repository = root / "repositories" / "source"
+            self.assertTrue(self._git(repository, "rev-parse", "origin/main"))
+
+    def test_add_refuses_a_repository_that_is_already_there(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            (root / "repositories" / "source").mkdir(parents=True)
+            service = self._service(root)
+
+            added, message, _ = service.add_repository(
+                "git@github.com:org/source.git")
+
+            self.assertFalse(added)
+            self.assertIn("already exists", message)
+
+    def test_a_failed_clone_leaves_no_directory_behind(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            service = self._service(root)
+
+            added, message, _ = service.add_repository(
+                str(root / "missing-repository.git"))
+
+            self.assertFalse(added)
+            self.assertIn("Could not clone", message)
+            self.assertFalse((root / "repositories" / "missing-repository")
+                             .exists())
+
+    def test_list_reports_the_clone_and_skips_everything_else(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            source = self._source_repository(root / "source", "main")
+            service = self._service(root)
+            service.add_repository(str(source))
+            (root / "repositories" / "scratch").mkdir()
+
+            repositories = service.list_repositories()
+
+            self.assertEqual([repository["name"] for repository in repositories],
+                             ["source"])
+            self.assertEqual(repositories[0]["url"], str(source))
+            self.assertEqual(repositories[0]["default_branch"], "main")
+
+    def test_list_is_empty_before_anything_is_cloned(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            service = self._service(Path(temporary_directory))
+
+            self.assertEqual(service.list_repositories(), [])
+
+
 class AzureDevOpsOAuthTest(unittest.TestCase):
     """The admin side of the flow: build the URL, then handle the callback."""