cmp-standards 2.0.0 → 2.4.0

package/standards/general/sync-workflow.md

@@ -0,0 +1,235 @@
+# Sync Inteligente - Adaptación de Estándares
+
+## Concepto
+
+El sync **NO es un script**. Es un proceso inteligente donde la IA:
+
+1. Lee estándares globales (este paquete)
+2. Analiza el proyecto local
+3. Adapta los estándares al contexto
+4. Actualiza CLAUDE.md local
+
+## Invocación
+
+```bash
+/sync
+```
+
+## Proceso de Sync
+
+### 1. Leer Estándares Globales
+
+La IA lee los estándares de `cmp-standards`:
+
+```
+standards/
+├── general/      → Cómo trabajar
+├── mcp/          → Cómo crear MCP servers
+├── tools/        → Cómo diseñar tools
+├── skills/       → Cómo crear skills
+└── experts/      → Cuándo consultar expertos
+```
+
+### 2. Analizar Proyecto Local
+
+La IA examina:
+
+```
+Estructura:
+- src/
+- package.json
+- tsconfig.json
+- CLAUDE.md (existente)
+
+Tech Stack:
+- Framework (Next.js, Remix, etc.)
+- ORM (Drizzle, Prisma, etc.)
+- Styling (Tailwind, CSS Modules, etc.)
+
+Patrones:
+- Estructura de carpetas
+- Convenciones de naming
+- Tests existentes
+```
+
+### 3. Adaptar Estándares
+
+**NO copiar literalmente**. Adaptar al contexto:
+
+```markdown
+# Ejemplo: Estándar Global
+"Usar Drizzle ORM con filtro de sistema"
+
+# Adaptación para Proyecto sin Multi-tenancy
+"Usar Drizzle ORM" (sin filtro de sistema)
+
+# Adaptación para Proyecto con Prisma
+Omitir - no aplica a este proyecto
+```
+
+### 4. Actualizar CLAUDE.md
+
+Generar/actualizar CLAUDE.md local con:
+
+```markdown
+# CLAUDE.md
+
+## Proyecto: [nombre]
+
+> [descripción breve]
+
+## Tech Stack
+[detectado del proyecto]
+
+## Reglas Específicas
+[adaptadas de estándares globales]
+
+## Workflow
+[recordatorio de cómo trabajar]
+
+## Expertos
+[cuándo consultar /experts]
+```
+
+## Qué SIEMPRE incluir
+
+Independiente del proyecto, siempre recordar:
+
+### Workflow Básico
+
+```markdown
+## Cómo Trabajar
+
+1. **Planificar** - Usar TodoWrite para tareas
+2. **Ejecutar** - Una tarea a la vez
+3. **Verificar** - Typecheck y tests
+4. **Aprender** - Registrar en memoria
+```
+
+### Consulta a Expertos
+
+```markdown
+## Expertos
+
+Consultar /experts cuando:
+- Código financiero
+- Autenticación/autorización
+- Cambios de schema
+- Refactoring grande
+```
+
+### Memory
+
+```markdown
+## Memory
+
+- Registrar tareas al empezar
+- Capturar aprendizajes
+- Documentar decisiones
+```
+
+## Qué ADAPTAR por Proyecto
+
+### Base de Datos
+
+```markdown
+# Si usa Drizzle + MySQL compartida
+## Database
+- Filter by system='PROJECT_NAME'
+- Use transactions for multiple ops
+
+# Si usa Prisma local
+## Database
+- Standard Prisma queries
+- Use $transaction for atomicity
+```
+
+### Testing
+
+```markdown
+# Si tiene Vitest
+## Testing
+npm run test
+
+# Si tiene Jest
+## Testing
+npm test
+
+# Si no tiene tests
+## Testing
+Consider adding tests for critical paths
+```
+
+### Linting
+
+```markdown
+# Si tiene ESLint config
+## Linting
+npm run lint
+
+# Si no tiene
+## Linting
+Consider adding ESLint
+```
+
+## Ejemplo de CLAUDE.md Generado
+
+```markdown
+# CLAUDE.md - MyProject
+
+> E-commerce platform with Next.js
+
+## Tech Stack
+- Next.js 14 (App Router)
+- Prisma + PostgreSQL
+- Tailwind CSS
+- tRPC
+
+## Core Rules
+
+### Code Quality
+- NO `any` types
+- Use Zod for validation
+- Prefer Server Components
+
+### Database
+- Use Prisma transactions
+- Always handle errors
+- Index frequently queried fields
+
+## Workflow
+
+1. Plan with TodoWrite
+2. Execute incrementally
+3. Run typecheck + lint
+4. Consult experts for critical code
+
+## Commands
+
+```bash
+npm run dev        # Development
+npm run build      # Production build
+npm run lint       # ESLint
+npm run typecheck  # TypeScript
+```
+
+## When to use /experts
+
+- Payment processing code
+- User authentication
+- Database migrations
+- Large refactoring
+```
+
+## Frecuencia de Sync
+
+- **Inicial**: Al empezar a trabajar en proyecto nuevo
+- **Periódico**: Cuando cambian estándares globales
+- **Manual**: Cuando el usuario ejecuta `/sync`
+
+## NO hacer en Sync
+
+- No sobreescribir reglas específicas del proyecto
+- No agregar estándares irrelevantes
+- No crear archivos innecesarios
+- No modificar código, solo documentación

