higpertext-cli 0.8.0__py3-none-any.whl

higpertext/hooks/hook_tasks/_rules/session_rules.py

@@ -0,0 +1,316 @@
+"""Reglas de sesión para UserPromptSubmit.
+
+Inyecta estado de sesión y contexto de skills activas en cada prompt.
+"""
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+import json
+import platform
+import shutil
+# Auto-start usa lista de argumentos sin shell.
+import subprocess  # nosec B404
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from higpertext.kernel.infrastructure.logger import get_logger
+
+_log = get_logger()
+
+try:
+    from higpertext.kernel.htx_resolver import get_htx_cmd
+except ImportError:
+    get_htx_cmd = None
+
+try:
+    from higpertext.kernel.domain.context_engine import reset_window_state
+except ImportError:
+    reset_window_state = None
+
+try:
+    import higpertext.hooks.hook_tasks.telemetry_utils as telem
+except ImportError:
+    telem = None
+
+from higpertext.kernel.app_config import (
+    ENVIRONMENT_FILE as _ENVIRONMENT_JSON,
+    SESSION_FILE as _SESSION_JSON,
+    SKILL_DIRS as _SKILL_DIRS,
+    AGENT_DIRS as _AGENT_DIRS,
+)
+RuleSeverity = Literal["continue", "context", "block"]
+
+
+@dataclass
+class RuleResult:
+    severity: RuleSeverity
+    message: str = ""
+
+
+# ── Auto-inicio de sesión ─────────────────────────────────────────────────────
+
+
+def _get_htx(root: Path) -> list[str]:
+    if get_htx_cmd is not None:
+        try:
+            return get_htx_cmd(root)
+        except Exception as exc:
+            _log.warning(f"[session] No se pudo resolver htx desde config: {exc}")
+
+    venv_htx = root / ".venv" / ("Scripts" if platform.system() == "Windows" else "bin") / "htx"
+    if venv_htx.exists():
+        return [str(venv_htx)]
+    if htx := shutil.which("htx"):
+        return [htx]
+    return [str(root / ".venv" / "bin" / "python"), str(root / "htx.py")]
+
+
+def auto_start_session(root: Path) -> None:
+    """Inicia sesión automáticamente si no hay una activa."""
+    env = _read_json(root / WORKSPACE_DIR_NAME / "config" / _ENVIRONMENT_JSON)
+    profile = env.get("active_profile", "software_developer")
+    cmd = _get_htx(root) + [
+        "task",
+        "common.session-start",
+        "--action",
+        "start",
+        "--profile",
+        profile,
+    ]
+    try:
+        subprocess.run(cmd, cwd=str(root), timeout=20, capture_output=True)  # nosec B603
+    except (OSError, subprocess.SubprocessError) as exc:
+        _log.warning(f"[session] Auto-start omitido: {exc}")
+
+
+# ── Reset de ventana de contexto por turno ──────────────────────────────────
+
+
+def reset_window_accumulator(root: Path) -> None:
+    """Reinicia el acumulador de tokens de la ventana para el nuevo turno."""
+    if reset_window_state is not None:
+        try:
+            reset_window_state(root)
+        except Exception as exc:
+            _log.warning(f"[session] No se pudo reiniciar window accumulator: {exc}")
+
+
+# ── Regla 1: Estado de sesión (session_start) ─────────────────────────────────
+
+
+def inject_session_status(root: Path) -> RuleResult:
+    session = _read_json(root / WORKSPACE_DIR_NAME / "state" / _SESSION_JSON)
+    env = _read_json(root / WORKSPACE_DIR_NAME / "config" / _ENVIRONMENT_JSON)
+    profile = env.get("active_profile", "global")
+    asst = env.get("assistant", "claude")
+    active = session.get("status") == "active"
+    sid = session.get("session_id", "—")
+
+    if active and not _already_recorded(root, sid):
+        if telem is not None:
+            telem.session_start(root, sid, profile)
+        reset_window_accumulator(root)
+
+    if not active:
+        available = _available_skills(root, profile)
+        skills_hint = f"Skills disponibles : {', '.join(available)}" if available else ""
+        lines = [
+            "╔─ HIGPERTEXT  ·  Sin sesión activa ────────────────────────",
+            f"│  Perfil : {profile}",
+        ]
+        if skills_hint:
+            lines.append(f"│  {skills_hint}")
+        lines += [
+            f"│  → htx task common.session-start --profile {profile}",
+            "╚──────────────────────────────────────────────────────",
+        ]
+        return RuleResult(severity="context", message="\n".join(lines))
+
+    skills = _list_dir_names(root / _SKILL_DIRS.get(asst, ".claude/skills"))
+    subagents = _list_dir_names(root / _AGENT_DIRS.get(asst, ".claude/subagents"), "*.md")
+    lines = [
+        "╔─ HIGPERTEXT  ·  Sesión activa ─────────────────────────────",
+        f"│  {sid}  ·  perfil: {profile}",
+        f"│  Skills     : {', '.join(skills) or '—'}",
+        f"│  Subagentes : {', '.join(subagents) or '—'}",
+        "╚───────────────────────────────────────────────────────",
+    ]
+
+    workflows = _available_workflows(root, profile)
+    if workflows:
+        wf_lines = ["╔─ HIGPERTEXT  ·  Workflows del perfil ──────────────────────"]
+        for wf in workflows:
+            wf_lines.append(f"│  [{wf['id']}]")
+            wf_lines.append(f"│    Cuándo : {wf.get('when', '—')}")
+            wf_lines.append(f"│    Comando: {wf.get('command', '—')}")
+        wf_lines.append("╚───────────────────────────────────────────────────────")
+        lines.append("\n".join(wf_lines))
+
+    learned = _load_learned_profile(root)
+    profile_block = _render_profile_block(learned)
+    if profile_block:
+        lines.append(profile_block)
+
+    return RuleResult(severity="context", message="\n".join(lines))
+
+
+# ── Regla 2: Contexto de skills activas (session_context) ────────────────────
+
+
+def inject_skills_context(root: Path) -> RuleResult | None:
+    session = _read_json(root / WORKSPACE_DIR_NAME / "state" / _SESSION_JSON)
+    env = _read_json(root / WORKSPACE_DIR_NAME / "config" / _ENVIRONMENT_JSON)
+
+    if session.get("status") != "active":
+        return None
+
+    asst = env.get("assistant", "claude")
+    sid = session.get("session_id", "—")
+    skills_dir = root / _SKILL_DIRS.get(asst, ".claude/skills")
+
+    skill_entries: list[tuple[str, str]] = []
+    if skills_dir.exists():
+        for d in sorted(skills_dir.iterdir()):
+            if d.is_dir():
+                summary = _skill_summary(d)
+                skill_entries.append((d.name, summary))
+
+    if not skill_entries:
+        return None
+
+    lines = [f"╔─ HIGPERTEXT  ·  Contexto de sesión  ·  {sid} ─────────────"]
+    lines.append("│  Skills activas:")
+    for name, summary in skill_entries:
+        desc = f"  {summary}" if summary else ""
+        lines.append(f"│    • {name}{desc}")
+    lines.append("╚───────────────────────────────────────────────────────")
+
+    return RuleResult(severity="context", message="\n".join(lines))
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+
+def _read_json(path: Path) -> dict:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _list_dir_names(path: Path, glob: str = "*") -> list[str]:
+    if not path.exists():
+        return []
+    if glob == "*.md":
+        return sorted(f.stem for f in path.glob(glob))
+    return sorted(d.name for d in path.iterdir() if d.is_dir())
+
+
+def _available_skills(root: Path, profile: str) -> list[str]:
+    data = _read_json(root / "src" / "config" / "profiles" / f"{profile}.json")
+    return data.get("session_skills", [])
+
+
+def _available_workflows(root: Path, profile: str) -> list[dict]:
+    data = _read_json(root / "src" / "config" / "profiles" / f"{profile}.json")
+    return data.get("workflows", [])
+
+
+def _already_recorded(root: Path, session_id: str) -> bool:
+    store = root / WORKSPACE_DIR_NAME / "state" / "telemetry.jsonl"
+    if not store.exists():
+        return False
+    try:
+        for line in store.read_text(encoding="utf-8").splitlines():
+            try:
+                e = json.loads(line)
+                if e.get("event") == "session_start" and e.get("session_id") == session_id:
+                    return True
+            except (json.JSONDecodeError, TypeError):
+                continue
+    except OSError:
+        pass
+    return False
+
+
+def _load_learned_profile(root: Path) -> dict:
+    return _read_json(root / WORKSPACE_DIR_NAME / "state" / "learned_profile.json")
+
+
+def _render_profile_block(profile: dict) -> str | None:
+    if not profile:
+        return None
+    strong = ", ".join(profile.get("strong_patterns", [])[:3]) or "—"
+    weak = ", ".join(profile.get("weak_patterns", [])[:3]) or "—"
+    adoption = profile.get("higpertext_adoption_trend", 0)
+    topics = ", ".join(profile.get("commit_topics", [])[:4]) or "—"
+    best = profile.get("best_session_pattern", "—")
+    cost = profile.get("cost_per_commit_avg", 0.0)
+    return "\n".join(
+        [
+            "╔─ HIGPERTEXT  ·  Perfil aprendido ──────────────────────────",
+            f"│  Fortalezas    : {strong}",
+            f"│  Debilidades   : {weak}",
+            f"│  Adopción prom : {adoption}%",
+            f"│  Temas commits : {topics}",
+            f"│  Mejor patrón  : {best}",
+            f"│  Costo/commit  : ${cost:.4f} USD",
+            "╚───────────────────────────────────────────────────────",
+        ]
+    )
+
+
+def _skill_summary(skill_dir: Path) -> str:
+    md = skill_dir / "SKILL.md"
+    if not md.exists():
+        return ""
+    try:
+        for line in md.read_text(encoding="utf-8").splitlines()[1:]:
+            s = line.strip()
+            if s and not s.startswith("#"):
+                return s[:90]
+    except OSError:  # nosec B110
+        pass
+    return ""
+
+
+def handle_compact_command(root: Path) -> RuleResult:
+    """Genera el reporte de compactación y avisa de resetear el chat."""
+    session = _read_json(root / WORKSPACE_DIR_NAME / "state" / _SESSION_JSON)
+    env = _read_json(root / WORKSPACE_DIR_NAME / "config" / _ENVIRONMENT_JSON)
+    sid = session.get("session_id", "—")
+    profile = env.get("active_profile", "—")
+
+    changed_files = []
+    git_path = shutil.which("git") or "git"
+    try:
+        r = subprocess.run(
+            [git_path, "status", "--porcelain"],  # nosec B603 B607
+            capture_output=True,
+            text=True,
+            cwd=str(root),
+            timeout=5,
+        )
+        changed_files = [line[3:].strip() for line in r.stdout.splitlines() if line.strip()]
+    except (OSError, subprocess.SubprocessError):
+        pass
+
+    files_str = ", ".join(changed_files[:5]) or "Ninguno"
+    if len(changed_files) > 5:
+        files_str += f" y {len(changed_files) - 5} más"
+
+    msg = "\n".join(
+        [
+            "╔─ HIGPERTEXT  ·  Checkpoint de Compactación ──────────────",
+            f"│  Sesión Activa: {sid} ({profile})",
+            f"│  Archivos Modificados: {files_str}",
+            "│",
+            "│  ⚠  ¡REQUERIDO!: Guarda/actualiza acuerdos y estado clave",
+            "│     en '.memory/context.md' (o similar) antes de continuar.",
+            "│  → Una vez guardado, escribe '/clear' o usa el botón de",
+            "│    reseteo del chat para vaciar el historial redundante.",
+            "╚───────────────────────────────────────────────────────",
+        ]
+    )
+    return RuleResult(severity="context", message=msg)

