bamboo-coding 0.1.0__py3-none-any.whl

agent/bamboo_git_agent/capabilities/repo.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable
+
+import git_utils
+from shared.protocol import TaskMessage
+
+
+def _allowed_roots(repositories: dict[str, str] | list[str] | tuple[str, ...]) -> list[str]:
+    if isinstance(repositories, dict):
+        values = list(repositories.values()) or list(repositories.keys())
+    else:
+        values = list(repositories)
+    return [str(Path(item).expanduser().resolve()) for item in values]
+
+
+def _resolve_allowed_path(task: TaskMessage, repositories: dict[str, str] | list[str] | tuple[str, ...]) -> str:
+    target = str(Path(task.path).expanduser().resolve())
+    for root in _allowed_roots(repositories):
+        try:
+            Path(target).relative_to(root)
+            return target
+        except ValueError:
+            continue
+    raise PermissionError(f"Path outside allowed roots: {task.path}")
+
+
+def _resolve_repo_root(task: TaskMessage, repositories: dict[str, str] | list[str] | tuple[str, ...]) -> str:
+    allowed_path = _resolve_allowed_path(task, repositories)
+    return git_utils.resolve_git_repository_path(allowed_path)
+
+
+def execute_task(task: TaskMessage, repositories: dict[str, str] | list[str] | tuple[str, ...]) -> dict:
+    handler = _HANDLERS.get((task.capability, task.action))
+    if handler is None:
+        raise KeyError(f"Unsupported task: {task.capability}/{task.action}")
+    git_utils.clear_cache()
+    return handler(task, repositories)
+
+
+def _fs_tree(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    include_nested = bool(task.params.get("all", False))
+    if git_utils.is_git_repository_path(path):
+        repo_path = git_utils.resolve_git_repository_path(path)
+        return git_utils.get_file_tree(repo_path, changed_only=not include_nested)
+    return git_utils.get_workspace_tree(path, include_nested=include_nested)
+
+
+def _fs_browse(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    return git_utils.browse_workspace(path)
+
+
+def _fs_read(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    return git_utils.read_workspace_file(path)
+
+
+def _fs_write(task: TaskMessage, repositories) -> dict:
+    path = _resolve_allowed_path(task, repositories)
+    return git_utils.write_workspace_file(path, task.params["content"], task.params.get("encoding", "utf-8"))
+
+
+def _tree(task: TaskMessage, repositories) -> dict:
+    show_all = bool(task.params.get("all", False))
+    return git_utils.get_file_tree(_resolve_repo_root(task, repositories), changed_only=not show_all)
+
+
+def _browse(task: TaskMessage, repositories) -> dict:
+    return git_utils.browse_directory(_resolve_repo_root(task, repositories), task.params.get("path", "/"))
+
+
+def _diff(task: TaskMessage, repositories) -> dict:
+    return git_utils.get_file_diff(
+        _resolve_repo_root(task, repositories),
+        task.params["file"],
+        bool(task.params.get("staged", False)),
+        int(task.params.get("context", 3)),
+    )
+
+
+def _status(task: TaskMessage, repositories) -> dict:
+    return git_utils.get_repo_status(_resolve_repo_root(task, repositories))
+
+
+def _commits(task: TaskMessage, repositories) -> dict:
+    limit = int(task.params.get("limit", 50))
+    offset = int(task.params.get("offset", 0))
+    repo_path = _resolve_repo_root(task, repositories)
+    return {
+        "commits": git_utils.get_commit_history(repo_path, limit=limit, offset=offset),
+        "limit": limit,
+        "offset": offset,
+    }
+
+
+def _commit_details(task: TaskMessage, repositories) -> dict:
+    return git_utils.get_commit_details(_resolve_repo_root(task, repositories), task.params["commit_hash"])
+
+
+def _read_file(task: TaskMessage, repositories) -> dict:
+    return git_utils.read_file_content(_resolve_repo_root(task, repositories), task.params["file_path"])
+
+
+def _write_file(task: TaskMessage, repositories) -> dict:
+    return git_utils.write_file_content(
+        _resolve_repo_root(task, repositories),
+        task.params["file_path"],
+        task.params["content"],
+        task.params.get("encoding", "utf-8"),
+    )
+
+
+def _stage(task: TaskMessage, repositories) -> dict:
+    repo_path = _resolve_repo_root(task, repositories)
+    if task.params.get("stage_all"):
+        return git_utils.stage_all_files(repo_path)
+    return git_utils.stage_file(repo_path, task.params["file_path"])
+
+
+def _unstage(task: TaskMessage, repositories) -> dict:
+    return git_utils.unstage_file(_resolve_repo_root(task, repositories), task.params["file_path"])
+
+
+def _list_branches(task: TaskMessage, repositories) -> dict:
+    return git_utils.list_branches(_resolve_repo_root(task, repositories))
+
+
+def _create_branch(task: TaskMessage, repositories) -> dict:
+    return git_utils.create_branch(_resolve_repo_root(task, repositories), task.params["name"], task.params.get("start_point"))
+
+
+def _checkout_branch(task: TaskMessage, repositories) -> dict:
+    return git_utils.switch_branch(_resolve_repo_root(task, repositories), task.params["name"])
+
+
+def _delete_branch(task: TaskMessage, repositories) -> dict:
+    return git_utils.delete_branch(_resolve_repo_root(task, repositories), task.params["name"], bool(task.params.get("force", False)))
+
+
+def _merge_branch(task: TaskMessage, repositories) -> dict:
+    return git_utils.merge_branch(_resolve_repo_root(task, repositories), task.params["source"], task.params.get("message"))
+
+
+def _create_commit(task: TaskMessage, repositories) -> dict:
+    return git_utils.create_commit(
+        _resolve_repo_root(task, repositories),
+        task.params["message"],
+        task.params.get("author_name"),
+        task.params.get("author_email"),
+    )
+
+
+_HANDLERS: dict[tuple[str, str], Callable[[TaskMessage, dict[str, str] | list[str] | tuple[str, ...]], dict]] = {
+    ("fs.tree", "get"): _fs_tree,
+    ("fs.browse", "get"): _fs_browse,
+    ("fs.file.read", "get"): _fs_read,
+    ("fs.file.write", "put"): _fs_write,
+    ("repo.tree", "get"): _tree,
+    ("repo.browse", "get"): _browse,
+    ("repo.diff", "get"): _diff,
+    ("repo.status", "get"): _status,
+    ("repo.commits", "list"): _commits,
+    ("repo.commit_details", "get"): _commit_details,
+    ("repo.file.read", "get"): _read_file,
+    ("repo.file.write", "put"): _write_file,
+    ("repo.stage", "post"): _stage,
+    ("repo.unstage", "post"): _unstage,
+    ("repo.branches.list", "get"): _list_branches,
+    ("repo.branches.create", "post"): _create_branch,
+    ("repo.branches.checkout", "put"): _checkout_branch,
+    ("repo.branches.delete", "delete"): _delete_branch,
+    ("repo.branches.merge", "post"): _merge_branch,
+    ("repo.commit.create", "post"): _create_commit,
+    ("git.status", "get"): _status,
+    ("git.diff", "get"): _diff,
+    ("git.commits", "list"): _commits,
+    ("git.commit_details", "get"): _commit_details,
+    ("git.stage", "post"): _stage,
+    ("git.unstage", "post"): _unstage,
+    ("git.branches.list", "get"): _list_branches,
+    ("git.branches.create", "post"): _create_branch,
+    ("git.branches.checkout", "put"): _checkout_branch,
+    ("git.branches.delete", "delete"): _delete_branch,
+    ("git.branches.merge", "post"): _merge_branch,
+    ("git.commit.create", "post"): _create_commit,
+}

agent/bamboo_git_agent/config.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import json
+import os
+import platform
+
+
+@dataclass(frozen=True)
+class RepositoryConfig:
+    repo_id: str
+    name: str
+    path: str
+
+
+@dataclass(frozen=True)
+class AgentConfig:
+    controller_url: str
+    client_id: str
+    hostname: str
+    version: str
+    token: str
+    token_path: Path
+    journal_path: Path
+    max_concurrent_tasks: int = 1
+    allowed_roots: tuple[str, ...] = field(default_factory=tuple)
+    repositories: tuple[RepositoryConfig, ...] = field(default_factory=tuple)
+
+
+def _normalize_root(path_value: str) -> str:
+    return str(Path(path_value).expanduser().resolve())
+
+
+def _load_allowed_roots() -> tuple[str, ...]:
+    raw_value = os.getenv("AGENT_ALLOWED_ROOTS") or os.getenv("AGENT_ROOT") or os.getenv("AGENT_REPO_PATH") or str(Path.cwd())
+    roots = tuple(_normalize_root(item) for item in raw_value.split(os.pathsep) if item.strip())
+    return roots or (_normalize_root(str(Path.cwd())),)
+
+
+def _load_stored_token(token_path: Path) -> str:
+    if not token_path.exists():
+        return ""
+    try:
+        payload = json.loads(token_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return ""
+    token = payload.get("token")
+    return token if isinstance(token, str) else ""
+
+
+def load_config() -> AgentConfig:
+    base_dir = Path(os.getenv("AGENT_HOME", Path.cwd() / ".agent"))
+    token_path = Path(os.getenv("AGENT_TOKEN_PATH", base_dir / "token.json"))
+    allowed_roots = _load_allowed_roots()
+    repositories = tuple(
+        RepositoryConfig(
+            repo_id=root,
+            name=Path(root).name or root,
+            path=root,
+        )
+        for root in allowed_roots
+    )
+    token = os.getenv("AGENT_TOKEN") or _load_stored_token(token_path)
+    return AgentConfig(
+        controller_url=os.getenv("CONTROLLER_URL", "ws://127.0.0.1:8100/ws/agents"),
+        client_id=os.getenv("AGENT_CLIENT_ID", platform.node() or "git-agent"),
+        hostname=os.getenv("AGENT_HOSTNAME", platform.node() or "git-agent"),
+        version=os.getenv("AGENT_VERSION", "0.1.0"),
+        token=token,
+        token_path=token_path,
+        journal_path=Path(os.getenv("AGENT_JOURNAL_PATH", base_dir / "journal.db")),
+        max_concurrent_tasks=int(os.getenv("AGENT_MAX_CONCURRENT_TASKS", "1")),
+        allowed_roots=allowed_roots,
+        repositories=repositories,
+    )

agent/bamboo_git_agent/controller_client.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import json
+from typing import Awaitable, Callable
+
+from websockets import connect
+from websockets.exceptions import ConnectionClosed
+
+from shared.protocol import (
+    AgentRegisterMessage,
+    ClientStatusMessage,
+    TaskEventMessage,
+    TaskMessage,
+    TaskQueryResultMessage,
+    TaskResultMessage,
+)
+
+
+class ControllerConnection:
+    def __init__(self, controller_url: str, token: str = ""):
+        self.controller_url = controller_url
+        self.token = token
+        self.websocket = None
+
+    async def connect(self):
+        headers = {}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        self.websocket = await connect(self.controller_url, extra_headers=headers or None, ping_interval=None, ping_timeout=None)
+        return self.websocket
+
+    async def send_register(self, message: AgentRegisterMessage) -> dict:
+        await self._send(message.model_dump())
+        return await self._receive()
+
+    async def send_status(self, message: ClientStatusMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def send_event(self, message: TaskEventMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def send_result(self, message: TaskResultMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def send_query_result(self, message: TaskQueryResultMessage) -> None:
+        await self._send(message.model_dump())
+
+    async def listen(self, on_task: Callable[[TaskMessage], Awaitable[None]]) -> None:
+        if self.websocket is None:
+            raise RuntimeError("connection not established")
+        try:
+            async for raw in self.websocket:
+                data = json.loads(raw)
+                if data.get("type") == "task":
+                    await on_task(TaskMessage(**data))
+        except ConnectionClosed:
+            return
+
+    async def close(self) -> None:
+        if self.websocket is not None:
+            await self.websocket.close()
+            self.websocket = None
+
+    async def _send(self, payload: dict) -> None:
+        if self.websocket is None:
+            raise RuntimeError("connection not established")
+        await self.websocket.send(json.dumps(payload))
+
+    async def _receive(self) -> dict:
+        if self.websocket is None:
+            raise RuntimeError("connection not established")
+        raw = await self.websocket.recv()
+        return json.loads(raw)

agent/bamboo_git_agent/journal.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+import time
+from pathlib import Path
+
+
+ACTIVE_STATUSES = {"received", "queued", "accepted", "running"}
+TERMINAL_STATUSES = {"succeeded", "failed", "cancelled", "timeout"}
+
+
+def _json_dumps(value) -> str | None:
+    if value is None:
+        return None
+    return json.dumps(value, sort_keys=True)
+
+
+def _json_loads(value):
+    if not value:
+        return None
+    return json.loads(value)
+
+
+class RuntimeJournal:
+    def __init__(self, path: str | Path):
+        self.path = Path(path)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._ensure_schema()
+
+    def _connect(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self.path)
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA foreign_keys = ON")
+        return conn
+
+    def _ensure_schema(self) -> None:
+        with self._connect() as conn:
+            conn.executescript(
+                """
+                CREATE TABLE IF NOT EXISTS tasks (
+                    task_id TEXT PRIMARY KEY,
+                    repo_id TEXT NOT NULL,
+                    capability TEXT NOT NULL,
+                    action TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    params_json TEXT NOT NULL DEFAULT '{}',
+                    result_json TEXT,
+                    error TEXT,
+                    created_at REAL NOT NULL,
+                    updated_at REAL NOT NULL,
+                    completed_at REAL,
+                    last_seq INTEGER NOT NULL DEFAULT 0
+                );
+
+                CREATE TABLE IF NOT EXISTS task_events (
+                    task_id TEXT NOT NULL,
+                    seq INTEGER NOT NULL,
+                    event_type TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    payload_json TEXT NOT NULL DEFAULT '{}',
+                    created_at REAL NOT NULL,
+                    PRIMARY KEY (task_id, seq),
+                    FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
+                );
+                """
+            )
+
+    def record_task_received(self, *, task_id: str, repo_id: str, capability: str, action: str, params: dict) -> dict:
+        now = time.time()
+        with self._connect() as conn:
+            conn.execute(
+                """
+                INSERT OR IGNORE INTO tasks (
+                    task_id, repo_id, capability, action, status, params_json, created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (task_id, repo_id, capability, action, "received", _json_dumps(params), now, now),
+            )
+            row = conn.execute("SELECT * FROM tasks WHERE task_id = ?", (task_id,)).fetchone()
+        return self._row_to_task(row)
+
+    def append_event(self, *, task_id: str, event_type: str, status: str, payload: dict | None = None) -> dict:
+        payload = payload or {}
+        now = time.time()
+        with self._connect() as conn:
+            row = conn.execute("SELECT * FROM tasks WHERE task_id = ?", (task_id,)).fetchone()
+            if row is None:
+                raise KeyError(f"unknown task_id: {task_id}")
+            seq = int(row["last_seq"]) + 1
+            completed_at = row["completed_at"]
+            if status in TERMINAL_STATUSES and completed_at is None:
+                completed_at = now
+            conn.execute(
+                "INSERT INTO task_events (task_id, seq, event_type, status, payload_json, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+                (task_id, seq, event_type, status, _json_dumps(payload), now),
+            )
+            conn.execute(
+                "UPDATE tasks SET status = ?, updated_at = ?, completed_at = ?, last_seq = ? WHERE task_id = ?",
+                (status, now, completed_at, seq, task_id),
+            )
+        return {
+            "task_id": task_id,
+            "seq": seq,
+            "event_type": event_type,
+            "status": status,
+            "payload": payload,
+            "created_at": now,
+        }
+
+    def record_terminal_result(self, *, task_id: str, status: str, result: dict | None = None, error: str | None = None) -> dict:
+        if status not in TERMINAL_STATUSES:
+            raise ValueError(f"terminal status required, got {status}")
+        payload = {"result": result or {}}
+        if error is not None:
+            payload["error"] = error
+        event = self.append_event(task_id=task_id, event_type="result", status=status, payload=payload)
+        now = time.time()
+        with self._connect() as conn:
+            conn.execute(
+                "UPDATE tasks SET result_json = ?, error = ?, updated_at = ?, completed_at = COALESCE(completed_at, ?) WHERE task_id = ?",
+                (_json_dumps(result or {}), error, now, now, task_id),
+            )
+            row = conn.execute("SELECT * FROM tasks WHERE task_id = ?", (task_id,)).fetchone()
+        summary = self._row_to_task(row)
+        return {
+            "task_id": task_id,
+            "status": summary["status"],
+            "seq": event["seq"],
+            "result": summary["result"],
+            "error": summary["error"],
+        }
+
+    def get_task(self, task_id: str) -> dict | None:
+        with self._connect() as conn:
+            row = conn.execute("SELECT * FROM tasks WHERE task_id = ?", (task_id,)).fetchone()
+        return self._row_to_task(row)
+
+    def get_events(self, task_id: str, *, after_seq: int = 0) -> list[dict]:
+        with self._connect() as conn:
+            rows = conn.execute(
+                "SELECT task_id, seq, event_type, status, payload_json, created_at FROM task_events WHERE task_id = ? AND seq > ? ORDER BY seq ASC",
+                (task_id, after_seq),
+            ).fetchall()
+        return [self._row_to_event(row) for row in rows]
+
+    def list_active_tasks(self) -> list[dict]:
+        placeholders = ",".join("?" for _ in ACTIVE_STATUSES)
+        with self._connect() as conn:
+            rows = conn.execute(
+                f"SELECT * FROM tasks WHERE status IN ({placeholders}) ORDER BY created_at ASC",
+                tuple(sorted(ACTIVE_STATUSES)),
+            ).fetchall()
+        return [self._row_to_task(row) for row in rows]
+
+    def build_replay_payload(self, cursor_map: dict[str, int] | None) -> dict:
+        cursor_map = cursor_map or {}
+        active_tasks = self.list_active_tasks()
+        events = {}
+        terminal_results = []
+        for task_id, cursor in cursor_map.items():
+            summary = self.get_task(task_id)
+            if summary is None:
+                continue
+            replay_events = self.get_events(task_id, after_seq=int(cursor or 0))
+            if replay_events:
+                events[task_id] = replay_events
+            if summary["status"] in TERMINAL_STATUSES and summary["last_seq"] > int(cursor or 0):
+                terminal_results.append(
+                    {
+                        "task_id": task_id,
+                        "repo_id": summary["repo_id"],
+                        "capability": summary["capability"],
+                        "action": summary["action"],
+                        "status": summary["status"],
+                        "seq": summary["last_seq"],
+                        "result": summary["result"],
+                        "error": summary["error"],
+                    }
+                )
+        return {"active_tasks": active_tasks, "events": events, "terminal_results": terminal_results}
+
+    def _row_to_task(self, row: sqlite3.Row | None) -> dict | None:
+        if row is None:
+            return None
+        return {
+            "task_id": row["task_id"],
+            "repo_id": row["repo_id"],
+            "capability": row["capability"],
+            "action": row["action"],
+            "status": row["status"],
+            "params": _json_loads(row["params_json"]) or {},
+            "result": _json_loads(row["result_json"]) or {},
+            "error": row["error"],
+            "created_at": row["created_at"],
+            "updated_at": row["updated_at"],
+            "completed_at": row["completed_at"],
+            "last_seq": row["last_seq"],
+        }
+
+    def _row_to_event(self, row: sqlite3.Row) -> dict:
+        return {
+            "task_id": row["task_id"],
+            "seq": row["seq"],
+            "event_type": row["event_type"],
+            "status": row["status"],
+            "payload": _json_loads(row["payload_json"]) or {},
+            "created_at": row["created_at"],
+        }