@scemoon/cdh 1.0.6 → 1.0.7

package/onecode/skills/argument_substitution.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-import re
-
-
-_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/bootstrap.py

@@ -1,124 +0,0 @@
-"""onecode bootstrap — ensures ai-dlc-skill is installed in the cdh platform pool.
-
-Called at onecode startup (or cdh launch) to sync the ai-dlc-skill version
-from the repository source (ai-dlc-skill/) to ~/.cdh/skills/ai-dlc-skill/.
-"""
-
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-from typing import Optional
-
-import yaml
-
-from cdh.cdh_skill_manager import CdhSkillManager
-
-logger = logging.getLogger("onecode.skills.bootstrap")
-
-SKILL_SOURCE_NAME = "ai-dlc-skill"
-DEFAULT_VERSION = "4.0.0"
-
-
-def get_source_skill_dir(workspace_root: Path) -> Optional[Path]:
-    """Walk up from workspace_root to find ai-dlc-skill/ directory."""
-    current = workspace_root.resolve()
-    # Check current directory
-    candidate = current / SKILL_SOURCE_NAME
-    if candidate.is_dir() and (candidate / "skill.yaml").exists():
-        return candidate
-    # Check parent (if in a subdirectory)
-    candidate = current.parent / SKILL_SOURCE_NAME
-    if candidate.is_dir() and (candidate / "skill.yaml").exists():
-        return candidate
-    # Check git root
-    try:
-        git_root = next(
-            p for p in current.parents if (p / ".git").exists()
-        )
-        candidate = git_root / SKILL_SOURCE_NAME
-        if candidate.is_dir() and (candidate / "skill.yaml").exists():
-            return candidate
-    except StopIteration:
-        pass
-    return None
-
-
-def get_source_version(source_dir: Path) -> str:
-    """Read metadata.version from source skill.yaml."""
-    try:
-        skill_yaml = source_dir / "skill.yaml"
-        data = yaml.safe_load(skill_yaml.read_text(encoding="utf-8")) or {}
-        return data.get("metadata", {}).get("version", DEFAULT_VERSION)
-    except Exception:
-        return DEFAULT_VERSION
-
-
-def ensure_onecode_default_skills() -> None:
-    """Install built-in skills (git, shell) to ~/.onecode/skills/ on first run."""
-    from onecode.config import ONECODE_DIR
-
-    target_dir = ONECODE_DIR / "skills"
-    target_dir.mkdir(parents=True, exist_ok=True)
-
-    builtin_root = Path(__file__).resolve().parent.parent / "builtin_skills"
-    if not builtin_root.exists():
-        return
-
-    mgr = CdhSkillManager(skills_dir=target_dir)
-
-    for d in sorted(builtin_root.iterdir()):
-        if not d.is_dir():
-            continue
-        if not (d / "skill.yaml").exists():
-            continue
-        name = d.name
-        if mgr.get_installed_version(name) is not None:
-            continue
-        err = mgr.install(d)
-        if err:
-            logger.warning("default skill %s install failed: %s", name, err)
-        else:
-            logger.info("default skill %s installed \u2192 %s/%s", name, target_dir, name)
-
-
-def ensure_ai_dlc_skill(workspace_root: Path | None = None) -> None:
-    """Bootstrap ai-dlc-skill into cdh platform pool.
-
-    Compares source version with installed version. If missing or outdated,
-    installs via CdhSkillManager. Return value: None (logs warnings on failure).
-    """
-    root = workspace_root or Path.cwd()
-    mgr = CdhSkillManager()
-
-    # Check if already installed and up-to-date
-    installed_version = mgr.get_installed_version(SKILL_SOURCE_NAME)
-
-    # Find source directory
-    source_dir = get_source_skill_dir(root)
-    if source_dir is None:
-        if installed_version is None:
-            logger.warning(
-                "ai-dlc-skill source not found at %s/ai-dlc-skill/ and not installed; "
-                "install from repository root to enable AI-DLC methodology.",
-                root,
-            )
-        return
-
-    source_version = get_source_version(source_dir)
-
-    if installed_version == source_version:
-        logger.debug("ai-dlc-skill v%s is current, skipping install.", source_version)
-        return
-
-    # Install or update
-    err = mgr.install(source_dir)
-    if err:
-        logger.warning("ai-dlc-skill install failed: %s", err)
-    else:
-        logger.info(
-            "ai-dlc-skill installed v%s → %s/%s",
-            source_version,
-            mgr.skills_dir,
-            SKILL_SOURCE_NAME,
-        )

package/onecode/skills/create.py

@@ -1,56 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,139 +0,0 @@
-from __future__ import annotations
-
-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 ONECODE_DIR
-
-
-USER_SKILLS_DIR = ONECODE_DIR / "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(("onecode", USER_SKILLS_DIR))
-        return dirs
-
-    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 search(self, keyword: str) -> list[Skill]:
-        kw = keyword.lower()
-        results: list[tuple[Skill, int]] = []
-
-        for skill in self._discover().values():
-            score = 0
-            name_lower = skill.name.lower()
-            desc_lower = skill.description.lower()
-
-            if kw == name_lower:
-                score += 100
-            elif kw in name_lower:
-                score += 50
-            if kw in desc_lower:
-                score += 30
-                if desc_lower.startswith(kw):
-                    score += 10
-            for trigger in skill.triggers:
-                if kw in trigger.lower():
-                    score += 20
-                    break
-            for phase in skill.phases:
-                if kw in phase.lower():
-                    score += 10
-                    break
-
-            if score > 0:
-                results.append((skill, score))
-
-        results.sort(key=lambda x: x[1], reverse=True)
-        return [s for s, _ in results]
-
-    def invalidate_cache(self) -> None:
-        self._cache = None

package/onecode/skills/manager.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Optional
-
-import yaml
-
-from onecode.config import ONECODE_DIR
-
-
-class SkillManager:
-    def __init__(self):
-        self.skills_dir = ONECODE_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

@@ -1,43 +0,0 @@
-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

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-import uuid
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Optional
-
-from sqlalchemy import Column, String, DateTime, JSON, create_engine
-from sqlalchemy.orm import declarative_base, sessionmaker
-
-from onecode.config import ONECODE_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 = ONECODE_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

@@ -1,54 +0,0 @@
-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)