@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/onecode/agent/tools/agent_tools.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import Tool, ToolRegistry, ToolSpec
+
+
+class AgentTool(Tool):
+    def __init__(self, registry: ToolRegistry, permission_checker=None):
+        self._registry = registry
+        self._permission_checker = permission_checker
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="Agent",
+            description="Execute a sequence of tool calls as a single atomic agent step.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "calls": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {"type": "string", "description": "Tool name"},
+                                "input": {"type": "object", "description": "Tool input arguments"},
+                            },
+                            "required": ["name", "input"],
+                        },
+                    },
+                    "stop_on_error": {
+                        "type": "boolean",
+                        "description": "Stop execution on first error",
+                    },
+                },
+                "required": ["calls"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        calls = tool_input.get("calls", [])
+        stop_on_error = bool(tool_input.get("stop_on_error", True))
+        if not isinstance(calls, list):
+            return ToolResult(name="Agent", output={"error": "calls must be an array"}, is_error=True)
+        results = []
+        any_error = False
+        for idx, call in enumerate(calls):
+            if not isinstance(call, dict):
+                return ToolResult(name="Agent", output={"error": f"calls[{idx}] must be an object"}, is_error=True)
+            sub_name = call.get("name", "")
+            if sub_name == "Agent":
+                results.append({"name": sub_name, "is_error": True, "output": "Agent tool cannot be nested"})
+                any_error = True
+                if stop_on_error:
+                    break
+                continue
+            sub_input = call.get("input", {})
+            if self._permission_checker:
+                denied = self._permission_checker(sub_name, sub_input)
+                if denied:
+                    results.append({"name": sub_name, "is_error": True, "output": denied})
+                    any_error = True
+                    if stop_on_error:
+                        break
+                    continue
+            from onecode.agent.tools.protocol import ToolCall
+            sub_result = self._registry.dispatch(ToolCall(name=sub_name, input=sub_input, tool_use_id=f"agent_{idx}"))
+            sub_error = sub_result.is_error
+            results.append({"name": sub_name, "is_error": sub_error, "output": sub_result.output})
+            any_error = any_error or sub_error
+            if sub_error and stop_on_error:
+                break
+        return ToolResult(name="Agent", output={"results": results}, is_error=any_error)
+
+
+
+class TaskTool(Tool):
+    VALID_AGENT_TYPES: tuple[str, ...] = (
+        "general", "explore", "scout",
+        "build", "plan", "solo",
+    )
+
+    def __init__(self, spawn_fn):
+        self._spawn = spawn_fn
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        return asyncio.run(self.run_async(tool_input))
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="Spawn",
+            description="Delegate a subtask to a specialized subagent. Use for complex multi-step work or work that benefits from an isolated context.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "agent_type": {
+                        "type": "string",
+                        "enum": list(self.VALID_AGENT_TYPES),
+                        "description": "general (implementation) | explore (code search) | scout (research) | build (full dev) | plan (analysis) | solo (autonomous). Default: general. Choose based on subtask nature.",
+                    },
+                    "prompt": {"type": "string", "description": "Detailed task description for the subagent. Include context, goals, and expected output format."},
+                },
+                "required": ["prompt"],
+            },
+        )
+
+    async def run_async(self, tool_input: dict[str, Any]) -> ToolResult:
+        agent_type = tool_input.get("agent_type", "general")
+        prompt = tool_input.get("prompt", "")
+        if agent_type not in self.VALID_AGENT_TYPES:
+            return ToolResult(
+                name="Spawn",
+                output={
+                    "error": (
+                        f"Unknown agent_type '{agent_type}'. "
+                        f"Valid types: {', '.join(self.VALID_AGENT_TYPES)}"
+                    ),
+                },
+                is_error=True,
+            )
+        try:
+            result = await self._spawn(agent_type, prompt)
+        except Exception as e:
+            return ToolResult(name="Spawn", output={"error": str(e)}, is_error=True)
+        return ToolResult(name="Spawn", output=str(result))
+

