oden-forge 2.0.0

package/.claude/commands/oden/sync.md

@@ -0,0 +1,286 @@
+---
+allowed-tools: Bash, Read, Write, LS, Task
+description: Sincronizar epic y tasks con GitHub Issues (nativo, sin CCPM)
+---
+
+# Sync - GitHub Issues Synchronization
+
+Sincroniza epics y tasks locales con GitHub Issues. Comando nativo sin dependencia de CCPM.
+
+## Usage
+```
+/oden:sync <feature_name> [subcommand]
+/oden:sync status
+```
+
+## Subcommands
+
+- `/oden:sync <name>` - Full sync: push epic + tasks to GitHub, create branch
+- `/oden:sync <name> push` - Same as above (explicit)
+- `/oden:sync <name> update` - Update existing GitHub issues from local changes
+- `/oden:sync status` - Show sync status of all epics
+
+## Preflight
+
+### Repository Protection
+```bash
+remote_url=$(git remote get-url origin 2>/dev/null || echo "")
+if [[ "$remote_url" == *"automazeio/ccpm"* ]] || [[ "$remote_url" == *"automazeio/ccpm.git"* ]]; then
+  echo "Cannot sync to CCPM template repository!"
+  echo "Update remote: git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPO.git"
+  exit 1
+fi
+```
+
+### Validation
+1. **Epic exists**: Check `.claude/epics/$ARGUMENTS/epic.md`
+   - If not found: "Epic not found. Create it: /oden:prd $ARGUMENTS && /oden:epic $ARGUMENTS && /oden:tasks $ARGUMENTS"
+
+2. **Tasks exist**: Check for numbered task files in `.claude/epics/$ARGUMENTS/`
+   - If none found: "No tasks found. Create them: /oden:tasks $ARGUMENTS"
+
+3. **Git remote**: Verify origin is configured
+   - If not: "No remote. Run: git remote add origin <url>"
+
+## Instructions
+
+### Detect Repository
+```bash
+remote_url=$(git remote get-url origin 2>/dev/null || echo "")
+REPO=$(echo "$remote_url" | sed 's|.*github.com[:/]||' | sed 's|\.git$||')
+[ -z "$REPO" ] && REPO="user/repo"
+```
+
+### Setup Labels
+Create labels if they don't exist (silently):
+```bash
+gh label create "epic" --color "0E8A16" --description "Epic issue" 2>/dev/null || true
+gh label create "task" --color "1D76DB" --description "Task issue" 2>/dev/null || true
+gh label create "feature" --color "A2EEEF" --description "New feature" 2>/dev/null || true
+```
+
+---
+
+## Full Sync Flow (`/oden:sync <name>`)
+
+### Step 1: Create Epic Issue
+
+Strip frontmatter and prepare body:
+```bash
+# Extract content without frontmatter
+sed '1,/^---$/d; 1,/^---$/d' .claude/epics/$ARGUMENTS/epic.md > /tmp/epic-body-raw.md
+
+# Remove "## Tasks Created" section (will be auto-generated from sub-issues)
+awk '
+  /^## Tasks Created/ { skip=1; next }
+  /^## / && skip { skip=0 }
+  !skip { print }
+' /tmp/epic-body-raw.md > /tmp/epic-body.md
+
+# Create epic issue
+epic_number=$(gh issue create \
+  --repo "$REPO" \
+  --title "Epic: $ARGUMENTS" \
+  --body-file /tmp/epic-body.md \
+  --label "epic,epic:$ARGUMENTS,feature" \
+  --json number -q .number)
+```
+
+### Step 2: Create Task Sub-Issues
+
+Check for gh-sub-issue extension:
+```bash
+if gh extension list | grep -q "yahsan2/gh-sub-issue"; then
+  use_subissues=true
+else
+  use_subissues=false
+fi
+```
+
+For each task file:
+```bash
+for task_file in .claude/epics/$ARGUMENTS/[0-9][0-9][0-9].md; do
+  [ -f "$task_file" ] || continue
+
+  task_name=$(grep '^name:' "$task_file" | sed 's/^name: *//')
+  sed '1,/^---$/d; 1,/^---$/d' "$task_file" > /tmp/task-body.md
+
+  if [ "$use_subissues" = true ]; then
+    task_number=$(gh sub-issue create \
+      --parent "$epic_number" \
+      --title "$task_name" \
+      --body-file /tmp/task-body.md \
+      --label "task,epic:$ARGUMENTS" \
+      --json number -q .number)
+  else
+    task_number=$(gh issue create \
+      --repo "$REPO" \
+      --title "$task_name" \
+      --body-file /tmp/task-body.md \
+      --label "task,epic:$ARGUMENTS" \
+      --json number -q .number)
+  fi
+
+  echo "$task_file:$task_number" >> /tmp/task-mapping.txt
+done
+```
+
+**For 5+ tasks**: Use Task tool for parallel creation in batches of 3-4.
+
+### Step 3: Rename Files and Update References
+
+Build old-to-new mapping:
+```bash
+> /tmp/id-mapping.txt
+while IFS=: read -r task_file task_number; do
+  old_num=$(basename "$task_file" .md)
+  echo "$old_num:$task_number" >> /tmp/id-mapping.txt
+done < /tmp/task-mapping.txt
+```
+
+Rename and update references:
+```bash
+repo_name=$(gh repo view --json nameWithOwner -q .nameWithOwner)
+current_date=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+while IFS=: read -r task_file task_number; do
+  new_name="$(dirname "$task_file")/${task_number}.md"
+  content=$(cat "$task_file")
+
+  # Update depends_on and conflicts_with references
+  while IFS=: read -r old_num new_num; do
+    content=$(echo "$content" | sed "s/\b$old_num\b/$new_num/g")
+  done < /tmp/id-mapping.txt
+
+  echo "$content" > "$new_name"
+  [ "$task_file" != "$new_name" ] && rm "$task_file"
+
+  # Update frontmatter
+  github_url="https://github.com/$repo_name/issues/$task_number"
+  sed -i.bak "/^github:/c\github: $github_url" "$new_name"
+  sed -i.bak "/^updated:/c\updated: $current_date" "$new_name"
+  rm "${new_name}.bak"
+done < /tmp/task-mapping.txt
+```
+
+### Step 4: Update Epic with Task List (fallback without sub-issues)
+
+If NOT using gh-sub-issue, add task list to epic issue body:
+```bash
+if [ "$use_subissues" = false ]; then
+  gh issue view ${epic_number} --json body -q .body > /tmp/epic-body.md
+  # Append task checklist
+  echo "" >> /tmp/epic-body.md
+  echo "## Tasks" >> /tmp/epic-body.md
+  while IFS=: read -r task_file task_number; do
+    task_name=$(grep '^name:' "$(dirname "$task_file")/${task_number}.md" | sed 's/^name: *//')
+    echo "- [ ] #${task_number} ${task_name}" >> /tmp/epic-body.md
+  done < /tmp/task-mapping.txt
+  gh issue edit ${epic_number} --body-file /tmp/epic-body.md
+fi
+```
+
+### Step 5: Update Local Epic File
+
+```bash
+epic_url="https://github.com/$repo_name/issues/$epic_number"
+current_date=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+# Update frontmatter
+sed -i.bak "/^github:/c\github: $epic_url" .claude/epics/$ARGUMENTS/epic.md
+sed -i.bak "/^updated:/c\updated: $current_date" .claude/epics/$ARGUMENTS/epic.md
+rm .claude/epics/$ARGUMENTS/epic.md.bak
+```
+
+Update "## Tasks Created" section with real issue numbers.
+
+### Step 6: Create Mapping File
+
+Create `.claude/epics/$ARGUMENTS/github-mapping.md`:
+```markdown
+# GitHub Issue Mapping
+
+Epic: #{epic_number} - https://github.com/{repo}/issues/{epic_number}
+
+Tasks:
+- #{task_number}: {task_name} - https://github.com/{repo}/issues/{task_number}
+- ...
+
+Synced: {current_datetime}
+```
+
+### Step 7: Create Branch
+
+Follow `/rules/branch-operations.md`:
+```bash
+git checkout main && git pull origin main
+git checkout -b epic/$ARGUMENTS
+git push -u origin epic/$ARGUMENTS
+```
+
+### Output
+
+```
+Synced to GitHub
+  Epic: #{epic_number}
+  Tasks: {count} issues created
+  Labels: epic, task, epic:{name}
+  Files renamed: 001.md -> {issue_id}.md
+  Branch: epic/$ARGUMENTS
+
+Next: /oden:epic-start $ARGUMENTS
+View: https://github.com/{repo}/issues/{epic_number}
+```
+
+---
+
+## Update Flow (`/oden:sync <name> update`)
+
+For syncing local changes to existing GitHub issues:
+
+1. Read github-mapping.md for issue numbers
+2. For each task with local changes since last sync:
+   - Update GitHub issue body if task description changed
+   - Add progress comment if updates exist
+3. Update epic progress on GitHub
+4. Update local sync timestamps
+
+---
+
+## Status Flow (`/oden:sync status`)
+
+Scan all epics and show sync state:
+
+```
+SYNC STATUS
+
+Epics:
+  {name} (#{number}) - {closed}/{total} tasks | {progress}%
+  {name} (#{number}) - {closed}/{total} tasks | {progress}%
+
+Issues in progress:
+  #{number}: {title}
+  #{number}: {title}
+
+Local only (not synced):
+  {name} - Run: /oden:sync {name}
+```
+
+---
+
+## Error Handling
+
+Follow `/rules/github-operations.md` for GitHub CLI errors.
+
+If any issue creation fails:
+- Report what succeeded and what failed
+- Don't attempt rollback (partial sync is fine)
+- Suggest: "Retry failed items with: /oden:sync $ARGUMENTS update"
+
+## Important Notes
+
+- **No CCPM dependency** - this is fully native
+- Always check remote origin before GitHub writes
+- Get REAL datetime: `date -u +"%Y-%m-%dT%H:%M:%SZ"`
+- Update frontmatter only after successful creation
+- Clean up temp files after operations

