claude
 
> Implementa autenticación JWT
[Conversación interactiva]

import { ClaudeCode } from '@anthropic-ai/claude-code';
 
const agent = new ClaudeCode({
  model: 'claude-sonnet-4-20250514'
});
 
const result = await agent.run('Analiza este código');

# Terminal 1
claude
> Refactoriza src/auth/login.ts
 
# Terminal 2
claude
> Refactoriza src/auth/register.ts
 
# Terminal 3
claude
> Refactoriza src/auth/logout.ts

const files = ['login.ts', 'register.ts', 'logout.ts'];
 
for (const file of files) {
  await agent.run(`Refactoriza src/auth/${file}`);
}

// En GitHub Actions, GitLab CI, etc.
const codeReview = await agent.run('Revisa los cambios del PR');
await postComment(codeReview);

const securityAuditor = new ClaudeCode({
  systemPrompt: 'Eres un experto en seguridad. Busca vulnerabilidades OWASP.',
  model: 'claude-opus-4-5-20251101' // Modelo más potente
});
 
const performanceAnalyzer = new ClaudeCode({
  systemPrompt: 'Analiza rendimiento y sugiere optimizaciones.',
  model: 'claude-sonnet-4-20250514'
});

// 1. Planning
const plan = await planningAgent.run('Diseña arquitectura de auth');
 
// 2. Implementation
const code = await codeAgent.run(`Implementa según: ${plan}`);
 
// 3. Review
const review = await reviewAgent.run(`Revisa: ${code}`);
 
// 4. Testing
const tests = await testAgent.run('Genera tests');

# Como dependencia de proyecto
npm install @anthropic-ai/claude-code
 
# O global
npm install -g @anthropic-ai/claude-code

export ANTHROPIC_API_KEY="tu-api-key-aqui"

# .env
ANTHROPIC_API_KEY=tu-api-key-aqui

import dotenv from 'dotenv';
dotenv.config();

const agent = new ClaudeCode({
  apiKey: process.env.ANTHROPIC_API_KEY,
  model: 'claude-sonnet-4-20250514'
});

import { ClaudeCode } from '@anthropic-ai/claude-code';
 
const agent = new ClaudeCode({
  // Modelo a usar
  model: 'claude-sonnet-4-20250514',
 
  // System prompt (personaliza comportamiento)
  systemPrompt: 'Eres un experto en TypeScript y Node.js',
 
  // Tools disponibles
  tools: ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob'],
 
  // Configuración adicional
  maxTokens: 4096,
  temperature: 0.7
});

// Ejecución simple
const result = await agent.run('Analiza src/index.ts');
 
console.log(result.output);
// "Este archivo es el punto de entrada de la aplicación..."
 
// Ejecución con contexto
const result = await agent.run('Implementa validateEmail', {
  context: {
    files: ['src/utils/validators.ts'],
    CLAUDE_MD: './CLAUDE.md'
  }
});

const result = await agent.run('Genera reporte de cobertura', {
  // Working directory
  cwd: '/path/to/project',
 
  // Timeout (ms)
  timeout: 300000, // 5 minutos
 
  // Streaming de respuesta
  stream: true,
  onChunk: (chunk) => {
    process.stdout.write(chunk);
  }
});

const refactorAgent = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: `
    Eres un experto en refactoring de código.
 
    Principios que sigues:
    - DRY (Don't Repeat Yourself)
    - SOLID
    - Nombres descriptivos
    - Funciones pequeñas y enfocadas
 
    Siempre:
    - Explica qué cambios hiciste y por qué
    - Mantén los tests pasando
    - Prioriza legibilidad sobre brevedad
  `
});

const docAgent = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: `
    Generas documentación técnica clara y completa.
 
    Formato:
    - Markdown
    - Ejemplos de código funcionales
    - Casos de uso
    - Errores comunes y soluciones
 
    Audiencia: Desarrolladores con experiencia intermedia
  `
});

// Agente solo lectura
const readOnlyAgent = new ClaudeCode({
  tools: ['Read', 'Grep', 'Glob'],
  // NO puede usar Write, Edit, Bash
});
 
// Agente con permisos completos
const fullAgent = new ClaudeCode({
  tools: ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob']
});
 
// Agente de análisis (no modifica código)
const analyzerAgent = new ClaudeCode({
  tools: ['Read', 'Grep', 'Glob', 'Bash(git *)']
  // Puede leer y ejecutar git, pero no modificar archivos
});

// Tareas complejas: Opus
const complexAgent = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  maxTokens: 8192
});
 
// Tareas estándar: Sonnet
const standardAgent = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  maxTokens: 4096
});
 
// Tareas simples y rápidas: Haiku
const quickAgent = new ClaudeCode({
  model: 'claude-haiku-4-20250514',
  maxTokens: 2048
});

const result = await agent.run('Analiza src/auth/login.ts');
 
console.log(result);
/*
{
  output: "Análisis del archivo...",
  toolsUsed: [
    { tool: 'Read', args: { file_path: 'src/auth/login.ts' } },
    { tool: 'Grep', args: { pattern: 'function.*login' } }
  ],
  filesModified: [],
  tokensUsed: 1250,
  duration: 3200, // ms
  success: true
}
*/

const result = await agent.run('Implementa feature X');
 
if (result.success) {
  console.log('✅ Tarea completada');
  console.log(`Archivos modificados: ${result.filesModified.length}`);
} else {
  console.error('❌ Error:', result.error);
}

const result = await agent.run('Refactoriza módulo de auth');
 
if (result.filesModified.length > 0) {
  console.log('Archivos modificados:');
  result.filesModified.forEach(file => {
    console.log(`  - ${file}`);
  });
 
  // Ejecutar tests
  const testResult = await agent.run('Ejecuta tests relacionados');
}

import { ClaudeCode } from '@anthropic-ai/claude-code';
import { glob } from 'glob';
 
const migrationAgent = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: 'Experto en migración de JavaScript a TypeScript'
});
 
// Encontrar todos los archivos .js
const jsFiles = await glob('src/**/*.js');
 
console.log(`Migrando ${jsFiles.length} archivos...`);
 
for (const file of jsFiles) {
  console.log(`Migrando ${file}...`);
 
  const result = await migrationAgent.run(
    `Convierte ${file} a TypeScript. Mantén la funcionalidad exacta.`
  );
 
  if (result.success) {
    console.log(`  ✅ ${file} migrado`);
  } else {
    console.error(`  ❌ Error en ${file}:`, result.error);
  }
}
 
console.log('Migración completada');

import { ClaudeCode } from '@anthropic-ai/claude-code';
import { execSync } from 'child_process';
 
const reviewer = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: `
    Eres un code reviewer experimentado.
    Busca:
    - Bugs potenciales
    - Problemas de seguridad
    - Code smells
    - Violaciones de mejores prácticas
 
    Clasifica hallazgos como P1 (crítico), P2 (alto), P3 (medio), P4 (bajo)
  `
});
 
// Obtener archivos cambiados en el branch actual
const changedFiles = execSync('git diff --name-only main...HEAD')
  .toString()
  .trim()
  .split('\n')
  .filter(f => f.endsWith('.ts') || f.endsWith('.js'));
 
console.log(`Revisando ${changedFiles.length} archivos...`);
 
const reviews = [];
 
for (const file of changedFiles) {
  const result = await reviewer.run(`
    Revisa los cambios en ${file}
    Enfócate en issues de severidad P1 y P2
  `);
 
  reviews.push({
    file,
    review: result.output
  });
}
 
// Generar reporte
console.log('\n=== CODE REVIEW REPORT ===\n');
reviews.forEach(({ file, review }) => {
  console.log(`\n## ${file}\n`);
  console.log(review);
});

const testGenerator = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: 'Generas tests exhaustivos usando Vitest con patrón AAA'
});
 
const sourceFiles = await glob('src/**/*.ts', {
  ignore: ['**/*.test.ts', '**/*.spec.ts']
});
 
