nemonix-cli 1.0.0

package/src/config/claude-code-config/skills/workflow-debug/steps/step-03-propose.md

@@ -0,0 +1,142 @@
+---
+name: step-03-propose
+description: Present solutions to user for selection
+prev_step: steps/step-02-find-solutions.md
+next_step: steps/step-04-fix.md
+---
+
+# Step 3: Propose Solutions
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER implement before user selects (unless auto_mode)
+- ✅ ALWAYS present all solutions clearly before asking
+- 📋 YOU ARE A PRESENTER, not a decider
+- 💬 FOCUS on helping user choose only
+- 🚫 FORBIDDEN to modify files in this step
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Present each solution with full details before asking
+- 💾 Store selected solution in `{selected_solution}`
+- 📖 Get clear user confirmation before proceeding
+- 🚫 FORBIDDEN to load step-04 until solution selected
+
+## CONTEXT BOUNDARIES:
+
+- Variables from previous steps: `{error_context}`, `{auto_mode}`, `{error_analysis}`, `{solutions}`
+- Present solutions objectively
+- Let user make the final decision (unless auto_mode)
+
+## YOUR TASK:
+
+Present all identified solutions to the user and let them choose which one to implement.
+
+---
+
+## Available State
+
+From previous steps:
+
+| Variable | Description |
+|----------|-------------|
+| `{error_context}` | Original error description |
+| `{auto_mode}` | Skip confirmations flag |
+| `{error_analysis}` | Analysis with root cause |
+| `{solutions}` | List of solutions with pros/cons |
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Present Error Summary
+
+**Brief recap:**
+
+> **Error:** {error_type}
+> **Root Cause:** {root_cause}
+> **Affected Files:** {count} files
+
+### 2. Present Each Solution
+
+**For each solution in `{solutions}`:**
+
+---
+
+### Solution {N}: {name}
+
+**Approach:** {approach}
+
+**Files to modify:**
+- {file1}
+- {file2}
+
+| Pros | Cons |
+|------|------|
+| {pro1} | {con1} |
+| {pro2} | |
+
+**Effort:** {low|medium|high} · **Risk:** {low|medium|high}
+
+---
+
+### 3. Get User Selection
+
+**If `{auto_mode}` = true:**
+→ Select the solution marked as recommended
+→ Set `{selected_solution}` = recommended solution
+→ Proceed to step-04 automatically
+
+**If `{auto_mode}` = false:**
+
+Use **AskUserQuestion** with:
+- **Header:** "Solution"
+- **Question:** "Which solution should we implement?"
+- **Options:**
+  1. "Solution 1: {name} (Recommended)" → {approach} - Effort: {effort}, Risk: {risk}
+  2. "Solution 2: {name}" → {approach} - Effort: {effort}, Risk: {risk}
+  3. "Solution 3: {name}" → {approach} - Effort: {effort}, Risk: {risk}
+
+### 4. Store Selection and Proceed
+
+**Store selection:**
+
+| Field | Value |
+|-------|-------|
+| ID | {selected_id} |
+| Name | {name} |
+| Approach | {approach} |
+| Files to modify | {list} |
+
+→ Proceed directly to step-04 (no confirmation needed after selection)
+
+---
+
+## SUCCESS METRICS:
+
+✅ All solutions presented clearly
+✅ User selected a solution (or auto-selected recommended)
+✅ `{selected_solution}` state variable populated
+
+## FAILURE MODES:
+
+❌ Not presenting all options
+❌ Implementing without explicit selection
+❌ **CRITICAL**: Making code changes in this step
+
+## PROPOSAL PROTOCOLS:
+
+- Present solutions objectively without excessive bias
+- Explain why one is recommended
+- Be honest about trade-offs
+- Let user have final say
+
+---
+
+## NEXT STEP:
+
+After solution selected and confirmed, load `./step-04-fix.md`
+
+<critical>
+Remember: This step is ONLY about choosing - don't implement yet!
+</critical>

package/src/config/claude-code-config/skills/workflow-debug/steps/step-04-fix.md

