higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/infrastructure/hook_workflow_bridge.py

@@ -0,0 +1,60 @@
+"""WorkflowHookBridge — traduce workflow_hooks de hooks_config.json a hooks ejecutables."""
+
+from __future__ import annotations
+from pathlib import Path
+from dataclasses import dataclass
+
+from higpertext.kernel.infrastructure.hook_config_loader import load_hooks_config
+
+
+@dataclass
+class WorkflowHookEntry:
+    id: str
+    workflow_id: str
+    event: str
+    matcher: str
+    description: str
+    enabled: bool
+    assistants: list[str]
+    profiles: list[str]
+
+
+class WorkflowHookBridge:
+    def __init__(self, project_root: Path) -> None:
+        self.project_root = project_root
+
+    def get_active_workflow_hooks(self, assistant: str, profile: str) -> list[WorkflowHookEntry]:
+        config = self._load()
+        result: list[WorkflowHookEntry] = []
+        for raw in config.get("workflow_hooks", []):
+            if not raw.get("enabled", False):
+                continue
+            allowed_a = raw.get("assistants", [])
+            if allowed_a and assistant not in allowed_a:
+                continue
+            allowed_p = raw.get("profiles", [])
+            if allowed_p and profile not in allowed_p:
+                continue
+            result.append(
+                WorkflowHookEntry(
+                    id=raw["id"],
+                    workflow_id=raw["workflow_id"],
+                    event=raw["event"],
+                    matcher=raw.get("matcher", ""),
+                    description=raw.get("description", ""),
+                    enabled=raw.get("enabled", False),
+                    assistants=raw.get("assistants", []),
+                    profiles=raw.get("profiles", []),
+                )
+            )
+        return result
+
+    def to_hook_script_args(self, entry: WorkflowHookEntry) -> str:
+        """Genera el comando de shell que ejecuta el workflow desde el hook."""
+        return (
+            f"python3 src/higpertext/hooks/hook_tasks/workflow_runner_hook.py "
+            f"--workflow {entry.workflow_id}"
+        )
+
+    def _load(self) -> dict:
+        return load_hooks_config(self.project_root)

higpertext/kernel/infrastructure/llm/__init__.py

@@ -0,0 +1,6 @@
+"""LLM infrastructure — provider protocol, registry, and implementations."""
+
+from .provider import LLMProvider, LLMResponse
+from .registry import LLMRegistry
+
+__all__ = ["LLMProvider", "LLMResponse", "LLMRegistry"]

higpertext/kernel/infrastructure/llm/provider.py

@@ -0,0 +1,46 @@
+"""LLMProvider Protocol — contrato que todo provider debe implementar."""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Iterator, Protocol, runtime_checkable
+
+
+@dataclass
+class LLMResponse:
+    content: str
+    model: str
+    provider: str
+    input_tokens: int = 0
+    output_tokens: int = 0
+    metadata: dict = field(default_factory=dict)
+
+
+@runtime_checkable
+class LLMProvider(Protocol):
+    """Contrato de provider LLM. Soporta completion y streaming."""
+
+    provider_name: str
+
+    def complete(
+        self,
+        prompt: str,
+        *,
+        system: str = "",
+        model: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        **kwargs,
+    ) -> LLMResponse: ...
+
+    def stream(
+        self,
+        prompt: str,
+        *,
+        system: str = "",
+        model: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        **kwargs,
+    ) -> Iterator[str]: ...
+
+    def list_models(self) -> list[str]: ...

higpertext/kernel/infrastructure/llm/providers/anthropic_provider.py