for (const sourceFile of sourceFiles) {
  // Verificar si ya tiene tests
  const testFile = sourceFile.replace('.ts', '.test.ts');
 
  if (fs.existsSync(testFile)) {
    console.log(`⏭️  ${sourceFile} ya tiene tests`);
    continue;
  }
 
  console.log(`Generando tests para ${sourceFile}...`);
 
  const result = await testGenerator.run(`
    Lee ${sourceFile} y genera tests completos en ${testFile}
 
    Incluye tests para:
    - Casos normales (happy path)
    - Casos edge
    - Manejo de errores
    - Validaciones
  `);
 
  if (result.success) {
    console.log(`  ✅ Tests generados en ${testFile}`);
  }
}

const depUpdater = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  tools: ['Read', 'Write', 'Bash']
});
 
const result = await depUpdater.run(`
  1. Lee package.json
  2. Identifica dependencias desactualizadas con npm outdated
  3. Para cada dependencia:
     - Busca breaking changes en changelog
     - Si no hay breaking changes, actualiza
     - Si hay breaking changes, anota para revisión manual
  4. Genera reporte de qué se actualizó y qué necesita revisión
`);
 
console.log(result.output);

claude
 
> Implementa login
[Claude responde]
 
> Ahora añade validación
[Claude responde basándose en contexto anterior]
 
> Genera tests
[Claude responde con contexto de toda la conversación]

// Cada ejecución es independiente (sin contexto conversacional)
await agent.run('Implementa login');
await agent.run('Añade validación'); // No recuerda el login anterior
await agent.run('Genera tests'); // No recuerda nada anterior

// Opción 1: Llamada única con todos los pasos
const result = await agent.run(`
  1. Implementa login
  2. Añade validación
  3. Genera tests
`);
 
// Opción 2: Pasar contexto explícito
const step1 = await agent.run('Implementa login');
 
const step2 = await agent.run('Añade validación', {
  context: {
    previousStep: step1.output,
    files: step1.filesModified
  }
});

// Esto puede ser costoso en batch grandes
for (let i = 0; i < 1000; i++) {
  await agent.run(`Procesa archivo ${i}`);
}

await agent.run(`
  Procesa estos archivos en batch:
  ${files.slice(0, 100).join('\n')}
`);

// ❌ Puede exceder rate limits
const promises = files.map(f => agent.run(`Procesa ${f}`));
await Promise.all(promises);
 
// ✅ Mejor: Controla concurrencia
import pLimit from 'p-limit';
const limit = pLimit(5); // Max 5 concurrentes
 
const promises = files.map(f =>
  limit(() => agent.run(`Procesa ${f}`))
);
await Promise.all(promises);

const result = await agent.run('Refactoriza todo el proyecto', {
  timeout: 600000 // 10 minutos
});

// Misma tarea puede dar resultados ligeramente diferentes
const result1 = await agent.run('Implementa login');
const result2 = await agent.run('Implementa login');
 
// result1.output !== result2.output (probablemente)

const agent = new ClaudeCode({
  temperature: 0.0, // Menos aleatorio
  // Pero nunca 100% determinista
});

import { ClaudeCode } from '@anthropic-ai/claude-code';
 
const agent = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: 'Comportamiento personalizado',
  tools: ['Read', 'Write', 'Bash']
});
 
const result = await agent.run('Tu tarea aquí');

import { ClaudeCode } from '@anthropic-ai/claude-code';
 
const researcher = new ClaudeCode({
  model: 'claude-opus-4-5-20251101', // Modelo más capaz
  systemPrompt: `
    Eres un investigador senior experto en sintetizar información.
 
    Tu proceso:
    1. Leer todas las fuentes proporcionadas
    2. Extraer puntos clave
    3. Identificar patrones y tendencias
    4. Generar síntesis clara y estructurada
 
    Formato de salida:
    - Resumen ejecutivo (3-5 párrafos)
    - Puntos clave (bullets)
    - Fuentes citadas
  `
});
 
const result = await researcher.run(`
  Investiga el estado actual de WebAssembly en 2026.
 
  Fuentes a consultar:
  - docs/wasm/intro.md
  - docs/wasm/performance.md
  - docs/wasm/use-cases.md
  - research/wasm-benchmarks.csv
 
  Genera reporte ejecutivo en docs/reports/wasm-2026.md
`);
 
console.log('✅ Reporte generado:', result.filesModified[0]);

# Estado de WebAssembly en 2026
 
## Resumen Ejecutivo
 
WebAssembly ha alcanzado madurez en 2026 con adopción mainstream...
[Síntesis completa]
 
## Puntos Clave
 
- Rendimiento 50% mejor que JavaScript en tareas CPU-intensive
- Soporte nativo en todos los navegadores modernos
- 73% de aplicaciones enterprise usan WASM para módulos críticos
 
## Fuentes
 
- docs/wasm/intro.md
- docs/wasm/performance.md
- ...

const documentor = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: `
    Generas documentación técnica clara, estructurada y útil.
 
    Principios:
    - Estructura lógica (introducción → desarrollo → conclusión)
    - Ejemplos concretos
    - Lenguaje claro sin jerga innecesaria
    - Formato Markdown
  `
});
 
// Generar documentación desde notas de reunión
await documentor.run(`
  Lee estas notas de reuniones:
  - meetings/2026-01-15-product-planning.md
  - meetings/2026-01-16-tech-discussion.md
  - meetings/2026-01-17-design-review.md
 
  Genera documento consolidado: docs/Q1-2026-product-roadmap.md
 
  Estructura:
  1. Visión general del producto
  2. Features prioritarias Q1
  3. Decisiones técnicas
  4. Próximos pasos
`);

const organizer = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: `
    Organizas archivos de forma lógica y mantenible.
 
    Criterios de organización:
    - Por tipo de contenido
    - Por fecha cuando es relevante
    - Por proyecto/categoría
    - Nomenclatura consistente
  `
});
 
await organizer.run(`
  Analiza todos los archivos en downloads/
 
  Organízalos en:
  - documents/work/ (archivos laborales)
  - documents/personal/ (archivos personales)
  - media/images/ (imágenes)
  - media/videos/ (videos)
  - archives/ (archivos antiguos >1 año)
 
  Criterios:
  - Infiere categoría por nombre y contenido
  - Mantén estructura por año/mes si es relevante
  - Renombra archivos con nombres descriptivos
  - Genera reporte de qué moviste donde
`);

const dataAnalyzer = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: `
    Analizas datos y generas insights accionables.
 
    Proceso:
    1. Explorar estructura de datos
    2. Identificar patrones y anomalías
    3. Calcular estadísticas relevantes
    4. Generar visualizaciones (scripts Python/R si es necesario)
    5. Presentar findings de forma clara
  `
});
 
await dataAnalyzer.run(`
  Analiza datos/ventas-2025.csv
 
  Genera reporte en reportes/analisis-ventas-2025.md con:
  1. Resumen estadístico (totales, promedios, máximos, mínimos)
  2. Tendencias temporales
  3. Productos más vendidos
  4. Anomalías o outliers
  5. Recomendaciones basadas en datos
 
  Si necesitas scripts de análisis, créalos en scripts/
`);

# Análisis de Ventas 2025
 
## Resumen Estadístico
 
- Total ventas: $2,450,000
- Promedio mensual: $204,166
- Mes más alto: Diciembre ($340,000)
- Mes más bajo: Enero ($125,000)
 
## Tendencias
 
!Gráfico de tendencia
 
- Crecimiento constante 12% YoY
- Picos en Q4 (temporada navideña)
- Caída en Q1 (patrón histórico)
 
## Recomendaciones
 
1. Aumentar inventario para Q4
2. Promociones agresivas en Q1 para compensar caída
3. Investigar por qué Producto X bajó 20% en ventas