@@ -0,0 +1,176 @@
+---
+name: step-04-fix
+description: Implement the chosen solution
+prev_step: steps/step-03-propose.md
+next_step: steps/step-05-verify.md
+---
+
+# Step 4: Fix the Problem
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER deviate from selected solution without asking
+- ✅ ALWAYS implement exactly what was agreed
+- 📋 YOU ARE AN IMPLEMENTER, following the plan
+- 💬 FOCUS on precise implementation only
+- 🚫 FORBIDDEN to add unrequested improvements
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Read each file before modifying it
+- 💾 Track all changes in `{files_modified}`
+- 📖 Complete all changes before verifying
+- 🚫 FORBIDDEN to load step-05 until implementation complete
+
+## CONTEXT BOUNDARIES:
+
+- Variables from previous steps: `{error_context}`, `{auto_mode}`, `{error_analysis}`, `{debug_logs}`, `{solutions}`, `{selected_solution}`
+- Only modify files listed in `{selected_solution.files_to_modify}`
+- Don't add features or refactors not in the plan
+- If `{debug_logs}` exists, those logs MUST be removed in this step
+
+## YOUR TASK:
+
+Implement the selected solution precisely as planned, modifying only the necessary files.
+
+---
+
+## Available State
+
+From previous steps:
+
+| Variable | Description |
+|----------|-------------|
+| `{error_context}` | Original error description |
+| `{auto_mode}` | Skip confirmations flag |
+| `{error_analysis}` | Analysis with root cause |
+| `{selected_solution}` | Chosen solution with approach and files |
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Review Implementation Plan
+
+**From `{selected_solution}`:**
+- **Solution:** {name}
+- **Approach:** {approach}
+- **Files to modify:** {files_to_modify}
+
+### 2. Add Strategic Debug Logging (If Needed)
+
+<critical>
+Only add logging if the fix involves complex logic or you need to verify intermediate values.
+Remove debug logs before finalizing!
+</critical>
+
+**When to add temporary logs:**
+- Complex conditional logic
+- Data transformation steps
+- Async operations (to verify execution order)
+- Loops with potential edge cases
+
+**Strategic logging pattern:**
+```javascript
+console.log('[DEBUG] functionName:', { input, state, output });
+console.log('[DEBUG] processData: start', { data });
+// ... logic
+console.log('[DEBUG] processData: end', { result });
+```
+
+**Track debug logs added:**
+
+| File | Line | Purpose |
+|------|------|---------|
+| {path} | {number} | *What you're checking* |
+
+### 3. Implement Changes
+
+**For each file in `{selected_solution.files_to_modify}`:**
+
+1. **Read the file first** (mandatory)
+2. **Identify exact changes needed**
+3. **Apply changes using Edit tool**
+4. **Track modification:**
+
+| File | Changes Made |
+|------|--------------|
+| {path} | *What was changed* |
+
+### 4. Handle Unexpected Issues
+
+**If implementation reveals additional required changes:**
+→ Make minimal additional changes needed
+→ Document in `{files_modified}`
+
+### 5. Remove Debug Logs
+
+<critical>
+Remove ALL debug logs - both from this step AND from step-01b (Log Technique)!
+</critical>
+
+**Before finalizing, remove any temporary debug logs:**
+
+**A. Remove logs from `{debug_logs}` (if Log Technique was used):**
+
+| File | Line | Prefix |
+|------|------|--------|
+| *From {debug_logs} state variable* | | |
+
+**B. Remove logs added during implementation:**
+- Check tracked debug logs for logs to remove
+- Search for `[DEBUG` markers in modified files
+- Verify no console.log/print statements remain (unless intentional)
+
+**Verification command:**
+```bash
+grep -r "\[DEBUG" src/
+```
+
+### 6. Complete Implementation
+
+**Update files_modified state:**
+
+| File | Changes |
+|------|---------|
+| {path1} | {description} |
+| {path2} | {description} |
+
+→ Proceed directly to step-05 (no confirmation needed)
+
+---
+
+## SUCCESS METRICS:
+
+✅ All planned files modified
+✅ Changes align with selected solution
+✅ No unrequested modifications added
+✅ `{files_modified}` accurately tracks all changes
+✅ ALL debug logs removed (including from Log Technique)
+✅ Ready for verification
+
+## FAILURE MODES:
+
+❌ Modifying files not in the plan without asking
+❌ Adding "improvements" beyond the fix
+❌ Not reading files before editing
+❌ Leaving debug logs in the codebase
+❌ **CRITICAL**: Proceeding without complete implementation
+
+## IMPLEMENTATION PROTOCOLS:
+
+- Read before writing - always
+- Make minimal, precise changes
+- Follow existing code patterns
+- Don't change formatting or style unless necessary
+- Keep the fix focused
+
+---
+
+## NEXT STEP:
+
+After implementation confirmed, load `./step-05-verify.md`
+
+<critical>
+Remember: Implement ONLY what was agreed - no scope creep!
+</critical>

package/src/config/claude-code-config/skills/workflow-debug/steps/step-05-verify.md

