agent-toolkit-cli 1.11.0__py3-none-win_amd64.whl

agent_toolkit/runner/providers/base.py

@@ -0,0 +1,53 @@
+"""
+Base interface for LLM providers.
+
+All providers must implement this interface to be used by the dev-companion runner.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class LLMResponse:
+    content: str
+    model: str
+    provider: str
+    tokens_used: Optional[int] = None
+    duration_sec: Optional[float] = None
+
+
+class LLMProvider(ABC):
+    name: str
+    is_local: bool = False
+    is_free: bool = False
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if the provider is available (installed, configured, etc.)"""
+        pass
+
+    @abstractmethod
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        repo_path: Optional[Path] = None,
+        timeout_sec: int = 300,
+    ) -> LLMResponse:
+        """Generate a response from the LLM"""
+        pass
+
+    def get_priority(self) -> int:
+        """Lower = higher priority. Local free providers should have priority over cloud paid ones."""
+        return 100
+
+    def supports_directory_context(self) -> bool:
+        """Whether the provider can operate in a specific directory context"""
+        return False
+
+    def get_model_name(self) -> str:
+        """Return the model name used by this provider"""
+        return "unknown"

agent_toolkit/runner/providers/ollama_provider.py

@@ -0,0 +1,108 @@
+"""
+Ollama provider for dev-companion.
+
+Uses ollama CLI to generate responses with locally running models.
+Requires: ollama installed and running with models (e.g., llama3.2, mistral).
+"""
+
+import json
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional
+
+from .base import LLMProvider, LLMResponse
+
+
+class OllamaProvider(LLMProvider):
+    name = "ollama"
+    is_local = True
+    is_free = True
+
+    def __init__(self, model: str = "llama3.2"):
+        self.model = model
+
+    def is_available(self) -> bool:
+        try:
+            result = subprocess.run(
+                ["ollama", "list"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode != 0:
+                return False
+            return self.model in result.stdout
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+    def supports_directory_context(self) -> bool:
+        return False
+
+    def get_model_name(self) -> str:
+        return self.model
+
+    def get_priority(self) -> int:
+        return 2
+
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        repo_path: Optional[Path] = None,
+        timeout_sec: int = 300,
+    ) -> LLMResponse:
+        start_time = time.time()
+
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+
+        input_data = {
+            "model": self.model,
+            "messages": messages,
+            "stream": False,
+        }
+
+        try:
+            result = subprocess.run(
+                ["ollama", "api", "chat", "-"],
+                input=json.dumps(input_data),
+                capture_output=True,
+                text=True,
+                timeout=timeout_sec,
+            )
+
+            duration = time.time() - start_time
+
+            if result.returncode != 0:
+                return LLMResponse(
+                    content=f"Error: {result.stderr}",
+                    model=self.model,
+                    provider=self.name,
+                    duration_sec=duration,
+                )
+
+            try:
+                response_data = json.loads(result.stdout)
+                content = response_data.get("message", {}).get("content", "")
+                if not content:
+                    content = str(response_data)
+            except json.JSONDecodeError:
+                content = result.stdout
+
+            return LLMResponse(
+                content=content,
+                model=self.model,
+                provider=self.name,
+                duration_sec=duration,
+            )
+
+        except subprocess.TimeoutExpired:
+            return LLMResponse(
+                content=f"Timeout after {timeout_sec} seconds",
+                model=self.model,
+                provider=self.name,
+                duration_sec=timeout_sec,
+            )

agent_toolkit/runner/providers/openai_provider.py

@@ -0,0 +1,103 @@
+"""
+OpenAI provider for dev-companion.
+
+Uses OpenAI API as optional paid provider.
+Requires: OPENAI_API_KEY environment variable.
+"""
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Optional
+
+from .base import LLMProvider, LLMResponse
+
+
+class OpenAIProvider(LLMProvider):
+    name = "openai"
+    is_local = False
+    is_free = False
+
+    def __init__(self, model: str = "gpt-4o-mini"):
+        self.model = model
+
+    def is_available(self) -> bool:
+        return bool(os.environ.get("OPENAI_API_KEY"))
+
+    def supports_directory_context(self) -> bool:
+        return False
+
+    def get_model_name(self) -> str:
+        return self.model
+
+    def get_priority(self) -> int:
+        return 20
+
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        repo_path: Optional[Path] = None,
+        timeout_sec: int = 300,
+    ) -> LLMResponse:
+        import urllib.error
+        import urllib.request
+
+        start_time = time.time()
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
+        }
+
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+
+        data = {
+            "model": self.model,
+            "messages": messages,
+            "max_tokens": 4096,
+        }
+
+        try:
+            req = urllib.request.Request(
+                "https://api.openai.com/v1/chat/completions",
+                data=json.dumps(data).encode(),
+                headers=headers,
+                method="POST",
+            )
+
+            with urllib.request.urlopen(req, timeout=timeout_sec) as response:
+                result = json.loads(response.read().decode())
+
+            duration = time.time() - start_time
+
+            content = result.get("choices", [{}])[0].get("message", {}).get("content", "")
+            usage = result.get("usage", {})
+
+            return LLMResponse(
+                content=content,
+                model=self.model,
+                provider=self.name,
+                tokens_used=usage.get("total_tokens"),
+                duration_sec=duration,
+            )
+
+        except urllib.error.HTTPError as e:
+            body = e.read().decode() if e.fp else ""
+            return LLMResponse(
+                content=f"HTTP Error: {e.code} - {e.reason}\n{body}",
+                model=self.model,
+                provider=self.name,
+                duration_sec=time.time() - start_time,
+            )
+        except Exception as e:
+            return LLMResponse(
+                content=f"Error: {str(e)}",
+                model=self.model,
+                provider=self.name,
+                duration_sec=time.time() - start_time,
+            )