const presentationMaker = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  systemPrompt: `
    Creas presentaciones impactantes y bien estructuradas.
 
    Principios:
    - Una idea clave por slide
    - Títulos descriptivos y accionables
    - Bullets concisos (max 5 por slide)
    - Storytelling: problema → solución → impacto
  `
});
 
await presentationMaker.run(`
  Crea presentación para inversores basada en:
  - business/business-plan.md
  - data/financial-projections.csv
  - research/market-analysis.md
 
  Genera: presentations/investor-deck-Q1-2026.md
 
  Estructura (10-12 slides):
  1. Problema que resolvemos
  2. Nuestra solución
  3. Mercado (TAM/SAM/SOM)
  4. Modelo de negocio
  5. Tracción actual
  6. Proyecciones financieras
  7. Equipo
  8. Competencia
  9. Ask (cuánto buscamos, para qué)
  10. Próximos hitos
 
  Formato: Markdown compatible con Marp o reveal.js
`);

const editor = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: `
    Editas y mejoras textos profesionales.
 
    Tareas:
    - Corregir gramática y ortografía
    - Mejorar claridad y estructura
    - Ajustar tono según audiencia
    - Sugerir mejoras de estilo
  `
});
 
// Mejorar email profesional
await editor.run(`
  Lee drafts/email-to-client.txt
 
  Mejora el email:
  - Tono: Profesional pero amigable
  - Claridad: Mensaje directo y claro
  - Estructura: Intro → Contexto → Request → Cierre
  - Correcciones: Gramática y estilo
 
  Guarda versión mejorada en drafts/email-to-client-final.txt
  Genera diff mostrando cambios en drafts/email-changes.md
`);
 
// Adaptar documento a diferentes audiencias
await editor.run(`
  Lee technical-spec.md
 
  Genera 3 versiones:
  1. Executive summary (para C-level)
  2. Technical deep-dive (para ingenieros)
  3. User-facing docs (para usuarios finales)
 
  Guarda en docs/audiences/
`);

const contentCreator = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: `
    Generas contenido engaging y optimizado para cada canal.
 
    Conoces:
    - SEO best practices
    - Estructura de blog posts efectivos
    - Longitud óptima por canal
    - Call-to-actions efectivos
  `
});
 
// Generar serie de blog posts
await contentCreator.run(`
  Basándote en research/product-features.md
 
  Genera 5 blog posts en blog/posts/:
  1. "Introducción a [Producto]: Lo que necesitas saber" (1000 palabras)
  2. "Cómo [Producto] resuelve [Problema común]" (800 palabras)
  3. "Guía paso a paso: Tu primer [Acción con producto]" (1200 palabras)
  4. "5 casos de uso reales de [Producto]" (900 palabras)
  5. "[Producto] vs Alternativas: Comparación completa" (1500 palabras)
 
  Cada post debe incluir:
  - Meta description (SEO)
  - Headings estructurados (H2, H3)
  - CTA al final
  - Keywords relevantes
`);
 
// Adaptar contenido para redes sociales
await contentCreator.run(`
  Lee blog/posts/product-launch.md
 
  Genera contenido para redes sociales en social-media/:
  - Twitter: 5 tweets (thread)
  - LinkedIn: Post profesional (300 palabras)
  - Instagram: Caption + 10 hashtags
  - Facebook: Post casual (200 palabras)
 
  Mantén mensaje central pero adapta tono a cada plataforma
`);

const adminAssistant = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: 'Automatizas tareas administrativas con precisión y eficiencia'
});
 
// Responder emails rutinarios
await adminAssistant.run(`
  Lee carpeta inbox/support-requests/
 
  Para cada email sin responder:
  1. Clasifica el tipo de request
  2. Si es FAQ común (consulta kb/faqs.md), genera respuesta
  3. Si requiere investigación, marca para revisión manual
  4. Genera drafts en inbox/draft-responses/
 
  Mantén tono amigable y profesional
`);
 
// Generar reportes semanales
await adminAssistant.run(`
  Genera reporte semanal basado en:
  - data/timesheets.csv (horas trabajadas)
  - data/tasks-completed.json (tareas completadas)
  - data/metrics.csv (métricas clave)
 
  Formato: reports/weekly-report-YYYY-MM-DD.md
 
  Incluye:
  - Resumen ejecutivo
  - Logros de la semana
  - Métricas clave
  - Blockers/issues
  - Plan para próxima semana
`);

const curator = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  systemPrompt: `
    Organizas y sintetizas conocimiento para fácil consulta.
 
    Creas:
    - Resúmenes ejecutivos
    - Tag system coherente
    - Relaciones entre conceptos
    - Knowledge base estructurado
  `
});
 
await curator.run(`
  Procesa todo en reading-list/:
 
  Para cada documento:
  1. Lee y extrae:
     - Idea principal
     - Conceptos clave (max 10)
     - Insights accionables
     - Citas destacadas
 
  2. Clasifica por:
     - Tema (tecnología, negocios, personal, etc.)
     - Tipo (tutorial, research, opinion, case study)
     - Nivel (beginner, intermediate, advanced)
 
  3. Genera knowledge base en kb/:
     - Estructura por tema/subtema
     - Índice searchable
     - Links cruzados entre contenido relacionado
 
  4. Crea kb/README.md con:
     - Cómo navegar el knowledge base
     - Índice por tema
     - Documentos más valiosos (top 10)
`);

const planner = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: `
    Ayudas a planificar y organizar proyectos y vida personal.
 
    Principios:
    - Metas SMART (Specific, Measurable, Achievable, Relevant, Time-bound)
    - Priorización (Eisenhower matrix)
    - Breakdown en tareas accionables
  `
});
 
// Planificación trimestral
await planner.run(`
  Basándote en goals/2026-annual-goals.md
 
  Crea plan detallado para Q1 2026:
 
  1. Desglose de objetivos anuales en metas trimestrales
  2. Para cada meta trimestral:
     - Milestones mensuales
     - Tareas semanales accionables
     - Métricas de éxito
     - Recursos necesarios
 
  3. Calendario de revisiones:
     - Review semanal (qué hacer)
     - Review mensual (qué hacer)
 
  Genera en plans/Q1-2026-plan.md
`);
 
// Organizar semana
await planner.run(`
  Lee:
  - calendar/meetings-this-week.ics
  - tasks/pending-tasks.md
  - goals/Q1-goals.md
 
  Genera schedule optimizado en plans/week-plan.md:
 
  - Bloques de tiempo para deep work
  - Preparación para meetings
  - Tareas según prioridad
  - Buffer time para imprevistos
  - Balance trabajo/vida
 
  Sugiere qué delegar o eliminar si hay sobrecarga
`);

const agent = new ClaudeCode({
  systemPrompt: 'Define expertise y comportamiento específico'
});

await agent.run(`
  1. Lee fuentes X, Y, Z
  2. Analiza según criterio A
  3. Genera output en formato B
  4. Guarda en ubicación C
`);

const draft = await agent.run('Genera primer borrador');
 
const improved = await agent.run(`
  Basándote en ${draft.filesModified[0]},
  mejora según feedback: ${userFeedback}
`);

// Script simple que cualquiera puede usar
const researcher = new ClaudeCode({ /* config */ });
await researcher.run('Tu tarea en lenguaje natural');

// Procesar 100 documentos con el mismo esfuerzo que 1
for (const doc of documents) {
  await agent.run(`Procesa ${doc}`);
}

// Mismo formato, mismo estándar de calidad
await curator.run('Procesa todos los artículos de la semana');

const agent = new ClaudeCode({
  systemPrompt: 'Define expertise',
  model: 'claude-sonnet-4-20250514'
});
 
await agent.run(`
  1. Lee [fuentes]
  2. Procesa según [criterio]
  3. Genera [output]
`);

Usuario: Implementa autenticación JWT
         ↓
Claude implementa directamente
         ↓
Problemas aparecen durante implementación
         ↓
Refactoring y cambios de diseño

Usuario: Implementa autenticación JWT
         ↓
