codee-agent 0.6.0__tar.gz → 0.6.1__tar.gz

{codee_agent-0.6.0 → codee_agent-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codee-agent
-Version: 0.6.0
+Version: 0.6.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,codex,automation
 Author: Denis Kibalko
@@ -41,6 +41,13 @@ Codee works with Jira and Azure DevOps as tasks providers, new providers are qui
 
 As agents it currently works with Claude Code, Github Copilot and Codex.
 
+## Documentation
+
+Full documentation is at [fusebase-dev.github.io/codee](https://fusebase-dev.github.io/codee/), covering
+installation, configuration and tutorials for working on tasks in Jira and Azure DevOps. There is also a
+[click-through demo of the admin UI](https://fusebase-dev.github.io/codee/demo/) that runs without installing
+anything.
+
 ## Run Codee
 
 Codee lives in its own directory, where it keeps skills, memory, temp files and config.

{codee_agent-0.6.0 → codee_agent-0.6.1}/README.md

@@ -6,6 +6,13 @@ Codee works with Jira and Azure DevOps as tasks providers, new providers are qui
 
 As agents it currently works with Claude Code, Github Copilot and Codex.
 
+## Documentation
+
+Full documentation is at [fusebase-dev.github.io/codee](https://fusebase-dev.github.io/codee/), covering
+installation, configuration and tutorials for working on tasks in Jira and Azure DevOps. There is also a
+[click-through demo of the admin UI](https://fusebase-dev.github.io/codee/demo/) that runs without installing
+anything.
+
 ## Run Codee
 
 Codee lives in its own directory, where it keeps skills, memory, temp files and config.

{codee_agent-0.6.0 → codee_agent-0.6.1}/pyproject.toml

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

{codee_agent-0.6.0 → codee_agent-0.6.1}/src/codee/executor.py

@@ -44,7 +44,8 @@ POLL_INTERVAL = 60  # 1 minute
 SESSIONS_FILE = context.data_dir / "sessions.json"
 # The project Codee operates on — same root the trigger modules scan for
 # `.claude/skills`. The coding agent is spawned with this as its cwd, so the
-# `/<slug>` messages we build from those skills actually resolve.
+# invocations we build from those skills — a `/<slug>` command, or a path to the
+# skill file for agents that don't resolve one — actually resolve.
 REPO_ROOT = project_root()
 
 # Task agents run concurrently, one thread each, so one long agent (up to 2h)
@@ -246,7 +247,7 @@ def _pull_latest_code() -> bool:
 
 
 def _run_agent(user_message: str, session_id: str, model: str = "",
-               agent_code: str = "") -> str:
+               agent_code: str = "", label: str = "") -> str:
     """Run the skill's coding agent and return its response text.
 
     ``model`` comes from the triggering skill's ``model:`` frontmatter; agents
@@ -254,9 +255,14 @@ def _run_agent(user_message: str, session_id: str, model: str = "",
     its ``x-codee-agent:`` frontmatter and picks which agent runs at all, empty
     for the default one. Wraps the agent run in job tracking; the agent itself
     raises on any failure so callers can retry.
+
+    ``label`` is how the run should read on the dashboard when that differs
+    from the prompt — an issue run is always shown as ``/<slug> <task id>``,
+    whatever wording the agent needed. Empty means the prompt is the label.
     """
     agent = _agent_for_skill(agent_code)
-    job_id = runs_db.start_job(session_id, user_message, agent=agent.DISPLAY_NAME,
+    job_id = runs_db.start_job(session_id, label or user_message,
+                               agent=agent.DISPLAY_NAME,
                                model=model, main_context=context)
     log.debug("job %s started: session=%s message=%r model=%r agent=%s",
               job_id, session_id, user_message, model, agent.describe())
@@ -288,21 +294,26 @@ def _run_agent(user_message: str, session_id: str, model: str = "",
 
 
 def _run_task(task_id: str, message: str, session_id: str, skill_name: str,
-              model: str = "", agent_code: str = "") -> None:
+              model: str = "", agent_code: str = "", label: str = "") -> None:
     """Pool worker: run one task's coding agent, then release its in-flight slot.
 
     Logs the outcome to the runs table like the cron/email/sqs triggers do, so
     issue-triggered coding runs show up on the dashboard too. Stamped with the
     launch time (not the finish time) so the hourly chart buckets it where it
     actually started — an agent can run for hours.
+
+    ``label`` is what the dashboard and the run log show instead of ``message``,
+    so every issue run reads as its ``/<slug> <task id>`` command no matter how
+    the agent had to be asked. The prompt itself is in the debug log.
     """
     started_at = datetime.now(timezone.utc).isoformat()
+    shown = label or message
     try:
-        response = _run_agent(message, session_id, model, agent_code)
+        response = _run_agent(message, session_id, model, agent_code, label)
         log.info("Agent response for %s (%d chars): %s",
                  task_id, len(response), response)
         runs_db.record_run(skill_name, "issue", session_id, "succeeded",
-                           started_at=started_at, message=message,
+                           started_at=started_at, message=shown,
                            main_context=context)
     except Exception as exc:
         # Over-limit / transient failure: leave the task in its current
@@ -311,14 +322,14 @@ def _run_task(task_id: str, message: str, session_id: str, skill_name: str,
         log.debug("%s failed with:\n%s", task_id, traceback.format_exc())
         runs_db.record_run(skill_name, "issue", session_id, "failed",
                            error=str(exc)[:500], started_at=started_at,
-                           message=message, main_context=context)
+                           message=shown, main_context=context)
     finally:
         with _inflight_lock:
             _inflight.discard(task_id)
 
 
 def _submit_task(task_id: str, message: str, session_id: str, skill_name: str,
-                 model: str = "", agent_code: str = "") -> bool:
+                 model: str = "", agent_code: str = "", label: str = "") -> bool:
     """Start a task's agent unless one is already in flight or we're at the cap.
 
     Returns True if launched, False if skipped — as a duplicate, or because
@@ -342,7 +353,7 @@ def _submit_task(task_id: str, message: str, session_id: str, skill_name: str,
     # killing it mid-run, which is what the thread pool used to give us.
     threading.Thread(target=_run_task, name=f"task-agent-{task_id}",
                      args=(task_id, message, session_id, skill_name, model,
-                           agent_code)).start()
+                           agent_code, label)).start()
     log.info("Started an agent for %s (%d running, max %d).",
              task_id, depth, limit)
     return True
@@ -424,13 +435,19 @@ def run_once() -> None:
             log.debug("No issue trigger matches %s (%s, %s); skipping",
                       task_id, status, issue_type)
             continue
-        message = f"/{skill.slug} {task_id}"
+        # How a skill is invoked is the agent's business: Claude Code resolves
+        # the slash command out of `.claude/skills`, Copilot has to be pointed
+        # at the file. The command stays the label either way, so one issue run
+        # reads the same on the dashboard whichever agent picked it up.
+        label = f"/{skill.slug} {task_id}"
+        message = _agent_for_skill(skill.agent).skill_prompt(
+            skill.slug, skill.path, task_id, skill.argument_name)
 
         log.info("Processing %s (%s, %s): %s  session-id=%s",
                  task_id, status, issue_type, summary, session_id)
 
         _submit_task(task_id, message, session_id, skill.name,
-                     skill.model, skill.agent)
+                     skill.model, skill.agent, label)
 
 
 def main() -> None:

{codee_agent-0.6.0 → codee_agent-0.6.1}/src/codee/lib/test_trigger_issue_skills.py

@@ -19,6 +19,27 @@ class IssueTriggeredSkillsTest(unittest.TestCase):
         directory.mkdir()
         (directory / "SKILL.md").write_text(f"---\n{frontmatter}---\nBody\n")
 
+    def test_reads_the_argument_name_out_of_the_argument_hint(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            common = ("disable-model-invocation: true\nx-codee-trigger: issue\n"
+                      "x-codee-issue-status: [Ready]\nx-codee-issue-type: story\n")
+            self._skill(root, "bracketed",
+                        common + "argument-hint: <STORY_ID>\n")
+            self._skill(root, "bare", common + "argument-hint: STORY_ID\n")
+            self._skill(root, "several",
+                        common + "argument-hint: <TASK_ID> [continue]\n")
+            self._skill(root, "none", common)
+
+            names = {skill.slug: skill.argument_name
+                     for skill in find_issue_triggered_skills(root)}
+
+            self.assertEqual(names["bracketed"], "STORY_ID")
+            self.assertEqual(names["bare"], "STORY_ID")
+            # Only the first argument is passed; optional extras are dropped.
+            self.assertEqual(names["several"], "TASK_ID")
+            self.assertEqual(names["none"], "")
+
     def test_reads_the_model_frontmatter_when_present(self) -> None:
         with tempfile.TemporaryDirectory() as temporary_directory:
             root = Path(temporary_directory)

{codee_agent-0.6.0 → codee_agent-0.6.1}/src/codee/lib/trigger_issue_skills.py

@@ -34,6 +34,10 @@ class IssueTriggeredSkill:
     # The agent this skill asks to be run by (``x-codee-agent``), empty when it
     # names none and the default agent from Settings should drive it.
     agent: str = ""
+    # What the skill calls the value it's invoked with (``argument-hint:
+    # <STORY_ID>``), empty when it names none. Agents that spell the invocation
+    # out instead of sending a slash command label the task id with it.
+    argument_name: str = ""
 
 
 def find_issue_triggered_skills(
@@ -91,6 +95,7 @@ def find_issue_triggered_skills(
             issue_type=issue_type,
             model=str(metadata.get("model", "")).strip(),
             agent=str(metadata.get("x-codee-agent", "") or "").strip(),
+            argument_name=_argument_name(metadata.get("argument-hint")),
         ))
     return skills
 
@@ -124,6 +129,18 @@ def _parse_frontmatter(contents: str) -> dict[str, Any]:
     return parsed if isinstance(parsed, dict) else {}
 
 
+def _argument_name(value: Any) -> str:
+    """The name a skill's ``argument-hint`` gives its first argument.
+
+    ``<STORY_ID>`` names ``STORY_ID`` and ``<TASK_ID> [continue]`` names
+    ``TASK_ID``: an issue trigger passes exactly one value, and that value is
+    the first the hint describes. Anything optional behind it is the skill's
+    own business and never reaches the invocation.
+    """
+    words = str(value or "").strip().split()
+    return words[0].strip("<>[]").strip() if words else ""
+
+
 def _status_values(value: Any) -> tuple[str, ...]:
     values = value if isinstance(value, list) else [value]
     return tuple(

{codee_agent-0.6.0 → codee_agent-0.6.1}/src/codee/test_executor.py

@@ -4,6 +4,7 @@ import unittest
 from pathlib import Path
 from unittest.mock import Mock, patch
 
+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_main_context.context import (
@@ -186,6 +187,33 @@ class AgentForSkillTest(unittest.TestCase):
                       executor.coding_agent)
 
 
+class SkillPromptTest(unittest.TestCase):
+    """The invocation a skill gets is phrased by the agent that will run it."""
+
+    SKILL = Path("/repo/.claude/skills/story-code-reviewer/SKILL.md")
+
+    def test_claude_code_gets_the_slash_command(self) -> None:
+        agent = ClaudeCodeAgent(Settings(), Path("/repo"))
+
+        self.assertEqual(
+            agent.skill_prompt("story-code-reviewer", self.SKILL, "90939",
+                               "STORY_ID"),
+            "/story-code-reviewer 90939",
+        )
+
+    def test_copilot_gets_told_to_read_the_skill_file(self) -> None:
+        # `copilot` resolves no slash command and the skill hides itself with
+        # disable-model-invocation, so the path has to be spelled out.
+        agent = GitHubCopilotAgent(Settings(), Path("/repo"))
+
+        self.assertEqual(
+            agent.skill_prompt("story-code-reviewer", self.SKILL, "90939",
+                               "STORY_ID"),
+            "Read .claude/skills/story-code-reviewer/SKILL.md and follow its "
+            "instructions exactly. STORY_ID = 90939",
+        )
+
+
 class RunAgentSelectionTest(unittest.TestCase):
     """The agent a run lands on is the one the triggering skill asked for."""
 
@@ -258,6 +286,48 @@ class RunTaskLoggingTest(unittest.TestCase):
             self.assertEqual(executor._run_agent("/story-developer NIM-4", "sid-4"),
                              "done")
 
+    def test_the_run_log_shows_the_command_not_the_agents_wording(self) -> None:
+        # A Copilot run is prompted with the skill's file path, but the run log
+        # is still the slash command, so both agents' runs read the same.
+        prompt = ("Read .claude/skills/story-developer/SKILL.md and follow its "
+                  "instructions exactly. STORY_ID = 4124")
+
+        with patch.object(executor, "_run_agent", return_value="done") as run:
+            executor._run_task("NIM-5", prompt, "sid-5", "story-developer",
+                               label="/story-developer 4124")
+
+        run_record, = self._runs()
+        self.assertEqual(run_record["message"], "/story-developer 4124")
+        # The agent still gets the wording it can act on.
+        self.assertEqual(run.call_args.args[0], prompt)
+
+    def test_a_failed_run_is_logged_under_the_command_too(self) -> None:
+        with patch.object(executor, "_run_agent", side_effect=RuntimeError("boom")):
+            executor._run_task("NIM-6", "Read .claude/skills/x/SKILL.md ...",
+                               "sid-6", "story-developer",
+                               label="/story-developer 4124")
+
+        run_record, = self._runs()
+        self.assertEqual(run_record["message"], "/story-developer 4124")
+
+    def test_the_live_job_row_carries_the_command(self) -> None:
+        with patch.object(executor.coding_agent, "run", return_value="done"), \
+                patch.object(runs_db, "start_job",
+                             return_value="job-1") as started:
+            executor._run_agent("Read .claude/skills/x/SKILL.md ...", "sid-7",
+                                label="/story-developer 4124")
+
+        self.assertEqual(started.call_args.args[1], "/story-developer 4124")
+
+    def test_a_run_with_no_label_is_shown_as_its_prompt(self) -> None:
+        # Cron, email and SQS hand over a skill body and have no command to show.
+        with patch.object(executor, "_run_agent", return_value="done"):
+            executor._run_task("NIM-7", "Do the nightly sweep", "sid-8",
+                               "nightly")
+
+        run_record, = self._runs()
+        self.assertEqual(run_record["message"], "Do the nightly sweep")
+
     def test_counts_include_issue_runs(self) -> None:
         with patch.object(executor, "_run_agent", return_value="done"):
             executor._run_task("NIM-3", "/story-developer NIM-3",

{codee_agent-0.6.0 → codee_agent-0.6.1}/src/codee_agent_abstract/provider.py

@@ -69,6 +69,21 @@ class AbstractCodingAgent(ABC):
         """
         ...
 
+    def skill_prompt(self, slug: str, path: Path, argument: str = "",
+                     argument_name: str = "") -> str:
+        """The message that makes this agent run the skill stored at ``path``.
+
+        The default is the slash command Claude Code resolves out of
+        ``.claude/skills``. Agents that don't read those skills — every
+        issue-triggered one carries ``disable-model-invocation: true``, so they
+        won't find it on their own either — override this and name the file.
+
+        ``argument`` is the single value the trigger passes (a task id) and
+        ``argument_name`` is what the skill's ``argument-hint`` calls it, empty
+        when it names none.
+        """
+        return f"/{slug} {argument}".strip()
+
     @classmethod
     def best_model(cls) -> str:
         """The id to pass for "the most capable model", for callers with no skill.

{codee_agent-0.6.0 → codee_agent-0.6.1}/src/codee_agent_github_copilot/provider.py

@@ -35,6 +35,10 @@ DEFAULT_MAX_AI_CREDITS = 1000
 # than a misconfigured cap, so a smaller override is raised to it instead.
 MIN_AI_CREDITS = 30
 
+# What to call the value an issue trigger passes when the skill's frontmatter
+# carries no ``argument-hint`` to name it.
+DEFAULT_ARGUMENT_NAME = "ARGUMENT"
+
 
 def _max_ai_credits() -> str:
     """The per-run credit cap, read fresh so a changed env applies to the next run."""
@@ -67,6 +71,22 @@ class GitHubCopilotAgent(AbstractCodingAgent):
     def best_model(cls) -> str:
         return cls.BEST_MODEL
 
+    def skill_prompt(self, slug: str, path: Path, argument: str = "",
+                     argument_name: str = "") -> str:
+        """Point copilot at the skill file instead of sending a slash command.
+
+        `copilot` has no slash command for `.claude/skills`, and every
+        issue-triggered skill sets ``disable-model-invocation: true``, so it
+        won't pick the skill up on its own either. Naming the file and telling
+        it to follow what's inside is the only way in. The path is relative to
+        the working directory the run gets, which is where the CLI starts.
+        """
+        prompt = (f"Read {_relative(path, self._cwd)} and follow its "
+                  "instructions exactly.")
+        if argument:
+            prompt += f" {argument_name or DEFAULT_ARGUMENT_NAME} = {argument}"
+        return prompt
+
     @classmethod
     def list_models(cls) -> list[AgentModel]:
         try:
@@ -149,6 +169,14 @@ class GitHubCopilotAgent(AbstractCodingAgent):
         return reply
 
 
+def _relative(path: Path, cwd: Path) -> str:
+    """``path`` as the CLI will see it from ``cwd``, or absolute if it's outside."""
+    try:
+        return str(path.relative_to(cwd))
+    except ValueError:
+        return str(path)
+
+
 def _fetch_acp_models() -> list[AgentModel]:
     """Ask ``copilot --acp`` for the account's model catalog.
 

{codee_agent-0.6.0 → codee_agent-0.6.1}/src/codee_agent_github_copilot/test.py

@@ -29,6 +29,51 @@ def _completed(stdout: str = "", stderr: str = "", returncode: int = 0):
         args=["copilot"], returncode=returncode, stdout=stdout, stderr=stderr)
 
 
+class CopilotSkillPromptTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.agent = GitHubCopilotAgent(Settings(), Path("/repo"))
+
+    def _prompt(self, path: Path, argument: str = "", argument_name: str = "") -> str:
+        return self.agent.skill_prompt("story-code-reviewer", path, argument,
+                                       argument_name)
+
+    def test_names_the_skill_file_instead_of_a_slash_command(self) -> None:
+        prompt = self._prompt(
+            Path("/repo/.claude/skills/story-code-reviewer/SKILL.md"),
+            "90939", "STORY_ID")
+
+        self.assertEqual(
+            prompt,
+            "Read .claude/skills/story-code-reviewer/SKILL.md and follow its "
+            "instructions exactly. STORY_ID = 90939",
+        )
+
+    def test_a_skill_that_names_no_argument_gets_a_generic_label(self) -> None:
+        prompt = self._prompt(
+            Path("/repo/.claude/skills/story-code-reviewer/SKILL.md"), "90939")
+
+        self.assertTrue(prompt.endswith("ARGUMENT = 90939"), prompt)
+
+    def test_no_argument_leaves_the_instruction_alone(self) -> None:
+        prompt = self._prompt(
+            Path("/repo/.claude/skills/story-code-reviewer/SKILL.md"))
+
+        self.assertEqual(
+            prompt,
+            "Read .claude/skills/story-code-reviewer/SKILL.md and follow its "
+            "instructions exactly.",
+        )
+
+    def test_a_skill_outside_the_working_directory_keeps_its_full_path(self) -> None:
+        prompt = self._prompt(Path("/elsewhere/skills/reviewer/SKILL.md"), "7", "ID")
+
+        self.assertEqual(
+            prompt,
+            "Read /elsewhere/skills/reviewer/SKILL.md and follow its "
+            "instructions exactly. ID = 7",
+        )
+
+
 class CopilotRunTest(unittest.TestCase):
     def setUp(self) -> None:
         self.agent = GitHubCopilotAgent(Settings(), Path("/repo"))