iac-code 0.1.0__py3-none-any.whl

iac_code/tasks/task_state.py

@@ -0,0 +1,66 @@
+"""Background task state management."""
+
+from __future__ import annotations
+
+import uuid
+from collections import OrderedDict
+from dataclasses import dataclass
+from enum import Enum
+
+
+class TaskStatus(str, Enum):
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    STOPPED = "stopped"
+
+
+@dataclass
+class TaskInfo:
+    id: str
+    description: str
+    agent_type: str = "general-purpose"
+    status: TaskStatus = TaskStatus.RUNNING
+    result: str | None = None
+    error: str | None = None
+    tool_use_count: int = 0
+    token_count: int = 0
+
+
+class TaskManager:
+    def __init__(self) -> None:
+        self._tasks: OrderedDict[str, TaskInfo] = OrderedDict()
+
+    def register(self, description: str, agent_type: str = "general-purpose") -> str:
+        task_id = str(uuid.uuid4())[:8]
+        self._tasks[task_id] = TaskInfo(id=task_id, description=description, agent_type=agent_type)
+        return task_id
+
+    def get(self, task_id: str) -> TaskInfo | None:
+        return self._tasks.get(task_id)
+
+    def complete(self, task_id: str, result: str) -> None:
+        task = self._tasks.get(task_id)
+        if task:
+            task.status = TaskStatus.COMPLETED
+            task.result = result
+
+    def fail(self, task_id: str, error: str) -> None:
+        task = self._tasks.get(task_id)
+        if task:
+            task.status = TaskStatus.FAILED
+            task.error = error
+
+    def stop(self, task_id: str) -> None:
+        task = self._tasks.get(task_id)
+        if task:
+            task.status = TaskStatus.STOPPED
+
+    def update_progress(self, task_id: str, tool_use_count: int = 0, token_count: int = 0) -> None:
+        task = self._tasks.get(task_id)
+        if task:
+            task.tool_use_count = tool_use_count
+            task.token_count = token_count
+
+    def list_all(self) -> list[TaskInfo]:
+        return list(self._tasks.values())

iac_code/tasks/task_tools.py

