@scemoon/cdh 1.0.0

package/onecode/skills/argument_substitution.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+_PATH_RE = re.compile(r'\$path')
+_ARG_RE = re.compile(r'\$(\d+)')
+_ARGS_RE = re.compile(r'\$ARGUMENTS')
+
+
+def substitute_arguments(content: str, arguments: list[str] | None = None) -> str:
+    """Substitute positional arguments in skill content.
+
+    Supports:
+      $path        -> first argument
+      $0, $1, $2   -> positional arguments
+      $ARGUMENTS   -> all arguments joined by space
+    """
+    args = arguments or []
+    text = content
+
+    # $path -> first argument
+    if args:
+        text = _PATH_RE.sub(args[0], text)
+    else:
+        text = _PATH_RE.sub("", text)
+
+    # $0, $1, $2...
+    def _replace_arg(m: re.Match) -> str:
+        idx = int(m.group(1))
+        return args[idx] if idx < len(args) else ""
+
+    text = _ARG_RE.sub(_replace_arg, text)
+
+    # $ARGUMENTS -> all joined
+    text = _ARGS_RE.sub(" ".join(args), text)
+
+    return text

package/onecode/skills/create.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+SKILL_TEMPLATE = """---
+name: {name}
+description: {description}
+enabled: true
+---
+
+# {name} Skill
+
+## Description
+{description}
+
+## Usage
+When the user asks about {name}, follow these instructions:
+
+## Guidelines
+- Follow the project conventions
+- Use appropriate tools
+"""
+
+
+def create_skill_scaffold(
+    skills_dir: Path,
+    name: str,
+    description: str = "",
+) -> Optional[str]:
+    """Create a new skill directory with SKILL.md and skill.yaml.
+
+    Returns error message or None on success.
+    """
+    skill_path = skills_dir / name
+    if skill_path.exists():
+        return f"Skill '{name}' already exists at {skill_path}"
+
+    skill_path.mkdir(parents=True, exist_ok=True)
+
+    skill_md = skill_path / "SKILL.md"
+    skill_md.write_text(
+        SKILL_TEMPLATE.format(name=name, description=description or f"A skill for {name}"),
+        encoding="utf-8",
+    )
+
+    skill_yaml = skill_path / "skill.yaml"
+    skill_yaml.write_text(
+        yaml.dump({"name": name, "description": description, "enabled": True}, default_flow_style=False),
+        encoding="utf-8",
+    )
+
+    return None

package/onecode/skills/frontmatter.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import yaml
+
+
+_FRONTMATTER_RE = re.compile(
+    r'^---\s*\n(.*?)\n---\s*\n?',
+    re.DOTALL,
+)
+
+
+def parse_frontmatter(text: str) -> tuple[dict[str, Any], str]:
+    """Parse YAML frontmatter from markdown text.
+
+    Returns (frontmatter_dict, body_text). If no frontmatter,
+    frontmatter_dict is empty and body_text is the full text.
+    """
+    match = _FRONTMATTER_RE.match(text)
+    if not match:
+        return {}, text
+
+    yaml_block = match.group(1)
+    body = text[match.end():]
+
+    try:
+        frontmatter = yaml.safe_load(yaml_block) or {}
+    except yaml.YAMLError:
+        frontmatter = {}
+
+    return frontmatter, body

