nemonix-cli 1.0.0

package/src/config/claude-code-config/skills/meta-skill-workflow-creator/references/step-template.md

@@ -0,0 +1,334 @@
+# Step Template
+
+Use this template as the base for any workflow step. Based on BMAD micro-file architecture.
+
+---
+
+## Complete Step Template
+
+```markdown
+---
+name: step-NN-{name}
+description: {What this step does}
+prev_step: steps/step-{NN-1}-{prev-name}.md
+next_step: steps/step-{NN+1}-{next-name}.md
+---
+
+# Step {N}: {Title}
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER {critical forbidden action}
+- ✅ ALWAYS {critical required action}
+- 📋 YOU ARE A {role}, not a {anti-role}
+- 💬 FOCUS on {this step's scope} only
+- 🚫 FORBIDDEN to {boundary violation}
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- 💾 Update document/frontmatter after each phase
+- 📖 Complete this step fully before loading next
+- 🚫 FORBIDDEN to load next step until {completion criteria}
+
+## CONTEXT BOUNDARIES:
+
+- Variables from previous steps are available in memory
+- Previous context = what's in output document + frontmatter
+- Don't assume knowledge from future steps
+- {Resource} loaded on-demand when needed
+
+## YOUR TASK:
+
+{One clear sentence describing what this step accomplishes}
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. {First Phase Name}
+
+{Instructions for first phase}
+
+**If `{save_mode}` = true:** Append to `{output_dir}/NN-{step-name}.md`
+
+### 2. {Second Phase Name}
+
+{Instructions for second phase}
+
+### 3. {Third Phase Name}
+
+**If `{auto_mode}` = true:**
+→ Use recommended option, proceed automatically
+
+**If `{auto_mode}` = false:**
+→ Use AskUserQuestion:
+
+```yaml
+questions:
+  - header: "Confirm"
+    question: "Phase 3 complete. Ready to proceed?"
+    options:
+      - label: "Continue (Recommended)"
+        description: "Proceed to next phase"
+      - label: "Review first"
+        description: "I want to review before continuing"
+      - label: "Go back"
+        description: "Return to previous step"
+    multiSelect: false
+```
+
+### 4. Update State
+
+**Update frontmatter:**
+```yaml
+---
+stepsCompleted: [1, 2, ..., N]
+{new_variable}: '{value}'
+---
+```
+
+**Append to document:**
+```markdown
+## {Section Title}
+
+{Content based on this step's work}
+```
+
+---
+
+## SUCCESS METRICS:
+
+✅ {Success criterion 1}
+✅ {Success criterion 2}
+✅ {Success criterion 3}
+✅ Frontmatter properly updated with step state
+✅ Output saved (if save_mode)
+
+## FAILURE MODES:
+
+❌ {Failure mode 1}
+❌ {Failure mode 2}
+❌ {Failure mode 3}
+❌ **CRITICAL**: Proceeding without completing this step fully
+❌ **CRITICAL**: Not using AskUserQuestion for user input
+
+## {STEP NAME} PROTOCOLS:
+
+- {Protocol 1 specific to this step}
+- {Protocol 2 specific to this step}
+- {Protocol 3 specific to this step}
+
+---
+
+## NEXT STEP:
+
+After user confirms via AskUserQuestion, load `./step-{NN+1}-{next-name}.md`
+
+<critical>
+Remember: {Important reminder about this step's boundaries}
+</critical>
+```
+
+---
+
+## Init Step Template (step-00-init.md)
+
+```markdown
+---
+name: step-00-init
+description: Initialize workflow - parse flags, detect continuation, setup state
+next_step: steps/step-01-{first-step}.md
+---
+
+# Step 0: Initialization
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER skip flag parsing
+- ✅ ALWAYS check for existing workflow before creating new
+- 📋 Parse ALL flags before any other action
+- 💬 FOCUS on initialization only - don't look ahead
+- 🚫 FORBIDDEN to proceed without proper state setup
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Parse flags first, then check resume, then setup
+- 💾 Create output structure if save_mode
+- 📖 Initialize frontmatter with all state variables
+- 🚫 FORBIDDEN to load step-01 until init complete
+
+## YOUR TASK:
+
+Initialize the workflow by parsing flags, detecting continuation state, and setting up the execution environment.
+
+---
+
+## DEFAULTS CONFIGURATION:
+
+```yaml
+# Edit these to change default behavior
+flag_a: false      # -a: Description
+flag_b: false      # -b: Description
+save_mode: false   # -s: Save outputs
+auto_mode: false   # -a: Skip confirmations
+```
+
+---
+
+## INITIALIZATION SEQUENCE:
+
+### 1. Parse Flags and Input
+
+**Step 1: Load defaults from config above**
+
+**Step 2: Parse user input and override defaults:**
+```
+Enable flags (lowercase):
+  -a → {flag_a} = true
+  -b → {flag_b} = true
+
+Disable flags (UPPERCASE):
+  -A → {flag_a} = false
+  -B → {flag_b} = false
+
+Remainder → {task_description}
+```
+
+### 2. Check for Existing Workflow
+
+**If output document exists with `stepsCompleted` in frontmatter:**
+- Read frontmatter to restore state
+- Find last completed step
+- Load next incomplete step
+- **STOP** - do not continue with fresh init
+
+**If no existing workflow:**
+→ Continue to step 3
+
+### 3. Create Output Structure (if save_mode)
+
+```bash
+mkdir -p {output_dir}
+```
+
+Create `00-context.md`:
+```markdown
+# Task: {task_id}
+
+**Created:** {timestamp}
+**Task:** {task_description}
+
+## Configuration
+| Flag | Value |
+|------|-------|
+| flag_a | {value} |
+| flag_b | {value} |
+
+## Progress
+| Step | Status | Timestamp |
+|------|--------|-----------|
+| 00-init | ✓ | {timestamp} |
+| 01-{name} | ⏸ Pending | |
+```
+
+### 4. Confirm Start
+
+**If `{auto_mode}` = true:**
+→ Proceed directly to step-01
+
+**If `{auto_mode}` = false:**
+Use AskUserQuestion:
+```yaml
+questions:
+  - header: "Start"
+    question: "Workflow initialized. Ready to begin?"
+    options:
+      - label: "Begin (Recommended)"
+        description: "Start the workflow"
+      - label: "Modify settings"
+        description: "I want to change the configuration"
+      - label: "Cancel"
+        description: "Don't start this workflow"
+    multiSelect: false
+```
+
+---
+
+## SUCCESS METRICS:
+
+✅ All flags correctly parsed
+✅ Existing workflow detected and resumed properly
+✅ Fresh workflow initialized with proper structure
+✅ Output folder created (if save_mode)
+✅ State variables set for subsequent steps
+
+## FAILURE MODES:
+
+❌ Proceeding with fresh init when existing workflow exists
+❌ Not parsing all flags before proceeding
+❌ Missing state variables in frontmatter
+❌ Not creating output structure when save_mode
+
+---
+
+## NEXT STEP:
+
+After initialization, load `./step-01-{first-step}.md`
+
+<critical>
+Remember: Init is ONLY about setup - don't start actual work here!
+</critical>
+```
+
+---
+
+## Conditional Branching Template
+
+```markdown
+## NEXT STEP DECISION:
+
+**If `{auto_mode}` = true:**
+→ Use first/recommended option automatically
+
+**If `{auto_mode}` = false:**
+Use AskUserQuestion:
+```yaml
+questions:
+  - header: "Path"
+    question: "Which path would you like to take?"
+    options:
+      - label: "Option A (Recommended)"
+        description: "Description of path A"
+      - label: "Option B"
+        description: "Description of path B"
+      - label: "Option C"
+        description: "Description of path C"
+    multiSelect: false
+```
+
+**Route based on response:**
+- **Option A:** Load `./step-03a-option.md`
+- **Option B:** Load `./step-03b-option.md`
+- **Option C:** Load `./step-03c-option.md`
+```
+
+---
+
+## Key Elements Checklist
+
+Every step file MUST have:
+
+- [ ] Frontmatter with name, description, prev/next step
+- [ ] **MANDATORY EXECUTION RULES** section with emojis
+- [ ] **EXECUTION PROTOCOLS** section
+- [ ] **CONTEXT BOUNDARIES** section
+- [ ] **YOUR TASK** - single clear sentence
+- [ ] Numbered **EXECUTION SEQUENCE**
+- [ ] Auto mode handling (skip AskUserQuestion if auto)
+- [ ] Save mode handling (append to output if save)
+- [ ] **SUCCESS METRICS** with ✅ checkmarks
+- [ ] **FAILURE MODES** with ❌ marks
+- [ ] **PROTOCOLS** section specific to step
+- [ ] **NEXT STEP** section with clear routing
+- [ ] `<critical>` reminder at the end

package/src/config/claude-code-config/skills/meta-skill-workflow-creator/references/workflow-patterns.md

@@ -0,0 +1,300 @@
+# Workflow Patterns
+
+Common patterns for designing multi-step workflows.
+
+---
+
+## Pattern 1: Linear Workflow
+
+Steps execute in sequence, each depending on the previous.
+
+```
+┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
+│  Step 1  │───►│  Step 2  │───►│  Step 3  │───►│  Step 4  │
+│ Analyze  │    │   Plan   │    │ Execute  │    │ Validate │
+└──────────┘    └──────────┘    └──────────┘    └──────────┘
+```
+
+**Use when:** Each step builds on the previous, no branching needed.
+
+**Example:** Basic implementation workflow
+
+```markdown
+next_step: steps/step-02-plan.md  # Always goes to next step
+```
+
+---
+
+## Pattern 2: Conditional Branching
+
+Different paths based on conditions or user choice.
+
+```
+                              ┌──────────┐
+                         ┌───►│ Step 3a  │
+┌──────────┐    ┌────────┴─┐  │  Quick   │
+│  Step 1  │───►│  Step 2  │  └──────────┘
+│ Analyze  │    │  Decide  │
+└──────────┘    └────────┬─┘  ┌──────────┐
+                         └───►│ Step 3b  │
+                              │ Thorough │
+                              └──────────┘
+```
+
+**Use when:** User needs to choose approach, or conditions determine path.
+
+**Implementation:**
+
+```markdown
+<next_step_decision>
+IF {scope} = "quick":
+    → Load step-03a-quick.md
+
+ELSE IF {scope} = "thorough":
+    → Load step-03b-thorough.md
+
+ELSE:
+    → Ask user to choose
+</next_step_decision>
+```
+
+---
+
+## Pattern 3: Optional Steps
+
+Some steps only run if certain flags are set.
+
+```
+┌──────────┐    ┌──────────┐    ┌──────────┐    ┌ ─ ─ ─ ─ ┐    ┌──────────┐
+│  Step 1  │───►│  Step 2  │───►│  Step 3  │───►  Step 4  ├───►│  Step 5  │
+│ Analyze  │    │   Plan   │    │ Execute  │    │  Tests   │    │ Complete │
+└──────────┘    └──────────┘    └──────────┘    └ ─ ─ ─ ─ ┘    └──────────┘
+                                                (if --test)
+```
+
+**Use when:** Features like testing, review are optional.
+
+**Implementation:**
+
+```markdown
+<next_step_decision>
+IF {test_mode} = true:
+    → Load step-04-tests.md
+
+ELSE:
+    → Load step-05-complete.md
+</next_step_decision>
+```
+
+---
+
+## Pattern 4: Loop Until Success
+
+Repeat a step until condition is met.
+
+```
+┌──────────┐    ┌──────────┐    ┌──────────┐
+│  Step 1  │───►│  Step 2  │───►│  Step 3  │
+│  Setup   │    │   Run    │◄──┐│ Complete │
+└──────────┘    └────┬─────┘   │└──────────┘
+                     │         │
+                     ▼         │
+                ┌─────────┐    │
+                │ Failed? │────┘
+                │   Fix   │ (loop back)
+                └─────────┘
+```
+
+**Use when:** Running tests until green, fixing errors.
+
+**Implementation:**
+
+```markdown
+<execution_loop>
+max_attempts = 10
+attempt = 0
+
+WHILE attempt < max_attempts:
+    attempt += 1
+
+    1. Run the operation
+    2. Check result
+
+    IF success:
+        → EXIT LOOP
+
+    IF failure:
+        → Fix the issue
+        → CONTINUE LOOP
+
+    IF same_failure_3_times:
+        → Ask user for help
+</execution_loop>
+```
+
+---
+
+## Pattern 5: Parallel Then Merge
+
+Multiple independent operations, then combine results.
+
+```
+              ┌──────────┐
+         ┌───►│ Agent 1  │───┐
+         │    │ Research │   │
+┌────────┴─┐  └──────────┘   │  ┌──────────┐    ┌──────────┐
+│  Step 1  │                 ├─►│  Step 2  │───►│  Step 3  │
+│  Split   │  ┌──────────┐   │  │  Merge   │    │ Execute  │
+└────────┬─┘  │ Agent 2  │   │  └──────────┘    └──────────┘
+         │    │ Explore  │   │
+         └───►└──────────┘───┘
+```
+
+**Use when:** Multiple independent explorations, then synthesis.
+
+**Implementation:**
+
+```markdown
+<parallel_execution>
+**Launch ALL agents in a SINGLE message:**
+
+Agent 1: explore-codebase
+Agent 2: explore-docs
+Agent 3: websearch
+
+**Wait for all to complete, then merge results.**
+</parallel_execution>
+```
+
+---
+
+## Pattern 6: Pipeline with Checkpoints
+
+Save state at each step for resume capability.
+
+```
+┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
+│  Step 1  │───►│  Step 2  │───►│  Step 3  │───►│  Step 4  │
+│ Analyze  │    │   Plan   │    │ Execute  │    │ Validate │
+└────┬─────┘    └────┬─────┘    └────┬─────┘    └────┬─────┘
+     │               │               │               │
+     ▼               ▼               ▼               ▼
+┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐
+│01-analyze│   │02-plan  │    │03-execute│   │04-validate│
+│   .md    │    │  .md   │    │   .md    │   │   .md    │
+└─────────┘    └─────────┘    └─────────┘    └─────────┘
+```
+
+**Use when:** Long workflows that might be interrupted.
+
+**Implementation:**
+
+```markdown
+<save_checkpoint>
+**At end of each step:**
+
+1. Write step output to {output_dir}/NN-step.md
+2. Update progress in 00-context.md
+3. Include completion marker
+
+**On resume:**
+
+1. Read 00-context.md
+2. Find last completed step
+3. Load next step
+</save_checkpoint>
+```
+
+---
+
+## Pattern 7: Review and Resolve
+
+Adversarial review followed by resolution.
+
+```
+┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
+│ Execute  │───►│  Review  │───►│ Findings │───►│ Resolve  │
+│          │    │(optional)│    │  Table   │    │ Findings │
+└──────────┘    └──────────┘    └──────────┘    └──────────┘
+                     │
+              (if -x flag)
+```
+
+**Use when:** Code review, quality checks.
+
+**Implementation:**
+
+```markdown
+<review_flow>
+IF {examine_mode} = true OR user_requests:
+    1. Launch review agent
+    2. Collect findings
+    3. Present findings table
+    4. Load step-06-resolve.md
+
+ELSE:
+    → Skip to completion
+</review_flow>
+```
+
+---
+
+## Pattern 8: Economy Mode Override
+
+Alternative lightweight path for resource savings.
+
+```
+┌──────────┐         ┌──────────────┐
+│  Init    │────────►│ step-00b.md  │ (if -e flag)
+│          │         │ Economy rules│
+└──────────┘         └──────────────┘
+                           │
+                     Overrides all
+                     subsequent steps
+```
+
+**Use when:** Offering a lighter-weight alternative.
+
+**Implementation:**
+
+```markdown
+<economy_mode>
+IF {economy_mode} = true:
+    → Load economy override file
+    → Apply rules to all steps:
+      - No subagents
+      - Direct tools only
+      - Minimal exploration
+</economy_mode>
+```
+
+---
+
+## Choosing a Pattern
+
+| Workflow Type | Pattern |
+|---------------|---------|
+| Simple sequential | Linear |
+| User choice needed | Conditional Branching |
+| Features toggleable | Optional Steps |
+| Error fixing | Loop Until Success |
+| Research phase | Parallel Then Merge |
+| Resumable | Pipeline with Checkpoints |
+| Quality checks | Review and Resolve |
+| Budget option | Economy Mode Override |
+
+---
+
+## Combining Patterns
+
+Real workflows often combine multiple patterns:
+
+```
+APEX Workflow:
+- Linear (steps 1-4)
+- Optional Steps (review if -x, tests if -t)
+- Parallel (agents in step 1)
+- Loop (tests until green in step 8)
+- Checkpoints (save mode)
+- Economy Override (if -e)
+```