higpertext-cli 0.8.0__py3-none-any.whl

higpertext/capabilities/common/llm-invoke.json

@@ -0,0 +1,59 @@
+{
+    "id": "common.llm-invoke",
+    "version": "1.0.0",
+    "description": "Invoca un modelo LLM por API (Anthropic, OpenAI, Gemini, Ollama). Soporta completion y streaming.",
+    "entrypoint": "capabilities/common/scripts/llm_invoke.py",
+    "language": "python",
+    "parameters": [
+        {
+            "name": "prompt",
+            "description": "Prompt principal a enviar al modelo.",
+            "required": true
+        },
+        {
+            "name": "provider",
+            "description": "Provider a usar: anthropic | openai | gemini | ollama. Default: según environment.json o HIGPERTEXT_LLM_PROVIDER.",
+            "required": false
+        },
+        {
+            "name": "model",
+            "description": "ID del modelo. Default: según environment.json del provider.",
+            "required": false
+        },
+        {
+            "name": "system",
+            "description": "System prompt opcional.",
+            "required": false
+        },
+        {
+            "name": "max_tokens",
+            "description": "Tokens máximos de respuesta. Default: 1024.",
+            "required": false
+        },
+        {
+            "name": "temperature",
+            "description": "Temperatura de sampling (0.0-1.0). Default: 0.7.",
+            "required": false
+        },
+        {
+            "name": "stream",
+            "description": "Activar streaming (true/false). Default: false.",
+            "required": false
+        },
+        {
+            "name": "output_file",
+            "description": "Ruta de archivo donde guardar el resultado. Opcional.",
+            "required": false
+        }
+    ],
+    "contract": {
+        "rules": [
+            "El prompt no puede estar vacío.",
+            "El provider debe ser uno de: anthropic, openai, gemini, ollama.",
+            "Las API keys deben estar en variables de entorno, nunca en parámetros.",
+            "El output incluye el contenido generado y métricas de tokens."
+        ],
+        "output_format": "Markdown con header de metadatos y cuerpo de respuesta."
+    },
+    "example": "htx task common.llm-invoke --prompt \"Escribe un resumen de DDD\" --provider anthropic --max_tokens 512"
+}

higpertext/capabilities/common/load-rules.json

@@ -0,0 +1,37 @@
+{
+    "id": "common.load-rules",
+    "version": "1.0.0",
+    "name": "Load Rules",
+    "description": "Carga las reglas detalladas de capacidades seleccionadas al contexto del LLM activo. Escribe un archivo de reglas en la ruta correspondiente al asistente (.claude/rules/, .opencode/rules/, etc.) para que sea cargado automáticamente en el siguiente turno.",
+    "entrypoint": "capabilities/common/scripts/load_rules.py",
+    "language": "python",
+    "parameters": [
+        {
+            "name": "rules",
+            "description": "IDs de capacidades a cargar, separados por coma. Acepta short ID (grep-search) o full ID (common.grep-search). Usa 'all' para cargar todas las del perfil activo.",
+            "required": true
+        },
+        {
+            "name": "workflows",
+            "description": "IDs de workflows a cargar, separados por coma. Acepta short ID (higpertext-build) o full ID (workflow.higpertext-build). Usa 'all' para cargar todos los compilados.",
+            "required": false
+        },
+        {
+            "name": "clear",
+            "description": "Si es 'true', elimina el archivo session-capabilities.md (o el bloque equivalente) sin generar nuevo contenido.",
+            "required": false,
+            "default": "false"
+        }
+    ],
+    "hook_task_id": "hook_load_rules",
+    "contract": {
+        "rules": [
+            "Debe leer el asistente activo desde .higpertext/environment.json para determinar la ruta de destino.",
+            "Debe leer el perfil activo para validar que los IDs solicitados existen en el perfil.",
+            "Para claude y opencode: debe escribir .claude/rules/session-capabilities.md o equivalente.",
+            "Para gemini, copilot y antigravity: debe reemplazar el bloque session-capabilities en el archivo principal si existe, o appenderlo si no.",
+            "Si un ID no existe en el perfil, debe fallar con mensaje descriptivo antes de escribir.",
+            "Debe reportar cuántas capacidades se cargaron y en qué archivo."
+        ]
+    }
+}