package/.claude/commands/oden/tasks.md

@@ -0,0 +1,156 @@
+---
+allowed-tools: Bash, Read, Write, LS, Task
+description: Descomponer Epic en tasks/issues individuales (nativo, sin CCPM)
+---
+
+# Tasks - Decompose Epic into Issues
+
+Descompone un Epic en tasks individuales, accionables y con dependencias claras.
+
+## Usage
+```
+/oden:tasks <feature_name>
+```
+
+## Preflight
+
+Silently validate:
+
+1. **Epic exists**: Check `.claude/epics/$ARGUMENTS/epic.md`
+   - If not found: "Epic not found. Create it first: /oden:epic $ARGUMENTS"
+
+2. **Epic frontmatter**: Verify name, status, created, prd fields
+   - If invalid: "Invalid epic. Check: .claude/epics/$ARGUMENTS/epic.md"
+
+3. **Existing tasks**: Check for numbered files (001.md, 002.md, etc.) in `.claude/epics/$ARGUMENTS/`
+   - If found, list them and ask: "Found {count} existing tasks. Delete and recreate? (yes/no)"
+   - Only proceed with confirmation
+
+4. **Epic status**: If status is "completed", warn before proceeding
+
+## Instructions
+
+You are decomposing an epic into actionable tasks for: **$ARGUMENTS**
+
+### 1. Read the Epic
+
+Load `.claude/epics/$ARGUMENTS/epic.md`:
+- Understand technical approach
+- Review task breakdown preview
+- Note dependencies and constraints
+
+### 2. Create Tasks
+
+For each task, create a numbered file in `.claude/epics/$ARGUMENTS/`:
+
+#### Task File Format: `.claude/epics/$ARGUMENTS/{number}.md`
+
+```markdown
+---
+name: [Task Title]
+status: open
+created: [Real datetime]
+updated: [Real datetime]
+github:
+depends_on: []
+parallel: true
+conflicts_with: []
+---
+
+# Task: [Task Title]
+
+## Description
+[Clear, concise description]
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+- [ ] Criterion 3
+
+## Technical Details
+[Implementation approach, files affected, key considerations]
+
+## Dependencies
+- [ ] Task/external dependencies
+
+## Effort Estimate
+- Size: XS/S/M/L/XL
+- Parallel: true/false
+```
+
+### 3. Task Guidelines
+
+- **Numbering**: Sequential 001.md, 002.md, etc.
+- **Size**: Each task completable in 1-3 days
+- **Max tasks**: Aim for 10 or fewer
+- **Parallel field**: Set true if no blocking dependencies
+- **depends_on**: Reference task numbers that must complete first (e.g., [001, 002])
+- **conflicts_with**: Tasks that modify same files
+
+### 4. Execution Strategy
+
+Choose based on task count:
+
+**< 5 tasks**: Create sequentially (simpler)
+
+**5-10 tasks**: Can batch with Task tool:
+```yaml
+Task:
+  description: "Create tasks batch {X} for epic $ARGUMENTS"
+  subagent_type: "general-purpose"
+  prompt: |
+    Create task files for epic: $ARGUMENTS
+    Tasks to create: [list]
+    Directory: .claude/epics/$ARGUMENTS/
+    Use exact frontmatter format.
+    Get real datetime: date -u +"%Y-%m-%dT%H:%M:%SZ"
+```
+
+### 5. Update Epic
+
+After creating all tasks, update `.claude/epics/$ARGUMENTS/epic.md`:
+
+Add/replace "## Tasks Created" section:
+```markdown
+## Tasks Created
+- [ ] 001 - {Task Title} (parallel: true/false)
+- [ ] 002 - {Task Title} (parallel: true/false)
+- etc.
+
+Total tasks: {count}
+Parallel tasks: {parallel_count}
+Sequential tasks: {sequential_count}
+```
+
+Update frontmatter `updated` field with current datetime.
+
+### 6. Validation
+
+Before finalizing:
+- All tasks have clear acceptance criteria
+- Task sizes are reasonable (1-3 days)
+- Dependencies are logical (no circular)
+- Parallel tasks don't conflict
+- Combined tasks cover all epic requirements
+
+## Output
+
+```
+Created {count} tasks for epic: $ARGUMENTS
+
+Tasks:
+  001 - {title} (S, parallel)
+  002 - {title} (M, parallel)
+  003 - {title} (M, depends: 001)
+  ...
+
+Parallel: {count} | Sequential: {count}
+
+Next: /oden:sync $ARGUMENTS
+```
+
+## Important
+
+- Get REAL datetime: `date -u +"%Y-%m-%dT%H:%M:%SZ"`
+- Keep tasks actionable and well-scoped
+- Prefer fewer, well-defined tasks over many granular ones

