# Crea sesiones con nombre para diferentes proyectos
claude --session frontend "Trabajando en el frontend de React"
claude --session backend "Desarrollo de API backend"
claude --session devops "Infraestructura e implementación"

# Reanuda sesiones específicas con nombre
claude --resume frontend "Continuar el trabajo del frontend"
claude --resume backend "Verificar el rendimiento de la API"

# Lista todas las sesiones con nombre
claude sessions list --filter named

# Exporta y comparte configuraciones de sesión
claude sessions export frontend > frontend-session.json
claude sessions import frontend-session.json

# Crea una plantilla para el desarrollo de React
cat > ~/.claude/templates/react-dev.json << EOF
{
  "allowedTools": ["Edit", "View", "Bash(npm:*)", "Bash(git:*)"],
  "addDirectories": ["./src", "./test", "./docs"],
  "systemPrompt": "Eres un desarrollador senior de React. Sigue las mejores prácticas de TypeScript y concéntrate en el rendimiento y la accesibilidad.",
  "mcpServers": ["git", "filesystem"],
  "projectMemory": "Proyecto React TypeScript con pruebas Jest"
}
EOF

# Usa la plantilla para iniciar sesiones
claude --template react-dev "Iniciar sesión de desarrollo de React"

# Proyecto: Plataforma de Comercio Electrónico

## Resumen de la arquitectura
- **Frontend**: React 18 + TypeScript + Vite
- **Backend**: Node.js + Express + TypeScript
- **Base de datos**: PostgreSQL 14 con ORM Prisma
- **Cache**: Redis para almacenamiento de sesiones
- **Implementación**: Docker + Kubernetes en AWS

## Objetivos del sprint actual
- [ ] Implementar autenticación de usuario con JWT
- [ ] Agregar procesamiento de pagos con Stripe
- [ ] Configurar el pipeline de pruebas automatizadas
- [ ] Optimizar las consultas de la base de datos para la búsqueda de productos

## Estándares de desarrollo
- Usar TypeScript para todo el código nuevo
- Seguir la configuración ESLint + Prettier
- Escribir pruebas unitarias para toda la lógica de negocio
- Usar commits convencionales para los mensajes de git
- Implementar en staging antes que en producción

## Problemas conocidos
- El rendimiento de la búsqueda disminuye con > 10k productos
- El tiempo de espera de la sesión de usuario necesita configuración
- Limitación de la tasa del servicio de correo electrónico en producción

## Decisiones recientes
- Se cambió de REST a GraphQL para una mejor integración del frontend
- Se usa Tailwind CSS para la coherencia en el estilo
- Se implementan feature flags para despliegues graduales

# Actualiza la memoria del proyecto con los desarrollos recientes
claude /memory add "Se implementó el almacenamiento en caché de Redis para los resultados de búsqueda - 40% de mejora en el rendimiento"

# Establece el enfoque actual
claude /memory set-focus "Trabajando en el sistema de autenticación de usuarios esta semana"

# Agrega decisiones arquitectónicas
claude /memory add-decision "Uso de tokens JWT con vencimiento de 24h y rotación de tokens de actualización"

# Configuración global (~/.claude.json)
{
  "defaultModel": "claude-sonnet-4",
  "globalAllowedTools": ["View"],
  "globalDisallowedTools": ["Bash(rm:*)", "Bash(sudo:*)"],
  "theme": "dark-daltonized",
  "editorMode": "vim"
}

# Configuración de la organización (~/.claude/org-config.json)
{
  "extends": "~/.claude.json",
  "allowedTools": ["Edit", "View", "Bash(git:*)", "mcp__git__*"],
  "mcpServers": {
    "company-git": {
      "command": "company-git-server",
      "env": {"COMPANY_TOKEN": "${COMPANY_GIT_TOKEN}"}
    }
  },
  "auditLogging": true,
  "complianceMode": "SOC2"
}

# Configuración del proyecto (./claude-config.json)
{
  "extends": "~/.claude/org-config.json",
  "projectName": "ecommerce-platform",
  "allowedTools": ["Edit", "View", "Bash(npm:*)", "Bash(git:*)", "mcp__*"],
  "systemPrompt": "Estás trabajando en una plataforma de comercio electrónico. Concéntrate en la seguridad, el rendimiento y la experiencia del usuario.",
  "addDirectories": ["./src", "./tests", "./docs"],
  "mcpServers": {
    "project-db": {
      "command": "postgres-mcp-server",
      "env": {"DATABASE_URL": "${PROJECT_DATABASE_URL}"}
    }
  }
}

# Entorno de desarrollo
export CLAUDE_ENV=development
export CLAUDE_CONFIG_FILE=~/.claude/dev-config.json