@@ -0,0 +1,94 @@
+"""AnthropicProvider — implementación LLMProvider para Anthropic Claude."""
+
+from __future__ import annotations
+import os
+from typing import Iterator
+
+from higpertext.kernel.infrastructure.llm.provider import LLMProvider, LLMResponse
+
+
+class AnthropicProvider:
+    provider_name = "anthropic"
+
+    def __init__(self, config: dict | None = None) -> None:
+        self._config = config or {}
+        self._default_model = self._config.get("model", "")
+        self._client = None
+
+    def _resolve_model(self, model: str) -> str:
+        resolved_model = model or self._default_model
+        if not resolved_model:
+            raise ValueError("Modelo Anthropic no definido. Indica --model o HIGPERTEXT_LLM_MODEL.")
+        return resolved_model
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                import anthropic
+            except ImportError:
+                raise ImportError("Instala el SDK: pip install anthropic")
+            api_key = os.environ.get("ANTHROPIC_API_KEY") or self._config.get("api_key", "")
+            if not api_key:
+                raise ValueError("ANTHROPIC_API_KEY no está definida en el entorno")
+            self._client = anthropic.Anthropic(api_key=api_key)
+        return self._client
+
+    def complete(
+        self,
+        prompt: str,
+        *,
+        system: str = "",
+        model: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        **kwargs,
+    ) -> LLMResponse:
+        client = self._get_client()
+        resolved_model = self._resolve_model(model)
+        msg = client.messages.create(
+            model=resolved_model,
+            max_tokens=max_tokens,
+            system=system or None,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=temperature,
+        )
+        content = msg.content[0].text if msg.content else ""
+        return LLMResponse(
+            content=content,
+            model=resolved_model,
+            provider=self.provider_name,
+            input_tokens=msg.usage.input_tokens,
+            output_tokens=msg.usage.output_tokens,
+        )
+
+    def stream(
+        self,
+        prompt: str,
+        *,
+        system: str = "",
+        model: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        **kwargs,
+    ) -> Iterator[str]:
+        client = self._get_client()
+        resolved_model = self._resolve_model(model)
+        with client.messages.stream(
+            model=resolved_model,
+            max_tokens=max_tokens,
+            system=system or None,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=temperature,
+        ) as stream:
+            for text in stream.text_stream:
+                yield text
+
+    def list_models(self) -> list[str]:
+        return [
+            "claude-sonnet-4-6",
+            "claude-opus-4-8",
+            "claude-haiku-4-5-20251001",
+        ]
+
+
+assert isinstance(AnthropicProvider(), LLMProvider)

higpertext/kernel/infrastructure/llm/providers/gemini_embeddings.py

@@ -0,0 +1,74 @@
+"""Gemini Embedding Provider implementation using native urllib requests."""
+
+from __future__ import annotations
+import json
+import urllib.request
+import urllib.error
+from pathlib import Path
+from higpertext.kernel.domain.rag import IEmbeddingProvider
+
+
+class GeminiEmbeddingProvider(IEmbeddingProvider):
+    """Generates text embeddings using Google's Gemini API."""
+
+    def __init__(self, project_root: Path) -> None:
+        self.project_root = project_root
+        self._api_key = self._load_api_key()
+
+    def _load_api_key(self) -> str:
+        # Intentar cargar desde el entorno
+        import os
+        key = os.environ.get("GEMINI_API_KEY")
+        if key:
+            return key
+
+        # Intentar leer del environment.json
+        env_file = self.project_root / ".higpertext" / "config" / "environment.json"
+        if env_file.exists():
+            try:
+                data = json.loads(env_file.read_text(encoding="utf-8"))
+                return data.get("GEMINI_API_KEY", "")
+            except (OSError, json.JSONDecodeError):
+                pass
+        return ""
+
+    def get_embedding(self, text: str) -> list[float]:
+        if not self._api_key:
+            raise ValueError("[ERROR] No se configuró la variable GEMINI_API_KEY para RAG.")
+
+        url = f"https://generativelanguage.googleapis.com/v1beta/models/text-embedding-004:embedContent?key={self._api_key}"
+        payload = {
+            "model": "models/text-embedding-004",
+            "content": {
+                "parts": [{"text": text}]
+            }
+        }
+        
+        req = urllib.request.Request(
+            url,
+            data=json.dumps(payload).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST"
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=10) as response:
+                res_data = json.loads(response.read().decode("utf-8"))
+                return res_data["embedding"]["values"]
+        except urllib.error.HTTPError as e:
+            err_body = e.read().decode("utf-8")
+            raise RuntimeError(f"[ERROR] API de Embeddings devolvió HTTP {e.code}: {err_body}")
+        except Exception as e:
+            raise RuntimeError(f"[ERROR] Falló conexión a la API de Embeddings: {e}")
+
+    def get_embeddings_batch(self, texts: list[str]) -> list[list[float]]:
+        # La API de Gemini permite procesar listas si se llama adecuadamente o secuencial.
+        # Por seguridad y límites de API, lo implementamos secuencial pero mapeado.
+        embeddings: list[list[float]] = []
+        for text in texts:
+            if not text.strip():
+                # Embedding vacío por defecto
+                embeddings.append([0.0] * 768)
+            else:
+                embeddings.append(self.get_embedding(text))
+        return embeddings