package/onecode/skills/loader.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from onecode.skills.frontmatter import parse_frontmatter
+from onecode.skills.model import Skill
+
+from onecode.config import CLOUD_DEV_HARNESS_DIR
+
+
+USER_SKILLS_DIR = CLOUD_DEV_HARNESS_DIR / "skills"
+
+
+SKILL_LOCATIONS = [
+    ("user", USER_SKILLS_DIR),
+    (".opencode", ".opencode/skills"),
+    (".claude", ".claude/skills"),
+    (".agents", ".agents/skills"),
+]
+
+
+class SkillLoader:
+    def __init__(self, workspace_root: Path | None = None):
+        self._workspace_root = workspace_root or Path.cwd()
+        self._cache: dict[str, Skill] | None = None
+
+    def _get_search_dirs(self) -> list[tuple[str, Path]]:
+        dirs = []
+        if USER_SKILLS_DIR.exists():
+            dirs.append(("user", USER_SKILLS_DIR))
+
+        # Built-in skills packaged with onecode
+        builtin_dir = Path(__file__).resolve().parent.parent / "builtin_skills"
+        if builtin_dir.exists():
+            dirs.append(("builtin", builtin_dir))
+
+        # Project root-level directories containing SKILL.md
+        try:
+            for d in sorted(self._workspace_root.iterdir()):
+                if d.is_dir() and (d / "SKILL.md").exists():
+                    dirs.append(("project", self._workspace_root))
+                    break
+        except Exception:
+            pass
+
+        search_paths = [
+            (".opencode", ".claude", ".agents"),
+        ]
+        for group in search_paths:
+            for name in group:
+                pattern = f"{name}/skills"
+                for parent in self._walk_up_parents():
+                    candidate = parent / pattern
+                    if candidate.exists():
+                        dirs.append((f"{name}/skills", candidate))
+                        break
+
+        return dirs
+
+    def _walk_up_parents(self):
+        current = self._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
+        yield Path.home()
+
+    def _discover(self) -> dict[str, Skill]:
+        if self._cache is not None:
+            return self._cache
+
+        skills: dict[str, Skill] = {}
+        seen_names: set[str] = set()
+
+        for source, skills_dir in self._get_search_dirs():
+            if not skills_dir.exists():
+                continue
+            try:
+                for d in sorted(skills_dir.iterdir()):
+                    if not d.is_dir():
+                        continue
+                    skill_md = d / "SKILL.md"
+                    if not skill_md.exists():
+                        continue
+
+                    content = skill_md.read_text(encoding="utf-8")
+                    cfg = {}
+                    skill_yaml = d / "skill.yaml"
+                    if skill_yaml.exists():
+                        try:
+                            cfg = yaml.safe_load(skill_yaml.read_text(encoding="utf-8")) or {}
+                        except Exception:
+                            cfg = {}
+
+                    frontmatter, body = parse_frontmatter(content)
+
+                    raw_name = frontmatter.get("name") or cfg.get("name") or d.name
+                    name = raw_name.lower()
+
+                    valid, err = Skill.validate_name(name)
+                    if not valid:
+                        continue
+
+                    desc = frontmatter.get("description") or cfg.get("description", "")
+
+                    skill = Skill(
+                        name=name,
+                        description=desc,
+                        path=d,
+                        enabled=frontmatter.get("enabled", cfg.get("enabled", True)),
+                        allowed_tools=frontmatter.get("allowed_tools") or cfg.get("allowed_tools", []),
+                        arguments=frontmatter.get("arguments") or cfg.get("arguments", []),
+                        triggers=frontmatter.get("triggers") or cfg.get("triggers", []),
+                        phases=frontmatter.get("phases") or cfg.get("phases", []),
+                        content=body if body else content,
+                        license=frontmatter.get("license") or cfg.get("license", ""),
+                        compatibility=frontmatter.get("compatibility") or cfg.get("compatibility", ""),
+                        metadata=frontmatter.get("metadata") or cfg.get("metadata", {}),
+                    )
+
+                    if name not in seen_names:
+                        skills[name] = skill
+                        seen_names.add(name)
+
+            except Exception:
+                continue
+
+        self._cache = skills
+        return skills
+
+    def get_all(self) -> dict[str, Skill]:
+        return self._discover()
+
+    def get(self, name: str) -> Optional[Skill]:
+        return self._discover().get(name.lower())
+
+    def get_enabled(self) -> list[Skill]:
+        return [s for s in self._discover().values() if s.enabled]
+
+    def get_by_source(self, source_prefix: str) -> list[Skill]:
+        return [
+            s for s in self._discover().values()
+            if s.path and str(s.path).startswith(source_prefix)
+        ]
+
+    def invalidate_cache(self) -> None:
+        self._cache = None

