bamboo-coding 0.1.0__py3-none-any.whl

agent/bamboo_git_agent/main.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from dataclasses import asdict
+from pathlib import Path
+from typing import Awaitable, Callable
+
+from agent.bamboo_git_agent.capabilities.repo import execute_task
+from agent.bamboo_git_agent.config import load_config
+from agent.bamboo_git_agent.controller_client import ControllerConnection
+from agent.bamboo_git_agent.journal import RuntimeJournal
+from agent.bamboo_git_agent.status import build_register_message, build_status_message
+from shared.protocol import TaskEventMessage, TaskMessage, TaskResultMessage
+
+
+TaskExecutor = Callable[[TaskMessage], Awaitable[dict]]
+
+
+class AgentRuntime:
+    def __init__(self, executor: TaskExecutor, config=None):
+        self.config = config or load_config()
+        self.executor = executor
+        self.journal = RuntimeJournal(self.config.journal_path)
+        self.connection = ControllerConnection(self.config.controller_url, token=self.config.token)
+
+    def capabilities(self) -> list[dict]:
+        return [
+            {"capability": "fs.tree", "actions": ["get"]},
+            {"capability": "fs.browse", "actions": ["get"]},
+            {"capability": "fs.file.read", "actions": ["get"]},
+            {"capability": "fs.file.write", "actions": ["put"]},
+            {"capability": "git.diff", "actions": ["get"]},
+            {"capability": "git.status", "actions": ["get"]},
+            {"capability": "git.commits", "actions": ["list"]},
+            {"capability": "git.commit_details", "actions": ["get"]},
+            {"capability": "git.stage", "actions": ["post"]},
+            {"capability": "git.unstage", "actions": ["post"]},
+            {"capability": "git.branches.list", "actions": ["get"]},
+            {"capability": "git.branches.create", "actions": ["post"]},
+            {"capability": "git.branches.checkout", "actions": ["put"]},
+            {"capability": "git.branches.delete", "actions": ["delete"]},
+            {"capability": "git.branches.merge", "actions": ["post"]},
+            {"capability": "git.commit.create", "actions": ["post"]},
+            {"capability": "repo.tree", "actions": ["get"]},
+            {"capability": "repo.browse", "actions": ["get"]},
+            {"capability": "repo.diff", "actions": ["get"]},
+            {"capability": "repo.status", "actions": ["get"]},
+            {"capability": "repo.commits", "actions": ["list"]},
+            {"capability": "repo.commit_details", "actions": ["get"]},
+            {"capability": "repo.file.read", "actions": ["get"]},
+            {"capability": "repo.file.write", "actions": ["put"]},
+            {"capability": "repo.stage", "actions": ["post"]},
+            {"capability": "repo.unstage", "actions": ["post"]},
+            {"capability": "repo.branches.list", "actions": ["get"]},
+            {"capability": "repo.branches.create", "actions": ["post"]},
+            {"capability": "repo.branches.checkout", "actions": ["put"]},
+            {"capability": "repo.branches.delete", "actions": ["delete"]},
+            {"capability": "repo.branches.merge", "actions": ["post"]},
+            {"capability": "repo.commit.create", "actions": ["post"]},
+        ]
+
+    def roots(self) -> list[dict]:
+        return [{"path": item.path, "name": item.name} for item in self.config.repositories]
+
+    def repositories(self) -> list[dict]:
+        return [asdict(item) for item in self.config.repositories]
+
+    def runtime_health(self) -> tuple[int, int, int]:
+        active = len(self.journal.list_active_tasks())
+        queued = 0
+        return active, queued, self.config.max_concurrent_tasks
+
+    def _persist_token(self, token: str) -> None:
+        self.config.token_path.parent.mkdir(parents=True, exist_ok=True)
+        self.config.token_path.write_text(json.dumps({"token": token}), encoding="utf-8")
+        self.connection.token = token
+
+    async def register_once(self) -> bool:
+        await self.connection.connect()
+        active, queued, max_concurrent = self.runtime_health()
+        register = build_register_message(
+            client_id=self.config.client_id,
+            hostname=self.config.hostname,
+            version=self.config.version,
+            platform_name="python",
+            capabilities=self.capabilities(),
+            roots=self.roots(),
+            active_tasks=active,
+            queued_tasks=queued,
+            max_concurrent_tasks=max_concurrent,
+            connected=True,
+        )
+        registration = await self.connection.send_register(register)
+        approved = bool(registration.get("approved", False))
+        token = registration.get("token")
+        if approved and isinstance(token, str) and token:
+            self._persist_token(token)
+        return approved
+
+    async def run(self) -> None:
+        while True:
+            try:
+                approved = await self.register_once()
+                if not approved:
+                    await self.connection.close()
+                    await asyncio.sleep(1)
+                    continue
+                await self.connection.listen(self.handle_task)
+            except Exception:
+                await self.connection.close()
+                await asyncio.sleep(1)
+                continue
+            await self.connection.close()
+            await asyncio.sleep(1)
+
+    async def handle_task(self, task: TaskMessage) -> None:
+        self.journal.record_task_received(
+            task_id=task.task_id,
+            repo_id=task.repo_id,
+            capability=task.capability,
+            action=task.action,
+            params=task.params,
+        )
+        self.journal.append_event(task_id=task.task_id, event_type="accepted", status="running", payload={"message": "started"})
+        await self.connection.send_event(TaskEventMessage(task_id=task.task_id, status="running", message="started"))
+        try:
+            result = await self.executor(task)
+            self.journal.record_terminal_result(task_id=task.task_id, status="succeeded", result=result)
+            await self.connection.send_result(TaskResultMessage(task_id=task.task_id, success=True, result=result))
+        except Exception as exc:
+            self.journal.record_terminal_result(task_id=task.task_id, status="failed", error=str(exc))
+            await self.connection.send_result(TaskResultMessage(task_id=task.task_id, success=False, error=str(exc)))
+        active, queued, max_concurrent = self.runtime_health()
+        await self.connection.send_status(
+            build_status_message(
+                client_id=self.config.client_id,
+                hostname=self.config.hostname,
+                version=self.config.version,
+                platform_name="python",
+                reason="task_update",
+                capabilities=self.capabilities(),
+                roots=self.roots(),
+                active_tasks=active,
+                queued_tasks=queued,
+                max_concurrent_tasks=max_concurrent,
+                connected=True,
+            )
+        )
+
+
+def main() -> None:
+    config = load_config()
+    repositories = {item.repo_id: item.path for item in config.repositories}
+
+    async def _execute(task: TaskMessage) -> dict:
+        return execute_task(task, repositories)
+
+    runtime = AgentRuntime(_execute, config=config)
+    asyncio.run(runtime.run())
+
+
+if __name__ == "__main__":
+    main()