higpertext/kernel/infrastructure/llm/providers/gemini_provider.py

@@ -0,0 +1,101 @@
+"""GeminiProvider — implementación LLMProvider para Google Gemini."""
+
+from __future__ import annotations
+import os
+from typing import Iterator
+
+from higpertext.kernel.infrastructure.llm.provider import LLMProvider, LLMResponse
+
+
+class GeminiProvider:
+    provider_name = "gemini"
+
+    def __init__(self, config: dict | None = None) -> None:
+        self._config = config or {}
+        self._default_model = self._config.get("model", "")
+        self._client = None
+
+    def _resolve_model(self, model: str) -> str:
+        resolved_model = model or self._default_model
+        if not resolved_model:
+            raise ValueError("Modelo Gemini no definido. Indica --model o HIGPERTEXT_LLM_MODEL.")
+        return resolved_model
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                from google import genai
+            except ImportError:
+                raise ImportError("Instala el SDK: pip install google-genai")
+            api_key = os.environ.get("GEMINI_API_KEY") or self._config.get("api_key", "")
+            if not api_key:
+                raise ValueError("GEMINI_API_KEY no está definida en el entorno")
+            self._client = genai.Client(api_key=api_key)
+        return self._client
+
+    def complete(
+        self,
+        prompt: str,
+        *,
+        system: str = "",
+        model: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        **kwargs,
+    ) -> LLMResponse:
+        from google.genai import types
+
+        client = self._get_client()
+        resolved_model = self._resolve_model(model)
+        config = types.GenerateContentConfig(
+            max_output_tokens=max_tokens,
+            temperature=temperature,
+            system_instruction=system or None,
+        )
+        resp = client.models.generate_content(
+            model=resolved_model,
+            contents=prompt,
+            config=config,
+        )
+        content = resp.text or ""
+        usage = resp.usage_metadata
+        return LLMResponse(
+            content=content,
+            model=resolved_model,
+            provider=self.provider_name,
+            input_tokens=usage.prompt_token_count if usage else 0,
+            output_tokens=usage.candidates_token_count if usage else 0,
+        )
+
+    def stream(
+        self,
+        prompt: str,
+        *,
+        system: str = "",
+        model: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        **kwargs,
+    ) -> Iterator[str]:
+        from google.genai import types
+
+        client = self._get_client()
+        resolved_model = self._resolve_model(model)
+        config = types.GenerateContentConfig(
+            max_output_tokens=max_tokens,
+            temperature=temperature,
+            system_instruction=system or None,
+        )
+        for chunk in client.models.generate_content_stream(
+            model=resolved_model,
+            contents=prompt,
+            config=config,
+        ):
+            if chunk.text:
+                yield chunk.text
+
+    def list_models(self) -> list[str]:
+        return ["gemini-2.0-flash", "gemini-1.5-pro", "gemini-1.5-flash"]
+
+
+assert isinstance(GeminiProvider(), LLMProvider)

higpertext/kernel/infrastructure/llm/providers/ollama_provider.py

