codee-agent 0.1.0__py3-none-any.whl

codee/test_executor.py

@@ -0,0 +1,190 @@
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from codee_agent_github_copilot.provider import GitHubCopilotAgent
+from codee_main_context.context import (
+    CodingAgent, Settings, TasksProvider, save_settings)
+from codee_tasks_azure_devops.provider import AzureDevOpsTasksProvider
+from codee_tasks_jira.provider import JiraTasksProvider
+
+from codee import executor
+from codee.lib import runs_db
+
+
+class RefreshConfigTest(unittest.TestCase):
+    """The executor re-reads settings.json each poll, so edits need no restart."""
+
+    def setUp(self) -> None:
+        self._temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(self._temporary.cleanup)
+        self.data_dir = Path(self._temporary.name)
+        # The Azure DevOps provider resolves its token store from the ambient
+        # data dir at construction, so point that at the temp dir too.
+        environment = patch.dict(os.environ,
+                                 {"CODEE_DATA_DIR": str(self.data_dir)})
+        environment.start()
+        self.addCleanup(environment.stop)
+
+        original_data_dir = executor.context.data_dir
+        original_settings = executor.context.settings
+        original_provider = executor.tasks_provider
+        original_agent = executor.coding_agent
+
+        def restore() -> None:
+            executor.context.data_dir = original_data_dir
+            executor.context.settings = original_settings
+            executor.tasks_provider = original_provider
+            executor.coding_agent = original_agent
+
+        self.addCleanup(restore)
+
+        executor.context.data_dir = self.data_dir
+        executor.context.settings = Settings()
+        executor.tasks_provider = executor._build_tasks_provider(Settings())
+
+    def _save(self, **overrides) -> Settings:
+        settings = Settings(**overrides)
+        save_settings(self.data_dir, settings)
+        return settings
+
+    def test_switching_provider_rebuilds_it(self) -> None:
+        self._save(
+            tasks_provider=TasksProvider.AZURE_DEVOPS,
+            credentials={TasksProvider.AZURE_DEVOPS.value: {
+                "organization_url": "https://dev.azure.com/acme",
+                "project": "Core",
+                "tenant_id": "tenant-1",
+                "client_id": "client-1",
+                "client_secret": "secret-1",
+            }},
+        )
+
+        executor._refresh_config()
+
+        self.assertIsInstance(executor.tasks_provider, AzureDevOpsTasksProvider)
+        self.assertEqual(executor.context.settings.tasks_provider,
+                         TasksProvider.AZURE_DEVOPS)
+
+    def test_new_credentials_reach_the_provider(self) -> None:
+        self._save(credentials={TasksProvider.JIRA.value: {
+            "base_url": "https://acme.atlassian.net",
+            "account_email": "bot@acme.test",
+            "api_token": "rotated-token",
+            "project": "NIM",
+        }})
+
+        executor._refresh_config()
+
+        provider = executor.tasks_provider
+        self.assertIsInstance(provider, JiraTasksProvider)
+        self.assertTrue(provider.is_configured())
+        self.assertIn("NIM", provider.describe())
+
+    def test_unchanged_settings_keep_the_live_provider(self) -> None:
+        self._save()
+        executor._refresh_config()
+        provider = executor.tasks_provider
+
+        executor._refresh_config()
+
+        self.assertIs(executor.tasks_provider, provider)
+
+    def test_broken_provider_settings_keep_polling_with_the_old_one(self) -> None:
+        self._save(credentials={TasksProvider.JIRA.value: {
+            "base_url": "https://acme.atlassian.net",
+            "account_email": "bot@acme.test",
+            "api_token": "token",
+            "project": "NIM",
+        }})
+        executor._refresh_config()
+        provider = executor.tasks_provider
+
+        self._save(
+            tasks_provider=TasksProvider.AZURE_DEVOPS,
+            credentials={TasksProvider.AZURE_DEVOPS.value: {"project": "Core"}},
+        )
+        with patch.dict(executor._TASKS_PROVIDERS,
+                        {TasksProvider.AZURE_DEVOPS: _Exploding}):
+            executor._refresh_config()
+
+        self.assertIs(executor.tasks_provider, provider)
+
+    def test_switching_coding_agent_rebuilds_it(self) -> None:
+        self._save(coding_agent=CodingAgent.CLAUDE_CODE)
+        executor._refresh_config()
+
+        self._save(coding_agent=CodingAgent.GITHUB_COPILOT)
+        executor._refresh_config()
+
+        self.assertIsInstance(executor.coding_agent, GitHubCopilotAgent)
+        self.assertEqual(executor.context.settings.coding_agent,
+                         CodingAgent.GITHUB_COPILOT)
+
+    def test_broken_coding_agent_settings_keep_polling_with_the_old_one(self) -> None:
+        self._save(coding_agent=CodingAgent.CLAUDE_CODE)
+        executor._refresh_config()
+        agent = executor.coding_agent
+
+        # An agent that can't be built must not take down the poll loop.
+        self._save(coding_agent=CodingAgent.GITHUB_COPILOT)
+        with patch.dict(executor._CODING_AGENTS,
+                        {CodingAgent.GITHUB_COPILOT: _Exploding}):
+            executor._refresh_config()
+
+        self.assertIs(executor.coding_agent, agent)
+
+
+class RunTaskLoggingTest(unittest.TestCase):
+    """Issue-triggered coding runs land in the runs table like the other triggers."""
+
+    def setUp(self) -> None:
+        self._temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(self._temporary.cleanup)
+        original_data_dir = executor.context.data_dir
+        self.addCleanup(
+            lambda: setattr(executor.context, "data_dir", original_data_dir))
+        executor.context.data_dir = Path(self._temporary.name)
+
+    def _runs(self) -> list[dict]:
+        return runs_db.recent_runs(main_context=executor.context)
+
+    def test_successful_run_is_recorded(self) -> None:
+        with patch.object(executor, "_run_agent", return_value="done"):
+            executor._run_task("NIM-1", "/story-developer NIM-1",
+                               "sid-1", "story-developer")
+
+        run, = self._runs()
+        self.assertEqual(run["skill_name"], "story-developer")
+        self.assertEqual(run["trigger_type"], "issue")
+        self.assertEqual(run["status"], "succeeded")
+        self.assertEqual(run["session_id"], "sid-1")
+        self.assertEqual(run["message"], "/story-developer NIM-1")
+
+    def test_failed_run_is_recorded_with_the_error(self) -> None:
+        with patch.object(executor, "_run_agent", side_effect=RuntimeError("over limit")):
+            executor._run_task("NIM-2", "/story-developer NIM-2",
+                               "sid-2", "story-developer")
+
+        run, = self._runs()
+        self.assertEqual(run["status"], "failed")
+        self.assertIn("over limit", run["error"])
+
+    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",
+                               "sid-3", "story-developer")
+
+        counts = runs_db.counts(executor.context)
+        self.assertEqual(counts, {"total": 1, "last_24h": 1})
+
+
+class _Exploding:
+    def __init__(self, *args, **kwargs):
+        raise RuntimeError("bad credentials")
+
+
+if __name__ == "__main__":
+    unittest.main()