higpertext/capabilities/common/memory-manager.json

@@ -0,0 +1,65 @@
+{
+    "id": "common.memory-manager",
+    "version": "1.0.0",
+    "name": "Gestor de Memoria de Acciones",
+    "description": "Persiste aprendizajes y estados después de cada acción del agente.",
+    "entrypoint": "capabilities/common/scripts/memory_manager.py",
+    "language": "python",
+    "contract": {
+        "format": "JSON/Markdown Persistence",
+        "rules": [
+            "Cada entrada debe incluir un 'action_id' único.",
+            "El campo 'learned' debe ser una lista de aprendizajes clave.",
+            "Si la acción falló, incluir 'failure_root_cause'.",
+            "La memoria se guarda en la carpeta .memory/ del proyecto activo."
+        ]
+    },
+    "parameters": [
+        {
+            "name": "action",
+            "type": "string",
+            "required": true,
+            "description": "Nombre de la acción realizada."
+        },
+        {
+            "name": "status",
+            "type": "string",
+            "enum": [
+                "success",
+                "failure"
+            ],
+            "required": true,
+            "description": "Estado final de la acción."
+        },
+        {
+            "name": "notes",
+            "type": "string",
+            "required": true,
+            "description": "Aprendizajes o notas técnicas de la acción."
+        },
+        {
+            "name": "action_id",
+            "type": "string",
+            "required": false,
+            "description": "ID único de la acción (si no se proporciona se autogenera)."
+        },
+        {
+            "name": "learned",
+            "type": "string",
+            "required": false,
+            "description": "Aprendizajes clave obtenidos (separados por comas)."
+        },
+        {
+            "name": "failure_root_cause",
+            "type": "string",
+            "required": false,
+            "description": "Causa raíz de la falla si el estado es 'failure'."
+        },
+        {
+            "name": "tags",
+            "type": "string",
+            "required": false,
+            "description": "Tags asociados a la acción (separados por comas)."
+        }
+    ]
+}

higpertext/capabilities/common/quality-scan.json

@@ -0,0 +1,21 @@
+{
+  "id": "common.quality-scan",
+  "version": "1.0.0",
+  "name": "Quality Scan",
+  "description": "Genera .higpertext/reports/code_quality_report.md analizando archivos Python con quality gates básicos.",
+  "entrypoint": "capabilities/common/scripts/quality_scan.py",
+  "language": "python",
+  "parameters": [
+    {"name": "target", "description": "Directorio o archivo Python objetivo.", "required": false, "default": "src"},
+    {"name": "output", "description": "Ruta del reporte Markdown generado.", "required": false, "default": ".higpertext/reports/code_quality_report.md"},
+    {"name": "max_function_lines", "description": "Máximo de líneas por función.", "required": false, "default": "30"},
+    {"name": "max_class_lines", "description": "Máximo de líneas por clase.", "required": false, "default": "200"}
+  ],
+  "contract": {
+    "rules": [
+      "Debe generar un reporte Markdown en .higpertext/reports/code_quality_report.md por defecto.",
+      "Debe listar archivos analizados con puntuación /100.",
+      "Debe incluir la sección 'Penalizaciones aplicadas' compatible con common.quality-resolver."
+    ]
+  }
+}

higpertext/capabilities/common/quality-updater.json

