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

agent/tools/registry.py

@@ -0,0 +1,219 @@
+"""
+agent/tools/registry.py
+───────────────────────
+ToolRegistry and PermissionGuard.
+
+Improvements:
+  - PermissionGuard: session-level "allow all" whitelist so the model
+    isn't interrupted on every destructive call after first approval
+  - ToolRegistry: accepts RepoContext and passes it to fs tools
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Awaitable, Callable
+
+from agent.tools.base import BaseTool, ToolResult
+from agent.tools.search_code import SearchCodeTool
+
+from agent.tools.shell import RunBashTool
+from agent.tools.a2a import A2ATool
+from agent.tools.web_search import WebSearchTool
+
+from agent.tools.git_ops import GitStatusTool, GitCommitTool
+from agent.tools.doc_gen import DocGenTool
+from agent.tools.diagram import DiagramTool
+from agent.ui import UI
+
+if TYPE_CHECKING:
+    from agent.config import Config
+    from agent.context import RepoContext
+
+
+class PermissionGuard:
+    """
+    Intercepts calls to destructive tools and prompts the user.
+
+    Three response modes:
+      y / Enter  → allow this one call
+      a          → allow all remaining calls this session (whitelist)
+      n          → deny this call
+
+    In --no-confirm mode all calls are allowed without prompting.
+    """
+
+    def __init__(self, no_confirm: bool = False) -> None:
+        self.no_confirm = no_confirm
+        self._allow_all = False          # set to True when user types 'a'
+        self._whitelisted: set[str] = set()  # per-tool whitelist (future extension)
+
+    def allow_all_for_session(self) -> None:
+        """Programmatically grant session-wide permission (used by tests / CI)."""
+        self._allow_all = True
+
+    async def check(self, tool_name: str, tool_input: dict[str, Any]) -> bool:
+        if self.no_confirm or self._allow_all:
+            return True
+
+        # Build a human-readable preview
+        preview_lines: list[str] = []
+        if tool_name == "write_file":
+            preview_lines.append(f"Write to: {tool_input.get('path', '?')}")
+        elif tool_name == "edit_file":
+            preview_lines.append(f"Edit file: {tool_input.get('path', '?')}")
+        elif tool_name == "run_bash":
+            preview_lines.append(f"Run: {tool_input.get('command', '?')}")
+        elif tool_name == "git_commit":
+            preview_lines.append(
+                f"Git Commit: {tool_input.get('message', '')}\n  Files: {', '.join(tool_input.get('paths', []))}"
+            )
+        else:
+            for k, v in tool_input.items():
+                preview_lines.append(f"  {k}: {v}")
+
+        choice = await UI.ask_permission(tool_name, preview_lines)
+
+        if choice in ("y", "yes", ""):
+            return True
+        if choice in ("a", "all"):
+            self._allow_all = True
+            UI.print_info("Permission granted for all remaining operations this session.")
+            return True
+        if choice in ("n", "no"):
+            return False
+        
+        return False
+
+
+@dataclass
+class ToolRegistry:
+    """
+    Unified store of tool schemas and executors.
+    Manages both built-in OOP tools and dynamic MCP/A2A tools.
+    """
+
+    _config: "Config"
+    _context: "RepoContext | None" = field(default=None)
+    _tools: dict[str, BaseTool] = field(default_factory=dict)
+    _mcp_schemas: list[dict[str, Any]] = field(default_factory=list)
+    _mcp_executors: dict[str, Callable[[dict[str, Any]], Awaitable[ToolResult]]] = field(
+        default_factory=dict
+    )
+    _guard: PermissionGuard = field(init=False)
+
+    def __post_init__(self) -> None:
+        self._guard = PermissionGuard(no_confirm=self._config.no_confirm)
+        self._register_builtins()
+
+    def _register_builtins(self) -> None:
+        """Register all default native tools."""
+        # Import here to avoid circular imports at module load time
+        from agent.tools.fs import ListFilesTool, ReadFileTool, WriteFileTool, EditFileTool
+
+        tools: list[BaseTool] = [
+            ReadFileTool(self._config, self._context),
+            WriteFileTool(self._config, self._context),
+            EditFileTool(self._config, self._context),
+            ListFilesTool(self._config, self._context),
+            RunBashTool(self._config),
+            SearchCodeTool(self._config),
+
+            GitStatusTool(self._config),
+            GitCommitTool(self._config),
+            DocGenTool(self._config),
+            DiagramTool(self._config),
+        ]
+
+        if self._config.web_search_enabled:
+            tools.append(WebSearchTool(self._config))
+
+
+        if self._config.a2a_enabled:
+            tools.append(A2ATool(self._config))
+
+        for t in tools:
+            self._tools[t.name] = t
+
+    # ── Tool management ───────────────────────────────────────────────────────
+
+    def register_tool(self, tool: BaseTool) -> None:
+        self._tools[tool.name] = tool
+
+    # ── Schema access ─────────────────────────────────────────────────────────
+
+    @property
+    def schemas(self) -> list[dict[str, Any]]:
+        seen_names = set()
+        final_schemas = []
+
+        # Add native tools first (they take precedence)
+        for t in self._tools.values():
+            if t.schema.name not in seen_names:
+                final_schemas.append({
+                    "name": t.schema.name,
+                    "description": t.schema.description,
+                    "input_schema": t.schema.parameters,
+                })
+                seen_names.add(t.schema.name)
+        
+        # Add MCP tools if they don't collide
+        for s in self._mcp_schemas:
+            if s["name"] not in seen_names:
+                final_schemas.append({
+                    "name": s["name"],
+                    "description": s["description"],
+                    "input_schema": s["input_schema"],
+                })
+                seen_names.add(s["name"])
+                
+        return final_schemas
+
+    def has_tool(self, name: str) -> bool:
+        return name in self._tools or name in self._mcp_executors
+
+    # ── Execution ─────────────────────────────────────────────────────────────
+
+    async def execute(self, tool_name: str, tool_input: dict[str, Any]) -> ToolResult:
+        if not self.has_tool(tool_name):
+            available = list(self._tools.keys()) + list(self._mcp_executors.keys())
+            return ToolResult(
+                f"Error: Unknown tool '{tool_name}'. Available: {', '.join(available)}",
+                is_error=True,
+            )
+
+        is_destructive = (
+            self._tools[tool_name].is_destructive
+            if tool_name in self._tools
+            else False
+        )
+
+        if is_destructive:
+            allowed = await self._guard.check(tool_name, tool_input)
+            if not allowed:
+                return ToolResult(f"Operation cancelled by user: {tool_name}", is_error=False)
+
+        try:
+            if tool_name in self._tools:
+                return await self._tools[tool_name].execute(**tool_input)
+            else:
+                return await self._mcp_executors[tool_name](tool_input)
+        except Exception as e:
+            return ToolResult(f"Unexpected error in {tool_name}: {e}", is_error=True)
+
+    # ── MCP extension ─────────────────────────────────────────────────────────
+
+    def register_mcp_tool(
+        self,
+        schema: dict[str, Any],
+        executor: Callable[[dict[str, Any]], Awaitable[ToolResult]],
+    ) -> None:
+        name: str = schema["name"]
+        self._mcp_schemas.append(schema)
+        self._mcp_executors[name] = executor
+
+    def deregister_mcp_tools(self, server_id: str) -> None:
+        to_remove = [s["name"] for s in self._mcp_schemas if s.get("_mcp_server_id") == server_id]
+        self._mcp_schemas = [s for s in self._mcp_schemas if s.get("_mcp_server_id") != server_id]
+        for name in to_remove:
+            self._mcp_executors.pop(name, None)

agent/tools/search_code.py

@@ -0,0 +1,120 @@
+"""
+agent/tools/search_code.py
+──────────────────────────
+Code search tool — search_code.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from agent.tools.base import BaseTool, ToolResult, ToolSchema
+
+if TYPE_CHECKING:
+    from agent.config import Config
+
+
+class SearchCodeTool(BaseTool):
+    """Search for patterns across files in the working directory."""
+
+    def __init__(self, config: "Config") -> None:
+        self._config = config
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="search_code",
+            description=(
+                "Search for a pattern (regex supported) across files in the project. "
+                "Returns matching lines with file paths and line numbers. "
+                "Use this to find function definitions, usages, imports, etc."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "pattern": {
+                        "type": "string",
+                        "description": "Regex or literal pattern to search for.",
+                    },
+                    "file_pattern": {
+                        "type": "string",
+                        "description": "Glob pattern to filter files (e.g. '*.py', '*.ts').",
+                    },
+                    "context_lines": {
+                        "type": "integer",
+                        "description": "Lines of context around each match (default: 2).",
+                        "default": 2,
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Maximum number of matches to return (default: 50).",
+                        "default": 50,
+                    },
+                },
+                "required": ["pattern"],
+            },
+            required=["pattern"],
+            sprint="Sprint 1",
+        )
+
+    async def execute(  # type: ignore[override]
+        self,
+        pattern: str,
+        file_pattern: str | None = None,
+        context_lines: int = 2,
+        max_results: int = 50,
+    ) -> ToolResult:
+        if not pattern:
+            return ToolResult("Error: 'pattern' parameter is required.", is_error=True)
+
+        search_path = Path(self._config.workdir)
+        glob = file_pattern or "*.*"
+
+        try:
+            # Use ripgrep if available
+            rg_cmd = ["rg", "--no-heading", "--line-number", f"-C{context_lines}"]
+            if file_pattern:
+                rg_cmd.extend(["-g", file_pattern])
+            rg_cmd.extend([pattern, str(search_path)])
+
+            rg_result = subprocess.run(
+                rg_cmd,
+                capture_output=True,
+                text=True,
+                timeout=15,
+                encoding="utf-8",
+                errors="replace",
+            )
+            if rg_result.returncode in (0, 1):   # 0=matches found, 1=no matches
+                output = rg_result.stdout.strip() or f"No matches for '{pattern}'."
+                # Optionally cap output
+                lines = output.splitlines()
+                if len(lines) > max_results * (context_lines * 2 + 1):
+                    output = "\n".join(lines[:max_results * (context_lines * 2 + 1)]) + "\n... (truncated)"
+                return ToolResult(output, is_error=False)
+        except (FileNotFoundError, OSError):
+            pass  # ripgrep not available, fall back
+
+        # Pure-Python fallback: glob + line scan (simple, no context)
+        matches: list[str] = []
+        for file_path in sorted(search_path.rglob(glob)):
+            if not file_path.is_file():
+                continue
+            try:
+                lines = file_path.read_text(encoding="utf-8", errors="replace").splitlines()
+                for i, line in enumerate(lines, start=1):
+                    if pattern.lower() in line.lower():
+                        matches.append(f"{file_path}:{i}: {line.rstrip()}")
+            except OSError:
+                continue
+
+        if not matches:
+            return ToolResult(f"No matches for '{pattern}' in {search_path}.", is_error=False)
+
+        output = "\n".join(matches[:max_results])
+        if len(matches) > max_results:
+            output += f"\n... (truncated {len(matches) - max_results} more matches)"
+            
+        return ToolResult(output, is_error=False)

