{
  "permissions": {
    "deny": [
      "Read(.env)",
      "Read(no_leer.txt)",
      "Read(**/*.pem)",
      "Edit(.env)",
      "Bash(rm -rf *)",
      "Bash(DROP TABLE *)"
    ],
    "allow": [
      "Bash(npm run *)",
      "Bash(npx prisma *)",
      "Bash(git *)",
      "Read",
      "Edit",
      "Write"
    ]
  }
}

# CRM Proyecto - Instrucciones para Claude

## Stack
- Runtime: Node.js 20+ con TypeScript y React 19
- Framework: Next.js 16 (App Router)
- Estilos: Tailwind CSS v4
- ORM: Prisma con PostgreSQL (Neon DB)
- Pruebas: Vitest

## Comandos
- Dev server: `npm run dev`
- Build: `npm run build`
- DB generate: `npx prisma generate`
- Linter: `npm run lint`

## Convenciones
- Componentes de UI van en `src/components/` (usamos Lucide React para íconos)
- Lógica de backend y endpoints en `src/app/api/`
- Páginas de la app van en `src/app/`
- Componentes de servidor (RSC) por defecto. Usa `"use client"` solo si necesitas interactividad o hooks de React
- Las mutaciones a la base de datos se hacen usando Server Actions o en rutas de API

## Seguridad
- NUNCA commitear archivos `.env.local` ni secrets
- NUNCA retornar objetos Prisma completos al frontend, filtra datos sensibles
- Valida entradas de usuario antes de tocar la DB

# Convenciones de Testing

- Framework: Vitest + Supertest para tests de integración
- Cada test debe cubrir: happy path, errores, edge cases
- Nombrar tests descriptivamente:
  "should return 404 when product not found"
- Usar factories para datos de prueba, no hardcodear

# Dentro de una sesión de Claude Code:
/init
# Claude analizará tu proyecto y generará un CLAUDE.md base

# Nombrar la sesión actual
/rename bugfix-authentication

# Continuar la sesión más reciente
claude -c

# Seleccionar sesión para reanudar
claude -r

# Reanudar por nombre
claude --resume bugfix-authentication

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/block-risky-commands.sh"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/format.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT="$(cat)"
CMD="$(echo "$INPUT" | jq -r '.tool_input.command // empty')"

if echo "$CMD" | grep -Eq 'rm -rf|sudo rm'; then
  jq -n '{
    hookSpecificOutput: {
      hookEventName: "PreToolUse",
      permissionDecision: "deny",
      permissionDecisionReason: "Comando destructivo bloqueado por policy"
    }
  }'
  exit 0
fi

exit 0

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "file=$(jq -r '.tool_input.file_path // empty'); [ -n \"$file\" ] && npx prettier --write \"$file\" 2>/dev/null || true"
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "file=$(jq -r '.tool_input.file_path // empty'); if echo \"$file\" | grep -q 'prisma/schema.prisma'; then echo 'Blocked: No editar prisma/schema.prisma directamente.' >&2; exit 2; fi"
          }
        ]
      }
    ],
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code' 'Necesita tu atención' 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

---
name: "test-writer"
description: Genera tests unitarios e integración para componentes React y rutas API
model: sonnet
color: red
tools:
  - Read
  - Edit
  - Write
  - Bash
  - Glob
  - Grep
---

# Test Writer Agent

Especialista en escribir tests completos y confiables con Vitest + React Testing Library.

## Stack de Testing

- **Framework**: Vitest (con `vitest.config.ts`)
- **Testing Library**: React Testing Library para componentes
- **Assertions**: expect() de Vitest
- **HTTP Testing**: Supertest para rutas API
- **Cobertura mínima**: 80% de líneas

## Reglas de Testing

### Componentes React (`src/components/`)

- Renderizar sin errores (render + expect)
- Testear interacciones: clics, inputs, cambios de estado
- Usar `screen.getByRole()`, `getByTestId()` solo si necesario
- Mockear `next/navigation`: `useRouter`, `usePathname`, `useSearchParams`
- Mockear llamadas a APIs: fetch, POST, DELETE
- Evitar mockear la lógica interna (test del comportamiento, no la implementación)

### Rutas API (`src/app/api/`)

- Testear status codes (200, 404, 400, 500)
- Validar payload de request/response
- Mockear Prisma: `prismock` o manual `jest.mock()`
- Probar casos de error: registros no encontrados, validación fallida
- Usar Supertest: `request(app).get('/api/...')`

### Estructura de Archivos

```
src/
  components/
    Sidebar.tsx
  __tests__/
    components/
      Sidebar.test.tsx
    api/
      customers.test.ts
```

### Nombres Descriptivos

- ✅ "debe renderizar la tabla con filas de clientes"
- ✅ "retorna 404 cuando cliente no existe"
- ❌ "test 1", "works", "basic test"

## Proceso

1. **Leer el código**: Entiende el componente/ruta
   - Props, estado, efectos secundarios
   - Dependencias externas (APIs, librerías)