Planning Agent: Diseña arquitectura
         ↓
Usuario revisa y aprueba plan
         ↓
Implementation Agent: Implementa según plan
         ↓
Menos problemas, mejor arquitectura

import { ClaudeCode } from '@anthropic-ai/claude-code';
 
const planningAgent = new ClaudeCode({
  model: 'claude-opus-4-5-20251101', // Modelo más capaz para planning
  systemPrompt: `
    Eres un arquitecto de software senior con 15 años de experiencia.
 
    Tu rol es diseñar soluciones técnicas antes de la implementación.
 
    Proceso que sigues:
    1. Analizar requisitos y restricciones
    2. Considerar múltiples enfoques
    3. Evaluar trade-offs
    4. Proponer arquitectura óptima
    5. Identificar riesgos y mitigaciones
    6. Crear plan de implementación detallado
 
    Principios que aplicas:
    - SOLID
    - DRY
    - KISS (Keep It Simple)
    - YAGNI (You Aren't Gonna Need It)
    - Separation of Concerns
 
    Output esperado:
    - Documento de diseño técnico
    - Diagrama de arquitectura (texto/mermaid)
    - Plan de implementación paso a paso
    - Identificación de riesgos
  `,
  tools: ['Read', 'Grep', 'Glob'] // Solo lectura, no implementa
});

const plan = await planningAgent.run(`
  Requisito: Sistema de autenticación JWT para API REST
 
  Contexto:
  - Backend: Node.js + Express
  - Base de datos: PostgreSQL
  - Frontend: React
 
  Restricciones:
  - Debe soportar refresh tokens
  - Tokens expiran en 15 minutos
  - Refresh tokens expiran en 7 días
  - Debe ser stateless
 
  Genera plan de arquitectura completo
`);
 
console.log(plan.output);

## Resumen Ejecutivo
 
Sistema de autenticación basado en JWT con refresh tokens para API REST.
Arquitectura stateless usando Redis para blacklist de tokens invalidados.

## Decisiones Arquitectónicas
 
### JWT vs Sessions
**Decisión:** JWT
**Razón:** Requisito de stateless, escalabilidad horizontal
 
### Almacenamiento de refresh tokens
**Decisión:** PostgreSQL con índice en user_id
**Razón:** Ya tenemos PostgreSQL, no justifica añadir Redis solo para esto
 
### Blacklist de tokens
**Decisión:** Redis con TTL
**Razón:** Alta performance para verificación rápida, expira automáticamente

## Arquitectura
 
┌─────────────┐
│   Cliente   │
└──────┬──────┘
       │
       │ 1. POST /auth/login
       ▼
┌─────────────────────────────────────┐
│         API Gateway                  │
│  ┌─────────────────────────────┐   │
│  │  Middleware de autenticación │   │
│  └─────────────────────────────┘   │
└──────┬───────────────────┬──────────┘
       │                   │
       │ 2. Valida JWT     │ 3. Si inválido,
       │                   │    verifica refresh
       ▼                   ▼
┌──────────┐         ┌────────────┐
│  Redis   │         │ PostgreSQL │
│ (Blacklist)       │  (Refresh  │
└──────────┘         │   Tokens)  │
                     └────────────┘

## Componentes
 
### 1. AuthController
**Responsabilidad:** Endpoints de autenticación
**Métodos:**
- POST /auth/login → Genera access + refresh token
- POST /auth/refresh → Genera nuevo access token
- POST /auth/logout → Invalida tokens
 
### 2. TokenService
**Responsabilidad:** Generación y validación de tokens
**Métodos:**
- generateAccessToken(userId)
- generateRefreshToken(userId)
- validateAccessToken(token)
- validateRefreshToken(token)
- invalidateToken(token)
 
### 3. AuthMiddleware
**Responsabilidad:** Proteger rutas
**Funcionalidad:**
- Extraer token de header
- Validar token
- Verificar blacklist
- Adjuntar user a request

## Plan de Implementación
 
### Fase 1: Configuración base (1-2 horas)
- [ ] Instalar dependencias (jsonwebtoken, bcrypt)
- [ ] Configurar variables de entorno (JWT_SECRET, etc.)
- [ ] Crear tabla refresh_tokens en DB
- [ ] Configurar conexión a Redis
 
### Fase 2: Token Service (2-3 horas)
- [ ] Implementar generateAccessToken()
- [ ] Implementar generateRefreshToken()
- [ ] Implementar validateAccessToken()
- [ ] Implementar validateRefreshToken()
- [ ] Implementar invalidateToken()
- [ ] Tests unitarios
 
### Fase 3: Auth Controller (2-3 horas)
- [ ] Endpoint POST /auth/login
- [ ] Endpoint POST /auth/refresh
- [ ] Endpoint POST /auth/logout
- [ ] Validación de inputs
- [ ] Manejo de errores
- [ ] Tests de integración
 
### Fase 4: Middleware (1-2 horas)
- [ ] Implementar authMiddleware
- [ ] Verificación de blacklist
- [ ] Tests
 
### Fase 5: Integración (1 hora)
- [ ] Proteger rutas existentes
- [ ] Tests end-to-end
- [ ] Documentación de API

## Riesgos
 
### Alto
- **Riesgo:** JWT_SECRET comprometido
  **Impacto:** Cualquiera puede generar tokens válidos
  **Mitigación:** Usar secreto fuerte, rotar periódicamente, guardar en secrets manager
 
### Medio
- **Riesgo:** Redis down = no se puede verificar blacklist
  **Impacto:** Tokens invalidados podrían ser usados
  **Mitigación:** Fallback a PostgreSQL, monitoreo de Redis
 
### Bajo
- **Riesgo:** Refresh tokens robados
  **Impacto:** Acceso prolongado no autorizado
  **Mitigación:** Detectar uso desde IPs diferentes, invalidar todos los tokens del usuario

const advancedPlanningAgent = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  systemPrompt: `
    Eres un arquitecto de software senior especializado en ${TECH_STACK}.
 
    SIEMPRE lees primero:
    - CLAUDE.md del proyecto (convenciones y arquitectura)
    - Código existente relacionado
    - Documentación de arquitectura
 
    Tu diseño debe:
    - Ser coherente con la arquitectura existente
    - Seguir las convenciones del proyecto
    - Reutilizar componentes existentes cuando sea posible
    - Minimizar cambios disruptivos
 
    NO propongas tecnologías nuevas a menos que sea absolutamente necesario.
  `
});
 
const contextualPlan = await advancedPlanningAgent.run(`
  Requisito: ${requirement}
 
  IMPORTANTE: Antes de diseñar, lee:
  1. CLAUDE.md
  2. Archivos en src/auth/ (para ver patterns existentes)
  3. docs/architecture.md
 
  Diseña solución que sea consistente con lo existente.
`);

const templateBasedAgent = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  systemPrompt: `
    Generas planes siguiendo el formato de Technical Design Doc de la empresa.
 
    Plantilla a seguir:
    1. Resumen (3-5 líneas)
    2. Contexto y problema
    3. Objetivos y no-objetivos
    4. Diseño propuesto
       4.1. Arquitectura
       4.2. Componentes
       4.3. APIs
       4.4. Data model
    5. Alternativas consideradas
    6. Riesgos y mitigación
    7. Plan de implementación
    8. Métricas de éxito
    9. Preguntas abiertas
 
    Usa formato Markdown con headings apropiados.
  `
});

const featureDesigner = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  systemPrompt: 'Diseñas features completas desde producto hasta implementación'
});
 
const featurePlan = await featureDesigner.run(`
  Feature: Sistema de notificaciones multi-canal
 
  Requisitos de producto:
  - Usuarios pueden recibir notificaciones por email, SMS, push
  - Usuarios configuran preferencias por tipo de notificación
  - Sistema debe ser extensible (agregar canales fácilmente)
  - Debe manejar 10,000 notificaciones/minuto
 
  Diseña:
  1. Arquitectura técnica
  2. Data model
  3. APIs necesarias
  4. Plan de implementación
  5. Estrategia de testing
  6. Plan de rollout (cómo desplegarlo gradualmente)
 
  Guarda plan en docs/designs/notifications-system.md
`);

