aiblueprint-cli 1.4.40 → 1.4.42

package/claude-code-config/skills/workflow-apex/SKILL.md

@@ -1,303 +0,0 @@
----
-name: apex
-description: Systematic implementation using APEX methodology (Analyze-Plan-Execute-eXamine) with parallel agents, self-validation, and optional adversarial review. Use when implementing features, fixing bugs, or making code changes that benefit from structured workflow.
-argument-hint: "[-a] [-x] [-s] [-t] [-b] [-pr] [-i] [-r <task-id>] <task description>"
----
-
-<objective>
-Execute systematic implementation workflows using the APEX methodology. This skill uses progressive step loading to minimize context usage and supports saving outputs for review and resumption.
-</objective>
-
-<quick_start>
-**Basic usage:**
-
-```bash
-/apex add authentication middleware
-```
-
-**Recommended workflow (autonomous with save):**
-
-```bash
-/apex -a -s implement user registration
-```
-
-**With adversarial review:**
-
-```bash
-/apex -a -x -s fix login bug
-```
-
-**Flags:**
-
-- `-a` (auto): Skip confirmations
-- `-s` (save): Save outputs to `.claude/output/apex/`
-- `-x` (examine): Include adversarial code review
-- `-t` (test): Create and run tests
-- `-pr` (pull-request): Create PR at end
-
-See `<parameters>` for complete flag list.
-</quick_start>
-
-<parameters>
-
-<flags>
-**Enable flags (turn ON):**
-| Short | Long | Description |
-|-------|------|-------------|
-| `-a` | `--auto` | Autonomous mode: skip confirmations, auto-approve plans |
-| `-x` | `--examine` | Auto-examine mode: proceed to adversarial review |
-| `-s` | `--save` | Save mode: output each step to `.claude/output/apex/` |
-| `-t` | `--test` | Test mode: include test creation and runner steps |
-| `-e` | `--economy` | Economy mode: no subagents, save tokens (for limited plans) |
-| `-r` | `--resume` | Resume mode: continue from a previous task |
-| `-b` | `--branch` | Branch mode: verify not on main, create branch if needed |
-| `-pr` | `--pull-request` | PR mode: create pull request at end (enables -b) |
-| `-i` | `--interactive` | Interactive mode: configure flags via AskUserQuestion |
-
-**Disable flags (turn OFF):**
-| Short | Long | Description |
-|-------|------|-------------|
-| `-A` | `--no-auto` | Disable auto mode |
-| `-X` | `--no-examine` | Disable examine mode |
-| `-S` | `--no-save` | Disable save mode |
-| `-T` | `--no-test` | Disable test mode |
-| `-E` | `--no-economy` | Disable economy mode |
-| `-B` | `--no-branch` | Disable branch mode |
-| `-PR` | `--no-pull-request` | Disable PR mode |
-</flags>
-
-<examples>
-```bash
-# Basic
-/apex add auth middleware
-
-# Autonomous (skip confirmations)
-/apex -a add auth middleware
-
-# Save outputs + examine
-/apex -a -x -s add auth middleware
-
-# Full workflow with tests
-/apex -a -x -s -t add auth middleware
-
-# With PR creation
-/apex -a -pr add auth middleware
-
-# Resume previous task
-/apex -r 01-auth-middleware
-/apex -r 01  # Partial match
-
-# Economy mode (save tokens)
-/apex -e add auth middleware
-
-# Interactive flag config
-/apex -i add auth middleware
-
-# Disable flags (uppercase)
-/apex -A add auth middleware  # Disable auto
-```
-</examples>
-
-<parsing_rules>
-**Flag parsing:**
-
-1. Defaults loaded from `steps/step-00-init.md` `<defaults>` section
-2. Command-line flags override defaults (enable with lowercase `-x`, disable with uppercase `-X`)
-3. Flags removed from input, remainder becomes `{task_description}`
-4. Task ID generated as `NN-kebab-case-description`
-
-For detailed parsing algorithm, see `steps/step-00-init.md`.
-</parsing_rules>
-
-</parameters>
-
-<output_structure>
-**When `{save_mode}` = true:**
-
-All outputs saved to PROJECT directory (where Claude Code is running):
-```
-
-.claude/output/apex/{task-id}/
-├── 00-context.md # Params, user request, timestamp
-├── 01-analyze.md # Analysis findings
-├── 02-plan.md # Implementation plan
-├── 03-execute.md # Execution log
-├── 04-validate.md # Validation results
-├── 05-examine.md # Review findings (if -x)
-├── 06-resolve.md # Resolution log (if -x)
-├── 07-tests.md # Test analysis and creation (if --test)
-├── 08-run-tests.md # Test runner log (if --test)
-└── 09-finish.md # Workflow finish and PR creation (if --pull-request)
-
-````
-
-**00-context.md structure:**
-```markdown
-# APEX Task: {task_id}
-
-**Created:** {timestamp}
-**Task:** {task_description}
-
-## Flags
-- Auto mode: {auto_mode}
-- Examine mode: {examine_mode}
-- Save mode: {save_mode}
-- Test mode: {test_mode}
-
-## User Request
-{original user input}
-
-## Acceptance Criteria
-- [ ] AC1: {inferred criterion}
-- [ ] AC2: {inferred criterion}
-````
-
-</output_structure>
-
-<resume_workflow>
-**Resume mode (`-r {task-id}`):**
-
-When provided, step-00 will:
-
-1. Locate the task folder in `.claude/output/apex/`
-2. Restore state from `00-context.md`
-3. Find the last completed step
-4. Continue from the next step
-
-Supports partial matching (e.g., `-r 01` finds `01-add-auth-middleware`).
-
-For implementation details, see `steps/step-00-init.md`.
-</resume_workflow>
-
-<workflow>
-**Standard flow:**
-1. Parse flags and task description
-2. If `-r`: Execute resume workflow
-3. If `-s`: Create output folder and 00-context.md
-4. Load step-01-analyze.md → gather context
-5. Load step-02-plan.md → create strategy
-6. Load step-03-execute.md → implement
-7. Load step-04-validate.md → verify
-8. If `--test`: Load step-07-tests.md → analyze and create tests
-9. If `--test`: Load step-08-run-tests.md → run until green
-10. If `-x` or user requests: Load step-05-examine.md → adversarial review
-11. If findings: Load step-06-resolve.md → fix findings
-12. If `-pr`: Load step-09-finish.md → create pull request
-</workflow>
-
-<state_variables>
-**Persist throughout all steps:**
-
-| Variable                | Type    | Description                                            |
-| ----------------------- | ------- | ------------------------------------------------------ |
-| `{task_description}`    | string  | What to implement (flags removed)                      |
-| `{feature_name}`        | string  | Kebab-case name without number (e.g., `add-auth-middleware`) |
-| `{task_id}`             | string  | Full identifier with number (e.g., `01-add-auth-middleware`) |
-| `{acceptance_criteria}` | list    | Success criteria (inferred or explicit)                |
-| `{auto_mode}`           | boolean | Skip confirmations, use recommended options            |
-| `{examine_mode}`        | boolean | Auto-proceed to adversarial review                     |
-| `{save_mode}`           | boolean | Save outputs to .claude/output/apex/                   |
-| `{test_mode}`           | boolean | Include test steps (07-08)                             |
-| `{economy_mode}`        | boolean | No subagents, direct tool usage only                   |
-| `{branch_mode}`         | boolean | Verify not on main, create branch if needed            |
-| `{pr_mode}`             | boolean | Create pull request at end                             |
-| `{interactive_mode}`    | boolean | Configure flags interactively                          |
-| `{resume_task}`         | string  | Task ID to resume (if -r provided)                     |
-| `{output_dir}`          | string  | Full path to output directory                          |
-| `{branch_name}`         | string  | Created branch name (if branch_mode)                   |
-
-</state_variables>
-
-<entry_point>
-
-**FIRST ACTION:** Load `steps/step-00-init.md`
-
-Step 00 handles:
-
-- Flag parsing (-a, -x, -s, -r, --test)
-- Resume mode detection and task lookup
-- Output folder creation (if save_mode)
-- 00-context.md creation (if save_mode)
-- State variable initialization
-
-After initialization, step-00 loads step-01-analyze.md.
-
-</entry_point>
-
-<step_files>
-**Progressive loading - only load current step:**
-
-| Step | File                         | Purpose                                              |
-| ---- | ---------------------------- | ---------------------------------------------------- |
-| 00   | `steps/step-00-init.md`      | Parse flags, create output folder, initialize state  |
-| 01   | `steps/step-01-analyze.md`   | Smart context gathering with 1-10 parallel agents based on complexity |
-| 02   | `steps/step-02-plan.md`      | File-by-file implementation strategy                 |
-| 03   | `steps/step-03-execute.md`   | Todo-driven implementation                           |
-| 04   | `steps/step-04-validate.md`  | Self-check and validation                            |
-| 05   | `steps/step-05-examine.md`   | Adversarial code review (optional)                   |
-| 06   | `steps/step-06-resolve.md`   | Finding resolution (optional)                        |
-| 07   | `steps/step-07-tests.md`     | Test analysis and creation (if --test)               |
-| 08   | `steps/step-08-run-tests.md` | Test runner loop until green (if --test)             |
-| 09   | `steps/step-09-finish.md`    | Create pull request (if --pull-request)              |
-
-</step_files>
-
-<execution_rules>
-
-- **Load one step at a time** - Only load the current step file
-- **ULTRA THINK** before major decisions
-- **Persist state variables** across all steps
-- **Follow next_step directive** at end of each step
-- **Save outputs** if `{save_mode}` = true (append to step file)
-- **Use parallel agents** for independent exploration tasks
-
-## 🧠 Smart Agent Strategy in Analyze Phase
-
-The analyze phase (step-01) uses **adaptive agent launching** (unless economy_mode):
-
-**Available agents:**
-- `explore-codebase` - Find existing patterns, files, utilities
-- `explore-docs` - Research library docs (use when unfamiliar with API)
-- `websearch` - Find approaches, best practices, gotchas
-
-**Launch 1-10 agents based on task complexity:**
-
-| Complexity | Agents | When |
-|------------|--------|------|
-| Simple | 1-2 | Bug fix, small tweak |
-| Medium | 2-4 | New feature in familiar stack |
-| Complex | 4-7 | Unfamiliar libraries, integrations |
-| Major | 6-10 | Multiple systems, many unknowns |
-
-**BE SMART:** Analyze what you actually need before launching. Don't over-launch for simple tasks, don't under-launch for complex ones.
-
-</execution_rules>
-
-<save_output_pattern>
-**When `{save_mode}` = true:**
-
-Step-00 runs `scripts/setup-templates.sh` to initialize all output files from `templates/` directory.
-
-**Each step then:**
-
-1. Run `scripts/update-progress.sh {task_id} {step_num} {step_name} "in_progress"`
-2. Append findings/outputs to the pre-created step file
-3. Run `scripts/update-progress.sh {task_id} {step_num} {step_name} "complete"`
-
-**Template system benefits:**
-
-- Reduces token usage by ~75% (1,350 tokens saved per workflow)
-- Templates in `templates/` directory (not inline in steps)
-- Scripts handle progress tracking automatically
-- See `templates/README.md` for details
-
-</save_output_pattern>
-
-<success_criteria>
-
-- Each step loaded progressively
-- All validation checks passing
-- Outputs saved if `{save_mode}` enabled
-- Tests passing if `{test_mode}` enabled
-- Clear completion summary provided
-  </success_criteria>

