higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/infrastructure/diagnostics/health.py

@@ -0,0 +1,191 @@
+"""higpertext Health Check — verifica integridad del motor en < 2 s (Infraestructura)."""
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+import json
+import time
+import importlib.util
+from pathlib import Path
+from higpertext.kernel.pkg_resources import resolve_resource, pkg_data_root
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+ROOT_DIR = Path(__file__).resolve().parent.parent.parent.parent.parent.parent
+CAPS_DIR = resolve_resource(ROOT_DIR, "src", "higpertext", "capabilities")
+CUSTOM_CAPS_DIR = ROOT_DIR / WORKSPACE_DIR_NAME / "capabilities"
+
+
+def _check_json_valid(path: Path) -> str | None:
+    try:
+        json.loads(path.read_text(encoding="utf-8"))
+        return None
+    except (json.JSONDecodeError, OSError) as e:
+        return str(e)
+
+
+def _collect_all_caps() -> list[Path]:
+    dirs = [CAPS_DIR]
+    if CUSTOM_CAPS_DIR.exists():
+        dirs.append(CUSTOM_CAPS_DIR)
+    result = []
+    for d in dirs:
+        result.extend(d.rglob("*.json"))
+    return result
+
+
+def _display_path(p: Path) -> str:
+    for base in (ROOT_DIR, pkg_data_root()):
+        if base is not None:
+            try:
+                return str(p.relative_to(base))
+            except ValueError:
+                continue
+    return str(p)
+
+
+def _check_entrypoint(cap_json: Path, entrypoint: str) -> dict | None:
+    ep_path = entrypoint
+    for prefix in ("python3 ", "python "):
+        if ep_path.startswith(prefix):
+            ep_path = ep_path[len(prefix) :]
+            break
+    candidates = [ROOT_DIR / "src" / ep_path, ROOT_DIR / ep_path]
+    pkg_root = pkg_data_root()
+    if pkg_root is not None:
+        candidates.append(pkg_root / ep_path)
+    if any(c.exists() for c in candidates):
+        return None
+    return {
+        "file": _display_path(cap_json),
+        "severity": "critical",
+        "issue": f"Entrypoint no encontrado: {entrypoint}",
+    }
+
+
+def _check_capabilities() -> list[dict]:
+    issues = []
+    for cap_json in _collect_all_caps():
+        err = _check_json_valid(cap_json)
+        if err:
+            issues.append(
+                {
+                    "file": _display_path(cap_json),
+                    "severity": "critical",
+                    "issue": f"JSON inválido: {err}",
+                }
+            )
+            continue
+
+        data = json.loads(cap_json.read_text(encoding="utf-8"))
+
+        if "version" not in data:
+            issues.append(
+                {
+                    "file": _display_path(cap_json),
+                    "severity": "warning",
+                    "issue": "Falta campo 'version'",
+                }
+            )
+
+        entrypoint = data.get("entrypoint")
+        if entrypoint:
+            issue = _check_entrypoint(cap_json, entrypoint)
+            if issue:
+                issues.append(issue)
+    return issues
+
+
+def _check_python_deps() -> list[dict]:
+    required = ["argparse", "json", "pathlib", "subprocess", "ast"]
+    issues = []
+    for mod in required:
+        if importlib.util.find_spec(mod) is None:
+            issues.append(
+                {
+                    "module": mod,
+                    "severity": "critical",
+                    "issue": "Módulo requerido no disponible",
+                }
+            )
+    return issues
+
+
+def _check_venv() -> dict:
+    import platform
+    venv_name = ".venv"
+    try:
+        from higpertext.kernel.htx_resolver import _load_config
+        cfg = _load_config()
+        is_windows = platform.system() == "Windows"
+        venv_rel = cfg.get("venv_bin_windows" if is_windows else "venv_bin", ".venv/bin/htx")
+        venv_name = str(Path(venv_rel).parent.parent)
+    except Exception as exc:
+        _log.warning(f"[health] No se pudo leer config de venv: {exc}")
+    venv = ROOT_DIR / venv_name
+    if venv.exists():
+        return {"status": "ok", "path": str(venv.relative_to(ROOT_DIR))}
+    return {
+        "status": "warning",
+        "message": f"{venv_name} no encontrado — usando Python del sistema",
+    }
+
+
+def run_health_check(verbose: bool = False) -> int:
+    t0 = time.time()
+    _log.info("=" * 60)
+    _log.info("HIGPERTEXT ENGINE — HEALTH CHECK")
+    _log.info("=" * 60)
+
+    cap_issues = _check_capabilities()
+    critical_caps = [i for i in cap_issues if i["severity"] == "critical"]
+    warning_caps = [i for i in cap_issues if i["severity"] == "warning"]
+
+    _log.info(f"\n[Capabilities] {len(_collect_all_caps())} archivos JSON escaneados")
+    _print_issues(critical_caps, "errores críticos", "✖", verbose=True)
+    _print_issues(warning_caps, "advertencias", "⚠", verbose=verbose)
+
+    dep_issues = _check_python_deps()
+    _log.info(f"\n[Python Deps] Módulos core del motor")
+    _print_issues(dep_issues, "Módulos faltantes", "✖", key="module")
+
+    venv_status = _check_venv()
+    _log.info(f"\n[Entorno]")
+    if venv_status["status"] == "ok":
+        _log.info(f"  ✔ .venv encontrado: {venv_status['path']}")
+    else:
+        _log.warning(f"  ⚠  {venv_status['message']}")
+
+    elapsed = time.time() - t0
+    ok = len(critical_caps) == 0 and len(dep_issues) == 0
+    _log.info(f"\n{'=' * 60}")
+    status_label = "OK" if ok else "FAIL"
+    _log.info(f"Estado: {status_label} | Tiempo: {elapsed:.2f}s")
+    _log.info("=" * 60)
+
+    return 0 if ok else 1
+
+
+def _print_issues(
+    issues: list[dict],
+    label: str,
+    symbol: str,
+    verbose: bool = False,
+    key: str = "issue",
+) -> None:
+    if not issues:
+        if label in ("errores críticos", "Módulos faltantes"):
+            _log.info(f"  ✔ Sin {label.lower()}")
+        return
+
+    show_all = verbose or label in ("errores críticos", "Módulos faltantes")
+    total = len(issues)
+    if not show_all:
+        _log.info(f"  {symbol} {total} {label} (usa --verbose para ver)")
+        return
+
+    _log.info(f"  {symbol} {total} {label}:")
+    for issue in issues[:10]:
+        file_info = f"{issue['file']}: " if 'file' in issue else ""
+        _log.info(f"    - {file_info}{issue[key]}")
+    if total > 10 and verbose:
+        _log.info(f"    ... y {total - 10} más (usa --verbose para ver todos)")