agent_toolkit/runner/providers/opencode_provider.py

@@ -0,0 +1,127 @@
+"""
+OpenCode provider for dev-companion.
+
+Uses opencode run command to generate responses.
+Default model: big-pickle (free, local).
+"""
+
+import json
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional
+
+from .base import LLMProvider, LLMResponse
+
+
+class OpenCodeProvider(LLMProvider):
+    name = "opencode"
+    is_local = True
+    is_free = True
+
+    def __init__(self, model: str = "opencode/big-pickle"):
+        self.model = model
+
+    def is_available(self) -> bool:
+        try:
+            result = subprocess.run(
+                ["opencode", "--version"],
+                capture_output=True,
+                timeout=5,
+            )
+            return result.returncode == 0
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+    def supports_directory_context(self) -> bool:
+        return True
+
+    def get_model_name(self) -> str:
+        return self.model
+
+    def get_priority(self) -> int:
+        return 1
+
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        repo_path: Optional[Path] = None,
+        timeout_sec: int = 300,
+    ) -> LLMResponse:
+        start_time = time.time()
+
+        cmd = [
+            "opencode",
+            "run",
+            "--model",
+            self.model,
+            "--format",
+            "json",
+        ]
+
+        if repo_path:
+            cmd.extend(["--dir", str(repo_path)])
+
+        full_prompt = prompt
+        if system_prompt:
+            full_prompt = f"{system_prompt}\n\n---\n\n{prompt}"
+
+        cmd.append(full_prompt)
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout_sec,
+            )
+
+            duration = time.time() - start_time
+
+            if result.returncode != 0:
+                return LLMResponse(
+                    content=f"Error: {result.stderr}",
+                    model=self.model,
+                    provider=self.name,
+                    duration_sec=duration,
+                )
+
+            try:
+                lines = result.stdout.strip().split("\n")
+                text_parts = []
+                for line in lines:
+                    try:
+                        data = json.loads(line)
+                        if data.get("type") == "text":
+                            part = data.get("part", {})
+                            if isinstance(part, dict) and "text" in part:
+                                text_parts.append(part.get("text", ""))
+                            elif "text" in data:
+                                text_parts.append(data.get("text", ""))
+                    except json.JSONDecodeError:
+                        continue
+                if text_parts:
+                    content = "\n".join(text_parts)
+                else:
+                    content = result.stdout
+            except Exception:
+                content = result.stdout
+
+            return LLMResponse(
+                content=content,
+                model=self.model,
+                provider=self.name,
+                duration_sec=duration,
+            )
+
+        except subprocess.TimeoutExpired:
+            return LLMResponse(
+                content=f"Timeout after {timeout_sec} seconds",
+                model=self.model,
+                provider=self.name,
+                duration_sec=timeout_sec,
+            )
+
+    def _extract_content(self, response_data) -> str:
+        return ""

