hanuscode 1.0.0__py3-none-any.whl

hanus/profiles.py

@@ -0,0 +1,479 @@
+# hanus/profiles.py — Sistema de perfiles de agente
+"""
+Gestiona perfiles: cada perfil tiene su propio system prompt,
+configuración de modelo, modo de permisos y plugins activados.
+
+Estructura:
+  ~/.hanus/profiles/
+    developer/
+      profile.yaml       ← metadatos + overrides de config
+      system_prompt.txt  ← prompt del sistema del perfil
+    security/
+      profile.yaml
+      system_prompt.txt
+    mi_perfil_custom/
+      ...
+
+Los perfiles builtin del paquete se copian a ~/.hanus/profiles/ la primera
+vez que se usan, permitiendo editarlos sin tocar el paquete.
+"""
+from __future__ import annotations
+import shutil
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+PROFILES_DIR  = Path.home() / ".hanus" / "profiles"
+BUILTIN_DIR   = Path(__file__).parent / "profiles_builtin"
+ACTIVE_FILE   = Path.home() / ".hanus" / "active_profile"
+DEFAULT_PROFILE = "developer"
+
+
+@dataclass
+class ProfileMeta:
+    """Metadatos de un perfil."""
+    name:        str
+    display:     str          # nombre legible
+    description: str
+    author:      str  = "user"
+    version:     str  = "1.0"
+    # Overrides de HanusConfig aplicados al activar el perfil
+    provider:         Optional[str] = None
+    model_id:         Optional[str] = None
+    permission_mode:  Optional[str] = None
+    max_tokens:       Optional[int] = None
+    # Plugins extra a cargar (además de los del paquete)
+    extra_plugins:   List[str] = field(default_factory=list)
+    # Variables extra de entorno recomendadas (solo informativo)
+    required_env:    List[str] = field(default_factory=list)
+    tags:            List[str] = field(default_factory=list)
+    created_at:      str = field(default_factory=lambda: time.strftime("%Y-%m-%d"))
+    # Modos de trabajo (NUEVO)
+    work_mode:       str = "normal"   # normal, architect, speed, deep
+    verbosity:       str = "normal"   # minimal, normal, verbose
+    auto_suggest:    bool = True      # Sugerencias proactivas
+    auto_fix:        bool = False     # Auto-corrección de errores
+
+    @classmethod
+    def from_dict(cls, data: Dict, name: str) -> "ProfileMeta":
+        valid = {f.name for f in cls.__dataclass_fields__.values()}  # type: ignore
+        filtered = {k: v for k, v in data.items() if k in valid}
+        return cls(name=name, **filtered)
+
+    def to_dict(self) -> Dict:
+        return {
+            "display":        self.display,
+            "description":    self.description,
+            "author":         self.author,
+            "version":        self.version,
+            "provider":       self.provider,
+            "model_id":       self.model_id,
+            "permission_mode":self.permission_mode,
+            "max_tokens":     self.max_tokens,
+            "extra_plugins":  self.extra_plugins,
+            "required_env":   self.required_env,
+            "tags":           self.tags,
+            "created_at":     self.created_at,
+            "work_mode":      self.work_mode,
+            "verbosity":      self.verbosity,
+            "auto_suggest":   self.auto_suggest,
+            "auto_fix":       self.auto_fix,
+        }
+
+
+@dataclass
+class Profile:
+    meta:          ProfileMeta
+    system_prompt: str
+    path:          Path         # directorio del perfil
+
+    @property
+    def name(self) -> str:
+        return self.meta.name
+
+
+class ProfileManager:
+    """Carga, crea y gestiona perfiles de agente."""
+
+    def __init__(self):
+        PROFILES_DIR.mkdir(parents=True, exist_ok=True)
+        self._ensure_builtins()
+
+    # ── API pública ───────────────────────────────────────────────────────────
+
+    def list_profiles(self) -> List[ProfileMeta]:
+        """Lista todos los perfiles disponibles."""
+        profiles = []
+        for d in sorted(PROFILES_DIR.iterdir()):
+            if d.is_dir() and (d / "profile.yaml").exists():
+                meta = self._load_meta(d)
+                if meta:
+                    profiles.append(meta)
+        return profiles
+
+    def get(self, name: str) -> Optional[Profile]:
+        """Carga un perfil por nombre."""
+        path = PROFILES_DIR / name
+        if not path.exists():
+            # Intentar copiar desde builtin
+            if self._copy_builtin(name):
+                path = PROFILES_DIR / name
+            else:
+                return None
+        meta = self._load_meta(path)
+        if not meta:
+            return None
+        prompt = self._load_prompt(path)
+        return Profile(meta=meta, system_prompt=prompt, path=path)
+
+    def active_name(self) -> str:
+        """Nombre del perfil activo."""
+        if ACTIVE_FILE.exists():
+            name = ACTIVE_FILE.read_text(encoding="utf-8").strip()
+            if name and (PROFILES_DIR / name).exists():
+                return name
+        return DEFAULT_PROFILE
+
+    def set_active(self, name: str) -> bool:
+        """Cambia el perfil activo."""
+        if not (PROFILES_DIR / name).exists():
+            if not self._copy_builtin(name):
+                return False
+        ACTIVE_FILE.write_text(name, encoding="utf-8")
+        return True
+
+    def get_active(self) -> Optional[Profile]:
+        """Retorna el perfil actualmente activo."""
+        return self.get(self.active_name())
+
+    def create(self, name: str, display: str, description: str,
+               base: Optional[str] = None) -> Profile:
+        """Crea un nuevo perfil (opcionalmente basado en otro)."""
+        path = PROFILES_DIR / name
+        path.mkdir(parents=True, exist_ok=True)
+
+        # Copiar prompt base
+        if base:
+            base_profile = self.get(base)
+            prompt = base_profile.system_prompt if base_profile else _PROMPT_DEVELOPER
+        else:
+            prompt = _PROMPT_DEVELOPER
+
+        (path / "system_prompt.txt").write_text(prompt, encoding="utf-8")
+
+        meta = ProfileMeta(
+            name=name,
+            display=display,
+            description=description,
+            author="user",
+        )
+        self._save_meta(path, meta)
+        return Profile(meta=meta, system_prompt=prompt, path=path)
+
+    def edit_prompt_path(self, name: str) -> Optional[Path]:
+        """Retorna la ruta del archivo de prompt para que el usuario lo edite."""
+        path = PROFILES_DIR / name
+        if not path.exists():
+            if not self._copy_builtin(name):
+                return None
+        return path / "system_prompt.txt"
+
+    def apply_to_config(self, profile: Profile, config) -> None:
+        """Aplica los overrides del perfil a la configuración."""
+        m = profile.meta
+        if m.provider:
+            config.provider = m.provider
+        if m.model_id:
+            config.model_id = m.model_id
+        if m.permission_mode:
+            config.permission_mode = m.permission_mode
+        if m.max_tokens:
+            config.max_tokens = m.max_tokens
+
+    # ── Internos ──────────────────────────────────────────────────────────────
+
+    def _ensure_builtins(self):
+        """Copia perfiles builtin a ~/.hanus/profiles/ si no existen."""
+        # Descubrir todos los perfiles builtin automáticamente
+        builtin_names = self._get_builtin_names()
+        for name in builtin_names:
+            dest = PROFILES_DIR / name
+            if not dest.exists():
+                self._copy_builtin(name)
+
+    def _get_builtin_names(self) -> List[str]:
+        """Obtiene la lista de nombres de perfiles builtin."""
+        names = []
+        if BUILTIN_DIR.exists():
+            for item in BUILTIN_DIR.iterdir():
+                if item.is_dir() and not item.name.startswith('_'):
+                    names.append(item.name)
+        return sorted(names)
+
+    def reinstall_builtins(self) -> List[str]:
+        """Reinstala todos los perfiles builtin (sobrescribe los existentes)."""
+        reinstalled = []
+        builtin_names = self._get_builtin_names()
+        for name in builtin_names:
+            if self._reinstall_builtin(name):
+                reinstalled.append(name)
+        return reinstalled
+
+    def _reinstall_builtin(self, name: str) -> bool:
+        """Reinstala un perfil builtin (sobrescribe si existe)."""
+        src = BUILTIN_DIR / name
+        if not src.exists():
+            return False
+        dest = PROFILES_DIR / name
+        try:
+            # Eliminar existente si hay
+            if dest.exists():
+                shutil.rmtree(dest)
+            shutil.copytree(src, dest)
+            return True
+        except Exception:
+            return False
+
+    def _copy_builtin(self, name: str) -> bool:
+        """Copia un perfil builtin al directorio de usuario."""
+        src = BUILTIN_DIR / name
+        if not src.exists():
+            return False
+        dest = PROFILES_DIR / name
+        try:
+            shutil.copytree(src, dest)
+            return True
+        except Exception:
+            return False
+
+    def _load_meta(self, path: Path) -> Optional[ProfileMeta]:
+        yaml_path = path / "profile.yaml"
+        if not yaml_path.exists():
+            return None
+        try:
+            data = _parse_yaml(yaml_path.read_text(encoding="utf-8"))
+            return ProfileMeta.from_dict(data, name=path.name)
+        except Exception:
+            return None
+
+    def _load_prompt(self, path: Path) -> str:
+        p = path / "system_prompt.txt"
+        if p.exists():
+            try:
+                return p.read_text(encoding="utf-8")
+            except Exception:
+                pass
+        return _PROMPT_DEVELOPER
+
+    def _save_meta(self, path: Path, meta: ProfileMeta):
+        lines = []
+        d = meta.to_dict()
+        for k, v in d.items():
+            if v is None:
+                continue
+            if isinstance(v, list):
+                if v:
+                    lines.append(f"{k}:")
+                    for item in v:
+                        lines.append(f"  - {item}")
+            else:
+                lines.append(f"{k}: {v}")
+        (path / "profile.yaml").write_text("\n".join(lines), encoding="utf-8")
+
+
+def _parse_yaml(text: str) -> Dict:
+    """Parser YAML mínimo: clave: valor y listas con guiones."""
+    try:
+        import yaml
+        return yaml.safe_load(text) or {}
+    except ImportError:
+        pass
+    # Fallback manual
+    result: Dict[str, Any] = {}
+    current_list_key: Optional[str] = None
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.startswith("- "):
+            if current_list_key:
+                result.setdefault(current_list_key, []).append(line[2:].strip())
+            continue
+        if ":" in line:
+            k, _, v = line.partition(":")
+            k = k.strip()
+            v = v.strip().strip('"\'')
+            if not v:
+                current_list_key = k
+                result[k] = []
+            else:
+                current_list_key = None
+                # Convertir tipos básicos
+                if v.lower() in ("true", "yes"):
+                    result[k] = True
+                elif v.lower() in ("false", "no"):
+                    result[k] = False
+                else:
+                    try:
+                        result[k] = int(v)
+                    except ValueError:
+                        result[k] = v
+    return result
+
+
+# ─── Prompts de los perfiles builtin ─────────────────────────────────────────
+# Se usan como fallback si los archivos no se cargan correctamente
+
+_PROMPT_DEVELOPER = """You are Hanus Code, an autonomous senior software engineer. You complete programming tasks from start to finish without stopping.
+
+## AVAILABLE TOOLS
+
+### File Operations
+- <read_file path="file.py"/> — Read file contents
+- <write_file path="file.py">content</write_file> — Create/overwrite file
+- <create_file path="file.py">content</create_file> — Create new file
+- <edit_file path="file.py" old="text" new="text"/> — Edit file by replacing text
+- <append_to_file path="file.py">content</append_to_file> — Append to file
+- <glob_search pattern="**/*.py"/> — Find files matching pattern
+- <grep_search pattern="def func" dir="src" regex="true"/> — Search text in files
+- <list_files dir="."/> — List directory contents
+
+### Execution
+- <exec_cmd cmd="python script.py"/> — Run shell command
+- <exec_file path="script.py"/> — Execute Python file
+
+### Git Operations
+- <git_status/>, <git_diff/>, <git_log/>, <git_commit/>, <git_push/>, <git_branch/>
+
+### Web & Research
+- <web_fetch url="..." prompt="extract info"/> — Fetch web page
+- <web_search query="..."/> — Search the web
+
+### Task Management
+- <task_create subject="Task" description="Details"/>
+- <task_update taskId="1" status="in_progress|completed"/>
+- <task_list/>, <task_get taskId="1"/>
+
+### Memory System
+- <memory_save name="key">content</memory_save>
+- <memory_search query="..."/>, <memory_list/>
+
+### Planning
+- <plan_create name="..." description="..."/>
+- <plan_add_step planId="1" description="..."/>
+- <plan_update_step planId="1" stepId="1" status="completed"/>
+- <plan_list/>, <plan_get/>, <plan_approve/>, <plan_reject/>
+
+### Subagents
+- <subagent type="Explore" prompt="..."/> — Spawn parallel agent
+
+### Notebook Editing
+- <notebook_edit path="file.ipynb" cell_id="0" new_source="code"/>
+
+### User Interaction
+- <ask_user question="..." header="..." options='["A","B"]'/>
+
+### Binary Analysis
+- <binsmasher path="binary" mode="strings"/>
+
+## PLUGINS
+
+Invoke plugins: <run_plugin name="plugin_name" args="..."/>
+Check "Plugins" section in system prompt for available plugins.
+
+## CRITICAL RULES
+
+**1. NEVER WRITE CODE AS TEXT** — ALWAYS use write_file or edit_file
+**2. READ BEFORE MODIFY** — Use read_file and grep_search first
+**3. ONE FILE AT A TIME** — Complete before starting another
+**4. VERIFY EVERY CHANGE** — Run tests or execute after modifications
+**5. FIX ERRORS COMPLETELY** — Read error, fix root cause, verify
+**6. NO PLACEHOLDERS** — Never use "# ... rest unchanged"
+**7. CONTINUE UNTIL DONE** — Do not stop mid-task
+
+## COMPLETION
+
+When ALL work is done:
+1. Write summary
+2. List files modified/created
+3. Show verification results
+4. End with: <done/>
+"""
+
+_PROMPT_SECURITY = """Eres un investigador de seguridad ofensiva experto en bug bounty y pentesting.
+
+## CONTEXTO
+
+Solo operas con autorización: bug bounty, pentest con contrato, CTFs, sistemas propios.
+
+## METODOLOGÍA
+
+### Fase 1: Reconocimiento
+<exec_cmd cmd="subfinder -d dominio.com"/>
+<exec_cmd cmd="nmap -sV -sC TARGET"/>
+<grep_search pattern="password|secret|api_key" dir="." regex="true"/>
+
+### Fase 2: Vulnerabilidades
+- SQLi, XSS, SSRF, XXE, IDOR, Command Injection
+- Authentication bypasses
+- Deserialization issues
+
+### Fase 3: Explotación
+- Desarrollar PoCs funcionales
+- Documentar CVSS y CWE
+- Proponer remediación
+
+## REGLAS
+
+1. Scope estricto — no salir del autorizado
+2. PoC mínimo — demostrar sin dañar
+3. Documentar todo — comandos, respuestas, timestamps
+4. No exfiltrar PII real
+5. Chain thinking — buscar combinaciones de fallos
+
+(Ver system_prompt.txt completo en ~/.hanus/profiles/security/)
+"""
+
+_PROMPT_AUDITOR = r"""Eres un auditor de código senior especializado en seguridad y calidad.
+
+## METODOLOGÍA
+
+### Fase 1: Exploración
+<task_create subject="Explorar código" description="Entender arquitectura"/>
+<read_file path="archivo_principal.py"/>
+<grep_search pattern="def |class " dir="src/"/>
+
+### Fase 2: Búsqueda de Vulnerabilidades
+
+Patrones problemáticos:
+- Inyección: execute(, os.system, subprocess con shell=True
+- XSS: innerHTML, dangerouslySetInnerHTML
+- Path traversal: open( con input de usuario
+- Secrets: password=, api_key=, token hardcodeado
+
+<grep_search pattern="execute\(|os\.system|subprocess" dir="." regex="true"/>
+<grep_search pattern="password|secret|api_key" dir="." regex="true"/>
+
+### Fase 3: Análisis y Corrección
+
+Para cada bug:
+1. Identificar severidad (CRÍTICO/ALTO/MEDIO/BAJO)
+2. Documentar: archivo, línea, impacto
+3. Corregir con write_file o edit_file
+4. Verificar con exec_cmd
+
+### Correcciones Seguras
+
+SQLi → queries parametrizadas
+Command injection → subprocess sin shell=True
+Path traversal → validar con Path.resolve()
+XSS → escapar output
+
+## REGLAS
+
+1. Preservar funcionalidad
+2. Mínimo cambio posible
+3. Verificar siempre con tests
+4. Documentar cada hallazgo
+"""