agent/tools/shell.py

@@ -0,0 +1,118 @@
+"""
+agent/tools/shell.py
+────────────────────
+Shell tool — run_bash.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+from typing import TYPE_CHECKING, Any
+
+from agent.tools.base import BaseTool, ToolResult, ToolSchema
+
+if TYPE_CHECKING:
+    from agent.config import Config
+
+
+_IS_WINDOWS = sys.platform == "win32"
+_DEFAULT_SHELL = os.getenv(
+    "DEVPILOT_SHELL",
+    "powershell.exe" if _IS_WINDOWS else "/bin/bash",
+)
+_SHELL_FLAG = "-Command" if _IS_WINDOWS else "-c"
+
+# Commands that are always blocked regardless of --no-confirm
+_BLOCKED_COMMANDS = frozenset([
+    "rm -rf /",
+    "dd if=/dev/zero",
+    ":(){:|:&};:",   # Fork bomb
+])
+
+
+class RunBashTool(BaseTool):
+    """Execute a bash command in the working directory."""
+
+    def __init__(self, config: "Config") -> None:
+        self._config = config
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="run_bash",
+            description=(
+                "Execute a bash command in the project's working directory. "
+                "Use for running tests, builds, package installs, linters, etc. "
+                "Always shown to the user before execution."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "command": {
+                        "type": "string",
+                        "description": "Bash command to execute.",
+                    },
+                    "timeout": {
+                        "type": "integer",
+                        "description": "Timeout in seconds (default: 60).",
+                        "default": 60,
+                    },
+                },
+                "required": ["command"],
+            },
+            required=["command"],
+            is_destructive=True,
+            sprint="Sprint 1",
+        )
+
+    async def execute(self, command: str, timeout: int = 60) -> ToolResult:  # type: ignore[override]
+        if not command:
+            return ToolResult("Error: 'command' parameter is required.", is_error=True)
+
+        if any(b in command for b in _BLOCKED_COMMANDS):
+            return ToolResult(f"Error: Command contains blocked patterns.", is_error=True)
+
+        try:
+            # Use asyncio subprocess to avoid blocking the event loop
+            process = await asyncio.create_subprocess_exec(
+                _DEFAULT_SHELL,
+                _SHELL_FLAG,
+                command,
+                cwd=self._config.workdir,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+            try:
+                stdout_bytes, stderr_bytes = await asyncio.wait_for(
+                    process.communicate(), timeout=timeout
+                )
+            except asyncio.TimeoutError:
+                try:
+                    process.kill()
+                    await process.communicate()
+                except ProcessLookupError:
+                    pass
+                return ToolResult(
+                    f"Error: Command timed out after {timeout}s: {command}", is_error=True
+                )
+
+            stdout = stdout_bytes.decode("utf-8", errors="replace")
+            stderr = stderr_bytes.decode("utf-8", errors="replace")
+
+            output_parts: list[str] = []
+            if stdout.strip():
+                output_parts.append(f"stdout:\n{stdout.rstrip()}")
+            if stderr.strip():
+                output_parts.append(f"stderr:\n{stderr.rstrip()}")
+
+            output_parts.append(f"exit code: {process.returncode}")
+            output = "\n\n".join(output_parts) if output_parts else "(no output)"
+            is_error = process.returncode != 0
+            
+            return ToolResult(output, is_error=is_error)
+
+        except Exception as e:
+            return ToolResult(f"Error executing command: {e}", is_error=True)

agent/tools/web_search.py

@@ -0,0 +1,105 @@
+"""
+agent/tools/web_search.py
+─────────────────────────
+Web search tool using Tavily API.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any
+
+from agent.tools.base import BaseTool, ToolResult, ToolSchema
+
+if TYPE_CHECKING:
+    from agent.config import Config
+
+
+class WebSearchTool(BaseTool):
+    """Search the web for current information using the Tavily API."""
+
+    def __init__(self, config: "Config") -> None:
+        self._config = config
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="web_search",
+            description=(
+                "Search the web for current information. Use when you need up-to-date "
+                "documentation, library versions, recent news, or anything not in your "
+                "training data. Returns a concise summary with source URLs."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query.",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Max number of results to return (default: 5).",
+                        "default": 5,
+                    },
+                    "include_raw_content": {
+                        "type": "boolean",
+                        "description": "If true, include raw page content for deeper analysis.",
+                        "default": False,
+                    },
+                },
+                "required": ["query"],
+            },
+            required=["query"],
+            sprint="Sprint 2",
+        )
+
+    async def execute(  # type: ignore[override]
+        self,
+        query: str,
+        max_results: int = 5,
+        include_raw_content: bool = False,
+    ) -> ToolResult:
+        if not query:
+            return ToolResult("Error: 'query' parameter is required.", is_error=True)
+
+        api_key = os.getenv("TAVILY_API_KEY")
+        if not api_key:
+            return ToolResult(
+                "Error: TAVILY_API_KEY environment variable is not set. "
+                "Get a free key at https://tavily.com and add it to your .env.",
+                is_error=True,
+            )
+
+        try:
+            from tavily import TavilyClient  # type: ignore[import]
+            client = TavilyClient(api_key=api_key)
+
+            response = client.search(
+                query=query,
+                max_results=max_results,
+                include_raw_content=include_raw_content,
+            )
+
+            results = response.get("results", [])
+            if not results:
+                return ToolResult(f"No web results found for: {query}", is_error=False)
+
+            lines: list[str] = [f"Web search results for: {query}\n"]
+            for i, r in enumerate(results, 1):
+                lines.append(f"[{i}] {r.get('title', 'Untitled')}")
+                lines.append(f"    URL: {r.get('url', '')}")
+                lines.append(f"    {r.get('content', '').strip()[:400]}")
+                if include_raw_content and r.get("raw_content"):
+                    lines.append(f"\n    Full content:\n{r['raw_content'][:2000]}")
+                lines.append("")
+
+            return ToolResult("\n".join(lines), is_error=False)
+
+        except ImportError:
+            return ToolResult(
+                "Error: tavily-python is not installed. Run: pip install tavily-python",
+                is_error=True,
+            )
+        except Exception as e:
+            return ToolResult(f"Web search error: {e}", is_error=True)

agent/tui/__init__.py

@@ -0,0 +1,3 @@
+"""
+DevPilot Textual UI Package.
+"""