2. **Identificar escenarios**:
   - Happy path (caso exitoso)
   - Casos de error (validación, no encontrado)
   - Edge cases (entrada vacía, valores extremos)

3. **Escribir tests**:
   - Describe: agrupar tests por funcionalidad
   - It/test: un comportamiento por test
   - Arrange-Act-Assert pattern

4. **Mockear dependencias**:
   - Prisma: crear mock del cliente
   - APIs externas: mockear fetch/axios
   - Next.js: mockear `next/navigation`

5. **Ejecutar y validar**:
   - `npm run test` para ejecutar todos
   - `npm run test:watch` durante desarrollo
   - Verificar cobertura: `npm run test:coverage`

## Ejemplo: Componente

```tsx
// src/components/CustomerTable.test.tsx
import { render, screen } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { CustomerTable } from "./CustomerTable";

describe("CustomerTable", () => {
  it("debe renderizar tabla con clientes", () => {
    const customers = [{ id: "1", name: "Juan", email: "juan@example.com" }];
    render();
    expect(screen.getByText("Juan")).toBeInTheDocument();
  });

  it("debe llamar onDelete cuando se hace clic en eliminar", async () => {
    const onDelete = vi.fn();
    render(
      ,
    );
    await userEvent.click(screen.getByRole("button", { name: /eliminar/i }));
    expect(onDelete).toHaveBeenCalledWith("1");
  });
});
```

## Ejemplo: Ruta API

```ts
// src/app/api/customers/[id]/route.test.ts
import { describe, it, expect, beforeEach, vi } from "vitest";
import { GET } from "./route";

describe("GET /api/customers/[id]", () => {
  it("debe retornar cliente cuando existe", async () => {
    const response = await GET(
      new Request("http://localhost:3000/api/customers/123"),
      { params: { id: "123" } },
    );
    expect(response.status).toBe(200);
  });

  it("debe retornar 404 cuando cliente no existe", async () => {
    const response = await GET(
      new Request("http://localhost:3000/api/customers/999"),
      { params: { id: "999" } },
    );
    expect(response.status).toBe(404);
  });
});
```

---
name: "code-reviewer"
description: Revisa código buscando bugs, seguridad, performance y code smells
model: haiku
tools:
  - Read
  - Grep
  - Glob
  - Bash
color: green
---

# Code Reviewer Agent

Especialista en auditoría de código con enfoque en seguridad, calidad y performance.

## Áreas de Revisión

### 🔴 CRITICAL (Bloquea merge)

- **Seguridad**: SQL injection, XSS, CSRF, autenticación ausente
- **Datos sensibles**: secrets en código, logs de contraseñas
- **Crashes**: null dereferences, tipos incorrectos, missing null checks
- **DB**: N+1 queries, migraciones sin rollback, deadlocks

### 🟠 HIGH (Revisar antes de merge)

- **Bugs lógicos**: race conditions, estado inconsistente, edge cases
- **Performance**: queries sin índices, renders innecesarios, memory leaks
- **Code smells**: funciones >50 líneas, complejidad ciclomática >10
- **Testing**: rutas críticas sin tests, cobertura <60%

### 🟡 MEDIUM (Nice to have)

- **Duplicación**: código repetido, DRY violations
- **Naming**: variables confusas, funciones genéricas
- **Documentación**: APIs sin JSDoc, lógica no documentada
- **Imports**: unused, circular dependencies

### 🔵 LOW (Cosmético)

- **Estilo**: formatting, trailing spaces, imports no ordenados
- **Logging**: verbosidad, nivel de detalle
- **Comments**: obvios, desactualizados

## Proceso

1. **Recibir archivos/ruta**: Usuario indica qué revisar.
2. **Analizar línea por línea**: Buscar vulnerabilidades, performance issues, y code smells.
3. **Documentar hallazgos**: Generar un reporte claro por severidades.

# Query simple
claude -p "explica qué hace la función processPayment"

# Piping: analizar logs
cat error.log | claude -p "explica este error y sugiere la solución"

# Output JSON estructurado
claude -p "lista los endpoints de la API" --output-format json

# Limitar presupuesto
claude -p "revisa seguridad del proyecto" --max-budget-usd 2.00

# Linter semántico con Claude
git diff main --name-only -- '*.ts' | while read file; do
  cat "$file" | claude -p \
    "Busca bugs lógicos y vulnerabilidades. Formato: ARCHIVO:LINEA - PROBLEMA" \
    --output-format text --max-budget-usd 0.50
done

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]
  issue_comment:
    types: [created]

jobs:
  claude-review:
    if: |
      (github.event_name == 'pull_request') ||
      (github.event_name == 'issue_comment' &&
       contains(github.event.comment.body, '@claude'))
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
      issues: write
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          model: sonnet

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

// Forzar modo in-process (sin tmux)
{ "teammateMode": "in-process" }

// O desde la línea de comandos:
// claude --teammate-mode in-process