higpertext/hooks/hook_tasks/_rules/telemetry_rules.py

@@ -0,0 +1,121 @@
+"""Reglas de observabilidad para tool calls (PostToolUse).
+
+Registra telemetría de tokens y actividad. Sin efectos de bloqueo.
+"""
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+RuleSeverity = Literal["continue", "context", "block"]
+
+
+@dataclass
+class RuleResult:
+    severity: RuleSeverity
+    message: str = ""
+
+
+# ── Regla 1: Registro de telemetría de tokens ─────────────────────────────────
+
+
+def record_telemetry(payload: dict, root: Path) -> RuleResult:
+    import higpertext.hooks.hook_tasks.telemetry_utils as telem
+
+    session = _read_json(root / WORKSPACE_DIR_NAME / "state" / "session.json")
+    sid = session.get("session_id", "unknown")
+
+    tool_name = payload.get("tool_name", "unknown")
+    tool_input = payload.get("tool_input", {})
+    tool_response = payload.get("tool_response", {})
+
+    input_str = json.dumps(tool_input, ensure_ascii=False)
+    output_str = json.dumps(tool_response, ensure_ascii=False)
+
+    cmd = (
+        (tool_input.get("command") or tool_input.get("CommandLine") or "")
+        if isinstance(tool_input, dict)
+        else ""
+    )
+    is_higpertext_call = "htx.py" in cmd and "task" in cmd
+
+    telem.tool_call(
+        root,
+        session_id=sid,
+        tool_name=tool_name,
+        input_chars=len(input_str),
+        output_chars=len(output_str),
+        is_higpertext_call=is_higpertext_call,
+    )
+
+    op_type, target, scope = _extract_activity(tool_name, tool_input, is_higpertext_call)
+    if op_type:
+        telem.activity(
+            root,
+            session_id=sid,
+            tool=tool_name,
+            op_type=op_type,
+            target=target,
+            scope=scope,
+            higpertext_related=is_higpertext_call,
+        )
+
+    return RuleResult(severity="continue")
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+
+def _rel(path_str: str) -> str:
+    try:
+        return str(Path(path_str).relative_to(os.getcwd()))
+    except ValueError:
+        return Path(path_str).name
+
+
+def _extract_activity(
+    tool: str, tool_input: dict, is_higpertext_call: bool
+) -> tuple[str, str, str]:
+    if not isinstance(tool_input, dict):
+        return "", "", ""
+
+    if tool == "Edit":
+        rel = _rel(tool_input.get("file_path", ""))
+        return "code-change", rel, str(Path(rel).parent)
+
+    if tool == "Write":
+        rel = _rel(tool_input.get("file_path", ""))
+        return "new-file", rel, str(Path(rel).parent)
+
+    if tool == "Read":
+        rel = _rel(tool_input.get("file_path", ""))
+        return "file-read", rel, str(Path(rel).parent)
+
+    if tool in ("Bash", "PowerShell"):
+        cmd = (tool_input.get("command") or tool_input.get("CommandLine") or "")[:100]
+        if is_higpertext_call:
+            parts = cmd.split()
+            try:
+                idx = parts.index("task")
+                cap = parts[idx + 1] if idx + 1 < len(parts) else cmd
+            except ValueError:
+                cap = cmd
+            return "higpertext-task", cap, "higpertext"
+        return "bash-cmd", cmd, "bash"
+
+    if tool == "Skill":
+        skill = tool_input.get("skill", tool_input.get("name", "unknown"))
+        return "skill-invoked", skill, "skill"
+
+    return "", "", ""
+
+
+def _read_json(path: Path) -> dict:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}

