@scemoon/cdh 1.0.6 → 1.0.7

package/onecode/agent/permissions.py

@@ -1,150 +0,0 @@
-from __future__ import annotations
-
-import fnmatch
-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

@@ -1,62 +0,0 @@
-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/project_doc.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-
-def load_project_doc(workspace_root: Path) -> str:
-    """Read ``AGENTS.md`` at the project root if present.
-
-    Convention mirrors ``AGENTS.md`` / ``CLAUDE.md``: exactly one file at
-    the workspace root that all AI agents must read.  Unlike skills,
-    this is not registered — it's injected directly as project context.
-    """
-    path = workspace_root.resolve() / "AGENTS.md"
-    if not path.exists():
-        return ""
-    try:
-        return path.read_text(encoding="utf-8")
-    except Exception:
-        return ""

package/onecode/agent/session.py

@@ -1,195 +0,0 @@
-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
-    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,
-            "todos": self.todos,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> SessionData:
-        # Merge legacy ``tasks`` and ``todos`` fields into the unified
-        # ``todos`` list.  Older sessions stored them as two separate lists;
-        # TodoManager.from_dict already handles the legacy entry shape, so
-        # we just concatenate here.
-        legacy_todos: list[dict] = []
-        legacy_todos.extend(data.get("tasks") or [])
-        legacy_todos.extend(data.get("todos") or [])
-        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"),
-            todos=legacy_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
-
-    def _default_storage_path(self) -> Path:
-        cdh_sessions = Path.home() / ".cdh" / "sessions"
-        # One-time self-heal: move sessions incorrectly saved to ~/.onecode/sessions/
-        # back to the cdh platform-level directory (B mapping mode).
-        onecode_sessions = Path.home() / ".onecode" / "sessions"
-        marker = cdh_sessions / ".migrated_from_onecode"
-        if not marker.exists() and onecode_sessions.exists():
-            try:
-                cdh_sessions.mkdir(parents=True, exist_ok=True)
-                for f in list(onecode_sessions.glob("*.json"))[:250]:
-                    dst = cdh_sessions / f.name
-                    if not dst.exists():
-                        import shutil
-                        shutil.move(str(f), str(dst))
-                marker.write_text("migrated", encoding="utf-8")
-            except Exception as e:
-                logger.warning("Failed to migrate onecode sessions to cdh: %s", e)
-        return cdh_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 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"]
-        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

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-import fnmatch
-import json
-import os
-import shutil
-import tarfile
-import uuid
-from dataclasses import dataclass
-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 ONECODE_DIR
-        self.base_path = base_path or (ONECODE_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

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