@scemoon/cdh 1.0.0

package/onecode/agent/attachments.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import fnmatch
+import mimetypes
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+
+ALLOWED_EXTENSIONS = {".txt", ".md", ".py", ".json", ".yaml", ".yml", ".sql", ".sh", ".bash", ".zsh", ".toml", ".ini", ".cfg", ".conf", ".log"}
+DEFAULT_MAX_SIZE_MB = 10
+
+
+@dataclass
+class Attachment:
+    path: str
+    alias: Optional[str] = None
+    content: Optional[str] = None
+    size: int = 0
+    mime_type: Optional[str] = None
+    error: Optional[str] = None
+
+    @property
+    def name(self) -> str:
+        return self.alias or Path(self.path).name
+
+    @property
+    def display_name(self) -> str:
+        return f"{self.name} ({self.path})"
+
+
+@dataclass
+class AttachmentSet:
+    _items: list = field(default_factory=list)
+    max_size_mb: int = DEFAULT_MAX_SIZE_MB
+    allowed_extensions: set = field(default_factory=lambda: ALLOWED_EXTENSIONS.copy())
+
+    def attach(self, path: str, alias: Optional[str] = None) -> Attachment:
+        p = Path(path)
+        if not p.exists():
+            att = Attachment(path=path, alias=alias, error="File not found")
+            self._items.append(att)
+            return att
+
+        if not p.is_file():
+            att = Attachment(path=path, alias=alias, error="Not a file")
+            self._items.append(att)
+            return att
+
+        size = p.stat().st_size
+        if size > self.max_size_mb * 1024 * 1024:
+            att = Attachment(path=path, alias=alias, size=size, error=f"File too large (max {self.max_size_mb}MB)")
+            self._items.append(att)
+            return att
+
+        ext = p.suffix.lower()
+        if ext not in self.allowed_extensions and not self._is_text_file(p):
+            att = Attachment(path=path, alias=alias, size=size, error="File type not allowed")
+            self._items.append(att)
+            return att
+
+        try:
+            content = p.read_text(encoding="utf-8")
+            mime = mimetypes.guess_type(str(p))[0]
+            att = Attachment(path=path, alias=alias, content=content, size=size, mime_type=mime)
+            self._items.append(att)
+            return att
+        except Exception as e:
+            att = Attachment(path=path, alias=alias, size=size, error=str(e))
+            self._items.append(att)
+            return att
+
+    def attach_glob(self, pattern: str, base: Optional[str] = None) -> list[Attachment]:
+        base_path = Path(base) if base else Path.cwd()
+        results = []
+        for p in base_path.glob(pattern):
+            if p.is_file():
+                results.append(self.attach(str(p)))
+        return results
+
+    def get(self, index: int) -> Optional[Attachment]:
+        if 0 <= index < len(self._items):
+            return self._items[index]
+        return None
+
+    def list(self) -> list[Attachment]:
+        return self._items
+
+    def clear(self) -> None:
+        self._items = []
+
+    def remove(self, index: int) -> bool:
+        if 0 <= index < len(self._items):
+            self._items.pop(index)
+            return True
+        return False
+
+    def get_context_text(self) -> str:
+        parts = []
+        for i, att in enumerate(self._items):
+            if att.error:
+                parts.append(f"[Attachment {i+1}] {att.display_name}: ERROR - {att.error}")
+            else:
+                parts.append(f"[Attachment {i+1}] {att.display_name}:\n```\n{att.content[:2000]}{'...' if len(att.content) > 2000 else ''}\n```")
+        return "\n\n".join(parts) if parts else ""
+
+    def _is_text_file(self, p: Path) -> bool:
+        try:
+            with open(str(p), "r", encoding="utf-8") as f:
+                f.read(1024)
+            return True
+        except Exception:
+            return False