higpertext/hooks/hook_tasks/audit_logger_hook.py

@@ -0,0 +1,28 @@
+"""Hook PostToolUse — registra cada tool use en .higpertext/audit.log."""
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+
+import sys
+import json
+import datetime
+from higpertext.hooks.hook_tasks.hook_utils import get_project_root
+
+
+def main() -> None:
+    data = json.load(sys.stdin)
+    tool_name = data.get("tool_name", "unknown")
+    session_id = data.get("session_id", "")
+    timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
+
+    log_dir = get_project_root() / WORKSPACE_DIR_NAME
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / "audit.log"
+
+    entry = json.dumps({"ts": timestamp, "tool": tool_name, "session": session_id})
+    with log_file.open("a", encoding="utf-8") as f:
+        f.write(entry + "\n")
+
+    print(json.dumps({"continue": True}))
+
+
+if __name__ == "__main__":
+    main()

higpertext/hooks/hook_tasks/hook_bash_guard.py

@@ -0,0 +1,101 @@
+"""Hook PreToolUse:Bash — evalúa todas las reglas de comandos Bash en cadena."""
+
+from __future__ import annotations
+from higpertext.hooks.hook_tasks._rules.bash_rules import (
+    RuleResult,
+    is_whitelisted,
+    check_git_commit_block,
+    check_hard_blocks,
+    check_branch_protection,
+    check_deployment_gate,
+    check_ls_redirect,
+    check_grep_redirect,
+    check_git_redirect,
+    check_knowledge_redirect,
+    check_large_file_read_redirect,
+    check_list_rules,
+    check_load_rules,
+    check_exit_guard,
+    check_higpertext_enforcer,
+    check_profile_rules,
+)
+import higpertext.hooks.hook_tasks.telemetry_utils as telem
+from higpertext.hooks.hook_tasks.hook_utils import get_project_root
+from higpertext.hooks.hook_tasks.hook_io import (
+    hook_main,
+    read_payload,
+    read_tool_command,
+    emit_continue,
+    emit_context,
+    emit_block,
+)
+import sys
+from pathlib import Path
+
+_SRC = Path(__file__).resolve().parents[3]  # src/
+if str(_SRC) not in sys.path:
+    sys.path.insert(0, str(_SRC))
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+_RULES = [
+    check_git_commit_block,
+    check_hard_blocks,
+    check_branch_protection,
+    check_deployment_gate,
+    check_ls_redirect,
+    check_grep_redirect,
+    check_git_redirect,
+    check_knowledge_redirect,
+    check_large_file_read_redirect,
+    check_list_rules,
+    check_load_rules,
+    check_exit_guard,
+    check_higpertext_enforcer,
+    check_profile_rules,
+]
+
+
+@hook_main
+def main() -> None:
+    payload = read_payload()
+    cmd = read_tool_command(payload)
+
+    if is_whitelisted(cmd):
+        emit_continue()
+        return
+
+    root = get_project_root()
+    session_data = {}
+    try:
+        import json
+
+        session_data = json.loads(
+            (root / WORKSPACE_DIR_NAME / "state" / "session.json").read_text(encoding="utf-8")
+        )
+    except Exception:  # nosec B110
+        pass
+    sid = session_data.get("session_id", "unknown")
+
+    for rule_fn in _RULES:
+        result: RuleResult | None = rule_fn(cmd, root)
+        if result is None:
+            continue
+
+        if result.severity == "block":
+            telem.hook_intercept(root, sid, result.capability or "BLOCKED", cmd)
+            emit_block("PreToolUse", result.message)
+            return
+
+        if result.severity == "context":
+            telem.hook_intercept(root, sid, result.capability or "context", cmd)
+            emit_context("PreToolUse", result.message)
+            return
+
+    emit_continue()
+
+
+if __name__ == "__main__":
+    main()

