@scemoon/cdh 1.0.0

package/onecode/agent/tools/cron_tools.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import asyncio
+import json
+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 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:
+    """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:
+    """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:
+    """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,187 @@
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from onecode.agent.permissions import PermissionChecker, PermissionSet, create_safe_permission_set
+from onecode.agent.tools.sandbox import Sandbox, SandboxConfig, SandboxMode, ResourceLimits, 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 []
+
+    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)
+
+
+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

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional
+
+from onecode.agent.tools.file_ops import FileOps
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import ToolSpec
+
+
+class ReadTool:
+    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:
+    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:
+    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:
+    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:
+    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:
+    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:
+    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:
+    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))
+