@scemoon/cdh 1.0.0

package/onecode/agent/permissions.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import fnmatch
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+
+class PermissionResult(Enum):
+    ALLOW = "allow"
+    DENY = "deny"
+    ASK = "ask"
+
+
+@dataclass
+class PathRule:
+    pattern: str
+    permission: PermissionResult = PermissionResult.ALLOW
+
+    def matches(self, path: str) -> bool:
+        return (
+            fnmatch.fnmatch(path, self.pattern) or
+            fnmatch.fnmatch(Path(path).name, self.pattern) or
+            fnmatch.fnmatch(Path(path).stem, self.pattern)
+        )
+
+
+@dataclass
+class CommandRule:
+    pattern: str
+    permission: PermissionResult = PermissionResult.ALLOW
+
+    def matches(self, cmd: str) -> bool:
+        normalized = cmd.strip()
+        if fnmatch.fnmatch(normalized, self.pattern):
+            return True
+        parts = normalized.split()
+        if parts:
+            cmd_base = parts[0]
+            args = " ".join(parts[1:]) if len(parts) > 1 else ""
+            if args and fnmatch.fnmatch(f"{cmd_base} {args}", self.pattern):
+                return True
+            if fnmatch.fnmatch(cmd_base, self.pattern):
+                return True
+        return False
+
+
+@dataclass
+class PermissionSet:
+    path_rules: list[PathRule] = field(default_factory=list)
+    command_rules: list[CommandRule] = field(default_factory=list)
+    default_path_permission: PermissionResult = PermissionResult.ALLOW
+    default_command_permission: PermissionResult = PermissionResult.ALLOW
+
+    def check_path(self, path: str) -> PermissionResult:
+        matched = self.default_path_permission
+        for rule in self.path_rules:
+            if rule.matches(path):
+                matched = rule.permission
+        return matched
+
+    def check_command(self, cmd: str) -> PermissionResult:
+        matched = self.default_command_permission
+        for rule in self.command_rules:
+            if rule.matches(cmd):
+                matched = rule.permission
+        return matched
+
+    def allow_path(self, pattern: str) -> None:
+        self.path_rules.append(PathRule(pattern, PermissionResult.ALLOW))
+
+    def deny_path(self, pattern: str) -> None:
+        self.path_rules.append(PathRule(pattern, PermissionResult.DENY))
+
+    def ask_path(self, pattern: str) -> None:
+        self.path_rules.append(PathRule(pattern, PermissionResult.ASK))
+
+    def allow_command(self, pattern: str) -> None:
+        self.command_rules.append(CommandRule(pattern, PermissionResult.ALLOW))
+
+    def deny_command(self, pattern: str) -> None:
+        self.command_rules.append(CommandRule(pattern, PermissionResult.DENY))
+
+    def ask_command(self, pattern: str) -> None:
+        self.command_rules.append(CommandRule(pattern, PermissionResult.ASK))
+
+    @classmethod
+    def from_config(cls, config: dict) -> "PermissionSet":
+        ps = cls()
+        perm_map = {"allow": PermissionResult.ALLOW, "ask": PermissionResult.ASK, "deny": PermissionResult.DENY}
+
+        if "path" in config:
+            for pattern, action in config["path"].items():
+                if action in perm_map:
+                    getattr(ps, f"{action}_path")(pattern)
+
+        if "command" in config:
+            for pattern, action in config["command"].items():
+                if action in perm_map:
+                    getattr(ps, f"{action}_command")(pattern)
+
+        if "default" in config:
+            default = config["default"]
+            if "path" in default and default["path"] in perm_map:
+                ps.default_path_permission = perm_map[default["path"]]
+            if "command" in default and default["command"] in perm_map:
+                ps.default_command_permission = perm_map[default["command"]]
+
+        return ps
+
+
+class PermissionChecker:
+    def __init__(self, permission_set: Optional[PermissionSet] = None):
+        self.permission_set = permission_set or PermissionSet()
+
+    def check_file_read(self, path: str) -> PermissionResult:
+        return self.permission_set.check_path(path)
+
+    def check_file_write(self, path: str) -> PermissionResult:
+        return self.permission_set.check_path(path)
+
+    def check_command(self, cmd: str) -> PermissionResult:
+        return self.permission_set.check_command(cmd)
+
+    def is_allowed(self, permission: PermissionResult) -> bool:
+        return permission == PermissionResult.ALLOW
+
+    def is_denied(self, permission: PermissionResult) -> bool:
+        return permission == PermissionResult.DENY
+
+    def requires_approval(self, permission: PermissionResult) -> bool:
+        return permission == PermissionResult.ASK
+
+
+def create_safe_permission_set() -> PermissionSet:
+    ps = PermissionSet()
+    ps.deny_path("**/.env")
+    ps.deny_path("**/secrets/**")
+    ps.deny_path("**/credentials/**")
+    ps.deny_command("rm -rf /")
+    ps.deny_command("rm -rf /*")
+    ps.deny_command("dd if=*")
+    ps.deny_command("mkfs.*")
+    ps.deny_command(":(){:|:&};:")
+    ps.ask_command("sudo *")
+    ps.ask_command("chmod 777 *")
+    ps.ask_command("curl *")
+    ps.ask_command("wget *")
+    return ps

