higpertext-cli 0.8.0__py3-none-any.whl

higpertext/capabilities/common/scripts/list_rules.py

@@ -0,0 +1,175 @@
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+from higpertext.kernel.infrastructure.capability_helper import CapabilityHelper
+from higpertext.kernel.config_paths import (
+    CAPABILITIES_DIR,
+    WORKFLOWS_DIR,
+    PROFILES_DIR,
+    PROJECT_ROOT as ROOT,
+)
+import sys
+import json
+from pathlib import Path
+
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+# Calcular ROOT para bootstrap de sys.path
+_ROOT = Path(__file__).resolve()
+while _ROOT.name != "LLM-agent" and len(_ROOT.parents) > 0:
+    _ROOT = _ROOT.parent
+
+COMPILED_WORKFLOWS_DIR = ROOT / WORKSPACE_DIR_NAME / "workflows" / "compiled"
+
+
+PINNED_CAPABILITIES = [
+    "common.grep-search",
+    "common.knowledge-asker",
+    "ado_admin.git-diff",
+    "common.code-skeletonizer",
+]
+
+
+def load_profile_capabilities(profile_name: str) -> list[str]:
+    profile_file = PROFILES_DIR / f"{profile_name}.json"
+    if not profile_file.exists():
+        _log.warning(f"[!] Perfil no encontrado: {profile_file}")
+        sys.exit(1)
+    data = json.loads(profile_file.read_text(encoding="utf-8"))
+    return data.get("capabilities", [])
+
+
+def load_capability_meta(cap_id: str) -> dict | None:
+    if "." not in cap_id:
+        return None
+    namespace, short_id = cap_id.split(".", 1)
+    cap_file = CAPABILITIES_DIR / namespace / f"{short_id}.json"
+    if not cap_file.exists():
+        return None
+    try:
+        return json.loads(cap_file.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return None
+
+
+def load_compiled_workflows() -> list[dict]:
+    workflows_dir = WORKFLOWS_DIR
+    if not workflows_dir.exists():
+        return []
+    workflows = []
+    for wf_file in sorted(workflows_dir.glob("*.json")):
+        try:
+            data = json.loads(wf_file.read_text(encoding="utf-8"))
+            if data.get("id"):
+                workflows.append(data)
+        except json.JSONDecodeError:  # nosec B110
+            pass
+    return workflows
+
+
+def print_capabilities(capability_ids: list[str]) -> None:
+    col_ns = 16
+    col_id = 24
+    col_desc = 48
+    col_flag = 7
+
+    header = f"{'NAMESPACE':<{col_ns}} {'ID':<{col_id}} {'FLAG':<{col_flag}} {'DESCRIPCIÓN'}"
+    separator = "-" * (col_ns + col_id + col_flag + col_desc + 3)
+
+    _log.info(separator)
+    _log.info(header)
+    _log.info(separator)
+
+    missing = []
+    for cap_id in capability_ids:
+        if "." not in cap_id:
+            continue
+        namespace, short_id = cap_id.split(".", 1)
+        meta = load_capability_meta(cap_id)
+        flag = "[FIJA]" if cap_id in PINNED_CAPABILITIES else ""
+        if meta is None:
+            missing.append(cap_id)
+            desc = "(JSON no encontrado)"
+        else:
+            desc = meta.get("description", "")
+            if len(desc) > col_desc:
+                desc = desc[: col_desc - 3] + "..."
+        _log.info(f"{namespace:<{col_ns}} {short_id:<{col_id}} {flag:<{col_flag}} {desc}")
+
+    _log.info(separator)
+    _log.info(
+        f"Total: {len(capability_ids)} capacidades  "
+        f"({sum(1 for c in capability_ids if c in PINNED_CAPABILITIES)} fijas)\n"
+    )
+
+    if missing:
+        _log.warning(f"[!] Sin JSON: {', '.join(missing)}\n")
+
+
+def print_workflows(workflows: list[dict]) -> None:
+    col_id = 36
+    col_desc = 52
+
+    header = f"{'WORKFLOW ID':<{col_id}} {'DESCRIPCIÓN'}"
+    separator = "-" * (col_id + col_desc + 1)
+
+    _log.info(separator)
+    _log.info(header)
+    _log.info(separator)
+
+    for wf in workflows:
+        wf_id = wf.get("id", "")
+        desc = wf.get("description", "")
+        if len(desc) > col_desc:
+            desc = desc[: col_desc - 3] + "..."
+        _log.info(f"{wf_id:<{col_id}} {desc}")
+
+    _log.info(separator)
+    _log.info(f"Total: {len(workflows)} workflows\n")
+
+
+def parse_args(args: list[str]) -> dict:
+    parsed = {"type": "all"}
+    i = 0
+    while i < len(args):
+        if args[i] == "--type" and i + 1 < len(args):
+            parsed["type"] = args[i + 1].lower()
+            i += 2
+        else:
+            i += 1
+    return parsed
+
+
+def main(args: list[str]) -> None:
+    parsed = parse_args(args)
+    env = CapabilityHelper.load_environment(ROOT)
+
+    profile_name = env.get("active_profile", "")
+    if not profile_name:
+        _log.warning("[!] No hay perfil activo en .higpertext/environment.json")
+        sys.exit(1)
+
+    list_type = parsed["type"]
+
+    if list_type in ("all", "capabilities"):
+        capability_ids = load_profile_capabilities(profile_name)
+        _log.info(f"\nCapacidades disponibles para: {profile_name}")
+        _log.info("  [FIJA] = siempre incluida automáticamente por load-rules")
+        print_capabilities(capability_ids)
+
+    if list_type in ("all", "workflows"):
+        workflows = load_compiled_workflows()
+        _log.info(f"Workflows disponibles (compilados):")
+        if workflows:
+            print_workflows(workflows)
+        else:
+            _log.info("  (ninguno compilado — ejecuta 'profile load' para compilarlos)\n")
+
+    _log.info("Comandos de carga:")
+    _log.info('  htx task load-rules --rules "<id1>,<id2>"')
+    _log.info("  htx task load-rules --rules all")
+    _log.info("  htx task load-rules --workflows all")
+    _log.info('  htx task load-rules --rules grep-search --workflows "higpertext-build"\n')
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

higpertext/capabilities/common/scripts/llm_invoke.py

@@ -0,0 +1,135 @@
+"""Capacidad common.llm-invoke — invoca un modelo LLM por API."""
+
+from __future__ import annotations
+import argparse
+import sys
+from pathlib import Path
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+# Permite importar kernel desde cualquier CWD
+_SCRIPT_DIR = Path(__file__).resolve().parent
+for _candidate in [
+    _SCRIPT_DIR.parents[3],
+    _SCRIPT_DIR.parents[3] / "core" / "kernel",
+    _SCRIPT_DIR.parents[5] / "src" / "core" / "kernel",
+]:
+    if _candidate.exists() and str(_candidate) not in sys.path:
+        sys.path.insert(0, str(_candidate))
+        break
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(description="higpertext LLM Invoke")
+    p.add_argument("--prompt", required=True)
+    p.add_argument("--provider", default="")
+    p.add_argument("--model", default="")
+    p.add_argument("--system", default="")
+    p.add_argument("--max_tokens", type=int, default=1024)
+    p.add_argument("--temperature", type=float, default=0.7)
+    p.add_argument("--stream", default="false")
+    p.add_argument("--output_file", default="")
+    return p
+
+
+def _resolve_project_root() -> Path:
+    """Sube desde el script hasta encontrar .venv/bin/htx o htx.py."""
+    current = Path(__file__).resolve()
+    for parent in current.parents:
+        if (parent / ".venv" / "bin" / "htx").exists():
+            return parent
+        if (parent / "htx.py").exists():
+            return parent
+    return Path.cwd()
+
+
+def main() -> None:
+    args = _build_parser().parse_args()
+
+    if not args.prompt.strip():
+        print("[ERROR] --prompt no puede estar vacío.", file=sys.stderr)
+        sys.exit(1)
+
+    use_stream = args.stream.lower() in ("true", "1", "yes")
+
+    try:
+        from higpertext.kernel.infrastructure.llm.registry import LLMRegistry
+    except ImportError as exc:
+        print(f"[ERROR] No se pudo importar LLMRegistry: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    root = _resolve_project_root()
+    registry = LLMRegistry(project_root=root)
+    provider_name = args.provider or registry.default_provider()
+    model = args.model or registry.default_model(provider_name)
+
+    if not provider_name:
+        _log.info(
+            "[ERROR] Provider LLM no definido. Usa --provider, HIGPERTEXT_LLM_PROVIDER "
+            "o configura llm.default_provider en .higpertext/config/environment.json.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    if not model:
+        _log.info(
+            "[ERROR] Modelo LLM no definido. Usa --model, HIGPERTEXT_LLM_MODEL "
+            "o configura llm.providers.<provider>.model en .higpertext/config/environment.json.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    try:
+        provider = registry.resolve(provider_name)
+    except (ValueError, ImportError) as exc:
+        print(f"[ERROR] {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    _log.info(f"[*] Provider : {provider_name}  |  Modelo: {model or 'default'}")
+    _log.info(f"[*] Stream   : {use_stream}")
+    _log.info("─" * 60)
+
+    output_parts: list[str] = []
+
+    try:
+        if use_stream:
+            for chunk in provider.stream(
+                args.prompt,
+                system=args.system,
+                model=model,
+                max_tokens=args.max_tokens,
+                temperature=args.temperature,
+            ):
+                _log.info(chunk, end="", flush=True)
+                output_parts.append(chunk)
+            _log.info()
+            full_output = "".join(output_parts)
+            _log.info("─" * 60)
+            _log.ok("[SUCCESS] Streaming completado.")
+        else:
+            resp = provider.complete(
+                args.prompt,
+                system=args.system,
+                model=model,
+                max_tokens=args.max_tokens,
+                temperature=args.temperature,
+            )
+            full_output = resp.content
+            _log.info(full_output)
+            _log.info("─" * 60)
+            _log.ok(
+f"[SUCCESS] Tokens — entrada: {resp.input_tokens}  |  "
+                f"salida: {resp.output_tokens}"
+            )
+    except Exception as exc:
+        print(f"[ERROR] Llamada al provider falló: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    if args.output_file:
+        out_path = Path(args.output_file)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(full_output, encoding="utf-8")
+        _log.ok(f"[*] Resultado guardado en: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

higpertext/capabilities/common/scripts/load_rules.py

@@ -0,0 +1,379 @@
+"""load-rules: carga reglas de capacidades seleccionadas al contexto del LLM activo."""
+
+import json
+import sys
+from pathlib import Path
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+from higpertext.kernel.infrastructure.logger import get_logger
+_log = get_logger()
+
+from higpertext.kernel.app_config import (
+    APPEND_ASSISTANTS,
+    PINNED_CAPABILITIES,
+    CLI_NAME,
+    RULES_DESTINATIONS_REL,
+)
+from higpertext.kernel.config_paths import (
+    CAPABILITIES_DIR,
+    WORKFLOWS_DIR,
+    PROFILES_DIR,
+    PROJECT_ROOT as ROOT,
+    WORKSPACE_DIR_NAME,
+)
+
+ENVIRONMENT_FILE = ROOT / WORKSPACE_DIR_NAME / "config" / "environment.json"
+
+RULES_DESTINATIONS = {k: ROOT / v for k, v in RULES_DESTINATIONS_REL.items()}
+
+
+
+def load_environment() -> dict:
+    if not ENVIRONMENT_FILE.exists():
+        return {}
+    try:
+        return json.loads(ENVIRONMENT_FILE.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+
+
+def load_profile_capabilities(profile_name: str) -> list[str]:
+    profile_file = PROFILES_DIR / f"{profile_name}.json"
+    if not profile_file.exists():
+        _log.warning(f"[!] Perfil no encontrado: {profile_file}")
+        sys.exit(1)
+    data = json.loads(profile_file.read_text(encoding="utf-8"))
+    return data.get("capabilities", [])
+
+
+def load_capability_meta(cap_id: str) -> dict | None:
+    if "." not in cap_id:
+        return None
+    namespace, short_id = cap_id.split(".", 1)
+    cap_file = CAPABILITIES_DIR / namespace / f"{short_id}.json"
+    if not cap_file.exists():
+        return None
+    try:
+        return json.loads(cap_file.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return None
+
+
+def render_capability_md(cap: dict) -> list[str]:
+    """Renderiza una capacidad en formato Markdown."""
+    higpertext_cmd = CLI_NAME
+    short_id = cap["id"].split(".")[-1]
+    lines = [
+        f"### `{cap['id']}`",
+        f"**Descripción**: {cap['description']}",
+        f"**Comando**: `{higpertext_cmd} task {short_id} [--params]`",
+        "",
+    ]
+    if cap.get("parameters"):
+        lines.append("**Parámetros**:")
+        for p in cap["parameters"]:
+            req_tag = "`REQUERIDO`" if p.get("required") else "`opcional`"
+            default = f" — default: `{p['default']}`" if "default" in p else ""
+            lines.append(f"- `--{p['name']}` {req_tag}: {p['description']}{default}")
+        lines.append("")
+    if cap.get("contract"):
+        rules = cap["contract"].get("rules", [])
+        if rules:
+            lines.append("**Contrato Técnico** — el output DEBE cumplir todas las reglas:")
+            for rule in rules:
+                lines.append(f"- `[CRÍTICO]` {rule}")
+            lines.append("")
+    lines += ["---", ""]
+    return lines
+
+
+def build_section(caps: list[dict], pinned: list[dict]) -> str:
+    lines = [
+        "<!-- session-capabilities — generado por load-rules, no editar manualmente -->",
+        "## Capacidades cargadas en sesión",
+        "",
+    ]
+    if pinned:
+        lines += ["### Capacidades fijas (siempre disponibles)", ""]
+        for cap in pinned:
+            lines += render_capability_md(cap)
+    if caps:
+        lines += ["### Capacidades cargadas bajo demanda", ""]
+        for cap in caps:
+            lines += render_capability_md(cap)
+    lines.append("<!-- end session-capabilities -->")
+    return "\n".join(lines)
+
+
+def write_dedicated(dest: Path, content: str) -> None:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(content, encoding="utf-8")
+
+
+def write_append(dest: Path, content: str) -> None:
+    """Reemplaza bloque session-capabilities si existe, sino lo appenda."""
+    if not dest.exists():
+        _log.warning(f"[!] Archivo destino no encontrado: {dest}")
+        _log.info("    Ejecuta 'htx profile load' primero.")
+        sys.exit(1)
+
+    existing = dest.read_text(encoding="utf-8")
+    start_marker = "<!-- session-capabilities"
+    end_marker = "<!-- end session-capabilities -->"
+
+    if start_marker in existing and end_marker in existing:
+        start_idx = existing.index(start_marker)
+        end_idx = existing.index(end_marker) + len(end_marker)
+        updated = existing[:start_idx] + content + existing[end_idx:]
+    else:
+        updated = existing.rstrip() + "\n\n" + content + "\n"
+
+    dest.write_text(updated, encoding="utf-8")
+
+
+def clear_rules(assistant: str) -> None:
+    dest = RULES_DESTINATIONS.get(assistant)
+    if dest is None:
+        _log.warning(f"[!] Asistente no soportado: {assistant}")
+        sys.exit(1)
+
+    if assistant in APPEND_ASSISTANTS:
+        if not dest.exists():
+            _log.info("[i] No hay reglas de sesión que limpiar.")
+            return
+        existing = dest.read_text(encoding="utf-8")
+        start_marker = "<!-- session-capabilities"
+        end_marker = "<!-- end session-capabilities -->"
+        if start_marker in existing and end_marker in existing:
+            start_idx = existing.index(start_marker)
+            end_idx = existing.index(end_marker) + len(end_marker)
+            cleaned = existing[:start_idx].rstrip() + "\n" + existing[end_idx:].lstrip()
+            dest.write_text(cleaned, encoding="utf-8")
+            _log.ok(f"[✓] Bloque session-capabilities eliminado de {dest.relative_to(ROOT)}")
+        else:
+            _log.info("[i] No se encontró bloque session-capabilities.")
+    else:
+        if dest.exists():
+            dest.unlink()
+            _log.ok(f"[✓] Eliminado: {dest.relative_to(ROOT)}")
+        else:
+            _log.info("[i] No hay reglas de sesión que limpiar.")
+
+
+def load_workflow_meta(workflow_id: str) -> dict | None:
+    """Carga el JSON de un workflow desde src/config/workflows/."""
+    workflows_dir = WORKFLOWS_DIR
+    short_id = workflow_id.split(".")[-1]
+    wf_file = workflows_dir / f"{short_id}.json"
+    if not wf_file.exists():
+        wf_file_alt = workflows_dir / f"{short_id.replace('-', '_')}.json"
+        if wf_file_alt.exists():
+            wf_file = wf_file_alt
+        else:
+            return None
+    try:
+        return json.loads(wf_file.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return None
+
+
+def load_profile_workflows(profile_name: str) -> list[str]:
+    """Lee los IDs de workflows desde src/config/workflows/."""
+    workflows_dir = WORKFLOWS_DIR
+    if not workflows_dir.exists():
+        return []
+    wf_ids = []
+    for wf_file in sorted(workflows_dir.glob("*.json")):
+        try:
+            data = json.loads(wf_file.read_text(encoding="utf-8"))
+            if data.get("id"):
+                wf_ids.append(data["id"])
+        except json.JSONDecodeError:  # nosec B110
+            pass
+    return wf_ids
+
+
+def render_workflow_md(wf: dict) -> list[str]:
+    """Renderiza un workflow en formato Markdown."""
+    higpertext_cmd = CLI_NAME
+    short_id = wf["id"].split(".")[-1]
+    lines = [
+        f"### `{wf['id']}` ({wf.get('name', short_id)})",
+        f"**Descripción**: {wf.get('description', '')}",
+        f"**Comando**: `{higpertext_cmd} workflow run {short_id} [--params]`",
+        "",
+    ]
+    if wf.get("parameters"):
+        lines.append("**Parámetros**:")
+        for p in wf["parameters"]:
+            req_tag = "`REQUERIDO`" if p.get("required") else "`opcional`"
+            lines.append(f"- `--{p['name']}` {req_tag}: {p['description']}")
+        lines.append("")
+    if wf.get("execution_chain"):
+        lines.append("**Cadena de Ejecución**:")
+        for step in wf["execution_chain"]:
+            lines.append(f"- `Paso {step['step']}`: `{step['task']}`")
+        lines.append("")
+    lines += ["---", ""]
+    return lines
+
+
+def build_section(caps: list[dict], pinned: list[dict], workflows: list[dict] | None = None) -> str:
+    lines = [
+        "<!-- session-capabilities — generado por load-rules, no editar manualmente -->",
+        "## Capacidades cargadas en sesión",
+        "",
+    ]
+    if pinned:
+        lines += ["### Capacidades fijas (siempre disponibles)", ""]
+        for cap in pinned:
+            lines += render_capability_md(cap)
+    if caps:
+        lines += ["### Capacidades cargadas bajo demanda", ""]
+        for cap in caps:
+            lines += render_capability_md(cap)
+    if workflows:
+        lines += ["## Workflows cargados en sesión", ""]
+        for wf in workflows:
+            lines += render_workflow_md(wf)
+    lines.append("<!-- end session-capabilities -->")
+    return "\n".join(lines)
+
+
+def parse_args(args: list[str]) -> dict:
+    parsed = {"rules": None, "workflows": None, "clear": False}
+    i = 0
+    while i < len(args):
+        if args[i] == "--rules" and i + 1 < len(args):
+            parsed["rules"] = args[i + 1]
+            i += 2
+        elif args[i] == "--workflows" and i + 1 < len(args):
+            parsed["workflows"] = args[i + 1]
+            i += 2
+        elif args[i] == "--clear" and i + 1 < len(args):
+            parsed["clear"] = args[i + 1].lower() == "true"
+            i += 2
+        else:
+            i += 1
+    return parsed
+
+
+def main(args: list[str]) -> None:
+    parsed = parse_args(args)
+    env = load_environment()
+    assistant = env.get("assistant", "claude")
+    profile_name = env.get("active_profile", "")
+
+    if not profile_name:
+        _log.warning("[!] No hay perfil activo en .higpertext/environment.json")
+        sys.exit(1)
+
+    if parsed["clear"]:
+        clear_rules(assistant)
+        return
+
+    if not parsed["rules"] and not parsed["workflows"]:
+        _log.warning("[!] Se requiere --rules o --workflows (o ambos).")
+        _log.info("    Ejemplos:")
+        _log.info("      htx task load-rules --rules all")
+        _log.info("      htx task load-rules --rules grep-search,code-quality")
+        _log.info("      htx task load-rules --workflows all")
+        _log.info("      htx task load-rules --rules grep-search --workflows higpertext-build")
+        sys.exit(1)
+
+    all_cap_ids = load_profile_capabilities(profile_name)
+
+    # --- Capacidades pinned (siempre incluidas) ---
+    pinned_caps = []
+    pinned_ids_in_profile = [c for c in PINNED_CAPABILITIES if c in all_cap_ids]
+    for cap_id in pinned_ids_in_profile:
+        meta = load_capability_meta(cap_id)
+        if meta:
+            pinned_caps.append(meta)
+
+    # --- Capacidades bajo demanda ---
+    demand_caps = []
+    if parsed["rules"]:
+        if parsed["rules"].strip().lower() == "all":
+            # all = todas excepto las pinned (ya se incluyen arriba)
+            selected_ids = [c for c in all_cap_ids if c not in PINNED_CAPABILITIES]
+        else:
+            requested = [r.strip() for r in parsed["rules"].split(",")]
+            id_map = {cap_id.split(".")[-1]: cap_id for cap_id in all_cap_ids}
+            id_map.update({cap_id: cap_id for cap_id in all_cap_ids})
+            selected_ids = []
+            unknown = []
+            for r in requested:
+                if r in id_map:
+                    full_id = id_map[r]
+                    if full_id not in PINNED_CAPABILITIES:
+                        selected_ids.append(full_id)
+                else:
+                    unknown.append(r)
+            if unknown:
+                _log.warning(f"[!] Capacidades no encontradas en el perfil: {', '.join(unknown)}")
+                _log.info("    Usa 'htx task list-rules' para ver las disponibles.")
+                sys.exit(1)
+
+        for cap_id in selected_ids:
+            meta = load_capability_meta(cap_id)
+            if meta is None:
+                _log.warning(f"[!] JSON no encontrado para: {cap_id} — omitido")
+                continue
+            demand_caps.append(meta)
+
+    # --- Workflows ---
+    wf_metas = []
+    if parsed["workflows"]:
+        all_wf_ids = load_profile_workflows(profile_name)
+        if parsed["workflows"].strip().lower() == "all":
+            selected_wf_ids = all_wf_ids
+        else:
+            requested_wf = [w.strip() for w in parsed["workflows"].split(",")]
+            wf_id_map = {wf_id.split(".")[-1]: wf_id for wf_id in all_wf_ids}
+            wf_id_map.update({wf_id: wf_id for wf_id in all_wf_ids})
+            selected_wf_ids = []
+            unknown_wf = []
+            for w in requested_wf:
+                if w in wf_id_map:
+                    selected_wf_ids.append(wf_id_map[w])
+                else:
+                    unknown_wf.append(w)
+            if unknown_wf:
+                _log.warning(f"[!] Workflows no encontrados: {', '.join(unknown_wf)}")
+                _log.info("    Usa 'htx task list-rules --type workflows' para ver los disponibles.")
+                sys.exit(1)
+        for wf_id in selected_wf_ids:
+            meta = load_workflow_meta(wf_id)
+            if meta is None:
+                _log.warning(f"[!] JSON no encontrado para workflow: {wf_id} — omitido")
+                continue
+            wf_metas.append(meta)
+
+    if not pinned_caps and not demand_caps and not wf_metas:
+        _log.warning("[!] No se cargó ninguna capacidad ni workflow.")
+        sys.exit(1)
+
+    content = build_section(demand_caps, pinned_caps, wf_metas if wf_metas else None)
+    dest = RULES_DESTINATIONS.get(assistant)
+
+    if dest is None:
+        _log.warning(f"[!] Asistente no soportado: {assistant}")
+        sys.exit(1)
+
+    if assistant in APPEND_ASSISTANTS:
+        write_append(dest, content)
+    else:
+        write_dedicated(dest, content)
+
+    total_caps = len(pinned_caps) + len(demand_caps)
+    _log.ok(
+f"[OK] {total_caps} capacidad(es) ({len(pinned_caps)} fijas + {len(demand_caps)} bajo demanda)" # noqa: E501
+        f" + {len(wf_metas)} workflow(s) -> {dest.relative_to(ROOT)}"
+    )
+    _log.info(f"    Asistente: {assistant} | Perfil: {profile_name}")
+    if assistant not in APPEND_ASSISTANTS:
+        _log.info("    El archivo se carga automáticamente en el próximo turno.")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])