package/.claude/commands/oden/test.md

@@ -0,0 +1,200 @@
+---
+allowed-tools: Bash, Read, Write, Edit, LS, Glob, Grep, Task, TodoWrite
+description: Testing - estrategia, ejecución y análisis
+---
+
+# Oden Forge - Testing
+
+Comandos para testing completo del proyecto.
+
+## Usage
+
+```
+/oden:test [subcommand]
+```
+
+## Subcomandos
+
+### `/oden:test strategy`
+
+Crea estrategia de testing para el proyecto.
+
+**Usa:** `test-engineer` agent
+
+**Genera:**
+- `docs/reference/testing-strategy.md`
+- Estructura de tests recomendada
+- Cobertura mínima por módulo
+- Tipos de tests por feature
+
+### `/oden:test run [scope]`
+
+Ejecuta tests y analiza resultados.
+
+**Usa:** `test-runner` agent
+
+**Scope:**
+- (vacío) - Todos los tests
+- `unit` - Solo unit tests
+- `integration` - Solo integration
+- `e2e` - Solo end-to-end
+- `module {name}` - Tests de un módulo
+
+**Output:**
+```
+╔══════════════════════════════════════════════════════════════╗
+║                     TEST RESULTS                             ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+║  ✅ Passed: 45                                               ║
+║  ❌ Failed: 3                                                ║
+║  ⏭️  Skipped: 2                                              ║
+║                                                              ║
+║  Coverage: 78%                                               ║
+║                                                              ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+║  FAILURES:                                                   ║
+║                                                              ║
+║  1. auth.test.ts:45                                          ║
+║     Expected: 200                                            ║
+║     Received: 401                                            ║
+║     → Posible causa: Token expirado                          ║
+║                                                              ║
+║  2. orders.test.ts:123                                       ║
+║     Expected: "completed"                                    ║
+║     Received: "pending"                                      ║
+║     → Posible causa: Estado no actualizado                   ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+### `/oden:test fix`
+
+Analiza tests fallidos y sugiere fixes.
+
+**Usa:** `debugger` + `code-analyzer` agents
+
+**Proceso:**
+1. Lee output de último test run
+2. Analiza cada fallo
+3. Identifica causa raíz
+4. Sugiere fix específico
+
+### `/oden:test coverage`
+
+Analiza cobertura y sugiere tests faltantes.
+
+**Usa:** `test-engineer` agent
+
+**Output:**
+```
+╔══════════════════════════════════════════════════════════════╗
+║                   COVERAGE ANALYSIS                          ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+║  MODULE              COVERAGE    TARGET    STATUS            ║
+║  ─────────────────────────────────────────────────────────── ║
+║  auth                92%         80%       ✅                ║
+║  orders              67%         80%       ❌ (-13%)         ║
+║  payments            85%         80%       ✅                ║
+║  users               45%         80%       ❌ (-35%)         ║
+║                                                              ║
+╠══════════════════════════════════════════════════════════════╣
+║                                                              ║
+║  TESTS SUGERIDOS:                                            ║
+║                                                              ║
+║  orders:                                                     ║
+║  - [ ] Test: cancelOrder con items parciales                 ║
+║  - [ ] Test: refund cuando ya hay refund parcial             ║
+║  - [ ] Test: transición ACTIVE → COMPLETED                   ║
+║                                                              ║
+║  users:                                                      ║
+║  - [ ] Test: updateProfile con campos inválidos              ║
+║  - [ ] Test: deleteUser con órdenes activas                  ║
+║  - [ ] Test: cambio de rol                                   ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+```
+
+### `/oden:test generate [module]`
+
+Genera tests basados en specs.
+
+**Usa:** `test-engineer` agent
+
+**Lee:**
+- `docs/reference/modules/{module}-spec.md`
+- Especialmente secciones de:
+  - Validaciones
+  - Estados y transiciones
+  - Edge cases
+  - Testing checklist
+
+**Genera:**
+- Unit tests para validaciones
+- Integration tests para flujos
+- Tests de transiciones de estado
+
+---
+
+## Integración con Specs
+
+Los tests se generan basándose en las especificaciones:
+
+### De la Spec → A Tests
+
+| Sección Spec | Tipo de Test |
+|--------------|--------------|
+| Validaciones de campo | Unit tests |
+| Transiciones de estado | State machine tests |
+| API endpoints | Integration tests |
+| Flujos de usuario | E2E tests |
+| Edge cases | Específicos por caso |
+
+### Ejemplo
+
+Si la spec dice:
+```markdown
+### 5.1 Validaciones de Campo
+| Campo | Regla | Mensaje |
+| name | No vacío | "El nombre es requerido" |
+| name | Max 100 chars | "El nombre no puede exceder 100 caracteres" |
+```
+
+Genera:
+```typescript
+describe('Order validations', () => {
+  it('should require name', () => {
+    expect(() => createOrder({ name: '' }))
+      .toThrow('El nombre es requerido');
+  });
+
+  it('should reject name > 100 chars', () => {
+    expect(() => createOrder({ name: 'a'.repeat(101) }))
+      .toThrow('El nombre no puede exceder 100 caracteres');
+  });
+});
+```
+
+---
+
+## Flujo Recomendado
+
+1. **Al crear spec:** `/oden:spec orders`
+2. **Generar tests:** `/oden:test generate orders`
+3. **Implementar código:** (desarrollo)
+4. **Ejecutar tests:** `/oden:test run`
+5. **Si fallan:** `/oden:test fix`
+6. **Verificar coverage:** `/oden:test coverage`
+
+---
+
+## Guardar Resultados
+
+Los resultados de tests se guardan en:
+```
+docs/development/current/{feature}/TEST_RESULTS_{fecha}.md
+```
+
+Para referencia en daily logs.