package/claude-code-config/skills/workflow-apex/steps/step-02-plan.md

@@ -1,264 +0,0 @@
----
-name: step-02-plan
-description: Strategic planning - create detailed file-by-file implementation strategy
-prev_step: steps/step-01-analyze.md
-next_step: steps/step-03-execute.md
----
-
-# Step 2: Plan (Strategic Design)
-
-## MANDATORY EXECUTION RULES (READ FIRST):
-
-- 🛑 NEVER start implementing - that's step 3
-- 🛑 NEVER write or modify code in this step
-- ✅ ALWAYS structure plan by FILE, not by feature
-- ✅ ALWAYS include specific line numbers from analysis
-- ✅ ALWAYS map acceptance criteria to file changes
-- 📋 YOU ARE A PLANNER, not an implementer
-- 💬 FOCUS on "What changes need to be made where?"
-- 🚫 FORBIDDEN to use Edit, Write, or Bash tools
-
-## EXECUTION PROTOCOLS:
-
-- 🎯 ULTRA THINK before creating the plan
-- 💾 Save plan to output file (if save_mode)
-- 📖 Reference patterns from step-01 analysis
-- 🚫 FORBIDDEN to proceed until user approves plan (unless auto_mode)
-
-## CONTEXT BOUNDARIES:
-
-- Context from step-01 (files, patterns, utilities) is available
-- Implementation has NOT started
-- User has NOT approved any changes yet
-- Plan must be complete before execution
-
-## YOUR TASK:
-
-Transform analysis findings into a comprehensive, executable, file-by-file implementation plan.
-
----
-
-<available_state>
-From previous steps:
-
-| Variable | Description |
-|----------|-------------|
-| `{task_description}` | What to implement |
-| `{task_id}` | Kebab-case identifier |
-| `{acceptance_criteria}` | Success criteria from step-01 |
-| `{auto_mode}` | Skip confirmations |
-| `{save_mode}` | Save outputs to files |
-| `{output_dir}` | Path to output (if save_mode) |
-| Files found | From step-01 codebase exploration |
-| Patterns | From step-01 pattern analysis |
-| Utilities | From step-01 utility discovery |
-</available_state>
-
----
-
-## EXECUTION SEQUENCE:
-
-### 1. Initialize Save Output (if save_mode)
-
-**If `{save_mode}` = true:**
-
-```bash
-bash {skill_dir}/scripts/update-progress.sh "{task_id}" "02" "plan" "in_progress"
-```
-
-Append plan to `{output_dir}/02-plan.md` as you work.
-
-### 2. ULTRA THINK: Design Complete Strategy
-
-**CRITICAL: Think through ENTIRE implementation before writing any plan.**
-
-Mental simulation:
-- Walk through the implementation step by step
-- Identify all files that need changes
-- Determine logical order (dependencies first)
-- Consider edge cases and error handling
-- Plan test coverage
-
-### 3. Clarify Ambiguities
-
-**If `{auto_mode}` = true:**
-→ Use recommended option for any ambiguity, proceed automatically
-
-**If `{auto_mode}` = false AND multiple valid approaches exist:**
-
-```yaml
-questions:
-  - header: "Approach"
-    question: "Multiple approaches are possible. Which should we use?"
-    options:
-      - label: "Approach A (Recommended)"
-        description: "Description and tradeoffs of A"
-      - label: "Approach B"
-        description: "Description and tradeoffs of B"
-      - label: "Approach C"
-        description: "Description and tradeoffs of C"
-    multiSelect: false
-```
-
-### 4. Create Detailed Plan
-
-**Structure by FILE, not by feature:**
-
-```markdown
-## Implementation Plan: {task_description}
-
-### Overview
-[1-2 sentences: High-level strategy and approach]
-
-### Prerequisites
-- [ ] Prerequisite 1 (if any)
-- [ ] Prerequisite 2 (if any)
-
----
-
-### File Changes
-
-#### `src/path/file1.ts`
-- Add `functionName` that handles X
-- Extract logic from Y (follow pattern in `example.ts:45`)
-- Handle error case: [specific scenario]
-- Consider: [edge case or important context]
-
-#### `src/path/file2.ts`
-- Update imports to include new module
-- Call `functionName` in existing flow at line ~42
-- Update types: Add `NewType` interface
-
-#### `src/path/file3.ts` (NEW FILE)
-- Create utility for Z
-- Export: `utilityFunction`, `HelperType`
-- Pattern: Follow `similar-util.ts` structure
-
----
-
-### Testing Strategy
-
-**New tests:**
-- `src/path/file1.test.ts` - Test functionName with:
-  - Happy path
-  - Error case
-  - Edge case
-
-**Update existing:**
-- `src/path/existing.test.ts` - Add test for new flow
-
----
-
-### Acceptance Criteria Mapping
-- [ ] AC1: Satisfied by changes in `file1.ts`
-- [ ] AC2: Satisfied by changes in `file2.ts`
-
----
-
-### Risks & Considerations
-- Risk 1: [potential issue and mitigation]
-```
-
-**If `{save_mode}` = true:** Append full plan to 02-plan.md
-
-### 5. Verify Plan Completeness
-
-Checklist:
-- [ ] All files identified - nothing missing
-- [ ] Logical order - dependencies handled first
-- [ ] Clear actions - every step specific and actionable
-- [ ] Test coverage - all paths have test strategy
-- [ ] In scope - no scope creep
-- [ ] AC mapped - every criterion has implementation
-
-### 6. Present Plan for Approval
-
-```
-**Implementation Plan Ready**
-
-**Overview:** [1 sentence summary]
-
-**Files to modify:** {count} files
-**New files:** {count} files
-**Tests:** {count} test files
-
-**Estimated changes:**
-- `file1.ts` - Major changes (add function, handle errors)
-- `file2.ts` - Minor changes (imports, single call)
-- `file1.test.ts` - New test file
-```
-
-**If `{auto_mode}` = true:**
-→ Skip confirmation, proceed directly to execution
-
-**If `{auto_mode}` = false:**
-
-```yaml
-questions:
-  - header: "Plan"
-    question: "Review the implementation plan. Ready to proceed?"
-    options:
-      - label: "Approve and execute (Recommended)"
-        description: "Plan looks good, start implementation"
-      - label: "Adjust plan"
-        description: "I want to modify specific parts"
-      - label: "Ask questions"
-        description: "I have questions about the plan"
-      - label: "Start over"
-        description: "Revise the entire plan"
-    multiSelect: false
-```
-
-### 7. Complete Save Output (if save_mode)
-
-**If `{save_mode}` = true:**
-
-Append to `{output_dir}/02-plan.md`:
-```markdown
----
-## Step Complete
-**Status:** ✓ Complete
-**Files planned:** {count}
-**Tests planned:** {count}
-**Next:** step-03-execute.md
-**Timestamp:** {ISO timestamp}
-```
-
----
-
-## SUCCESS METRICS:
-
-✅ Complete file-by-file plan created
-✅ Logical dependency order established
-✅ All acceptance criteria mapped to changes
-✅ Test strategy defined
-✅ User approved plan (or auto-approved)
-✅ NO code written or modified
-✅ Output saved (if save_mode)
-
-## FAILURE MODES:
-
-❌ Organizing by feature instead of file
-❌ Vague actions like "add feature" or "fix issue"
-❌ Missing test strategy
-❌ Not mapping to acceptance criteria
-❌ Starting to write code (that's step 3!)
-❌ **CRITICAL**: Not using AskUserQuestion for approval
-
-## PLANNING PROTOCOLS:
-
-- Structure by FILE - each file is a section
-- Include line number references from analysis
-- Every action must be specific and actionable
-- Map every AC to specific file changes
-- Plan tests alongside implementation
-
----
-
-## NEXT STEP:
-
-After user approves via AskUserQuestion (or auto-proceed), load `./step-03-execute.md`
-
-<critical>
-Remember: Planning is ONLY about designing the approach - save all implementation for step-03!
-</critical>