higpertext/kernel/infrastructure/env_runtime.py

@@ -0,0 +1,227 @@
+"""Implementación de infraestructura para ejecución de entornos Docker/Podman."""
+
+from __future__ import annotations
+import json
+import shutil
+# Ejecución de Docker/Podman con listas y sin shell.
+import subprocess  # nosec B404
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+import yaml
+
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+from higpertext.kernel.domain.env_runtime import EnvironmentTemplate, RunState, RunSpec
+
+
+def run_process(args: list[str], cwd: str, timeout: int = 300) -> tuple[int, str, str]:
+    """Ejecuta proceso sin shell y devuelve rc/stdout/stderr."""
+    result = subprocess.run(
+        args, cwd=cwd, timeout=timeout, capture_output=True, text=True
+    )
+    return result.returncode, result.stdout or "", result.stderr or ""
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    rc: int
+    stdout: str
+    stderr: str
+
+
+class ComposeBackend:
+    """Backend común para docker compose y podman compose."""
+
+    def __init__(self, engine: str) -> None:
+        self.engine = engine
+
+    def available(self) -> bool:
+        return shutil.which(self.engine) is not None
+
+    def compose_base(self, project_name: str, compose_file: Path) -> list[str]:
+        return [self.engine, "compose", "-p", project_name, "-f", str(compose_file)]
+
+    def up(self, project_name: str, compose_file: Path, cwd: Path, timeout: int) -> CommandResult:
+        return self._run(self.compose_base(project_name, compose_file) + ["up", "-d"], cwd, timeout)
+
+    def exec(
+        self,
+        project_name: str,
+        compose_file: Path,
+        cwd: Path,
+        service: str,
+        command: str,
+        timeout: int,
+    ) -> CommandResult:
+        args = self.compose_base(project_name, compose_file) + [
+            "exec",
+            "-T",
+            service,
+            "sh",
+            "-lc",
+            command,
+        ]
+        return self._run(args, cwd, timeout)
+
+    def logs(
+        self,
+        project_name: str,
+        compose_file: Path,
+        cwd: Path,
+        service: str = "",
+        tail: int = 200,
+    ) -> CommandResult:
+        args = self.compose_base(project_name, compose_file) + [
+            "logs",
+            "--no-color",
+            "--tail",
+            str(tail),
+        ]
+        if service:
+            args.append(service)
+        return self._run(args, cwd, 60)
+
+    def down(
+        self, project_name: str, compose_file: Path, cwd: Path, volumes: bool = False
+    ) -> CommandResult:
+        args = self.compose_base(project_name, compose_file) + ["down"]
+        if volumes:
+            args.append("--volumes")
+        return self._run(args, cwd, 120)
+
+    @staticmethod
+    def _run(args: list[str], cwd: Path, timeout: int) -> CommandResult:
+        rc, stdout, stderr = run_process(args, str(cwd), timeout)
+        return CommandResult(rc, stdout, stderr)
+
+
+def resolve_backend(engine: str) -> ComposeBackend:
+    """Selecciona Docker/Podman; auto prefiere Docker y luego Podman."""
+    candidates = ["docker", "podman"] if engine == "auto" else [engine]
+    for candidate in candidates:
+        backend = ComposeBackend(candidate)
+        if backend.available():
+            return backend
+    raise RuntimeError(f"No hay motor de contenedores disponible para: {engine}")
+
+
+class RunStore:
+    """Guarda estados bajo .higpertext/env/runs/<run_id>."""
+
+    def __init__(self, project_root: Path) -> None:
+        self.root = project_root / WORKSPACE_DIR_NAME / "env" / "runs"
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def run_dir(self, run_id: str) -> Path:
+        path = self.root / run_id
+        path.mkdir(parents=True, exist_ok=True)
+        (path / "logs").mkdir(exist_ok=True)
+        return path
+
+    def save(self, state: RunState) -> None:
+        path = Path(state.run_dir) / "state.json"
+        path.write_text(json.dumps(state.to_dict(), ensure_ascii=False, indent=2), encoding="utf-8")
+
+    def load(self, run_id: str) -> RunState:
+        path = self.root / run_id / "state.json"
+        if not path.exists():
+            raise FileNotFoundError(f"Run no encontrado: {run_id}")
+        return RunState.from_dict(json.loads(path.read_text(encoding="utf-8")))
+
+    def list(self) -> list[RunState]:
+        states = []
+        for path in sorted(self.root.glob("*/state.json")):
+            try:
+                states.append(RunState.from_dict(json.loads(path.read_text(encoding="utf-8"))))
+            except (OSError, json.JSONDecodeError, TypeError):
+                continue
+        return states
+
+    def delete(self, run_id: str) -> None:
+        shutil.rmtree(self.root / run_id, ignore_errors=True)
+
+
+class ComposeRenderer:
+    """Convierte una plantilla a Docker/Podman Compose."""
+
+    def render(self, template: EnvironmentTemplate, spec: RunSpec, run_dir: Path) -> Path:
+        services = {
+            name: self._service_payload(payload, template, spec)
+            for name, payload in template.services.items()
+        }
+        compose = {"services": services}
+        if template.security.get("network", "isolated") == "isolated":
+            compose["networks"] = {"default": {"name": f"{run_dir.name}_net"}}
+        path = run_dir / "compose.yaml"
+        path.write_text(yaml.safe_dump(compose, sort_keys=False), encoding="utf-8")
+        return path
+
+    def _service_payload(
+        self, payload: dict[str, Any], template: EnvironmentTemplate, spec: RunSpec
+    ) -> dict[str, Any]:
+        result = {k: v for k, v in payload.items() if k not in {"tasks", "install", "env"}}
+        limits = template.limits
+        if limits.get("memory"):
+            result["mem_limit"] = str(limits["memory"])
+        if limits.get("cpus"):
+            result["cpus"] = str(limits["cpus"])
+        env = dict(result.get("environment", {}) or {})
+        env.update(payload.get("env", {}) or {})
+        env.update(spec.env)
+        if env:
+            result["environment"] = env
+        result["privileged"] = bool(template.security.get("privileged", False))
+        return result
+
+
+class TemplateLoader:
+    """Resuelve templates locales primero y luego templates del motor."""
+
+    def __init__(self, project_root: Path) -> None:
+        self.project_root = project_root
+        self.local_dir = project_root / WORKSPACE_DIR_NAME / "env" / "templates"
+        self.engine_dir = Path(__file__).resolve().parents[2] / "templates" / "env"
+
+    def list_templates(self) -> list[EnvironmentTemplate]:
+        templates: dict[str, EnvironmentTemplate] = {}
+        for directory in (self.engine_dir, self.local_dir):
+            if not directory.exists():
+                continue
+            for path in sorted(
+                [
+                    *directory.glob("*.yaml"),
+                    *directory.glob("*.yml"),
+                    *directory.glob("*.json"),
+                ]
+            ):
+                template = self.load_file(path)
+                templates[template.id] = template
+        return sorted(templates.values(), key=lambda item: item.id)
+
+    def load(self, template_id: str) -> EnvironmentTemplate:
+        for directory in (self.local_dir, self.engine_dir):
+            for suffix in (".yaml", ".yml", ".json"):
+                path = directory / f"{template_id}{suffix}"
+                if path.exists():
+                    return self.load_file(path)
+        raise FileNotFoundError(f"Template no encontrado: {template_id}")
+
+    @staticmethod
+    def load_file(path: Path) -> EnvironmentTemplate:
+        data: dict[str, Any]
+        if path.suffix == ".json":
+            data = json.loads(path.read_text(encoding="utf-8"))
+        else:
+            data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+        if not data.get("id") or not isinstance(data.get("services"), dict):
+            raise ValueError(f"Template inválido: {path}")
+        return EnvironmentTemplate(
+            id=data["id"],
+            description=data.get("description", ""),
+            services=data["services"],
+            defaults=data.get("defaults", {}),
+            tasks=data.get("tasks", data.get("checks", {})),
+            limits=data.get("limits", {}),
+            security=data.get("security", {}),
+            source=path,
+        )

