@cristiancorreau/forge 2.9.5 → 2.9.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cristiancorreau/forge",
-  "version": "2.9.5",
+  "version": "2.9.7",
   "description": "Agentic development framework — multi-runtime support for Claude Code, OpenCode, Codex and Kiro",
   "author": "Cristian Correa <cristian@socialweb.cl>",
   "license": "Apache-2.0",
@@ -28,7 +28,7 @@
     "build:all": "npm run build:assets && npm run build",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build:all",
-    "test": "node --test test/commands.test.mjs"
+    "test": "node --test test/commands.test.mjs test/assets.test.mjs"
   },
   "files": [
     "dist",

package/assets/adapters/claude-code/generate-claude-md.py

@@ -1,304 +0,0 @@
-#!/usr/bin/env python3
-# Copyright 2026 Cristian Correa — Apache License 2.0
-# https://github.com/cristiancorreau/forge
-"""
-Genera CLAUDE.md para un proyecto usando forge.
-
-Usage:
-  python3 .agentic/adapters/claude-code/generate-claude-md.py
-
-Lee project.yaml en la raíz y genera CLAUDE.md adaptado al stack del proyecto.
-Si ya existe un CLAUDE.md, muestra el diff antes de sobreescribir.
-
-Requiere: pyyaml
-"""
-import os
-import sys
-from pathlib import Path
-
-FORCE = "--force" in sys.argv
-
-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 _render_phases(config: dict) -> str:
-    sprint = config.get("sprint", {})
-    current = sprint.get("current", 1)
-    phases = sprint.get("phases", [])
-    if not phases:
-        return (
-            f"- **Sprint actual:** Sprint {current}\n"
-            "- **Completadas:** —\n"
-            "- **En curso:** —\n"
-            "- **Pendientes:** —"
-        )
-    lines = [f"- **Sprint actual:** Sprint {current}"]
-    for phase in phases:
-        pid = phase.get("id", "?")
-        name = phase.get("name", "")
-        specs = phase.get("specs", [])
-        status = phase.get("status", "pendiente")
-        spec_list = ", ".join(specs) if specs else "—"
-        lines.append(f"- **Fase {pid} — {name}** ({status}): {spec_list}")
-    return "\n".join(lines)
-
-
-_AGENT_TRIGGER = {
-    "orchestrator":        ("tareas multi-agente, análisis de >3 archivos, descomposición de features completas", None),
-    "backend-engineer":    ("endpoints, middleware, validaciones, lógica de negocio", "api"),
-    "api-engineer":        ("endpoints REST, middleware, validaciones, migraciones de BD", "api"),
-    "frontend-engineer":   ("componentes UI, páginas, estilos, integración con API", "frontend"),
-    "admin-engineer":      ("UI de gestión interna, dashboards de admin", "admin"),
-    "mobile-engineer":     ("pantallas móviles, navegación, stores de estado", "mobile"),
-    "fullstack-engineer":  ("features full-stack end-to-end que abarcan backend y frontend", None),
-    "test-engineer":       ("tests unitarios, integración, E2E — nunca código de producción", "tests"),
-    "docs-writer":         ("specs, ADRs, READMEs, documentación — nunca código de producción", "specs"),
-    "compliance-reviewer": ("revisión de PRs con PII, consentimientos, logs de auditoría", None),
-    "security-auditor":    ("auditoría de vulnerabilidades, revisión de dependencias, pentest", None),
-    "migration-specialist": ("migraciones de versión de framework (ej: L6→L13)", "migrations"),
-    "wp-engineer":         ("temas WordPress, FSE, Gutenberg, child themes", "frontend"),
-    "divi-engineer":       ("layouts Divi 5, módulos custom, Divi Builder", "frontend"),
-    "elementor-engineer":  ("templates Elementor Pro, widgets custom", "frontend"),
-    "scanner-engineer":    ("scraping, crawling, extracción estructurada de datos", "scanner"),
-}
-
-
-def _build_agent_scope_table(agents_cfg: dict, paths: dict) -> str:
-    active = agents_cfg.get("active", [])
-    compliance = agents_cfg.get("compliance", [])
-    agent_paths = {**(paths or {})}
-    rows = []
-    for agent in active + compliance:
-        trigger, path_key = _AGENT_TRIGGER.get(agent, ("implementación", None))
-        scope = agent_paths.get(path_key) if path_key else None
-        scope_str = f"`{scope}`" if scope else "`/`"
-        rows.append(f"| `{agent}` | {scope_str} | {trigger} |")
-    if not rows:
-        return ""
-    header = (
-        "## Agentes y su scope\n\n"
-        "| Agente | Scope | Cuándo usarlo |\n"
-        "|--------|-------|---------------|\n"
-    )
-    return header + "\n".join(rows) + "\n\n> Invocar el agente del scope correcto, no el orchestrator, para tareas acotadas.\n\n"
-
-
-def generate_claude_md(config: dict) -> str:
-    proj = config.get("project", {})
-    stack = config.get("stack", {})
-    team = config.get("team", {})
-    compliance_cfg = config.get("compliance", {})
-    agents_cfg = config.get("agents", {})
-    paths = config.get("paths", {})
-
-    name = proj.get("name", "Mi Proyecto")
-    description = proj.get("description", "")
-    language = proj.get("language", "typescript")
-    backend = stack.get("backend") or "N/A"
-    frontend = stack.get("frontend") or "N/A"
-    database = stack.get("database") or "N/A"
-    frameworks = compliance_cfg.get("frameworks", [])
-    specs_path = paths.get("specs", "docs/specs")
-    progress_path = paths.get("progress", "docs/progress.html")
-    agent_scope_section = _build_agent_scope_table(agents_cfg, paths)
-
-    # Agentes activos
-    active = agents_cfg.get("active", [])
-
-    # Comandos según lenguaje
-    if language == "typescript":
-        dev_cmd = "pnpm dev"
-        test_cmd = "pnpm test"
-        lint_cmd = "pnpm lint"
-        build_cmd = "pnpm build"
-    elif language == "python":
-        dev_cmd = "python manage.py runserver  # o uvicorn main:app"
-        test_cmd = "pytest"
-        lint_cmd = "ruff check ."
-        build_cmd = "# no aplica"
-    elif language == "ruby":
-        dev_cmd = "rails server"
-        test_cmd = "bundle exec rspec"
-        lint_cmd = "rubocop"
-        build_cmd = "# no aplica"
-    elif language == "go":
-        dev_cmd = "go run ./cmd/..."
-        test_cmd = "go test ./..."
-        lint_cmd = "golangci-lint run"
-        build_cmd = "go build ./..."
-    elif language == "php":
-        dev_cmd = "php artisan serve  # o php -S localhost:8000 -t public"
-        test_cmd = "vendor/bin/phpunit  # o ./vendor/bin/pest"
-        lint_cmd = "vendor/bin/phpstan analyse"
-        build_cmd = "composer install --no-dev --optimize-autoloader"
-    elif language == "mixed":
-        dev_cmd = "# ver documentación del proyecto (stack mixto)"
-        test_cmd = "# ver documentación del proyecto (stack mixto)"
-        lint_cmd = "# ver documentación del proyecto (stack mixto)"
-        build_cmd = "# ver documentación del proyecto (stack mixto)"
-    else:
-        dev_cmd = "# ver documentación del proyecto"
-        test_cmd = "# ver documentación del proyecto"
-        lint_cmd = "# ver documentación del proyecto"
-        build_cmd = "# ver documentación del proyecto"
-
-    compliance_section = ""
-    if frameworks:
-        compliance_section = f"""
-## Compliance activo
-
-Este proyecto opera bajo los siguientes marcos regulatorios:
-{chr(10).join(f'- **{f.upper()}**' for f in frameworks)}
-
-Reglas no-negociables:
-- Sin datos personales en logs de stdout
-- Consentimiento explícito antes de cualquier tracker no esencial
-- Logs de auditoría append-only (sin UPDATE/DELETE)
-- Derechos del titular implementados (acceso, rectificación, supresión, oposición, portabilidad)
-"""
-
-    return f"""# CLAUDE.md — {name}
-
-> Generado por forge. Actualizar project.yaml para cambiar la configuración.
-> Si actualizás el código de manera que invalide algo aquí, actualizá este archivo en el mismo PR.
-
-## Misión del proyecto
-
-{description}
-
-## Stack
-
-- **Lenguaje**: {language}
-- **Backend**: {backend}
-- **Frontend**: {frontend}
-- **Base de datos**: {database}
-- **Testing**: {", ".join(stack.get("testing", []))}
-
-{agent_scope_section}## Estructura
-
-```
-{proj.get("slug", "proyecto")}/
-├── CLAUDE.md                    ← Estás acá
-├── AGENTS.md                    ← Convenciones del agent team
-├── project.yaml                 ← Config de forge (fuente de verdad)
-├── {specs_path}/                ← Specs de features (requeridas antes de implementar)
-└── {progress_path}              ← Dashboard de progreso del proyecto
-```
-
-## Cómo trabajar (SDD)
-
-Cuando recibás una tarea:
-
-1. **Identificá la spec.** Si no está en `{specs_path}/`, pará y pedí que se cree.
-2. **Leé la spec correspondiente.**
-3. **Leé el `CLAUDE.md` del módulo** que vas a modificar (si existe).
-4. **Proponé opciones** para decisiones arquitectónicas no cubiertas por la spec.
-5. **Esperá aprobación** antes de generar código.
-6. **Tests** junto con la implementación, no al final.
-7. **Al terminar**, actualizá la spec con decisiones tomadas durante la implementación.
-8. **Antes de cerrar**: `{test_cmd}`, `{lint_cmd}`.
-{compliance_section}
-## Phases activas y estado
-
-{_render_phases(config)}
-
-> Actualizar `project.yaml` (sprint.phases) para reflejar el estado real.
-
-## Comandos frecuentes
-
-```bash
-{dev_cmd}     # Desarrollo
-{test_cmd}    # Tests
-{lint_cmd}    # Lint
-{build_cmd}   # Build
-```
-
-## Qué NO hacer
-
-- No implementar sin spec en `{specs_path}/`
-- No hardcodear tokens, passwords o secrets
-- No usar `any` en TypeScript sin comentario que explique por qué
-- No commits con `console.log` o `print` de depuración
-- No hacer force push a main/master
-"""
-
-
-def _generate_architecture_rules(root: Path, forge: Path, config: dict):
-    """Crea .claude/architecture.rules desde el template si no existe. Nunca sobreescribe."""
-    dst = root / ".claude" / "architecture.rules"
-    if dst.exists():
-        return
-
-    # Buscar el template en forge
-    tpl_path = forge / "core" / "templates" / "claude-md" / "architecture.rules"
-    if not tpl_path.exists():
-        return
-
-    project_name = config.get("project", {}).get("name", "Mi Proyecto")
-    content = tpl_path.read_text(encoding="utf-8")
-    content = content.replace("<NOMBRE_PROYECTO>", project_name)
-
-    dst.parent.mkdir(parents=True, exist_ok=True)
-    dst.write_text(content, encoding="utf-8")
-    print(f"[OK] .claude/architecture.rules — creado desde template")
-
-
-def _find_forge_dir(root: Path) -> Path:
-    """Localiza el directorio de forge relativo a este script."""
-    # Este script está en forge/adapters/claude-code/generate-claude-md.py
-    script_dir = Path(__file__).parent
-    # forge_dir = forge/
-    candidate = script_dir.parent.parent
-    if (candidate / "core").exists():
-        return candidate
-    # Fallback: buscar .agentic o forge en la raíz del proyecto
-    for name in (".agentic", "forge"):
-        c = root / name
-        if (c / "core").exists():
-            return c
-    return candidate
-
-
-def main():
-    try:
-        root = find_project_root()
-    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_claude_md(config)
-    output_path = root / "CLAUDE.md"
-
-    if output_path.exists() and not FORCE:
-        print(f"CLAUDE.md ya existe en {root}. Sobreescribir? [s/N] ", end="")
-        resp = input().strip().lower()
-        if resp not in ("s", "si", "sí", "y", "yes"):
-            print("Cancelado.")
-            sys.exit(0)
-
-    with open(output_path, "w") as f:
-        f.write(content)
-
-    print(f"CLAUDE.md generado en {output_path}")
-
-    forge = _find_forge_dir(root)
-    _generate_architecture_rules(root, forge, config)
-
-
-if __name__ == "__main__":
-    main()

package/assets/adapters/codex/generate-codex-config.py

@@ -1,269 +0,0 @@
-#!/usr/bin/env python3
-# Copyright 2026 Cristian Correa — Apache License 2.0
-# https://github.com/cristiancorreau/forge
-"""
-generate-codex-config.py — Genera AGENTS.md para Codex CLI (OpenAI).
-
-Usage:
-  python3 .agentic/adapters/codex/generate-codex-config.py
-
-Lee project.yaml en la raíz y genera AGENTS.md enriquecido para Codex CLI.
-
-Diferencias respecto al adapter OpenCode:
-  - Incluye sección "Workflow SDD" con pasos explícitos (Codex opera autónomamente)
-  - Incluye "Security rules" y "Autonomy limits" inline (crítico para ejecución sin supervisión)
-  - Header identifica el archivo como generado para Codex CLI
-
-Codex CLI lee AGENTS.md desde la raíz del repositorio como contexto del agente.
-Referencia: https://github.com/openai/codex
-
-Requiere: pyyaml
-"""
-from __future__ import annotations
-
-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 generate_agents_md(config: dict, forge: Path) -> str:
-    """
-    Genera AGENTS.md enriquecido para Codex CLI.
-
-    Codex CLI opera autónomamente en terminal: las reglas de seguridad y los
-    límites de autonomía deben estar inline en AGENTS.md, no en un archivo
-    separado, para que el agente las reciba como contexto en cada sesión.
-    """
-    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")
-    description = proj.get("description", "")
-    language = proj.get("language", "typescript")
-    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")
-
-    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 Codex CLI).",
-        f"> Fuente de verdad: `project.yaml`. Re-ejecutar `generate-codex-config.py` al cambiar agentes.",
-        "",
-    ]
-
-    if description:
-        lines += [description, ""]
-
-    lines += [
-        "## Stack",
-        "",
-        f"- **Lenguaje:** {language}",
-        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', []))}",
-        "",
-        "## Workflow: Spec-Driven Development",
-        "",
-        "Antes de implementar cualquier feature:",
-        "",
-        f"1. Verificar que existe una spec en `{specs_path}/`.",
-        "2. Si no existe, crearla y esperar aprobación antes de codificar.",
-        "3. Implementar con tests junto al código, no al final.",
-        "4. Actualizar la spec con decisiones tomadas durante la implementación.",
-        "",
-        "## Reglas de seguridad (no negociables)",
-        "",
-        "- Sin hardcodear tokens, passwords ni secrets — usar variables de entorno.",
-        "- Parámetros preparados en todas las queries SQL — nunca concatenar input del usuario.",
-        "- PII nunca en logs de stdout.",
-        "- Verificar autenticación Y autorización en cada endpoint de API.",
-        "- Sin force push a main/master.",
-        "",
-        "## Límites de autonomía",
-        "",
-        "- Modificar solo archivos dentro del scope declarado del agente.",
-        "- Preguntar antes de eliminar archivos o ejecutar comandos destructivos.",
-        "- Nunca hacer commit directo a main/master.",
-        "- Correr los tests antes de marcar una tarea como completa.",
-        "- Si una tarea requiere acceso a credenciales no disponibles, detenerse y reportar.",
-        "",
-        "## Roster de agentes",
-        "",
-    ]
-
-    if active:
-        lines += ["### Activos", ""]
-        for agent in active:
-            desc = read_agent_description(forge, agent, profiles)
-            lines.append(f"#### `{agent}`")
-            lines.append(desc)
-            lines.append("")
-
-    if compliance:
-        lines += ["### Compliance y revisión", ""]
-        for agent in compliance:
-            desc = read_agent_description(forge, agent, profiles)
-            lines.append(f"#### `{agent}`")
-            lines.append(desc)
-            lines.append("")
-
-    if specialized:
-        lines += ["### Especializados del proyecto", ""]
-        for agent in specialized:
-            desc = read_agent_description(forge, agent, profiles)
-            lines.append(f"#### `{agent}`")
-            lines.append(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)",
-            "",
-        ]
-
-    lines += [
-        "## Forge v2 Commands",
-        "",
-        "Codex CLI no soporta slash commands. Usa las plantillas de prompt de",
-        "`adapters/codex/commands/` copiando su contenido directamente en tu sesión.",
-        "",
-        "| Comando | Archivo | Cuándo usarlo |",
-        "|---------|---------|---------------|",
-        "| plan | `adapters/codex/commands/plan.md` | Antes de implementar — verifica o crea la spec |",
-        "| work | `adapters/codex/commands/work.md` | Implementar una feature con spec APPROVED |",
-        "| review | `adapters/codex/commands/review.md` | Revisar código o cambios antes del merge |",
-        "| ship | `adapters/codex/commands/ship.md` | Verificar que el proyecto está listo para deploy |",
-        "| session-start | `adapters/codex/commands/session-start.md` | Al iniciar cada sesión de trabajo |",
-        "| session-close | `adapters/codex/commands/session-close.md` | Al cerrar cada sesión de trabajo |",
-        "",
-        "### Flujo SDD recomendado",
-        "",
-        "```",
-        "1. session-start   → verificar ambiente y branch",
-        "2. plan            → spec antes que código (DRAFT → APPROVED)",
-        "3. work            → implementar con tests (spec APPROVED → IMPLEMENTED)",
-        "4. review          → checklist de seguridad y calidad",
-        "5. ship            → verificar build, tests y variables antes del deploy",
-        "6. session-close   → registrar progreso y limpiar",
-        "```",
-        "",
-        "## Reglas de producción (pre-bash-check)",
-        "",
-        "Los siguientes comandos están bloqueados en contexto de producción.",
-        "Si necesitás ejecutarlos, hacelo manualmente en la terminal con plena consciencia:",
-        "",
-        "- `--force-reset` — puede destruir datos de base de datos",
-        "- `prisma migrate reset` — borra y re-crea la base de datos",
-        "- `DROP TABLE` / `DROP DATABASE` — destruye tablas o bases de datos",
-        "- `TRUNCATE` — elimina todos los registros de una tabla",
-        "- `DELETE FROM <tabla>;` — sin cláusula WHERE, elimina todo",
-        "- `dropdb` — elimina una base de datos completa",
-        "- `rm -rf /` — elimina recursivamente desde la raíz",
-        "- `git push --force` sin `--with-lease` — sobreescribe historial remoto",
-        "",
-        "Contexto de producción = la URL de producción o el project_id aparecen",
-        "en el comando, o hay variables de entorno `PROD_*` / `PRODUCTION_*` activas.",
-        "",
-        "Lección del 2026-04-28: --force-reset borró 225 usuarios y 35 formularios",
-        "en producción. Estas reglas existen por eso.",
-        "",
-        "## Branch guard (pre-edit-check)",
-        "",
-        "No editar archivos de código fuente directamente en `main` o `master`.",
-        "",
-        "Archivos de código = `.py`, `.ts`, `.js`, `.tsx`, `.jsx`, `.php`, `.rb`,",
-        "`.go`, `.rs`, `.java`, `.cs`, `.cpp`, `.c`, `.sh`",
-        "",
-        "Excenciones permitidas en rama protegida:",
-        "- Archivos de documentación (`docs/`, `.md`)",
-        "- Archivos de configuración en raíz (`.yaml`, `.yml`, `.json`)",
-        "- `CLAUDE.md`, `AGENTS.md`, `README.md`, `CHANGELOG.md`",
-        "",
-        "Si estás en `main` o `master`, crea una feature branch primero:",
-        "```bash",
-        "git checkout -b feature/<tema>-$(date +%Y-%m-%d)",
-        "```",
-        "",
-    ]
-
-    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"  [OK]   AGENTS.md generado en {output_path}")
-    print("         (adapter Codex: incluye SDD workflow + security rules + autonomy limits)")
-
-
-if __name__ == "__main__":
-    main()