@@ -0,0 +1,35 @@
+{
+    "id": "common.quality-updater",
+    "version": "1.0.0",
+    "description": "Actualiza el archivo del plan de remediación progresiva (.higpertext/reportes/remediation_todo.md) marcando las tareas corregidas como [x] y añadiendo nuevas violaciones detectadas.",
+    "entrypoint": "capabilities/common/scripts/quality_resolver.py",
+    "language": "python",
+    "parameters": [
+        {
+            "name": "report",
+            "description": "Nombre o ruta del reporte de calidad en .higpertext/reportes/.",
+            "required": false,
+            "default": "code_quality_report.md"
+        },
+        {
+            "name": "todo_file",
+            "description": "Nombre o ruta del archivo TODO checklist a actualizar.",
+            "required": false,
+            "default": "remediation_todo.md"
+        },
+        {
+            "name": "mode",
+            "description": "Modo de actualización: 'update' para actualizar progresivamente, 'create' para sobreescribir.",
+            "required": false,
+            "default": "update"
+        }
+    ],
+    "contract": {
+        "rules": [
+            "Debe leer el checklist de remediación anterior si existe.",
+            "Debe comparar las violaciones actuales con las anteriores.",
+            "Debe marcar como completadas [x] las violaciones resueltas.",
+            "Debe añadir como pendientes [ ] las nuevas violaciones detectadas."
+        ]
+    }
+}

higpertext/capabilities/common/rag-index.json

@@ -0,0 +1,17 @@
+{
+  "id": "common.rag-index",
+  "version": "1.0.0",
+  "name": "RAG Indexer",
+  "description": "Indexa el código fuente y documentación del proyecto para habilitar la búsqueda semántica.",
+  "entrypoint": "capabilities/common/scripts/rag_index.py",
+  "language": "python",
+  "parameters": [
+    {"name": "root", "description": "Ruta al directorio raíz del proyecto.", "required": false, "default": "."}
+  ],
+  "contract": {
+    "rules": [
+      "Debe generar fragmentos semánticos usando AST.",
+      "Debe generar embeddings y guardarlos en .higpertext/state/vector_store.json."
+    ]
+  }
+}

higpertext/capabilities/common/report-viewer.json

@@ -0,0 +1,24 @@
+{
+    "id": "common.report-viewer",
+    "version": "1.0.0",
+    "name": "Visualizador de Reportes Premium",
+    "description": "Compila la telemetría, el diario de decisiones de diseño y el análisis de desviación en un dashboard HTML autoportante interactivo.",
+    "entrypoint": "capabilities/common/scripts/report_viewer.py",
+    "language": "python",
+    "parameters": [
+        {
+            "name": "output",
+            "type": "string",
+            "required": false,
+            "default": ".higpertext/reports/index.html",
+            "description": "Ruta de destino del dashboard HTML resultante."
+        }
+    ],
+    "contract": {
+        "rules": [
+            "Debe consolidar todos los reportes Markdown generados por higpertext en una sola estructura unificada.",
+            "Usa el motor common.html-presentation para compilar el HTML final.",
+            "Debe copiar los assets necesarios (JS/CSS) de manera portable al directorio del reporte."
+        ]
+    }
+}

higpertext/capabilities/common/roadmap-report.json

@@ -0,0 +1,37 @@
+{
+    "id": "common.roadmap-report",
+    "version": "1.0.0",
+    "name": "Roadmap Report",
+    "description": "Genera un reporte explicativo del roadmap activo: progreso por fase, skills y subagents usados, y timeline HTML visual. Se puede invocar al completar cada fase via /plan.",
+    "entrypoint": "capabilities/common/scripts/roadmap_report.py",
+    "language": "python",
+    "parameters": [
+        {
+            "name": "roadmap",
+            "description": "Path al archivo roadmap JSON. Default: .higpertext/roadmap.json.",
+            "required": false,
+            "default": ".higpertext/roadmap.json"
+        },
+        {
+            "name": "format",
+            "description": "Formato de salida: markdown o html. Default: markdown.",
+            "required": false,
+            "default": "markdown"
+        },
+        {
+            "name": "output",
+            "description": "Ruta de salida del reporte. Default: .higpertext/reports/roadmap/<roadmap-id>_report.<ext>.",
+            "required": false
+        }
+    ],
+    "contract": {
+        "rules": [
+            "Debe leer .higpertext/roadmap.json o el path indicado.",
+            "Debe mostrar resumen ejecutivo en lenguaje natural con % de completitud.",
+            "Debe mostrar todas las fases con su status (done/active/pending) e iconos visuales.",
+            "Debe listar skills y subagents por fase y totales.",
+            "Debe generar HTML con barra de progreso y timeline coloreado por status.",
+            "Debe completar con [SUCCESS] o [ERROR] explícito."
+        ]
+    }
+}

