@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/onecode/agent/tools/config_tool.py

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

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

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

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