@@ -0,0 +1,279 @@
+---
+name: step-05-verify
+description: Multi-layer verification to prove the fix works
+prev_step: steps/step-04-fix.md
+next_step: null
+---
+
+# Step 5: Verify the Fix (Multi-Layer)
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER declare success without RUNTIME verification
+- ✅ ALWAYS run multiple verification layers, not just tests
+- 📋 YOU ARE A SKEPTIC - assume the fix is broken until proven otherwise
+- 💬 FOCUS on PROVING the fix works, not hoping it works
+- 🚫 FORBIDDEN to trust green tests alone (20-40% still fail in production)
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Execute ALL verification layers in order
+- 💾 Document results from EACH layer in `{verification_result}`
+- 📖 If ANY layer fails, stop and address before continuing
+- 🚫 FORBIDDEN to skip runtime verification (Layer 3)
+
+## CONTEXT BOUNDARIES:
+
+- Variables from previous steps: all accumulated state
+- Use `{error_analysis.verification_method}` from step 1
+- Focus on the ORIGINAL error, not new features
+
+## YOUR TASK:
+
+Prove the fix works through multi-layer verification: static checks → automated tests → runtime execution → user confirmation.
+
+---
+
+## Available State
+
+From previous steps:
+
+| Variable | Description |
+|----------|-------------|
+| `{error_context}` | Original error description |
+| `{auto_mode}` | Skip confirmations flag |
+| `{error_analysis}` | Analysis with root cause and verification method |
+| `{selected_solution}` | Solution that was implemented |
+| `{files_modified}` | Files that were changed |
+
+---
+
+## VERIFICATION PYRAMID
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    VERIFICATION PYRAMID                     │
+│                                                             │
+│                    ┌───────────┐                            │
+│     Layer 4:       │  Manual   │  ← User confirms behavior  │
+│                    │  Review   │     (if not auto_mode)     │
+│                    └─────┬─────┘                            │
+│               ┌──────────┴──────────┐                       │
+│     Layer 3:  │   Runtime Execution  │ ← CRITICAL: Real     │
+│               │   (Actual behavior)  │   execution, not     │
+│               └──────────┬──────────┘   just tests          │
+│          ┌───────────────┴───────────────┐                  │
+│  Layer 2:│      Automated Checks          │ ← Tests, Lint   │
+│          │  (Build, Types, Lint, Tests)   │                 │
+│          └───────────────┬───────────────┘                  │
+│     ┌────────────────────┴────────────────────┐             │
+│  L1:│           Static Analysis               │ ← Immediate │
+│     │  (Syntax, Imports, Basic validation)    │   feedback  │
+│     └─────────────────────────────────────────┘             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+<critical>
+Tests pass but real execution fails ~20-40% of the time. NEVER skip Layer 3 (Runtime).
+</critical>
+
+---
+
+## EXECUTION SEQUENCE:
+
+### Layer 1: Static Analysis (Immediate Feedback)
+
+**Run these checks first:**
+
+```bash
+# Check for syntax errors (immediate)
+node --check {file}           # Node.js
+python -m py_compile {file}   # Python
+```
+
+**Verify:**
+- [ ] No syntax errors in modified files
+- [ ] Imports resolve correctly
+- [ ] No obvious typos in changed code
+
+**If Layer 1 fails:** Fix immediately before proceeding.
+
+---
+
+### Layer 2: Automated Checks (Build/Types/Lint/Tests)
+
+**Run in order of speed (fast → slow):**
+
+| Check | Command | What It Catches | Reliability |
+|-------|---------|-----------------|-------------|
+| **Build** | `npm run build` | Compilation, bundling | 95% |
+| **Types** | `tsc --noEmit` / `npx tsc` | Type errors, null safety | 90% |
+| **Lint** | `npm run lint` | Code patterns, potential bugs | 80% |
+| **Tests** | `npm test -- --testPathPattern={pattern}` | Regression in tested paths | 70%* |
+
+*Tests only catch what they test for - same blind spots apply
+
+**Execute:**
+```bash
+npm run build
+npm run typecheck  # or: npx tsc --noEmit
+npm run lint
+npm test -- --testPathPattern="{related-test-file}"
+```
+
+**Document Layer 2 results:**
+
+| Check | Result |
+|-------|--------|
+| Build | ✅ Passed / ❌ Failed |
+| Types | ✅ Passed / ❌ Failed / ⏭️ Skipped |
+| Lint | ✅ Passed / ❌ Failed / ⏭️ Skipped |
+| Tests | ✅ Passed / ❌ Failed / ⏭️ Skipped |
+
+*If failed, include relevant output*
+
+**If Layer 2 fails:** Fix the issue, return to Layer 1.
+
+---
+
+### Layer 3: Runtime Execution (CRITICAL - DO NOT SKIP)
+
+<critical>
+This is the most important layer. Tests can pass while real execution fails.
+</critical>
+
+**Based on error type, execute the ACTUAL code:**
+
+| Error Type | Runtime Verification | Tool/Method |
+|------------|---------------------|-------------|
+| **Frontend UI** | Open in browser, interact | Chrome DevTools Console |
+| **API endpoint** | Call the endpoint | `curl`, Postman, or browser |
+| **CLI command** | Run the command | Terminal |
+| **Build error** | Run full build, check output | Terminal |
+| **Server error** | Start server, trigger the path | Browser/curl |
+| **Test failure** | Run the SPECIFIC test | Test runner |
+
+**Frontend Verification:**
+```bash
+npm run dev
+# Open in Chrome, check DevTools Console for:
+# - No new errors
+# - Network requests succeed
+# - UI behaves correctly
+```
+
+**Backend/API Verification:**
+```bash
+curl -X GET http://localhost:3000/api/{endpoint}
+# Or for POST:
+curl -X POST http://localhost:3000/api/{endpoint} \
+  -H "Content-Type: application/json" \
+  -d '{"key": "value"}'
+```
+
+**CLI Verification:**
+```bash
+{the-original-failing-command}
+# Verify output matches expected behavior
+```
+
+**Document Layer 3 results:**
+
+| Field | Value |
+|-------|-------|
+| Method | *What was executed* |
+| Original error still occurs? | No (should be fixed!) |
+| New errors? | None / *list if any* |
+| Actual behavior | *What happened* |
+| Expected behavior | *What should happen* |
+| **Passed?** | ✅ Yes / ❌ No |
+
+**If Layer 3 fails:** The fix doesn't work. Return to step-03 or step-04.
+
+---
+
+### Layer 4: Regression & User Confirmation
+
+**Check for regressions:**
+```bash
+npm test
+# Or run full CI check
+npm run ci  # if available
+```
+
+**Document:**
+
+| Field | Value |
+|-------|-------|
+| Regression check | *What was run* |
+| Regressions found? | Yes / No |
+| Details | *If any* |
+
+**If all layers passed:**
+→ Report success, workflow complete
+
+**If any layer fails:**
+→ Report failure with details
+→ Automatically attempt to fix the issue and re-verify
+→ If unable to fix, present the failure clearly and end workflow
+
+---
+
+## SUCCESS METRICS:
+
+✅ Layer 1 (Static): No syntax errors
+✅ Layer 2 (Automated): Build + Types + Lint pass
+✅ Layer 3 (Runtime): ACTUAL execution works - error no longer occurs
+✅ Layer 4 (Regression): No new issues introduced
+✅ All results documented in `{verification_result}`
+
+## FAILURE MODES:
+
+❌ Skipping Layer 3 (Runtime) - "tests pass" is not enough
+❌ Declaring success after only Layer 2
+❌ Not testing the ORIGINAL error scenario
+❌ Ignoring new errors introduced by the fix
+❌ **CRITICAL**: Trusting green tests without runtime verification
+
+## VERIFICATION PROTOCOLS:
+
+- Run ALL layers, not just the convenient ones
+- Layer 3 (Runtime) is MANDATORY - never skip
+- Document failures clearly for debugging
+- Be honest about partial fixes
+- Tests passing ≠ fix working (20-40% false confidence rate)
+
+---
+
+## WORKFLOW COMPLETE:
+
+**If ALL layers passed:**
+
+## ✅ Fix Verified Successfully
+
+| Field | Value |
+|-------|-------|
+| **Error** | {original error} |
+| **Solution** | {selected_solution.name} |
+| **Files Modified** | {count} |
+
+**Verification Results:**
+
+| Layer | Check | Result |
+|-------|-------|--------|
+| 1 | Static Analysis | ✅ Passed |
+| 2 | Build | ✅ Passed |
+| 2 | Types | ✅ Passed |
+| 2 | Lint | ✅ Passed |
+| 2 | Tests | ✅ Passed |
+| 3 | Runtime Execution | ✅ Passed |
+| 4 | Regression Check | ✅ No regressions |
+
+The fix has been verified across all layers.
+
+**If FAILED:** Offer paths forward (retry, revert, accept partial)
+
+<critical>
+Remember: Green tests mean nothing without runtime verification.
+NEVER claim success without executing the actual code path that was failing.
+</critical>