devpilot-agentic-cli 1.0.0__py3-none-any.whl

agent/config.py

@@ -0,0 +1,232 @@
+"""
+agent/config.py
+───────────────
+Central configuration for DevPilot.
+
+All settings are read from environment variables (or a .env file).
+API keys are NEVER hardcoded. Missing keys raise a clear ConfigError
+so the user knows exactly what to set before running.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal
+
+from dotenv import load_dotenv
+
+# ── Load .env file if present (safe to call even if file is missing) ─────────
+load_dotenv(dotenv_path=Path(__file__).resolve().parent.parent / ".env", override=False)
+
+
+# ── Custom exception ─────────────────────────────────────────────────────────
+
+class ConfigError(Exception):
+    """Raised when required configuration is missing or invalid."""
+
+
+# ── Supported providers ───────────────────────────────────────────────────────
+
+Provider = Literal["anthropic", "openai"]
+
+PROVIDER_DEFAULTS: dict[str, str] = {
+    "anthropic": "claude-opus-4-5",
+    "openai": "gpt-4o",
+}
+
+# Keys required per provider (checked lazily so we can build/test without keys)
+REQUIRED_ENV_KEYS: dict[str, str] = {
+    "anthropic": "ANTHROPIC_API_KEY",
+    "openai": "OPENAI_API_KEY",
+}
+
+# Models that support extended thinking (Anthropic only)
+THINKING_CAPABLE_MODELS: set[str] = {
+    "claude-3-7-sonnet-20250219",
+    "claude-3-5-sonnet-20241022",
+    "claude-opus-4-5",
+    "claude-opus-4-20250514",
+}
+
+
+# ── Config dataclass ──────────────────────────────────────────────────────────
+
+@dataclass
+class Config:
+    # Provider + model
+    provider: Provider
+    model: str
+    base_url: str | None          # Custom endpoint for Ollama / local models
+
+    # Agentic loop
+    max_iterations: int
+
+    # Safety
+    no_confirm: bool
+
+    # A2A server
+    a2a_port: int
+    a2a_token: str | None
+
+    # Workspace
+    workdir: str
+
+    # Extended thinking (Anthropic Claude only)
+    extended_thinking: bool
+    thinking_budget: int
+
+    # Feature flags
+    web_search_enabled: bool
+    memory_enabled: bool
+    a2a_enabled: bool
+
+    # Sessions
+    sessions_dir: Path
+
+    # ── Derived properties ────────────────────────────────────────────────────
+
+    @property
+    def anthropic_api_key(self) -> str | None:
+        return os.getenv("ANTHROPIC_API_KEY")
+
+    @property
+    def openai_api_key(self) -> str | None:
+        return os.getenv("OPENAI_API_KEY")
+
+    @property
+    def active_api_key(self) -> str | None:
+        """Return the API key for the currently selected provider."""
+        if self.provider == "anthropic":
+            return self.anthropic_api_key
+        return self.openai_api_key
+
+    # ── Validation ────────────────────────────────────────────────────────────
+
+    def validate_api_key(self) -> None:
+        """
+        Raises ConfigError if the active provider's API key is missing.
+        Call this right before making the first API request — not at startup —
+        so users can explore/test without a key.
+        """
+        key_name = REQUIRED_ENV_KEYS[self.provider]
+        if not self.active_api_key:
+            raise ConfigError(
+                f"\n[DevPilot] Missing API key for provider '{self.provider}'.\n"
+                f"  → Set the environment variable: {key_name}\n"
+                f"  → Or add it to your .env file (copy .env.example to .env).\n"
+                f"  → Get an Anthropic key at: https://console.anthropic.com/\n"
+            )
+        
+        if self.extended_thinking:
+            if self.provider != "anthropic":
+                raise ConfigError("Extended thinking is only supported with the Anthropic provider.")
+            if self.thinking_budget < 1000:
+                raise ConfigError("thinking_budget must be >= 1000 tokens.")
+            # Note: We don't strictly enforce model names since API evolves, but it's good to check
+            if not any(self.model.startswith(m) for m in ["claude-3", "claude-opus"]):
+                pass  # We'll let the API reject it if it's really unsupported
+
+    # ── Factory ───────────────────────────────────────────────────────────────
+
+    @classmethod
+    def load(cls) -> "Config":
+        """
+        Load configuration from environment variables.
+        Raises ConfigError for invalid (not missing) values.
+        """
+        # ── Provider ────────────────────────────────────────────────────
+        provider_raw = os.getenv("DEVPILOT_PROVIDER", "anthropic").lower()
+        if provider_raw not in ("anthropic", "openai"):
+            raise ConfigError(
+                f"Invalid DEVPILOT_PROVIDER='{provider_raw}'. "
+                "Must be 'anthropic' or 'openai'."
+            )
+        provider: Provider = provider_raw  # type: ignore[assignment]
+
+        # ── Model ───────────────────────────────────────────────────────
+        model = os.getenv("DEVPILOT_MODEL") or PROVIDER_DEFAULTS[provider]
+
+        # ── Base URL ────────────────────────────────────────────────────
+        base_url = os.getenv("DEVPILOT_BASE_URL") or None
+
+        # ── Max iterations ───────────────────────────────────────────────
+        try:
+            max_iterations = int(os.getenv("DEVPILOT_MAX_ITERATIONS", "50"))
+            if max_iterations < 1:
+                raise ValueError
+        except ValueError:
+            raise ConfigError(
+                "DEVPILOT_MAX_ITERATIONS must be a positive integer."
+            )
+
+        # ── No-confirm flag ─────────────────────────────────────────────
+        no_confirm_raw = os.getenv("DEVPILOT_NO_CONFIRM", "false").lower()
+        no_confirm = no_confirm_raw in ("true", "1", "yes")
+
+        # ── A2A port ────────────────────────────────────────────────────
+        try:
+            a2a_port = int(os.getenv("DEVPILOT_A2A_PORT", "8000"))
+        except ValueError:
+            raise ConfigError("DEVPILOT_A2A_PORT must be an integer.")
+
+        # ── A2A token ───────────────────────────────────────────────────
+        a2a_token = os.getenv("DEVPILOT_A2A_TOKEN") or None
+
+        # ── Workspace ───────────────────────────────────────────────────
+        workdir = os.getenv("DEVPILOT_WORKDIR", os.getcwd())
+
+        # ── Extended thinking ───────────────────────────────────────────
+        extended_thinking = os.getenv("DEVPILOT_THINKING", "false").lower() in ("true", "1", "yes")
+        try:
+            thinking_budget = int(os.getenv("DEVPILOT_THINKING_BUDGET", "10000"))
+        except ValueError:
+            raise ConfigError("DEVPILOT_THINKING_BUDGET must be an integer.")
+
+        # ── Feature flags ───────────────────────────────────────────────
+        web_search_enabled = os.getenv("DEVPILOT_NO_WEB_SEARCH", "false").lower() not in ("true", "1", "yes")
+        memory_enabled = os.getenv("DEVPILOT_NO_MEMORY", "false").lower() not in ("true", "1", "yes")
+        a2a_enabled = os.getenv("DEVPILOT_NO_A2A", "false").lower() not in ("true", "1", "yes")
+
+        # ── Sessions dir ────────────────────────────────────────────────
+        sessions_dir = Path(
+            os.getenv("DEVPILOT_SESSIONS_DIR", ".devpilot_sessions")
+        )
+
+        return cls(
+            provider=provider,
+            model=model,
+            base_url=base_url,
+            max_iterations=max_iterations,
+            no_confirm=no_confirm,
+            a2a_port=a2a_port,
+            a2a_token=a2a_token,
+            workdir=workdir,
+            extended_thinking=extended_thinking,
+            thinking_budget=thinking_budget,
+            web_search_enabled=web_search_enabled,
+            memory_enabled=memory_enabled,
+            a2a_enabled=a2a_enabled,
+            sessions_dir=sessions_dir,
+        )
+
+    # ── Display ───────────────────────────────────────────────────────────────
+
+    def __str__(self) -> str:
+        key_status = "✓ present" if self.active_api_key else "✗ MISSING"
+        return (
+            f"DevPilot Config\n"
+            f"  provider      : {self.provider}\n"
+            f"  model         : {self.model}\n"
+            f"  base_url      : {self.base_url or '(default)'}\n"
+            f"  max_iterations: {self.max_iterations}\n"
+            f"  no_confirm    : {self.no_confirm}\n"
+            f"  a2a_port      : {self.a2a_port}\n"
+            f"  thinking      : {self.extended_thinking} (budget: {self.thinking_budget})\n"
+            f"  web_search    : {self.web_search_enabled}\n"
+            f"  memory        : {self.memory_enabled}\n"
+            f"  a2a           : {self.a2a_enabled}\n"
+            f"  api_key       : {key_status}\n"
+            f"  sessions_dir  : {self.sessions_dir}\n"
+        )

agent/context.py

@@ -0,0 +1,182 @@
+"""
+agent/context.py
+────────────────
+RepoContext — tracks which files the model has read this session,
+their content hashes, and the repo structure snapshot.
+
+Injected into every system prompt so the model always knows:
+  - What it has already read (no redundant re-reads)
+  - Whether a file has changed since it last read it
+  - The top-level directory structure of the project
+"""
+
+from __future__ import annotations
+
+import hashlib
+import ast
+from pathlib import Path
+
+
+
+
+class RepoContext:
+    """
+    Lightweight repo awareness tracker.
+
+    The loop calls record_read() after every successful read_file call.
+    WriteFileTool calls record_write() after every successful write.
+    build_context_block() returns a compact text block injected into
+    the system prompt at the start of every chat() call.
+    """
+
+    def __init__(self, workdir: str) -> None:
+        self._workdir = Path(workdir).resolve()
+        # path (relative str) -> content hash at last read
+        self._read_files: dict[str, str] = {}
+        # path (relative str) -> content hash at write time
+        self._written_files: dict[str, str] = {}
+
+
+    # ── Recording ─────────────────────────────────────────────────────────────
+
+    def record_read(self, path: str, content: str) -> None:
+        """Called by ReadFileTool after a successful read."""
+        rel = self._rel(path)
+        self._read_files[rel] = self._hash(content)
+
+    def record_write(self, path: str, content: str) -> None:
+        """Called by WriteFileTool after a successful write."""
+        rel = self._rel(path)
+        self._written_files[rel] = self._hash(content)
+        # Also update read cache so model knows current on-disk state
+        self._read_files[rel] = self._hash(content)
+
+
+    # ── Stale detection ───────────────────────────────────────────────────────
+
+    def is_stale(self, path: str) -> bool:
+        """
+        Returns True if the file on disk has changed since last read.
+        Used to hint the model it should re-read before writing.
+        """
+        rel = self._rel(path)
+        if rel not in self._read_files:
+            return False
+        try:
+            full = self._workdir / rel
+            current = self._hash(full.read_text(encoding="utf-8", errors="replace"))
+            return current != self._read_files[rel]
+        except OSError:
+            return False
+
+    # ── Context block for system prompt ──────────────────────────────────────
+
+    def build_context_block(self) -> str:
+        """
+        Returns a compact text block describing current repo awareness.
+        Injected into the system prompt on every chat() call.
+        """
+        lines: list[str] = []
+
+        if self._read_files:
+            lines.append("Files you have already read this session (do not re-read unless stale):")
+            for rel in sorted(self._read_files):
+                stale = self.is_stale(rel)
+                tag = "  ⚠ MODIFIED ON DISK — re-read before editing" if stale else ""
+                lines.append(f"  • {rel}{tag}")
+        else:
+            lines.append("You have not read any files yet this session.")
+
+        if self._written_files:
+            lines.append("\nFiles you have written this session:")
+            for rel in sorted(self._written_files):
+                lines.append(f"  • {rel}")
+
+        tree = self._build_project_tree()
+        if tree:
+            lines.append(f"\nProject root ({self._workdir.name}/):")
+            lines.extend(f"  {entry}" for entry in tree)
+
+        return "\n".join(lines)
+
+
+
+    # ── Helpers ───────────────────────────────────────────────────────────────
+
+    def _rel(self, path: str) -> str:
+        p = Path(path)
+        if p.is_absolute():
+            try:
+                return str(p.relative_to(self._workdir))
+            except ValueError:
+                return path
+        return str(p)
+
+    @staticmethod
+    def _hash(content: str) -> str:
+        return hashlib.md5(content.encode("utf-8", errors="replace")).hexdigest()
+
+    def _extract_signatures(self, path: Path) -> list[str]:
+        rel = self._rel(str(path))
+        if rel in self._read_files:
+            return []
+
+        sigs = []
+        try:
+            content = path.read_text(encoding="utf-8", errors="ignore")
+            if path.suffix == ".py":
+                tree = ast.parse(content)
+                for node in tree.body:
+                    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                        sigs.append(f"    def {node.name}(...)")
+                    elif isinstance(node, ast.ClassDef):
+                        sigs.append(f"    class {node.name}:")
+                        for sub_node in node.body:
+                            if isinstance(sub_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                                sigs.append(f"        def {sub_node.name}(...)")
+            elif path.suffix in (".js", ".ts"):
+                for line in content.splitlines():
+                    line = line.strip()
+                    if line.startswith("class ") or line.startswith("export class ") or \
+                       line.startswith("function ") or line.startswith("export function "):
+                        sigs.append(f"    {line}")
+        except Exception:
+            pass
+        return sigs
+
+    def _build_project_tree(self, max_entries: int = 200) -> list[str]:
+        entries: list[str] = []
+        ignores = {
+            ".git", "node_modules", ".venv", "__pycache__", "dist", 
+            "build", ".next", ".tox", "coverage_html_report", ".devpilot_sessions"
+        }
+
+        def _traverse(directory: Path, prefix: str = "") -> None:
+            if len(entries) >= max_entries:
+                return
+
+            try:
+                for item in sorted(directory.iterdir()):
+                    if item.name.startswith(".") and item.name not in (".env", ".gitignore", ".github"):
+                        continue
+                    if item.name in ignores or item.name.endswith(".egg-info"):
+                        continue
+
+                    if item.is_dir():
+                        entries.append(f"{prefix}📁 {item.name}/")
+                        _traverse(item, prefix + "  ")
+                    else:
+                        entries.append(f"{prefix}📄 {item.name}")
+                        if item.suffix in (".py", ".js", ".ts"):
+                            sigs = self._extract_signatures(item)
+                            for sig in sigs:
+                                entries.append(f"{prefix}{sig}")
+
+                    if len(entries) >= max_entries:
+                        entries.append("… (truncated to ~200 items for context size)")
+                        break
+            except OSError:
+                pass
+
+        _traverse(self._workdir)
+        return entries

agent/history.py

@@ -0,0 +1,172 @@
+"""
+agent/history.py
+────────────────
+Manages the conversation history and context window.
+
+Improvements over original blunt character-count truncation:
+  - Smart pruning: large bash/tool outputs are SUMMARISED in place rather
+    than the whole message being dropped. The model retains awareness of
+    what ran and what happened, just with a shorter representation.
+  - Tool results over TOOL_RESULT_TRIM_CHARS are replaced with a one-line
+    summary: "[output truncated — N lines, exit code X]"
+  - When overall history still exceeds the limit after trimming, oldest
+    user↔assistant pairs are dropped (never orphaning tool_use blocks).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+# Overall hard limit in characters (~400k chars ≈ 100k tokens)
+_MAX_CHARS = 100_000 * 4
+
+# Individual tool result outputs larger than this get summarised in-place
+# before they're ever stored (≈4k tokens — enough for most command output)
+_TOOL_RESULT_TRIM_CHARS = 16_000
+
+
+def _summarise_tool_result_message(msg: dict[str, Any]) -> dict[str, Any]:
+    """
+    Replace oversized tool_result content blocks with a compact summary.
+    Returns a new message dict; the original is not mutated.
+    """
+    if msg.get("role") != "user":
+        return msg
+    content = msg.get("content")
+    if not isinstance(content, list):
+        return msg
+
+    new_blocks: list[dict[str, Any]] = []
+    changed = False
+    for block in content:
+        if (
+            isinstance(block, dict)
+            and block.get("type") == "tool_result"
+            and isinstance(block.get("content"), str)
+            and len(block["content"]) > _TOOL_RESULT_TRIM_CHARS
+        ):
+            raw: str = block["content"]
+            lines = raw.splitlines()
+            # Extract exit code if present (run_bash format)
+            exit_code_line = next(
+                (ln for ln in reversed(lines) if ln.startswith("exit code:")), None
+            )
+            exit_info = f", {exit_code_line}" if exit_code_line else ""
+            summary = (
+                f"[output trimmed — {len(lines)} lines, "
+                f"{len(raw):,} chars{exit_info}. "
+                f"First 20 lines:\n"
+                + "\n".join(lines[:20])
+                + ("\n…" if len(lines) > 20 else "")
+                + "]"
+            )
+            new_blocks.append({**block, "content": summary})
+            changed = True
+        else:
+            new_blocks.append(block)
+
+    return {**msg, "content": new_blocks} if changed else msg
+
+
+class HistoryManager:
+    """Stores the conversation history and manages session persistence."""
+
+    def __init__(self) -> None:
+        self._messages: list[dict[str, Any]] = []
+
+    def append(self, message: dict[str, Any]) -> None:
+        """Add a message to history, summarising large tool outputs first."""
+        self._messages.append(_summarise_tool_result_message(message))
+        self._truncate_if_needed()
+
+    def extend(self, messages: list[dict[str, Any]]) -> None:
+        for msg in messages:
+            self._messages.append(_summarise_tool_result_message(msg))
+        self._truncate_if_needed()
+
+    def get_messages(self) -> list[dict[str, Any]]:
+        return list(self._messages)
+
+    # ── Internal helpers ──────────────────────────────────────────────────────
+
+    def _is_tool_result(self, msg: dict[str, Any]) -> bool:
+        if msg.get("role") != "user":
+            return False
+        content = msg.get("content")
+        if isinstance(content, list):
+            return any(
+                isinstance(b, dict) and b.get("type") == "tool_result" for b in content
+            )
+        return False
+
+    def _is_tool_use(self, msg: dict[str, Any]) -> bool:
+        if msg.get("role") != "assistant":
+            return False
+        content = msg.get("content")
+        if isinstance(content, list):
+            return any(
+                isinstance(b, dict) and b.get("type") == "tool_use" for b in content
+            )
+        return False
+
+    def _truncate_if_needed(self) -> None:
+        """
+        Drop oldest complete exchange units until under _MAX_CHARS.
+
+        An exchange unit is one of:
+          • A plain user message
+          • An assistant message + its following tool_result user messages
+
+        We never drop a tool_use assistant message without also dropping
+        its paired tool_result messages, avoiding Anthropic 400 errors.
+        """
+        while True:
+            total = sum(len(json.dumps(m)) for m in self._messages)
+            if total <= _MAX_CHARS or len(self._messages) <= 2:
+                break
+
+            # Find the first droppable unit: a user message that is NOT a
+            # tool_result (those must go with their preceding assistant msg).
+            drop_end = 0
+            for i, msg in enumerate(self._messages):
+                if msg.get("role") == "user" and not self._is_tool_result(msg):
+                    drop_end = i + 1
+                    # Also drop the following assistant message + its tool results
+                    j = drop_end
+                    while j < len(self._messages):
+                        next_msg = self._messages[j]
+                        if next_msg.get("role") == "assistant":
+                            drop_end = j + 1
+                            j += 1
+                            # consume paired tool_results
+                            while j < len(self._messages) and self._is_tool_result(
+                                self._messages[j]
+                            ):
+                                drop_end = j + 1
+                                j += 1
+                        else:
+                            break
+                    break
+
+            if drop_end == 0:
+                # Fallback: drop the very first message
+                self._messages.pop(0)
+            else:
+                del self._messages[:drop_end]
+
+    # ── Persistence ───────────────────────────────────────────────────────────
+
+    def save(self, path: Path | str) -> None:
+        p = Path(path)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        with open(p, "w", encoding="utf-8") as f:
+            json.dump(self._messages, f, indent=2)
+
+    def load(self, path: Path | str) -> None:
+        p = Path(path)
+        if not p.exists():
+            return
+        with open(p, "r", encoding="utf-8") as f:
+            self._messages = json.load(f)

