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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codee-agent
-Version: 0.2.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.2.0 → codee_agent-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codee-agent"
-version = "0.2.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.2.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,6 +350,11 @@ class AdminState(rx.State):
         return _save_toast(*SERVICE.save_agents(self.agents_content))
 
     def load_memories(self) -> None:
+        self.load_coding_agent()
+        if self.coding_agent == "github_copilot":
+            self.memories = []
+            self.selected_memory = ""
+            return
         self.memories = [MemoryEntry(**entry)
                          for entry in SERVICE.list_memories()]
 
@@ -362,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 = [
@@ -471,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
@@ -605,6 +660,7 @@ class AdminState(rx.State):
 
 
 ACCENT = "var(--codee-accent)"
+ACCENT_DEEP = "var(--codee-accent-deep)"
 BORDER = "1px solid var(--codee-border)"
 MUTED = "var(--codee-muted)"
 SURFACE = "var(--codee-surface)"
@@ -676,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",
@@ -706,23 +764,26 @@ def shell(content: rx.Component) -> rx.Component:
         color=TEXT,
         font_family="IBM Plex Sans, sans-serif",
         style={
-            "--codee-accent": rx.color_mode_cond("#167d5a", "#4abd85"),
-            "--codee-border": rx.color_mode_cond("#dfe4df", "#354039"),
-            "--codee-muted": rx.color_mode_cond("#68716b", "#a1ada5"),
-            "--codee-surface": rx.color_mode_cond("#ffffff", "#18201c"),
-            "--codee-page-background": rx.color_mode_cond("#f3f5f3", "#101512"),
-            "--codee-nav-background": rx.color_mode_cond("#f7f9f7", "#141b17"),
-            "--codee-text": rx.color_mode_cond("#202721", "#edf3ef"),
-            "--codee-hover": rx.color_mode_cond("#edf5f0", "#213029"),
-            "--codee-active": rx.color_mode_cond("#e2efe9", "#23372e"),
-            "--codee-grid": rx.color_mode_cond("#e4e9e5", "#2e3932"),
-            "--codee-subtle-icon": rx.color_mode_cond("#91a097", "#718078"),
-            "--codee-warning-background": rx.color_mode_cond("#fffbeb", "#332a13"),
-            "--codee-warning-border": rx.color_mode_cond("#d97706", "#f59e0b"),
+            "--codee-accent": rx.color_mode_cond("#2f6fd6", "#7aa9f0"),
+            # The darker half of the two-blue brand pairing, for filled marks
+            # that should recede behind the interactive blue (step markers).
+            "--codee-accent-deep": rx.color_mode_cond("#232c9b", "#5866de"),
+            "--codee-border": rx.color_mode_cond("#dbe1ec", "#2b3350"),
+            "--codee-muted": rx.color_mode_cond("#5d687f", "#a3adc4"),
+            "--codee-surface": rx.color_mode_cond("#ffffff", "#171d33"),
+            "--codee-page-background": rx.color_mode_cond("#f2f5fb", "#0e1224"),
+            "--codee-nav-background": rx.color_mode_cond("#f7f9fd", "#121729"),
+            "--codee-text": rx.color_mode_cond("#1b2440", "#e9edf7"),
+            "--codee-hover": rx.color_mode_cond("#edf3fc", "#1e2742"),
+            "--codee-active": rx.color_mode_cond("#e0eafb", "#24304f"),
+            "--codee-grid": rx.color_mode_cond("#e2e7f1", "#2a3350"),
+            "--codee-subtle-icon": rx.color_mode_cond("#8e99b0", "#6e7a94"),
+            "--codee-warning-background": rx.color_mode_cond("#fff5ed", "#33200f"),
+            "--codee-warning-border": rx.color_mode_cond("#e26128", "#f5854a"),
             # Tint reserved for in-flight work, so a live run reads at a glance.
-            "--codee-running-background": rx.color_mode_cond("#effaf4", "#15271f"),
+            "--codee-running-background": rx.color_mode_cond("#eff4fd", "#14203a"),
             "--codee-running-glow": rx.color_mode_cond(
-                "rgba(22, 125, 90, 0.16)", "rgba(74, 189, 133, 0.18)"),
+                "rgba(47, 111, 214, 0.16)", "rgba(122, 169, 240, 0.18)"),
             "color_scheme": "light dark",
         },
     )