package/onecode/agent/cdh_loader.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+def _walk_up_parents(workspace_root: Path):
+    """Yield workspace root, then git root.
+
+    Unlike :class:`~onecode.skills.loader.SkillLoader` we deliberately do
+    **not** yield ``Path.home()`` — the global ``~/.onecode/`` is the onecode
+    user-config directory, not a project-level ``.cdh/``, so including it
+    would cause false-positive matches.
+    """
+    current = workspace_root.resolve()
+    yield current
+    try:
+        git_root = next(
+            (
+                p
+                for p in current.parents
+                if (p / ".git").exists() or (p / ".hg").exists()
+            ),
+            None,
+        )
+        if git_root:
+            yield git_root
+    except StopIteration:
+        pass
+
+
+class CdhProjectLoader:
+    """Load project-level ``.cdh/`` state and inject it into agent context.
+
+    Looks for ``.cdh/`` by walking up from the workspace root to the git
+    root, then the home directory — the same pattern used by
+    :class:`~onecode.skills.loader.SkillLoader` for skill discovery.
+    """
+
+    CDH_DIRNAME = ".cdh"
+    LAST_SESSION_FILENAME = "last_session.json"
+    TASKS_FILENAME = "tasks.json"
+    PERMISSIONS_FILENAME = "permissions.json"
+
+    # ── discovery ──────────────────────────────────────────────
+
+    @staticmethod
+    def find_cdh_dir(workspace_root: Path) -> Optional[Path]:
+        """Walk up parent directories looking for a ``.cdh/`` folder.
+
+        Returns the first match (nearest ancestor wins), or ``None`` if
+        none of the ancestor trees contain a ``.cdh/`` directory.
+        """
+        for parent in _walk_up_parents(workspace_root):
+            candidate = parent / CdhProjectLoader.CDH_DIRNAME
+            if candidate.is_dir():
+                return candidate
+        return None
+
+    # ── file readers ───────────────────────────────────────────
+
+    @staticmethod
+    def load_project_config(cdh_dir: Path) -> dict:
+        """Read ``.cdh/config.yaml`` (preferred) or ``.cdh/config.json``."""
+        yaml_path = cdh_dir / "config.yaml"
+        if yaml_path.exists():
+            try:
+                return yaml.safe_load(yaml_path.read_text(encoding="utf-8")) or {}
+            except Exception:
+                pass
+        json_path = cdh_dir / "config.json"
+        if json_path.exists():
+            try:
+                return json.loads(json_path.read_text(encoding="utf-8"))
+            except Exception:
+                pass
+        return {}
+
+    @staticmethod
+    def load_project_state(cdh_dir: Path) -> dict:
+        """Read ``.cdh/state.json``."""
+        state_path = cdh_dir / "state.json"
+        if state_path.exists():
+            try:
+                return json.loads(state_path.read_text(encoding="utf-8"))
+            except Exception:
+                pass
+        return {}
+
+    @staticmethod
+    def get_skill_content(cdh_dir: Path) -> str:
+        """Read ``.cdh/SKILL.md`` if it exists."""
+        skill_path = cdh_dir / "SKILL.md"
+        if skill_path.exists():
+            try:
+                return skill_path.read_text(encoding="utf-8")
+            except Exception:
+                pass
+        return ""
+
+    # ── last-session persistence ───────────────────────────────
+
+    @staticmethod
+    def save_last_session(cdh_dir: Path, session_data: dict) -> None:
+        """Save last session info to ``.cdh/last_session.json``."""
+        path = cdh_dir / CdhProjectLoader.LAST_SESSION_FILENAME
+        path.write_text(
+            json.dumps(session_data, ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+
+    @staticmethod
+    def load_last_session(cdh_dir: Path) -> dict:
+        """Load last session info from ``.cdh/last_session.json``."""
+        path = cdh_dir / CdhProjectLoader.LAST_SESSION_FILENAME
+        if path.exists():
+            try:
+                return json.loads(path.read_text(encoding="utf-8"))
+            except Exception:
+                pass
+        return {}
+
+    # ── task persistence ───────────────────────────────────────
+
+    @staticmethod
+    def save_tasks(cdh_dir: Path, tasks_data: dict) -> None:
+        """Save tasks/todos to ``.cdh/tasks.json``."""
+        path = cdh_dir / CdhProjectLoader.TASKS_FILENAME
+        path.write_text(
+            json.dumps(tasks_data, ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+
+    @staticmethod
+    def load_tasks(cdh_dir: Path) -> dict:
+        """Load tasks/todos from ``.cdh/tasks.json``."""
+        path = cdh_dir / CdhProjectLoader.TASKS_FILENAME
+        if path.exists():
+            try:
+                return json.loads(path.read_text(encoding="utf-8"))
+            except Exception:
+                pass
+        return {}
+
+    # ── permission persistence ─────────────────────────────────
+
+    @staticmethod
+    def save_permissions(cdh_dir: Path, perm_data: dict) -> None:
+        """Save permission overrides to ``.cdh/permissions.json``."""
+        path = cdh_dir / CdhProjectLoader.PERMISSIONS_FILENAME
+        path.write_text(
+            json.dumps(perm_data, ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+
+    @staticmethod
+    def load_permissions(cdh_dir: Path) -> dict:
+        """Load permission overrides from ``.cdh/permissions.json``."""
+        path = cdh_dir / CdhProjectLoader.PERMISSIONS_FILENAME
+        if path.exists():
+            try:
+                return json.loads(path.read_text(encoding="utf-8"))
+            except Exception:
+                pass
+        return {}
+
+    # ── public API ─────────────────────────────────────────────
+
+    @staticmethod
+    def load_for_workspace(workspace_root: Path) -> str:
+        """Find ``.cdh/`` and return formatted context text, or ``""``."""
+        cdh_dir = CdhProjectLoader.find_cdh_dir(workspace_root)
+        if cdh_dir is None:
+            return ""
+
+        config = CdhProjectLoader.load_project_config(cdh_dir)
+        state = CdhProjectLoader.load_project_state(cdh_dir)
+        skill = CdhProjectLoader.get_skill_content(cdh_dir)
+
+        parts = ["## Project State (.cdh)"]
+        name = config.get("name", cdh_dir.parent.name)
+        parts.append(f"- Name: {name}")
+        parts.append(f"- Path: {cdh_dir.parent}")
+        phase = state.get("current_phase", config.get("phase", ""))
+        if phase:
+            parts.append(f"- Phase: {phase}")
+        platform = config.get("platform", "")
+        if platform:
+            parts.append(f"- Platform: {platform}")
+        if config:
+            parts.append(f"- Config: {json.dumps(config, ensure_ascii=False)}")
+        if state:
+            parts.append(f"- State: {json.dumps(state, ensure_ascii=False)}")
+        if skill:
+            parts.append(f"\n--- .cdh/SKILL.md ---\n{skill}")
+
+        parts.append(
+            "\n**Important**: Work directly in the project root directory shown above. "
+            "Do NOT create a subdirectory named after the project — all files go "
+            "directly under the project root."
+        )
+
+        return "\n".join(parts)
+
+    # ── scaffolding ────────────────────────────────────────────
+
+    @staticmethod
+    def init_project(
+        workspace_root: Path,
+        name: str,
+        platform: str = "",
+        phase: str = "init",
+    ) -> Path:
+        """Scaffold a ``.cdh/`` directory inside *workspace_root*.
+
+        Creates ``.cdh/config.yaml``, ``.cdh/state.json``, and a
+        stub ``.cdh/SKILL.md``.
+
+        If *workspace_root* is inside a directory that is already a
+        ``.cdh/`` project, a warning is printed and the existing project
+        root is returned (auto-correct) instead of raising an error.
+        """
+        workspace_root = workspace_root.resolve()
+        existing = CdhProjectLoader.find_cdh_dir(workspace_root)
+        if existing is not None:
+            if existing.parent != workspace_root:
+                import sys as _sys
+                print(
+                    f"⚠ {workspace_root} is inside an existing project at "
+                    f"{existing.parent}. Auto-correcting to use that project.",
+                    file=_sys.stderr,
+                )
+                return existing
+            cdh_dir = existing
+        else:
+            cdh_dir = workspace_root / CdhProjectLoader.CDH_DIRNAME
+            cdh_dir.mkdir(parents=True, exist_ok=True)
+
+        config = {"name": name}
+        if platform:
+            config["platform"] = platform
+        if phase:
+            config["phase"] = phase
+        config_path = cdh_dir / "config.yaml"
+        config_path.write_text(yaml.dump(config, default_flow_style=False), encoding="utf-8")
+
+        state = {"current_phase": phase}
+        state_path = cdh_dir / "state.json"
+        state_path.write_text(json.dumps(state, ensure_ascii=False, indent=2), encoding="utf-8")
+
+        skill_path = cdh_dir / "SKILL.md"
+        if not skill_path.exists():
+            skill_path.write_text(
+                f"# {name} — Project Instructions\n\n"
+                "Add project-specific agent instructions here.\n",
+                encoding="utf-8",
+            )
+
+        return cdh_dir