hanuscode 1.0.0__py3-none-any.whl

hanus/rules/__init__.py

@@ -0,0 +1,237 @@
+# hanus/rules/__init__.py
+"""
+Rules loader and registry.
+
+Carga reglas comunes y específicas por lenguaje desde archivos .md
+y las registra para uso del sistema de agentes.
+"""
+from __future__ import annotations
+import re
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+from enum import Enum
+
+
+class RuleCategory(Enum):
+    """Categorías de reglas."""
+    CODING_STYLE = "coding-style"
+    SECURITY = "security"
+    TESTING = "testing"
+    PATTERNS = "patterns"
+    PERFORMANCE = "performance"
+    DEVELOPMENT_WORKFLOW = "development-workflow"
+
+
+class RuleLanguage(Enum):
+    """Lenguajes soportados."""
+    COMMON = "common"
+    PYTHON = "python"
+    TYPESCRIPT = "typescript"
+    JAVASCRIPT = "javascript"
+    GO = "go"
+    RUST = "rust"
+    JAVA = "java"
+    PHP = "php"
+    SWIFT = "swift"
+    KOTLIN = "kotlin"
+    CPP = "cpp"
+    CSHARP = "csharp"
+    REACT = "react"
+    FASTAPI = "fastapi"
+    DJANGO = "django"
+
+
+@dataclass
+class Rule:
+    """Representa una regla cargada desde archivo."""
+    category: RuleCategory
+    language: RuleLanguage
+    name: str
+    content: str
+    file_path: Path
+    sections: Dict[str, str] = field(default_factory=dict)
+
+    def get_section(self, name: str) -> Optional[str]:
+        """Obtiene una sección específica de la regla."""
+        return self.sections.get(name)
+
+    def get_all_sections(self) -> Dict[str, str]:
+        """Obtiene todas las secciones."""
+        return self.sections
+
+
+class RulesLoader:
+    """Cargador de reglas desde archivos markdown."""
+
+    def __init__(self, rules_dir: Path = None):
+        self.rules_dir = rules_dir or Path(__file__).parent
+        self._rules: Dict[str, Rule] = {}
+        self._loaded = False
+
+    def load_all(self, force: bool = False) -> Dict[str, Rule]:
+        """Carga todas las reglas desde los archivos .md."""
+        if self._loaded and not force:
+            return self._rules
+
+        self._rules.clear()
+
+        # Cargar reglas comunes
+        common_dir = self.rules_dir / "common"
+        if common_dir.exists():
+            for rule_file in common_dir.glob("*.md"):
+                rule = self._load_rule(rule_file, RuleLanguage.COMMON)
+                if rule:
+                    key = f"common/{rule.name}"
+                    self._rules[key] = rule
+
+        # Cargar reglas por lenguaje
+        for language in RuleLanguage:
+            if language == RuleLanguage.COMMON:
+                continue
+            lang_dir = self.rules_dir / language.value
+            if lang_dir.exists():
+                for rule_file in lang_dir.glob("*.md"):
+                    rule = self._load_rule(rule_file, language)
+                    if rule:
+                        key = f"{language.value}/{rule.name}"
+                        self._rules[key] = rule
+
+        self._loaded = True
+        return self._rules
+
+    def _load_rule(self, file_path: Path, language: RuleLanguage) -> Optional[Rule]:
+        """Carga una regla desde un archivo .md."""
+        try:
+            content = file_path.read_text(encoding="utf-8")
+
+            # Extraer nombre del archivo
+            name = file_path.stem
+
+            # Determinar categoría
+            category = self._get_category_from_name(name)
+
+            # Parsear secciones
+            sections = self._parse_sections(content)
+
+            return Rule(
+                category=category,
+                language=language,
+                name=name,
+                content=content,
+                file_path=file_path,
+                sections=sections,
+            )
+        except Exception as e:
+            print(f"[RulesLoader] Error loading {file_path}: {e}")
+            return None
+
+    def _get_category_from_name(self, name: str) -> RuleCategory:
+        """Determina la categoría de la regla desde su nombre."""
+        name_lower = name.lower()
+        for category in RuleCategory:
+            if category.value in name_lower:
+                return category
+        return RuleCategory.CODING_STYLE  # Default
+
+    def _parse_sections(self, content: str) -> Dict[str, str]:
+        """Parsea las secciones del markdown."""
+        sections = {}
+        current_section = None
+        current_content = []
+
+        for line in content.split("\n"):
+            # Detectar encabezados de sección (##)
+            if line.startswith("## "):
+                if current_section:
+                    sections[current_section] = "\n".join(current_content).strip()
+                current_section = line[3:].strip()
+                current_content = []
+            elif current_section:
+                current_content.append(line)
+
+        # Guardar última sección
+        if current_section:
+            sections[current_section] = "\n".join(current_content).strip()
+
+        return sections
+
+    def get_rule(self, language: str, category: str) -> Optional[Rule]:
+        """Obtiene una regla específica."""
+        if not self._loaded:
+            self.load_all()
+
+        key = f"{language}/{category}"
+        return self._rules.get(key)
+
+    def get_rules_for_language(self, language: RuleLanguage) -> List[Rule]:
+        """Obtiene todas las reglas para un lenguaje."""
+        if not self._loaded:
+            self.load_all()
+
+        return [r for r in self._rules.values() if r.language == language]
+
+    def get_rules_for_category(self, category: RuleCategory) -> List[Rule]:
+        """Obtiene todas las reglas para una categoría."""
+        if not self._loaded:
+            self.load_all()
+
+        return [r for r in self._rules.values() if r.category == category]
+
+    def get_common_rules(self) -> List[Rule]:
+        """Obtiene todas las reglas comunes."""
+        return self.get_rules_for_language(RuleLanguage.COMMON)
+
+    def get_all_rules(self) -> Dict[str, Rule]:
+        """Obtiene todas las reglas cargadas."""
+        if not self._loaded:
+            self.load_all()
+        return self._rules
+
+    def get_applicable_rules(self, language: RuleLanguage) -> Dict[str, List[Rule]]:
+        """Obtiene reglas aplicables: comunes + específicas del lenguaje."""
+        common = self.get_common_rules()
+        specific = self.get_rules_for_language(language)
+
+        return {
+            "common": common,
+            "language_specific": specific,
+            "all": common + specific,
+        }
+
+
+# Instancia global
+_loader: Optional[RulesLoader] = None
+
+
+def get_rules_loader(rules_dir: Path = None) -> RulesLoader:
+    """Obtiene el cargador de reglas."""
+    global _loader
+    if _loader is None:
+        _loader = RulesLoader(rules_dir)
+    return _loader
+
+
+def get_rule(language: str, category: str) -> Optional[Rule]:
+    """Obtiene una regla específica."""
+    return get_rules_loader().get_rule(language, category)
+
+
+def get_rules_for_language(language: str) -> List[Rule]:
+    """Obtiene todas las reglas para un lenguaje."""
+    try:
+        lang = RuleLanguage(language.lower())
+    except ValueError:
+        lang = RuleLanguage.PYTHON  # Default
+
+    return get_rules_loader().get_rules_for_language(lang)
+
+
+def get_applicable_rules(language: str) -> Dict[str, List[Rule]]:
+    """Obtiene reglas aplicables para un lenguaje."""
+    try:
+        lang = RuleLanguage(language.lower())
+    except ValueError:
+        lang = RuleLanguage.PYTHON  # Default
+
+    return get_rules_loader().get_applicable_rules(lang)

hanus/search/__init__.py

@@ -0,0 +1,5 @@
+# hanus/search/__init__.py
+"""Code search tools for HanusCode."""
+from .semantic import SemanticSearch, SearchResult
+
+__all__ = ["SemanticSearch", "SearchResult"]