@@ -753,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,
@@ -765,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",
@@ -888,13 +951,13 @@ def skill_card(skill: SkillSummary) -> rx.Component:
     return rx.box(
         rx.vstack(
             rx.hstack(rx.heading(skill.name, size="4"), rx.spacer(),
-                      rx.badge(skill.type, color_scheme="green", variant="soft"), width="100%"),
+                      rx.badge(skill.type, color_scheme="blue", variant="soft"), width="100%"),
             rx.text(skill.description, color=MUTED, font_size="0.9rem", min_height="2.7rem",
                     overflow="hidden"),
             rx.cond(
                 skill.issue_status != "",
                 rx.hstack(
-                    rx.badge(skill.issue_type, color_scheme="green",
+                    rx.badge(skill.issue_type, color_scheme="blue",
                              variant="outline"),
                     rx.icon("circle-dot", size=14, color=SUBTLE_ICON),
                     rx.text(skill.issue_status, color=MUTED,
@@ -1192,12 +1255,73 @@ 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."),
-                           rx.cond(AdminState.selected_memory ==
-                                   "", listing, memory_editor()),
+    return shell(rx.vstack(page_header("Memory", "Manage agent provider's memory."),
+                           rx.cond(AdminState.coding_agent == "github_copilot",
+                                   empty_state(
+                                       "notebook-text",
+                                       "Github Copilot currently does not support local memory"),
+                                   rx.cond(AdminState.selected_memory ==
+                                           "", listing, memory_editor())),
                            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(
@@ -1239,7 +1363,7 @@ def workflow_warning(message: rx.Var) -> rx.Component:
     return rx.callout(
         message,
         icon="triangle-alert",
-        color_scheme="amber",
+        color_scheme="orange",
         width="100%",
     )
 
@@ -1393,7 +1517,7 @@ def sessions_page() -> rx.Component:
 
 def azure_step(number: int, title: str, detail: rx.Component | str) -> rx.Component:
     return rx.hstack(
-        rx.box(str(number), color="white", background=ACCENT, min_width="1.4rem",
+        rx.box(str(number), color="white", background=ACCENT_DEEP, min_width="1.4rem",
                height="1.4rem", display="grid", place_items="center",
                border_radius="50%", font_size="0.75rem", font_weight="700"),
         rx.vstack(rx.text(title, font_weight="600", font_size="0.9rem"),
@@ -1516,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(
@@ -1635,10 +1759,10 @@ app = rx.App(
             "width": "6px",
         },
         ".workflow-route-node--forward .react-flow__handle": {
-            "background": "#167d5a",
+            "background": "#2f6fd6",
         },
         ".workflow-route-node--return .react-flow__handle": {
-            "background": "#d97706",
+            "background": "#e26128",
         },
     },
     stylesheets=[
@@ -1652,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.2.0 → codee_agent-0.4.0}/src/codee/admin_cli.py

@@ -22,8 +22,8 @@ config = rx.Config(
     plugins=[
         rx.plugins.RadixThemesPlugin(
             theme=rx.theme(
-                accent_color="green",
-                gray_color="sage",
+                accent_color="indigo",
+                gray_color="slate",
                 radius="small",
                 appearance="inherit",
             )

{codee_agent-0.2.0 → codee_agent-0.4.0}/src/codee/admin_service.py

@@ -1,4 +1,5 @@
 """Framework-independent operations for the Codee admin UI."""
+import hashlib
 import json
 import re
 import os
@@ -56,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",
@@ -74,6 +89,9 @@ _CODING_AGENTS: dict[CodingAgent, type[AbstractCodingAgent]] = {
 }
 WORKFLOW_NODE_SPACING = 440
 WORKFLOW_NODE_CENTER_OFFSET = 110
+# Inferring the workflow costs a coding-agent run, so the graph is kept in the
+# data directory and reused by later admin processes.
+WORKFLOW_CACHE_FILE = "workflow.json"
 
 # Port the admin UI listens on unless ``codee-admin --port`` says otherwise.
 # The OAuth redirect URI is built from it, and Entra ID matches redirect URIs
@@ -111,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:
@@ -199,6 +233,18 @@ def _transition_values(value: Any) -> list[dict[str, str]]:
     return transitions
 
 
+def _is_workflow(value: Any) -> bool:
+    """Whether a stored graph still has the shape the workflow page reads."""
+    if not isinstance(value, dict):
+        return False
+    return all(
+        isinstance(value.get(issue_type), dict)
+        and all(isinstance(value[issue_type].get(key), list)
+                for key in ("nodes", "edges", "warnings"))
+        for issue_type in ISSUE_TYPES
+    )
+
+
 def _remove_redundant_skill_transitions(
     transitions: list[dict[str, str]],
 ) -> list[dict[str, str]]:
@@ -240,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)
@@ -247,7 +294,8 @@ class AdminService:
         self.data_dir.mkdir(parents=True, exist_ok=True)
         self.context = CodeeMainContext(data_dir=self.data_dir)
         self.context.settings = load_settings(self.data_dir)
-        self._workflow_cache: dict[str, Any] | None = None
+        # Cached graph plus the skill fingerprint it was generated from.
+        self._workflow_cache: tuple[str, dict[str, Any]] | None = None
         self._workflow_lock = threading.Lock()
         # Asking an agent for its catalog can mean spawning its CLI, so the
         # answer is cached per agent for the life of the process.
@@ -343,16 +391,73 @@ class AdminService:
         return ""
 
     def generate_workflow(self, force: bool = False) -> dict[str, Any]:
-        """Return cached workflows by issue type, regenerating when requested."""
+        """Return cached workflows by issue type, regenerating when requested.
+
+        The cache outlives the admin process: it is stored in the data
+        directory under the fingerprint of the skill documents the graph was
+        inferred from, so a restart reuses it while an edited skill still
+        regenerates it.
+        """
         workflow_lock = getattr(self, "_workflow_lock", None)
         if workflow_lock is None:
             workflow_lock = self._workflow_lock = threading.Lock()
         with workflow_lock:
-            workflow_cache = getattr(self, "_workflow_cache", None)
-            if not force and workflow_cache is not None:
-                return workflow_cache
-            self._workflow_cache = self._generate_workflow()
-            return self._workflow_cache
+            fingerprint = self._workflow_fingerprint()
+            if not force:
+                cached = self._cached_workflow(fingerprint)
+                if cached is not None:
+                    return cached
+            workflow = self._generate_workflow()
+            self._workflow_cache = (fingerprint, workflow)
+            self._store_workflow(fingerprint, workflow)
+            return workflow
+
+    def _workflow_fingerprint(self) -> str:
+        """Digest the skill documents the workflow graph is inferred from."""
+        digest = hashlib.sha256()
+        for skill in find_issue_triggered_skills(self.skills_dir):
+            digest.update(skill.slug.encode())
+            digest.update(b"\0")
+            digest.update(skill.path.read_bytes())
+            digest.update(b"\0")
+        return digest.hexdigest()
+
+    def _workflow_cache_path(self) -> Path:
+        return self.data_dir / WORKFLOW_CACHE_FILE
+
+    def _cached_workflow(self, fingerprint: str) -> dict[str, Any] | None:
+        """This process's graph, else the one an earlier process stored."""
+        cached = getattr(self, "_workflow_cache", None)
+        if cached is not None and cached[0] == fingerprint:
+            return cached[1]
+        try:
+            stored = json.loads(self._workflow_cache_path().read_text())
+        except FileNotFoundError:
+            return None
+        except (OSError, ValueError) as error:
+            print(f"[admin] Ignoring unreadable workflow cache: {error}")
+            return None
+        if not isinstance(stored, dict) or stored.get("fingerprint") != fingerprint:
+            return None
+        workflow = stored.get("workflow")
+        if not _is_workflow(workflow):
+            return None
+        self._workflow_cache = (fingerprint, workflow)
+        return workflow
+
+    def _store_workflow(self, fingerprint: str, workflow: dict[str, Any]) -> None:
+        """Persist the graph for the next admin process; failing is not fatal."""
+        path = self._workflow_cache_path()
+        pending = path.with_suffix(".tmp")
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            pending.write_text(json.dumps(
+                {"fingerprint": fingerprint, "workflow": workflow}))
+            # Replace in one step so a crash mid-write cannot leave a
+            # half-written cache behind.
+            pending.replace(path)
+        except OSError as error:
+            print(f"[admin] Failed to store workflow cache: {error}")
 
     def _generate_workflow(self) -> dict[str, Any]:
         """Infer separate status graphs for story and task skills."""
@@ -873,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.2.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,11 +11,31 @@ 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)
 
 
+def _empty_workflow() -> dict:
+    return {issue_type: {"nodes": [], "edges": [], "warnings": []}
+            for issue_type in ("story", "task")}
+
+
+def _write_issue_skill(root: Path) -> Path:
+    """Create one issue-trigger skill, the input the workflow cache is keyed on."""
+    skills_dir = root / ".claude" / "skills"
+    skill_dir = skills_dir / "develop"
+    skill_dir.mkdir(parents=True)
+    (skill_dir / "SKILL.md").write_text(
+        "---\nname: develop\ndisable-model-invocation: true\n"
+        "x-codee-trigger: issue\nx-codee-issue-status: [Ready]\n"
+        "x-codee-issue-type: story\n---\n"
+        "After implementation, move the issue to Review.\n"
+    )
+    return skills_dir
+
+
 class AdminServiceIssueTriggerTest(unittest.TestCase):
     def test_list_skills_includes_issue_status(self) -> None:
         with tempfile.TemporaryDirectory() as temporary_directory:
@@ -227,6 +248,7 @@ class AdminServiceIssueTriggerTest(unittest.TestCase):
             service = AdminService.__new__(AdminService)
             service.root = root
             service.skills_dir = skills_dir
+            service.data_dir = root / ".codee"
             service.context = Mock(settings=Settings(
                 coding_agent=CodingAgent.CLAUDE_CODE))
 
@@ -315,6 +337,7 @@ class AdminServiceIssueTriggerTest(unittest.TestCase):
             service = AdminService.__new__(AdminService)
             service.root = root
             service.skills_dir = skills_dir
+            service.data_dir = root / ".codee"
             service.context = Mock(
                 settings=Settings(coding_agent=CodingAgent.CLAUDE_CODE))
 
@@ -356,6 +379,7 @@ class AdminServiceIssueTriggerTest(unittest.TestCase):
             service = AdminService.__new__(AdminService)
             service.root = root
             service.skills_dir = skills_dir
+            service.data_dir = root / ".codee"
             service.context = Mock(
                 settings=Settings(coding_agent=CodingAgent.CLAUDE_CODE))
 
@@ -406,6 +430,7 @@ class AdminServiceIssueTriggerTest(unittest.TestCase):
             service = AdminService.__new__(AdminService)
             service.root = root
             service.skills_dir = skills_dir
+            service.data_dir = root / ".codee"
             service.context = Mock(
                 settings=Settings(coding_agent=CodingAgent.CLAUDE_CODE))
 
@@ -462,6 +487,7 @@ class AdminServiceIssueTriggerTest(unittest.TestCase):
             service = AdminService.__new__(AdminService)
             service.root = root
             service.skills_dir = skills_dir
+            service.data_dir = root / ".codee"
             service.context = Mock(
                 settings=Settings(coding_agent=CodingAgent.CLAUDE_CODE))
 
@@ -501,6 +527,7 @@ class AdminServiceIssueTriggerTest(unittest.TestCase):
             service = AdminService.__new__(AdminService)
             service.root = root
             service.skills_dir = skills_dir
+            service.data_dir = root / ".codee"
             service.context = Mock(
                 settings=Settings(coding_agent=CodingAgent.CLAUDE_CODE))
 
@@ -518,8 +545,10 @@ class AdminServiceIssueTriggerTest(unittest.TestCase):
 
     def test_generate_workflow_returns_empty_without_issue_skills(self) -> None:
         with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
             service = AdminService.__new__(AdminService)
-            service.skills_dir = Path(temporary_directory)
+            service.skills_dir = root
+            service.data_dir = root / ".codee"
 
             self.assertEqual(service.generate_workflow(), {
                 "story": {"nodes": [], "edges": [], "warnings": []},
@@ -527,15 +556,92 @@ class AdminServiceIssueTriggerTest(unittest.TestCase):
             })
 
     def test_generate_workflow_is_cached_until_forced(self) -> None:
-        service = AdminService.__new__(AdminService)
-        generated = {"nodes": [], "edges": [], "warnings": []}
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            service = AdminService.__new__(AdminService)
+            service.skills_dir = root / ".claude" / "skills"
+            service.data_dir = root / ".codee"
+            generated = _empty_workflow()
+
+            with patch.object(service, "_generate_workflow",
+                              return_value=generated) as generate:
+                self.assertIs(service.generate_workflow(), generated)
+                self.assertIs(service.generate_workflow(), generated)
+                self.assertIs(service.generate_workflow(force=True), generated)
+
+            self.assertEqual(generate.call_count, 2)
+
+    def test_generate_workflow_reuses_graph_stored_by_an_earlier_process(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            skills_dir = _write_issue_skill(root)
+            generated = _empty_workflow()
+            generated["story"]["warnings"] = ["stored"]
+
+            first = AdminService.__new__(AdminService)
+            first.skills_dir = skills_dir
+            first.data_dir = root / ".codee"
+            with patch.object(first, "_generate_workflow", return_value=generated):
+                first.generate_workflow()
+
+            # A restart starts from an empty in-memory cache, so only the file
+            # written above can spare it another coding-agent run.
+            restarted = AdminService.__new__(AdminService)
+            restarted.skills_dir = skills_dir
+            restarted.data_dir = root / ".codee"
+            with patch.object(restarted, "_generate_workflow") as generate:
+                workflow = restarted.generate_workflow()
+
+            generate.assert_not_called()
+            self.assertEqual(workflow["story"]["warnings"], ["stored"])
+
+    def test_generate_workflow_ignores_stored_graph_after_a_skill_changes(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            skills_dir = _write_issue_skill(root)
+
+            first = AdminService.__new__(AdminService)
+            first.skills_dir = skills_dir
+            first.data_dir = root / ".codee"
+            with patch.object(first, "_generate_workflow",
+                              return_value=_empty_workflow()):
+                first.generate_workflow()
+
+            (skills_dir / "develop" / "SKILL.md").write_text(
+                "---\nname: develop\ndisable-model-invocation: true\n"
+                "x-codee-trigger: issue\nx-codee-issue-status: [Ready]\n"
+                "x-codee-issue-type: story\n---\n"
+                "After implementation, move the issue to Done.\n"
+            )
+            regenerated = _empty_workflow()
+            regenerated["story"]["warnings"] = ["regenerated"]
+            restarted = AdminService.__new__(AdminService)
+            restarted.skills_dir = skills_dir
+            restarted.data_dir = root / ".codee"
+            with patch.object(restarted, "_generate_workflow",
+                              return_value=regenerated) as generate:
+                workflow = restarted.generate_workflow()
+
+            generate.assert_called_once_with()
+            self.assertEqual(workflow["story"]["warnings"], ["regenerated"])
+
+    def test_generate_workflow_ignores_a_corrupt_stored_graph(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            skills_dir = _write_issue_skill(root)
+            data_dir = root / ".codee"
+            data_dir.mkdir()
+            (data_dir / "workflow.json").write_text("{ not json")
 
-        with patch.object(service, "_generate_workflow", return_value=generated) as generate:
-            self.assertIs(service.generate_workflow(), generated)
-            self.assertIs(service.generate_workflow(), generated)
-            self.assertIs(service.generate_workflow(force=True), generated)
+            service = AdminService.__new__(AdminService)
+            service.skills_dir = skills_dir
+            service.data_dir = data_dir
+            generated = _empty_workflow()
+            with patch.object(service, "_generate_workflow",
+                              return_value=generated) as generate:
+                self.assertIs(service.generate_workflow(), generated)
 
-        self.assertEqual(generate.call_count, 2)
+            generate.assert_called_once_with()
 
 
 class AdminServiceSkillModelTest(unittest.TestCase):
@@ -776,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."""