package/onecode/agent/tools/apply_patch_tool.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from onecode.agent.tools.file_ops import FileOps
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import Tool, ToolSpec
+
+
+class ApplyPatchTool(Tool):
+    def __init__(self, file_ops: FileOps):
+        self._file_ops = file_ops
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="ApplyPatch",
+            description="Apply a patch to files. Supports creating, updating, moving, and deleting files via patch format.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "patch": {
+                        "type": "string",
+                        "description": "Patch content with marker lines:\n"
+                                      "*** Add File: <path>\n"
+                                      "*** Update File: <path>\n"
+                                      "*** Move to: <path>\n"
+                                      "*** Delete File: <path>",
+                    },
+                },
+                "required": ["patch"],
+            },
+            is_destructive=True,
+            max_result_size_chars=50_000,
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        patch = tool_input.get("patch", "")
+        if not patch:
+            return ToolResult(name="ApplyPatch", output={"error": "patch is required"}, is_error=True)
+
+        results = []
+        current_file: str | None = None
+        current_content: list[str] = []
+
+        lines = patch.split("\n")
+        i = 0
+        while i < len(lines):
+            line = lines[i].rstrip()
+
+            add_match = re.match(r"^\*\*\*\s*Add File:\s*(.+)$", line)
+            update_match = re.match(r"^\*\*\*\s*Update File:\s*(.+)$", line)
+            move_match = re.match(r"^\*\*\*\s*Move to:\s*(.+)$", line)
+            delete_match = re.match(r"^\*\*\*\s*Delete File:\s*(.+)$", line)
+
+            if add_match:
+                if current_file and current_content:
+                    result = self._write_file(current_file, "\n".join(current_content))
+                    results.append(result)
+                current_file = add_match.group(1).strip()
+                current_content = []
+
+            elif update_match:
+                if current_file and current_content:
+                    result = self._write_file(current_file, "\n".join(current_content))
+                    results.append(result)
+                current_file = update_match.group(1).strip()
+                current_content = []
+
+            elif move_match:
+                target = move_match.group(1).strip()
+                if current_file:
+                    result = self._move_file(current_file, target)
+                    results.append(result)
+                    current_file = target
+
+            elif delete_match:
+                target = delete_match.group(1).strip()
+                result = self._delete_file(target)
+                results.append(result)
+                current_file = None
+                current_content = []
+
+            else:
+                if current_file is not None:
+                    current_content.append(line)
+
+            i += 1
+
+        if current_file and current_content:
+            result = self._write_file(current_file, "\n".join(current_content))
+            results.append(result)
+
+        if not results:
+            return ToolResult(name="ApplyPatch", output={"error": "No patches applied"}, is_error=True)
+
+        success_count = sum(1 for r in results if r.get("success"))
+        return ToolResult(
+            name="ApplyPatch",
+            output={"applied": len(results), "success": success_count, "results": results},
+            is_error=False,
+        )
+
+    def _write_file(self, path: str, content: str) -> dict:
+        return self._file_ops.write(path, content)
+
+    def _move_file(self, src: str, dst: str) -> dict:
+        p_src = self._file_ops._resolve(src)
+        p_dst = self._file_ops._resolve(dst)
+
+        if not p_src.exists():
+            return {"success": False, "error": f"Source file not found: {src}"}
+
+        if not self._file_ops._is_within_workspace(p_dst):
+            return {"success": False, "error": "Path outside workspace"}
+
+        try:
+            p_dst.parent.mkdir(parents=True, exist_ok=True)
+            p_src.rename(p_dst)
+            return {"success": True, "operation": "move", "from": src, "to": dst}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def _delete_file(self, path: str) -> dict:
+        p = self._file_ops._resolve(path)
+
+        if not p.exists():
+            return {"success": False, "error": f"File not found: {path}"}
+
+        if not self._file_ops._is_within_workspace(p):
+            return {"success": False, "error": "Path outside workspace"}
+
+        try:
+            p.unlink()
+            return {"success": True, "operation": "delete", "path": path}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+