package/onecode/skills/manager.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+from onecode.config import CLOUD_DEV_HARNESS_DIR
+
+
+class SkillManager:
+    def __init__(self):
+        self.skills_dir = CLOUD_DEV_HARNESS_DIR / "skills"
+        self.skills_dir.mkdir(parents=True, exist_ok=True)
+        self._skills: dict[str, dict] = {}
+
+    def install(self, path: Path) -> Optional[str]:
+        skill_yaml = path / "skill.yaml"
+        if not skill_yaml.exists():
+            return "skill.yaml not found"
+        data = yaml.safe_load(skill_yaml.read_text())
+        name = data.get("name", path.name)
+        target = self.skills_dir / name
+        target.mkdir(parents=True, exist_ok=True)
+        for src in path.iterdir():
+            (target / src.name).write_bytes(src.read_bytes())
+        self._skills[name] = data
+        return None
+
+    def list(self) -> list[dict]:
+        result = []
+        for d in self.skills_dir.iterdir():
+            if d.is_dir():
+                config_path = d / "skill.yaml"
+                if config_path.exists():
+                    data = yaml.safe_load(config_path.read_text()) or {}
+                    data["name"] = data.get("name", d.name)
+                    data["enabled"] = data.get("enabled", True)
+                    result.append(data)
+        return result
+
+    def enable(self, name: str, enabled: bool = True):
+        config_path = self.skills_dir / name / "skill.yaml"
+        if config_path.exists():
+            data = yaml.safe_load(config_path.read_text()) or {}
+            data["enabled"] = enabled
+            config_path.write_text(yaml.dump(data, default_flow_style=False))
+
+    def remove(self, name: str) -> Optional[str]:
+        """Remove a skill by name.
+
+        Returns error message or None on success.
+        """
+        skill_path = self.skills_dir / name
+        if not skill_path.exists():
+            return f"Skill '{name}' not found"
+        if not skill_path.is_dir():
+            return f"'{name}' is not a skill directory"
+        import shutil
+        shutil.rmtree(skill_path)
+        self._skills.pop(name, None)
+        return None
+
+    def get(self, name: str) -> Optional[dict]:
+        """Get a skill by name."""
+        if name in self._skills:
+            return self._skills[name]
+        skill_path = self.skills_dir / name / "skill.yaml"
+        if skill_path.exists():
+            data = yaml.safe_load(skill_path.read_text()) or {}
+            data["name"] = data.get("name", name)
+            data["enabled"] = data.get("enabled", True)
+            self._skills[name] = data
+            return data
+        return None

package/onecode/skills/model.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+SKILL_NAME_RE = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*$")
+
+
+@dataclass
+class Skill:
+    name: str
+    description: str = ""
+    path: Path | None = None
+    enabled: bool = True
+    allowed_tools: list[str] = field(default_factory=list)
+    arguments: list[dict[str, Any]] = field(default_factory=list)
+    triggers: list[str] = field(default_factory=list)
+    phases: list[str] = field(default_factory=list)
+    content: str = ""
+    license: str = ""
+    compatibility: str = ""
+    metadata: dict[str, str] = field(default_factory=dict)
+
+    @classmethod
+    def validate_name(cls, name: str) -> tuple[bool, str]:
+        if not name:
+            return False, "name is required"
+        if len(name) < 1 or len(name) > 64:
+            return False, "name must be 1-64 characters"
+        if not SKILL_NAME_RE.match(name):
+            return False, "name must be lowercase alphanumeric with single hyphens, cannot start/end with hyphen or have consecutive hyphens"
+        return True, ""
+
+    @classmethod
+    def validate_description(cls, desc: str) -> tuple[bool, str]:
+        if not desc:
+            return False, "description is required"
+        if len(desc) > 1024:
+            return False, "description must be 1-1024 characters"
+        return True, ""

