hanuscode 1.0.0__py3-none-any.whl

hanus/__init__.py

@@ -0,0 +1,5 @@
+"""
+Hanus Code — Agente de programación autónomo para la terminal.
+"""
+__version__ = "1.0.0"
+__author__  = "Hanus"

hanus/__main__.py

@@ -0,0 +1,10 @@
+"""Permite ejecutar: python -m hanus"""
+from hanus.agent_runner import cli_main
+
+
+def main():
+    cli_main()
+
+
+if __name__ == "__main__":
+    main()

hanus/action_handlers.py

@@ -0,0 +1,76 @@
+# action_handlers.py — Adaptador legacy de acciones XML → ToolExecutor
+"""
+Mantiene ActionDispatcher para compatibilidad con plugins XML legacy.
+En v2.0 el flujo principal va por QueryEngine + ToolExecutor directo.
+"""
+from __future__ import annotations
+import json
+from pathlib import Path
+from typing import Dict, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from hanus.config import HanusConfig
+    from hanus.ui import UI
+
+from hanus.tools import ToolExecutor
+from hanus.permissions import PermissionManager, PermissionMode
+
+
+class ActionDispatcher:
+    def __init__(self, config: "HanusConfig", ui: "UI", task_manager=None):
+        self.config   = config
+        self.ui       = ui
+        perms         = PermissionManager(PermissionMode.BYPASS)
+        self.executor = ToolExecutor(config.root_dir, perms, task_manager=task_manager)
+        self._notes   = _NotesStore(config.root_dir / "agent_notes.json")
+
+    def handle_read(self, action: Dict) -> Optional[str]:
+        result = self.executor.execute("read_file", {"path": action.get("path","")})
+        if not result.success: return None
+        content = result.output
+        MAX = self.config.max_file_read_chars
+        if len(content) > MAX: content = content[:MAX] + "\n…(truncado)"
+        reason = action.get("reason","")
+        header = f"[Archivo: {action.get('path','?')}]" + (f" ({reason})" if reason else "")
+        return f"{header}\n```\n{content}\n```"
+
+    def handle_write(self, action: Dict) -> bool:
+        t = action.get("type","write_file")
+        tool_map = {"write_file":"write_file","create_file":"create_file","append_to_file":"append_to_file"}
+        result = self.executor.execute(tool_map.get(t,"write_file"), {
+            "path": action.get("path",""), "content": action.get("content","")
+        })
+        if result.success: self.ui.success(f"  ✓ {action.get('path','?')}")
+        else:              self.ui.error(result.error)
+        return result.success
+
+    def handle_exec(self, action: Dict) -> Optional[str]:
+        if action.get("type") == "exec_cmd":
+            r = self.executor.execute("exec_cmd", {"cmd": action.get("cmd","")})
+        else:
+            r = self.executor.execute("exec_file", {"path": action.get("path","")})
+        return r.to_str()
+
+    def handle_note(self, action: Dict) -> Optional[str]:
+        typ  = action.get("type"); name = action.get("name","").strip()
+        notes = self._notes.load()
+        if typ == "list_note":
+            return "Notas:\n" + "\n".join(f"  • {k}" for k in notes) if notes else "Sin notas."
+        if not name: return None
+        if typ == "add_note":
+            notes[name] = action.get("data","").strip(); self._notes.save(notes)
+            return f"Nota '{name}' guardada."
+        if typ == "read_note":
+            return f"[Nota: {name}]\n{notes.get(name,'(no existe)')}"
+        return None
+
+
+class _NotesStore:
+    def __init__(self, path: Path): self.path = path
+    def load(self) -> Dict:
+        if not self.path.exists(): return {}
+        try: return json.loads(self.path.read_text(encoding="utf-8"))
+        except: return {}
+    def save(self, notes: Dict):
+        try: self.path.write_text(json.dumps(notes, ensure_ascii=False, indent=2), encoding="utf-8")
+        except: pass

hanus/action_parser.py

@@ -0,0 +1,82 @@
+# action_parser.py — Parser de acciones XML (compatibilidad legacy)
+"""
+En v2.0 el bucle agéntico usa tool_calls nativos del modelo.
+Este módulo se mantiene para plugins que emitan respuestas en formato XML.
+"""
+from __future__ import annotations
+import re
+import json
+from typing import List, Dict
+
+
+def parse_actions(text: str) -> List[Dict]:
+    actions: List[Dict] = []
+    actions.extend(_parse_json(text))
+    actions.extend(_parse_xml_blocks(text))
+    actions.extend(_parse_xml_selfclose(text))
+    actions.extend(_parse_plugin(text))
+    seen, unique = set(), []
+    for a in actions:
+        key = a.get("raw", str(a))
+        if key not in seen:
+            seen.add(key); unique.append(a)
+    return unique
+
+
+def _parse_json(text: str) -> List[Dict]:
+    try:
+        data = json.loads(text.strip())
+        if not isinstance(data, dict): return []
+        _map = {
+            "create_file": lambda d: {"type": "create_file", "path": d.get("path"), "content": d.get("content","")},
+            "write_file":  lambda d: {"type": "write_file",  "path": d.get("path"), "content": d.get("content","")},
+            "exec_cmd":    lambda d: {"type": "exec_cmd",    "cmd": d.get("cmd") or d.get("command"), "reason": d.get("reason","")},
+        }
+        actions = []
+        for key, builder in _map.items():
+            if key in data and isinstance(data[key], dict):
+                a = builder(data[key]); a["raw"] = text; actions.append(a)
+        return actions
+    except Exception:
+        return []
+
+
+def _parse_xml_blocks(text: str) -> List[Dict]:
+    actions = []
+    TAGS = r"write_file|create_file|append_to_file|exec_cmd|exec_file"
+    for m in re.finditer(r'<(' + TAGS + r')\b([^>]*)>(.*?)</\1>', text, re.DOTALL | re.I):
+        tag = m.group(1).lower(); attrs = _attrs(m.group(2)); content = _unfence(m.group(3).strip())
+        a = {"type": tag, "raw": m.group(0)}; a.update(attrs)
+        if tag == "exec_cmd": a["cmd"] = attrs.get("cmd") or attrs.get("command") or content
+        else: a["path"] = attrs.get("path",""); a["content"] = content
+        actions.append(a)
+    return actions
+
+
+def _parse_xml_selfclose(text: str) -> List[Dict]:
+    actions = []
+    for m in re.finditer(r'<(read_file|exec_cmd|exec_file)\b([^>]*)/?>', text, re.I):
+        tag = m.group(1).lower(); attrs = _attrs(m.group(2))
+        a = {"type": tag, "raw": m.group(0)}; a.update(attrs)
+        if tag == "exec_cmd": a["cmd"] = attrs.get("cmd") or attrs.get("command","")
+        actions.append(a)
+    return actions
+
+
+def _parse_plugin(text: str) -> List[Dict]:
+    actions = []
+    for m in re.finditer(r'<run_plugin\b([^>]*)/?>', text, re.I):
+        attrs = _attrs(m.group(1)); a = {"type": "run_plugin", "raw": m.group(0)}; a.update(attrs); actions.append(a)
+    return actions
+
+
+def _attrs(s: str) -> Dict[str, str]:
+    return {m.group(1): m.group(2) for m in re.finditer(r'(\w+)\s*=\s*["\']([^"\']*)["\']', s or "")}
+
+
+def _unfence(content: str) -> str:
+    content = content.strip()
+    if content.startswith("```"):
+        lines = content.splitlines()
+        if len(lines) > 2: return "\n".join(lines[1:-1]).strip()
+    return content