higpertext-cli 0.8.0__py3-none-any.whl

higpertext/adapters/claude_adapter/claude_adapter.py

@@ -0,0 +1,154 @@
+"""
+higpertext Module — Auto-generated Documentation
+"""
+
+from pathlib import Path
+from higpertext.adapters.adapter_utils import (
+    HTX_CMD,
+    HTX_WORKFLOW_CMD,
+    load_session,
+    guidelines_lines,
+    session_lines,
+    capabilities_section,
+    workflows_section,
+    delegation_rule_lines,
+    workflow_trigger_lines,
+    project_refs_lines,
+    loop_guard_lines,
+    reasoning_style_lines,
+)
+from higpertext.kernel.app_config import ADAPTERS_CONFIG
+_CFG = ADAPTERS_CONFIG["claude"]
+
+
+def _header_lines(agent_name: str, profile: dict) -> list:
+    return [
+        line.format(
+            agent_name=agent_name,
+            agent_name_upper=agent_name.upper(),
+            system_prompt=profile["system_prompt"],
+            htx_cmd=HTX_CMD,
+        )
+        for line in _CFG["header_lines"]
+    ]
+
+
+def _pair_programming_lines() -> list:
+    return list(_CFG["pair_programming_lines"])
+
+
+def _behavior_lines(profile: dict) -> list:
+    behavior = list(_CFG["behavior_lines"])
+    if profile.get("governance_access"):
+        behavior.append(_CFG["behavior_governance_line"])
+    return behavior + [""]
+
+
+def _execution_protocol_lines() -> list:
+    base_lines = [
+        line.format(htx_cmd=HTX_CMD)
+        for line in _CFG["execution_protocol_lines"]
+    ]
+    return base_lines + delegation_rule_lines()
+
+
+def _token_rules_lines() -> list:
+    return list(_CFG["token_rules_lines"])
+
+
+def _claude_md_index(agent_name: str) -> str:
+    """Genera un CLAUDE.md liviano que apunta al rules file como fuente de verdad.
+
+    Claude Code carga .claude/rules/*.md con prioridad; CLAUDE.md duplicar ese
+    contenido infla el contexto ~30KB por turno sin aportar información nueva.
+    """
+    return "\n".join(
+        [
+            line.format(
+                agent_name=agent_name,
+                htx_cmd=HTX_CMD,
+                htx_workflow_cmd=HTX_WORKFLOW_CMD,
+            )
+            for line in _CFG["claude_md_index"]
+        ]
+    )
+
+
+def _write_outputs(target_dir: Path, agent_name: str, content: str) -> Path:
+    agents_file = target_dir / "AGENTS.md"
+    agents_file.write_text(content, encoding="utf-8")
+    # CLAUDE.md es un índice liviano; el contenido completo vive en .claude/rules/
+    (target_dir / "CLAUDE.md").write_text(_claude_md_index(agent_name), encoding="utf-8")
+    (target_dir / ".clauderules").write_text(content, encoding="utf-8")
+    try:
+        ag_dir = target_dir / ".agents" / "rules"
+        ag_dir.mkdir(parents=True, exist_ok=True)
+        (ag_dir / "higpertext_rules.md").write_text(content, encoding="utf-8")
+    except OSError:  # nosec B110
+        pass
+    try:
+        cr_dir = target_dir / ".claude" / "rules"
+        if cr_dir.exists():
+            for f in cr_dir.glob("*.md"):
+                try:
+                    f.unlink()
+                except OSError:  # nosec B110
+                    pass
+        cr_dir.mkdir(parents=True, exist_ok=True)
+        (cr_dir / f"{agent_name}.md").write_text(content, encoding="utf-8")
+    except OSError:  # nosec B110
+        pass
+    return target_dir / ".claude" / "rules" / f"{agent_name}.md"
+
+
+class ClaudeAdapter:
+    """Genera .clauderules para Claude Code basado en el contexto del higpertext Engine."""
+
+    @staticmethod
+    def generate_rules(context: dict, target_dir: Path) -> Path:
+        profile = context["profile"]
+        agent_name = profile["name"]
+        capabilities = context["active_capabilities"]
+        workflows = context.get("active_workflows", [])
+
+        lines = []
+        lines += _header_lines(agent_name, profile)
+        lines += _pair_programming_lines()
+        lines += _behavior_lines(profile)
+
+        guide_lines = guidelines_lines(Path(__file__))
+        if guide_lines:
+            lines += ["## Lineamientos activos de gobernanza", ""]
+            lines += [
+                "Estas reglas son de cumplimiento obligatorio en todo el desarrollo:",
+                "",
+            ]
+            lines += guide_lines
+            lines += ["---", ""]
+
+        lines += loop_guard_lines()
+        lines += reasoning_style_lines()
+        lines += _execution_protocol_lines()
+        lines += workflow_trigger_lines(workflows)
+        lines += _token_rules_lines()
+        lines += project_refs_lines(
+            target_dir,
+            header=(
+                "## REFERENCIAS DEL PROYECTO\n\n"
+                "Estos archivos de referencia están disponibles en el espacio de trabajo."
+                " **NO leas el archivo de memoria context.md en su totalidad en cada turno**;"
+                " en su lugar, consulta las memorias y la gobernanza dinámicamente usando"
+                " `common.knowledge-asker` para buscar entradas relevantes."
+            ),
+        )
+
+        session = load_session(target_dir)
+        lines += session_lines(session, target_dir, ".claude/skills")
+
+        lines += capabilities_section(capabilities)
+        lines += workflows_section(workflows)
+        lines.append(
+            "*higpertext Engine v5.0 — configuración auto-generada. No editar manualmente.*"
+        )
+
+        return _write_outputs(target_dir, agent_name, "\n".join(lines))

