genoma-evolution 1.0.0

package/backend/skill_detector.py

@@ -0,0 +1,227 @@
+"""
+Skill Detector — Escanea y detecta skills de múltiples proveedores
+Proveedores soportados: Claude Code, OpenCode, Kilocode, Antigravity, Hermes
+"""
+
+import json
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Optional
+
+
+@dataclass
+class SkillInfo:
+    """Información de una skill detectada"""
+    name: str
+    provider: str
+    path: str
+    description: str = ""
+    enabled: bool = False
+    installed_at: Optional[str] = None
+    tags: List[str] = None
+    
+    def __post_init__(self):
+        if self.tags is None:
+            self.tags = []
+    
+    def to_dict(self):
+        return asdict(self)
+
+
+class SkillDetector:
+    """Detector de skills multi-proveedor"""
+    
+    PROVIDER_PATHS = {
+        "claude-code": Path.home() / ".claude" / "skills",
+        "opencode": Path.home() / ".opencode" / "skills",
+        "kilocode": Path.home() / ".kilocode" / "skills",
+        "antigravity": Path.home() / ".antigravity" / "providers",
+        "hermes": Path.home() / ".hermes" / "skills",
+        "agency": Path.home() / ".hermes" / "hermes-agent" / "skills" / "agency",
+    }
+    
+    def __init__(self, config_path: Optional[Path] = None):
+        self.config_path = config_path or (Path.home() / ".hermes" / "memory" / "skills_config.json")
+        self.enabled_skills = self._load_enabled()
+    
+    def _load_enabled(self) -> Dict[str, bool]:
+        if self.config_path.exists():
+            try:
+                data = json.loads(self.config_path.read_text())
+                return {k: v for k, v in data.items()}
+            except Exception:
+                pass
+        return {}
+    
+    def _save_enabled(self):
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        self.config_path.write_text(json.dumps(self.enabled_skills, indent=2))
+    
+    def detect_all(self) -> List[SkillInfo]:
+        skills = []
+        for provider, skills_dir in self.PROVIDER_PATHS.items():
+            if not skills_dir.exists():
+                continue
+            if provider == "claude-code":
+                skills.extend(self._detect_claude_skills(skills_dir))
+            elif provider == "opencode":
+                skills.extend(self._detect_opencode_skills(skills_dir))
+            elif provider == "kilocode":
+                skills.extend(self._detect_kilocode_skills(skills_dir))
+            elif provider == "antigravity":
+                skills.extend(self._detect_antigravity_skills(skills_dir))
+            elif provider == "hermes":
+                skills.extend(self._detect_hermes_skills(skills_dir))
+            elif provider == "agency":
+                skills.extend(self._detect_agency_skills(skills_dir))
+        return skills
+    
+    def _detect_claude_skills(self, skills_dir: Path) -> List[SkillInfo]:
+        skills = []
+        for skill_dir in skills_dir.iterdir():
+            if not skill_dir.is_dir():
+                continue
+            skill_file = skill_dir / "SKILL.md"
+            if skill_file.exists():
+                name = skill_dir.name
+                description = self._parse_description(skill_file)
+                key = f"claude-code.{name}"
+                skills.append(SkillInfo(
+                    name=name, provider="claude-code", path=str(skill_dir),
+                    description=description, enabled=self.enabled_skills.get(key, False),
+                    installed_at=str(skill_file.stat().st_mtime), tags=["claude", "ai-assistant"]
+                ))
+        return skills
+    
+    def _detect_opencode_skills(self, skills_dir: Path) -> List[SkillInfo]:
+        skills = []
+        for skill_dir in skills_dir.iterdir():
+            if not skill_dir.is_dir():
+                continue
+            skill_file = skill_dir / "SKILL.md"
+            if skill_file.exists():
+                name = skill_dir.name
+                description = self._parse_description(skill_file)
+                key = f"opencode.{name}"
+                skills.append(SkillInfo(
+                    name=name, provider="opencode", path=str(skill_dir),
+                    description=description, enabled=self.enabled_skills.get(key, False),
+                    installed_at=str(skill_file.stat().st_mtime), tags=["opencode", "coding"]
+                ))
+        return skills
+    
+    def _detect_kilocode_skills(self, skills_dir: Path) -> List[SkillInfo]:
+        skills = []
+        for skill_dir in skills_dir.iterdir():
+            if not skill_dir.is_dir():
+                continue
+            skill_file = skill_dir / "SKILL.md"
+            if skill_file.exists():
+                name = skill_dir.name
+                description = self._parse_description(skill_file)
+                key = f"kilocode.{name}"
+                skills.append(SkillInfo(
+                    name=name, provider="kilocode", path=str(skill_dir),
+                    description=description, enabled=self.enabled_skills.get(key, False),
+                    installed_at=str(skill_file.stat().st_mtime), tags=["kilocode"]
+                ))
+        return skills
+    
+    def _detect_antigravity_skills(self, providers_dir: Path) -> List[SkillInfo]:
+        skills = []
+        if not providers_dir.exists():
+            return skills
+        for provider_dir in providers_dir.iterdir():
+            if not provider_dir.is_dir():
+                continue
+            for skill_dir in provider_dir.iterdir():
+                if not skill_dir.is_dir():
+                    continue
+                skill_file = skill_dir / "SKILL.md"
+                if skill_file.exists():
+                    name = f"{provider_dir.name}.{skill_dir.name}"
+                    description = self._parse_description(skill_file)
+                    key = f"antigravity.{provider_dir.name}.{skill_dir.name}"
+                    skills.append(SkillInfo(
+                        name=name, provider="antigravity", path=str(skill_dir),
+                        description=description, enabled=self.enabled_skills.get(key, False),
+                        installed_at=str(skill_file.stat().st_mtime),
+                        tags=["antigravity", provider_dir.name]
+                    ))
+        return skills
+    
+    def _detect_agency_skills(self, skills_dir: Path) -> List[SkillInfo]:
+        skills = []
+        if not skills_dir.exists():
+            return skills
+        for skill_dir in skills_dir.iterdir():
+            if not skill_dir.is_dir():
+                continue
+            skill_file = skill_dir / "SKILL.md"
+            if skill_file.exists():
+                name = skill_dir.name
+                description = self._parse_description(skill_file)
+                key = f"agency.{name}"
+                skills.append(SkillInfo(
+                    name=name, provider="agency", path=str(skill_dir),
+                    description=description, enabled=self.enabled_skills.get(key, False),
+                    installed_at=str(skill_file.stat().st_mtime), tags=["agency", "external"]
+                ))
+        return skills
+
+    def _detect_hermes_skills(self, skills_dir: Path) -> List[SkillInfo]:
+        skills = []
+        if not skills_dir.exists():
+            return skills
+        for skill_dir in skills_dir.iterdir():
+            if not skill_dir.is_dir():
+                continue
+            skill_file = skill_dir / "SKILL.md"
+            if skill_file.exists():
+                name = skill_dir.name
+                description = self._parse_description(skill_file)
+                key = f"hermes.{name}"
+                skills.append(SkillInfo(
+                    name=name, provider="hermes", path=str(skill_dir),
+                    description=description, enabled=self.enabled_skills.get(key, False),
+                    installed_at=str(skill_file.stat().st_mtime), tags=["hermes", "core"]
+                ))
+        return skills
+    
+    def _parse_description(self, skill_file: Path) -> str:
+        try:
+            content = skill_file.read_text()
+            lines = [l.strip() for l in content.split(chr(10)) if l.strip()]
+            for line in lines:
+                if not line.startswith('#') and len(line) > 10:
+                    return line[:200]
+        except Exception:
+            pass
+        return "Skill descargada"
+    
+    def get_providers(self) -> List[Dict]:
+        skills = self.detect_all()
+        providers = {}
+        for skill in skills:
+            if skill.provider not in providers:
+                providers[skill.provider] = {
+                    "name": skill.provider, "total": 0, "enabled": 0, "skills": []
+                }
+            providers[skill.provider]["total"] += 1
+            if skill.enabled:
+                providers[skill.provider]["enabled"] += 1
+            providers[skill.provider]["skills"].append(skill.to_dict())
+        return list(providers.values())
+    
+    def toggle_skill(self, provider: str, skill_name: str, enabled: bool) -> bool:
+        key = f"{provider}.{skill_name}"
+        self.enabled_skills[key] = enabled
+        self._save_enabled()
+        return True
+    
+    def get_skill(self, provider: str, skill_name: str) -> Optional[SkillInfo]:
+        for s in self.detect_all():
+            if s.provider == provider and s.name == skill_name:
+                return s
+        return None