codee/test_init_cli.py

@@ -0,0 +1,131 @@
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+import yaml
+
+from codee.init_cli import main
+
+
+class InitCliTest(unittest.TestCase):
+    def test_copies_packaged_templates_to_current_directory(self) -> None:
+        original_directory = Path.cwd()
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            os.chdir(temporary_directory)
+            try:
+                self.assertEqual(main(), 0)
+                self.assertTrue(Path("AGENTS.md").is_file())
+                self.assertEqual(Path("CLAUDE.md").read_text(), "@AGENTS.md")
+                self.assertTrue(
+                    Path(".claude/skills/story-planner/SKILL.md").is_file())
+                self.assertTrue(
+                    Path(
+                        ".claude/skills/story-planner/assets/readme-template.md").is_file()
+                )
+            finally:
+                os.chdir(original_directory)
+
+    def test_copied_issue_skills_have_one_allowed_issue_type(self) -> None:
+        original_directory = Path.cwd()
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            os.chdir(temporary_directory)
+            try:
+                self.assertEqual(main(), 0)
+                issue_skills = 0
+                for path in Path(".claude/skills").glob("*/SKILL.md"):
+                    parts = path.read_text().split("---", 2)
+                    frontmatter = yaml.safe_load(parts[1]) or {}
+                    if frontmatter.get("x-codee-trigger") != "issue":
+                        continue
+                    issue_skills += 1
+                    self.assertIn(
+                        frontmatter.get("x-codee-issue-type"),
+                        {"story", "task"},
+                        path,
+                    )
+                self.assertGreater(issue_skills, 0)
+            finally:
+                os.chdir(original_directory)
+
+    def test_creates_working_directories_and_ignores_them(self) -> None:
+        original_directory = Path.cwd()
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            os.chdir(temporary_directory)
+            try:
+                self.assertEqual(main(), 0)
+                self.assertTrue(Path("repositories").is_dir())
+                self.assertTrue(Path("temp").is_dir())
+                self.assertTrue(Path("memory").is_dir())
+                # memory/ stays tracked: the admin UI commits memory edits.
+                self.assertEqual(
+                    Path(".gitignore").read_text(), "/repositories\n/temp\n")
+            finally:
+                os.chdir(original_directory)
+
+    def test_appends_only_missing_gitignore_entries(self) -> None:
+        original_directory = Path.cwd()
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            os.chdir(temporary_directory)
+            try:
+                # No trailing newline, and `repositories` in an equivalent form.
+                Path(".gitignore").write_text("*.log\nrepositories/")
+                self.assertEqual(main(), 0)
+                self.assertEqual(
+                    Path(".gitignore").read_text(),
+                    "*.log\nrepositories/\n/temp\n",
+                )
+            finally:
+                os.chdir(original_directory)
+
+    def test_leaves_gitignore_untouched_when_already_covered(self) -> None:
+        original_directory = Path.cwd()
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            os.chdir(temporary_directory)
+            try:
+                Path(".gitignore").write_text("/repositories\n/temp\n")
+                self.assertEqual(main(), 0)
+                self.assertEqual(
+                    Path(".gitignore").read_text(), "/repositories\n/temp\n")
+            finally:
+                os.chdir(original_directory)
+
+    def test_declining_prompt_leaves_existing_files_unchanged(self) -> None:
+        original_directory = Path.cwd()
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            os.chdir(temporary_directory)
+            try:
+                Path("AGENTS.md").write_text("custom")
+                with patch("builtins.input", return_value="no") as prompt:
+                    self.assertEqual(main(), 1)
+                self.assertEqual(Path("AGENTS.md").read_text(), "custom")
+                self.assertFalse(Path("CLAUDE.md").exists())
+                self.assertFalse(Path("repositories").exists())
+                self.assertFalse(Path(".gitignore").exists())
+                prompt.assert_called_once()
+            finally:
+                os.chdir(original_directory)
+
+    def test_confirming_prompt_updates_templates_and_preserves_claude_settings(self) -> None:
+        original_directory = Path.cwd()
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            os.chdir(temporary_directory)
+            try:
+                Path(".claude").mkdir()
+                Path(".claude/settings.json").write_text("custom")
+                Path("AGENTS.md").write_text("old")
+                with patch("builtins.input", return_value="yes") as prompt:
+                    self.assertEqual(main(), 0)
+                self.assertNotEqual(Path("AGENTS.md").read_text(), "old")
+                self.assertEqual(
+                    Path(".claude/settings.json").read_text(), "custom")
+                self.assertTrue(
+                    Path(".claude/skills/task-qa/SKILL.md").is_file())
+                prompt.assert_called_once()
+            finally:
+                os.chdir(original_directory)
+
+
+if __name__ == "__main__":
+    unittest.main()