const refactorPlanner = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  systemPrompt: 'Diseñas estrategias de refactoring minimizando riesgo'
});
 
await refactorPlanner.run(`
  Módulo a refactorizar: src/legacy/payment-processor/
 
  Problemas actuales:
  - Código spagueti (funciones de 500+ líneas)
  - Sin tests
  - Dependencias hardcodeadas
  - Difícil de mantener
 
  Lee todo el módulo y diseña plan de refactoring que:
  1. Identifique responsabilidades actuales
  2. Proponga nueva arquitectura modular
  3. Defina estrategia de migración incremental
  4. Minimice riesgo (cómo refactorizar sin romper producción)
  5. Plan de testing
  6. Métricas para validar que refactor fue exitoso
 
  Guarda en docs/designs/payment-processor-refactor.md
`);

const techEvaluator = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  systemPrompt: 'Evalúas tecnologías objetivamente considerando trade-offs'
});
 
await techEvaluator.run(`
  Decisión: Elegir ORM para nuevo proyecto
 
  Opciones:
  - Prisma
  - TypeORM
  - Sequelize
  - Kysely (query builder)
 
  Evalúa cada opción en:
  1. Type safety
  2. Performance
  3. Developer experience
  4. Ecosistema y soporte
  5. Curva de aprendizaje
  6. Casos de uso óptimos
 
  Genera comparación en docs/evaluations/orm-comparison.md
 
  Incluye:
  - Tabla comparativa
  - Recomendación con justificación
  - POC sugerido para validar decisión
`);

import { ClaudeCode } from '@anthropic-ai/claude-code';
 
// Agente 1: Planning
const planner = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  systemPrompt: 'Arquitecto de software senior',
  tools: ['Read', 'Grep', 'Glob']
});
 
// Agente 2: Implementation
const implementer = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: 'Implementas código siguiendo diseños técnicos al pie de la letra',
  tools: ['Read', 'Write', 'Edit', 'Bash']
});
 
// Paso 1: Generar plan
console.log('📋 Generando plan de arquitectura...');
const plan = await planner.run(`
  Requisito: ${requirement}
 
  Genera plan técnico completo en docs/designs/feature-x.md
`);
 
console.log('✅ Plan generado:', plan.filesModified[0]);
 
// Paso 2: Revisión humana
console.log('\n⏸️  Revisa el plan antes de continuar...');
await waitForUserApproval();
 
// Paso 3: Implementar según plan
console.log('\n🔨 Implementando según plan...');
const implementation = await implementer.run(`
  Lee el plan en ${plan.filesModified[0]}
 
  Implementa TODO lo descrito en el plan.
 
  Sigue el plan EXACTAMENTE:
  - Mismos nombres de archivos/componentes
  - Misma arquitectura
  - Mismo orden de implementación
 
  Ejecuta tests después de cada fase
`);
 
console.log('✅ Implementación completa');
console.log('Archivos creados/modificados:', implementation.filesModified);

// ❌ Mal: Planning agent con acceso a Write
const planner = new ClaudeCode({
  tools: ['Read', 'Write', 'Edit'] // Puede implementar
});
 
// ✅ Bien: Solo lectura
const planner = new ClaudeCode({
  tools: ['Read', 'Grep', 'Glob'] // Solo analiza
});

// Planning es tarea compleja → Opus
const planner = new ClaudeCode({
  model: 'claude-opus-4-5-20251101'
});
 
// Implementation puede usar Sonnet
const implementer = new ClaudeCode({
  model: 'claude-sonnet-4-20250514'
});

await planner.run(`
  Genera plan Y guárdalo en docs/designs/
 
  Formato Markdown, bien estructurado.
 
  El plan debe ser comprensible sin contexto adicional.
`);

const plan = await planner.run(task);
 
// SIEMPRE revisar antes de implementar
console.log('Plan generado. Por favor revisa antes de continuar.');
await askUserToReview(plan.filesModified[0]);
 
// Solo después de aprobación
const implementation = await implementer.run(`Implementa ${plan.filesModified[0]}`);

const PLANNING_AGENT_PROMPT = `
Eres [ROLE: arquitecto senior / tech lead / especialista en X].
 
## Tu proceso de planning:
1. [PASO 1: ej. Analizar requisitos]
2. [PASO 2: ej. Revisar código existente]
3. [PASO 3: ej. Considerar alternativas]
4. [PASO 4: ej. Proponer solución óptima]
5. [PASO 5: ej. Identificar riesgos]
 
## Principios que aplicas:
- [PRINCIPIO 1: ej. SOLID]
- [PRINCIPIO 2: ej. Keep it simple]
- [PRINCIPIO 3: ej. Consider scalability]
 
## Output esperado:
1. [SECCIÓN 1: ej. Resumen ejecutivo]
2. [SECCIÓN 2: ej. Arquitectura propuesta]
3. [SECCIÓN 3: ej. Plan de implementación]
4. [SECCIÓN 4: ej. Riesgos]
 
## Formato:
- Markdown estructurado
- Diagramas en Mermaid/ASCII cuando sea útil
- Guarda en [UBICACIÓN]
 
## Restricciones:
- [RESTRICCIÓN 1: ej. NO implementes, solo diseña]
- [RESTRICCIÓN 2: ej. Mantén consistencia con código existente]
`;
 
const planner = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  systemPrompt: PLANNING_AGENT_PROMPT
});

const planner = new ClaudeCode({
  model: 'claude-opus-4-5-20251101', // Modelo potente
  systemPrompt: 'Arquitecto senior...', // Define expertise
  tools: ['Read', 'Grep', 'Glob'] // Solo lectura
});

import { ClaudeCode } from '@anthropic-ai/claude-code';
 
// Agente 1: Planning
const planner = new ClaudeCode({
  model: 'claude-opus-4-5-20251101',
  systemPrompt: 'Arquitecto de software senior',
  tools: ['Read', 'Grep', 'Glob']
});
 
// Agente 2: Implementation
const implementer = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: 'Implementas código de producción con tests',
  tools: ['Read', 'Write', 'Edit', 'Bash']
});
 
// Agente 3: Code Reviewer
const reviewer = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: 'Reviewer estricto enfocado en bugs y security',
  tools: ['Read', 'Grep']
});
 
// Agente 4: Test Generator
const tester = new ClaudeCode({
  model: 'claude-sonnet-4-20250514',
  systemPrompt: 'Generas tests exhaustivos',
  tools: ['Read', 'Write', 'Bash']
});
 
async function buildFeatureWithPipeline(requirement) {
  console.log('🎯 Iniciando pipeline para:', requirement);
 
  // Paso 1: Planning
  console.log('\n📋 Fase 1: Planning');
  const planResult = await planner.run(`
    Diseña arquitectura para: ${requirement}
    Guarda plan en docs/designs/feature-plan.md
  `);
  console.log('✅ Plan generado');
 
  // Paso 2: Implementation
  console.log('\n🔨 Fase 2: Implementation');
  const implResult = await implementer.run(`
    Lee el plan en ${planResult.filesModified[0]}
    Implementa según el plan exactamente
  `);
  console.log('✅ Implementación completa');
 
  // Paso 3: Code Review
  console.log('\n🔍 Fase 3: Code Review');
  const reviewResult = await reviewer.run(`
    Revisa los archivos modificados:
    ${implResult.filesModified.join('\n')}
 
    Busca:
    - Bugs potenciales (P1)
    - Vulnerabilidades de seguridad (P1)
    - Code smells (P2)
 
    Guarda reporte en reviews/feature-review.md
  `);
  console.log('✅ Review completado');
 
  // Paso 4: Generar tests
  console.log('\n🧪 Fase 4: Tests');
  const testResult = await tester.run(`
    Para cada archivo implementado:
    ${implResult.filesModified.join('\n')}
 
    Genera tests completos siguiendo TDD best practices
  `);
  console.log('✅ Tests generados');
 
  // Paso 5: Ejecutar tests
  console.log('\n✓ Fase 5: Ejecutar tests');
  const testRunResult = await tester.run('Ejecuta npm test');
 
  if (testRunResult.output.includes('FAIL')) {
    console.log('❌ Tests fallaron, aplicando fixes...');
 
    const fixResult = await implementer.run(`
      Los tests fallaron con este output:
      ${testRunResult.output}
 
      Arregla los problemas y vuelve a ejecutar tests
    `);
  } else {
    console.log('✅ Todos los tests pasan');
  }
 
  console.log('\n🎉 Pipeline completado exitosamente');
 
  return {
    plan: planResult.filesModified[0],
    implementation: implResult.filesModified,
    review: reviewResult.filesModified[0],
    tests: testResult.filesModified
  };
}
 