# Entorno de staging
export CLAUDE_ENV=staging
export CLAUDE_CONFIG_FILE=~/.claude/staging-config.json

# Entorno de producción (solo lectura)
export CLAUDE_ENV=production
export CLAUDE_CONFIG_FILE=~/.claude/prod-config.json

# .github/workflows/claude-code-review.yml
name: Revisión de Código Claude

on:
  pull_request:
    branches: [main, develop]

jobs:
  claude-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Obtener historial completo para un mejor análisis

      - name: Configurar Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'

      - name: Instalar Código Claude
        run: npm install -g @anthropic-ai/claude-code

      - name: Ejecutar Revisión de Seguridad
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # Crear configuración segura para CI
          cat > ci-config.json << EOF
          {
            "allowedTools": ["View"],
            "outputFormat": "json",
            "verbose": false
          }
          EOF

          # Ejecutar análisis de seguridad
          claude --config ci-config.json \
            -p "Analice esta solicitud de extracción en busca de vulnerabilidades de seguridad, problemas de rendimiento y problemas de calidad del código. Concéntrese en los cambios en el directorio src/." \
            --output-format json > review-results.json

      - name: Publicar Comentarios de Revisión
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const results = JSON.parse(fs.readFileSync('review-results.json', 'utf8'));

            // Publicar resultados como comentario de PR
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## 🤖 Revisión de Código Claude\n\n${results.analysis}\n\n### Problemas de Seguridad: ${results.security_issues}\n### Problemas de Rendimiento: ${results.performance_issues}\n### Calidad del Código: ${results.code_quality}`
            });

# .gitlab-ci.yml
claude_review:
  image: node:18
  stage: review
  script:
    - npm install -g @anthropic-ai/claude-code
    - |
      claude --allowedTools "View" \
        -p "Revisar esta solicitud de fusión en busca de calidad de código y problemas de seguridad" \
        --output-format json > review.json
    - cat review.json
  artifacts:
    reports:
      junit: review.json
  only:
    - merge_requests

#!/bin/bash
# .git/hooks/pre-commit

# Obtener archivos en stage
staged_files=$(git diff --cached --name-only --diff-filter=ACM)

if [ -z "$staged_files" ]; then
    exit 0
fi

echo "🤖 Ejecutando análisis de código Claude en archivos en stage..."

# Crear archivo temporal con cambios en stage
git diff --cached > /tmp/staged_changes.diff

# Analizar con Claude
analysis=$(claude --allowedTools "View" \
    -p "Analice estos cambios de git en busca de problemas potenciales antes de commit. Concéntrese en: 1) Vulnerabilidades de seguridad 2) Calidad del código 3) Problemas de rendimiento 4) Cambios importantes. Devuelva JSON con niveles de severidad." \
    --output-format json < /tmp/staged_changes.diff)

# Analizar resultados
critical_issues=$(echo "$analysis" | jq -r '.critical_issues // []')
warning_issues=$(echo "$analysis" | jq -r '.warnings // []')

# Bloquear commit si se encuentran problemas críticos
if [ "$critical_issues" != "[]" ] && [ "$critical_issues" != "null" ]; then
    echo "❌ Problemas críticos encontrados:"
    echo "$critical_issues" | jq -r '.[]'
    echo "Commit bloqueado. Por favor, arregle los problemas críticos antes de commit."
    exit 1
fi

# Mostrar advertencias pero permitir commit
if [ "$warning_issues" != "[]" ] && [ "$warning_issues" != "null" ]; then
    echo "⚠️  Advertencias encontradas:"
    echo "$warning_issues" | jq -r '.[]'
    echo "Considere abordar estos problemas."
fi

echo "✅ Análisis pre-commit completo"
rm /tmp/staged_changes.diff

#!/bin/bash
# scripts/update-docs.sh

# Documentación de API automatizada
claude --allowedTools "View,Edit" \
    --add-dir ./src/api \
    "Actualizar la documentación de la API en docs/api.md basándose en las interfaces TypeScript actuales y las implementaciones de los puntos finales"

# Generar actualizaciones de README
claude --allowedTools "View,Edit" \
    "Actualizar README.md con el estado actual del proyecto, las instrucciones de instalación y los ejemplos de uso"

# Crear entradas de registro de cambios
git log --since="1 week ago" --pretty=format:"%h %s" | \
    claude -p "Generar entradas de registro de cambios a partir de estos commits de git. Concéntrese en los cambios de cara al usuario." \
    >> CHANGELOG.md

// custom-project-server.js
const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
const fs = require('fs');
const path = require('path');

class ProjectServer extends Server {
  constructor() {
    super({
      name: 'project-server',
      version: '1.0.0',
    });

    this.setupTools();
  }

