higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/infrastructure/cli/session_commands.py

@@ -0,0 +1,36 @@
+"""Handlers CLI para ciclo de vida de sesiones."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def parse_session_resources(args: argparse.Namespace) -> tuple[list | None, list | None]:
+    skills = [s.strip() for s in args.skills.split(",")] if args.skills else None
+    subagents = [sa.strip() for sa in args.subagents.split(",")] if args.subagents else None
+    return skills, subagents
+
+
+def start_session(
+    nexus,
+    session_mgr,
+    args: argparse.Namespace,
+    default_profile: str,
+    default_assistant: str,
+) -> None:
+    profile = args.profile or default_profile
+    assistant = args.assistant or default_assistant
+    skills, subagents = parse_session_resources(args)
+    session_mgr.start_session(profile, assistant, skills, subagents)
+    nexus.load_agent_profile(profile, assistant)
+
+
+def dispatch_session(nexus, args: argparse.Namespace, root_dir: Path, session_manager_cls) -> None:
+    session_mgr = session_manager_cls(Path.cwd(), root_dir)
+    assistant, profile = session_mgr.get_assistant_and_profile()
+    if args.action == "start":
+        start_session(nexus, session_mgr, args, profile, assistant)
+    elif args.action == "clean":
+        session_mgr.clean_session()
+        nexus.load_agent_profile(profile, assistant)

higpertext/kernel/infrastructure/cli/task_commands.py

@@ -0,0 +1,23 @@
+"""Handlers CLI para ejecución de tareas/capacidades."""
+
+from __future__ import annotations
+
+import argparse
+
+from higpertext.kernel.infrastructure.cli.arguments import parse_kv_args, pop_bool_flag
+
+
+def dispatch_task(nexus, args: argparse.Namespace) -> None:
+    task_args = list(args.task_args) if args.task_args else []
+    no_cache = getattr(args, "no_cache", False)
+    stream = getattr(args, "stream", False)
+
+    no_cache, task_args = pop_bool_flag(task_args, "--no-cache", no_cache)
+    stream, task_args = pop_bool_flag(task_args, "--stream", stream)
+
+    nexus.run_task(
+        args.name,
+        parse_kv_args(task_args),
+        stream=stream,
+        no_cache=no_cache,
+    )

higpertext/kernel/infrastructure/cli/task_result_reporter.py

@@ -0,0 +1,56 @@
+"""Presentación de resultados de tareas/capacidades."""
+
+from __future__ import annotations
+
+# Solo tipado de CompletedProcess.
+import subprocess  # nosec B404
+
+
+def build_memory_notes(
+    task_name: str,
+    params: dict,
+    result: subprocess.CompletedProcess,
+    contract_success: bool,
+    contract_errors: list,
+) -> str:
+    notes = f"Ejecución de {task_name} con params: {params}"
+    if not contract_success:
+        notes += f" | Falló Contrato: {', '.join(contract_errors)}"
+    elif result.stdout:
+        notes += f" | OUT: {result.stdout[:150].strip()}"
+    if result.stderr:
+        notes += f" | ERR: {result.stderr[:150].strip()}"
+    return notes.replace("\n", " ").replace("\r", "")
+
+
+def print_task_failure(
+    task_name: str,
+    result: subprocess.CompletedProcess,
+    contract_success: bool,
+    contract_errors: list,
+    logger,
+) -> None:
+    if not contract_success:
+        logger.error(f"[ERROR] Falló la validación del contrato técnico para '{task_name}':")
+        for error in contract_errors:
+            logger.info(f"    - [CONTRATO] {error}")
+    else:
+        logger.error(f"[ERROR] Falló la ejecución:\n{result.stderr}")
+        if result.stdout:
+            logger.info(f"Detalles (stdout):\n{result.stdout[:500]}")
+
+
+def report_task_result(
+    task_name: str,
+    result: subprocess.CompletedProcess,
+    contract_success: bool,
+    contract_errors: list,
+    logger,
+) -> bool:
+    if result.returncode == 0 and contract_success:
+        logger.ok("[SUCCESS] Tarea completada y contrato técnico validado.")
+        if result.stdout:
+            logger.info(result.stdout)
+        return True
+    print_task_failure(task_name, result, contract_success, contract_errors, logger)
+    return False

higpertext/kernel/infrastructure/cli/workflow_commands.py

@@ -0,0 +1,25 @@
+"""Handlers CLI para workflows."""
+
+from __future__ import annotations
+
+import argparse
+
+from higpertext.kernel.infrastructure.cli.arguments import parse_kv_args
+
+
+def dispatch_workflow(nexus, args: argparse.Namespace) -> None:
+    if args.workflow_action == "run":
+        nexus.run_workflow(args.name, parse_kv_args(args.wf_args))
+    else:
+        nexus.list_workflows_cli()
+
+
+def resolve_workflow_params(workflow: dict, cli_params: dict) -> dict:
+    params: dict = {}
+    for parameter in workflow.get("parameters", []):
+        name = parameter.get("name")
+        params[name] = cli_params.get(name, parameter.get("default", ""))
+    for key, value in cli_params.items():
+        if key not in params:
+            params[key] = value
+    return params

higpertext/kernel/infrastructure/compilers/__init__.py

@@ -0,0 +1,3 @@
+from higpertext.kernel.infrastructure.compilers.factory import CompilerFactory
+
+__all__ = ["CompilerFactory"]

higpertext/kernel/infrastructure/compilers/factory.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+from higpertext.kernel.domain.compilers import ICompiler
+from higpertext.kernel.infrastructure.compilers.hook_compiler import HookCompiler
+from higpertext.kernel.infrastructure.compilers.playbook_compiler import PlaybookCompiler
+from higpertext.kernel.infrastructure.compilers.guide_compiler import GuideCompiler
+from higpertext.kernel.infrastructure.compilers.graph_compiler import GraphCompiler
+
+class CompilerFactory:
+    @staticmethod
+    def create(activity_type: str, project_root: Path, engine_root: Path = None, pkg_data_dir: Path = None, engine = None) -> ICompiler:
+        """Fabrica el compilador correspondiente según el tipo de actividad."""
+        if activity_type == "hook":
+            if not pkg_data_dir:
+                raise ValueError("pkg_data_dir is required for hook compiler")
+            return HookCompiler(project_root, pkg_data_dir)
+        elif activity_type == "playbook":
+            if not engine_root or not pkg_data_dir or not engine:
+                raise ValueError("engine_root, pkg_data_dir, and engine are required for playbook compiler")
+            return PlaybookCompiler(project_root, engine_root, pkg_data_dir, engine)
+        elif activity_type == "guide":
+            if not engine:
+                raise ValueError("engine is required for guide compiler")
+            return GuideCompiler(project_root, engine)
+        elif activity_type == "graph":
+            return GraphCompiler(project_root)
+        else:
+            raise ValueError(f"Unknown compiler activity type: {activity_type}")

higpertext/kernel/infrastructure/compilers/graph_compiler.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+from higpertext.kernel.domain.compilers import ICompiler
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+class GraphCompiler(ICompiler):
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+
+    def compile(self) -> bool:
+        """Genera el grafo semántico inicial."""
+        try:
+            from higpertext.kernel.infrastructure.parser.semantic_graph import SemanticGraphGenerator
+            _log.info("[*] Generando grafo semántico inicial...")
+            SemanticGraphGenerator.generate(self.project_root)
+            _log.ok("[SUCCESS] Grafo semántico generado en .higpertext/state/semantic_graph.md")
+            return True
+        except Exception as e:
+            _log.warning(f"[WARNING] No se pudo generar el grafo semántico: {e}")
+            return False

higpertext/kernel/infrastructure/compilers/guide_compiler.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+from higpertext.kernel.domain.compilers import ICompiler
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+class GuideCompiler(ICompiler):
+    def __init__(self, target_path: Path, engine):
+        self.target_path = target_path
+        self.engine = engine
+
+    def compile(self, assistant: str) -> bool:
+        """Genera la guía del asistente con capacidades globales."""
+        try:
+            try:
+                global_ctx = self.engine.get_agent_context("global")
+                guide_caps = global_ctx.get("active_capabilities", [])
+            except (OSError, KeyError):
+                guide_caps = []
+
+            from higpertext.kernel.infrastructure.cli.router import _GUIDE_SPECS
+            spec = _GUIDE_SPECS.get(assistant)
+            if not spec:
+                return False
+
+            rel_path, title, intro = spec
+            guide_file = self.target_path / rel_path
+            guide_file.parent.mkdir(parents=True, exist_ok=True)
+            self._write_md_guide(guide_file, title, intro, guide_caps)
+            return True
+        except Exception as e:
+            _log.warning(f"[!] Error generando guía de usuario: {e}")
+            return False
+
+    def _write_md_guide(
+        self, file_path: Path, title: str, intro_lines: list[str], capabilities: list
+    ) -> None:
+        from higpertext.kernel.infrastructure.cli.router import _PROFILES_SECTION, _RULES_SECTION
+        content = [title] + intro_lines + _PROFILES_SECTION + _RULES_SECTION
+        content.append("\n## 🛠️ Comandos y Herramientas a Integrar")
+        for cap in capabilities:
+            short_id = cap["id"].split(".")[-1]
+            content += [
+                f"### {cap['id']}",
+                f"- **Propósito**: {cap.get('description', '')}",
+                f"- **Comando Base**: `htx task {short_id} [argumentos_aqui]`",
+                "- **Notas de Integración**: *(Espacio para documentar parámetros específicos del proyecto)*\n",
+            ]
+        content.append("\n---\n*higpertext Engine Framework - Automated Agent Configuration.*")
+        file_path.write_text("\n".join(content), encoding="utf-8")
+        _log.ok("[SUCCESS] Guía generada: " f"{file_path.relative_to(file_path.parent.parent)}")

higpertext/kernel/infrastructure/compilers/hook_compiler.py

@@ -0,0 +1,69 @@
+from pathlib import Path
+import json
+from higpertext.kernel.domain.compilers import ICompiler
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+class HookCompiler(ICompiler):
+    def __init__(self, project_root: Path, pkg_data_dir: Path):
+        self.project_root = project_root
+        self.pkg_data_dir = pkg_data_dir
+
+    def compile(self, profile_name: str, assistant: str | None = None, context: dict | None = None) -> bool:
+        """Compila las capas de hooks y renderiza la configuración nativa del asistente."""
+        try:
+            if assistant and context:
+                from higpertext.kernel.application.skill_hook_compiler import SkillHookCompiler
+                cap_ids = [c["id"] for c in context.get("active_capabilities", [])]
+                SkillHookCompiler(self.project_root).compile(profile_name, cap_ids)
+
+            # Compilar capas de hooks
+            self._compile_hook_layers(profile_name)
+
+            if assistant and context:
+                from higpertext.kernel.application.hook_renderer import HookRenderer
+                HookRenderer(self.project_root).render(assistant, profile_name)
+            return True
+        except Exception as e:
+            _log.warning(f"[WARNING] Falló compilación de hooks: {e}")
+            return False
+
+    def _compile_hook_layers(self, profile_name: str) -> None:
+        engine_src = self.pkg_data_dir / "config" / "hooks"
+        agent_src = self.project_root / "src" / "config" / "hooks"
+        layers = [
+            ("global", engine_src / "global"),
+            ("profile", engine_src / "profiles" / profile_name),
+            ("profile_local", agent_src / "profiles" / profile_name),
+            ("custom", agent_src / "custom"),
+        ]
+
+        compiled: list[dict] = []
+        for layer_name, layer_path in layers:
+            if not layer_path.exists():
+                continue
+            for hook_file in sorted(layer_path.glob("*.json")):
+                try:
+                    hook_data = json.loads(hook_file.read_text(encoding="utf-8"))
+                    hook_data["_layer"] = layer_name
+                    hook_data["_source"] = hook_file.as_posix()
+                    if "script" in hook_data:
+                        hook_data["script"] = str(Path(hook_data["script"]))
+                    compiled.append(hook_data)
+                except (OSError, json.JSONDecodeError) as e:
+                    _log.warning(f"[WARNING] Hook ignorado {hook_file.name}: {e}")
+
+        out_dir = self.project_root / WORKSPACE_DIR_NAME / "config"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        out_file = out_dir / "hooks_config.json"
+        existing: dict = {}
+        if out_file.exists():
+            try:
+                existing = json.loads(out_file.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError):
+                pass
+
+        existing["agent_hooks"] = compiled
+        out_file.write_text(json.dumps(existing, indent=2, ensure_ascii=False), encoding="utf-8")
+        _log.info(f"[*] Hooks compilados ({len(compiled)} entradas) en: {out_file}")

higpertext/kernel/infrastructure/compilers/playbook_compiler.py

@@ -0,0 +1,154 @@
+from pathlib import Path
+import json
+import shutil
+from higpertext.kernel.domain.compilers import ICompiler
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+class PlaybookCompiler(ICompiler):
+    def __init__(self, project_root: Path, engine_root: Path, pkg_data_dir: Path, engine):
+        self.project_root = project_root
+        self.engine_root = engine_root
+        self.pkg_data_dir = pkg_data_dir
+        self.engine = engine
+
+    def compile(self, assistant: str, copy_resources: bool = True) -> bool:
+        """Genera los playbooks primarios adaptados al asistente."""
+        try:
+            has_session, session_id = self._read_session_state()
+            from higpertext.kernel.session_manager import SessionManager
+            session_mgr = SessionManager(self.project_root, self.engine_root)
+            wf_dest, sk_dest, sa_dest = session_mgr.get_paths(assistant)
+
+            if not has_session:
+                for d in (sk_dest, sa_dest):
+                    if d.exists():
+                        try:
+                            shutil.rmtree(d)
+                        except OSError:
+                            pass
+
+            from higpertext.kernel.infrastructure.cli.router import _ASSISTANT_IGNORE, _IGNORE_CONTENT
+            for ignore_name in _ASSISTANT_IGNORE.get(assistant, ()):
+                (self.project_root / ignore_name).write_text(_IGNORE_CONTENT, encoding="utf-8")
+
+            skills_str, subs_str = self._build_playbook_strings(
+                has_session, session_id, sk_dest, sa_dest
+            )
+            self._write_playbooks(
+                session_mgr,
+                wf_dest,
+                skills_str,
+                subs_str,
+                has_session,
+                session_id,
+                assistant,
+            )
+            _log.info(f"[*] Workflows generados dinámicamente en: {wf_dest}")
+            return True
+        except Exception as e:
+            _log.warning(f"[!] Error compilando playbooks: {e}")
+            return False
+
+    def _read_session_state(self) -> tuple[bool, str | None]:
+        session_file = self.project_root / WORKSPACE_DIR_NAME / "state" / "session.json"
+        if not session_file.exists():
+            return False, None
+        try:
+            data = json.loads(session_file.read_text(encoding="utf-8"))
+            if data.get("status") == "active":
+                return True, data.get("session_id")
+        except (OSError, json.JSONDecodeError):
+            pass
+        return False, None
+
+    def _collect_skill_links(self, skills_dest: Path) -> list[str]:
+        if not skills_dest.exists():
+            return []
+        links = []
+        for item in sorted(skills_dest.iterdir()):
+            if not item.is_dir():
+                continue
+            try:
+                rel = item.relative_to(self.project_root).as_posix()
+                links.append(f"- [{item.name}](file:///{rel}/SKILL.md)")
+            except ValueError:
+                links.append(f"- `{item.name}`")
+        return links
+
+    def _collect_subagent_links(self, subagents_dest: Path) -> list[str]:
+        if not subagents_dest.exists():
+            return []
+        links = []
+        for item in sorted(subagents_dest.glob("*.md")):
+            try:
+                rel = item.relative_to(self.project_root).as_posix()
+                links.append(f"- [{item.stem}](file:///{rel})")
+            except ValueError:
+                links.append(f"- `{item.stem}`")
+        return links
+
+    def _build_playbook_strings(
+        self,
+        has_session: bool,
+        session_id: str | None,
+        skills_dest: Path,
+        subagents_dest: Path,
+    ) -> tuple[str, str]:
+        if has_session:
+            sk = self._collect_skill_links(skills_dest)
+            sa = self._collect_subagent_links(subagents_dest)
+            skills_str = "\n".join(sk) if sk else "- `00-quick-reference`"
+            subs_str = "\n".join(sa) if sa else "- `research`"
+        else:
+            skills_str = "_No active session — run `session-start` to mount skills._"
+            subs_str = "_No active session — run `session-start` to mount subagents._"
+        return skills_str, subs_str
+
+    def _write_playbooks(
+        self,
+        session_mgr,
+        workflows_dest: Path,
+        skills_str: str,
+        subs_str: str,
+        has_session: bool,
+        session_id: str | None,
+        assistant: str,
+    ) -> None:
+        tmpl_dir = self.pkg_data_dir / "higpertext" / "templates" / "workflows"
+        workflows_dest.mkdir(parents=True, exist_ok=True)
+        for stale in workflows_dest.glob("*.md"):
+            try:
+                stale.unlink()
+            except OSError:
+                pass
+        session_block = (
+            (f"\n# Session Info\n- **Session ID**: `{session_id}`\n- **Status**: `active`")
+            if (has_session and session_id)
+            else ""
+        )
+
+        for name in ("spec", "plan", "build", "review"):
+            src = tmpl_dir / f"{name}.json"
+            if not src.exists():
+                continue
+            try:
+                data = json.loads(src.read_text(encoding="utf-8"))
+                profile_model = session_mgr.get_model(assistant)
+                try:
+                    _, active_profile = session_mgr.get_assistant_and_profile()
+                    profile_data = self.engine.profiles.load_profile(active_profile)
+                    if profile_data and "model" in profile_data:
+                        profile_model = profile_data["model"]
+                except Exception as exc:
+                    _log.warning(f"[!] Modelo de perfil activo no disponible: {exc}")
+
+                content = session_mgr._generate_workflow_base_md(data, assistant, profile_model)
+                content = content.replace("{required_skills_str}", skills_str)
+                content = content.replace("{related_subagents_str}", subs_str)
+                content += session_block
+
+                (workflows_dest / f"{name}.md").write_text(content, encoding="utf-8")
+            except (OSError, json.JSONDecodeError) as e:
+                _log.warning(f"[!] Error compilando playbook '{name}': {e}")