@scemoon/cdh 1.0.8 → 1.0.9-beta.2

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 Tool, ToolSpec
+from onecode.config import GlobalConfig
+
+logger = logging.getLogger("onecode.tools.config")
+
+
+class ConfigReadTool(Tool):
+    """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(Tool):
+    """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)
+

package/onecode/agent/tools/cron_tools.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Any, Callable
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import Tool, ToolSpec
+
+
+@dataclass
+class CronJob:
+    name: str
+    interval_seconds: int
+    command: str
+    args: dict[str, Any] = field(default_factory=dict)
+    last_run: datetime | None = None
+    next_run: datetime | None = None
+    active: bool = True
+    run_count: int = 0
+
+
+class CronScheduler:
+    """Simple in-process cron scheduler for periodic tool execution."""
+
+    def __init__(self):
+        self._jobs: dict[str, CronJob] = {}
+        self._task: asyncio.Task | None = None
+
+    def add(self, name: str, interval_seconds: int, command: str, args: dict | None = None) -> str:
+        now = datetime.now()
+        job = CronJob(
+            name=name,
+            interval_seconds=interval_seconds,
+            command=command,
+            args=args or {},
+            next_run=now + timedelta(seconds=interval_seconds),
+        )
+        self._jobs[name] = job
+        return name
+
+    def remove(self, name: str) -> bool:
+        return self._jobs.pop(name, None) is not None
+
+    def list(self) -> list[dict]:
+        return [
+            {
+                "name": j.name,
+                "interval_seconds": j.interval_seconds,
+                "command": j.command,
+                "active": j.active,
+                "run_count": j.run_count,
+                "next_run": j.next_run.isoformat() if j.next_run else None,
+            }
+            for j in self._jobs.values()
+        ]
+
+    def pause(self, name: str) -> bool:
+        job = self._jobs.get(name)
+        if job:
+            job.active = False
+            return True
+        return False
+
+    def resume(self, name: str) -> bool:
+        job = self._jobs.get(name)
+        if job:
+            job.active = True
+            job.next_run = datetime.now() + timedelta(seconds=job.interval_seconds)
+            return True
+        return False
+
+    async def start_loop(self, executor: Callable[[str, dict], None] | None = None) -> None:
+        async def _tick():
+            while True:
+                now = datetime.now()
+                for job in list(self._jobs.values()):
+                    if job.active and job.next_run and now >= job.next_run:
+                        job.last_run = now
+                        job.next_run = now + timedelta(seconds=job.interval_seconds)
+                        job.run_count += 1
+                        if executor:
+                            try:
+                                executor(job.command, job.args)
+                            except Exception:
+                                pass
+                await asyncio.sleep(1)
+        self._task = asyncio.create_task(_tick())
+
+    def stop_loop(self) -> None:
+        if self._task:
+            self._task.cancel()
+            self._task = None
+
+
+class CronCreateTool(Tool):
+    """Create a scheduled cron job (Clawd-Code pattern)."""
+
+    def __init__(self, scheduler: CronScheduler):
+        self._scheduler = scheduler
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="CronCreate",
+            description="Create a scheduled job that runs periodically. The command is a tool name; args are passed to it.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "description": "Unique job name"},
+                    "interval_seconds": {"type": "integer", "description": "Interval in seconds"},
+                    "command": {"type": "string", "description": "Tool name to execute"},
+                    "args": {"type": "object", "description": "Arguments to pass to the tool"},
+                },
+                "required": ["name", "interval_seconds", "command"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        name = tool_input["name"]
+        if name in self._scheduler._jobs:
+            return ToolResult(name="CronCreate", output={"error": f"job '{name}' already exists"}, is_error=True)
+        self._scheduler.add(
+            name=name,
+            interval_seconds=tool_input["interval_seconds"],
+            command=tool_input["command"],
+            args=tool_input.get("args"),
+        )
+        return ToolResult(name="CronCreate", output={"name": name, "status": "created"})
+
+
+
+class CronListTool(Tool):
+    """List all cron jobs."""
+
+    def __init__(self, scheduler: CronScheduler):
+        self._scheduler = scheduler
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="CronList",
+            description="List all registered cron jobs with their status and next run time.",
+            input_schema={
+                "type": "object",
+                "properties": {},
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        return ToolResult(name="CronList", output={"jobs": self._scheduler.list()})
+
+
+
+class CronRemoveTool(Tool):
+    """Remove a cron job."""
+
+    def __init__(self, scheduler: CronScheduler):
+        self._scheduler = scheduler
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="CronRemove",
+            description="Remove a cron job by name.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "description": "Job name to remove"},
+                },
+                "required": ["name"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        name = tool_input.get("name", "")
+        if self._scheduler.remove(name):
+            return ToolResult(name="CronRemove", output={"name": name, "status": "removed"})
+        return ToolResult(name="CronRemove", output={"error": f"job '{name}' not found"}, is_error=True)
+

package/onecode/agent/tools/errors.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+
+class ToolError(Exception):
+    pass
+
+
+class ToolInputError(ToolError):
+    pass
+
+
+class ToolPermissionError(ToolError):
+    pass
+
+
+class ToolExecutionError(ToolError):
+    pass

package/onecode/agent/tools/file_ops.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import asyncio
+import subprocess
+from pathlib import Path
+from typing import Callable, Optional
+
+from onecode.agent.permissions import PermissionChecker, PermissionSet, create_safe_permission_set
+from onecode.agent.tools.sandbox import create_sandbox
+
+
+class FileOps:
+    def __init__(self, workspace: Optional[Path] = None):
+        self.workspace = workspace or Path.cwd()
+        self._undo_stack: list[dict] = []
+
+    def read(self, path: str, offset: int = 0, limit: int = 0) -> str:
+        p = self._resolve(path)
+        if not p.exists():
+            return f"File not found: {path}"
+        try:
+            content = p.read_text(encoding="utf-8")
+            lines = content.split("\n")
+            if limit > 0:
+                lines = lines[offset:offset + limit]
+            elif offset > 0:
+                lines = lines[offset:]
+            return "\n".join(lines)
+        except Exception as e:
+            return f"Error reading {path}: {e}"
+
+    def write(self, path: str, content: str) -> dict:
+        p = self._resolve(path)
+        if not self._is_within_workspace(p):
+            return {"success": False, "error": "Path outside workspace"}
+        try:
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text(content, encoding="utf-8")
+            return {"success": True, "path": str(p)}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def edit(self, path: str, old: str, new: str) -> dict:
+        p = self._resolve(path)
+        if not p.exists():
+            return {"success": False, "error": "File not found"}
+        try:
+            content = p.read_text(encoding="utf-8")
+            if old not in content:
+                return {"success": False, "error": "String not found in file"}
+            count = content.count(old)
+            if count > 1:
+                return {
+                    "success": False,
+                    "error": f"old_string matches {count} locations in file. "
+                             f"Provide a larger string with more surrounding context to make it unique.",
+                }
+            self._undo_stack.append({"path": str(p), "content": content})
+            content = content.replace(old, new, 1)
+            p.write_text(content, encoding="utf-8")
+            return {"success": True, "path": str(p)}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def insert(self, path: str, line: int, text: str) -> dict:
+        p = self._resolve(path)
+        if not p.exists():
+            return {"success": False, "error": "File not found"}
+        try:
+            content = p.read_text(encoding="utf-8")
+            lines = content.split("\n")
+            self._undo_stack.append({"path": str(p), "content": content})
+            if line == -1:
+                lines.insert(0, text)
+            elif line < len(lines):
+                lines.insert(line + 1, text)
+            else:
+                lines.append(text)
+            new_content = "\n".join(lines)
+            p.write_text(new_content, encoding="utf-8")
+            return {"success": True, "path": str(p)}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def undo_edit(self, path: str) -> dict:
+        p = self._resolve(path)
+        if not self._undo_stack:
+            return {"success": False, "error": "No edit history to undo"}
+        try:
+            for i in range(len(self._undo_stack) - 1, -1, -1):
+                snapshot = self._undo_stack[i]
+                if snapshot["path"] == str(p):
+                    p.write_text(snapshot["content"], encoding="utf-8")
+                    self._undo_stack.pop(i)
+                    return {"success": True, "path": str(p), "message": "Edit undone"}
+            return {"success": False, "error": f"No edit history for {path}"}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    def glob(self, pattern: str, path: Optional[str] = None) -> list[str]:
+        base = self._resolve(path) if path else self.workspace
+        try:
+            matches = list(base.glob(pattern))
+            return sorted([str(m.relative_to(base)) for m in matches])
+        except Exception:
+            return []
+
+    def grep(self, pattern: str, include: Optional[str] = None, path: Optional[str] = None) -> list[str]:
+        base = self._resolve(path) if path else self.workspace
+        cmd = ["grep", "-rn", pattern, str(base)]
+        if include:
+            cmd.extend(["--include", include])
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+            return result.stdout.split("\n")
+        except Exception:
+            return []
+
+    async def grep_async(self, pattern: str, include: Optional[str] = None, path: Optional[str] = None) -> list[str]:
+        base = self._resolve(path) if path else self.workspace
+        cmd = ["grep", "-rn", pattern, str(base)]
+        if include:
+            cmd.extend(["--include", include])
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, _ = await asyncio.wait_for(process.communicate(), timeout=30)
+            return stdout.decode("utf-8", errors="replace").split("\n")
+        except Exception:
+            return []
+
+    def list(self, path: str = ".") -> list[dict]:
+        p = self._resolve(path)
+        if not p.exists():
+            return [{"error": "Path not found"}]
+        if p.is_file():
+            return [{"name": p.name, "type": "file", "size": p.stat().st_size}]
+        items = []
+        for child in p.iterdir():
+            items.append({
+                "name": child.name,
+                "type": "dir" if child.is_dir() else "file",
+                "size": child.stat().st_size if child.is_file() else 0
+            })
+        return sorted(items, key=lambda x: x["name"])
+
+    def _resolve(self, path: str) -> Path:
+        p = Path(path)
+        if not p.is_absolute():
+            p = self.workspace / p
+        return p.resolve()
+
+    def _is_within_workspace(self, p: Path) -> bool:
+        try:
+            p.resolve().relative_to(self.workspace.resolve())
+            return True
+        except ValueError:
+            return False
+
+
+class ShellTool:
+    """Shell execution with safety checks.
+
+    Permission (ALLOW / ASK / DENY) is handled at the engine level via
+    ``_check_tool_permission``.  This class only enforces command-level
+    safety rules (dangerous patterns, sandboxing).
+    """
+
+    def __init__(
+        self,
+        workspace: Optional[Path] = None,
+        permission_set: Optional[PermissionSet] = None,
+        sandbox_mode: str = "auto",
+    ):
+        self.workspace = workspace or Path.cwd()
+        self._checker = PermissionChecker(permission_set or create_safe_permission_set())
+        self._sandbox = create_sandbox(self.workspace, mode=sandbox_mode)
+
+    def exec(self, cmd: str, cwd: Optional[str] = None, timeout: int = 60) -> dict:
+        result = self._checker.check_command(cmd)
+        if result.value == "deny":
+            return {"success": False, "error": "Command not allowed", "requires_approval": False}
+        if result.value == "ask":
+            return {"success": False, "error": "Command requires approval", "requires_approval": True}
+
+        work_dir = Path(cwd) if cwd else self.workspace
+        if not work_dir.is_relative_to(self.workspace.resolve()):
+            return {"success": False, "error": "CWD outside workspace"}
+
+        return self._sandbox.exec(cmd, timeout=timeout)
+
+    async def exec_async(
+        self, cmd: str,
+        cwd: Optional[str] = None,
+        timeout: int = 60,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> dict:
+        result = self._checker.check_command(cmd)
+        if result.value == "deny":
+            return {"success": False, "error": "Command not allowed", "requires_approval": False}
+        if result.value == "ask":
+            return {"success": False, "error": "Command requires approval", "requires_approval": True}
+
+        work_dir = Path(cwd) if cwd else self.workspace
+        if not work_dir.is_relative_to(self.workspace.resolve()):
+            return {"success": False, "error": "CWD outside workspace"}
+
+        return await self._sandbox.exec_async(cmd, timeout=timeout, cancel_check=cancel_check)
+
+
+class ToolFactory:
+    @staticmethod
+    def create_file_ops(workspace: Optional[Path] = None) -> FileOps:
+        return FileOps(workspace)
+
+    @staticmethod
+    def create_shell(workspace: Optional[Path] = None) -> ShellTool:
+        return ShellTool(workspace)