@@ -0,0 +1,110 @@
+"""OllamaProvider — implementación LLMProvider para Ollama (Llama local)."""
+
+from __future__ import annotations
+import json
+import urllib.request
+import urllib.error
+from typing import Iterator
+
+from higpertext.kernel.infrastructure.llm.provider import LLMProvider, LLMResponse
+from higpertext.kernel.app_config import OLLAMA_BASE_URL as _DEFAULT_BASE_URL
+
+
+class OllamaProvider:
+    provider_name = "ollama"
+
+    def __init__(self, config: dict | None = None) -> None:
+        self._config = config or {}
+        self._default_model = self._config.get("model", "")
+        self._base_url = self._config.get("base_url", _DEFAULT_BASE_URL).rstrip("/")
+
+    def _resolve_model(self, model: str) -> str:
+        resolved_model = model or self._default_model
+        if not resolved_model:
+            raise ValueError("Modelo Ollama no definido. Indica --model o HIGPERTEXT_LLM_MODEL.")
+        return resolved_model
+
+    def _post(self, endpoint: str, payload: dict) -> urllib.request.http.client.HTTPResponse:
+        url = f"{self._base_url}{endpoint}"
+        data = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        return urllib.request.urlopen(req, timeout=120)  # nosec B310
+
+    def complete(
+        self,
+        prompt: str,
+        *,
+        system: str = "",
+        model: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        **kwargs,
+    ) -> LLMResponse:
+        resolved_model = self._resolve_model(model)
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
+        payload = {
+            "model": resolved_model,
+            "messages": messages,
+            "stream": False,
+            "options": {"temperature": temperature, "num_predict": max_tokens},
+        }
+        with self._post("/api/chat", payload) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+        content = data.get("message", {}).get("content", "")
+        return LLMResponse(
+            content=content,
+            model=resolved_model,
+            provider=self.provider_name,
+            input_tokens=data.get("prompt_eval_count", 0),
+            output_tokens=data.get("eval_count", 0),
+        )
+
+    def stream(
+        self,
+        prompt: str,
+        *,
+        system: str = "",
+        model: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        **kwargs,
+    ) -> Iterator[str]:
+        resolved_model = self._resolve_model(model)
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
+        payload = {
+            "model": resolved_model,
+            "messages": messages,
+            "stream": True,
+            "options": {"temperature": temperature, "num_predict": max_tokens},
+        }
+        with self._post("/api/chat", payload) as resp:
+            for line in resp:
+                chunk = json.loads(line.decode("utf-8"))
+                text = chunk.get("message", {}).get("content", "")
+                if text:
+                    yield text
+                if chunk.get("done"):
+                    break
+
+    def list_models(self) -> list[str]:
+        try:
+            url = f"{self._base_url}/api/tags"
+            with urllib.request.urlopen(url, timeout=5) as resp:  # nosec B310
+                data = json.loads(resp.read().decode("utf-8"))
+            return [m["name"] for m in data.get("models", [])]
+        except Exception:
+            return []
+
+
+assert isinstance(OllamaProvider(), LLMProvider)

higpertext/kernel/infrastructure/llm/providers/openai_provider.py