package/onecode/storage/activity.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from sqlalchemy import Column, String, Text, DateTime, JSON, create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+from onecode.config import CLOUD_DEV_HARNESS_DIR
+
+Base = declarative_base()
+
+
+class ActivityRecord(Base):
+    __tablename__ = "activities"
+
+    id = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    event_type = Column(String(50), nullable=False)
+    project = Column(String(255), default="")
+    session = Column(String(36), default="")
+    details = Column(JSON, default=dict)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+
+class ActivityRecorder:
+    def __init__(self, db_path: Optional[Path] = None):
+        if db_path is None:
+            db_path = CLOUD_DEV_HARNESS_DIR / "sessions" / "cdh.db"
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.engine = create_engine(f"sqlite:///{db_path}")
+        Base.metadata.create_all(self.engine)
+        self.Session = sessionmaker(bind=self.engine)
+
+    def record(self, event_type: str, project: str = "", session: str = "", details: Optional[dict] = None) -> str:
+        with self.Session() as s:
+            record = ActivityRecord(
+                event_type=event_type,
+                project=project,
+                session=session,
+                details=details or {},
+            )
+            s.add(record)
+            s.commit()
+            s.refresh(record)
+            return record.id
+
+    def list_activities(self, project: str = "", limit: int = 50) -> list[ActivityRecord]:
+        with self.Session() as s:
+            q = s.query(ActivityRecord).order_by(ActivityRecord.created_at.desc())
+            if project:
+                q = q.filter_by(project=project)
+            return q.limit(limit).all()
+
+    def list_by_session(self, session_id: str) -> list[ActivityRecord]:
+        with self.Session() as s:
+            return (
+                s.query(ActivityRecord)
+                .filter_by(session=session_id)
+                .order_by(ActivityRecord.created_at.desc())
+                .all()
+            )

package/onecode/storage/project.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+class ProjectConfig:
+    def __init__(self, root: Path):
+        self.root = root
+        self.config_path = root / "cdh.project.yaml"
+        self._data: dict = {}
+        if self.config_path.exists():
+            self._data = yaml.safe_load(self.config_path.read_text()) or {}
+
+    def save(self):
+        self.config_path.write_text(yaml.dump(self._data, default_flow_style=False))
+
+    def get(self, key: str, default=None):
+        return self._data.get(key, default)
+
+    def set(self, key: str, value):
+        self._data[key] = value
+
+    @staticmethod
+    def create(name: str, path: Optional[Path] = None) -> ProjectConfig:
+        if path is None:
+            path = Path.cwd() / name
+        path.mkdir(parents=True, exist_ok=True)
+        config = ProjectConfig(path)
+        config._data = {"name": name, "version": "0.1.0"}
+        config.save()
+        return config
+
+    def tree(self, depth: int = 3) -> str:
+        lines = []
+        self._render_tree(self.root, "", depth, lines)
+        return "\n".join(lines)
+
+    def _render_tree(self, path: Path, prefix: str, depth: int, lines: list):
+        if depth < 0:
+            return
+        entries = sorted(
+            [e for e in path.iterdir() if not e.name.startswith(".") and e.name != "__pycache__"],
+            key=lambda e: (not e.is_dir(), e.name),
+        )
+        for i, entry in enumerate(entries):
+            is_last = i == len(entries) - 1
+            connector = "└── " if is_last else "├── "
+            lines.append(f"{prefix}{connector}{entry.name}{'/' if entry.is_dir() else ''}")
+            if entry.is_dir():
+                ext = "    " if is_last else "│   "
+                self._render_tree(entry, prefix + ext, depth - 1, lines)