agent/loop.py

@@ -0,0 +1,102 @@
+"""
+agent/loop.py
+─────────────
+The core agentic loop.
+"""
+
+from __future__ import annotations
+
+from agent.config import Config
+from agent.history import HistoryManager
+from agent.providers.base import BaseProvider
+from agent.tools import ToolRegistry
+from agent.ui import UI
+
+
+async def run_agent_loop(
+    provider: BaseProvider,
+    registry: ToolRegistry,
+    history: HistoryManager,
+    config: Config,
+    max_iterations: int = 50,
+    context=None,
+) -> None:
+    """
+    Executes the agentic loop until the model stops returning tool_uses or
+    max_iterations is reached.
+
+    Uses chat_stream() by default so tokens are printed in real time.
+    Falls back transparently for providers/modes that don't support streaming
+    (e.g. extended thinking).
+    """
+    heal_attempts = 0
+
+    for iteration in range(max_iterations):
+        messages = history.get_messages()
+        tools = registry.schemas
+
+        from agent.providers.system_prompt import build_system_prompt
+        
+        system = build_system_prompt(
+            repo_context_block=context.build_context_block() if context else ""
+        )
+
+        try:
+            # chat_stream() prints text tokens live and returns the full response.
+            # For extended thinking or providers without streaming it falls back to chat().
+            response = await provider.chat_stream(messages, tools, system=system)
+        except Exception as e:
+            UI.print_error(f"Provider error: {e}")
+            break
+
+        # Append the assistant's message to history
+        history.append(response.assistant_message)
+
+        # UI: render extended thinking if present (Anthropic only; non-streaming path)
+        if response.thinking:
+            UI.print_thinking_block(response.thinking)
+
+        # UI: print assistant text only when NOT already streamed live.
+        if response.text and not response.streamed_text:
+            UI.print_assistant_message(response.text)
+
+        if not response.has_tool_uses:
+            # The model is done
+            break
+
+        should_break_outer = False
+
+        for tool_use in response.tool_uses:
+            UI.print_tool_call(tool_use.name, tool_use.input)
+
+            tool_result = await registry.execute(tool_use.name, tool_use.input)
+
+            UI.print_tool_result(tool_use.name, tool_result.output, tool_result.is_error)
+
+            # Format and append tool result message
+            tool_msg = provider.make_tool_result_message(
+                tool_use_id=tool_use.id,
+                content=tool_result.output,
+                is_error=tool_result.is_error,
+            )
+            history.append(tool_msg)
+            
+            if tool_result.is_error:
+                heal_attempts += 1
+                if heal_attempts >= 3:
+                    UI.print_error("Too many consecutive tool errors (>= 3). Aborting loop to prevent infinite retries.")
+                    should_break_outer = True
+                    break
+                # Inject explicit user prod to fix for this specific tool
+                history.append(provider.make_user_message(
+                    f"Tool '{tool_use.name}' failed with: {tool_result.output}\n"
+                    "Please analyze the error, fix the underlying issue, and retry."
+                ))
+            else:
+                heal_attempts = 0
+
+        if should_break_outer:
+            break
+
+    else:
+        UI.print_error(f"Max iterations ({max_iterations}) reached. Terminating loop.")