codee/test_memory_index.py

@@ -0,0 +1,31 @@
+"""Unit tests for the MEMORY.md line parser."""
+from codee.admin_service import parse_index
+
+
+def test_wellformed_line():
+    [e] = parse_index("- [My Title](my_file.md) — short hook")
+    assert e["matched"]
+    assert e["title"] == "My Title"
+    assert e["file"] == "my_file.md"
+    assert e["hook"] == "short hook"
+    assert e["lineno"] == 0
+
+
+def test_line_without_hook():
+    [e] = parse_index("- [No Hook](nohook.md)")
+    assert e["matched"]
+    assert e["file"] == "nohook.md"
+    assert e["hook"] == ""
+
+
+def test_non_matching_line_preserved():
+    [e] = parse_index("## Some heading, not an entry")
+    assert e["matched"] is False
+    assert e["raw"] == "## Some heading, not an entry"
+
+
+if __name__ == "__main__":
+    test_wellformed_line()
+    test_line_without_hook()
+    test_non_matching_line_preserved()
+    print("ok")

codee/test_start_cli.py

@@ -0,0 +1,164 @@
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import Mock, call, patch
+
+from codee_main_context.logging import DEBUG_ENV_VAR
+
+from codee.start_cli import _ensure_initialized, main
+
+
+class StartCliTest(unittest.TestCase):
+    @patch("codee.start_cli.init_main")
+    def test_initializes_empty_current_directory(self, init_main: Mock) -> None:
+        original_directory = Path.cwd()
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            os.chdir(temporary_directory)
+            try:
+                _ensure_initialized()
+            finally:
+                os.chdir(original_directory)
+
+        init_main.assert_called_once_with()
+
+    @patch("codee.start_cli.init_main")
+    def test_skips_initialization_when_target_exists(self, init_main: Mock) -> None:
+        original_directory = Path.cwd()
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            os.chdir(temporary_directory)
+            try:
+                Path(".claude").mkdir()
+                with self.assertLogs("codee.start_cli", level="INFO") as logs:
+                    _ensure_initialized()
+            finally:
+                os.chdir(original_directory)
+
+        init_main.assert_not_called()
+        self.assertEqual(
+            logs.output,
+            ["INFO:codee.start_cli:Codee is already initialized; skipping codee-init"],
+        )
+
+    @patch("codee.start_cli.init_main")
+    def test_creates_working_directories_when_initialization_is_skipped(
+        self, init_main: Mock
+    ) -> None:
+        original_directory = Path.cwd()
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            os.chdir(temporary_directory)
+            try:
+                Path(".claude").mkdir()
+                with self.assertLogs("codee.start_cli", level="INFO"):
+                    _ensure_initialized()
+                self.assertTrue(Path("repositories").is_dir())
+                self.assertTrue(Path("temp").is_dir())
+                self.assertTrue(Path("memory").is_dir())
+                self.assertEqual(
+                    Path(".gitignore").read_text(), "/repositories\n/temp\n")
+            finally:
+                os.chdir(original_directory)
+
+        init_main.assert_not_called()
+
+    @patch("codee.start_cli._ensure_initialized")
+    @patch("codee.start_cli.subprocess.Popen")
+    def test_starts_both_services_and_stops_survivor(
+        self, popen: Mock, ensure_initialized: Mock
+    ) -> None:
+        executor = Mock()
+        executor.poll.return_value = 0
+        admin = Mock()
+        admin.poll.return_value = None
+        popen.side_effect = [executor, admin]
+
+        with patch.object(sys, "argv", ["codee-start", "--server.port", "8502"]):
+            self.assertEqual(main(), 0)
+
+        self.assertEqual(
+            popen.call_args_list,
+            [
+                call([sys.executable, "-m", "codee.executor"]),
+                call(
+                    [
+                        sys.executable,
+                        "-m",
+                        "codee.admin_cli",
+                        "--server.port",
+                        "8502",
+                    ]
+                ),
+            ],
+        )
+        executor.terminate.assert_not_called()
+        admin.terminate.assert_called_once_with()
+        admin.wait.assert_called_once_with(timeout=5)
+        ensure_initialized.assert_called_once_with()
+
+    @patch("codee.start_cli._ensure_initialized")
+    @patch("codee.start_cli.subprocess.Popen")
+    def test_debug_flag_is_exported_and_not_forwarded(
+        self, popen: Mock, ensure_initialized: Mock
+    ) -> None:
+        executor = Mock()
+        executor.poll.return_value = 0
+        admin = Mock()
+        admin.poll.return_value = None
+        popen.side_effect = [executor, admin]
+
+        with patch.dict(os.environ, {}, clear=False):
+            os.environ.pop(DEBUG_ENV_VAR, None)
+            with patch.object(sys, "argv", ["codee-start", "--debug", "--port", "8502"]):
+                self.assertEqual(main(), 0)
+            # Subprocesses inherit the environment, so this is what turns debug
+            # on in the executor and the admin UI.
+            self.assertEqual(os.environ[DEBUG_ENV_VAR], "1")
+
+        self.assertEqual(
+            popen.call_args_list[1],
+            call([sys.executable, "-m", "codee.admin_cli", "--port", "8502"]),
+        )
+
+    @patch("codee.start_cli._ensure_initialized")
+    @patch("codee.start_cli.time.sleep", side_effect=KeyboardInterrupt)
+    @patch("codee.start_cli.subprocess.Popen")
+    def test_ctrl_c_stops_both_services(
+        self, popen: Mock, sleep: Mock, ensure_initialized: Mock
+    ) -> None:
+        executor = Mock()
+        executor.poll.return_value = None
+        admin = Mock()
+        admin.poll.return_value = None
+        popen.side_effect = [executor, admin]
+
+        with patch.object(sys, "argv", ["codee-start"]):
+            self.assertEqual(main(), 130)
+
+        executor.terminate.assert_called_once_with()
+        admin.terminate.assert_called_once_with()
+        ensure_initialized.assert_called_once_with()
+
+    @patch("codee.start_cli._ensure_initialized")
+    @patch("codee.start_cli.subprocess.Popen")
+    def test_kills_service_that_does_not_stop(
+        self, popen: Mock, ensure_initialized: Mock
+    ) -> None:
+        executor = Mock()
+        executor.poll.return_value = 1
+        admin = Mock()
+        admin.poll.return_value = None
+        admin.wait.side_effect = [subprocess.TimeoutExpired("admin", 5), 0]
+        popen.side_effect = [executor, admin]
+
+        with patch.object(sys, "argv", ["codee-start"]):
+            self.assertEqual(main(), 1)
+
+        admin.kill.assert_called_once_with()
+        self.assertEqual(admin.wait.call_args_list, [call(timeout=5), call()])
+        ensure_initialized.assert_called_once_with()
+
+
+if __name__ == "__main__":
+    unittest.main()

