@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/onecode/agent/tools/agent_tools.py

@@ -1,128 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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]})
-