nemonix-cli 1.0.0

package/src/config/claude-code-config/skills/workflow-clean-code/steps/step-02-apply.md

@@ -0,0 +1,152 @@
+---
+name: step-02-apply
+description: Load documentation, recommend, and apply clean code fixes
+prev_step: steps/step-01-scan.md
+next_step: steps/step-03-verify.md
+---
+
+# Step 2: APPLY
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER apply patterns without reading docs first
+- ✅ ALWAYS load relevant reference files
+- 📋 YOU ARE AN IMPLEMENTER following best practices
+- 💬 FOCUS on applying patterns from loaded docs
+- 🚫 FORBIDDEN to invent patterns not in docs
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Load docs based on detected technologies
+- 💾 Track progress in table format
+- 📖 Complete all changes before step-03
+- 🚫 FORBIDDEN to skip verification after changes
+
+## CONTEXT BOUNDARIES:
+
+- From step-01: `{detected_tech}`, `{issues}`, flags
+- Reference files in `references/` folder
+- Optional: Context7 MCP for latest docs
+
+## YOUR TASK:
+
+Load relevant documentation, generate recommendations, and apply clean code fixes.
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Load Reference Files
+
+| Condition | Load |
+|-----------|------|
+| Always | `references/general-clean-code.md` |
+| React/Next.js | `references/react-clean-code.md` |
+| Next.js | `references/nextjs-clean-code.md` |
+| No data fetching lib | `references/tanstack-query-best-practices.md` |
+| Zustand | `references/zustand-best-practices.md` |
+
+**CRITICAL: Actually READ the files with Read tool!**
+
+### 2. Generate Recommendations
+
+Based on issues + loaded docs:
+
+```markdown
+## Recommendations
+
+### 🔴 High Priority
+1. Replace useEffect → TanStack Query
+2. Add Error Boundaries
+
+### 🟡 Medium Priority
+3. Fix `any` types
+
+### 🟢 Quick Wins
+4. Remove console.log
+```
+
+### 3. Confirm Before Applying
+
+**If `{auto_mode}` = true:**
+→ Apply all recommendations
+
+**If `{auto_mode}` = false:**
+→ Use AskUserQuestion:
+```yaml
+questions:
+  - header: "Apply"
+    question: "Apply these clean code improvements?"
+    options:
+      - label: "Apply All (Recommended)"
+        description: "Apply all recommendations"
+      - label: "High Priority Only"
+        description: "Only high priority fixes"
+    multiSelect: false
+```
+
+### 4. Install Dependencies
+
+If new libraries needed:
+```bash
+pnpm add @tanstack/react-query react-error-boundary
+```
+
+### 5. Apply Changes
+
+**If `{economy_mode}` = true:**
+→ Apply sequentially
+
+**If `{economy_mode}` = false AND 4+ files:**
+→ Use parallel Snipper agents
+
+**Track progress:**
+```markdown
+| File | Status | Change |
+|------|--------|--------|
+| providers.tsx | ✅ | Added QueryProvider |
+| Auth.tsx | ✅ | useEffect → useQuery |
+```
+
+### 6. Summary
+
+```markdown
+## Changes Applied
+- Files modified: 8
+- Lines added: 120
+- Lines removed: 180
+```
+
+**If `{save_mode}` = true:**
+→ Write to `.claude/output/clean-code/{task_id}/02-apply.md`
+
+---
+
+## SUCCESS METRICS:
+
+✅ Docs loaded and read
+✅ Recommendations generated
+✅ Changes applied following doc patterns
+✅ Progress tracked
+
+## FAILURE MODES:
+
+❌ Applying patterns without reading docs
+❌ Skipping dependency installation
+❌ Not tracking progress
+
+## APPLY PROTOCOLS:
+
+- Follow patterns from docs exactly
+- Don't invent new patterns
+- Verify build after major changes
+
+---
+
+## NEXT STEP:
+
+After changes applied, load `./step-03-verify.md`
+
+<critical>
+Follow patterns from LOADED DOCS only!
+</critical>

package/src/config/claude-code-config/skills/workflow-clean-code/steps/step-03-verify.md

