llmcode-cli 1.0.0__py3-none-any.whl

llm_code/tools/agent_roles.py

@@ -0,0 +1,82 @@
+"""Specialized agent role definitions for constrained sub-agents."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class AgentRole:
+    name: str
+    description: str
+    system_prompt_prefix: str
+    allowed_tools: frozenset[str]
+    model_key: str  # key in config.model_routing
+
+
+EXPLORE_ROLE = AgentRole(
+    name="explore",
+    description="Read-only code exploration agent",
+    system_prompt_prefix=(
+        "You are a read-only exploration agent. You MUST NOT create, modify, or delete any files. "
+        "Only use read-only tools to explore the codebase."
+    ),
+    allowed_tools=frozenset({
+        "read_file",
+        "glob_search",
+        "grep_search",
+        "git_status",
+        "git_diff",
+        "git_log",
+        "lsp_goto_definition",
+        "lsp_find_references",
+        "lsp_diagnostics",
+    }),
+    model_key="sub_agent",
+)
+
+PLAN_ROLE = AgentRole(
+    name="plan",
+    description="Planning-only agent that analyzes and plans but never executes changes",
+    system_prompt_prefix=(
+        "You are a planning agent. Analyze the codebase and create a detailed plan. "
+        "Do NOT execute any changes — only describe what should be done, which files to modify, "
+        "and what the implementation should look like."
+    ),
+    allowed_tools=frozenset({
+        "read_file",
+        "glob_search",
+        "grep_search",
+        "git_status",
+        "git_diff",
+        "git_log",
+        "memory_recall",
+        "memory_list",
+    }),
+    model_key="sub_agent",
+)
+
+VERIFICATION_ROLE = AgentRole(
+    name="verify",
+    description="Adversarial verification agent that tries to find problems",
+    system_prompt_prefix=(
+        "You are a verification agent. Your job is to find problems.\n"
+        "Run tests, linters, and type checkers. Check exit codes and output carefully.\n"
+        "Do NOT trust the implementer's claims. Verify independently.\n"
+        "Report VERDICT: PASS, FAIL, or PARTIAL with evidence for each check."
+    ),
+    allowed_tools=frozenset({
+        "read_file",
+        "glob_search",
+        "grep_search",
+        "bash",
+        "git_status",
+        "git_diff",
+    }),
+    model_key="sub_agent",
+)
+
+BUILT_IN_ROLES: dict[str, AgentRole] = {
+    "explore": EXPLORE_ROLE,
+    "plan": PLAN_ROLE,
+    "verify": VERIFICATION_ROLE,
+}

llm_code/tools/base.py

@@ -0,0 +1,94 @@
+"""Abstract base classes for tools."""
+from __future__ import annotations
+
+import dataclasses
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Callable
+
+from pydantic import BaseModel
+
+from llm_code.api.types import ToolDefinition
+
+
+class PermissionLevel(Enum):
+    READ_ONLY = "read_only"
+    WORKSPACE_WRITE = "workspace_write"
+    FULL_ACCESS = "full_access"
+
+
+@dataclasses.dataclass(frozen=True)
+class ToolResult:
+    output: str
+    is_error: bool = False
+    metadata: dict | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class ToolProgress:
+    tool_name: str
+    message: str
+    percent: float | None = None
+
+
+class Tool(ABC):
+    """Abstract base class for all tools."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str: ...
+
+    @property
+    @abstractmethod
+    def description(self) -> str: ...
+
+    @property
+    @abstractmethod
+    def input_schema(self) -> dict: ...
+
+    @property
+    @abstractmethod
+    def required_permission(self) -> PermissionLevel: ...
+
+    @abstractmethod
+    def execute(self, args: dict) -> ToolResult: ...
+
+    @property
+    def input_model(self) -> type[BaseModel] | None:
+        """Return the Pydantic model class for input validation, or None."""
+        return None
+
+    def is_read_only(self, args: dict) -> bool:
+        """Return True if this operation only reads data (never writes)."""
+        return False
+
+    def is_destructive(self, args: dict) -> bool:
+        """Return True if this operation can cause irreversible data loss."""
+        return False
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        """Return True if this operation is safe to run concurrently."""
+        return False
+
+    def validate_input(self, args: dict) -> dict:
+        """Validate args against input_model; return coerced dict or raise ValidationError."""
+        model_cls = self.input_model
+        if model_cls is None:
+            return args
+        validated = model_cls(**args)
+        return validated.model_dump()
+
+    def execute_with_progress(
+        self,
+        args: dict,
+        on_progress: Callable[[ToolProgress], None],
+    ) -> ToolResult:
+        """Execute the tool, optionally emitting progress events via on_progress."""
+        return self.execute(args)
+
+    def to_definition(self) -> ToolDefinition:
+        return ToolDefinition(
+            name=self.name,
+            description=self.description,
+            input_schema=self.input_schema,
+        )