agent_toolkit/swarm/__init__.py

@@ -0,0 +1,5 @@
+"""Swarm package init."""
+
+from .models import API_VERSION, KIND
+
+__all__ = ["API_VERSION", "KIND"]

agent_toolkit/swarm/approvals.py

@@ -0,0 +1,121 @@
+"""Swarm approvals — gates for plan, architecture, cost, final."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .store import append_trace, atomic_write_json, now_ts
+
+GATE_DESCRIPTIONS = {
+    "plan": "Plan approval: review task contract, acceptance criteria, risk assessment before implementation.",
+    "architecture": "Architecture decision approval: public contract changes or migration requires human decision.",
+    "cost_escalation": "Cost escalation approval: raising budget or switching to expensive model requires approval.",
+    "final": "Final integration approval: changes must be approved before base-branch merge.",
+}
+
+
+def default_gates_for_recipe(recipe: dict[str, Any]) -> list[dict[str, Any]]:
+    spec = recipe.get("spec", {}) if isinstance(recipe, dict) else {}
+    gates_cfg = spec.get("gates", {}) if isinstance(spec.get("gates"), dict) else {}
+    gates: list[dict[str, Any]] = []
+    if gates_cfg.get("require_plan_approval"):
+        gates.append(
+            {
+                "id": "plan",
+                "description": GATE_DESCRIPTIONS["plan"],
+                "required": True,
+                "approved": False,
+            }
+        )
+    # architecture gate is on-demand, not default
+    # cost gate is on-demand
+    if gates_cfg.get("require_final_approval", True):
+        gates.append(
+            {
+                "id": "final",
+                "description": GATE_DESCRIPTIONS["final"],
+                "required": True,
+                "approved": False,
+            }
+        )
+    return gates
+
+
+def approvals_path(run_dir: Path) -> Path:
+    return run_dir / "approvals.json"
+
+
+def load_approvals(run_dir: Path) -> list[dict[str, Any]]:
+    p = approvals_path(run_dir)
+    if not p.is_file():
+        return []
+    try:
+        data = json.loads(p.read_text(encoding="utf-8"))
+        if isinstance(data, list):
+            return data
+        if isinstance(data, dict) and "gates" in data:
+            return data["gates"]  # type: ignore
+        return []
+    except Exception:
+        return []
+
+
+def save_approvals(run_dir: Path, gates: list[dict[str, Any]]) -> None:
+    atomic_write_json(approvals_path(run_dir), gates)
+
+
+def request_approval(run_dir: Path, gate_id: str, description: str | None = None) -> dict[str, Any]:
+    gates = load_approvals(run_dir)
+    for g in gates:
+        if g.get("id") == gate_id:
+            return g
+    gate = {
+        "id": gate_id,
+        "description": description or GATE_DESCRIPTIONS.get(gate_id, gate_id),
+        "required": True,
+        "approved": False,
+        "requested_at": now_ts(),
+    }
+    gates.append(gate)
+    save_approvals(run_dir, gates)
+    append_trace(run_dir, {"ts": now_ts(), "kind": "approval_requested", "gate": gate_id})
+    return gate
+
+
+def approve_gate(run_dir: Path, gate_id: str) -> dict[str, Any] | None:
+    gates = load_approvals(run_dir)
+    for g in gates:
+        if g.get("id") == gate_id:
+            g["approved"] = True
+            g["approved_at"] = now_ts()
+            save_approvals(run_dir, gates)
+            append_trace(run_dir, {"ts": now_ts(), "kind": "approval_granted", "gate": gate_id})
+            return g
+    return None
+
+
+def reject_gate(run_dir: Path, gate_id: str, reason: str) -> dict[str, Any] | None:
+    gates = load_approvals(run_dir)
+    for g in gates:
+        if g.get("id") == gate_id:
+            g["approved"] = False
+            g["rejected"] = True
+            g["reason"] = reason
+            g["rejected_at"] = now_ts()
+            save_approvals(run_dir, gates)
+            append_trace(
+                run_dir,
+                {"ts": now_ts(), "kind": "approval_rejected", "gate": gate_id, "reason": reason},
+            )
+            return g
+    return None
+
+
+def all_required_approved(run_dir: Path) -> bool:
+    gates = load_approvals(run_dir)
+    for g in gates:
+        if g.get("required") and not g.get("approved"):
+            return False
+    return True