@@ -0,0 +1,143 @@
+---
+name: step-03-verify
+description: Verify build passes and summarize changes
+prev_step: steps/step-02-apply.md
+next_step: null
+---
+
+# Step 3: VERIFY
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER complete with failing build
+- ✅ ALWAYS run build before marking done
+- 📋 YOU ARE A VALIDATOR ensuring quality
+- 💬 FOCUS on verification and summary
+- 🚫 FORBIDDEN to skip any check
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Run all verification commands
+- 💾 Save summary if `{save_mode}` = true
+- 📖 Fix any errors before completing
+- 🚫 FORBIDDEN to mark complete if build fails
+
+## CONTEXT BOUNDARIES:
+
+- From step-02: changes applied, files modified
+- Build/lint commands from package.json
+
+## YOUR TASK:
+
+Run build, fix any errors, and provide final summary.
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Run TypeScript Check
+
+```bash
+npx tsc --noEmit
+```
+
+**If errors:** Fix and re-run until clean.
+
+### 2. Run Linter
+
+```bash
+pnpm lint
+```
+
+**If errors:** Fix with `pnpm lint --fix`, then manual fixes.
+
+### 3. Run Build
+
+```bash
+pnpm build
+```
+
+**If build fails:**
+1. Read error
+2. Fix issue
+3. Re-run
+4. **Loop until passes**
+
+### 4. Run Tests (if available)
+
+```bash
+pnpm test
+```
+
+### 5. Generate Summary
+
+```markdown
+## Clean Code Complete ✓
+
+### Verification
+| Check | Status |
+|-------|--------|
+| TypeScript | ✅ |
+| ESLint | ✅ |
+| Build | ✅ |
+
+### Improvements
+| Metric | Before | After |
+|--------|--------|-------|
+| useEffect fetching | 5 | 0 |
+| any types | 12 | 0 |
+
+### Files Changed: 12
+```
+
+**If `{save_mode}` = true:**
+→ Write to `.claude/output/clean-code/{task_id}/03-verify.md`
+
+### 6. Offer Commit
+
+**Use AskUserQuestion:**
+```yaml
+questions:
+  - header: "Complete"
+    question: "Clean code complete. Create commit?"
+    options:
+      - label: "Create Commit (Recommended)"
+        description: "Commit changes"
+      - label: "Done"
+        description: "Finish without commit"
+    multiSelect: false
+```
+
+**If commit:**
+```bash
+git add -A && git commit -m "refactor: apply clean code improvements"
+```
+
+---
+
+## SUCCESS METRICS:
+
+✅ TypeScript passes
+✅ Linter passes
+✅ Build passes
+✅ Summary generated
+
+## FAILURE MODES:
+
+❌ Completing with failing build
+❌ Skipping verification
+❌ Not offering commit option
+
+## VERIFY PROTOCOLS:
+
+- Always run build
+- Fix errors before completing
+- Provide clear summary
+
+---
+
+## WORKFLOW COMPLETE
+
+<critical>
+NEVER complete if build fails!
+</critical>