// Uso
const result = await buildFeatureWithPipeline(
  'Sistema de notificaciones por email con templates'
);

async function parallelCodeReview(files) {
  // Crear agentes especializados
  const securityReviewer = new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: 'Experto en seguridad, busca vulnerabilidades OWASP'
  });
 
  const performanceReviewer = new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: 'Experto en performance, identifica optimizaciones'
  });
 
  const styleReviewer = new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: 'Experto en clean code, revisa legibilidad y mantenibilidad'
  });
 
  console.log('🔍 Ejecutando reviews en paralelo...');
 
  // Ejecutar todos en paralelo
  const [securityReport, perfReport, styleReport] = await Promise.all([
    securityReviewer.run(`Revisa seguridad de ${files.join(', ')}`),
    performanceReviewer.run(`Analiza performance de ${files.join(', ')}`),
    styleReviewer.run(`Revisa clean code en ${files.join(', ')}`)
  ]);
 
  console.log('✅ Reviews completados');
 
  return {
    security: securityReport.output,
    performance: perfReport.output,
    style: styleReport.output
  };
}
 
// Uso
const reports = await parallelCodeReview([
  'src/auth/login.ts',
  'src/auth/register.ts'
]);
 
console.log('📊 Reportes generados:');
console.log('Security issues:', reports.security);
console.log('Performance issues:', reports.performance);
console.log('Style issues:', reports.style);

class RefactorOrchestrator {
  constructor() {
    // Maestro: coordina y toma decisiones
    this.master = new ClaudeCode({
      model: 'claude-opus-4-5-20251101',
      systemPrompt: 'Coordinas refactoring, tomas decisiones de alto nivel',
      tools: ['Read', 'Grep', 'Glob']
    });
 
    // Trabajadores: ejecutan tareas específicas
    this.workers = {
      analyzer: new ClaudeCode({
        model: 'claude-sonnet-4-20250514',
        systemPrompt: 'Analizas código y detectas code smells'
      }),
      refactorer: new ClaudeCode({
        model: 'claude-sonnet-4-20250514',
        systemPrompt: 'Refactorizas código manteniendo funcionalidad'
      }),
      tester: new ClaudeCode({
        model: 'claude-sonnet-4-20250514',
        systemPrompt: 'Verificas que tests sigan pasando'
      })
    };
  }
 
  async refactorModule(modulePath) {
    console.log(`🔄 Refactoring module: ${modulePath}`);
 
    // Maestro analiza y crea plan
    console.log('\n📋 Maestro: Analizando módulo...');
    const plan = await this.master.run(`
      Analiza ${modulePath} y crea plan de refactoring:
      1. Lista archivos a refactorizar (en orden de dependencias)
      2. Para cada archivo, identifica qué refactorizar
      3. Define orden de ejecución
    `);
 
    const filesToRefactor = this.parseFilesFromPlan(plan.output);
 
    // Ejecutar refactoring archivo por archivo
    for (const file of filesToRefactor) {
      console.log(`\n🔨 Refactoring ${file}...`);
 
      // Worker 1: Analizar
      const analysis = await this.workers.analyzer.run(
        `Analiza ${file} y sugiere refactorings`
      );
 
      // Worker 2: Refactorizar
      const refactored = await this.workers.refactorer.run(`
        Refactoriza ${file} según estas sugerencias:
        ${analysis.output}
      `);
 
      // Worker 3: Verificar tests
      const testResult = await this.workers.tester.run(
        `Ejecuta tests relacionados a ${file}`
      );
 
      if (testResult.output.includes('FAIL')) {
        console.log('❌ Tests fallaron, revirtiendo...');
        // Lógica de rollback
        continue;
      }
 
      console.log(`✅ ${file} refactorizado exitosamente`);
    }
 
    console.log('\n🎉 Refactoring completado');
  }
 
  parseFilesFromPlan(planOutput) {
    // Lógica para extraer lista de archivos del plan
    // Simplificado para el ejemplo
    return ['file1.ts', 'file2.ts', 'file3.ts'];
  }
}
 
// Uso
const orchestrator = new RefactorOrchestrator();
await orchestrator.refactorModule('src/legacy/payment');

async function improveCodeQuality(file, targetQuality = 90) {
  const analyzer = new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: 'Analizas calidad de código y asignas score 0-100'
  });
 
  const improver = new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: 'Mejoras código priorizando máximo impacto'
  });
 
  let currentScore = 0;
  let iteration = 0;
  const maxIterations = 5;
 
  console.log(`🎯 Objetivo: Calidad ${targetQuality}/100`);
 
  while (currentScore < targetQuality && iteration < maxIterations) {
    iteration++;
    console.log(`\n🔄 Iteración ${iteration}`);
 
    // Analizar calidad actual
    const analysis = await analyzer.run(`
      Analiza ${file}
 
      Califica (0-100) en:
      - Legibilidad
      - Mantenibilidad
      - Testabilidad
      - Performance
      - Security
 
      Identifica los 3 problemas más críticos
    `);
 
    currentScore = this.extractScore(analysis.output);
    console.log(`📊 Score actual: ${currentScore}/100`);
 
    if (currentScore >= targetQuality) {
      console.log('✅ Objetivo alcanzado');
      break;
    }
 
    // Mejorar basándose en análisis
    console.log('🔨 Aplicando mejoras...');
    await improver.run(`
      Mejora ${file} enfocándote en los 3 problemas críticos identificados:
      ${analysis.output}
 
      Prioriza mejoras con mayor impacto en el score
    `);
 
    // Verificar tests
    const testResult = await improver.run('Ejecuta tests');
    if (testResult.output.includes('FAIL')) {
      console.log('❌ Mejoras rompieron tests, revirtiendo...');
      break;
    }
  }
 
  console.log(`\n🏁 Final score: ${currentScore}/100 en ${iteration} iteraciones`);
}

const agents = {
  frontend: new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: 'Experto en React, TypeScript, CSS. Creas componentes reutilizables'
  }),
 
  backend: new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: 'Experto en Node.js, Express, PostgreSQL. Creas APIs RESTful'
  }),
 
  database: new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: 'DBA experto. Diseñas schemas optimizados con índices apropiados'
  }),
 
  devops: new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: 'Experto en CI/CD, Docker, deployment automation'
  })
};
 
async function buildFullStackFeature(feature) {
  console.log(`🚀 Building full-stack feature: ${feature}`);
 
  // 1. Database schema
  console.log('\n💾 Database layer');
  const dbSchema = await agents.database.run(`
    Diseña schema de DB para ${feature}
    Crea migration en migrations/
  `);
 
  // 2. Backend API
  console.log('\n⚙️  Backend API');
  const api = await agents.backend.run(`
    Implementa API endpoints para ${feature}
    Usa el schema: ${dbSchema.filesModified[0]}
  `);
 
  // 3. Frontend components
  console.log('\n🎨 Frontend');
  const frontend = await agents.frontend.run(`
    Implementa componentes React para ${feature}
    Consume estos endpoints: ${api.filesModified.join(', ')}
  `);
 
  // 4. DevOps configuration
  console.log('\n🔧 DevOps');
  const devops = await agents.devops.run(`
    Configura deployment para ${feature}:
    - Docker compose para local dev
    - GitHub Actions workflow para CI/CD
  `);
 
  console.log('\n✅ Full-stack feature completado');
 
  return {
    database: dbSchema.filesModified,
    backend: api.filesModified,
    frontend: frontend.filesModified,
    devops: devops.filesModified
  };
}

