higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/infrastructure/cli/parser_builder.py

@@ -0,0 +1,122 @@
+"""Constructor de parser para el CLI de higpertext."""
+
+from __future__ import annotations
+
+import argparse
+
+
+def add_task_ask_subparsers(subs: argparse.Action) -> None:
+    task_p = subs.add_parser("task", help="Ejecutar una tarea técnica")
+    task_p.add_argument("name", help="Nombre de la tarea")
+    task_p.add_argument("task_args", nargs=argparse.REMAINDER)
+    task_p.add_argument(
+        "--stream",
+        action="store_true",
+        default=False,
+        help="Activar streaming de output en tiempo real",
+    )
+    task_p.add_argument(
+        "--no-cache",
+        dest="no_cache",
+        action="store_true",
+        default=False,
+        help="Forzar ejecución ignorando el cache",
+    )
+    ask_p = subs.add_parser("ask", help="Consultar base de conocimiento")
+    ask_p.add_argument("query")
+
+
+def add_profile_init_subparsers(subs: argparse.Action, assistants: list[str]) -> None:
+    prof_p = subs.add_parser("profile", help="Gestionar perfiles de agentes")
+    prof_p.add_argument("action", choices=["load", "learn", "validate", "install"])
+    prof_p.add_argument("--source", default=None, help="Path al repo externo del perfil")
+    prof_p.add_argument("name", nargs="?")
+    prof_p.add_argument("--assistant", choices=assistants, default=None)
+
+    prof_p.add_argument("--target")
+    init_p = subs.add_parser("init", help="Inicializar proyecto para asistente")
+    init_p.add_argument("profile", nargs="?")
+    init_p.add_argument("--assistant", choices=assistants + ["agent"], required=True)
+    init_p.add_argument("--target")
+
+
+def add_session_workflow_subparsers(subs: argparse.Action, assistants: list[str]) -> None:
+    sess_p = subs.add_parser("session", help="Gestionar sesiones temporales")
+    sess_p.add_argument("action", choices=["start", "clean"])
+    sess_p.add_argument("--profile")
+    sess_p.add_argument("--assistant", choices=assistants)
+    sess_p.add_argument("--skills")
+    sess_p.add_argument("--subagents")
+    wf_p = subs.add_parser("workflow", help="Ejecutar flujos de trabajo")
+    wf_subs = wf_p.add_subparsers(dest="workflow_action")
+    run_p = wf_subs.add_parser("run")
+    run_p.add_argument("name")
+    run_p.add_argument("wf_args", nargs=argparse.REMAINDER)
+
+
+def add_health_subparser(subs: argparse.Action) -> None:
+    health_p = subs.add_parser("health", help="Verificar integridad del motor (< 2s)")
+    health_p.add_argument(
+        "--verbose",
+        action="store_true",
+        default=False,
+        help="Mostrar advertencias detalladas",
+    )
+    doctor_p = subs.add_parser("doctor", help="Diagnóstico integral del workspace higpertext")
+    doctor_p.add_argument("--json", action="store_true", default=False)
+
+
+def add_agent_subparser(subs: argparse.Action) -> None:
+    agent_p = subs.add_parser("agent", help="Gestionar agentes higpertext sin asistente")
+    agent_subs = agent_p.add_subparsers(dest="agent_action")
+
+    init_p = agent_subs.add_parser("init", help="Inicializar ambiente de agente")
+    init_p.add_argument("--profile", required=True, help="Perfil a activar")
+    init_p.add_argument("--target", default=None, help="Directorio destino (default: cwd)")
+
+    status_p = agent_subs.add_parser("status", help="Estado del ambiente del agente")
+    status_p.add_argument("--target", default=None)
+
+    clean_p = agent_subs.add_parser("clean", help="Limpiar ambiente efímero del agente")
+    clean_p.add_argument("--target", default=None)
+
+    reg_p = agent_subs.add_parser("register", help="Registrar agente externo en el motor")
+    reg_p.add_argument("--name", required=True, help="Nombre del agente")
+    reg_p.add_argument("--path", required=True, help="Ruta absoluta al proyecto del agente")
+    reg_p.add_argument("--profile", required=True, help="Perfil activo del agente")
+
+    sync_p = agent_subs.add_parser("sync", help="Sincronizar hooks y perfil hacia agentes registrados")
+    sync_p.add_argument("--name", default=None, help="Sincronizar solo este agente (default: todos)")
+    sync_p.add_argument("--assistant", default="claude", help="Asistente objetivo")
+
+    agent_subs.add_parser("list", help="Listar agentes externos registrados")
+
+
+def add_roadmap_subparser(subs: argparse.Action) -> None:
+    rm_p = subs.add_parser("roadmap", help="Gestionar roadmaps del proyecto")
+    rm_subs = rm_p.add_subparsers(dest="roadmap_action")
+
+    add_p = rm_subs.add_parser("add", help="Activar un roadmap existente")
+    add_p.add_argument("id", help="ID del roadmap (nombre del archivo sin .json)")
+
+    rm_subs.add_parser("list", help="Listar roadmaps activos e inactivos")
+
+    rm_p2 = rm_subs.add_parser("remove", help="Desactivar un roadmap activo")
+    rm_p2.add_argument("id", help="ID del roadmap a desactivar")
+
+    new_p = rm_subs.add_parser("new", help="Crear un roadmap nuevo")
+    new_p.add_argument("id", help="ID del nuevo roadmap")
+    new_p.add_argument("--project", required=True, help="Nombre del proyecto")
+    new_p.add_argument("--description", default="", help="Descripción del roadmap")
+
+
+def build_parser(assistants: list[str]) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="higpertext Engine Orchestrator")
+    subs = parser.add_subparsers(dest="command")
+    add_task_ask_subparsers(subs)
+    add_profile_init_subparsers(subs, assistants)
+    add_session_workflow_subparsers(subs, assistants)
+    add_health_subparser(subs)
+    add_agent_subparser(subs)
+    add_roadmap_subparser(subs)
+    return parser