higpertext/capabilities/common/scripts/_env_cli.py

@@ -0,0 +1,65 @@
+"""Helpers compartidos para capabilities env-* locales."""
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+
+import json
+from pathlib import Path
+
+from higpertext.kernel.application import EnvironmentService
+from higpertext.kernel.domain import RunState
+
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+
+def project_root() -> Path:
+    """Resuelve raíz local del proyecto."""
+    current = Path.cwd().resolve()
+    for candidate in (current, *current.parents):
+        if (candidate / "src/config/htx_config.json").exists() or (candidate / "pyproject.toml").exists():
+            return candidate
+    _fallback = Path("/home/aomerge/Documentos/Proyects/agents/LLM-agent")
+    if (_fallback / "src/config/htx_config.json").exists():
+        return _fallback
+    return current
+
+
+def service() -> EnvironmentService:
+    return EnvironmentService(project_root())
+
+
+def parse_bool(value: str) -> bool:
+    return value.lower() in {"true", "1", "yes", "y"}
+
+
+def parse_env(value: str) -> dict[str, str]:
+    env: dict[str, str] = {}
+    for item in [part.strip() for part in value.split(",") if part.strip()]:
+        if "=" in item:
+            key, val = item.split("=", 1)
+            env[key.strip()] = val.strip()
+    return env
+
+
+def state_payload(state: RunState) -> dict:
+    return state.to_dict()
+
+
+def print_json(payload: object) -> None:
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+def print_state(state: RunState) -> None:
+    _log.info("╔─ HIGPERTEXT · Env Runtime ─────────────────────────────────")
+    _log.info(f"│ Run ID   : {state.run_id}")
+    _log.info(f"│ Template : {state.template_id}")
+    _log.info(f"│ Engine   : {state.engine}")
+    _log.info(f"│ Status   : {state.status}")
+    _log.info(f"│ Service  : {state.service}")
+    _log.info(f"│ Command  : {state.command or '—'}")
+    _log.info(f"│ Exit code: {state.exit_code if state.exit_code is not None else '—'}")
+    if state.summary:
+        _log.info("╠─ Summary ─────────────────────────────────────────────────")
+        _log.info(state.summary)
+    _log.info("╚────────────────────────────────────────────────────────────")

higpertext/capabilities/common/scripts/agent_builder.py