package/src/config/claude-code-config/skills/workflow-debug/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: debug
+description: Systematic error debugging with analysis, solution discovery, and verification
+argument-hint: "[error description or context] [-a for auto mode]"
+---
+
+<objective>
+Debug errors systematically through a 5-step workflow: analyze the error, find potential solutions, propose options to the user, implement the fix, and verify it works through multi-layer verification.
+</objective>
+
+<quick_start>
+**Debug an error (interactive):**
+```bash
+/debug login page crashes on submit
+```
+
+**Auto mode (fully automatic, use recommended solutions):**
+```bash
+/debug -a API returning 500 on POST
+```
+
+**What it does:**
+1. **Analyze**: Reproduce error, identify root cause → **ask if you have more context**
+2. **Log Technique** (if needed): Add debug logs → **user runs & shares output** → analyze
+3. **Find Solutions**: Research 2-3+ potential fixes with pros/cons
+4. **Propose**: Present options → **you choose which solution**
+5. **Fix**: Implement solution with strategic logging
+6. **Verify**: Multi-layer verification (Static → Build → Runtime)
+
+**Key principle**: Tests passing ≠ fix working. Always execute the actual code path.
+
+**Log Technique**: When the error can't be reproduced, strategic debug logs are added. The user runs the app and shares the console output for analysis.
+</quick_start>
+
+<methodology>
+<core_principles>
+**Battle-Tested Principles:**
+
+1. **Reproduce Before Anything Else** - If you can't reproduce it, you can't verify the fix
+2. **Hypothesis-Driven Analysis** - List 3-5 causes ranked by likelihood, test systematically
+3. **Multi-Layer Verification** - Tests alone give false confidence (20-40% still fail in production)
+</core_principles>
+
+<verification_pyramid>
+**Verification Pyramid:**
+
+```
+        ┌─────────────┐
+        │   Manual    │  ← User confirms
+        └──────┬──────┘
+     ┌─────────┴─────────┐
+     │ Runtime Execution │  ← CRITICAL: Real execution
+     └─────────┬─────────┘
+   ┌───────────┴───────────┐
+   │   Automated Checks    │  ← Build, Types, Lint, Tests
+   └───────────┬───────────┘
+ ┌─────────────┴─────────────┐
+ │     Static Analysis       │  ← Syntax, Imports
+ └───────────────────────────┘
+```
+
+**Key Insight**: Tests passing ≠ fix working. ALWAYS execute the actual code path.
+</verification_pyramid>
+</methodology>
+
+<parameters>
+**Flags:**
+
+| Flag | Name | Description |
+|------|------|-------------|
+| `-a`, `--auto` | Auto mode | Full automatic mode - don't ask the user, use recommended solutions |
+
+**Arguments:**
+- Everything after flags = `{error_context}` - Description of the error or context about what's failing
+</parameters>
+
+<state_variables>
+**Persist throughout all steps:**
+
+| Variable | Type | Description |
+|----------|------|-------------|
+| `{error_context}` | string | User's description of the error |
+| `{auto_mode}` | boolean | Skip confirmations, use recommended options |
+| `{error_analysis}` | object | Detailed analysis from step 1 |
+| `{debug_logs}` | list | Debug logs added for cleanup (file, line, prefix) |
+| `{solutions}` | list | Potential solutions found in step 2 |
+| `{selected_solution}` | object | User's chosen solution from step 3 |
+| `{files_modified}` | list | Files changed during the fix |
+| `{verification_result}` | object | Results from verification step |
+</state_variables>
+
+<entry_point>
+Load `steps/step-00-init.md`
+</entry_point>
+
+<step_files>
+| Step | File | Description |
+|------|------|-------------|
+| 0 | `step-00-init.md` | Parse flags, setup state |
+| 1 | `step-01-analyze.md` | Reproduce error, form hypotheses, identify root cause |
+| 1b | `step-01b-log-instrumentation.md` | *Optional*: Add debug logs, user runs & shares output |
+| 2 | `step-02-find-solutions.md` | Research 2-3+ solutions with pros/cons |
+| 3 | `step-03-propose.md` | Present solutions for user selection |
+| 4 | `step-04-fix.md` | Implement with strategic logging |
+| 5 | `step-05-verify.md` | Multi-layer verification (Static → Build → Runtime → User) |
+</step_files>
+
+<references>
+| File | Description |
+|------|-------------|
+| `references/log-technique.md` | Log placement patterns, prefixes, security guidelines |
+</references>
+
+<success_criteria>
+- Error successfully reproduced
+- Root cause identified through hypothesis testing
+- 2-3+ potential solutions researched with pros/cons
+- Solution selected (by user or auto mode)
+- Fix implemented with strategic logging
+- Static analysis passes (syntax, imports)
+- Build completes successfully
+- Tests pass (if tests exist)
+- **Runtime execution verified** (actual code path executed)
+- User confirms fix resolves the original issue
+- No regressions introduced
+</success_criteria>

package/src/config/claude-code-config/skills/workflow-debug/references/log-technique.md