higpertext/kernel/infrastructure/execution/__init__.py

@@ -0,0 +1 @@
+# Infrastructure execution init

higpertext/kernel/infrastructure/execution/parallel.py

@@ -0,0 +1,188 @@
+"""higpertext Parallel Executor — ejecución concurrente de pasos independientes en workflows
+(Infraestructura)."""
+
+from __future__ import annotations
+import threading
+from dataclasses import dataclass, field
+from typing import Callable
+
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+
+@dataclass
+class StepResult:
+    step: int
+    task: str
+    success: bool
+    error: str = ""
+
+
+@dataclass
+class StepGroup:
+    """Grupo de pasos que pueden ejecutarse en paralelo."""
+
+    steps: list[dict] = field(default_factory=list)
+
+    def is_parallel(self) -> bool:
+        return len(self.steps) > 1
+
+
+def build_step_groups(chain: list[dict]) -> list[StepGroup]:
+    """Agrupa pasos del workflow por nivel de paralelismo."""
+    sorted_chain = sorted(chain, key=lambda x: x.get("step", 0))
+    groups: list[StepGroup] = []
+    current_group: StepGroup | None = None
+    current_pg: str | None = None
+
+    for step in sorted_chain:
+        is_parallel = step.get("parallel", False)
+        pg = step.get("parallel_group", None)
+
+        if is_parallel:
+            effective_pg = pg or "__auto__"
+            if current_group is None or current_pg != effective_pg:
+                current_group = StepGroup()
+                groups.append(current_group)
+                current_pg = effective_pg
+            current_group.steps.append(step)
+        else:
+            current_group = StepGroup(steps=[step])
+            groups.append(current_group)
+            current_pg = None
+
+    return groups
+
+
+class ParallelExecutor:
+    """Ejecuta grupos de pasos de workflow en paralelo usando threads."""
+
+    def __init__(self, run_task_fn: Callable[[str, dict], bool]) -> None:
+        self._run_task = run_task_fn
+
+    def execute_group(self, group: StepGroup, params: dict) -> list[StepResult]:
+        if not group.is_parallel():
+            return [self._execute_step(group.steps[0], params)]
+
+        results: list[StepResult] = []
+        lock = threading.Lock()
+        threads: list[threading.Thread] = []
+
+        def worker(step: dict) -> None:
+            res = self._execute_step(step, params)
+            with lock:
+                results.append(res)
+
+        step_nums = [s.get("step", "?") for s in group.steps]
+        _log.info(f"[Parallel] Ejecutando pasos {step_nums} concurrentemente...")
+
+        for step in group.steps:
+            t = threading.Thread(target=worker, args=(step,), daemon=True)
+            threads.append(t)
+            t.start()
+
+        for t in threads:
+            t.join()
+
+        results.sort(key=lambda r: r.step)
+        return results
+
+    def _execute_step(self, step: dict, params: dict) -> StepResult:
+        step_type = step.get("type", "task")
+        step_num = step.get("step", 0)
+        merged = {**params, **step.get("params", {})}
+
+        if step_type == "llm":
+            return self._execute_llm_step(step, step_num, merged)
+
+        task_name = step.get("task", "")
+        _log.info(f"[Step {step_num}] Iniciando tarea: {task_name}")
+        try:
+            success = self._run_task(task_name, merged)
+            return StepResult(step=step_num, task=task_name, success=success)
+        except Exception as e:  # noqa: BLE001
+            return StepResult(step=step_num, task=task_name, success=False, error=str(e))
+
+    def _execute_llm_step(self, step: dict, step_num: int, params: dict) -> StepResult:
+        """Ejecuta un step de tipo 'llm' via common.llm-invoke."""
+        llm_params = {
+            "prompt": step.get("prompt", params.get("prompt", "")),
+            "provider": step.get("provider", params.get("provider", "")),
+            "model": step.get("model", params.get("model", "")),
+            "system": step.get("system", params.get("system", "")),
+            "max_tokens": step.get("max_tokens", params.get("max_tokens", 1024)),
+            "temperature": step.get("temperature", params.get("temperature", 0.7)),
+            "stream": step.get("stream", params.get("stream", "false")),
+            "output_file": step.get("output_file", params.get("output_file", "")),
+        }
+        label = f"llm:{step.get('provider', 'default')}"
+        _log.info(f"[Step {step_num}] Iniciando step LLM: {label}")
+        try:
+            success = self._run_task("common.llm-invoke", llm_params)
+            return StepResult(step=step_num, task=label, success=success)
+        except Exception as e:  # noqa: BLE001
+            return StepResult(step=step_num, task=label, success=False, error=str(e))
+
+    def _resolve_step_params(
+        self,
+        group: StepGroup,
+        params: dict,
+        interpolate_fn: Callable[[dict, dict], dict] | None,
+    ) -> list[dict]:
+        step_params_list: list[dict] = []
+        for step in group.steps:
+            raw = step.get("params", {})
+            resolved = interpolate_fn(raw, params) if interpolate_fn else raw
+            step_params_list.append(resolved)
+        return step_params_list
+
+    def _execute_group_with_params(
+        self,
+        group: StepGroup,
+        step_params_list: list[dict],
+        params: dict,
+    ) -> list[StepResult]:
+        if group.is_parallel():
+            enriched_steps = [
+                {**step, "params": sp}
+                for step, sp in zip(group.steps, step_params_list)
+            ]
+            group_with_params = StepGroup(steps=enriched_steps)
+            return self.execute_group(group_with_params, params)
+
+        step = {**group.steps[0], "params": step_params_list[0]}
+        return [self._execute_step(step, params)]
+
+    def _handle_results(self, group: StepGroup, results: list[StepResult]) -> bool:
+        for res in results:
+            if res.success:
+                continue
+
+            step_def = next((s for s in group.steps if s.get("step") == res.step), {})
+            on_failure = step_def.get("on_failure", "abort")
+            if res.error:
+                _log.warning(f"[!] Paso {res.step} ({res.task}) — excepción: {res.error}")
+            else:
+                _log.warning(f"[!] Paso {res.step} ({res.task}) falló. Acción: {on_failure}")
+
+            if on_failure == "abort":
+                _log.error("[ERROR] Flujo de trabajo abortado.")
+                return False
+        return True
+
+    def execute_chain(
+        self,
+        chain: list[dict],
+        params: dict,
+        interpolate_fn: Callable[[dict, dict], dict] | None = None,
+    ) -> bool:
+        groups = build_step_groups(chain)
+
+        for group in groups:
+            step_params_list = self._resolve_step_params(group, params, interpolate_fn)
+            results = self._execute_group_with_params(group, step_params_list, params)
+            if not self._handle_results(group, results):
+                return False
+
+        _log.ok("\n[SUCCESS] Flujo de trabajo completado con éxito.")
+        return True