package/onecode/agent/permissions_store.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from onecode.agent.agents.types import AgentPermission
+
+
+class PermissionStore:
+    """Persists user-defined allow_always / reject_always overrides across
+    ``set_agent()`` calls so permissions survive mode switches.
+
+    Usage::
+
+        store = PermissionStore()
+        store.set_override("bash", AgentPermission.ALLOW)   # user said "Allow always"
+        store.set_override("edit", AgentPermission.DENY)    # user said "Reject always"
+        ...
+        store.apply_to(current_agent)                       # re-apply after set_agent
+    """
+
+    def __init__(self) -> None:
+        # perm_key → AgentPermission  (e.g. "bash" → AgentPermission.ALLOW)
+        self._overrides: dict[str, AgentPermission] = {}
+
+    def set_override(self, perm_key: str, perm: AgentPermission) -> None:
+        """Record a user override for the given permission key."""
+        self._overrides[perm_key] = perm
+
+    def get_override(self, perm_key: str) -> Optional[AgentPermission]:
+        return self._overrides.get(perm_key)
+
+    def clear_override(self, perm_key: str) -> None:
+        self._overrides.pop(perm_key, None)
+
+    def clear_all(self) -> None:
+        self._overrides.clear()
+
+    def apply_to(self, agent) -> None:
+        """Apply all recorded overrides to an AgentConfig instance.
+
+        Call this after ``set_agent()`` to restore the user's choices.
+        """
+        for perm_key, perm in self._overrides.items():
+            attr_name = f"permission_{perm_key}"
+            if hasattr(agent, attr_name):
+                setattr(agent, attr_name, perm)
+
+    def to_dict(self) -> dict[str, str]:
+        return {k: v.value for k, v in self._overrides.items()}
+
+    @classmethod
+    def from_dict(cls, d: dict[str, str]) -> PermissionStore:
+        store = cls()
+        for k, v in d.items():
+            try:
+                store._overrides[k] = AgentPermission(v)
+            except ValueError:
+                pass
+        return store
+
+    def snapshot(self) -> dict[str, AgentPermission]:
+        return dict(self._overrides)