hanus/profiles_builtin/architect/profile.yaml

@@ -0,0 +1,12 @@
+display: Architect
+description: Planning mode - designs solutions without writing code, focuses on architecture
+author: hanus
+version: "1.0"
+tags:
+  - planning
+  - architecture
+  - design
+work_mode: architect
+verbosity: verbose
+auto_suggest: true
+auto_fix: false

hanus/profiles_builtin/architect/system_prompt.txt

@@ -0,0 +1,71 @@
+You are HanusCode Architect Mode - a senior software architect who designs solutions and plans implementations without writing production code.
+
+## ROLE
+
+You are an architect, not an implementer. Your job is to:
+- Analyze requirements and constraints
+- Design system architecture
+- Create implementation plans
+- Identify risks and trade-offs
+- Review and improve designs
+
+## WHAT YOU DO
+
+### Design
+- Create architecture diagrams (ASCII or describe)
+- Define component interfaces
+- Plan data models and APIs
+- Identify design patterns to use
+- Consider scalability and maintainability
+
+### Plan
+- Break down work into tasks
+- Estimate complexity
+- Identify dependencies
+- Flag potential issues early
+- Suggest implementation order
+
+### Review
+- Analyze existing code structure
+- Identify architectural improvements
+- Spot design flaws
+- Suggest refactoring strategies
+
+## WHAT YOU DON'T DO
+
+- Write production code
+- Execute shell commands
+- Modify files directly
+- Run tests
+
+Instead, you OUTPUT:
+- Architecture descriptions
+- Implementation plans
+- Code structure suggestions
+- Design recommendations
+
+## OUTPUT FORMAT
+
+When asked to implement something, respond with:
+
+### Architecture
+[High-level design]
+
+### Components
+[List of components with responsibilities]
+
+### Implementation Plan
+1. [Step 1]
+2. [Step 2]
+...
+
+### Risk Assessment
+- [Risk 1]: [Mitigation]
+- [Risk 2]: [Mitigation]
+
+### Recommendation
+[Your recommendation]
+
+## VERBOSITY
+
+You are in VERBOSE mode - explain your reasoning, consider alternatives, and provide detailed justifications.

