higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/engine.py

@@ -0,0 +1,42 @@
+"""higpertext Engine — orquestador central que ensambla perfiles, capacidades y workflows."""
+
+from __future__ import annotations
+from pathlib import Path
+from higpertext.kernel.application.engine import ApplicationHigpertextEngine
+from higpertext.kernel.pkg_resources import resolve_resource
+from higpertext.kernel.application.profile_services import ProfileManager
+from higpertext.kernel.application.capability_manager import CapabilityManager
+from higpertext.kernel.application.workflow_manager import WorkflowManager
+
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+
+class HigpertextEngine:
+    """Orquestador central del higpertext Engine v5.0 (Fachada de compatibilidad)."""
+
+    def __init__(self, base_dir: Path) -> None:
+        self.base_dir = base_dir
+        self._app_engine = ApplicationHigpertextEngine(base_dir)
+
+        # Preserva atributos públicos requeridos por otras dependencias del kernel
+        # e indirectamente tests
+        self.profiles = ProfileManager(resolve_resource(base_dir, "src", "config", "profiles"))
+        self.capabilities = CapabilityManager(
+            resolve_resource(base_dir, "src", "higpertext", "capabilities")
+        )
+        self.workflows = WorkflowManager(resolve_resource(base_dir, "src", "config", "workflows"))
+
+    def get_agent_context(self, profile_name: str, env_data: dict | None = None) -> dict:
+        """Construye el contexto completo resolviendo la jerarquía de perfiles."""
+        return self._app_engine.get_agent_context(profile_name, env_data)
+
+    def validate_profile(self, profile_name: str) -> tuple[bool, list[str], list[str]]:
+        """Valida un perfil e integridad de sus dependencias."""
+        return self._app_engine.validate_profile(profile_name)
+
+    def get_all_capabilities(self) -> list:
+        return self.capabilities.get_all_capabilities_data()
+
+    def get_all_workflows(self) -> list:
+        return self.workflows.get_all_workflows_data()

higpertext/kernel/htx_resolver.py

@@ -0,0 +1,69 @@
+"""Single source of truth para resolver el ejecutable htx."""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shutil
+from functools import lru_cache
+from pathlib import Path
+
+
+@lru_cache(maxsize=1)
+def _load_config() -> dict:
+    possible_paths = [
+        Path(__file__).resolve().parents[3] / "src" / "config" / "htx_config.json",
+        Path(__file__).resolve().parents[4] / "src" / "config" / "htx_config.json",
+        Path("/home/aomerge/Documentos/Proyects/agents/LLM-agent/src/config/htx_config.json"),
+    ]
+    for config_path in possible_paths:
+        if config_path.exists():
+            try:
+                return json.loads(config_path.read_text(encoding="utf-8")).get("htx", {})
+            except (OSError, json.JSONDecodeError):
+                continue
+    return {}
+
+
+def _config() -> dict:
+    return _load_config()
+
+
+def _cli_name() -> str:
+    """Nombre del comando CLI para usar en textos/prompts (leído desde config)."""
+    return _config().get("cli_name", "htx")
+
+
+HTX_CMD = f"{_cli_name()} task"
+HTX_WORKFLOW_CMD = f"{_cli_name()} workflow run"
+
+
+def get_htx_cmd(project_root: Path) -> list[str]:
+    """Resuelve el ejecutable htx en orden de prioridad.
+
+    1. Variable de entorno HIGPERTEXT_HTX_BIN (override explícito)
+    2. .venv/bin/htx del project_root
+    3. htx en PATH del sistema
+    4. python htx.py (fallback legacy)
+    """
+    cfg = _config()
+
+    env_var = cfg.get("env_override", "HIGPERTEXT_HTX_BIN")
+    if override := os.environ.get(env_var):
+        return [override]
+
+    is_windows = platform.system() == "Windows"
+    venv_key = "venv_bin_windows" if is_windows else "venv_bin"
+    venv_rel = cfg.get(venv_key, ".venv/bin/htx")
+    venv_htx = project_root / venv_rel
+    if venv_htx.exists():
+        return [str(venv_htx)]
+
+    if system_htx := shutil.which("htx"):
+        return [system_htx]
+
+    fallback = cfg.get("fallback_script", "htx.py")
+    venv_python = project_root / ".venv" / ("Scripts/python.exe" if is_windows else "bin/python")
+    python = str(venv_python) if venv_python.exists() else "python"
+    return [python, str(project_root / fallback)]

higpertext/kernel/infrastructure/__init__.py