codee/workflow_graph.py

@@ -0,0 +1,83 @@
+"""Reflex wrappers for the React Flow workflow graph."""
+from typing import Any
+
+import reflex as rx
+from reflex_base.components.component import Component, NoSSRComponent, field
+from reflex_base.event import EventHandler, no_args_event_spec
+from reflex_base.vars.base import Var
+
+REACT_FLOW_LIBRARY = "@xyflow/react@12.9.3"
+
+
+def _edge_click_signature(
+    event: Var, edge: Var
+) -> tuple[Var[list[str]], Var[float], Var[float]]:
+    """Pass the clicked edge's skills and the viewport click position."""
+    return (
+        Var(_js_expr=f"({edge}?.data?.skills ?? [])"),
+        Var(_js_expr=f"{event}.clientX"),
+        Var(_js_expr=f"{event}.clientY"),
+    )
+
+
+class ReactFlow(NoSSRComponent):
+    library = REACT_FLOW_LIBRARY
+    tag = "ReactFlow"
+
+    nodes: Var[list[dict[str, Any]]] = field()
+    edges: Var[list[dict[str, Any]]] = field()
+    fit_view: Var[bool] = field()
+    fit_view_options: Var[dict[str, Any]] = field()
+    nodes_draggable: Var[bool] = field()
+    nodes_connectable: Var[bool] = field()
+    elements_selectable: Var[bool] = field()
+    min_zoom: Var[float] = field()
+    max_zoom: Var[float] = field()
+    pro_options: Var[dict[str, Any]] = field()
+
+    on_edge_click: EventHandler[_edge_click_signature] = field()
+    on_pane_click: EventHandler[no_args_event_spec] = field()
+
+    def add_imports(self) -> dict[str, str]:
+        return {"": "@xyflow/react/dist/style.css"}
+
+
+class Background(Component):
+    library = REACT_FLOW_LIBRARY
+    tag = "Background"
+
+    gap: Var[int] = field()
+    size: Var[int] = field()
+    color: Var[str] = field()
+
+
+def workflow_graph(
+    nodes: list[dict[str, Any]] | Var,
+    edges: list[dict[str, Any]] | Var,
+    on_edge_click: Any = None,
+    on_pane_click: Any = None,
+) -> rx.Component:
+    return rx.box(
+        ReactFlow.create(
+            Background.create(gap=20, size=1, color="var(--codee-grid)"),
+            nodes=nodes,
+            edges=edges,
+            on_edge_click=on_edge_click,
+            on_pane_click=on_pane_click,
+            fit_view=True,
+            fit_view_options={"padding": 0.25},
+            nodes_draggable=False,
+            nodes_connectable=False,
+            elements_selectable=True,
+            min_zoom=0.25,
+            max_zoom=1.75,
+            pro_options={"hideAttribution": True},
+            width="100%",
+            height="100%",
+        ),
+        height="560px",
+        min_height="28rem",
+        background="var(--codee-surface)",
+        border="1px solid var(--codee-border)",
+        width="100%",
+    )

