chaotic-cli 1.0.0__py3-none-any.whl

chaotic_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: chaotic-cli
+Version: 1.0.0
+Summary: CLI for Chaotic issue tracking system
+Project-URL: Homepage, https://chaotic.sh
+Project-URL: Repository, https://github.com/thethirdbearsolutions/chaotic.sh
+Project-URL: Documentation, https://chaotic.sh/docs
+Author: Third Bear Solutions
+License-Expression: MIT
+Keywords: chaotic,cli,issue-tracker,project-management
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Bug Tracking
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.7
+Requires-Dist: httpx>=0.26.0
+Requires-Dist: rich>=13.7.0
+Provides-Extra: dev
+Requires-Dist: pytest-mock>=3.12.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Chaotic CLI
+
+Command-line interface for the Chaotic issue tracker.
+
+## Installation
+
+```bash
+cd cli
+pip install -e .
+```
+
+## Configuration
+
+Set the API URL (defaults to http://localhost:24267):
+```bash
+chaotic config set-url https://your-api-server.com
+```
+
+## Authentication
+
+### Sign up / Login
+```bash
+chaotic auth signup
+chaotic auth login
+```
+
+### API Keys (for scripts/automation)
+```bash
+chaotic auth keys list
+chaotic auth keys create
+chaotic auth keys revoke <key-id>
+chaotic auth set-key ck_your_api_key_here
+chaotic auth clear-key
+```
+
+### Check current user
+```bash
+chaotic auth whoami
+chaotic me                     # Shortcut for 'auth whoami'
+```
+
+## Status
+
+Check current context (user, team, project):
+```bash
+chaotic status
+```
+
+## Teams
+
+```bash
+chaotic team list              # List your teams
+chaotic team use <team-id>     # Set current team
+chaotic team show              # Show current team details
+chaotic team create            # Create a new team
+chaotic team members           # List team members
+chaotic team invite            # Invite a member
+chaotic team accept-invite     # Accept an invitation
+```
+
+## Projects
+
+```bash
+chaotic project list           # List projects in current team
+chaotic project use <project-id>  # Set current project
+chaotic project show           # Show current project details
+chaotic project create         # Create a new project
+chaotic project update         # Update current project
+```
+
+## Issues
+
+### Listing and viewing
+```bash
+chaotic issue list                        # List issues in current project
+chaotic issue list --status in_progress   # Filter by status
+chaotic issue list --priority high        # Filter by priority
+chaotic issue mine                        # List issues assigned to me
+chaotic issue mine --status in_progress   # Filter my issues by status
+chaotic issue search "search term"        # Search issues across the team
+chaotic issue show CHT-123                # Show issue details
+chaotic issue view CHT-123                # Alias for 'show'
+chaotic issue open CHT-123                # Open issue in browser
+```
+
+### Creating issues
+```bash
+chaotic issue create --title "Bug fix"
+chaotic issue create --title "Bug fix" --project CHT     # Specify project by key
+chaotic issue create --title "Sub-task" --parent CHT-123  # Create sub-issue
+chaotic issue create --title "Feature" --priority high --status todo
+```
+
+### Updating issues
+```bash
+chaotic issue update CHT-123 --status done
+chaotic issue update CHT-123 --priority urgent
+chaotic issue update CHT-123 --assignee user-id
+chaotic issue update CHT-123 --estimate 5
+chaotic issue move CHT-123 in_progress      # Quick status change
+chaotic issue assign CHT-123 me             # Assign to yourself
+chaotic issue assign CHT-123 agent-bot      # Assign to an agent by name/ID
+chaotic issue assign CHT-123                # Unassign
+```
+
+### Comments
+```bash
+chaotic issue comment CHT-123 "This is a comment"
+```
+
+### Sub-issues and Relations
+```bash
+chaotic issue sub-issues CHT-123           # List sub-issues
+chaotic issue relations CHT-123            # Show issue relations
+chaotic issue block CHT-1 CHT-2            # CHT-1 blocks CHT-2
+chaotic issue block CHT-1 CHT-2 --type duplicates  # Mark as duplicate
+chaotic issue block CHT-1 CHT-2 --type relates_to  # Related issues
+chaotic issue unblock CHT-1 CHT-2          # Remove relation
+```
+
+### Deleting
+```bash
+chaotic issue delete CHT-123
+```
+
+## Sprints
+
+```bash
+chaotic sprint list            # List sprints in current project
+chaotic sprint current         # Get or create the current sprint
+chaotic sprint close <id>      # Close the current sprint
+chaotic sprint delete <id>     # Delete a sprint
+```
+
+## Labels
+
+```bash
+chaotic label list             # List labels in current team
+chaotic label create           # Create a new label
+chaotic label delete <id>      # Delete a label
+```
+
+## Documents
+
+```bash
+chaotic doc list               # List documents in current team
+chaotic doc show <id>          # Show document content
+chaotic doc create             # Create a new document
+chaotic doc update <id>        # Update a document
+chaotic doc delete <id>        # Delete a document
+```
+
+## Status Values
+
+- `backlog` - Not yet planned
+- `todo` - Planned for work
+- `in_progress` - Currently being worked on
+- `in_review` - Awaiting review
+- `done` - Completed
+- `canceled` - Canceled
+
+## Priority Values
+
+- `no_priority` - No priority set
+- `low` - Low priority
+- `medium` - Medium priority
+- `high` - High priority
+- `urgent` - Urgent, needs immediate attention
+
+## Relation Types
+
+- `blocks` - Issue blocks another issue
+- `relates_to` - Issues are related
+- `duplicates` - Issue is a duplicate of another

chaotic_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+cli/__init__.py,sha256=aqZS0F5cTFRSdt3Hi0k5JhOXCA4-hBSAMxg3YPQbRDc,36
+cli/client.py,sha256=CKWQJkumD_UFn_eYMXXVJjjszQhXt-mw38z9pghm__A,18163
+cli/config.py,sha256=JNG0XpUV-XAacpRPNV3TeEADKcLcw_mRooVCaEys97E,15154
+cli/main.py,sha256=KmSyGRe5A9n4Hq2JazZ4fsRMD5SDSpNFyTxzzA-cyic,125022
+cli/system.py,sha256=8dzUTAxuru6KPi2VftAV_plnYWCLDPXvX2y40ea-DOw,37274
+chaotic_cli-1.0.0.dist-info/METADATA,sha256=HuGrZ1ZrF3-G_pH8eocfd4P2PuWAZc6f3huKt_8dhfA,5880
+chaotic_cli-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+chaotic_cli-1.0.0.dist-info/entry_points.txt,sha256=99B9jsPWPv3ajZ3oFUWf1RxH_U6pxaZTNsXuQ600mLk,41
+chaotic_cli-1.0.0.dist-info/RECORD,,

chaotic_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

chaotic_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chaotic = cli.main:cli

cli/__init__.py

@@ -0,0 +1,2 @@
+# Chaotic CLI
+__version__ = "1.0.0"

cli/client.py

@@ -0,0 +1,432 @@
+"""API client for CLI."""
+import httpx
+from urllib.parse import quote, urlencode
+from cli.config import get_api_url, get_token, get_api_key
+
+
+class APIError(Exception):
+    """API error with message."""
+    pass
+
+
+class Client:
+    """API client."""
+
+    def _headers(self) -> dict:
+        """Get request headers.
+
+        Reads config on each call to support profile switching.
+        """
+        headers = {"Content-Type": "application/json"}
+        # Prefer API key over JWT token
+        api_key = get_api_key()
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        else:
+            token = get_token()
+            if token:
+                headers["Authorization"] = f"Bearer {token}"
+        return headers
+
+    def _request(self, method: str, path: str, data: dict = None) -> dict | None:
+        """Make API request."""
+        url = f"{get_api_url()}{path}"
+        with httpx.Client() as client:
+            response = client.request(
+                method,
+                url,
+                headers=self._headers(),
+                json=data if data is not None else None,
+                timeout=30.0,
+            )
+
+            if response.status_code == 204:
+                return None
+
+            result = response.json()
+
+            if not response.is_success:
+                detail = result.get("detail", "Unknown error")
+                # Format structured errors into actionable messages
+                if isinstance(detail, dict):
+                    if "pending_rituals" in detail and "issue_id" in detail:
+                        # Ticket ritual error - show first pending ritual with its prompt
+                        issue_id = detail.get("issue_id", "")
+                        pending = detail.get("pending_rituals", [])
+
+                        if pending:
+                            first = pending[0]
+                            if isinstance(first, dict):
+                                name = first.get("name", "unknown")
+                                prompt = first.get("prompt", "")
+                                prompt_line = f"\n  {prompt}" if prompt else ""
+                                msg = f"Pending ritual: {name}{prompt_line}"
+                            else:
+                                # Fallback for old format (just names)
+                                name = first
+                                msg = f"Pending ritual: {name}"
+                            msg += f"\n\nAfter completing the ritual, run: chaotic ritual attest {name} --ticket {issue_id}"
+                        else:
+                            msg = "Ticket has pending rituals."
+
+                        raise APIError(msg)
+                    elif "pending_rituals" in detail:
+                        raise APIError("Sprint is in limbo. Run `chaotic ritual list` to continue.")
+                    elif "arrears_by" in detail:
+                        raise APIError("Sprint is in arrears. Run `chaotic sprint close` to continue.")
+                    else:
+                        raise APIError(detail.get("message", str(detail)))
+                raise APIError(detail)
+
+            return result
+
+    # Auth
+    def signup(self, name: str, email: str, password: str) -> dict:
+        return self._request("POST", "/auth/signup", {"name": name, "email": email, "password": password})
+
+    def login(self, email: str, password: str) -> dict:
+        return self._request("POST", "/auth/login", {"email": email, "password": password})
+
+    def get_me(self) -> dict:
+        return self._request("GET", "/auth/me")
+
+    # API keys
+    def list_api_keys(self) -> list:
+        return self._request("GET", "/api-keys")
+
+    def create_api_key(self, name: str) -> dict:
+        return self._request("POST", "/api-keys", {"name": name})
+
+    def revoke_api_key(self, api_key_id: str):
+        return self._request("DELETE", f"/api-keys/{api_key_id}")
+
+    # Teams
+    def create_team(self, name: str, key: str, description: str = None) -> dict:
+        data = {"name": name, "key": key}
+        if description:
+            data["description"] = description
+        return self._request("POST", "/teams", data)
+
+    def get_teams(self) -> list:
+        return self._request("GET", "/teams")
+
+    def get_team(self, team_id: str) -> dict:
+        return self._request("GET", f"/teams/{team_id}")
+
+    def update_team(self, team_id: str, **kwargs) -> dict:
+        return self._request("PATCH", f"/teams/{team_id}", kwargs)
+
+    def delete_team(self, team_id: str):
+        return self._request("DELETE", f"/teams/{team_id}")
+
+    # Team members
+    def get_team_members(self, team_id: str) -> list:
+        return self._request("GET", f"/teams/{team_id}/members")
+
+    def remove_member(self, team_id: str, user_id: str):
+        return self._request("DELETE", f"/teams/{team_id}/members/{user_id}")
+
+    # Invitations
+    def invite_member(self, team_id: str, email: str, role: str = "member") -> dict:
+        return self._request("POST", f"/teams/{team_id}/invitations", {"email": email, "role": role})
+
+    def get_invitations(self, team_id: str) -> list:
+        return self._request("GET", f"/teams/{team_id}/invitations")
+
+    def accept_invitation(self, token: str) -> dict:
+        return self._request("POST", f"/teams/invitations/{token}/accept")
+
+    def delete_invitation(self, team_id: str, invitation_id: str):
+        return self._request("DELETE", f"/teams/{team_id}/invitations/{invitation_id}")
+
+    # Projects
+    def create_project(self, team_id: str, name: str, key: str, **kwargs) -> dict:
+        data = {"name": name, "key": key, **kwargs}
+        return self._request("POST", f"/projects?team_id={team_id}", data)
+
+    def get_projects(self, team_id: str) -> list:
+        return self._request("GET", f"/projects?team_id={team_id}")
+
+    def get_project(self, project_id: str) -> dict:
+        return self._request("GET", f"/projects/{project_id}")
+
+    def update_project(self, project_id: str, **kwargs) -> dict:
+        return self._request("PATCH", f"/projects/{project_id}", kwargs)
+
+    def delete_project(self, project_id: str):
+        return self._request("DELETE", f"/projects/{project_id}")
+
+    # Issues
+    def create_issue(self, project_id: str, title: str, **kwargs) -> dict:
+        data = {"title": title, **kwargs}
+        return self._request("POST", f"/issues?project_id={project_id}", data)
+
+    def get_issues(self, project_id: str = None, sprint_id: str = None, assignee_id: str = None, status: str = None, priority: str = None, limit: int = None, parent_id: str = None, sort_by: str = None, order: str = None, label: str = None, search: str = None) -> list:
+        params = {}
+        if project_id:
+            params["project_id"] = project_id
+        if sprint_id:
+            params["sprint_id"] = sprint_id
+        if assignee_id:
+            params["assignee_id"] = assignee_id
+        if limit:
+            params["limit"] = limit
+        if parent_id:
+            params["parent_id"] = parent_id
+        if sort_by:
+            params["sort_by"] = sort_by
+        if order:
+            params["order"] = order
+        if search:
+            params["search"] = search
+
+        # Build base query with urlencode for single params
+        query = urlencode(params) if params else ""
+
+        # Handle comma-separated status values (CHT-502)
+        if status:
+            status_values = [s.strip() for s in status.split(",")]
+            status_params = "&".join([f"status={quote(s)}" for s in status_values])
+            query = f"{query}&{status_params}" if query else status_params
+
+        # Handle comma-separated priority values
+        if priority:
+            priority_values = [p.strip() for p in priority.split(",")]
+            priority_params = "&".join([f"priority={quote(p)}" for p in priority_values])
+            query = f"{query}&{priority_params}" if query else priority_params
+
+        # Handle comma-separated label values (CHT-696)
+        if label:
+            label_values = [l.strip() for l in label.split(",")]
+            label_params = "&".join([f"label={quote(l)}" for l in label_values])
+            query = f"{query}&{label_params}" if query else label_params
+
+        return self._request("GET", f"/issues?{query}")
+
+    def get_issue(self, issue_id: str) -> dict:
+        return self._request("GET", f"/issues/{issue_id}")
+
+    def get_issue_by_identifier(self, identifier: str) -> dict:
+        return self._request("GET", f"/issues/identifier/{identifier}")
+
+    def search_issues(self, team_id: str, query: str, project_id: str = None) -> list:
+        url = f"/issues/search?team_id={team_id}&q={quote(query)}"
+        if project_id:
+            url += f"&project_id={project_id}"
+        return self._request("GET", url)
+
+    def update_issue(self, issue_id: str, **kwargs) -> dict:
+        return self._request("PATCH", f"/issues/{issue_id}", kwargs)
+
+    def delete_issue(self, issue_id: str):
+        return self._request("DELETE", f"/issues/{issue_id}")
+
+    # Sub-issues
+    def get_sub_issues(self, issue_id: str) -> list:
+        return self._request("GET", f"/issues/{issue_id}/sub-issues")
+
+    # Relations
+    def get_relations(self, issue_id: str) -> list:
+        return self._request("GET", f"/issues/{issue_id}/relations")
+
+    def create_relation(self, issue_id: str, related_issue_id: str, relation_type: str = "blocks") -> dict:
+        return self._request("POST", f"/issues/{issue_id}/relations", {
+            "related_issue_id": related_issue_id,
+            "relation_type": relation_type
+        })
+
+    def delete_relation(self, issue_id: str, relation_id: str):
+        return self._request("DELETE", f"/issues/{issue_id}/relations/{relation_id}")
+
+    # Comments
+    def create_comment(self, issue_id: str, content: str) -> dict:
+        return self._request("POST", f"/issues/{issue_id}/comments", {"content": content})
+
+    def get_comments(self, issue_id: str) -> list:
+        return self._request("GET", f"/issues/{issue_id}/comments")
+
+    def delete_comment(self, issue_id: str, comment_id: str):
+        return self._request("DELETE", f"/issues/{issue_id}/comments/{comment_id}")
+
+    # Sprints
+    def get_sprints(self, project_id: str, status: str = None) -> list:
+        url = f"/sprints?project_id={project_id}"
+        if status:
+            url += f"&sprint_status={status}"
+        return self._request("GET", url)
+
+    def get_sprint(self, sprint_id: str) -> dict:
+        return self._request("GET", f"/sprints/{sprint_id}")
+
+    def update_sprint(self, sprint_id: str, **kwargs) -> dict:
+        return self._request("PATCH", f"/sprints/{sprint_id}", kwargs)
+
+    def close_sprint(self, sprint_id: str) -> dict:
+        return self._request("POST", f"/sprints/{sprint_id}/close")
+
+    # Documents
+    def create_document(self, team_id: str, title: str, **kwargs) -> dict:
+        data = {"title": title, **kwargs}
+        return self._request("POST", f"/documents?team_id={team_id}", data)
+
+    def get_documents(self, team_id: str, project_id: str = None, sprint_id: str = None, search: str = None) -> list:
+        url = f"/documents?team_id={team_id}"
+        if project_id:
+            url += f"&project_id={project_id}"
+        if sprint_id:
+            url += f"&sprint_id={sprint_id}"
+        if search:
+            url += f"&search={search}"
+        return self._request("GET", url)
+
+    def get_document(self, document_id: str) -> dict:
+        return self._request("GET", f"/documents/{document_id}")
+
+    def update_document(self, document_id: str, **kwargs) -> dict:
+        return self._request("PATCH", f"/documents/{document_id}", kwargs)
+
+    def delete_document(self, document_id: str):
+        return self._request("DELETE", f"/documents/{document_id}")
+
+    # Document-Issue Links
+    def get_document_issues(self, document_id: str) -> list:
+        return self._request("GET", f"/documents/{document_id}/issues")
+
+    def link_document_to_issue(self, document_id: str, issue_id: str) -> dict:
+        return self._request("POST", f"/documents/{document_id}/issues/{issue_id}")
+
+    def unlink_document_from_issue(self, document_id: str, issue_id: str):
+        return self._request("DELETE", f"/documents/{document_id}/issues/{issue_id}")
+
+    def get_document_comments(self, document_id: str) -> list:
+        return self._request("GET", f"/documents/{document_id}/comments")
+
+    def create_document_comment(self, document_id: str, content: str) -> dict:
+        return self._request("POST", f"/documents/{document_id}/comments", {"content": content})
+
+    def get_issue_documents(self, issue_id: str) -> list:
+        return self._request("GET", f"/issues/{issue_id}/documents")
+
+    # Labels
+    def create_label(self, team_id: str, name: str, **kwargs) -> dict:
+        data = {"name": name, **kwargs}
+        return self._request("POST", f"/labels?team_id={team_id}", data)
+
+    def get_labels(self, team_id: str) -> list:
+        return self._request("GET", f"/labels?team_id={team_id}")
+
+    def update_label(self, label_id: str, **kwargs) -> dict:
+        return self._request("PATCH", f"/labels/{label_id}", kwargs)
+
+    def delete_label(self, label_id: str):
+        return self._request("DELETE", f"/labels/{label_id}")
+
+    def add_label_to_issue(self, issue_id: str, label_id: str) -> dict:
+        """Add a label to an issue."""
+        return self._request("POST", f"/issues/{issue_id}/labels", {"label_id": label_id})
+
+    def remove_label_from_issue(self, issue_id: str, label_id: str) -> dict:
+        """Remove a label from an issue."""
+        return self._request("DELETE", f"/issues/{issue_id}/labels/{label_id}")
+
+    # Rituals
+    def get_rituals(self, project_id: str) -> list:
+        return self._request("GET", f"/rituals?project_id={project_id}")
+
+    def get_limbo_status(self, project_id: str) -> dict:
+        return self._request("GET", f"/rituals/limbo?project_id={project_id}")
+
+    def force_clear_limbo(self, project_id: str) -> dict:
+        return self._request("POST", f"/rituals/force-clear-limbo?project_id={project_id}", {})
+
+    def create_ritual(self, project_id: str, name: str, prompt: str, **kwargs) -> dict:
+        data = {"name": name, "prompt": prompt, **kwargs}
+        return self._request("POST", f"/rituals?project_id={project_id}", data)
+
+    def update_ritual(self, ritual_id: str, **kwargs) -> dict:
+        """Update a ritual. Accepts prompt, name, approval_mode, trigger."""
+        data = {k: v for k, v in kwargs.items() if v is not None}
+        return self._request("PATCH", f"/rituals/{ritual_id}", data)
+
+    def delete_ritual(self, ritual_id: str) -> None:
+        """Delete (deactivate) a ritual."""
+        self._request("DELETE", f"/rituals/{ritual_id}")
+
+    def attest_ritual(self, ritual_id: str, project_id: str, note: str = None) -> dict:
+        data = {}
+        if note:
+            data["note"] = note
+        return self._request("POST", f"/rituals/{ritual_id}/attest?project_id={project_id}", data)
+
+    def approve_ritual(self, ritual_id: str, project_id: str) -> dict:
+        return self._request("POST", f"/rituals/{ritual_id}/approve?project_id={project_id}", {})
+
+    def complete_gate_ritual(self, ritual_id: str, project_id: str, note: str = None) -> dict:
+        data = {}
+        if note:
+            data["note"] = note
+        return self._request("POST", f"/rituals/{ritual_id}/complete?project_id={project_id}", data)
+
+    def get_pending_issue_rituals(self, issue_id: str) -> dict:
+        return self._request("GET", f"/rituals/issue/{issue_id}/pending")
+
+    def attest_ritual_for_issue(self, ritual_id: str, issue_id: str, note: str = None) -> dict:
+        data = {}
+        if note:
+            data["note"] = note
+        return self._request("POST", f"/rituals/{ritual_id}/attest-issue/{issue_id}", data)
+
+    def complete_gate_ritual_for_issue(self, ritual_id: str, issue_id: str, note: str = None) -> dict:
+        data = {}
+        if note:
+            data["note"] = note
+        return self._request("POST", f"/rituals/{ritual_id}/complete-issue/{issue_id}", data)
+
+    # Ritual Groups
+    def get_ritual_groups(self, project_id: str) -> list:
+        return self._request("GET", f"/rituals/groups?project_id={project_id}")
+
+    def get_ritual_group(self, group_id: str) -> dict:
+        return self._request("GET", f"/rituals/groups/{group_id}")
+
+    def create_ritual_group(self, project_id: str, name: str, selection_mode: str = "random_one") -> dict:
+        data = {"name": name, "selection_mode": selection_mode}
+        return self._request("POST", f"/rituals/groups?project_id={project_id}", data)
+
+    def update_ritual_group(self, group_id: str, **kwargs) -> dict:
+        data = {k: v for k, v in kwargs.items() if v is not None}
+        return self._request("PATCH", f"/rituals/groups/{group_id}", data)
+
+    def delete_ritual_group(self, group_id: str) -> None:
+        self._request("DELETE", f"/rituals/groups/{group_id}")
+
+    def get_current_sprint(self, project_id: str) -> dict:
+        return self._request("GET", f"/sprints/current?project_id={project_id}")
+
+    # Agents
+    def create_team_agent(self, team_id: str, name: str) -> dict:
+        """Create a team-scoped agent."""
+        return self._request("POST", f"/teams/{team_id}/agents", {"name": name})
+
+    def create_project_agent(self, project_id: str, name: str) -> dict:
+        """Create a project-scoped agent."""
+        return self._request("POST", f"/projects/{project_id}/agents", {"name": name})
+
+    def get_team_agents(self, team_id: str) -> list:
+        """List all agents for a team."""
+        return self._request("GET", f"/teams/{team_id}/agents")
+
+    def get_agent(self, agent_id: str) -> dict:
+        """Get agent by ID."""
+        return self._request("GET", f"/agents/{agent_id}")
+
+    def update_agent(self, agent_id: str, **kwargs) -> dict:
+        """Update an agent's name or avatar."""
+        return self._request("PATCH", f"/agents/{agent_id}", kwargs)
+
+    def delete_agent(self, agent_id: str):
+        """Delete an agent."""
+        return self._request("DELETE", f"/agents/{agent_id}")
+
+
+client = Client()