package/backend/skill_registry.py

@@ -0,0 +1,289 @@
+
+"""
+SkillRegistry: Versión simple — carga desde JSON al iniciar.
+"""
+
+from pathlib import Path
+import json, hashlib
+from dataclasses import dataclass, asdict
+from typing import Dict, List
+import shutil
+
+@dataclass
+class GlobalSkill:
+    id: str
+    name: str
+    description: str
+    canonical_path: str
+    code_hash: str
+    tags: List
+    providers: List
+    created_at: str
+    is_fork: bool = False
+
+class SimpleSkillRegistry:
+    GLOBAL_SKILLS_DIR = Path.home() / ".hermes" / "global_skills"
+    REGISTRY_DB = Path.home() / ".hermes" / "memory" / "skill_registry.json"
+    
+    PROVIDER_SOURCES = {
+        "claude-code": Path.home() / ".claude" / "skills",
+        "opencode": Path.home() / ".opencode" / "skills",
+        "kilocode": Path.home() / ".kilocode" / "skills",
+        "antigravity": Path.home() / ".antigravity" / "providers",
+        "hermes": Path.home() / ".hermes" / "skills",
+        # "agency": Path.home() / ".hermes" / "hermes-agent" / "skills" / "agency",
+    }
+    
+    def __init__(self):
+        self.global_skills: Dict[str, GlobalSkill] = {}
+        self.provider_index: Dict[str, str] = {}
+        self.load()
+    
+    def _quick_hash(self, skill_dir: Path) -> str:
+        h = hashlib.sha256()
+        md = skill_dir / "SKILL.md"
+        if md.exists():
+            st = md.stat()
+            h.update(f"md:{st.st_size}:{int(st.st_mtime)}".encode())
+        for f in skill_dir.iterdir():
+            if f.is_file() and f.suffix in ['.cp', '.py']:
+                st = f.stat()
+                h.update(f"{f.name}:{st.st_size}:{int(st.st_mtime)}".encode())
+                break
+        return h.hexdigest()[:16]
+    
+    def _quick_desc(self, md_path: Path) -> str:
+        try:
+            line = md_path.read_text().split('\n')[0].strip()
+            return line[:200] if line else "Skill"
+        except: return "Skill"
+    
+    def load(self):
+        if self.REGISTRY_DB.exists():
+            try:
+                data = json.loads(self.REGISTRY_DB.read_text())
+                self.global_skills = {k: GlobalSkill(**v) for k, v in data["global_skills"].items()}
+                self.provider_index = data["provider_index"]
+                print(f"[Registry] Cargado: {len(self.global_skills)} skills")
+                return self
+            except Exception as e:
+                print(f"[Registry] Error: {e}")
+        print("[Registry] Escaneando...")
+        self._fast_scan()
+        self.save()
+        return self
+    
+    def rescan(self):
+        self._fast_scan()
+        self.save()
+        return self
+    
+    def _fast_scan(self):
+        self.global_skills.clear()
+        self.provider_index.clear()
+        self.GLOBAL_SKILLS_DIR.mkdir(parents=True, exist_ok=True)
+        
+        for skill_dir in self.GLOBAL_SKILLS_DIR.iterdir():
+            if not skill_dir.is_dir() or not (skill_dir / "SKILL.md").exists():
+                continue
+            name = skill_dir.name
+            sid = self._quick_hash(skill_dir)
+            self.global_skills[sid] = GlobalSkill(
+                id=sid, name=name, description=self._quick_desc(skill_dir / "SKILL.md"),
+                canonical_path=str(skill_dir), code_hash=sid,
+                tags=[], providers=[], created_at="2024-01-01", is_fork=False
+            )
+        
+        for provider, src in self.PROVIDER_SOURCES.items():
+            if not src.exists(): continue
+            # Collect all skill directories (direct + nested in categories)
+            skill_dirs = []
+            for item in src.iterdir():
+                if not item.is_dir():
+                    continue
+                if (item / "SKILL.md").exists():
+                    # Direct skill: ~/.hermes/skills/skillname/
+                    skill_dirs.append((item.name, item, None))
+                else:
+                    # Check subdirs for categorized skills: ~/.hermes/skills/category/skillname/
+                    for sub in item.iterdir():
+                        if sub.is_dir() and (sub / "SKILL.md").exists():
+                            skill_dirs.append((sub.name, sub, item.name))  # (skill_name, path, category)
+            
+            for name, skill_dir, category_hint in skill_dirs:
+                lhash = self._quick_hash(skill_dir)
+                matched = None
+                if skill_dir.is_symlink():
+                    try:
+                        target = str(skill_dir.resolve())
+                        for gid, gs in self.global_skills.items():
+                            if gs.name == name and gs.canonical_path == target:
+                                matched = gid; break
+                    except: pass
+                if matched is None:
+                    for gid, gs in self.global_skills.items():
+                        if gs.name == name and gs.code_hash == lhash:
+                            matched = gid; break
+                key = f"{provider}.{name}"
+                if matched:
+                    self.provider_index[key] = matched
+                    self.global_skills[matched].providers.append({
+                        "name": provider, "enabled": True, "overrides": {},
+                        "local_path": str(skill_dir)
+                    })
+                else:
+                    # Skill existe solo en este provider → crear entrada global
+                    sid = self._quick_hash(skill_dir)
+                    self.global_skills[sid] = GlobalSkill(
+                        id=sid, name=name, description=self._quick_desc(skill_dir / "SKILL.md"),
+                        canonical_path=str(skill_dir), code_hash=sid,
+                        tags=[], providers=[{
+                            "name": provider, "enabled": True, "overrides": {},
+                            "local_path": str(skill_dir)
+                        }], created_at="2024-01-01", is_fork=False
+                    )
+                    self.provider_index[key] = sid
+        print(f"[Registry] Scan: {len(self.global_skills)} skills")
+    
+    def save(self):
+        self.REGISTRY_DB.parent.mkdir(parents=True, exist_ok=True)
+        data = {
+            "global_skills": {k: asdict(v) for k, v in self.global_skills.items()},
+            "provider_index": self.provider_index,
+            "updated_at": "2024-01-01"
+        }
+        self.REGISTRY_DB.write_text(json.dumps(data, indent=2))
+    
+    def _get_category(self, skill):
+        """Extrae categoría del path de la skill.
+        
+        Reglas:
+        - skills/category/skillname/ → category
+        - skills/skillname/ → 'general' (skill directa, sin categoría)
+        - agency/skills/agency/skillname/ → 'agency' (path especial de agency)
+        """
+        for path in [skill.canonical_path] + [p.get('local_path', '') for p in skill.providers]:
+            if '/skills/' in path:
+                after_skills = path.split('/skills/')[1].strip('/')
+                if not after_skills:
+                    continue
+                parts = after_skills.split('/')
+                # Si hay 2+ niveles → skills/category/skill/ → category es el primero
+                if len(parts) >= 2:
+                    # Excepción: si el primer nivel es el mismo nombre que la skill,
+                    # significa que es un path tipo ~/.claude/skills/skillname/
+                    # donde skillname es la carpeta de la skill, no una categoría
+                    if parts[0] == skill.name:
+                        return 'general'
+                    return parts[0]
+                # Si hay 1 nivel → skills/skillname/ → general
+                elif len(parts) == 1:
+                    return 'general'
+        return 'uncategorized'
+    
+    def get_providers(self):
+        providers = {}
+        for skill in self.global_skills.values():
+            # Skip agency skills entirely
+            if skill.name.startswith("agency-"):
+                continue
+            category = self._get_category(skill)
+            for p in skill.providers:
+                pn = p['name']
+                if pn not in providers:
+                    providers[pn] = {"name": pn, "total": 0, "enabled": 0, "skills": []}
+                providers[pn]["total"] += 1
+                if p.get("enabled"): providers[pn]["enabled"] += 1
+                providers[pn]["skills"].append({
+                    "name": skill.name, "description": skill.description,
+                    "enabled": p.get("enabled", False), "tags": skill.tags,
+                    "is_fork": skill.is_fork, "category": category,
+                })
+        return list(providers.values())
+    
+    def get_global_skills(self):
+        return [{**asdict(s), 'canonical_path': s.canonical_path} for s in self.global_skills.values() if not s.name.startswith("agency-")]
+    
+    def get_provider_skills(self, provider):
+        result = []
+        for skill in self.global_skills.values():
+            for p in skill.providers:
+                if p['name'] == provider:
+                    result.append({
+                        "global_id": skill.id, "name": skill.name,
+                        "description": skill.description, "enabled": p['enabled'],
+                        "tags": skill.tags, "is_fork": skill.is_fork,
+                        "canonical_path": skill.canonical_path
+                    })
+                    break
+        return result
+    
+    def get_skill_by_name(self, name):
+        for s in self.global_skills.values():
+            if s.name == name: return s
+        return None
+    
+    def toggle_provider_skill(self, provider, skill_name, enabled):
+        key = f"{provider}.{skill_name}"
+        if key in self.provider_index:
+            gid = self.provider_index[key]
+            skill = self.global_skills[gid]
+            for p in skill.providers:
+                if p['name'] == provider:
+                    p['enabled'] = enabled; self.save(); return True
+        for s in self.global_skills.values():
+            if s.name == skill_name and s.is_fork:
+                for p in s.providers:
+                    if p['name'] == provider:
+                        p['enabled'] = enabled; self.save(); return True
+        return False
+    
+    def delete_provider_skill(self, provider, skill_name):
+        key = f"{provider}.{skill_name}"
+        if key in self.provider_index:
+            gid = self.provider_index[key]
+            skill = self.global_skills[gid]
+            skill.providers = [p for p in skill.providers if p['name'] != provider]
+            del self.provider_index[key]
+            self.save()
+            return True
+        for s in self.global_skills.values():
+            if s.name == skill_name:
+                for p in s.providers:
+                    if p['name'] == provider:
+                        s.providers = [pp for pp in s.providers if pp['name'] != provider]
+                        self.save()
+                        return True
+        return False
+    
+    def delete_global_skill(self, skill_name):
+        for gid, skill in list(self.global_skills.items()):
+            if skill.name == skill_name and not skill.is_fork:
+                canon = Path(skill.canonical_path)
+                # 1. Eliminar symlinks PRIMERO
+                for provider, src_dir in self.PROVIDER_SOURCES.items():
+                    if not src_dir.exists(): continue
+                    link = src_dir / skill_name
+                    if link.exists() and link.is_symlink():
+                        try:
+                            if str(link.resolve()) == skill.canonical_path:
+                                link.unlink()
+                        except: pass
+                # 2. Eliminar directorio canónico
+                if canon.exists():
+                    shutil.rmtree(canon)
+                keys = [k for k, v in self.provider_index.items() if v == gid]
+                for k in keys: del self.provider_index[k]
+                del self.global_skills[gid]
+                self.save()
+                return True
+        return False
+
+_registry = None
+def get_registry():
+    global _registry
+    if _registry is None:
+        _registry = SimpleSkillRegistry()
+    return _registry
+
+print("✅ SimpleSkillRegistry listo")

package/backend/storage/__init__.py

@@ -0,0 +1,5 @@
+"""Storage layer for CanonicalRun persistence."""
+
+from backend.storage.run_store import RunStore
+
+__all__ = ["RunStore"]