higpertext/hooks/hook_tasks/hook_code_quality.py

@@ -0,0 +1,48 @@
+"""Hook PreToolUse:Write|Edit — evalúa calidad de código Python antes de escribir."""
+
+from __future__ import annotations
+from higpertext.hooks.hook_tasks._rules.quality_rules import (
+    check_code_length,
+    is_python_file,
+)
+from higpertext.hooks.hook_tasks.hook_utils import get_project_root
+from higpertext.hooks.hook_tasks.hook_io import (
+    hook_main,
+    read_payload,
+    emit_continue,
+    emit_context,
+)
+import sys
+from pathlib import Path
+
+_SRC = Path(__file__).resolve().parents[3]  # src/
+if str(_SRC) not in sys.path:
+    sys.path.insert(0, str(_SRC))
+
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+
+@hook_main
+def main() -> None:
+    payload = read_payload()
+    tool_name = payload.get("tool_name", "")
+    tool_input = payload.get("tool_input", {})
+
+    file_path = tool_input.get("file_path", "") or tool_input.get("path", "")
+    if tool_name not in ("Write", "Edit") or not is_python_file(file_path):
+        emit_continue()
+        return
+
+    root = get_project_root()
+    result = check_code_length(file_path, root)
+
+    if result is None:
+        emit_continue()
+        return
+
+    emit_context("PreToolUse", result.message)
+
+
+if __name__ == "__main__":
+    main()