package/onecode/storage/session.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from sqlalchemy import (
+    Column,
+    String,
+    Text,
+    DateTime,
+    JSON,
+    create_engine,
+)
+from sqlalchemy.orm import declarative_base, Session as SASession, sessionmaker
+
+from onecode.config import CLOUD_DEV_HARNESS_DIR
+
+Base = declarative_base()
+
+
+class SessionRecord(Base):
+    __tablename__ = "sessions"
+
+    id = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    name = Column(String(255), default="Untitled")
+    mode = Column(String(50), default="build")
+    project = Column(String(255), default="")
+    model = Column(String(255), default="")
+    provider = Column(String(255), default="")
+    messages = Column(JSON, default=list)
+    lifecycle_state = Column(JSON, default=dict)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(
+        DateTime,
+        default=lambda: datetime.now(timezone.utc),
+        onupdate=lambda: datetime.now(timezone.utc),
+    )
+
+
+class SessionStore:
+    def __init__(self, db_path: Optional[Path] = None):
+        if db_path is None:
+            db_path = CLOUD_DEV_HARNESS_DIR / "sessions" / "cdh.db"
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.engine = create_engine(f"sqlite:///{db_path}")
+        Base.metadata.create_all(self.engine)
+        self.Session = sessionmaker(bind=self.engine)
+
+    def create(self, name: str = "Untitled", mode: str = "build", project: str = "") -> SessionRecord:
+        with self.Session() as session:
+            record = SessionRecord(name=name, mode=mode, project=project)
+            session.add(record)
+            session.commit()
+            session.refresh(record)
+            return record
+
+    def list_all(self) -> list[SessionRecord]:
+        with self.Session() as session:
+            return session.query(SessionRecord).order_by(SessionRecord.updated_at.desc()).all()
+
+    def list_by_project(self, project: str) -> list[SessionRecord]:
+        with self.Session() as session:
+            return (
+                session.query(SessionRecord)
+                .filter_by(project=project)
+                .order_by(SessionRecord.updated_at.desc())
+                .all()
+            )
+
+    def load(self, session_id: str) -> Optional[SessionRecord]:
+        with self.Session() as session:
+            return session.query(SessionRecord).filter_by(id=session_id).first()
+
+    def update(self, record: SessionRecord):
+        with self.Session() as s:
+            s.merge(record)
+            s.commit()
+
+    def delete(self, session_id: str):
+        with self.Session() as s:
+            record = s.query(SessionRecord).filter_by(id=session_id).first()
+            if record:
+                s.delete(record)
+                s.commit()
+
+    def rename(self, session_id: str, new_name: str):
+        with self.Session() as s:
+            record = s.query(SessionRecord).filter_by(id=session_id).first()
+            if record:
+                record.name = new_name
+                s.commit()
+
+    def export_json(self, session_id: str) -> Optional[str]:
+        record = self.load(session_id)
+        if not record:
+            return None
+        return json.dumps(
+            {
+                "id": record.id,
+                "name": record.name,
+                "mode": record.mode,
+                "project": record.project,
+                "model": record.model,
+                "messages": record.messages,
+                "created_at": record.created_at.isoformat() if record.created_at else None,
+                "updated_at": record.updated_at.isoformat() if record.updated_at else None,
+            },
+            indent=2,
+            ensure_ascii=False,
+        )

package/onecode/tasks/__init__.py

@@ -0,0 +1,26 @@
+from onecode.tasks.models import (
+    TaskStatus,
+    TodoStatus,
+    TodoItem,
+    TaskChecklistState,
+    TaskGateRecord,
+    TaskToolCallSummary,
+    TaskTimelineEntry,
+    TaskRecord,
+)
+from onecode.tasks.manager import TaskManager, TaskExecutor, ExecutionTask, TaskExecutionResult
+
+__all__ = [
+    "TaskStatus",
+    "TodoStatus", 
+    "TodoItem",
+    "TaskChecklistState",
+    "TaskGateRecord",
+    "TaskToolCallSummary",
+    "TaskTimelineEntry",
+    "TaskRecord",
+    "TaskManager",
+    "TaskExecutor",
+    "ExecutionTask",
+    "TaskExecutionResult",
+]