package/standards/general/workflow.md

@@ -0,0 +1,82 @@
+# Workflow General con Claude Code
+
+## Principios Fundamentales
+
+### 1. Registrar Todo en Memory
+- **Antes** de empezar una tarea: registrarla
+- **Durante** la tarea: capturar ideas y aprendizajes
+- **Después** de la tarea: documentar resultado y lecciones
+
+### 2. Consultar Expertos en Decisiones Críticas
+Usar `/experts` cuando:
+- Cambios en código financiero o de pagos
+- Modificaciones de esquema de base de datos
+- Cambios de autenticación/autorización
+- Arquitectura nueva o refactoring grande
+
+### 3. Flujo de Trabajo Estándar
+
+```
+1. ENTENDER
+   - Leer contexto existente
+   - Buscar en memoria patrones similares
+   - Identificar archivos relevantes
+
+2. PLANIFICAR
+   - Crear plan con TodoWrite
+   - Dividir en tareas pequeñas
+   - Identificar si necesita validación de expertos
+
+3. EJECUTAR
+   - Una tarea a la vez
+   - Marcar progreso en todo list
+   - Capturar ideas que surjan
+
+4. VERIFICAR
+   - Ejecutar tests si existen
+   - Ejecutar typecheck
+   - Consultar expertos si es crítico
+
+5. APRENDER
+   - Registrar aprendizajes en memory
+   - Detectar patrones repetidos
+   - Actualizar estándares si aplica
+```
+
+## Comunicación
+
+- **Conciso**: Respuestas cortas y directas
+- **Sin emojis**: A menos que el usuario los pida
+- **Técnico**: Enfocado en la solución
+- **Honesto**: Si no sabes algo, dilo
+
+## Manejo de Errores
+
+1. **No asumir** - Verificar que archivos/funciones existen antes de usarlos
+2. **Leer antes de editar** - Siempre leer el archivo antes de modificarlo
+3. **No sobre-ingenierizar** - Solución mínima que funcione
+
+## Memory Usage
+
+```typescript
+// Registrar tarea
+await taskTracker.startTask({
+  title: "Implementar feature X",
+  description: "...",
+  userRequest: "mensaje original del usuario"
+})
+
+// Capturar idea durante trabajo
+await ideaCollector.captureIdea({
+  title: "Podríamos optimizar Y",
+  category: "optimization",
+  priority: "medium"
+})
+
+// Registrar aprendizaje
+await memoryClient.createMemory({
+  title: "Pattern Z funciona mejor que W",
+  body: "Descubrimos que...",
+  domain: "performance"
+})
+```