higpertext/adapters/copilot_adapter/copilot_adapter.py

@@ -0,0 +1,231 @@
+"""higpertext Copilot Adapter — genera configuración nativa para GitHub Copilot."""
+
+from pathlib import Path
+from higpertext.adapters.adapter_utils import (
+    HTX_CMD,
+    HTX_WORKFLOW_CMD,
+    load_session,
+    session_lines,
+    capabilities_section,
+    workflows_section,
+    delegation_rule_lines,
+    loop_guard_lines,
+    reasoning_style_lines,
+)
+from higpertext.kernel.app_config import ADAPTERS_CONFIG
+_CFG = ADAPTERS_CONFIG["copilot"]
+
+
+def _build_copilot_instructions_md(profile: dict, capabilities: list, workflows: list) -> str:
+    gov_text = _CFG["governance_enabled"] if profile.get("governance_access") else _CFG["governance_disabled"]
+    lines = [
+        line.format(
+            description=profile["description"],
+            system_prompt=profile["system_prompt"],
+            governance_access_text=gov_text,
+            htx_cmd=HTX_CMD,
+            htx_workflow_cmd=HTX_WORKFLOW_CMD,
+        )
+        for line in _CFG["working_rules_header"]
+    ]
+
+    lines += loop_guard_lines()
+    lines += reasoning_style_lines()
+    lines += delegation_rule_lines()
+    lines += capabilities_section(capabilities)
+    lines += workflows_section(workflows)
+    lines.append("*higpertext Engine v5.0 — auto-generated. Do not edit manually.*")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# .github/rules/{name}.md  — reglas extraídas por workflow
+# ---------------------------------------------------------------------------
+
+
+def _build_workflow_rules_md(wf: dict) -> str:
+    """Genera .github/rules/{name}.md con las reglas Do/Do not del workflow."""
+    wf_name = wf["id"].split(".")[-1]
+    lines = [
+        line.format(
+            wf_name=wf_name,
+            wf_description=wf.get("description", ""),
+        )
+        for line in _CFG["workflow_rules_header"]
+    ]
+    if wf.get("do"):
+        lines += ["## Do", ""]
+        for item in wf["do"]:
+            lines.append(f"- {item}")
+        lines.append("")
+    if wf.get("do_not"):
+        lines += ["## Do not", ""]
+        for item in wf["do_not"]:
+            lines.append(f"- {item}")
+        lines.append("")
+    lines.append("*higpertext Engine v5.0 — auto-generated.*")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# .github/agents/{name}.md  — agentes Copilot por workflow
+# ---------------------------------------------------------------------------
+
+
+def _build_workflow_agents_md(workflows: list) -> list[tuple[str, str]]:
+    """Genera .github/agents/{name}.md como agente Copilot por workflow activo.
+
+    Retorna lista de (filename, content).
+    """
+    files: list[tuple[str, str]] = []
+    for wf in workflows:
+        wf_name = wf["id"].split(".")[-1]
+        temperature = wf.get("temperature", 0.1)
+        allow_edit = "allow" if wf.get("allow_edit", False) else "deny"
+        allow_bash = "allow" if wf.get("allow_bash", False) else "deny"
+        when_to_use = wf.get("when_to_use", [wf.get("description", "")])
+
+        lines = [
+            line.format(
+                description=wf.get("description", ""),
+                temperature=temperature,
+                allow_edit=allow_edit,
+                allow_bash=allow_bash,
+            )
+            for line in _CFG["workflow_agents_header"]
+        ]
+        for item in (when_to_use if isinstance(when_to_use, list) else [when_to_use]):
+            lines.append(f"- {item}")
+        
+        footer = [
+            line.format(wf_name=wf_name)
+            for line in _CFG["workflow_agents_footer"]
+        ]
+        lines += footer
+        files.append((f"{wf_name}.md", "\n".join(lines)))
+    return files
+
+
+# ---------------------------------------------------------------------------
+# .github/instructions/*.instructions.md
+# ---------------------------------------------------------------------------
+
+
+def _build_instructions_md(profile: dict, capabilities: list, workflows: list) -> list[tuple[str, str]]:
+    """Genera archivos .instructions.md por dominio de capabilities/workflows.
+
+    Retorna lista de (filename, content) para escribir en .github/instructions/.
+    """
+    files: list[tuple[str, str]] = []
+
+    for wf in workflows:
+        wf_name = wf["id"].split(".")[-1]
+        content = "\n".join(
+            [
+                line.format(
+                    wf_name=wf_name,
+                    wf_description=wf["description"],
+                    htx_workflow_cmd=HTX_WORKFLOW_CMD,
+                )
+                for line in _CFG["instructions_template"]
+            ]
+        )
+        files.append((f"{wf_name}.instructions.md", content))
+
+    return files
+
+
+# ---------------------------------------------------------------------------
+# .github/skills/<name>/SKILL.md  (misma lógica que otros adapters)
+# ---------------------------------------------------------------------------
+
+
+def _session_skills_subdir() -> str:
+    return ".github/skills"
+
+
+# ---------------------------------------------------------------------------
+# AGENTS.md  (índice liviano — mismo patrón que OpenCode)
+# ---------------------------------------------------------------------------
+
+
+def _build_agents_md_index(profile: dict) -> str:
+    agent_name = profile["name"]
+    return "\n".join(
+        [
+            line.format(
+                agent_name=agent_name,
+                agent_name_upper=agent_name.upper(),
+                description=profile["description"],
+                htx_cmd=HTX_CMD,
+                htx_workflow_cmd=HTX_WORKFLOW_CMD,
+            )
+            for line in _CFG["agents_md_index"]
+        ]
+    )
+
+
+# ---------------------------------------------------------------------------
+# Adapter principal
+# ---------------------------------------------------------------------------
+
+
+class CopilotAdapter:
+    """Genera configuración nativa para GitHub Copilot basada en el perfil higpertext.
+
+    Estructura generada:
+        .github/
+          copilot-instructions.md
+          agents/
+            {name}.md                ← agente Copilot por workflow activo
+          rules/
+            {name}.md                ← reglas Do/Do not por workflow
+          instructions/
+            *.instructions.md        ← índice de workflow por capability
+          copilot/
+            hooks/                   ← scripts de hook por evento
+        AGENTS.md                    ← índice liviano
+    """
+
+    @staticmethod
+    def generate_rules(context: dict, project_root: Path) -> Path:
+        profile = context["profile"]
+        capabilities = context["active_capabilities"]
+        workflows = context.get("active_workflows", [])
+
+        github_dir = project_root / ".github"
+        github_dir.mkdir(exist_ok=True)
+
+        # ── 1. copilot-instructions.md ────────────────────────────────────────
+        instructions_content = _build_copilot_instructions_md(profile, capabilities, workflows)
+        instructions_file = github_dir / "copilot-instructions.md"
+        instructions_file.write_text(instructions_content, encoding="utf-8")
+
+        # ── 2. .github/agents/{name}.md ──────────────────────────────────────
+        agents_dir = github_dir / "agents"
+        agents_dir.mkdir(exist_ok=True)
+        for filename, content in _build_workflow_agents_md(workflows):
+            (agents_dir / filename).write_text(content, encoding="utf-8")
+
+        # ── 3. .github/rules/{name}.md ───────────────────────────────────────
+        rules_dir = github_dir / "rules"
+        rules_dir.mkdir(exist_ok=True)
+        for wf in workflows:
+            wf_name = wf["id"].split(".")[-1]
+            (rules_dir / f"{wf_name}.md").write_text(_build_workflow_rules_md(wf), encoding="utf-8")
+
+        # ── 4. .github/instructions/*.instructions.md ─────────────────────────
+        instr_dir = github_dir / "instructions"
+        instr_dir.mkdir(exist_ok=True)
+        for filename, content in _build_instructions_md(profile, capabilities, workflows):
+            (instr_dir / filename).write_text(content, encoding="utf-8")
+
+        # ── 5. AGENTS.md liviano en raíz ─────────────────────────────────────
+        agents_file = project_root / "AGENTS.md"
+        agents_file.write_text(_build_agents_md_index(profile), encoding="utf-8")
+
+        # ── 6. Sesión activa: skills ──────────────────────────────────────────
+        session = load_session(project_root)
+        _ = session_lines(session, project_root, _session_skills_subdir())
+
+        return instructions_file