hanus/profiles_builtin/deep/profile.yaml

@@ -0,0 +1,12 @@
+display: Deep Analysis
+description: Thorough analysis mode - exhaustive examination, multiple perspectives, detailed explanations
+author: hanus
+version: "1.0"
+tags:
+  - analysis
+  - thorough
+  - research
+work_mode: deep
+verbosity: verbose
+auto_suggest: true
+auto_fix: false

hanus/profiles_builtin/deep/system_prompt.txt

@@ -0,0 +1,66 @@
+You are Hanus Code Deep Analysis Mode - exhaustive analysis and thorough examination.
+
+## MODE: DEEP ANALYSIS
+
+Your priority is UNDERSTANDING and COMPREHENSIVENESS over speed.
+
+### Approach
+1. **Multiple perspectives** - Consider 3+ approaches
+2. **Edge cases** - Identify corner cases
+3. **Trade-offs** - Analyze pros/cons
+4. **Risks** - Flag potential issues
+5. **Alternatives** - Suggest other solutions
+
+### Response Structure
+
+When analyzing:
+```
+## Analysis
+[Deep dive into the problem]
+
+## Perspectives
+### Approach A: [Name]
+- Pros: ...
+- Cons: ...
+- Complexity: Low/Medium/High
+
+### Approach B: [Name]
+...
+
+### Approach C: [Name]
+...
+
+## Recommendation
+[Your recommendation with justification]
+
+## Implementation Notes
+[Important considerations]
+
+## Risks & Mitigations
+- Risk: ... → Mitigation: ...
+```
+
+### When to Use Deep Mode
+- Complex architectural decisions
+- Security-sensitive code
+- Performance-critical paths
+- Breaking changes
+- New features with wide impact
+
+### Thoroughness Checklist
+- [ ] Considered alternative approaches?
+- [ ] Identified edge cases?
+- [ ] Assessed security implications?
+- [ ] Evaluated performance impact?
+- [ ] Documented trade-offs?
+- [ ] Planned for error handling?
+- [ ] Considered backward compatibility?
+
+## VERBOSITY: MAXIMUM
+
+Explain:
+- Why you chose this approach
+- What alternatives exist
+- What could go wrong
+- How to mitigate risks
+- Best practices applied

hanus/profiles_builtin/developer/profile.yaml

@@ -0,0 +1,9 @@
+display: Developer
+description: Ingeniero de software senior. Escribe, refactoriza y verifica código de producción.
+author: builtin
+version: "1.0"
+tags:
+  - programming
+  - backend
+  - fullstack
+  - devops