@@ -0,0 +1,114 @@
+"""Model-side task tools for managing background agents."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from iac_code.tasks.task_state import TaskManager
+from iac_code.tools.base import Tool, ToolContext, ToolResult
+
+
+class TaskListTool(Tool):
+    def __init__(self, task_manager: TaskManager):
+        self._manager = task_manager
+
+    @property
+    def name(self) -> str:
+        return "task_list"
+
+    @property
+    def description(self) -> str:
+        return "List all background tasks with their status."
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {"type": "object", "properties": {}}
+
+    async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        tasks = self._manager.list_all()
+        if not tasks:
+            return ToolResult.success("No background tasks.")
+        lines = []
+        for t in tasks:
+            lines.append(f"- [{t.id}] {t.status.value} | [{t.agent_type}] {t.description}")
+            if t.result:
+                lines.append(f"  Result: {t.result[:200]}")
+            if t.error:
+                lines.append(f"  Error: {t.error[:200]}")
+        return ToolResult.success("\n".join(lines))
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        return True
+
+
+class TaskGetTool(Tool):
+    def __init__(self, task_manager: TaskManager):
+        self._manager = task_manager
+
+    @property
+    def name(self) -> str:
+        return "task_get"
+
+    @property
+    def description(self) -> str:
+        return "Get details of a specific background task by ID."
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {"task_id": {"type": "string"}},
+            "required": ["task_id"],
+        }
+
+    async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        task = self._manager.get(tool_input["task_id"])
+        if not task:
+            return ToolResult.error(f"Task '{tool_input['task_id']}' not found.")
+        lines = [
+            f"ID: {task.id}",
+            f"Description: {task.description}",
+            f"Status: {task.status.value}",
+            f"Agent type: {task.agent_type}",
+            f"Tool uses: {task.tool_use_count}",
+            f"Tokens: {task.token_count}",
+        ]
+        if task.result:
+            lines.append(f"Result: {task.result}")
+        if task.error:
+            lines.append(f"Error: {task.error}")
+        return ToolResult.success("\n".join(lines))
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        return True
+
+
+class TaskStopTool(Tool):
+    def __init__(self, task_manager: TaskManager):
+        self._manager = task_manager
+
+    @property
+    def name(self) -> str:
+        return "task_stop"
+
+    @property
+    def description(self) -> str:
+        return "Stop a running background task."
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {"task_id": {"type": "string"}},
+            "required": ["task_id"],
+        }
+
+    async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        task = self._manager.get(tool_input["task_id"])
+        if not task:
+            return ToolResult.error(f"Task '{tool_input['task_id']}' not found.")
+        self._manager.stop(tool_input["task_id"])
+        return ToolResult.success(f"Task '{tool_input['task_id']}' stopped.")
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        return False

iac_code/tools/__init__.py

@@ -0,0 +1,8 @@
+from iac_code.tools.base import Tool, ToolContext, ToolRegistry, ToolResult
+
+__all__ = [
+    "Tool",
+    "ToolContext",
+    "ToolRegistry",
+    "ToolResult",
+]

iac_code/tools/base.py

@@ -0,0 +1,226 @@
+"""Base classes for the tool system."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from iac_code.types.permissions import PermissionResult
+
+
+@dataclass
+class ToolContext:
+    """Execution context passed to tools."""
+
+    cwd: str = field(default_factory=os.getcwd)
+    event_queue: asyncio.Queue | None = None
+
+
+@dataclass
+class ToolResult:
+    """Result returned from tool execution.
+
+    Extended to support context modification:
+    - new_messages: Additional messages to inject into conversation context.
+    - context_modifier: Callback to modify the execution context
+      (e.g., add tool permissions, override model, override effort).
+    """
+
+    content: str
+    is_error: bool = False
+    new_messages: list[dict[str, Any]] = field(default_factory=list)
+    context_modifier: Callable[[dict], dict] | None = None
+
+    @staticmethod
+    def error(message: str) -> ToolResult:
+        """Create an error result."""
+        return ToolResult(content=message, is_error=True)
+
+    @staticmethod
+    def success(content: str) -> ToolResult:
+        """Create a success result."""
+        return ToolResult(content=content, is_error=False)
+
+
+class Tool(ABC):
+    """Abstract base class for all tools."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """The unique name of the tool."""
+        ...
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """A description of what the tool does."""
+        ...
+
+    @property
+    @abstractmethod
+    def input_schema(self) -> dict[str, Any]:
+        """JSON Schema defining the tool's input parameters."""
+        ...
+
+    @abstractmethod
+    async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        """Execute the tool with the given input.
+
+        Args:
+            tool_input: The input parameters as defined by input_schema.
+            context: The execution context.
+
+        Returns:
+            The result of the tool execution.
+        """
+        ...
+
+    def normalize_input(self, tool_input: dict[str, Any]) -> None:
+        """Normalize tool input in-place before validation.
+
+        Override in subclasses to handle parameter aliases.
+        """
+
+    def validate_input(self, tool_input: dict[str, Any]) -> tuple[bool, str]:
+        """Validate tool_input against input_schema using JSON Schema.
+
+        Returns:
+            (True, "") if valid, (False, error_message) if invalid.
+        """
+        self.normalize_input(tool_input)
+        try:
+            import jsonschema
+
+            jsonschema.validate(instance=tool_input, schema=self.input_schema)
+            return True, ""
+        except jsonschema.ValidationError as e:
+            return False, str(e.message)
+
+    def to_api_format(self) -> dict[str, Any]:
+        """Convert tool definition to LLM API format (legacy OpenAI format)."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.input_schema,
+            },
+        }
+
+    # --- UI rendering methods ---
+    def render_tool_use_message(self, input: dict, *, verbose: bool = False) -> str | None:
+        """Return detail text shown in parentheses after the tool name.
+
+        Displayed as ``● ToolName(detail)`` in the UI.  Use this to show
+        the key parameters of the tool invocation, e.g. file path, search
+        pattern, or URL.
+        """
+        return None
+
+    def render_tool_result_message(self, output: str, *, is_error: bool = False, verbose: bool = False) -> str | None:
+        """Return result summary shown after ``⎿`` prefix.
+
+        In non-verbose mode, return a short one-line summary (e.g.
+        "Found 5 files").  In verbose mode, include more detail.
+        """
+        return None
+
+    def render_tool_use_error_message(self, error: str) -> str | None:
+        """Return error text for display."""
+        return None
+
+    # --- Display info ---
+    def user_facing_name(self, input: dict | None = None) -> str:
+        """Short, human-readable tool name shown as the bold label in the UI.
+
+        Should be a concise noun like "Read", "Search", or "Bash".
+        Do NOT include parameter details here — use
+        ``render_tool_use_message`` for that.  This name is also used in
+        permission prompts (e.g. "Allow Read?").
+        """
+        return self.name
+
+    def get_activity_description(self, input: dict | None = None) -> str | None:
+        """Text shown in the spinner while the tool is executing."""
+        return None
+
+    def get_tool_use_summary(self, input: dict | None = None) -> str | None:
+        """Optional one-line summary of the tool invocation."""
+        return None
+
+    # --- Permission methods ---
+    @property
+    def timeout(self) -> float | None:
+        """Per-tool timeout in seconds. None means use the global default."""
+        return None
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        """Whether the tool only reads and never modifies state."""
+        return False
+
+    def is_concurrency_safe(self, tool_input: dict[str, Any]) -> bool:
+        """Whether this tool can safely run concurrently with other tools.
+        By default, read-only tools are concurrency safe.
+        """
+        return self.is_read_only(tool_input)
+
+    def is_destructive(self, input: dict | None = None) -> bool:
+        """Whether the tool performs destructive operations."""
+        return False
+
+    async def check_permissions(self, input: dict, context: dict | None = None) -> "PermissionResult":
+        """Check permissions"""
+        from iac_code.types.permissions import PermissionResult
+
+        if self.is_read_only(input):
+            return PermissionResult(behavior="allow")
+        return PermissionResult(behavior="ask", message=f"Allow {self.user_facing_name(input)}?")
+
+
+class ToolRegistry:
+    """Registry for managing available tools."""
+
+    def __init__(self) -> None:
+        self._tools: dict[str, Tool] = {}
+
+    def register(self, tool: Tool) -> None:
+        """Register a tool."""
+        self._tools[tool.name] = tool
+
+    def get(self, name: str) -> Tool | None:
+        """Get a tool by name."""
+        return self._tools.get(name)
+
+    def list_tools(self) -> list[Tool]:
+        """List all registered tools."""
+        return list(self._tools.values())
+
+    def to_api_format(self) -> list[dict[str, Any]]:
+        """Convert all tools to LLM API format (legacy OpenAI format)."""
+        return [tool.to_api_format() for tool in self._tools.values()]
+
+    def register_default_tools(self) -> None:
+        """Register all default built-in tools."""
+        from iac_code.tools.bash import BashTool
+        from iac_code.tools.edit_file import EditFileTool
+        from iac_code.tools.glob import GlobTool
+        from iac_code.tools.grep import GrepTool
+        from iac_code.tools.list_files import ListFilesTool
+        from iac_code.tools.read_file import ReadFileTool
+        from iac_code.tools.web_fetch import WebFetchTool
+        from iac_code.tools.write_file import WriteFileTool
+
+        self.register(ReadFileTool())
+        self.register(WriteFileTool())
+        self.register(EditFileTool())
+        self.register(BashTool())
+        self.register(ListFilesTool())
+        self.register(GlobTool())
+        self.register(GrepTool())
+        self.register(WebFetchTool())

iac_code/tools/bash.py

@@ -0,0 +1,133 @@
+"""Bash tool - executes shell commands."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from iac_code.i18n import _
+from iac_code.tools.base import Tool, ToolContext, ToolResult
+
+
+class BashTool(Tool):
+    @property
+    def name(self) -> str:
+        return "bash"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Execute a shell command in the system's default shell. "
+            "Use this for running programs, installing packages, searching code, "
+            "running tests, git operations, and other system tasks. "
+            "Commands are executed with a timeout of 120 seconds by default."
+        )
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "The shell command to execute.",
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Timeout in seconds. Defaults to 120.",
+                },
+            },
+            "required": ["command"],
+        }
+
+    async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        command = tool_input["command"]
+        timeout = tool_input.get("timeout", 120)
+
+        try:
+            process = await asyncio.create_subprocess_shell(
+                command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=context.cwd,
+            )
+
+            try:
+                stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=timeout)
+            except asyncio.TimeoutError:
+                process.kill()
+                await process.communicate()
+                return ToolResult.error(f"Command timed out after {timeout} seconds: {command}")
+
+            stdout_str = stdout.decode("utf-8", errors="replace") if stdout else ""
+            stderr_str = stderr.decode("utf-8", errors="replace") if stderr else ""
+
+            # Build result
+            parts = []
+            if stdout_str:
+                parts.append(f"STDOUT:\n{stdout_str}")
+            if stderr_str:
+                parts.append(f"STDERR:\n{stderr_str}")
+            parts.append(f"Exit code: {process.returncode}")
+
+            output = "\n".join(parts)
+
+            if process.returncode != 0:
+                return ToolResult.error(output)
+
+            return ToolResult.success(output)
+
+        except Exception as e:
+            return ToolResult.error(f"Error executing command: {e}")
+
+    # UI rendering methods
+    MAX_COMMAND_DISPLAY_CHARS = 160
+    MAX_COMMAND_DISPLAY_LINES = 2
+    MAX_OUTPUT_LINES = 20
+
+    def render_tool_use_message(self, input: dict, *, verbose: bool = False):
+        cmd = input.get("command", "")
+        if not cmd:
+            return None
+        if not verbose:
+            lines = cmd.split("\n")
+            if len(lines) > self.MAX_COMMAND_DISPLAY_LINES:
+                cmd = "\n".join(lines[: self.MAX_COMMAND_DISPLAY_LINES])
+            if len(cmd) > self.MAX_COMMAND_DISPLAY_CHARS:
+                cmd = cmd[: self.MAX_COMMAND_DISPLAY_CHARS]
+            return cmd.strip() + "…" if cmd != input.get("command", "") else cmd
+        return cmd
+
+    def render_tool_result_message(self, output: str, *, is_error: bool = False, verbose: bool = False):
+        lines = output.strip().splitlines()
+        if not verbose and len(lines) > self.MAX_OUTPUT_LINES:
+            return (
+                "\n".join(lines[: self.MAX_OUTPUT_LINES])
+                + "\n... "
+                + _("{count} more lines").format(count=len(lines) - self.MAX_OUTPUT_LINES)
+            )
+        return output.strip()
+
+    def render_tool_use_error_message(self, error: str):
+        return error
+
+    def user_facing_name(self, input: dict | None = None) -> str:
+        return _("Bash")
+
+    def get_activity_description(self, input: dict | None = None) -> str:
+        if input:
+            cmd = input.get("command", "")
+            short = cmd[:50] + "..." if len(cmd) > 50 else cmd
+            return _("Running {cmd}").format(cmd=short)
+        return _("Running command...")
+
+    def get_tool_use_summary(self, input: dict | None = None) -> str | None:
+        if input:
+            return input.get("command", "")[:80]
+        return None
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        return False
+
+    def is_destructive(self, input: dict | None = None) -> bool:
+        return False