llmcode-cli 1.0.0__py3-none-any.whl

llm_code/swarm/backend_subprocess.py

@@ -0,0 +1,108 @@
+"""Subprocess-based backend for spawning swarm members."""
+from __future__ import annotations
+
+import asyncio
+import shutil
+import sys
+from pathlib import Path
+from typing import IO
+
+
+class SubprocessBackend:
+    """Spawn swarm members as asyncio subprocesses.
+
+    Each member runs llm-code --lite with a role prompt piped to stdin.
+    Output is captured to swarm/<id>/output.log.
+    """
+
+    def __init__(self, swarm_dir: Path) -> None:
+        self._swarm_dir = Path(swarm_dir)
+        self._swarm_dir.mkdir(parents=True, exist_ok=True)
+        self._procs: dict[str, asyncio.subprocess.Process] = {}
+
+    async def spawn(
+        self,
+        member_id: str,
+        role: str,
+        task: str,
+        extra_args: tuple[str, ...] = (),
+        model: str = "",
+    ) -> int | None:
+        """Spawn a new llm-code --lite process for this member.
+
+        Returns the PID, or None on failure.
+        """
+        member_dir = self._swarm_dir / member_id
+        member_dir.mkdir(parents=True, exist_ok=True)
+        log_path = member_dir / "output.log"
+        log_path.touch()
+
+        llm_code_bin = shutil.which("llm-code") or sys.executable
+        cmd_args: list[str] = []
+        if llm_code_bin == sys.executable:
+            cmd_args = [sys.executable, "-m", "llm_code.cli.tui_main", "--lite"]
+        else:
+            cmd_args = [llm_code_bin, "--lite"]
+
+        cmd_args.extend(extra_args)
+
+        if model:
+            cmd_args.extend(["--model", model])
+
+        prompt = f"You are a swarm worker with role '{role}'. Your task: {task}"
+
+        log_fh = open(log_path, "w", encoding="utf-8")
+        proc = await asyncio.create_subprocess_exec(
+            *cmd_args,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=log_fh,
+            stderr=asyncio.subprocess.STDOUT,
+        )
+        self._procs[member_id] = proc
+        # Track open file handles for cleanup
+        if not hasattr(self, "_log_files"):
+            self._log_files: dict[str, IO[str]] = {}
+        self._log_files[member_id] = log_fh
+
+        # Send initial prompt
+        if proc.stdin:
+            proc.stdin.write((prompt + "\n").encode())
+            await proc.stdin.drain()
+
+        return proc.pid
+
+    async def stop(self, member_id: str) -> None:
+        """Terminate the process for a member."""
+        proc = self._procs.get(member_id)
+        if proc is None:
+            return
+        try:
+            proc.terminate()
+            await asyncio.wait_for(proc.wait(), timeout=5.0)
+        except (ProcessLookupError, asyncio.TimeoutError):
+            try:
+                proc.kill()
+            except ProcessLookupError:
+                pass
+        self._procs.pop(member_id, None)
+        # Close log file handle
+        if hasattr(self, "_log_files"):
+            fh = self._log_files.pop(member_id, None)
+            if fh is not None:
+                try:
+                    fh.close()
+                except Exception:
+                    pass
+
+    async def stop_all(self) -> None:
+        """Terminate all spawned processes."""
+        ids = list(self._procs.keys())
+        for member_id in ids:
+            await self.stop(member_id)
+
+    def is_running(self, member_id: str) -> bool:
+        """Check if a member process is still alive."""
+        proc = self._procs.get(member_id)
+        if proc is None:
+            return False
+        return proc.returncode is None

llm_code/swarm/backend_tmux.py