higpertext/adapters/gemini_adapter/gemini_adapter.py

@@ -0,0 +1,211 @@
+"""higpertext Gemini Adapter — genera GEMINI.md para Google Gemini CLI."""
+
+from pathlib import Path
+from higpertext.adapters.adapter_utils import (
+    HTX_CMD,
+    load_session,
+    guidelines_lines,
+    session_lines,
+    capabilities_section,
+    workflows_section,
+    delegation_rule_lines,
+    workflow_trigger_lines,
+    hooks_section,
+    operational_lines,
+    project_refs_lines,
+    loop_guard_lines,
+    reasoning_style_lines,
+)
+from higpertext.kernel.app_config import ADAPTERS_CONFIG
+_CFG = ADAPTERS_CONFIG["gemini"]
+
+
+def _header_lines(agent_name: str, profile: dict) -> list:
+    governance_text = _CFG["governance_access_enabled"] if profile.get("governance_access") else _CFG["governance_access_disabled"]
+    return [
+        line.format(
+            re_generate_cmd="htx profile load <profile> --assistant gemini",
+            title_prefix="Gemini",
+            agent_name_upper=agent_name.upper(),
+            description=profile["description"],
+            system_prompt=profile["system_prompt"],
+            governance_access_text=governance_text,
+            htx_cmd=HTX_CMD,
+        )
+        for line in _CFG["header_lines"]
+    ]
+
+
+class GeminiAdapter:
+    """Genera archivos GEMINI.md y AGENTS.md para Google Gemini y Antigravity CLI
+    basados en el contexto del higpertext Engine."""
+
+    @staticmethod
+    def generate_rules(context: dict, target_dir: Path) -> Path:
+        profile = context["profile"]
+        agent_name = profile["name"]
+        capabilities = context["active_capabilities"]
+        workflows = context.get("active_workflows", [])
+
+        def build_rule_content(
+            assistant_type: str,
+            session_skills_dir: str,
+            title_prefix: str,
+            load_cmd: str,
+        ) -> str:
+            governance_text = _CFG["governance_access_enabled"] if profile.get("governance_access") else _CFG["governance_access_disabled"]
+            lines = [
+                line.format(
+                    re_generate_cmd=load_cmd,
+                    title_prefix=title_prefix,
+                    agent_name_upper=agent_name.upper(),
+                    description=profile["description"],
+                    system_prompt=profile["system_prompt"],
+                    governance_access_text=governance_text,
+                    htx_cmd=HTX_CMD,
+                )
+                for line in _CFG["header_lines"]
+            ]
+            guide_lines = guidelines_lines(Path(__file__))
+            if guide_lines:
+                lines += ["## ACTIVE GOVERNANCE GUIDELINES", ""]
+                lines += [
+                    "These rules are MANDATORY across all development activities:",
+                    "",
+                ]
+                lines += guide_lines
+                lines += ["---", ""]
+
+            lines += delegation_rule_lines(
+                title=_CFG["delegation_title"],
+                mandate=_CFG["delegation_mandate"],
+                hint=_CFG["delegation_hint"],
+            )
+            lines += workflow_trigger_lines(
+                workflows,
+                title=_CFG["workflow_trigger_title"],
+                mandate=_CFG["workflow_trigger_mandate"],
+                hint=_CFG["workflow_trigger_hint"],
+            )
+            lines += loop_guard_lines()
+            lines += reasoning_style_lines()
+            
+            steps = [s.format(htx_cmd=HTX_CMD) for s in _CFG["operational_steps"]]
+            token_rules = list(_CFG["token_rules"])
+            lines += operational_lines(
+                title=_CFG["operational_title"],
+                steps=steps,
+                token_rules_title=_CFG["token_rules_title"],
+                token_rules=token_rules,
+            )
+            lines += project_refs_lines(
+                target_dir,
+                header=_CFG["project_refs_header"],
+            )
+            lines += hooks_section(target_dir, assistant_type, agent_name)
+            session = load_session(target_dir)
+            lines += session_lines(session, target_dir, session_skills_dir)
+            lines += capabilities_section(capabilities, label="## AVAILABLE CAPABILITIES")
+            lines += workflows_section(workflows, label="## AVAILABLE WORKFLOWS (PLAYBOOKS)")
+            lines.append(
+                "*higpertext Engine v5.0 — auto-generated agent configuration."
+                " Do not edit manually.*"
+            )
+            return "\n".join(lines)
+
+        # 1. Generate rules for Gemini (GEMINI.md)
+        gemini_content = build_rule_content(
+            "gemini",
+            ".gemini/skills",
+            "Gemini",
+            "htx profile load <profile> --assistant gemini",
+        )
+        gemini_file = target_dir / "GEMINI.md"
+        gemini_file.write_text(gemini_content, encoding="utf-8")
+
+        # 2. Generate rules for Antigravity (AGENTS.md)
+        antigravity_content = build_rule_content(
+            "antigravity",
+            ".agents/skills",
+            "Antigravity",
+            "htx profile load <profile> --assistant antigravity",
+        )
+        agents_file = target_dir / "AGENTS.md"
+        agents_file.write_text(antigravity_content, encoding="utf-8")
+
+        # Save to .agents/rules/higpertext_rules.md too
+        try:
+            ag_dir = target_dir / ".agents" / "rules"
+            ag_dir.mkdir(parents=True, exist_ok=True)
+            (ag_dir / "higpertext_rules.md").write_text(antigravity_content, encoding="utf-8")
+        except OSError:  # nosec B110
+            pass
+
+        _GEMINI_DIR = ".gemini"
+
+        # 3. Create both .gemini/ and .agents/ subdirectories to be ready
+        for subdir in ["workflows", "skills", "subagents"]:
+            (target_dir / _GEMINI_DIR / subdir).mkdir(parents=True, exist_ok=True)
+            (target_dir / ".agents" / subdir).mkdir(parents=True, exist_ok=True)
+
+        # 4. Mirror dynamic workflows, skills, and subagents between both platforms
+        def _mirror_dirs(src_dir: Path, dest_dir: Path):
+            if not src_dir.exists():
+                return
+            dest_dir.mkdir(parents=True, exist_ok=True)
+            import shutil
+
+            for item in src_dir.iterdir():
+                if item.is_file():
+                    shutil.copy2(item, dest_dir / item.name)
+                elif item.is_dir():
+                    _mirror_dirs(item, dest_dir / item.name)
+
+        # Mirror workflows both ways
+        _mirror_dirs(target_dir / _GEMINI_DIR / "workflows", target_dir / ".agents" / "workflows")
+        _mirror_dirs(target_dir / ".agents" / "workflows", target_dir / _GEMINI_DIR / "workflows")
+
+        # Convert workflows to skills to enable slash commands detection
+        def _workflows_to_skills(workflows_dir: Path, skills_dir: Path):
+            if not workflows_dir.exists():
+                return
+            skills_dir.mkdir(parents=True, exist_ok=True)
+            for item in workflows_dir.iterdir():
+                if item.is_file() and item.suffix == ".md":
+                    name = item.stem
+                    dest_skill_dir = skills_dir / name
+                    dest_skill_dir.mkdir(parents=True, exist_ok=True)
+                    try:
+                        content = item.read_text(encoding="utf-8")
+                        if content.startswith("---"):
+                            parts = content.split("---", 2)
+                            if len(parts) >= 3:
+                                frontmatter = parts[1]
+                                body = parts[2]
+                                if "name:" not in frontmatter:
+                                    frontmatter = f"\nname: {name}" + frontmatter
+                                content = f"---{frontmatter}---{body}"
+                        else:
+                            content = f"---\nname: {name}\n---\n\n" + content
+                        (dest_skill_dir / "SKILL.md").write_text(content, encoding="utf-8")
+                    except OSError:  # nosec B110
+                        pass
+
+        _workflows_to_skills(
+            target_dir / _GEMINI_DIR / "workflows", target_dir / _GEMINI_DIR / "skills"
+        )
+        _workflows_to_skills(
+            target_dir / ".agents" / "workflows", target_dir / ".agents" / "skills"
+        )
+
+        # Mirror skills and subagents both ways
+        _mirror_dirs(target_dir / _GEMINI_DIR / "skills", target_dir / ".agents" / "skills")
+        _mirror_dirs(target_dir / ".agents" / "skills", target_dir / _GEMINI_DIR / "skills")
+        _mirror_dirs(target_dir / _GEMINI_DIR / "subagents", target_dir / ".agents" / "subagents")
+        _mirror_dirs(target_dir / ".agents" / "subagents", target_dir / _GEMINI_DIR / "subagents")
+
+        return gemini_file
+
+    @staticmethod
+    def on_init(context: dict, target_dir: Path) -> None:
+        GeminiAdapter.generate_rules(context, target_dir)