agent/bamboo_git_agent/protocol.py

@@ -0,0 +1,21 @@
+from shared.protocol import (
+    AgentRegisterMessage,
+    ClientStatusMessage,
+    RegisterRequestMessage,
+    TaskEventMessage,
+    TaskMessage,
+    TaskQueryMessage,
+    TaskQueryResultMessage,
+    TaskResultMessage,
+)
+
+__all__ = [
+    "AgentRegisterMessage",
+    "ClientStatusMessage",
+    "RegisterRequestMessage",
+    "TaskEventMessage",
+    "TaskMessage",
+    "TaskQueryMessage",
+    "TaskQueryResultMessage",
+    "TaskResultMessage",
+]

agent/bamboo_git_agent/status.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from shared.protocol import AgentRegisterMessage, ClientStatusMessage
+
+
+def _build_common_payload(*, client_id: str, hostname: str, version: str, platform_name: str, capabilities: list[dict], roots: list[dict] | None, repositories: list[dict] | None, active_tasks: int, queued_tasks: int, max_concurrent_tasks: int, connected: bool) -> dict:
+    root_payload = roots if roots is not None else (repositories or [])
+    return {
+        "protocol_version": 2,
+        "client_id": client_id,
+        "client_info": {
+            "hostname": hostname,
+            "version": version,
+            "platform": platform_name,
+        },
+        "capabilities": capabilities,
+        "roots": root_payload,
+        "connectivity": {"controller": {"connected": connected}},
+        "runtime_health": {
+            "active_tasks": active_tasks,
+            "queued_tasks": queued_tasks,
+            "max_concurrent_tasks": max_concurrent_tasks,
+        },
+    }
+
+
+def build_register_message(*, client_id: str, hostname: str, version: str, platform_name: str, capabilities: list[dict], roots: list[dict] | None = None, repositories: list[dict] | None = None, active_tasks: int, queued_tasks: int, max_concurrent_tasks: int, connected: bool = True) -> AgentRegisterMessage:
+    payload = _build_common_payload(
+        client_id=client_id,
+        hostname=hostname,
+        version=version,
+        platform_name=platform_name,
+        capabilities=capabilities,
+        roots=roots,
+        repositories=repositories,
+        active_tasks=active_tasks,
+        queued_tasks=queued_tasks,
+        max_concurrent_tasks=max_concurrent_tasks,
+        connected=connected,
+    )
+    return AgentRegisterMessage(**payload)
+
+
+def build_status_message(*, client_id: str, hostname: str, version: str, platform_name: str, reason: str, capabilities: list[dict], roots: list[dict] | None = None, repositories: list[dict] | None = None, active_tasks: int, queued_tasks: int, max_concurrent_tasks: int, connected: bool) -> ClientStatusMessage:
+    payload = _build_common_payload(
+        client_id=client_id,
+        hostname=hostname,
+        version=version,
+        platform_name=platform_name,
+        capabilities=capabilities,
+        roots=roots,
+        repositories=repositories,
+        active_tasks=active_tasks,
+        queued_tasks=queued_tasks,
+        max_concurrent_tasks=max_concurrent_tasks,
+        connected=connected,
+    )
+    payload["reason"] = reason
+    return ClientStatusMessage(**payload)