@@ -0,0 +1,103 @@
+"""Tmux-based backend for spawning swarm members in panes."""
+from __future__ import annotations
+
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+
+
+def is_tmux_available() -> bool:
+    """Check if tmux is available and we are inside a tmux session."""
+    return shutil.which("tmux") is not None and "TMUX" in os.environ
+
+
+class TmuxBackend:
+    """Spawn swarm members as tmux split panes.
+
+    Each member runs llm-code --lite inside a new tmux pane with a role prompt.
+    """
+
+    def __init__(self) -> None:
+        self._panes: dict[str, str] = {}  # member_id -> pane_id (e.g. "%5")
+
+    def spawn(
+        self,
+        member_id: str,
+        role: str,
+        task: str,
+        extra_args: tuple[str, ...] = (),
+        model: str = "",
+    ) -> str | None:
+        """Spawn a new tmux pane running llm-code --lite.
+
+        Returns the tmux pane ID (e.g. '%5'), or None on failure.
+        """
+        llm_code_bin = shutil.which("llm-code") or sys.executable
+        if llm_code_bin == sys.executable:
+            cmd = f"{sys.executable} -m llm_code.cli.tui_main --lite"
+        else:
+            cmd = f"{llm_code_bin} --lite"
+
+        if extra_args:
+            cmd += " " + " ".join(extra_args)
+
+        if model:
+            cmd += " --model " + shlex.quote(model)
+
+        prompt = f"You are a swarm worker with role '{role}'. Your task: {task}"
+        full_cmd = f"echo {repr(prompt)} | {cmd}"
+
+        result = subprocess.run(
+            [
+                "tmux", "split-window", "-h",
+                "-P", "-F", "#{pane_id}",
+                full_cmd,
+            ],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode != 0:
+            return None
+
+        pane_id = result.stdout.strip()
+        self._panes[member_id] = pane_id
+        return pane_id
+
+    def stop(self, member_id: str) -> None:
+        """Kill the tmux pane for a member."""
+        pane_id = self._panes.pop(member_id, None)
+        if pane_id is None:
+            return
+        try:
+            subprocess.run(
+                ["tmux", "kill-pane", "-t", pane_id],
+                capture_output=True,
+                timeout=5,
+            )
+        except (subprocess.TimeoutExpired, OSError):
+            pass
+
+    def stop_all(self) -> None:
+        """Kill all managed panes."""
+        ids = list(self._panes.keys())
+        for member_id in ids:
+            self.stop(member_id)
+
+    def is_running(self, member_id: str) -> bool:
+        """Check if the pane still exists."""
+        pane_id = self._panes.get(member_id)
+        if pane_id is None:
+            return False
+        try:
+            result = subprocess.run(
+                ["tmux", "has-session", "-t", pane_id],
+                capture_output=True,
+                timeout=3,
+            )
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, OSError):
+            return False

llm_code/swarm/backend_worktree.py