@@ -0,0 +1,60 @@
+"""common.agent-builder — crea un agente higpertext independiente."""
+
+from higpertext.kernel.htx_resolver import get_htx_cmd
+import sys as _sys
+import argparse
+import json
+# Ejecuta htx con argumentos controlados y shell=False.
+import subprocess  # nosec B404
+import sys
+from pathlib import Path
+
+ROOT_DIR = Path(__file__).resolve().parents[4]
+
+if str(ROOT_DIR / "src") not in _sys.path:
+    _sys.path.insert(0, str(ROOT_DIR / "src"))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Crea un agente higpertext independiente")
+    parser.add_argument("--profile", required=True)
+    parser.add_argument("--target", required=True)
+    parser.add_argument("--description", default="")
+    args = parser.parse_args()
+
+    result = subprocess.run(  # nosec B603
+        _find_htx() + ["agent", "init", "--profile", args.profile, "--target", args.target],
+        cwd=str(ROOT_DIR),
+        capture_output=False,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        sys.exit(result.returncode)
+
+    if args.description:
+        _inject_description(args.target, args.profile, args.description)
+
+
+def _find_htx() -> list[str]:
+    """Localiza el binario htx via htx_resolver."""
+    return get_htx_cmd(ROOT_DIR)
+
+
+def _inject_description(target: str, profile: str, description: str) -> None:
+    profile_path = Path(target) / "src" / "config" / "profiles" / f"{profile}.json"
+    if not profile_path.exists():
+        return
+    try:
+        data = json.loads(profile_path.read_text(encoding="utf-8"))
+        if not data.get("description"):
+            data["description"] = description
+            profile_path.write_text(
+                json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+    except (OSError, json.JSONDecodeError):  # nosec B110
+        pass
+
+
+if __name__ == "__main__":
+    main()

higpertext/capabilities/common/scripts/agent_sync.py

@@ -0,0 +1,56 @@
+"""Entrypoint capability common.agent-sync — registro y sync de agentes externos."""
+
+from __future__ import annotations
+from higpertext.kernel.application.agent_registry import SyncAgentUseCase, ListAgentsUseCase, RegisterAgentUseCase
+from higpertext.kernel.infrastructure.agent_registry import JsonAgentRegistry
+import argparse
+import sys
+from pathlib import Path
+
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+ROOT_DIR = Path(__file__).parents[4]
+sys.path.insert(0, str(ROOT_DIR / "src" / "core"))
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(description="common.agent-sync")
+    p.add_argument("--action", required=True, choices=["register", "sync", "list"])
+    p.add_argument("--name")
+    p.add_argument("--path")
+    p.add_argument("--profile")
+    p.add_argument("--assistant", default="claude")
+    return p
+
+
+def main() -> None:
+    args = _build_parser().parse_args()
+    repo = JsonAgentRegistry(ROOT_DIR)
+
+    if args.action == "register":
+        if not args.name or not args.path or not args.profile:
+            _log.error("[ERROR] --name, --path y --profile son obligatorios para register")
+            sys.exit(1)
+        rec = RegisterAgentUseCase(repo).execute(args.name, args.path, args.profile)
+        _log.ok(f"[SUCCESS] Agente '{rec.name}' registrado (perfil: {rec.profile})")
+
+    elif args.action == "list":
+        agents = ListAgentsUseCase(repo).execute()
+        if not agents:
+            _log.info("[INFO] No hay agentes registrados.")
+            return
+        for a in agents:
+            _log.info(f"  • {a.name:20s} {a.profile:20s} {a.path}")
+
+    elif args.action == "sync":
+        results = SyncAgentUseCase(repo, ROOT_DIR).execute(args.name, args.assistant)
+        for r in results:
+            status = "✓" if r.success else "✗"
+            _log.info(f"  {status} {r.name}: {r.message}")
+        if not results:
+            _log.info("[INFO] No hay agentes que sincronizar.")
+
+
+if __name__ == "__main__":
+    main()

higpertext/capabilities/common/scripts/ask_higpertext.py

@@ -0,0 +1,38 @@
+"""higpertext Knowledge Bridge — delega consultas al hub de conocimiento via htx."""
+
+from higpertext.kernel.htx_resolver import get_htx_cmd
+import argparse
+import subprocess  # nosec B404
+import sys
+from pathlib import Path
+
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+_ROOT = Path(__file__).resolve().parents[4]
+if str(_ROOT / "src") not in sys.path:
+    sys.path.insert(0, str(_ROOT / "src"))
+
+
+def _get_htx() -> list[str]:
+    return get_htx_cmd(_ROOT)
+
+
+def main() -> None:
+    """Consulta el hub de conocimiento de higpertext con la query indicada."""
+    parser = argparse.ArgumentParser(description="higpertext Knowledge Bridge")
+    parser.add_argument("--query", required=True, help="Question to ask")
+    args = parser.parse_args()
+
+    cmd = _get_htx() + ["ask", args.query]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)  # nosec B603
+
+    if result.returncode == 0:
+        _log.info(result.stdout)
+    else:
+        _log.error(f"Error consultando el Hub de conocimiento: {result.stderr}")
+
+
+if __name__ == "__main__":
+    main()