  setupTools() {
    // Herramienta de estado del proyecto
    this.setRequestHandler('tools/list', async () => ({
      tools: [
        {
          name: 'get_project_status',
          description: 'Obtener el estado completo del proyecto, incluyendo git, dependencias y despliegue',
          inputSchema: {
            type: 'object',
            properties: {}
          }
        },
        {
          name: 'run_tests',
          description: 'Ejecutar pruebas de proyecto con el alcance especificado',
          inputSchema: {
            type: 'object',
            properties: {
              scope: { type: 'string', enum: ['unit', 'integration', 'e2e', 'all'] },
              coverage: { type: 'boolean', default: false }
            }
          }
        },
        {
          name: 'deploy_to_staging',
          description: 'Desplegar la rama actual en el entorno de staging',
          inputSchema: {
            type: 'object',
            properties: {
              branch: { type: 'string', default: 'main' },
              runMigrations: { type: 'boolean', default: true }
            }
          }
        }
      ]
    }));

    this.setRequestHandler('tools/call', async (request) => {
      const { name, arguments: args } = request.params;

      switch (name) {
        case 'get_project_status':
          return await this.getProjectStatus();
        case 'run_tests':
          return await this.runTests(args);
        case 'deploy_to_staging':
          return await this.deployToStaging(args);
        default:
          throw new Error(`Unknown tool: ${name}`);
      }
    });
  }

  async getProjectStatus() {
    // Implementación para el estado del proyecto
    const gitStatus = require('child_process').execSync('git status --porcelain').toString();
    const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));

    return {
      content: [{
        type: 'text',
        text: `Estado del Proyecto:
- Git: ${gitStatus ? 'Cambios sin confirmar' : 'Limpio'}
- Versión: ${packageJson.version}
- Dependencias: ${Object.keys(packageJson.dependencies || {}).length}
- Último commit: ${require('child_process').execSync('git log -1 --format="%h %s"').toString().trim()}`
      }]
    };
  }

  async runTests(args) {
    const { scope = 'all', coverage = false } = args;
    // Implementación para ejecutar pruebas
    // ...
  }

  async deployToStaging(args) {
    // Implementación para el despliegue
    // ...
  }
}

// Iniciar servidor
const server = new ProjectServer();
const transport = new StdioServerTransport();
server.connect(transport);

# Script avanzado para flujo de trabajo MCP
#!/bin/bash

echo "🚀 Iniciando flujo de trabajo de desarrollo..."

# 1. Verificar el estado del proyecto
claude --allowedTools "mcp__project__get_project_status" \
    "Obtener el estado actual del proyecto e identificar cualquier problema"

# 2. Ejecutar pruebas antes de comenzar a trabajar
claude --allowedTools "mcp__project__run_tests" \
    "Ejecutar pruebas unitarias para asegurar una base limpia"

# 3. Verificar vulnerabilidades de seguridad
claude --allowedTools "mcp__security__scan" \
    "Escanear el proyecto en busca de vulnerabilidades de seguridad"

# 4. Actualizar dependencias si es necesario
claude --allowedTools "mcp__npm__audit,mcp__npm__update" \
    "Verificar actualizaciones de dependencias y parches de seguridad"

# 5. Iniciar sesión de desarrollo
claude --allowedTools "Edit,View,mcp__git__*,mcp__project__*" \
    --add-dir ./src ./tests \
    "Listo para el desarrollo. El proyecto está limpio y probado."

# Limitar el contexto a directorios específicos
claude --add-dir ./src/components ./src/utils \
    "Enfocarse solo en componentes y utilidades"

# Usar consultas enfocadas
claude --allowedTools "View" \
    -p "Analizar solo el módulo de autenticación en busca de problemas de seguridad" \
    --context-files "src/auth/*.ts"

# Construcción progresiva del contexto
claude "Comenzar con una visión general de la estructura del proyecto"
# Luego, agregar contexto específico según sea necesario
claude "Ahora, enfóquese en el sistema de gestión de usuarios"

# Monitorear el rendimiento del código Claude
claude --profile --timing \
    "Analizar los cuellos de botella de rendimiento de la aplicación"

# Optimización del uso de tokens
export MAX_THINKING_TOKENS=30000  # Ajustar según las necesidades
claude --cost-tracking "Optimizar consultas de base de datos"

# Monitoreo del uso de memoria
claude --memory-usage --verbose \
    "Sesión de análisis de código base grande"

# Máxima información de depuración
claude \
    --verbose \
    --debug \
    --mcp-debug \
    --trace-all \
    --log-api-calls \
    --show-tokens \
    --cost-tracking \
    "Depurar un problema complejo de integración"