@@ -0,0 +1,13 @@
+# Infrastructure layer init
+from higpertext.kernel.infrastructure.governance import ContractLoader, AuditLog
+from higpertext.kernel.infrastructure.agent_registry import JsonAgentRegistry
+from higpertext.kernel.infrastructure.env_runtime import RunStore, ComposeRenderer, TemplateLoader, ComposeBackend, resolve_backend
+from higpertext.kernel.infrastructure.output_store import OutputStore
+from higpertext.kernel.infrastructure.profile_store import ProfileStore
+from higpertext.kernel.infrastructure.telemetry_reporter import render as render_telemetry
+from higpertext.kernel.infrastructure.context_engine import GraphIndex, PackStore, should_skeletonize, extract_skeleton, TelemetryReader
+from higpertext.kernel.infrastructure.semantic_engine import FileCache, GraphRebuildHook, GraphStore, LanguageParser, PythonParser, TypeScriptParser
+from higpertext.kernel.infrastructure.logger import get_logger, HtxLogger, reset_logger
+
+
+

higpertext/kernel/infrastructure/agent_registry.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+import json
+from pathlib import Path
+
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+from higpertext.kernel.domain.agent_registry import AgentRecord
+
+_REGISTRY_PATH = Path(WORKSPACE_DIR_NAME) / "config" / "agents_registry.json"
+
+
+class JsonAgentRegistry:
+    def __init__(self, engine_root: Path) -> None:
+        self._path = engine_root / _REGISTRY_PATH
+
+    def load(self) -> list[AgentRecord]:
+        if not self._path.exists():
+            return []
+        try:
+            data = json.loads(self._path.read_text(encoding="utf-8"))
+            return [AgentRecord(**a) for a in data.get("agents", [])]
+        except (OSError, json.JSONDecodeError, TypeError):
+            return []
+
+    def save(self, agents: list[AgentRecord]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        payload = {
+            "agents": [
+                {
+                    "name": a.name,
+                    "path": a.path,
+                    "profile": a.profile,
+                    "registered_at": a.registered_at,
+                }
+                for a in agents
+            ]
+        }
+        self._path.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    def find_by_name(self, name: str) -> AgentRecord | None:
+        return next((a for a in self.load() if a.name == name), None)

higpertext/kernel/infrastructure/cache/capability_cache.py

@@ -0,0 +1,319 @@
+"""higpertext Capability Cache - cache de resultados basado en hash de inputs + TTL (Infraestructura)."""  # noqa: E501
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+
+import hashlib
+import json
+import os
+# Tipos CompletedProcess; no ejecuta shell aquí.
+import subprocess  # nosec B404
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from higpertext.kernel.app_config import (
+    CACHE_DIR as _CACHE_DIR_NAME,
+    CACHE_FILE_GLOB as _CACHE_FILE_GLOB,
+    NO_CACHE_CAPABILITIES as _NO_CACHE_CAPABILITIES,
+)
+
+_DEFAULT_TTL = 300  # 5 minutos
+_DEFAULT_CACHE_DIR = f"{WORKSPACE_DIR_NAME}/{_CACHE_DIR_NAME}"
+
+
+@dataclass
+class CacheEntry:
+    stdout: str
+    stderr: str
+    returncode: int
+    created_at: float
+    ttl: float
+
+    def is_expired(self) -> bool:
+        return time.monotonic() - self.created_at > self.ttl
+
+    def to_dict(self) -> dict:
+        return {
+            "stdout": self.stdout,
+            "stderr": self.stderr,
+            "returncode": self.returncode,
+            "created_at": self.created_at,
+            "ttl": self.ttl,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "CacheEntry":
+        return cls(
+            stdout=data["stdout"],
+            stderr=data["stderr"],
+            returncode=data["returncode"],
+            created_at=data["created_at"],
+            ttl=data["ttl"],
+        )
+
+
+class CapabilityCache:
+    """
+    Cache de resultados de capabilities con invalidación por TTL y hash de inputs.
+
+    La clave de cache combina:
+    - capability_id
+    - parámetros de invocación (ordenados y serializados)
+    - hash del archivo entrypoint (detecta cambios en el script)
+    """
+
+    def __init__(
+        self,
+        cache_dir: Path | None = None,
+        default_ttl: float = _DEFAULT_TTL,
+    ) -> None:
+        self._cache_dir = cache_dir or (Path(os.getcwd()) / _DEFAULT_CACHE_DIR)
+        self._default_ttl = default_ttl
+        self._memory: dict[str, CacheEntry] = {}
+        # Índice inverso: capability_id → set de claves de cache
+        self._cap_index: dict[str, set[str]] = {}
+
+    def _ensure_dir(self) -> None:
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def _cache_key(self, capability_id: str, params: dict, entrypoint: str = "") -> str:
+        payload = {
+            "id": capability_id,
+            "params": dict(sorted(params.items())),
+            "entrypoint_hash": self._hash_entrypoint(entrypoint),
+            "workspace_fingerprint": self._workspace_fingerprint(params),
+        }
+        raw = json.dumps(payload, sort_keys=True, ensure_ascii=False)
+        return hashlib.sha256(raw.encode()).hexdigest()[:16]
+
+    @staticmethod
+    def _hash_entrypoint(entrypoint: str) -> str:
+        """Hash del script para invalidar cache cuando el script cambia."""
+        if not entrypoint:
+            return ""
+        try:
+            content = Path(entrypoint).read_bytes()
+            return hashlib.md5(content).hexdigest()[:8]  # nosec B324
+        except OSError:
+            return ""
+
+    def _cache_file(self, key: str) -> Path:
+        return self._cache_dir / f"{key}.json"
+
+    def _workspace_fingerprint(self, params: dict) -> str:
+        """Fingerprint barato del workspace y rutas de entrada relevantes."""
+        parts = [self._git_fingerprint(), self._params_paths_fingerprint(params)]
+        raw = "|".join(part for part in parts if part)
+        return hashlib.sha256(raw.encode()).hexdigest()[:16] if raw else ""
+
+    @staticmethod
+    def _git_fingerprint() -> str:
+        try:
+            head = subprocess.run(
+                ["git", "rev-parse", "HEAD"],
+                capture_output=True,
+                text=True,
+                timeout=2,
+                check=False,
+            ).stdout.strip()
+            status = subprocess.run(
+                ["git", "status", "--porcelain=v1"],
+                capture_output=True,
+                text=True,
+                timeout=3,
+                check=False,
+            ).stdout.strip()
+            return f"{head}\n{status}"
+        except (OSError, subprocess.TimeoutExpired):
+            return ""
+
+    def _params_paths_fingerprint(self, params: dict) -> str:
+        path_keys = {
+            "path",
+            "tests_path",
+            "source_path",
+            "file",
+            "files",
+            "target",
+            "target_dir",
+        }
+        chunks: list[str] = []
+        for key, value in sorted(params.items()):
+            if key not in path_keys or not value:
+                continue
+            for item in str(value).replace(",", " ").split():
+                chunks.extend(self._path_fingerprint(Path(item)))
+        return "\n".join(chunks)
+
+    @staticmethod
+    def _path_fingerprint(path: Path) -> list[str]:
+        if not path.exists():
+            return []
+        if path.is_file():
+            stat = path.stat()
+            return [f"{path}:{stat.st_size}:{stat.st_mtime_ns}"]
+        ignored = {
+            ".git",
+            ".venv",
+            "venv",
+            "node_modules",
+            "__pycache__",
+            WORKSPACE_DIR_NAME,
+        }
+        chunks: list[str] = []
+        for child in sorted(path.rglob("*")):
+            if len(chunks) >= 2000:
+                chunks.append("[truncated]")
+                break
+            if any(part in ignored for part in child.parts):
+                continue
+            if child.is_file():
+                stat = child.stat()
+                chunks.append(f"{child}:{stat.st_size}:{stat.st_mtime_ns}")
+        return chunks
+
+    def get(self, capability_id: str, params: dict, entrypoint: str = "") -> CacheEntry | None:
+        """Retorna la entrada cacheada si existe y no ha expirado."""
+        short_id = capability_id.split(".")[-1]
+        if capability_id in _NO_CACHE_CAPABILITIES or short_id in _NO_CACHE_CAPABILITIES:
+            return None
+
+        key = self._cache_key(capability_id, params, entrypoint)
+
+        # Primero revisa memoria
+        if key in self._memory:
+            entry = self._memory[key]
+            if not entry.is_expired():
+                return entry
+            del self._memory[key]
+
+        # Luego revisa disco
+        cache_file = self._cache_file(key)
+        if not cache_file.exists():
+            return None
+
+        try:
+            data = json.loads(cache_file.read_text(encoding="utf-8"))
+            entry = CacheEntry.from_dict(data)
+            if entry.is_expired():
+                cache_file.unlink(missing_ok=True)
+                return None
+            self._memory[key] = entry
+            return entry
+        except (OSError, json.JSONDecodeError, KeyError):
+            return None
+
+    def set(
+        self,
+        capability_id: str,
+        params: dict,
+        stdout: str,
+        stderr: str,
+        returncode: int,
+        entrypoint: str = "",
+        ttl: float | None = None,
+    ) -> None:
+        """Almacena un resultado en cache (memoria + disco)."""
+        short_id = capability_id.split(".")[-1]
+        if capability_id in _NO_CACHE_CAPABILITIES or short_id in _NO_CACHE_CAPABILITIES:
+            return
+        if returncode != 0:
+            return
+
+        effective_ttl = ttl if ttl is not None else self._default_ttl
+        key = self._cache_key(capability_id, params, entrypoint)
+        entry = CacheEntry(
+            stdout=stdout,
+            stderr=stderr,
+            returncode=returncode,
+            created_at=time.monotonic(),
+            ttl=effective_ttl,
+        )
+        self._memory[key] = entry
+        self._cap_index.setdefault(capability_id, set()).add(key)
+
+        try:
+            self._ensure_dir()
+            disk_data = {**entry.to_dict(), "_cap_id": capability_id}
+            self._cache_file(key).write_text(
+                json.dumps(disk_data, ensure_ascii=False, indent=2),
+                encoding="utf-8",
+            )
+        except OSError:  # nosec B110
+            pass
+
+    def invalidate(self, capability_id: str) -> int:
+        """Invalida todas las entradas de una capability. Retorna cantidad eliminada."""
+        keys = self._cap_index.pop(capability_id, set())
+        removed_memory = self._invalidate_memory_and_keys(keys)
+        removed_disk = self._invalidate_disk_by_id(capability_id)
+        return removed_memory + removed_disk
+
+    def _invalidate_memory_and_keys(self, keys: set[str]) -> int:
+        removed = 0
+        for k in keys:
+            if k in self._memory:
+                del self._memory[k]
+                removed += 1
+            cache_file = self._cache_file(k)
+            if cache_file.exists():
+                try:
+                    cache_file.unlink()
+                except OSError:  # nosec B110
+                    pass
+        return removed
+
+    def _invalidate_disk_by_id(self, capability_id: str) -> int:
+        removed = 0
+        if not self._cache_dir.exists():
+            return removed
+        for f in self._cache_dir.glob(_CACHE_FILE_GLOB):
+            try:
+                data = json.loads(f.read_text(encoding="utf-8"))
+                if data.get("_cap_id") == capability_id:
+                    key = f.stem
+                    self._memory.pop(key, None)
+                    f.unlink()
+                    removed += 1
+            except (OSError, json.JSONDecodeError):  # nosec B110
+                pass
+        return removed
+
+    def clear_expired(self) -> int:
+        """Elimina del disco todas las entradas expiradas. Retorna cantidad."""
+        removed = 0
+        if not self._cache_dir.exists():
+            return 0
+        for f in self._cache_dir.glob(_CACHE_FILE_GLOB):
+            try:
+                data = json.loads(f.read_text(encoding="utf-8"))
+                entry = CacheEntry.from_dict(data)
+                if entry.is_expired():
+                    f.unlink()
+                    removed += 1
+            except (OSError, json.JSONDecodeError, KeyError):
+                f.unlink(missing_ok=True)
+                removed += 1
+        return removed
+
+    def stats(self) -> dict:
+        """Retorna estadísticas del cache."""
+        total_disk = len(list(self._cache_dir.glob(_CACHE_FILE_GLOB))) if self._cache_dir.exists() else 0
+        return {
+            "in_memory": len(self._memory),
+            "on_disk": total_disk,
+            "cache_dir": str(self._cache_dir),
+            "default_ttl_seconds": self._default_ttl,
+        }
+
+
+# Singleton global del cache
+_capability_cache: CapabilityCache | None = None
+
+
+def get_capability_cache() -> CapabilityCache:
+    global _capability_cache
+    if _capability_cache is None:
+        _capability_cache = CapabilityCache()
+    return _capability_cache

higpertext/kernel/infrastructure/capability_helper.py

@@ -0,0 +1,40 @@
+"""Módulo centralizado de utilidades y helpers comunes para scripts de capacidades
+(Infraestructura)."""
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+import json
+from pathlib import Path
+
+
+class CapabilityHelper:
+    @staticmethod
+    def get_project_root(start_path: Path | None = None) -> Path:
+        """Busca recursivamente hacia arriba hasta encontrar el directorio raíz del proyecto
+        (.higpertext o .git)."""
+        current = Path(start_path or Path(__file__)).resolve()
+        for parent in [current] + list(current.parents):
+            if (parent / WORKSPACE_DIR_NAME).exists() or (parent / ".git").exists():
+                return parent
+        # Fallback al directorio de trabajo actual
+        return Path.cwd().resolve()
+
+    @staticmethod
+    def load_json_file(file_path: Path) -> dict:
+        """Carga y parsea de forma segura un archivo JSON."""
+        if not file_path.exists():
+            return {}
+        try:
+            return json.loads(file_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            return {}
+
+    @classmethod
+    def load_environment(cls, root: Path) -> dict:
+        """Carga el archivo de configuración de entorno del proyecto."""
+        return cls.load_json_file(root / WORKSPACE_DIR_NAME / "config" / "environment.json")
+
+    @classmethod
+    def load_session(cls, root: Path) -> dict:
+        """Carga la sesión de desarrollo temporal activa del proyecto."""
+        return cls.load_json_file(root / WORKSPACE_DIR_NAME / "state" / "session.json")

higpertext/kernel/infrastructure/cli/__init__.py

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

higpertext/kernel/infrastructure/cli/agent_commands.py

@@ -0,0 +1,62 @@
+"""Handlers CLI para gestión de agentes registrados."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def dispatch_agent(nexus, args: argparse.Namespace, logger, root_dir: Path) -> None:
+    action = getattr(args, "agent_action", None)
+    target = getattr(args, "target", None)
+    handlers = {
+        "init": lambda: nexus.agent_init(args.profile, target),
+        "status": lambda: nexus.agent_status(target),
+        "clean": lambda: nexus.agent_clean(target),
+        "register": lambda: dispatch_agent_register(args, logger, root_dir),
+        "sync": lambda: dispatch_agent_sync(args, logger, root_dir),
+        "list": lambda: dispatch_agent_list(logger, root_dir),
+    }
+    handler = handlers.get(action)
+    if handler is None:
+        logger.info("Uso: htx agent [init|status|clean|register|sync|list]")
+        return
+    handler()
+
+
+def dispatch_agent_register(args: argparse.Namespace, logger, root_dir: Path) -> None:
+    from higpertext.kernel.infrastructure import JsonAgentRegistry
+    from higpertext.kernel.application import RegisterAgentUseCase
+
+    try:
+        repo = JsonAgentRegistry(root_dir)
+        rec = RegisterAgentUseCase(repo).execute(args.name, args.path, args.profile)
+        logger.ok(f"[SUCCESS] Agente '{rec.name}' registrado (perfil: {rec.profile})")
+    except ValueError as e:
+        logger.error(f"[ERROR] {e}")
+
+
+def dispatch_agent_sync(args: argparse.Namespace, logger, root_dir: Path) -> None:
+    from higpertext.kernel.infrastructure import JsonAgentRegistry
+    from higpertext.kernel.application import SyncAgentUseCase
+
+    repo = JsonAgentRegistry(root_dir)
+    results = SyncAgentUseCase(repo, root_dir).execute(
+        getattr(args, "name", None), getattr(args, "assistant", "claude")
+    )
+    for result in results:
+        logger.ok(f"  {'✓' if result.success else '✗'} {result.name}: {result.message}")
+    if not results:
+        logger.info("[INFO] No hay agentes registrados para sincronizar.")
+
+
+def dispatch_agent_list(logger, root_dir: Path) -> None:
+    from higpertext.kernel.infrastructure import JsonAgentRegistry
+    from higpertext.kernel.application import ListAgentsUseCase
+
+    agents = ListAgentsUseCase(JsonAgentRegistry(root_dir)).execute()
+    if not agents:
+        logger.info("[INFO] No hay agentes registrados.")
+        return
+    for agent in agents:
+        logger.info(f"  • {agent.name:20s}  perfil: {agent.profile:20s}  {agent.path}")

higpertext/kernel/infrastructure/cli/arguments.py

@@ -0,0 +1,39 @@
+"""Helpers de parsing para la capa CLI."""
+
+from __future__ import annotations
+
+
+def parse_kv_args(raw_args: list[str]) -> dict:
+    """Parsea una lista ['--key', 'val', ...] en un dict."""
+    params: dict = {}
+    it = iter(raw_args)
+    for item in it:
+        if item.startswith("--"):
+            key = item.lstrip("--")
+            try:
+                params[key] = next(it)
+            except StopIteration:
+                params[key] = True
+    return params
+
+
+def pop_bool_flag(task_args: list[str], flag: str, default: bool) -> tuple[bool, list[str]]:
+    """Extrae un flag booleano opcional de argumentos remanentes."""
+    if flag not in task_args:
+        return default, task_args
+
+    idx = task_args.index(flag)
+    task_args.pop(idx)
+    value = True
+    if idx < len(task_args) and task_args[idx].lower() in (
+        "true",
+        "1",
+        "yes",
+        "false",
+        "0",
+        "no",
+    ):
+        value = task_args[idx].lower() in ("true", "1", "yes")
+        task_args.pop(idx)
+
+    return value, task_args