@cristiancorreau/forge 2.9.6 → 2.9.7

package/assets/adapters/opencode/generate-agents-md.py

@@ -1,262 +0,0 @@
-#!/usr/bin/env python3
-# Copyright 2026 Cristian Correa — Apache License 2.0
-# https://github.com/cristiancorreau/forge
-"""
-generate-agents-md.py — Genera AGENTS.md para OpenCode / Codex.
-
-Usage:
-  python3 .agentic/adapters/opencode/generate-agents-md.py
-
-Lee project.yaml en la raíz y genera AGENTS.md con el roster completo del equipo.
-OpenCode y Codex usan AGENTS.md como contexto de sistema para los agentes.
-
-Requiere: pyyaml
-"""
-import sys
-from pathlib import Path
-
-try:
-    import yaml
-except ImportError:
-    print("ERROR: pyyaml requerido. pip install pyyaml", file=sys.stderr)
-    sys.exit(1)
-
-
-def find_project_root() -> Path:
-    here = Path.cwd()
-    for p in [here] + list(here.parents):
-        if (p / "project.yaml").exists():
-            return p
-    raise FileNotFoundError("No se encontró project.yaml")
-
-
-def find_forge_dir() -> Path:
-    root = find_project_root()
-    for candidate in [root / ".agentic", root / "forge", Path(__file__).parent.parent.parent]:
-        if (candidate / "core").exists():
-            return candidate
-    raise FileNotFoundError("No se encontró el directorio forge con core/")
-
-
-def read_agent_description(forge: Path, name: str, profiles: list[str]) -> str:
-    """Lee el frontmatter description del agente desde forge (profiles > core)."""
-    for profile in profiles:
-        p = forge / "profiles" / profile / "agents" / f"{name}.md"
-        if p.exists():
-            content = p.read_text()
-            for line in content.splitlines():
-                if line.startswith("description:"):
-                    return line.split(":", 1)[1].strip().strip('"')
-    p = forge / "core" / "agents" / f"{name}.md"
-    if p.exists():
-        content = p.read_text()
-        for line in content.splitlines():
-            if line.startswith("description:"):
-                return line.split(":", 1)[1].strip().strip('"')
-    return "Agente de implementación"
-
-
-def _guardrail_section(config: dict) -> list[str]:
-    """Genera la sección de guardrails embebidos (equivalente a hooks de Claude Code)."""
-    proj = config.get("project", {})
-    mode = proj.get("mode", "startup")
-
-    lines = [
-        "## Guardrails (comportamiento no-negociable)",
-        "",
-        "Estas reglas se aplican siempre, en cualquier tarea, sin excepción.",
-        "",
-        "### Branch guard",
-        "",
-        "NUNCA editar código cuando la rama actual sea `main`, `master` o `develop`.",
-        "Antes de cualquier edición de archivo, verificar la rama con `git branch --show-current`.",
-        "Si la rama es main/master/develop: detener y pedir al usuario que cree una rama de feature.",
-        "Excepción: archivos de documentación (*.md) pueden editarse en main si el usuario lo indica explícitamente.",
-        "",
-        "### Detección de debug",
-        "",
-        "Antes de hacer commit, verificar que no haya en el código a commitear:",
-        "- `console.log(` en JS/TS (excepto archivos de logging)",
-        "- `print(` en Python que no sea logging de producción",
-        "- `debugger;` en JS/TS",
-        "- `binding.pry` en Ruby",
-        "- `dd(` o `dump(` en PHP",
-        "",
-        "Si se detectan estos patrones: reportar la línea exacta y pedir confirmación antes de continuar.",
-        "",
-        "### Producción safety",
-        "",
-        "Nunca ejecutar sin confirmación explícita del usuario:",
-        "- `DROP TABLE`, `DROP DATABASE`, `TRUNCATE` en bases de datos de producción",
-        "- `rm -rf` en directorios que no sean temporales o de build",
-        "- `git push --force` a main/master",
-        "- Deploy a producción sin haber ejecutado `/review` primero",
-        "",
-        "### SQL injection",
-        "",
-        "Nunca concatenar input del usuario en strings SQL.",
-        "Siempre usar parámetros preparados o el ORM del proyecto.",
-        "",
-        "### Secrets",
-        "",
-        "Nunca hardcodear tokens, passwords, API keys o certificados en archivos que van a git.",
-        "Usar variables de entorno y documentarlas en `.env.example`.",
-        "",
-    ]
-
-    if mode in ("standard", "enterprise"):
-        lines += [
-            "### Compliance (mode: " + mode + ")",
-            "",
-            "Verificar en cada PR que toque datos de usuarios:",
-            "- PII nunca en logs de stdout sin enmascarar",
-            "- Consentimiento explícito antes de cualquier tracker no esencial",
-            "- Logs de auditoría append-only (sin UPDATE/DELETE sobre eventos ya registrados)",
-            "",
-        ]
-
-    return lines
-
-
-def _forge_v2_commands_section() -> list[str]:
-    """Genera la sección de comandos Forge v2 SDD para OpenCode."""
-    return [
-        "## Comandos Forge v2 (flujo SDD)",
-        "",
-        "Este proyecto usa el flujo Spec-Driven Development de Forge v2.",
-        "Los comandos disponibles en `.opencode/commands/` son:",
-        "",
-        "| Comando | Cuándo usarlo |",
-        "|---------|--------------|",
-        "| `/session-start` | Al comenzar una sesión de trabajo — detecta branch, PRs abiertos y estado del repo |",
-        "| `/plan` | Para crear o revisar una spec en `docs/specs/` antes de implementar |",
-        "| `/work` | Para implementar una spec en estado `ready` — ejecuta en serie en la sesión actual |",
-        "| `/review` | Para hacer code review con veredicto APPROVED/CHANGES_REQUESTED/BLOCKED |",
-        "| `/ship` | Para hacer deploy a producción — requiere review aprobado y git limpio |",
-        "| `/session-close` | Al terminar una sesión — commit, daily note, RELEASE-NOTES y PR |",
-        "",
-        "**Flujo estándar:** `/session-start` → `/plan` → `/work` → `/review` → `/ship` → `/session-close`",
-        "",
-        "**Regla fundamental:** Sin spec en `docs/specs/` con estado `ready`, no se ejecuta `/work`.",
-        "",
-    ]
-
-
-def generate_agents_md(config: dict, forge: Path) -> str:
-    proj = config.get("project", {})
-    agents_cfg = config.get("agents", {})
-    compliance_cfg = config.get("compliance", {})
-    stack = config.get("stack", {})
-    paths = config.get("paths", {})
-
-    name = proj.get("name", "Mi Proyecto")
-    active = agents_cfg.get("active", [])
-    compliance = agents_cfg.get("compliance", [])
-    specialized = agents_cfg.get("specialized", [])
-    profiles = agents_cfg.get("profiles", [])
-    frameworks = compliance_cfg.get("frameworks", [])
-    specs_path = paths.get("specs", "docs/specs")
-
-    # Compliance-reviewer automático si hay frameworks
-    if frameworks and "compliance-reviewer" not in active + compliance:
-        compliance = list(set(compliance + ["compliance-reviewer"]))
-
-    lines = [
-        f"# AGENTS.md — {name}",
-        "",
-        f"> Generado por forge (adapter OpenCode/Codex).",
-        f"> Fuente de verdad: `project.yaml`. Re-ejecutar `generate-agents-md.py` al cambiar agentes.",
-        "",
-    ]
-
-    # Sección de comandos Forge v2 al inicio
-    lines += _forge_v2_commands_section()
-
-    lines += [
-        "## Stack del proyecto",
-        "",
-        f"- **Backend:** {stack.get('backend') or 'N/A'}",
-        f"- **Frontend:** {stack.get('frontend') or 'N/A'}",
-        f"- **Base de datos:** {stack.get('database') or 'N/A'}",
-        f"- **Testing:** {', '.join(stack.get('testing', []))}",
-        "",
-        "## Reglas globales (todos los agentes)",
-        "",
-        "- Specs en `" + specs_path + "/` primero — sin spec, sin código.",
-        "- Cada agente respeta su scope — no modifica archivos fuera de su dominio.",
-        "- Sin hardcodear tokens, passwords ni secrets.",
-        "- Parámetros preparados en todas las queries SQL.",
-        "- PII nunca en logs de stdout.",
-        "",
-    ]
-
-    # Guardrails embebidos (equivalente a hooks de Claude Code)
-    lines += _guardrail_section(config)
-
-    lines += [
-        "## Roster de agentes",
-        "",
-    ]
-
-    if active:
-        lines += ["### Agentes activos", ""]
-        for agent in active:
-            desc = read_agent_description(forge, agent, profiles)
-            lines.append(f"#### `{agent}`")
-            lines.append(f"{desc}")
-            lines.append("")
-
-    if compliance:
-        lines += ["### Agentes de compliance y revisión", ""]
-        for agent in compliance:
-            desc = read_agent_description(forge, agent, profiles)
-            lines.append(f"#### `{agent}`")
-            lines.append(f"{desc}")
-            lines.append("")
-
-    if specialized:
-        lines += ["### Agentes especializados del proyecto", ""]
-        for agent in specialized:
-            desc = read_agent_description(forge, agent, profiles)
-            lines.append(f"#### `{agent}`")
-            lines.append(f"{desc}")
-            lines.append("")
-
-    if frameworks:
-        lines += [
-            "## Compliance activo",
-            "",
-            f"Marcos regulatorios: {', '.join(f.upper() for f in frameworks)}",
-            "",
-            "Incluir `compliance-reviewer` en toda tarea que toque:",
-            "- Datos de usuarios o consentimientos",
-            "- Logs de auditoría",
-            "- Endpoints de derechos del titular (DSAR)",
-            "",
-        ]
-
-    return "\n".join(lines)
-
-
-def main():
-    try:
-        root = find_project_root()
-        forge = find_forge_dir()
-    except FileNotFoundError as e:
-        print(f"ERROR: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    with open(root / "project.yaml") as f:
-        config = yaml.safe_load(f)
-
-    content = generate_agents_md(config, forge)
-    output_path = root / "AGENTS.md"
-
-    with open(output_path, "w") as f:
-        f.write(content)
-
-    print(f"AGENTS.md generado en {output_path}")
-
-
-if __name__ == "__main__":
-    main()

package/assets/core/hooks/pre-bash-check.py

@@ -1,202 +0,0 @@
-#!/usr/bin/env python3
-"""
-Forge v2 — PreToolUse hook: pre-bash-check.py
-Bloquea comandos destructivos en contexto de producción.
-
-Contexto crítico: el 2026-04-28, --force-reset fue ejecutado accidentalmente
-contra la base de datos de producción de un proyecto real, borrando 225 usuarios
-y 35 formularios (recuperados desde backup de Supabase Pro). Este hook existe
-para que eso nunca vuelva a pasar.
-"""
-
-import json
-import os
-import re
-import sys
-
-
-DEBUG = os.environ.get("DEBUG", "") not in ("", "0", "false", "False")
-
-
-def dbg(msg):
-    if DEBUG:
-        print(f"[forge-hook-debug] {msg}", flush=True)
-
-
-def load_project_yaml():
-    """Walk up from cwd to find project.yaml. Returns dict or {}."""
-    try:
-        import yaml
-        path = os.getcwd()
-        for _ in range(6):
-            candidate = os.path.join(path, "project.yaml")
-            if os.path.isfile(candidate):
-                with open(candidate) as f:
-                    data = yaml.safe_load(f)
-                    return data if isinstance(data, dict) else {}
-            parent = os.path.dirname(path)
-            if parent == path:
-                break
-            path = parent
-    except Exception as e:
-        dbg(f"project.yaml load error: {e}")
-    return {}
-
-
-# ---------------------------------------------------------------------------
-# Patrones peligrosos hardcodeados
-# ---------------------------------------------------------------------------
-
-DANGEROUS_PATTERNS = [
-    (r"--force-reset",                              "--force-reset"),
-    (r"prisma\s+migrate\s+reset",                  "prisma migrate reset"),
-    (r"DROP\s+TABLE",                              "DROP TABLE"),
-    (r"TRUNCATE\s+",                               "TRUNCATE"),
-    (r"DELETE\s+FROM\s+\w+\s*;",                   "DELETE FROM sin WHERE"),
-    (r"DROP\s+DATABASE",                           "DROP DATABASE"),
-    (r"dropdb\s+",                                  "dropdb"),
-    (r"rm\s+-rf\s+/",                               "rm -rf /"),
-    (r"git\s+push\s+--force(?!\s+--with-lease)",   "git push --force sin --with-lease"),
-]
-
-
-def _match_dangerous(command: str) -> tuple[bool, str]:
-    """Retorna (matched, pattern_label). Verifica patrones hardcodeados."""
-    for pattern, label in DANGEROUS_PATTERNS:
-        if re.search(pattern, command, re.IGNORECASE):
-            return True, label
-    return False, ""
-
-
-def _match_project_forbidden(command: str, project: dict) -> tuple[bool, str]:
-    """Verifica patrones forbidden_in_production del project.yaml."""
-    try:
-        rules = project.get("rules", {})
-        forbidden = rules.get("forbidden_in_production", [])
-        if not isinstance(forbidden, list):
-            return False, ""
-        for pattern in forbidden:
-            if re.search(pattern, command):
-                return True, pattern
-    except Exception as e:
-        dbg(f"project.yaml forbidden_in_production error: {e}")
-    return False, ""
-
-
-def _is_production_context(command: str, project: dict) -> bool:
-    """
-    Retorna True si el comando se ejecuta en contexto de producción:
-    - La URL de producción aparece en el comando, o
-    - Variables de entorno PROD_* / PRODUCTION_* están seteadas en el proceso.
-    """
-    # URL de producción del project.yaml
-    deploy = project.get("deploy", {})
-    prod_url = deploy.get("production_url", "") or ""
-    project_id = deploy.get("project_id", "") or ""
-
-    if prod_url and prod_url in command:
-        dbg(f"production context: URL '{prod_url}' encontrada en comando")
-        return True
-    if project_id and project_id in command:
-        dbg(f"production context: project_id '{project_id}' encontrado en comando")
-        return True
-
-    # Variables de entorno que sugieren contexto de producción
-    prod_env_patterns = re.compile(r"^(PROD_|PRODUCTION_|PROD$|PRODUCTION$)", re.IGNORECASE)
-    for key, value in os.environ.items():
-        if prod_env_patterns.match(key) and value:
-            dbg(f"production context: env var '{key}' activa")
-            return True
-
-    return False
-
-
-def _extract_snippet(command: str, max_len: int = 120) -> str:
-    """Retorna un extracto legible del comando."""
-    command = command.strip()
-    if len(command) <= max_len:
-        return command
-    return command[:max_len] + "..."
-
-
-# ---------------------------------------------------------------------------
-# Main
-# ---------------------------------------------------------------------------
-
-def main():
-    try:
-        raw = sys.stdin.read()
-        if not raw.strip():
-            dbg("empty stdin, allowing")
-            sys.exit(0)
-        data = json.loads(raw)
-    except Exception as e:
-        dbg(f"stdin parse error: {e}")
-        sys.exit(0)
-
-    try:
-        tool_name = data.get("tool_name", "")
-        if tool_name != "Bash":
-            sys.exit(0)
-
-        tool_input = data.get("tool_input", {})
-        command = tool_input.get("command", "")
-        if not command:
-            sys.exit(0)
-
-        dbg(f"command: {command[:200]!r}")
-
-        project = load_project_yaml()
-
-        # Verificar patrones peligrosos hardcodeados
-        matched, pattern_label = _match_dangerous(command)
-
-        # Verificar patrones custom del project.yaml
-        if not matched:
-            matched, pattern_label = _match_project_forbidden(command, project)
-
-        if not matched:
-            sys.exit(0)
-
-        # Hay un patrón peligroso — ¿es contexto de producción?
-        in_production = _is_production_context(command, project)
-
-        snippet = _extract_snippet(command)
-
-        if in_production:
-            # BLOQUEAR
-            print(
-                f"forge: BLOQUEADO — comando destructivo detectado en contexto de producción.\n"
-                f"\n"
-                f"  Comando: {snippet}\n"
-                f"  Patrón: {pattern_label}\n"
-                f"\n"
-                f"  Si necesitás ejecutar esto, hacelo MANUALMENTE en la terminal\n"
-                f"  con plena consciencia de que afecta producción.\n"
-                f"\n"
-                f"  Lección del 2026-04-28: --force-reset borró 225 usuarios y\n"
-                f"  35 formularios en producción. Este hook existe por eso.",
-                flush=True,
-            )
-            sys.exit(2)
-        else:
-            # ADVERTIR — no bloquear
-            print(
-                f"forge: ADVERTENCIA — comando potencialmente destructivo detectado.\n"
-                f"\n"
-                f"  Comando: {snippet}\n"
-                f"  Patrón: {pattern_label}\n"
-                f"\n"
-                f"  Si esto apunta a producción, cancela y ejecuta manualmente.\n"
-                f"  Confirmá que el contexto es seguro antes de continuar.",
-                flush=True,
-            )
-            sys.exit(0)
-
-    except Exception as e:
-        dbg(f"unexpected error: {e}")
-        sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()