async function chooseBestArchitecture(requirement) {
  // Crear 3 agentes con diferentes filosofías
  const architects = [
    new ClaudeCode({
      model: 'claude-opus-4-5-20251101',
      systemPrompt: 'Prefieres simplicidad y mantenibilidad (KISS, YAGNI)'
    }),
    new ClaudeCode({
      model: 'claude-opus-4-5-20251101',
      systemPrompt: 'Prefieres escalabilidad y performance'
    }),
    new ClaudeCode({
      model: 'claude-opus-4-5-20251101',
      systemPrompt: 'Prefieres flexibilidad y extensibilidad'
    })
  ];
 
  console.log('🏛️  Generando propuestas de arquitectura...');
 
  // Cada arquitecto propone su solución
  const proposals = await Promise.all(
    architects.map((architect, i) =>
      architect.run(`
        Diseña arquitectura para: ${requirement}
 
        Guarda tu propuesta en:
        docs/proposals/architecture-proposal-${i + 1}.md
      `)
    )
  );
 
  console.log('✅ 3 propuestas generadas');
 
  // Evaluador imparcial
  const evaluator = new ClaudeCode({
    model: 'claude-opus-4-5-20251101',
    systemPrompt: 'Evalúas arquitecturas objetivamente considerando trade-offs'
  });
 
  // Evaluar todas las propuestas
  const evaluation = await evaluator.run(`
    Evalúa estas 3 propuestas:
    ${proposals.map(p => p.filesModified[0]).join('\n')}
 
    Criterios:
    - Simplicidad (1-10)
    - Escalabilidad (1-10)
    - Mantenibilidad (1-10)
    - Performance (1-10)
    - Costo de implementación (1-10)
 
    Recomienda la mejor para el contexto: ${requirement}
 
    Guarda evaluación en docs/proposals/evaluation.md
  `);
 
  console.log('📊 Evaluación completa');
  return evaluation.filesModified[0];
}
 
// Uso
const bestArchitecture = await chooseBestArchitecture(
  'E-commerce platform para 1M usuarios'
);

class AgentOrchestrator {
  constructor(config) {
    this.agents = {};
    this.results = {};
    this.config = config;
  }
 
  registerAgent(name, agent) {
    this.agents[name] = agent;
  }
 
  async execute(workflow) {
    console.log('🎯 Iniciando workflow:', workflow.name);
 
    for (const step of workflow.steps) {
      console.log(`\n▶️  Ejecutando: ${step.name}`);
 
      // Verificar dependencias
      if (step.dependsOn) {
        const dependencies = step.dependsOn.map(dep => this.results[dep]);
        if (dependencies.some(d => !d)) {
          throw new Error(`Dependencia no satisfecha para ${step.name}`);
        }
      }
 
      // Ejecutar agente
      const agent = this.agents[step.agent];
      const result = await agent.run(step.task);
 
      // Guardar resultado
      this.results[step.name] = result;
 
      // Verificar condiciones de parada
      if (step.stopIf && this.evaluateCondition(step.stopIf, result)) {
        console.log('🛑 Condición de parada alcanzada');
        break;
      }
 
      console.log(`✅ ${step.name} completado`);
    }
 
    console.log('\n🎉 Workflow completado');
    return this.results;
  }
 
  evaluateCondition(condition, result) {
    // Evaluar condición basándose en resultado
    // Simplificado para el ejemplo
    return condition(result);
  }
}
 
// Uso
const orchestrator = new AgentOrchestrator();
 
orchestrator.registerAgent('planner', planningAgent);
orchestrator.registerAgent('implementer', implementationAgent);
orchestrator.registerAgent('tester', testingAgent);
 
const workflow = {
  name: 'Feature Development',
  steps: [
    {
      name: 'planning',
      agent: 'planner',
      task: 'Diseña arquitectura para feature X'
    },
    {
      name: 'implementation',
      agent: 'implementer',
      task: 'Implementa según plan',
      dependsOn: ['planning']
    },
    {
      name: 'testing',
      agent: 'tester',
      task: 'Genera y ejecuta tests',
      dependsOn: ['implementation'],
      stopIf: (result) => result.output.includes('FAIL')
    }
  ]
};
 
await orchestrator.execute(workflow);

// ❌ Demasiado complejo
const agentForEachFunction = files.map(file =>
  new ClaudeCode({ /* config */ })
);
 
// ✅ Un agente puede procesar múltiples archivos
const agent = new ClaudeCode({ /* config */ });
await agent.run(`Procesa estos archivos: ${files.join('\n')}`);

async function robustPipeline() {
  try {
    const step1 = await agent1.run(task1);
 
    const step2 = await agent2.run(task2);
 
    return { success: true, results: [step1, step2] };
  } catch (error) {
    console.error('Pipeline failed:', error);
 
    // Rollback o cleanup
    await cleanup();
 
    return { success: false, error };
  }
}

function logAgentExecution(agentName, task, result) {
  console.log(`[${new Date().toISOString()}] ${agentName}`);
  console.log(`Task: ${task}`);
  console.log(`Duration: ${result.duration}ms`);
  console.log(`Tokens: ${result.tokensUsed}`);
  console.log(`Files modified: ${result.filesModified.length}`);
}

import pLimit from 'p-limit';
 
const limit = pLimit(3); // Max 3 agentes concurrentes
 
const results = await Promise.all(
  tasks.map(task =>
    limit(() => agent.run(task))
  )
);

# .github/workflows/ai-code-review.yml
name: AI Code Review
 
on:
  pull_request:
    types: [opened, synchronize]
 
jobs:
  ai-review:
    runs-on: ubuntu-latest
 
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Necesario para diff
 
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
 
      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code
 
      - name: Run AI Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          node scripts/ai-review.js
 
      - name: Post review as comment
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review-output.md', 'utf8');
 
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: review
            });

import { ClaudeCode } from '@anthropic-ai/claude-code';
import { execSync } from 'child_process';
import fs from 'fs';
 
async function runCodeReview() {
  // Obtener archivos cambiados
  const changedFiles = execSync('git diff --name-only origin/main...HEAD')
    .toString()
    .trim()
    .split('\n')
    .filter(f => f.endsWith('.ts') || f.endsWith('.js'));
 
  console.log(`Revisando ${changedFiles.length} archivos...`);
 
  // Crear agente reviewer
  const reviewer = new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: `
      Eres un code reviewer experimentado.
 
      Enfócate en:
      - Bugs potenciales (P1)
      - Vulnerabilidades de seguridad (P1)
      - Performance issues (P2)
      - Code smells (P3)
 
      Formato de output: Markdown con headings por archivo
    `
  });
 
  // Ejecutar review
  const result = await reviewer.run(`
    Revisa estos archivos cambiados en el PR:
    ${changedFiles.join('\n')}
 
    Para cada archivo:
    1. Lee el diff completo (cambios específicos del PR)
    2. Identifica issues con severidad
    3. Sugiere mejoras
 
    Genera reporte en Markdown
  `);
 
  // Generar reporte formateado
  const report = `
## 🤖 AI Code Review
 
${result.output}
 
---
 
*Review automático generado por Claude Code*
*Modelo: claude-sonnet-4-20250514*
*Archivos revisados: ${changedFiles.length}*
  `;
 
  fs.writeFileSync('review-output.md', report);
  console.log('✅ Review completado');
}
 
