@scemoon/cdh 1.0.6 → 1.0.8

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)

package/onecode/agent/tools/file_tools.py

@@ -1,225 +0,0 @@
-from __future__ import annotations
-
-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 ReadTool(Tool):
-    def __init__(self, file_ops: FileOps):
-        self._file_ops = file_ops
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="Read",
-            description="Read file contents with optional line range. Returns content with line numbers.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "path": {"type": "string", "description": "File path relative to workspace"},
-                    "offset": {"type": "integer", "description": "Starting line offset (0-based)", "default": 0},
-                    "limit": {"type": "integer", "description": "Max lines to read (0 = all)", "default": 0},
-                },
-                "required": ["path"],
-            },
-            is_read_only=True,
-            max_result_size_chars=200_000,
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        path = tool_input.get("path", "")
-        offset = tool_input.get("offset", 0)
-        limit = tool_input.get("limit", 0)
-        content = self._file_ops.read(path, offset, limit)
-        is_error = str(content).startswith("Error") or str(content).startswith("File not found")
-        return ToolResult(name="Read", output=str(content), is_error=is_error)
-
-
-
-class WriteTool(Tool):
-    def __init__(self, file_ops: FileOps):
-        self._file_ops = file_ops
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="Write",
-            description="Create or overwrite a file with content.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "path": {"type": "string", "description": "File path relative to workspace"},
-                    "content": {"type": "string", "description": "Full file content to write"},
-                },
-                "required": ["path", "content"],
-            },
-            is_destructive=True,
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        path = tool_input.get("path", "")
-        content = tool_input.get("content", "")
-        result = self._file_ops.write(path, content)
-        return ToolResult(name="Write", output=result, is_error=not result.get("success", True))
-
-
-
-class EditTool(Tool):
-    def __init__(self, file_ops: FileOps):
-        self._file_ops = file_ops
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="Edit",
-            description="Replace exact string in file. old_string MUST be unique — provide enough context.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "path": {"type": "string", "description": "File path relative to workspace"},
-                    "old_string": {"type": "string", "description": "Exact text to replace — must be unique"},
-                    "new_string": {"type": "string", "description": "Replacement text"},
-                },
-                "required": ["path", "old_string", "new_string"],
-            },
-            is_destructive=True,
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        path = tool_input.get("path", "")
-        old = tool_input.get("old_string", "")
-        new = tool_input.get("new_string", "")
-        result = self._file_ops.edit(path, old, new)
-        return ToolResult(name="Edit", output=result, is_error=not result.get("success", True))
-
-
-
-class InsertTool(Tool):
-    def __init__(self, file_ops: FileOps):
-        self._file_ops = file_ops
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="Insert",
-            description="Insert text at a specific line. line=-1 for beginning.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "path": {"type": "string", "description": "File path relative to workspace"},
-                    "line": {"type": "integer", "description": "Line number to insert after (-1 for beginning)"},
-                    "text": {"type": "string", "description": "Text to insert"},
-                },
-                "required": ["path", "line", "text"],
-            },
-            is_destructive=True,
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        path = tool_input.get("path", "")
-        line = tool_input.get("line", -1)
-        text = tool_input.get("text", "")
-        result = self._file_ops.insert(path, line, text)
-        return ToolResult(name="Insert", output=result, is_error=not result.get("success", True))
-
-
-
-class UndoEditTool(Tool):
-    def __init__(self, file_ops: FileOps):
-        self._file_ops = file_ops
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="UndoEdit",
-            description="Undo the most recent Edit/Insert operation on a file.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "path": {"type": "string", "description": "File path to undo last edit on"},
-                },
-                "required": ["path"],
-            },
-            is_destructive=True,
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        path = tool_input.get("path", "")
-        result = self._file_ops.undo_edit(path)
-        return ToolResult(name="UndoEdit", output=result, is_error=not result.get("success", True))
-
-
-
-class GlobTool(Tool):
-    def __init__(self, file_ops: FileOps):
-        self._file_ops = file_ops
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="Glob",
-            description="Find files matching a glob pattern (e.g. **/*.py).",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "pattern": {"type": "string", "description": "Glob pattern to match"},
-                },
-                "required": ["pattern"],
-            },
-            is_read_only=True,
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        pattern = tool_input.get("pattern", "")
-        result = self._file_ops.glob(pattern)
-        return ToolResult(name="Glob", output=str(result))
-
-
-
-class GrepTool(Tool):
-    def __init__(self, file_ops: FileOps):
-        self._file_ops = file_ops
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="Grep",
-            description="Search for regex pattern in files.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "pattern": {"type": "string", "description": "Regex pattern to search"},
-                    "include": {"type": "string", "description": "File pattern to filter (e.g. *.py)"},
-                },
-                "required": ["pattern"],
-            },
-            is_read_only=True,
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        pattern = tool_input.get("pattern", "")
-        include = tool_input.get("include")
-        result = self._file_ops.grep(pattern, include)
-        return ToolResult(name="Grep", output=str(result))
-
-
-
-class ListTool(Tool):
-    def __init__(self, file_ops: FileOps):
-        self._file_ops = file_ops
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="List",
-            description="List directory contents.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "path": {"type": "string", "description": "Directory path", "default": "."},
-                },
-                "required": [],
-            },
-            is_read_only=True,
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        path = tool_input.get("path", ".")
-        result = self._file_ops.list(path)
-        return ToolResult(name="List", output=str(result))
-