api/__init__.py

@@ -0,0 +1,2 @@
+"""API package initialization."""
+

api/commit.py

@@ -0,0 +1,82 @@
+"""
+Commit API Endpoints
+
+Provides endpoints for repository commit history operations.
+"""
+
+from sanic import Blueprint, response
+from sanic.exceptions import InvalidUsage, ServerError, NotFound
+
+import git_utils
+
+
+commit_bp = Blueprint("commit", url_prefix="/api/repo")
+
+
+@commit_bp.route("/commits")
+async def get_commits(request):
+    """
+    Get commit history with pagination.
+    
+    Query params:
+        limit: Maximum number of commits to return (default 50, max 100)
+        offset: Number of commits to skip (default 0)
+    
+    Returns:
+        JSON with list of commits and pagination info
+    """
+    repo_path = request.ctx.repo_path
+    
+    limit = int(request.args.get("limit", "50"))
+    offset = int(request.args.get("offset", "0"))
+    
+    # Validate parameters
+    if limit < 1 or limit > 100:
+        raise InvalidUsage("Limit must be between 1 and 100")
+    if offset < 0:
+        raise InvalidUsage("Offset must be non-negative")
+    
+    if not git_utils.is_valid_repository(repo_path):
+        raise InvalidUsage(f"Not a valid Git repository: {repo_path}")
+    
+    commits = git_utils.get_commit_history(repo_path, limit, offset)
+    
+    return response.json({
+        "commits": commits,
+        "limit": limit,
+        "offset": offset,
+        "count": len(commits)
+    })
+
+
+@commit_bp.route("/commit/<commit_hash>")
+async def get_commit_details(request, commit_hash):
+    """
+    Get detailed information about a specific commit.
+    
+    Path params:
+        commit_hash: Full or abbreviated commit hash
+    
+    Returns:
+        JSON with commit metadata, changed files, and diffs
+    """
+    repo_path = request.ctx.repo_path
+    
+    if not git_utils.is_valid_repository(repo_path):
+        raise InvalidUsage(f"Not a valid Git repository: {repo_path}")
+    
+    try:
+        commit_details = git_utils.get_commit_details(repo_path, commit_hash)
+        return response.json(commit_details)
+    except ValueError as e:
+        # Invalid commit hash or commit not found
+        error_msg = str(e)
+        if "not found" in error_msg.lower():
+            raise NotFound(error_msg)
+        else:
+            raise InvalidUsage(error_msg)
+    except git_utils.GitPermissionError as e:
+        raise ServerError(str(e))
+    except git_utils.InvalidGitRepositoryError as e:
+        raise InvalidUsage(str(e))
+