codee_admin/__init__.py

@@ -0,0 +1 @@
+"""Reflex entry package for the Codee admin UI."""

codee_admin/codee_admin.py

@@ -0,0 +1,4 @@
+"""Conventional Reflex application module."""
+from codee.admin import app
+
+__all__ = ["app"]

codee_agent-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: codee-agent
+Version: 0.1.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
+Author-email: Denis Kibalko <denis.kibalko@nimbusweb.me>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Bug Tracking
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Dist: boto3>=1.35,<2
+Requires-Dist: requests>=2.31,<3
+Requires-Dist: aiosmtpd>=1.4,<2
+Requires-Dist: pyyaml>=6.0.3,<7
+Requires-Dist: cron-descriptor>=2.1.0,<3
+Requires-Dist: python-dotenv>=1.2.2,<2
+Requires-Dist: reflex>=0.9.7
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/fusebase-dev/codee
+Project-URL: Repository, https://github.com/fusebase-dev/codee
+Project-URL: Issues, https://github.com/fusebase-dev/codee/issues
+Description-Content-Type: text/markdown
+
+# Codee - a virtual co-worker
+
+The goal of this project is to provide an assistant that will integrate into your existing environment in order to help you to solve tasks.
+
+Codee works with Jira and Azure DevOps as tasks provider, new providers are quite easy to create, PRs are welcome.
+
+As agents it current works with Claude Code and Github Copilot.
+
+## Run Codee
+
+Codee is a python package, you first need to install it.
+
+TODO: provide install instructions
+
+You need to create a separate repo for Codee where it will store skills, memory, temp files, config, etc.
+
+Run Codee:
+
+`uv run codee-start`
+
+On the first run, the command initializes Codee instructions and skills.
+
+## Debug mode
+
+```bash
+uv run codee-start --debug       # Codee debug output
+uv run codee-start --debug-all   # ...plus reflex, boto3, urllib3 and friends
+```
+
+### Skills
+
+Codee uses skills to perform tasks. It is the same skills which are used in Claude Code, Codex and other agents.
+
+
+TODO: add skill types, x-codee skills extension