package/onecode/agent/session.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import json
+import logging
+import uuid
+from datetime import datetime, timezone
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger("onecode.session")
+
+
+@dataclass
+class SessionData:
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    name: str = "Untitled"
+    mode: str = "build"
+    project: str = ""
+    model: str = ""
+    provider: str = ""
+    messages: list[dict] = field(default_factory=list)
+    lifecycle_state: dict = field(default_factory=dict)
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    tasks: list[dict] = field(default_factory=list)
+    todos: list[dict] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "mode": self.mode,
+            "project": self.project,
+            "model": self.model,
+            "provider": self.provider,
+            "messages": self.messages,
+            "lifecycle_state": self.lifecycle_state,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "tasks": self.tasks,
+            "todos": self.todos,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> SessionData:
+        return cls(
+            id=data.get("id", str(uuid.uuid4())),
+            name=data.get("name", "Untitled"),
+            mode=data.get("mode", "build"),
+            project=data.get("project", ""),
+            model=data.get("model", ""),
+            provider=data.get("provider", ""),
+            messages=data.get("messages", []),
+            lifecycle_state=data.get("lifecycle_state", {}),
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at"),
+            tasks=data.get("tasks", []),
+            todos=data.get("todos", []),
+        )
+
+
+class AgentSession:
+    def __init__(self, session_id: Optional[str] = None, storage_path: Optional[Path] = None):
+        self.storage_path = storage_path or self._default_storage_path()
+        self._data: SessionData = SessionData()
+        if session_id:
+            self._data.id = session_id
+            self.load()
+
+    def _default_storage_path(self) -> Path:
+        from onecode.config import CLOUD_DEV_HARNESS_DIR
+        return CLOUD_DEV_HARNESS_DIR / "sessions"
+
+    @property
+    def id(self) -> str:
+        return self._data.id
+
+    @property
+    def name(self) -> str:
+        return self._data.name
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._data.name = value
+
+    @property
+    def messages(self) -> list[dict]:
+        return self._data.messages
+
+    @messages.setter
+    def messages(self, value: list[dict]) -> None:
+        self._data.messages = value
+
+    @property
+    def lifecycle_state(self) -> dict:
+        return self._data.lifecycle_state
+
+    @property
+    def tasks(self) -> list[dict]:
+        return self._data.tasks
+
+    @tasks.setter
+    def tasks(self, value: list[dict]) -> None:
+        self._data.tasks = value
+
+    @property
+    def todos(self) -> list[dict]:
+        return self._data.todos
+
+    @todos.setter
+    def todos(self, value: list[dict]) -> None:
+        self._data.todos = value
+
+    def add_message(self, role: str, content: str) -> None:
+        self._data.messages.append({"role": role, "content": content})
+        self._touch()
+
+    def compact_messages(self, summary: str) -> None:
+        if len(self._data.messages) <= 2:
+            return
+        system_msgs = [m for m in self._data.messages if m.get("role") == "system"]
+        other_msgs = [m for m in self._data.messages if m.get("role") != "system"]
+        self._data.messages = system_msgs + [
+            {"role": "system", "content": f"[Previous context summarized]\n{summary}"}
+        ]
+        self._touch()
+
+    def update_state(self, key: str, value: any) -> None:
+        self._data.lifecycle_state[key] = value
+        self._touch()
+
+    def get_state(self, key: str, default: any = None) -> any:
+        return self._data.lifecycle_state.get(key, default)
+
+    def save(self) -> None:
+        self.storage_path.mkdir(parents=True, exist_ok=True)
+        file_path = self.storage_path / f"{self._data.id}.json"
+        self._data.updated_at = datetime.now(timezone.utc).isoformat()
+        file_path.write_text(json.dumps(self._data.to_dict(), indent=2, ensure_ascii=False), encoding="utf-8")
+
+    def load(self) -> bool:
+        file_path = self.storage_path / f"{self._data.id}.json"
+        if not file_path.exists():
+            return False
+        try:
+            data = json.loads(file_path.read_text(encoding="utf-8"))
+            self._data = SessionData.from_dict(data)
+            return True
+        except Exception as e:
+            logger.warning("Failed to load session %s: %s", self._data.id, e)
+            return False
+
+    def delete(self) -> None:
+        file_path = self.storage_path / f"{self._data.id}.json"
+        if file_path.exists():
+            file_path.unlink()
+
+    def _touch(self) -> None:
+        self._data.updated_at = datetime.now(timezone.utc).isoformat()
+
+    @classmethod
+    def list_sessions(cls, storage_path: Optional[Path] = None) -> list[SessionData]:
+        path = storage_path or cls()._default_storage_path()
+        if not path.exists():
+            return []
+        sessions = []
+        for f in path.glob("*.json"):
+            try:
+                data = json.loads(f.read_text(encoding="utf-8"))
+                sessions.append(SessionData.from_dict(data))
+            except Exception:
+                continue
+        return sorted(sessions, key=lambda s: s.updated_at or "", reverse=True)
+
+    @classmethod
+    def delete_by_id(cls, session_id: str, storage_path: Optional[Path] = None) -> bool:
+        path = storage_path or cls()._default_storage_path()
+        file_path = path / f"{session_id}.json"
+        if file_path.exists():
+            file_path.unlink()
+            return True
+        return False
+
+    def to_dict(self) -> dict:
+        return self._data.to_dict()