higpertext/hooks/hook_tasks/hook_context_hint.py

@@ -0,0 +1,46 @@
+"""Hook UserPromptSubmit — sugiere context-assembler ante prompts de tarea.
+
+Entrega híbrida (parte ligera): detecta verbos de tarea e inyecta un índice
+de pocas líneas. El agente decide invocar la capability pesada si lo necesita.
+"""
+
+from __future__ import annotations
+import re
+from higpertext.hooks.hook_tasks.hook_io import (
+    hook_main,
+    read_payload,
+    emit_continue,
+    emit_context,
+)
+
+# Verbos que indican una tarea de ingeniería sobre el código.
+_TASK_VERBS = re.compile(
+    r"\b(refactoriz\w*|implement\w*|arregl\w*|corrig\w*|migr\w*|"
+    r"optimiz\w*|reestructur\w*|añad\w*|agreg\w*|crea\w+|"
+    r"refactor|implement|fix|bugfix|build|add)\b",
+    re.IGNORECASE,
+)
+
+_HINT = (
+    "╔─ HIGPERTEXT · Context Pack disponible ─────────────────────\n"
+    "│  Detecté una tarea de ingeniería. Para recibir contexto\n"
+    "│  curado (símbolos relevantes bajo presupuesto de tokens):\n"
+    '│  → htx task common.context-assembler --goal "<objetivo>" --type <refactor|feature|bugfix>\n'
+    "╚───────────────────────────────────────────────────────"
+)
+
+
+@hook_main
+def main() -> None:
+    payload = read_payload()
+    prompt = payload.get("prompt", "") or payload.get("user_prompt", "")
+
+    if not _TASK_VERBS.search(prompt):
+        emit_continue()
+        return
+
+    emit_context("UserPromptSubmit", _HINT)
+
+
+if __name__ == "__main__":
+    main()