# Pedir a un teammate que se detenga
"Pide al teammate investigador que se detenga"

# Limpiar el equipo completo cuando termines
"Limpia el equipo"

# Esperar a que terminen antes de continuar
"Espera a que tus teammates completen sus tareas antes de continuar"

{
  "$schema": "https://opencode.ai/config.json",
  "model": "openai/gpt-oss-120b",
  "provider": {
    "openai": {
      "apiKey": "$OPENAI_API_KEY"
    }
  }
}

{
  "$schema": "https://opencode.ai/config.json",
  "model": "ollama/qwen2.5-coder:14b",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      }
    }
  }
}

# Reglas del proyecto

## Comandos
- Instalar: npm install
- Desarrollo: npm run dev
- Verificación: npm run lint && npm test

## Convenciones
- Mantén cambios pequeños y revisables.
- Antes de editar, explica el plan en máximo 5 bullets.
- Después de editar, ejecuta la verificación aplicable.
- Nunca incluyas secretos ni credenciales en archivos del repo.

## Criterios de entrega
- Resumen de cambios
- Comandos ejecutados
- Riesgos o trabajo pendiente

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp",
      "enabled": true
    },
    "sentry": {
      "type": "remote",
      "url": "https://mcp.sentry.dev/mcp",
      "oauth": {},
      "enabled": true
    },
    "Neon_db": {
      "type": "remote",
      "url": "https://mcp.neon.tech/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    },
    "github": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@modelcontextprotocol/server-github",
        "--GITHUB_PERSONAL_ACCESS_TOKEN",
        "xxxxxxxxxxxxxxxxxxxxxxxxx"
      ],
      "enabled": true
    },
    "sequential_thinking": {
      "type": "local",
      "command": ["npx", "-y", "@modelcontextprotocol/server-sequential-thinking"],
      "enabled": true
    }
  }
}

# Listar servidores MCP y estado de autenticación
opencode mcp list

# Autenticar un servidor remoto con OAuth
opencode mcp auth sentry

# Ver estado OAuth de servidores remotos
opencode mcp auth list

# Depurar conexión y flujo OAuth
opencode mcp debug sentry

# Cerrar sesión de un servidor
opencode mcp logout sentry

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp",
      "enabled": true
    }
  },
  "tools": {
    "context7_*": false
  },
  "agent": {
    "plan": {
      "tools": {
        "context7_*": true
      }
    }
  }
}

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "context7": {
      "type": "remote",
      "url": "https://mcp.context7.com/mcp",
      "enabled": true
    }
  }
}

npx ctx7 setup --opencode

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "github": {
      "type": "remote",
      "url": "https://api.githubcopilot.com/mcp/",
      "enabled": true
    }
  }
}

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "neon_pg": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@modelcontextprotocol/server-postgres",
        "{env:DATABASE_URL}"
      ],
      "enabled": true
    }
  }
}

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "sentry": {
      "type": "remote",
      "url": "https://mcp.sentry.dev/mcp",
      "oauth": {},
      "enabled": true
    }
  }
}

opencode mcp auth sentry

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "gh_grep": {
      "type": "remote",
      "url": "https://mcp.grep.app",
      "enabled": true
    }
  }
}

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "sequential_thinking": {
      "type": "local",
      "command": ["npx", "-y", "@modelcontextprotocol/server-sequential-thinking"],
      "enabled": true
    }
  }
}

my-skill/
├── SKILL.md       # requerido: metadata + instrucciones
├── scripts/       # opcional: comandos o utilidades ejecutables
├── references/    # opcional: documentación, guías, specs
├── assets/        # opcional: plantillas, ejemplos, recursos
└── ...            # opcional: archivos adicionales del workflow

---
name: review-pr
description: Revisa un PR y reporta riesgos, regresiones y faltantes de test.
license: MIT
compatibility: opencode
metadata:
  audience: developers
  workflow: code-review
---

# Review PR

Revisa el PR indicado por el usuario.

1. Resume los cambios clave.
2. Identifica bugs, regresiones y riesgos de seguridad.
3. Señala gaps de testing.
4. Entrega hallazgos por severidad con archivos afectados.
5. No modifiques archivos durante la revisión.

{
  "$schema": "https://opencode.ai/config.json",
  "agent": {
    "plan": {
      "permission": {
        "skill": {
          "docs-check": "allow",
          "db-migration": "ask"
        }
      }
    }
  }
}

# Buscar skills disponibles por palabra clave
npx skills search frontend
npx skills search design

# Instalar la skill de UI/UX y frontend de Anthropic
npx skills add https://github.com/anthropics/skills --skill frontend-design

# Verificar dentro de OpenCode
opencode
# Prompt: list installed skills
# Prompt: usa la skill frontend-design para revisar esta interfaz

{
  "$schema": "https://opencode.ai/config.json",
  "plugin": [
    "superpowers@git+https://github.com/obra/superpowers.git"
  ]
}