# Depuración selectiva
claude \
    --mcp-debug \
    --allowedTools "mcp__postgres__*" \
    "Depurar problemas de conectividad de la base de datos"

# Configuración de registro completa
export CLAUDE_LOG_LEVEL=debug
export CLAUDE_LOG_FILE=/var/log/claude/session.log
export CLAUDE_AUDIT_LOG=/var/log/claude/audit.log

# Monitoreo de registros en tiempo real
tail -f /var/log/claude/session.log | \
    claude -p "Monitorear estos registros en busca de errores y sugerir soluciones"

# Automatización del análisis de registros
cat /var/log/claude/session.log | \
    claude -p "Analizar registros en busca de patrones, errores y problemas de rendimiento. Generar informe resumido."

# Repositorio de configuración del equipo
git clone https://github.com/company/claude-configs.git ~/.claude/team

# Usar configuraciones del equipo
claude --config ~/.claude/team/frontend-config.json \
    "Iniciar sesión de desarrollo frontend"

# Compartir plantillas de sesión
cp ~/.claude/templates/react-dev.json \
   ~/.claude/team/templates/
git add . && git commit -m "Agregar plantilla de desarrollo de React"

# Generar documentación del equipo
claude --allowedTools "View,Edit" \
    "Crear documentación de incorporación para nuevos desarrolladores basada en la estructura y convenciones actuales del proyecto"

# Compartir guías de resolución de problemas
claude --allowedTools "View" \
    "Generar guía de resolución de problemas para problemas comunes de desarrollo en este proyecto"

# Crear registros de decisiones arquitectónicas
claude "Documentar la decisión de usar GraphQL en lugar de REST, incluyendo la justificación y los detalles de implementación"

# Flujo de trabajo de desarrollo de características de extremo a extremo
#!/bin/bash
feature_name=$1

echo "🎯 Iniciando el desarrollo de la característica: $feature_name"

# 1. Crear rama de característica
claude --allowedTools "mcp__git__*" \
    "Crear rama de característica para $feature_name"

# 2. Generar implementación inicial
claude --allowedTools "Edit,View" \
    "Generar implementación inicial para $feature_name basándose en los requisitos de REQUIREMENTS.md"

# 3. Escribir pruebas
claude --allowedTools "Edit,View" \
    "Crear pruebas exhaustivas para la característica $feature_name"

# 4. Ejecutar comprobaciones de calidad
claude --allowedTools "mcp__project__run_tests,mcp__lint__*" \
    "Ejecutar pruebas y linting para la nueva característica"

# 5. Generar documentación
claude --allowedTools "Edit,View" \
    "Actualizar la documentación para la nueva característica $feature_name"

# 6. Crear solicitud de extracción
claude --allowedTools "mcp__github__*" \
    "Crear solicitud de extracción para $feature_name con la descripción y los revisores adecuados"

echo "✅ Flujo de trabajo de desarrollo de características completado"

# Flujo de trabajo de despliegue progresivo
claude --config ~/.claude/deploy-config.json \
    --allowedTools "mcp__k8s__*,mcp__aws__*" \
    "Desplegar en el entorno de desarrollo y ejecutar pruebas de humo"

# Si tiene éxito, continuar a staging
claude --allowedTools "mcp__k8s__*,mcp__monitoring__*" \
    "Desplegar en staging y monitorear durante 10 minutos"

# Despliegue final de producción
claude --allowedTools "mcp__k8s__apply,mcp__monitoring__*" \
    "Desplegar en producción con estrategia azul-verde"

# Control de versiones de todas las configuraciones
git init ~/.claude
cd ~/.claude
git add .
git commit -m "Configuración inicial de Claude Code"
git remote add origin https://github.com/yourusername/claude-config.git
git push -u origin main

# Script de respaldo automatizado
#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR=~/.claude/backups

mkdir -p $BACKUP_DIR

# Respaldo de configuración
cp ~/.claude.json $BACKUP_DIR/claude-config-$DATE.json

# Respaldo de sesiones
claude sessions export --all > $BACKUP_DIR/sessions-$DATE.json

# Respaldo de memorias de proyecto
tar -czf $BACKUP_DIR/memories-$DATE.tar.gz ~/.claude/memories/

echo "Respaldo completado: $BACKUP_DIR"

# Script de migración de configuración
#!/bin/bash
OLD_VERSION=$1
NEW_VERSION=$2

echo "Migrando la configuración de Claude Code de $OLD_VERSION a $NEW_VERSION"

# Respaldo de la configuración actual
cp ~/.claude.json ~/.claude.json.backup

# Aplicar migración
claude config migrate --from $OLD_VERSION --to $NEW_VERSION

# Verificar migración
claude /doctor

echo "Migración completa. Verifique la salida de /doctor para problemas."