package/onecode/agent/snapshot.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import fnmatch
+import json
+import os
+import shutil
+import tarfile
+import tempfile
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class SnapshotInfo:
+    id: str
+    name: str
+    timestamp: str
+    description: str
+    size_bytes: int
+    file_count: int
+
+
+class SnapshotManager:
+    def __init__(self, base_path: Optional[Path] = None):
+        from onecode.config import CLOUD_DEV_HARNESS_DIR
+        self.base_path = base_path or (CLOUD_DEV_HARNESS_DIR / "snapshots")
+        self.base_path.mkdir(parents=True, exist_ok=True)
+
+    def create(
+        self,
+        workspace: Path,
+        name: str,
+        description: str = "",
+        exclude_patterns: Optional[list[str]] = None,
+    ) -> SnapshotInfo:
+        snapshot_id = str(uuid.uuid4())[:8]
+        snapshot_dir = self.base_path / snapshot_id
+        snapshot_dir.mkdir(parents=True, exist_ok=True)
+
+        tar_path = snapshot_dir / "snapshot.tar.gz"
+        manifest_path = snapshot_dir / "manifest.json"
+
+        exclude_patterns = exclude_patterns or [
+            ".git",
+            "node_modules",
+            "__pycache__",
+            "*.pyc",
+            ".pytest_cache",
+            ".venv",
+            "venv",
+            ".env",
+            "*.egg-info",
+            ".cdh",
+            "snapshots",
+        ]
+
+        file_count = 0
+        with tarfile.open(str(tar_path), "w:gz") as tar:
+            for root, dirs, files in os.walk(workspace):
+                dirs[:] = [d for d in dirs if not self._should_exclude(d, exclude_patterns)]
+
+                for file in files:
+                    file_path = Path(root) / file
+                    if not self._should_exclude(file_path.name, exclude_patterns):
+                        try:
+                            tar.add(str(file_path), arcname=str(file_path.relative_to(workspace)))
+                            file_count += 1
+                        except Exception:
+                            pass
+
+        size_bytes = tar_path.stat().st_size
+
+        manifest = {
+            "id": snapshot_id,
+            "name": name,
+            "description": description,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "workspace": str(workspace),
+            "file_count": file_count,
+            "size_bytes": size_bytes,
+        }
+        manifest_path.write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+
+        return SnapshotInfo(
+            id=snapshot_id,
+            name=name,
+            timestamp=manifest["timestamp"],
+            description=description,
+            size_bytes=size_bytes,
+            file_count=file_count,
+        )
+
+    def restore(self, snapshot_id: str, target_dir: Path) -> bool:
+        snapshot_dir = self.base_path / snapshot_id
+        if not snapshot_dir.exists():
+            return False
+
+        tar_path = snapshot_dir / "snapshot.tar.gz"
+        if not tar_path.exists():
+            return False
+
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        with tarfile.open(str(tar_path), "r:gz") as tar:
+            tar.extractall(target_dir)
+
+        return True
+
+    def list(self) -> list[SnapshotInfo]:
+        snapshots = []
+        for snapshot_dir in self.base_path.iterdir():
+            if not snapshot_dir.is_dir():
+                continue
+            manifest_path = snapshot_dir / "manifest.json"
+            if not manifest_path.exists():
+                continue
+            try:
+                manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+                snapshots.append(SnapshotInfo(
+                    id=manifest["id"],
+                    name=manifest["name"],
+                    timestamp=manifest["timestamp"],
+                    description=manifest.get("description", ""),
+                    size_bytes=manifest.get("size_bytes", 0),
+                    file_count=manifest.get("file_count", 0),
+                ))
+            except Exception:
+                continue
+        return sorted(snapshots, key=lambda s: s.timestamp, reverse=True)
+
+    def delete(self, snapshot_id: str) -> bool:
+        snapshot_dir = self.base_path / snapshot_id
+        if snapshot_dir.exists():
+            shutil.rmtree(snapshot_dir)
+            return True
+        return False
+
+    def _should_exclude(self, name: str, patterns: list[str]) -> bool:
+        for pattern in patterns:
+            if fnmatch.fnmatch(name, pattern):
+                return True
+        return False

package/onecode/agent/tools/__init__.py

@@ -0,0 +1,17 @@
+from onecode.agent.tools.file_ops import FileOps, ShellTool, ToolFactory
+from onecode.agent.tools.protocol import ToolCall, ToolResult
+from onecode.agent.tools.errors import ToolError, ToolInputError, ToolPermissionError, ToolExecutionError
+from onecode.agent.tools.registry import Tool, ToolRegistry, ToolSpec
+from onecode.agent.tools.permissions import ToolPermissionContext, PermissionResult
+from onecode.agent.tools.permission_handler import InteractivePermissionHandler, PermissionDecision, PermissionHandler
+from onecode.agent.tools.schema_validation import validate_json_schema
+
+__all__ = [
+    "FileOps", "ShellTool", "ToolFactory",
+    "ToolCall", "ToolResult",
+    "ToolError", "ToolInputError", "ToolPermissionError", "ToolExecutionError",
+    "Tool", "ToolRegistry", "ToolSpec",
+    "ToolPermissionContext", "PermissionResult",
+    "InteractivePermissionHandler", "PermissionDecision", "PermissionHandler",
+    "validate_json_schema",
+]