@@ -0,0 +1,306 @@
+"""Git worktree backend for spawning swarm members in isolated filesystem copies."""
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from llm_code.runtime.config import WorktreeConfig
+
+
+@dataclasses.dataclass(frozen=True)
+class WorktreeResult:
+    """Result from completing a worktree-backed swarm member."""
+
+    member_id: str
+    status: str  # "success" | "conflict" | "empty" | "error"
+    diff: str = ""
+    branch_name: str = ""
+    conflict_files: tuple[str, ...] = ()
+    message: str = ""
+
+
+class WorktreeBackend:
+    """Spawn swarm members in git worktrees for isolated file system access.
+
+    Lifecycle per member:
+      spawn    -> create worktree on a new branch, copy gitignored files, start llm-code --lite
+      stop     -> terminate the subprocess
+      complete -> commit changes, apply on_complete strategy, optionally cleanup
+    """
+
+    def __init__(self, project_dir: Path, config: WorktreeConfig) -> None:
+        self._project_dir = Path(project_dir)
+        self._config = config
+        # member_id -> worktree path
+        self._worktrees: dict[str, Path] = {}
+        # member_id -> asyncio/subprocess process
+        self._procs: dict[str, Any] = {}
+        # member_id -> branch name
+        self._branch_names: dict[str, str] = {}
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    async def spawn(
+        self,
+        member_id: str,
+        role: str,
+        task: str,
+        model: str = "",
+        extra_args: tuple[str, ...] = (),
+    ) -> int | None:
+        """Create a git worktree for member_id and launch llm-code --lite.
+
+        Returns the PID of the launched process, or None on failure.
+        """
+        base = Path(self._config.base_dir) if self._config.base_dir else Path("/tmp")
+        wt_path = base / f"llm-code-wt-{member_id}"
+        branch_name = f"agent/{member_id}"
+
+        # Create the worktree on a new branch
+        subprocess.run(
+            ["git", "worktree", "add", str(wt_path), "-b", branch_name],
+            cwd=str(self._project_dir),
+            capture_output=True,
+            text=True,
+        )
+
+        # Copy gitignored files into the worktree
+        for rel_path in self._config.copy_gitignored:
+            src = self._project_dir / rel_path
+            dst = wt_path / rel_path
+            if src.exists():
+                try:
+                    shutil.copy2(str(src), str(dst))
+                except OSError:
+                    pass
+
+        self._worktrees[member_id] = wt_path
+        self._branch_names[member_id] = branch_name
+
+        # Build the llm-code --lite command
+        llm_code_bin = shutil.which("llm-code") or sys.executable
+        cmd_args: list[str] = []
+        if llm_code_bin == sys.executable:
+            cmd_args = [sys.executable, "-m", "llm_code.cli.tui_main", "--lite"]
+        else:
+            cmd_args = [llm_code_bin, "--lite"]
+
+        cmd_args = list(cmd_args) + list(extra_args)
+        if model:
+            cmd_args.extend(["--model", model])
+
+        prompt = f"You are a swarm worker with role '{role}'. Your task: {task}"
+
+        proc = await asyncio.create_subprocess_exec(
+            *cmd_args,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            cwd=str(wt_path),
+        )
+        self._procs[member_id] = proc
+
+        if proc.stdin:
+            proc.stdin.write((prompt + "\n").encode())
+            await proc.stdin.drain()
+
+        return proc.pid
+
+    async def stop(self, member_id: str) -> None:
+        """Terminate the process for a member (without completing/merging)."""
+        proc = self._procs.get(member_id)
+        if proc is None:
+            return
+        try:
+            proc.terminate()
+            await asyncio.wait_for(proc.wait(), timeout=5.0)
+        except (ProcessLookupError, asyncio.TimeoutError):
+            try:
+                proc.kill()
+            except ProcessLookupError:
+                pass
+        self._procs.pop(member_id, None)
+
+    async def complete(self, member_id: str) -> WorktreeResult:
+        """Finalise a member's work according to config.on_complete.
+
+        Strategies:
+          "diff"   - commit all changes, capture diff, cleanup worktree+branch
+          "merge"  - commit, merge into current branch, handle conflicts
+          "branch" - commit, remove worktree, keep branch (for later review)
+
+        Unknown member_id returns an error result immediately.
+        """
+        if member_id not in self._worktrees:
+            return WorktreeResult(
+                member_id=member_id,
+                status="error",
+                message=f"No worktree registered for member '{member_id}'",
+            )
+
+        wt_path = self._worktrees[member_id]
+        branch_name = self._branch_names[member_id]
+        on_complete = self._config.on_complete
+
+        try:
+            if on_complete == "diff":
+                return await self._complete_diff(member_id, wt_path, branch_name)
+            elif on_complete == "merge":
+                return await self._complete_merge(member_id, wt_path, branch_name)
+            elif on_complete == "branch":
+                return await self._complete_branch(member_id, wt_path, branch_name)
+            else:
+                return WorktreeResult(
+                    member_id=member_id,
+                    status="error",
+                    message=f"Unknown on_complete strategy: '{on_complete}'",
+                )
+        except Exception as exc:
+            return WorktreeResult(
+                member_id=member_id,
+                status="error",
+                message=str(exc),
+            )
+
+    async def stop_all(self) -> None:
+        """Stop all running member processes."""
+        ids = list(self._procs.keys())
+        for member_id in ids:
+            await self.stop(member_id)
+
+    def is_running(self, member_id: str) -> bool:
+        """Return True if the member process is still alive."""
+        proc = self._procs.get(member_id)
+        if proc is None:
+            return False
+        return getattr(proc, "returncode", None) is None
+
+    # ------------------------------------------------------------------
+    # Private helpers
+    # ------------------------------------------------------------------
+
+    def _commit_worktree(self, wt_path: Path) -> None:
+        """Stage all changes and create a commit in the worktree."""
+        wt = str(wt_path)
+        subprocess.run(["git", "add", "-A"], cwd=wt, capture_output=True, text=True)
+        subprocess.run(
+            ["git", "commit", "--allow-empty", "-m", "swarm: agent work complete"],
+            cwd=wt,
+            capture_output=True,
+            text=True,
+        )
+
+    def _remove_worktree(self, wt_path: Path, branch_name: str, remove_branch: bool = True) -> None:
+        """Remove the worktree and optionally delete the branch."""
+        subprocess.run(
+            ["git", "worktree", "remove", "--force", str(wt_path)],
+            cwd=str(self._project_dir),
+            capture_output=True,
+            text=True,
+        )
+        if remove_branch:
+            subprocess.run(
+                ["git", "branch", "-d", branch_name],
+                cwd=str(self._project_dir),
+                capture_output=True,
+                text=True,
+            )
+
+    async def _complete_diff(
+        self, member_id: str, wt_path: Path, branch_name: str
+    ) -> WorktreeResult:
+        """Commit, capture diff, then cleanup worktree and branch."""
+        self._commit_worktree(wt_path)
+
+        diff_result = subprocess.run(
+            ["git", "diff", "HEAD~1..HEAD"],
+            cwd=str(wt_path),
+            capture_output=True,
+            text=True,
+        )
+        diff_text = diff_result.stdout
+
+        if self._config.cleanup_on_success:
+            self._remove_worktree(wt_path, branch_name, remove_branch=True)
+            self._worktrees.pop(member_id, None)
+            self._branch_names.pop(member_id, None)
+            self._procs.pop(member_id, None)
+
+        return WorktreeResult(
+            member_id=member_id,
+            status="success",
+            diff=diff_text,
+            branch_name=branch_name,
+        )
+
+    async def _complete_merge(
+        self, member_id: str, wt_path: Path, branch_name: str
+    ) -> WorktreeResult:
+        """Commit agent work, merge into current HEAD branch, handle conflicts."""
+        self._commit_worktree(wt_path)
+
+        merge_result = subprocess.run(
+            ["git", "merge", "--no-ff", branch_name, "-m", f"Merge {branch_name}"],
+            cwd=str(self._project_dir),
+            capture_output=True,
+            text=True,
+        )
+
+        if merge_result.returncode != 0:
+            status_result = subprocess.run(
+                ["git", "diff", "--name-only", "--diff-filter=U"],
+                cwd=str(self._project_dir),
+                capture_output=True,
+                text=True,
+            )
+            conflict_files = tuple(
+                f for f in status_result.stdout.splitlines() if f.strip()
+            )
+            return WorktreeResult(
+                member_id=member_id,
+                status="conflict",
+                branch_name=branch_name,
+                conflict_files=conflict_files,
+                message=merge_result.stderr,
+            )
+
+        if self._config.cleanup_on_success:
+            self._remove_worktree(wt_path, branch_name, remove_branch=True)
+            self._worktrees.pop(member_id, None)
+            self._branch_names.pop(member_id, None)
+            self._procs.pop(member_id, None)
+
+        return WorktreeResult(
+            member_id=member_id,
+            status="success",
+            branch_name=branch_name,
+        )
+
+    async def _complete_branch(
+        self, member_id: str, wt_path: Path, branch_name: str
+    ) -> WorktreeResult:
+        """Commit agent work, remove worktree, keep branch for later review."""
+        self._commit_worktree(wt_path)
+
+        subprocess.run(
+            ["git", "worktree", "remove", "--force", str(wt_path)],
+            cwd=str(self._project_dir),
+            capture_output=True,
+            text=True,
+        )
+        self._worktrees.pop(member_id, None)
+        self._branch_names.pop(member_id, None)
+        self._procs.pop(member_id, None)
+
+        return WorktreeResult(
+            member_id=member_id,
+            status="success",
+            branch_name=branch_name,
+        )