@@ -0,0 +1,285 @@
+# Log Technique Reference
+
+## Overview
+
+The **Log Technique** is a debugging strategy where you add strategic logging to the codebase and ask the user to run the application and share the logs back. This provides visibility into the application's runtime behavior when:
+
+- The error cannot be reproduced directly by the AI
+- The environment is different (production, user's machine, specific setup)
+- The bug is intermittent or timing-sensitive
+- You need to understand the actual data flow
+
+## When to Use
+
+| Scenario | Use Log Technique? |
+|----------|-------------------|
+| Cannot reproduce error locally | ✅ Yes |
+| Need to see actual runtime data | ✅ Yes |
+| Production-only bug | ✅ Yes |
+| Intermittent / flaky error | ✅ Yes |
+| Clear stack trace with obvious cause | ❌ No |
+| Error in code you can run directly | ❌ No |
+
+## Log Placement Strategy
+
+### 1. Entry/Exit Points
+
+Log at the boundaries of the suspected problematic area:
+
+```javascript
+// Entry point
+console.log('[DEBUG:entry] functionName called', {
+  timestamp: new Date().toISOString(),
+  args: { param1, param2 }
+});
+
+// Exit point
+console.log('[DEBUG:exit] functionName completed', {
+  timestamp: new Date().toISOString(),
+  result: returnValue
+});
+```
+
+### 2. Decision Points
+
+Log at conditionals where behavior branches:
+
+```javascript
+console.log('[DEBUG:decision] checking condition', {
+  condition: someValue,
+  willTake: someValue > threshold ? 'if-branch' : 'else-branch'
+});
+
+if (someValue > threshold) {
+  console.log('[DEBUG:branch] took if-branch');
+  // ...
+} else {
+  console.log('[DEBUG:branch] took else-branch');
+  // ...
+}
+```
+
+### 3. Data Transformation Points
+
+Log before and after data changes:
+
+```javascript
+console.log('[DEBUG:transform:before] raw data', { data });
+const processed = transformData(data);
+console.log('[DEBUG:transform:after] processed data', { processed });
+```
+
+### 4. Async Boundaries
+
+Log async operations with timing:
+
+```javascript
+console.log('[DEBUG:async:start] fetching user', { userId, time: Date.now() });
+try {
+  const user = await fetchUser(userId);
+  console.log('[DEBUG:async:success] user fetched', { user, time: Date.now() });
+} catch (error) {
+  console.log('[DEBUG:async:error] fetch failed', { error: error.message, time: Date.now() });
+}
+```
+
+## Log Format Standards
+
+### Prefix Convention
+
+Use consistent prefixes for easy filtering:
+
+| Prefix | Purpose |
+|--------|---------|
+| `[DEBUG:entry]` | Function/method entry |
+| `[DEBUG:exit]` | Function/method exit |
+| `[DEBUG:decision]` | Conditional check |
+| `[DEBUG:branch]` | Branch taken |
+| `[DEBUG:transform]` | Data transformation |
+| `[DEBUG:async]` | Async operation |
+| `[DEBUG:error]` | Error caught |
+| `[DEBUG:state]` | State snapshot |
+
+### Required Information
+
+Each log should include:
+
+1. **What**: Clear description of the checkpoint
+2. **Where**: Function/component name
+3. **Data**: Relevant values (sanitized if sensitive)
+4. **Timing**: Timestamp for async/timing issues
+
+### Example Format
+
+```javascript
+console.log('[DEBUG:checkpoint-name] description', {
+  function: 'functionName',
+  timestamp: new Date().toISOString(),
+  data: { /* relevant values */ }
+});
+```
+
+## Language-Specific Patterns
+
+### JavaScript/TypeScript
+
+```javascript
+console.log('[DEBUG:xxx]', JSON.stringify({ ... }, null, 2));
+```
+
+### Python
+
+```python
+import logging
+logging.debug(f'[DEBUG:xxx] {{"key": "{value}"}}')
+# or
+print(f'[DEBUG:xxx]', {'key': value})
+```
+
+### Go
+
+```go
+log.Printf("[DEBUG:xxx] %+v\n", data)
+```
+
+### Rust
+
+```rust
+println!("[DEBUG:xxx] {:?}", data);
+// or with tracing
+tracing::debug!(?data, "checkpoint description");
+```
+
+## Asking for Logs - User Interaction
+
+### AskUserQuestion Pattern
+
+After adding logs, use this pattern:
+
+```yaml
+questions:
+  - header: "Run & Share"
+    question: "I've added debug logs to track the issue. Please run the application, reproduce the error, and paste the console output. Ready?"
+    options:
+      - label: "I'll run it now"
+        description: "I'll execute and share the logs"
+      - label: "Need different logs"
+        description: "The logs aren't in the right place"
+      - label: "Can't run it"
+        description: "I can't run the application right now"
+    multiSelect: false
+```
+
+### Follow-up After Receiving Logs
+
+```yaml
+questions:
+  - header: "Logs Analysis"
+    question: "Based on the logs, I found [X]. Do you want me to add more logs or proceed with the fix?"
+    options:
+      - label: "Proceed with fix (Recommended)"
+        description: "I have enough information"
+      - label: "Add more logs"
+        description: "I need deeper visibility"
+      - label: "Different area"
+        description: "The problem is elsewhere"
+    multiSelect: false
+```
+
+## Log Cleanup
+
+<critical>
+ALWAYS remove debug logs after the issue is resolved!
+</critical>
+
+### Tracking Logs for Removal
+
+Keep a list of added logs:
+
+| File | Line | Log Prefix |
+|------|------|------------|
+| src/api.ts | 45 | `[DEBUG:entry]` |
+| src/api.ts | 52 | `[DEBUG:exit]` |
+| src/utils.ts | 23 | `[DEBUG:transform]` |
+
+### Removal Process
+
+1. Search for `[DEBUG:` pattern in modified files
+2. Remove each log statement
+3. Verify no debug logs remain: `grep -r "\[DEBUG:" src/`
+
+## Security Considerations
+
+<critical>
+NEVER log sensitive data!
+</critical>
+
+### Sanitize Before Logging
+
+```javascript
+// BAD - logs password
+console.log('[DEBUG:auth]', { user, password });
+
+// GOOD - sanitized
+console.log('[DEBUG:auth]', {
+  user,
+  passwordProvided: !!password,
+  passwordLength: password?.length
+});
+```
+
+### Sensitive Data Checklist
+
+Never log:
+- Passwords, tokens, API keys
+- Personal identifiable information (PII)
+- Credit card numbers
+- Session identifiers
+- Internal IP addresses (in production)
+
+## Iterative Log Technique
+
+Sometimes one round isn't enough:
+
+```
+┌─────────────────────────────────────┐
+│  1. Add initial logs at boundaries  │
+└──────────────┬──────────────────────┘
+               ▼
+┌─────────────────────────────────────┐
+│  2. User runs & shares logs         │
+└──────────────┬──────────────────────┘
+               ▼
+┌─────────────────────────────────────┐
+│  3. Analyze - found root cause?     │
+└──────────────┬──────────────────────┘
+               │
+      ┌────────┴────────┐
+      ▼                 ▼
+   [YES]              [NO]
+      │                 │
+      ▼                 ▼
+┌─────────────┐  ┌──────────────────┐
+│ Remove logs │  │ Add deeper logs  │
+│ & fix issue │  │ & repeat step 2  │
+└─────────────┘  └──────────────────┘
+```
+
+## Quick Reference Card
+
+```
+┌────────────────────────────────────────────┐
+│           LOG TECHNIQUE CHECKLIST          │
+├────────────────────────────────────────────┤
+│ □ Identify suspected area                  │
+│ □ Add entry/exit logs                      │
+│ □ Add decision point logs                  │
+│ □ Add async boundary logs (if applicable)  │
+│ □ Sanitize sensitive data                  │
+│ □ Track all added logs                     │
+│ □ Ask user to run & share                  │
+│ □ Analyze returned logs                    │
+│ □ Iterate if needed                        │
+│ □ Remove ALL debug logs when done          │
+└────────────────────────────────────────────┘
+```