package/onecode/agent/tools/bash_tool.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Callable
+
+from onecode.agent.tools.file_ops import ShellTool
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import Tool, ToolSpec
+
+
+_DANGEROUS_PATTERNS = [
+    re.compile(r"\bsudo\b", re.IGNORECASE),
+    re.compile(r"\bshutdown\b", re.IGNORECASE),
+    re.compile(r"\breboot\b", re.IGNORECASE),
+    re.compile(r"\bmkfs\b", re.IGNORECASE),
+    re.compile(r"\bdd\b\s+if=", re.IGNORECASE),
+    re.compile(r"\brm\b.*\s+-rf\s+/\s*$", re.IGNORECASE),
+    re.compile(r"\brm\b.*\s+-rf\s+/\s+"),
+    re.compile(r"\brm\b.*\s+-rf\s+\$", re.IGNORECASE),
+    re.compile(r"\brm\b.*\s+-rf\s+~", re.IGNORECASE),
+    re.compile(r"\brm\b.*\s+-rf\s+/[a-z]+\s*$", re.IGNORECASE),
+    re.compile(r"\bchown\b.*\s+-R\s+", re.IGNORECASE),
+    re.compile(r"\bchmod\b.*\s+-R\s+777\s+/", re.IGNORECASE),
+    re.compile(r"\bchmod\b.*777\s+/\s*$", re.IGNORECASE),
+    re.compile(r"\bmv\b.*/\s+/dev/null", re.IGNORECASE),
+    re.compile(r"\bpasswd\b", re.IGNORECASE),
+    re.compile(r"\buseradd\b", re.IGNORECASE),
+    re.compile(r"\busermod\b", re.IGNORECASE),
+    re.compile(r":\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:", re.IGNORECASE),
+]
+
+
+class BashTool(Tool):
+    def __init__(self, shell: ShellTool):
+        self._shell = shell
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="Bash",
+            description="Execute a shell command and return stdout/stderr.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string", "description": "Shell command to execute"},
+                    "timeout": {"type": "integer", "description": "Timeout in seconds", "default": 60},
+                },
+                "required": ["command"],
+            },
+            is_destructive=True,
+            max_result_size_chars=50_000,
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        command = tool_input.get("command", "")
+        timeout = tool_input.get("timeout", 60)
+
+        error = self._validate(command)
+        if error:
+            return error
+
+        result = self._shell.exec(command, timeout=timeout)
+        return self._to_tool_result(result, tool_input)
+
+    async def run_async(
+        self, tool_input: dict[str, Any],
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> ToolResult:
+        command = tool_input.get("command", "")
+        timeout = tool_input.get("timeout", 60)
+
+        error = self._validate(command)
+        if error:
+            return error
+
+        result = await self._shell.exec_async(command, timeout=timeout, cancel_check=cancel_check)
+        return self._to_tool_result(result, tool_input)
+
+    def _validate(self, command: str) -> ToolResult | None:
+        if not isinstance(command, str) or not command.strip():
+            return ToolResult(name="Bash", output="command must be a non-empty string", is_error=True, content_type="text")
+        if "\x00" in command:
+            return ToolResult(name="Bash", output="command contains NUL byte", is_error=True, content_type="text")
+        for pat in _DANGEROUS_PATTERNS:
+            if pat.search(command):
+                return ToolResult(name="Bash", output="refusing to run potentially dangerous command", is_error=True, content_type="text")
+        return None
+
+    def _to_tool_result(self, result: dict, tool_input: dict) -> ToolResult:
+        is_error = not result.get("success", True)
+        stdout = result.get("stdout", "") or ""
+        stderr = result.get("stderr", "") or ""
+        error_msg = result.get("error", "") or ""
+        formatted = self._format_bash_output(stdout, stderr, error_msg, is_error)
+        return ToolResult(
+            name="Bash",
+            output=formatted,
+            is_error=is_error,
+            content_type="text",
+            tool_use_id=tool_input.get("tool_use_id"),
+        )
+
+    @staticmethod
+    def _format_bash_output(stdout: str, stderr: str, error: str, is_error: bool) -> str:
+        """Format shell stdout / stderr as a single text block for the TUI.
+
+        Stderr is rendered first when present so failures are visible,
+        the underlying ``error`` string is included for non-zero exits /
+        transport failures, and the result is fenced so the TUI renders
+        it as a code block with bash syntax highlighting.
+        """
+        parts: list[str] = []
+        if error.strip():
+            parts.append(f"[error] {error.strip()}")
+        if stderr.strip():
+            parts.append(f"[stderr]\n{stderr.rstrip()}")
+        if stdout.strip():
+            parts.append(stdout.rstrip())
+        if not parts:
+            return "(no output)" if not is_error else "(failed with no output)"
+        return "```bash\n" + "\n\n".join(parts) + "\n```"
+

package/onecode/agent/tools/communication_tools.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from typing import Any
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import Tool, ToolRegistry, ToolSpec
+
+
+class SendMessageTool(Tool):
+    def __init__(self):
+        self.last_message: str = ""
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="SendMessage",
+            description="Send a user-visible message with optional file attachments.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "message": {"type": "string", "description": "The message to show to the user"},
+                    "attachments": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Optional file paths to attach",
+                    },
+                },
+                "required": ["message"],
+            },
+            is_read_only=True,
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        message = tool_input.get("message", "")
+        attachments = tool_input.get("attachments", [])
+        self.last_message = message
+        return ToolResult(name="SendMessage", output={"message": message, "attachments": attachments})
+
+
+
+_OPTION_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "label": {"type": "string", "description": "Display text for the option"},
+        "value": {"type": "string", "description": "Value returned when selected"},
+        "description": {"type": "string", "description": "Optional explanation of the choice"},
+        "key": {"type": "string", "description": "Optional keyboard shortcut (e.g. 'y', 'n')"},
+        "default": {"type": "boolean", "description": "Auto-select if user doesn't respond"},
+    },
+    "required": ["label", "value"],
+}
+
+_QUESTION_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "header": {"type": "string", "description": "Short label (max 30 chars) for this question"},
+        "question": {"type": "string", "description": "The question text shown to the user"},
+        "type": {
+            "type": "string",
+            "enum": ["single", "multiple", "confirm"],
+            "description": "Question type: single=one choice, multiple=multi-select, confirm=yes/no",
+        },
+        "options": {
+            "type": "array",
+            "items": _OPTION_SCHEMA,
+            "description": "Predefined choices. For 'confirm' type, omit to get default Yes/No options.",
+        },
+    },
+    "required": ["question"],
+}
+
+
+class AskUserTool(Tool):
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="AskUser",
+            description="Ask the user one or more questions with optional predefined choices.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "question": {"type": "string", "description": "[DEPRECATED] Single question text. Use 'questions' instead."},
+                    "header": {"type": "string", "description": "[DEPRECATED] Short label for single question."},
+                    "context": {"type": "string", "description": "Additional context"},
+                    "options": {
+                        "type": "array",
+                        "items": _OPTION_SCHEMA,
+                        "description": "[DEPRECATED] Options for single question. Use 'questions' instead.",
+                    },
+                    "questions": {
+                        "type": "array",
+                        "items": _QUESTION_SCHEMA,
+                        "minItems": 1,
+                        "maxItems": 6,
+                        "description": "One or more questions to ask the user. Supports single choice, multiple selection, and confirm types.",
+                    },
+                    "plan_submit": {
+                        "type": "boolean",
+                        "description": "PLAN AGENT ONLY: set to true when submitting the final plan for user approval (plan text goes in 'context'). On approval the system automatically hands off execution to the execution agent.",
+                    },
+                },
+                "oneOf": [
+                    {"required": ["question"]},
+                    {"required": ["questions"]},
+                ],
+            },
+            is_read_only=True,
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        question = tool_input.get("question", "")
+        header = tool_input.get("header", "")
+        context = tool_input.get("context", "")
+        options = tool_input.get("options", [])
+        questions = tool_input.get("questions", [])
+        plan_submit = bool(tool_input.get("plan_submit", False))
+        return ToolResult(name="AskUser", output={
+            "question": question,
+            "header": header,
+            "context": context,
+            "options": options,
+            "questions": questions,
+            "plan_submit": plan_submit,
+        })
+
+
+
+class ToolSearchTool(Tool):
+    def __init__(self, registry: ToolRegistry):
+        self._registry = registry
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="ToolSearch",
+            description="Search for available tools by keyword.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search keyword to find relevant tools"},
+                },
+                "required": ["query"],
+            },
+            is_read_only=True,
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        query = tool_input.get("query", "").lower()
+        specs = self._registry.list_specs()
+        matches = []
+        for spec in specs:
+            if query in spec.name.lower() or query in spec.description.lower():
+                matches.append({"name": spec.name, "description": spec.description})
+        if not matches:
+            matches = [{"name": s.name, "description": s.description[:80]} for s in specs[:10]]
+        return ToolResult(name="ToolSearch", output={"matches": matches[:20]})
+