llm_code/swarm/checkpoint.py

@@ -0,0 +1,74 @@
+"""Checkpoint system for agent teams — save/restore agent state for resume."""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class AgentCheckpoint:
+    member_id: str
+    role: str
+    status: str
+    conversation_snapshot: tuple[dict, ...]
+    last_tool_call: str | None = None
+    output: str = ""
+
+
+@dataclass(frozen=True)
+class TeamCheckpoint:
+    team_name: str
+    task_description: str
+    timestamp: str
+    checkpoints: tuple[AgentCheckpoint, ...]
+    coordinator_state: dict = field(default_factory=dict)
+    completed_members: tuple[str, ...] = ()
+
+
+def save_checkpoint(checkpoint: TeamCheckpoint, checkpoints_dir: Path) -> Path:
+    checkpoints_dir.mkdir(parents=True, exist_ok=True)
+    safe_ts = checkpoint.timestamp.replace(":", "-")
+    filename = f"{checkpoint.team_name}-{safe_ts}.json"
+    path = checkpoints_dir / filename
+    data = {
+        "team_name": checkpoint.team_name,
+        "task_description": checkpoint.task_description,
+        "timestamp": checkpoint.timestamp,
+        "checkpoints": [
+            {
+                "member_id": cp.member_id, "role": cp.role, "status": cp.status,
+                "conversation_snapshot": list(cp.conversation_snapshot),
+                "last_tool_call": cp.last_tool_call, "output": cp.output,
+            }
+            for cp in checkpoint.checkpoints
+        ],
+        "coordinator_state": checkpoint.coordinator_state,
+        "completed_members": list(checkpoint.completed_members),
+    }
+    path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    return path
+
+
+def load_checkpoint(path: Path) -> TeamCheckpoint:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    checkpoints = tuple(
+        AgentCheckpoint(
+            member_id=cp["member_id"], role=cp["role"], status=cp["status"],
+            conversation_snapshot=tuple(cp.get("conversation_snapshot", [])),
+            last_tool_call=cp.get("last_tool_call"), output=cp.get("output", ""),
+        )
+        for cp in data.get("checkpoints", [])
+    )
+    return TeamCheckpoint(
+        team_name=data["team_name"], task_description=data.get("task_description", ""),
+        timestamp=data.get("timestamp", ""), checkpoints=checkpoints,
+        coordinator_state=data.get("coordinator_state", {}),
+        completed_members=tuple(data.get("completed_members", [])),
+    )
+
+
+def list_checkpoints(checkpoints_dir: Path) -> list[Path]:
+    if not checkpoints_dir.is_dir():
+        return []
+    return sorted(checkpoints_dir.glob("*.json"))