runCodeReview().catch(console.error);

# .github/workflows/changelog.yml
name: Generate Changelog
 
on:
  release:
    types: [created]
 
jobs:
  changelog:
    runs-on: ubuntu-latest
 
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
 
      - name: Generate Changelog
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          npm install -g @anthropic-ai/claude-code
          node scripts/generate-changelog.js
 
      - name: Commit Changelog
        run: |
          git config user.name "github-actions[bot]"
          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add CHANGELOG.md
          git commit -m "docs: update changelog for ${{ github.event.release.tag_name }}"
          git push

import { ClaudeCode } from '@anthropic-ai/claude-code';
import { execSync } from 'child_process';
import fs from 'fs';
 
async function generateChangelog() {
  // Obtener commits desde último release
  const previousTag = execSync('git describe --tags --abbrev=0 HEAD^')
    .toString()
    .trim();
 
  const commits = execSync(`git log ${previousTag}..HEAD --pretty=format:"%h %s"`)
    .toString()
    .trim();
 
  const changelogAgent = new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: `
      Generas changelogs claros y bien organizados.
 
      Formato:
      ## [Version] - YYYY-MM-DD
 
      ### Added
      - Feature X
 
      ### Changed
      - Updated Y
 
      ### Fixed
      - Bug Z
 
      Agrupa commits relacionados.
      Usa lenguaje claro orientado a usuarios, no técnico.
    `
  });
 
  const result = await changelogAgent.run(`
    Genera entrada de changelog basándote en estos commits:
 
    ${commits}
 
    Version: ${process.env.GITHUB_REF_NAME}
    Fecha: ${new Date().toISOString().split('T')[0]}
  `);
 
  // Prepend al changelog existente
  let currentChangelog = '';
  if (fs.existsSync('CHANGELOG.md')) {
    currentChangelog = fs.readFileSync('CHANGELOG.md', 'utf8');
  }
 
  const newChangelog = result.output + '\n\n' + currentChangelog;
  fs.writeFileSync('CHANGELOG.md', newChangelog);
 
  console.log('✅ Changelog generado');
}
 
generateChangelog().catch(console.error);

# .github/workflows/breaking-changes.yml
name: Detect Breaking Changes
 
on:
  pull_request:
    branches: [main]
 
jobs:
  check-breaking:
    runs-on: ubuntu-latest
 
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
 
      - uses: actions/setup-node@v4
 
      - name: Check for Breaking Changes
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          npm install -g @anthropic-ai/claude-code
          node scripts/check-breaking-changes.js
 
      - name: Comment if breaking changes found
        if: failure()
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const analysis = fs.readFileSync('breaking-changes.md', 'utf8');
 
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## ⚠️ Breaking Changes Detected\n\n${analysis}`
            });

import { ClaudeCode } from '@anthropic-ai/claude-code';
import { execSync } from 'child_process';
import fs from 'fs';
 
async function checkBreakingChanges() {
  const changedFiles = execSync('git diff --name-only origin/main...HEAD')
    .toString()
    .trim()
    .split('\n');
 
  const analyzer = new ClaudeCode({
    model: 'claude-opus-4-5-20251101', // Modelo más capaz
    systemPrompt: `
      Analizas cambios de API para detectar breaking changes.
 
      Breaking changes incluyen:
      - Eliminar funciones/métodos públicos
      - Cambiar firma de funciones (parámetros, tipos de retorno)
      - Renombrar exports públicos
      - Cambiar comportamiento de APIs públicas
 
      Output:
      - Lista de breaking changes con severidad
      - Impacto estimado
      - Sugerencias de mitigación
    `
  });
 
  const result = await analyzer.run(`
    Analiza estos archivos para detectar breaking changes:
    ${changedFiles.join('\n')}
 
    Compara con la versión en origin/main
 
    Si encuentras breaking changes, detalla:
    1. Qué cambió
    2. Impacto (alto/medio/bajo)
    3. Sugerencias para migración
  `);
 
  if (result.output.includes('Breaking change')) {
    fs.writeFileSync('breaking-changes.md', result.output);
    console.error('❌ Breaking changes detectados');
    process.exit(1);
  } else {
    console.log('✅ No breaking changes');
  }
}
 
checkBreakingChanges().catch(console.error);

# .gitlab-ci.yml
stages:
  - review
  - test
  - deploy
 
ai-code-review:
  stage: review
  image: node:20
  before_script:
    - npm install -g @anthropic-ai/claude-code
  script:
    - node scripts/gitlab-review.js
  artifacts:
    reports:
      codequality: code-review.json
  only:
    - merge_requests
 
auto-documentation:
  stage: review
  image: node:20
  before_script:
    - npm install -g @anthropic-ai/claude-code
  script:
    - node scripts/generate-docs.js
  artifacts:
    paths:
      - docs/api/
  only:
    - main

// Jenkinsfile
pipeline {
  agent any
 
  environment {
    ANTHROPIC_API_KEY = credentials('anthropic-api-key')
  }
 
  stages {
    stage('Code Review') {
      steps {
        script {
          sh 'npm install -g @anthropic-ai/claude-code'
          sh 'node scripts/jenkins-review.js'
        }
      }
    }
 
    stage('Generate Docs') {
      when {
        branch 'main'
      }
      steps {
        script {
          sh 'node scripts/auto-docs.js'
        }
      }
    }
  }
 
  post {
    always {
      publishHTML([
        reportDir: 'reports',
        reportFiles: 'code-review.html',
        reportName: 'AI Code Review'
      ])
    }
  }
}

// scripts/generate-missing-tests.js
import { ClaudeCode } from '@anthropic-ai/claude-code';
import { glob } from 'glob';
import fs from 'fs';
 
async function generateMissingTests() {
  // Encontrar archivos sin tests
  const sourceFiles = await glob('src/**/*.ts', {
    ignore: ['**/*.test.ts', '**/*.spec.ts']
  });
 
  const testGenerator = new ClaudeCode({
    model: 'claude-sonnet-4-20250514',
    systemPrompt: 'Generas tests exhaustivos siguiendo TDD best practices'
  });
 
  const filesWithoutTests = sourceFiles.filter(file => {
    const testFile = file.replace('.ts', '.test.ts');
    return !fs.existsSync(testFile);
  });
 
  console.log(`Generando tests para ${filesWithoutTests.length} archivos...`);
 
  for (const file of filesWithoutTests) {
    await testGenerator.run(`
      Genera tests completos para ${file}
      Guarda en ${file.replace('.ts', '.test.ts')}
    `);
  }
 
  // Si se generaron tests, crear commit
  if (filesWithoutTests.length > 0) {
    execSync('git add .');
    execSync('git commit -m "test: add missing tests [skip ci]"');
    execSync('git push');
  }
}

// scripts/smart-dependency-update.js
async function smartDependencyUpdate() {
  const updater = new ClaudeCode({
    model: 'claude-opus-4-5-20251101',
    systemPrompt: 'Analizas actualizaciones de dependencias con enfoque en seguridad y compatibilidad'
  });
 
  await updater.run(`
    1. Ejecuta npm outdated
    2. Para cada dependencia desactualizada:
       a. Lee CHANGELOG en node_modules/[dep]/CHANGELOG.md
       b. Busca breaking changes
       c. Evalúa impacto de seguridad (CVEs)
    3. Categoriza en:
       - Seguras de actualizar (patch, no breaking)
       - Requieren revisión (minor con breaking)
       - Alto riesgo (major version)
    4. Actualiza solo las seguras
    5. Genera reporte de las pendientes
 
    Guarda reporte en dependency-update-report.md
  `);
 
  // Ejecutar tests después de actualizar
  const testResult = execSync('npm test').toString();
 
  if (testResult.includes('FAIL')) {
    console.log('❌ Tests fallaron después de actualizar deps');
    execSync('git checkout package.json package-lock.json');
  } else {
    console.log('✅ Dependencias actualizadas exitosamente');
  }
}