higpertext/adapters/llm_formatter.py

@@ -0,0 +1,46 @@
+class LLMFormatter:
+    """
+    Convierte el contexto del higpertext Engine (Perfiles y Capacidades)
+    al formato nativo de Function Calling / Tool Use de las APIs de LLMs.
+    """
+
+    @staticmethod
+    def to_openai_tools(higpertext_context: dict) -> list:
+        """Convierte las capacidades activas al formato OpenAI/Gemini Tools."""
+        tools = []
+        for cap in higpertext_context.get("active_capabilities", []):
+            tool = {
+                "type": "function",
+                "function": {
+                    "name": cap["id"].replace(".", "_").replace("-", "_"),
+                    "description": cap["description"],
+                    "parameters": {"type": "object", "properties": {}, "required": []},
+                },
+            }
+
+            # Mapear parámetros
+            for param in cap.get("parameters", []):
+                param_name = param["name"].replace("-", "_")
+                tool["function"]["parameters"]["properties"][param_name] = {
+                    "type": param["type"],
+                    "description": param["description"],
+                }
+                if param.get("required", False):
+                    tool["function"]["parameters"]["required"].append(param_name)
+
+            tools.append(tool)
+
+        return tools
+
+    @staticmethod
+    def generate_system_prompt(higpertext_context: dict) -> str:
+        """Genera el System Prompt inyectando el perfil y reglas dinámicas."""
+        profile = higpertext_context.get("profile", {})
+        prompt = f"Rol: {profile.get('name', 'Agente higpertext').upper()}\n"
+        prompt += f"{profile.get('system_prompt', '')}\n\n"
+        prompt += "Reglas Generales:\n"
+        prompt += "1. Usa las herramientas proporcionadas para interactuar con el entorno.\n"
+        prompt += (
+            "2. Nunca intentes adivinar información técnica;" " extraela usando tus capacidades.\n"
+        )
+        return prompt