higpertext/kernel/infrastructure/cli/profile_commands.py

@@ -0,0 +1,89 @@
+"""Handlers CLI para gestión de perfiles."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def dispatch_profile(nexus, args: argparse.Namespace, logger, root_dir: Path) -> None:
+    action = getattr(args, "action", None)
+    handlers = {
+        "learn": lambda: dispatch_profile_learn(args, root_dir),
+        "validate": lambda: dispatch_profile_validate(nexus, args, logger),
+        "install": lambda: nexus.install_profile(args.name, args.target, getattr(args, "source", None)),
+        "load": lambda: nexus.load_agent_profile(args.name, args.assistant, args.target),
+    }
+    handlers.get(action, handlers["load"])()
+
+
+def dispatch_profile_learn(args: argparse.Namespace, root_dir: Path) -> None:
+    """Extrae patrones, calibra pesos y actualiza learned_profile.json."""
+    from higpertext.kernel.application.profile_learner import (
+        ProfileExtractor,
+        ProfileUpdater,
+        WeightsCalibrator,
+    )
+    from higpertext.kernel.infrastructure.profile_store import ProfileStore
+    from higpertext.kernel.infrastructure.logger import get_logger
+
+    log = get_logger(project_root=root_dir)
+    days = getattr(args, "days", 30)
+    log.info(f"Analizando últimos {days} días de telemetría…")
+
+    extractor = ProfileExtractor(root_dir)
+    fresh, patterns = extractor.extract(days=days)
+
+    pattern_count = len(patterns)
+    calibrator = WeightsCalibrator(root_dir)
+    calibrator.calibrate(patterns)
+
+    if pattern_count >= 20:
+        calibration_mode = "regresión lineal"
+    elif pattern_count >= 10:
+        calibration_mode = "z-score"
+    else:
+        calibration_mode = f"defaults (faltan {10 - pattern_count} sesiones para z-score)"
+
+    store = ProfileStore(root_dir)
+    existing = store.load()
+    updater = ProfileUpdater()
+    merged = updater.merge(existing, fresh)
+    store.save(merged)
+
+    log.event_block(
+        "profile-learn",
+        status="ok",
+        fields={
+            "sessions_analyzed": pattern_count,
+            "calibration_mode": calibration_mode,
+            "adoption_pct": f"{fresh.higpertext_adoption_trend}%",
+            "strong_patterns": ", ".join(fresh.strong_patterns) or None,
+            "weak_patterns": ", ".join(fresh.weak_patterns) or None,
+            "commit_topics": ", ".join(fresh.commit_topics) or None,
+            "output": ".higpertext/state/learned_profile.json",
+        },
+    )
+
+
+def dispatch_profile_validate(nexus, args: argparse.Namespace, logger) -> None:
+    if not args.name:
+        logger.warning("[!] Especifica el nombre del perfil a validar (ej: software_developer).")
+        return
+    success, errors, warnings = nexus.engine.validate_profile(args.name)
+    if success:
+        logger.ok(
+            f"[SUCCESS] El perfil '{args.name}' es válido y cumple con todas las dependencias e integridad."
+        )
+        if warnings:
+            logger.info(f"\n[*] ALERTA: Optimización del perfil '{args.name}':")
+            for warning in warnings:
+                logger.info(f"    - {warning}")
+    else:
+        logger.warning(f"[!] El perfil '{args.name}' contiene errores de validación:")
+        for error in errors:
+            logger.info(f"    - {error}")
+        if warnings:
+            logger.info(f"\n[*] ALERTA: Optimización del perfil '{args.name}':")
+            for warning in warnings:
+                logger.info(f"    - {warning}")

higpertext/kernel/infrastructure/cli/roadmap_commands.py

@@ -0,0 +1,117 @@
+"""Handlers CLI para gestión de roadmaps."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+
+
+def dispatch_roadmap(args: argparse.Namespace, logger, project_root: Path | None = None) -> None:
+    """Gestiona roadmaps en .higpertext/config/roadmaps/."""
+    roadmaps_dir = (project_root or Path.cwd()) / WORKSPACE_DIR_NAME / "config" / "roadmaps"
+    roadmaps_dir.mkdir(parents=True, exist_ok=True)
+    active_index = roadmaps_dir / "active.json"
+
+    store = RoadmapCliStore(roadmaps_dir, active_index)
+    action = getattr(args, "roadmap_action", None)
+
+    if action == "list":
+        _list_roadmaps(store, logger)
+    elif action == "add":
+        _add_roadmap(store, args.id, logger)
+    elif action == "remove":
+        _remove_roadmap(store, args.id, logger)
+    elif action == "new":
+        _new_roadmap(store, args.id, args.project, args.description, logger)
+    else:
+        logger.info("Uso: htx roadmap [list|add|remove|new]")
+
+
+class RoadmapCliStore:
+    """Persistencia mínima para el comando roadmap."""
+
+    def __init__(self, roadmaps_dir: Path, active_index: Path) -> None:
+        self.roadmaps_dir = roadmaps_dir
+        self.active_index = active_index
+
+    def load_active(self) -> list[str]:
+        try:
+            return json.loads(self.active_index.read_text(encoding="utf-8")).get("active", [])
+        except (OSError, json.JSONDecodeError):
+            return []
+
+    def save_active(self, ids: list[str]) -> None:
+        self.active_index.write_text(
+            json.dumps({"active": ids}, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+
+    def roadmap_path(self, roadmap_id: str) -> Path:
+        return self.roadmaps_dir / f"{roadmap_id}.json"
+
+    def roadmap_ids(self) -> list[str]:
+        return sorted(f.stem for f in self.roadmaps_dir.glob("*.json") if f.stem != "active")
+
+
+def _list_roadmaps(store: RoadmapCliStore, logger) -> None:
+    active = store.load_active()
+    logger.info("\n── Roadmaps ──────────────────────────────")
+    for roadmap_id in store.roadmap_ids():
+        marker = "● activo" if roadmap_id in active else "○ inactivo"
+        try:
+            data = json.loads(store.roadmap_path(roadmap_id).read_text(encoding="utf-8"))
+            project = data.get("project", roadmap_id)
+            phases_done = sum(1 for p in data.get("phases", []) if p.get("status") == "done")
+            phases_total = len(data.get("phases", []))
+            logger.info(f"  {marker}  {roadmap_id}")
+            logger.info(f"            {project}  [{phases_done}/{phases_total} fases]")
+        except (OSError, json.JSONDecodeError):
+            logger.error(f"  {marker}  {roadmap_id}  (error al leer)")
+    logger.info("")
+
+
+def _add_roadmap(store: RoadmapCliStore, roadmap_id: str, logger) -> None:
+    if not store.roadmap_path(roadmap_id).exists():
+        logger.error(
+            f"[ERROR] No existe '{roadmap_id}.json' en roadmaps/. Créalo primero con 'roadmap new'."
+        )
+        return
+    active = store.load_active()
+    if roadmap_id in active:
+        logger.info(f"[*] '{roadmap_id}' ya está activo.")
+        return
+    active.append(roadmap_id)
+    store.save_active(active)
+    logger.ok(f"[SUCCESS] Roadmap '{roadmap_id}' activado. Activos: {active}")
+
+
+def _remove_roadmap(store: RoadmapCliStore, roadmap_id: str, logger) -> None:
+    active = store.load_active()
+    if roadmap_id not in active:
+        logger.info(f"[*] '{roadmap_id}' no está en la lista activa.")
+        return
+    active.remove(roadmap_id)
+    store.save_active(active)
+    logger.ok(f"[SUCCESS] Roadmap '{roadmap_id}' desactivado. Activos: {active}")
+
+
+def _new_roadmap(
+    store: RoadmapCliStore, roadmap_id: str, project: str, description: str, logger
+) -> None:
+    target = store.roadmap_path(roadmap_id)
+    if target.exists():
+        logger.error(f"[ERROR] Ya existe '{roadmap_id}.json'. Usa otro ID.")
+        return
+    template = {
+        "project": project,
+        "profile": "",
+        "description": description,
+        "phases": [],
+        "session_resources": {"skills": [], "subagents": []},
+    }
+    target.write_text(json.dumps(template, indent=2, ensure_ascii=False), encoding="utf-8")
+    logger.ok(f"[SUCCESS] Roadmap '{roadmap_id}' creado en {target}")
+    logger.info(f"          Edítalo y actívalo con: htx roadmap add {roadmap_id}")