@@ -0,0 +1,98 @@
+"""OpenAIProvider — implementación LLMProvider para OpenAI."""
+
+from __future__ import annotations
+import os
+from typing import Iterator
+
+from higpertext.kernel.infrastructure.llm.provider import LLMProvider, LLMResponse
+
+
+class OpenAIProvider:
+    provider_name = "openai"
+
+    def __init__(self, config: dict | None = None) -> None:
+        self._config = config or {}
+        self._default_model = self._config.get("model", "")
+        self._client = None
+
+    def _resolve_model(self, model: str) -> str:
+        resolved_model = model or self._default_model
+        if not resolved_model:
+            raise ValueError("Modelo OpenAI no definido. Indica --model o HIGPERTEXT_LLM_MODEL.")
+        return resolved_model
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                import openai
+            except ImportError:
+                raise ImportError("Instala el SDK: pip install openai")
+            api_key = os.environ.get("OPENAI_API_KEY") or self._config.get("api_key", "")
+            if not api_key:
+                raise ValueError("OPENAI_API_KEY no está definida en el entorno")
+            self._client = openai.OpenAI(api_key=api_key)
+        return self._client
+
+    def complete(
+        self,
+        prompt: str,
+        *,
+        system: str = "",
+        model: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        **kwargs,
+    ) -> LLMResponse:
+        client = self._get_client()
+        resolved_model = self._resolve_model(model)
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
+        resp = client.chat.completions.create(
+            model=resolved_model,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+        content = resp.choices[0].message.content or ""
+        return LLMResponse(
+            content=content,
+            model=resolved_model,
+            provider=self.provider_name,
+            input_tokens=resp.usage.prompt_tokens if resp.usage else 0,
+            output_tokens=resp.usage.completion_tokens if resp.usage else 0,
+        )
+
+    def stream(
+        self,
+        prompt: str,
+        *,
+        system: str = "",
+        model: str = "",
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        **kwargs,
+    ) -> Iterator[str]:
+        client = self._get_client()
+        resolved_model = self._resolve_model(model)
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
+        for chunk in client.chat.completions.create(
+            model=resolved_model,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            stream=True,
+        ):
+            delta = chunk.choices[0].delta.content
+            if delta:
+                yield delta
+
+    def list_models(self) -> list[str]:
+        return ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-3.5-turbo"]
+
+
+assert isinstance(OpenAIProvider(), LLMProvider)

higpertext/kernel/infrastructure/llm/registry.py

@@ -0,0 +1,81 @@
+"""LLMRegistry — resuelve e instancia el provider correcto por nombre."""
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+import json
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .provider import LLMProvider
+
+
+_PROVIDER_MODULES: dict[str, tuple[str, str]] = {
+    "anthropic": (
+        "kernel.infrastructure.llm.providers.anthropic_provider",
+        "AnthropicProvider",
+    ),
+    "openai": ("kernel.infrastructure.llm.providers.openai_provider", "OpenAIProvider"),
+    "gemini": ("kernel.infrastructure.llm.providers.gemini_provider", "GeminiProvider"),
+    "ollama": ("kernel.infrastructure.llm.providers.ollama_provider", "OllamaProvider"),
+}
+
+
+class LLMRegistry:
+    """Resuelve el provider LLM desde environment.json o variable de entorno."""
+
+    def __init__(self, project_root: Path | None = None) -> None:
+        self._root = project_root or Path.cwd()
+        self._cache: dict[str, "LLMProvider"] = {}
+
+    def _load_env_config(self) -> dict:
+        env_path = self._root / WORKSPACE_DIR_NAME / "config" / "environment.json"
+        try:
+            return json.loads(env_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            return {}
+
+    def default_provider(self) -> str:
+        env_var = os.environ.get("HIGPERTEXT_LLM_PROVIDER")
+        if env_var:
+            return env_var.lower()
+        cfg = self._load_env_config()
+        return cfg.get("llm", {}).get("default_provider", "")
+
+    def default_model(self, provider: str) -> str:
+        env_var = os.environ.get("HIGPERTEXT_LLM_MODEL")
+        if env_var:
+            return env_var
+        cfg = self._load_env_config()
+        provider_cfg = cfg.get("llm", {}).get("providers", {}).get(provider, {})
+        return provider_cfg.get("model", "")
+
+    def provider_config(self, provider: str) -> dict:
+        cfg = self._load_env_config()
+        return cfg.get("llm", {}).get("providers", {}).get(provider, {})
+
+    def resolve(self, provider_name: str | None = None) -> "LLMProvider":
+        name = (provider_name or self.default_provider()).lower()
+        if not name:
+            raise ValueError(
+                "Provider LLM no definido. Usa --provider, HIGPERTEXT_LLM_PROVIDER "
+                "o .higpertext/config/environment.json[llm.default_provider]."
+            )
+        if name in self._cache:
+            return self._cache[name]
+
+        if name not in _PROVIDER_MODULES:
+            raise ValueError(
+                f"Provider '{name}' no soportado. Disponibles: {list(_PROVIDER_MODULES)}"
+            )
+
+        module_path, class_name = _PROVIDER_MODULES[name]
+        import importlib
+
+        module = importlib.import_module(module_path)
+        provider_cls = getattr(module, class_name)
+        config = self.provider_config(name)
+        instance: "LLMProvider" = provider_cls(config=config)
+        self._cache[name] = instance
+        return instance