cmp-standards 2.0.1 → 2.6.0

package/standards/general/memory-usage.md

@@ -0,0 +1,205 @@
+# Uso de Memory
+
+## Filosofía
+
+El sistema de memoria captura **conocimiento que persiste** entre sesiones:
+
+- Tareas que estamos haciendo
+- Aprendizajes del trabajo
+- Patrones detectados
+- Decisiones tomadas
+
+## Cuándo Registrar
+
+### Al Empezar Tarea
+
+```typescript
+// Registrar tarea nueva
+await taskTracker.startTask({
+  title: "Implementar feature X",
+  description: "Agregar funcionalidad para...",
+  userRequest: "mensaje original del usuario"
+})
+```
+
+### Durante el Trabajo
+
+```typescript
+// Capturar idea que surge
+await ideaCollector.capture({
+  title: "Optimización posible",
+  description: "Podríamos cachear este query...",
+  category: "performance",
+  priority: "medium"
+})
+```
+
+### Al Completar
+
+```typescript
+// Registrar resultado
+await taskTracker.completeTask(taskId, {
+  result: "Implementado con éxito",
+  lessonsLearned: ["Pattern X funcionó mejor que Y"]
+})
+```
+
+### Al Aprender Algo Nuevo
+
+```typescript
+// Crear memoria de conocimiento
+await memoryClient.create({
+  type: 'memory',
+  title: "Pattern: Lazy loading de mapas",
+  body: "Para evitar errores de SSR...",
+  domain: "architecture",
+  tags: ["performance", "ssr", "maps"]
+})
+```
+
+## Qué NO Registrar
+
+- Información trivial
+- Datos temporales de sesión
+- Detalles de implementación obvios
+- Código completo (solo referencias)
+
+## Tipos de Memoria
+
+### 1. Tasks
+
+Trabajo en progreso:
+
+```typescript
+{
+  type: 'task',
+  status: 'pending' | 'in_progress' | 'completed',
+  title: string,
+  description: string,
+  context: { /* datos relevantes */ }
+}
+```
+
+### 2. Ideas
+
+Insights capturados:
+
+```typescript
+{
+  type: 'idea',
+  title: string,
+  description: string,
+  category: 'feature' | 'optimization' | 'fix' | 'research',
+  priority: 'low' | 'medium' | 'high'
+}
+```
+
+### 3. Memories
+
+Conocimiento persistente:
+
+```typescript
+{
+  type: 'memory',
+  title: string,
+  body: string,        // Markdown
+  domain: string,      // 'architecture', 'performance', etc.
+  tags: string[],
+  importance: 'low' | 'normal' | 'critical'
+}
+```
+
+### 4. Patterns
+
+Patrones detectados:
+
+```typescript
+{
+  type: 'pattern',
+  name: string,
+  description: string,
+  occurrences: number,
+  autoImprove: boolean  // true si >= 3 ocurrencias
+}
+```
+
+## Auto-Improvement
+
+Cuando un patrón se detecta 3+ veces:
+
+1. Sistema genera regla ESLint
+2. Crea entrada en memoria (gotcha)
+3. Actualiza estándares locales
+
+```
+Pattern detectado 3x: "await en loop"
+  ↓
+ESLint rule: no-await-in-loop
+  ↓
+Memory: "Usar Promise.all en lugar de await secuencial"
+  ↓
+Próxima sesión: IDE muestra warning
+```
+
+## Búsqueda de Conocimiento
+
+Antes de empezar tarea, buscar conocimiento previo:
+
+```typescript
+// Buscar memorias relevantes
+const relevant = await memoryClient.search({
+  query: "lazy loading components",
+  domain: "architecture",
+  limit: 5
+})
+
+// Aplicar conocimiento encontrado
+for (const memory of relevant) {
+  console.log(`Conocimiento previo: ${memory.title}`)
+}
+```
+
+## Integración con Workflow
+
+```
+1. EMPEZAR TAREA
+   └→ taskTracker.startTask()
+
+2. BUSCAR CONTEXTO
+   └→ memoryClient.search()
+
+3. TRABAJAR
+   └→ ideaCollector.capture() (si surge idea)
+
+4. COMPLETAR
+   └→ taskTracker.completeTask()
+   └→ memoryClient.create() (si aprendí algo)
+
+5. DETECTAR PATRONES
+   └→ patternDetector.scan()
+   └→ autoImprover.improve() (si 3+ ocurrencias)
+```
+
+## Comandos
+
+```bash
+# Ver estado de memoria
+claude-memory status
+
+# Buscar en memoria
+claude-memory search "query"
+
+# Ver patrones detectados
+claude-memory patterns
+
+# Ejecutar auto-mejora
+claude-memory improve
+```
+
+## Best Practices
+
+1. **Ser selectivo** - Solo registrar lo valioso
+2. **Títulos descriptivos** - Facilita búsqueda futura
+3. **Tags consistentes** - Usar vocabulario común
+4. **Actualizar, no duplicar** - Si existe, actualizar
+5. **Dominio correcto** - Clasificar apropiadamente

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"
+})
+```