@scemoon/cdh 1.0.0

package/onecode/agent/tools/agent_tools.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import ToolRegistry, ToolSpec
+
+
+class AgentTool:
+    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:
+    VALID_AGENT_TYPES: tuple[str, ...] = (
+        "general", "explore", "scout",
+        "build", "plan", "solo",
+    )
+
+    def __init__(self, spawn_fn):
+        self._spawn = spawn_fn
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="Task",
+            description="Delegate a subtask to a specialized subagent. Use for large, independent, or specialized work that benefits from a focused sub-agent.",
+            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"],
+            },
+        )
+
+    def run(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="Task",
+                output={
+                    "error": (
+                        f"Unknown agent_type '{agent_type}'. "
+                        f"Valid types: {', '.join(self.VALID_AGENT_TYPES)}"
+                    ),
+                },
+                is_error=True,
+            )
+        import asyncio
+        import concurrent.futures
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                future = asyncio.run_coroutine_threadsafe(
+                    self._spawn(agent_type, prompt), loop
+                )
+                result = future.result(timeout=300)
+            else:
+                result = asyncio.run(self._spawn(agent_type, prompt))
+        except Exception as e:
+            return ToolResult(name="Task", output={"error": str(e)}, is_error=True)
+        return ToolResult(name="Task", output=str(result))
+

package/onecode/agent/tools/apply_patch_tool.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+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 ToolSpec
+
+
+class ApplyPatchTool:
+    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] = []
+        patch_type = "update"
+
+        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 = []
+                patch_type = "add"
+
+            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 = []
+                patch_type = "update"
+
+            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
+                patch_type = "move"
+
+            elif delete_match:
+                target = delete_match.group(1).strip()
+                result = self._delete_file(target)
+                results.append(result)
+                current_file = None
+                current_content = []
+                patch_type = "delete"
+
+            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,91 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any, Optional
+
+from onecode.agent.tools.file_ops import ShellTool
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import 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":\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:", re.IGNORECASE),
+]
+
+
+class BashTool:
+    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)
+
+        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")
+
+        result = self._shell.exec(command, timeout=timeout)
+        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 both streams are fenced so the TUI
+        renders them as code blocks.
+        """
+        parts: list[str] = []
+        if error.strip():
+            parts.append(f"[error] {error.strip()}")
+        if stderr.strip():
+            parts.append(f"```\n[stderr]\n{stderr.rstrip()}\n```")
+        if stdout.strip():
+            parts.append(f"```\n{stdout.rstrip()}\n```")
+        if not parts:
+            return "(no output)" if not is_error else "(failed with no output)"
+        return "\n\n".join(parts)
+

package/onecode/agent/tools/communication_tools.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import ToolRegistry, ToolSpec
+
+
+class SendMessageTool:
+    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:
+    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.",
+                    },
+                },
+                "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", [])
+        return ToolResult(name="AskUser", output={
+            "question": question,
+            "header": header,
+            "context": context,
+            "options": options,
+            "questions": questions,
+        })
+
+
+
+class ToolSearchTool:
+    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]})
+

package/onecode/agent/tools/config_tool.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import ToolSpec
+from onecode.config import GlobalConfig
+
+logger = logging.getLogger("onecode.tools.config")
+
+
+class ConfigReadTool:
+    """Read configuration values accessible to the LLM (Clawd-Code pattern)."""
+
+    def __init__(self, config: GlobalConfig):
+        self._config = config
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="ConfigRead",
+            description="Read configuration values. Returns current config for the specified path (e.g. 'default_model', 'default_provider', 'tui.theme').",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "key": {
+                        "type": "string",
+                        "description": "Config key path (e.g. 'default_model', 'tui.theme'). Empty returns all.",
+                    },
+                },
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        key = tool_input.get("key", "")
+        if not key:
+            return ToolResult(name="ConfigRead", output={"config": self._config_to_dict()})
+        parts = key.split(".")
+        val = self._resolve(self._config, parts)
+        if val is None:
+            return ToolResult(name="ConfigRead", output={"error": f"config key '{key}' not found"}, is_error=True)
+        return ToolResult(name="ConfigRead", output={"key": key, "value": val})
+
+    def _config_to_dict(self) -> dict:
+        return {
+            "default_model": self._config.default_model,
+            "default_provider": self._config.default_provider,
+            "default_mode": self._config.default_mode,
+            "current_project": self._config.current_project,
+            "tui.theme": self._config.tui.theme if self._config.tui else None,
+            "log_level": self._config.log_level,
+        }
+
+    def _resolve(self, obj: Any, parts: list[str]) -> Any:
+        current = obj
+        for part in parts:
+            if hasattr(current, part):
+                current = getattr(current, part)
+            elif isinstance(current, dict):
+                current = current.get(part)
+            else:
+                return None
+        return current
+
+
+
+class ConfigWriteTool:
+    """Write configuration values accessible to the LLM (Clawd-Code pattern)."""
+
+    def __init__(self, config: GlobalConfig, save_fn=None):
+        self._config = config
+        self._save_fn = save_fn
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="ConfigWrite",
+            description="Set a configuration value. Path supports dot notation (e.g. 'tui.theme'). Only string/numeric values. Does NOT expose API keys or secrets.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "key": {"type": "string", "description": "Config key path (e.g. 'default_model', 'tui.theme')"},
+                    "value": {"type": "string", "description": "Value to set"},
+                },
+                "required": ["key", "value"],
+            },
+        )
+
+    ALLOWED_KEYS = {
+        "default_model", "default_provider", "default_mode",
+        "tui.theme", "log_level", "current_project",
+    }
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        key = tool_input.get("key", "")
+        value = tool_input.get("value", "")
+        if key not in self.ALLOWED_KEYS:
+            return ToolResult(
+                name="ConfigWrite",
+                output={"error": f"key '{key}' is not writable via this tool. Allowed: {sorted(self.ALLOWED_KEYS)}"},
+                is_error=True,
+            )
+        parts = key.split(".")
+        try:
+            self._set(self._config, parts, value)
+        except Exception as e:
+            return ToolResult(name="ConfigWrite", output={"error": str(e)}, is_error=True)
+        if self._save_fn:
+            try:
+                self._save_fn(self._config)
+            except Exception as e:
+                logger.warning("Config save failed: %s", e)
+        return ToolResult(name="ConfigWrite", output={"key": key, "value": value, "status": "updated"})
+
+    def _set(self, obj: Any, parts: list[str], value: Any) -> None:
+        current = obj
+        for part in parts[:-1]:
+            if hasattr(current, part):
+                current = getattr(current, part)
+        last = parts[-1]
+        if hasattr(current, last):
+            field_type = type(getattr(current, last))
+            if field_type is int:
+                setattr(current, last, int(value))
+            elif field_type is float:
+                setattr(current, last, float(value))
+            elif field_type is bool:
+                setattr(current, last, value.lower() in ("true", "1", "yes"))
+            else:
+                setattr(current, last, value)
+