aiblueprint-cli 1.4.23 → 1.4.25

package/claude-code-config/skills/{create-subagents → meta-subagent-creator}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: create-subagents
+name: skill-workflow-creator
 description: Expert guidance for creating, building, and using Claude Code subagents and the Task tool. Use when working with subagents, setting up agent configurations, understanding how agents work, or using the Task tool to launch specialized agents.
 ---
 
@@ -11,6 +11,7 @@ Subagents enable delegation of complex tasks to specialized agents that operate
 
 <quick_start>
 <workflow>
+
 1. Run `/agents` command
 2. Select "Create New Agent"
 3. Choose project-level (`.claude/agents/`) or user-level (`~/.claude/agents/`)
@@ -20,7 +21,7 @@ Subagents enable delegation of complex tasks to specialized agents that operate
    - **tools**: Optional comma-separated list (inherits all if omitted)
    - **model**: Optional (`sonnet`, `opus`, `haiku`, or `inherit`)
 5. Write the system prompt (the subagent's instructions)
-</workflow>
+   </workflow>
 
 <example>
 ```markdown
@@ -36,15 +37,17 @@ You are a senior code reviewer focused on quality, security, and best practices.
 </role>
 
 <focus_areas>
+
 - Code quality and maintainability
 - Security vulnerabilities
 - Performance issues
 - Best practices adherence
-</focus_areas>
+  </focus_areas>
 
 <output_format>
 Provide specific, actionable feedback with file:line references.
 </output_format>
+
 ```
 </example>
 </quick_start>
@@ -115,16 +118,18 @@ Use **subagents** for:
 
 **Example workflow pattern:**
 ```
+
 Main Chat: Ask user for requirements (AskUserQuestion)
-  ↓
+↓
 Subagent: Research API and create documentation (no user interaction)
-  ↓
+↓
 Main Chat: Review research with user, confirm approach
-  ↓
+↓
 Subagent: Generate code based on confirmed plan
-  ↓
+↓
 Main Chat: Present results, handle testing/deployment
-```
+
+````
 </workflow_design>
 </execution_model>
 
@@ -161,7 +166,8 @@ You are a senior code reviewer specializing in security.
 3. Provide specific remediation steps
 4. Rate severity (Critical/High/Medium/Low)
 </workflow>
-```
+````
+
 </principle>
 
 <principle name="task_specific">
@@ -185,21 +191,24 @@ Common tags for subagent structure:
 - `<output_format>` - How to structure deliverables
 - `<success_criteria>` - Completion criteria
 - `<validation>` - How to verify work
-</recommended_tags>
+  </recommended_tags>
 
 <intelligence_rules>
 **Simple subagents** (single focused task):
+
 - Use role + constraints + workflow minimum
 - Example: code-reviewer, test-runner
 
 **Medium subagents** (multi-step process):
+
 - Add workflow steps, output_format, success_criteria
 - Example: api-researcher, documentation-generator
 
 **Complex subagents** (research + generation + validation):
+
 - Add all tags as appropriate including validation, examples
 - Example: mcp-api-researcher, comprehensive-auditor
-</intelligence_rules>
+  </intelligence_rules>
 
 <critical_rule>
 **Remove ALL markdown headings (##, ###) from subagent body.** Use semantic XML tags instead.
@@ -225,6 +234,7 @@ You can explicitly invoke a subagent:
 ```
 > Have the test-writer subagent create tests for the new API endpoints
 ```
+
 </explicit>
 </invocation>
 
@@ -266,11 +276,13 @@ TaskOutput tool call:
 
 **Non-blocking check:**
 Set `block: false` to check status without waiting:
+
 ```
 TaskOutput tool call:
 - task_id: "agent-12345"
 - block: false
 ```
+
 Returns current status: running, completed, or the final result.
 </retrieving_results>
 
@@ -302,31 +314,37 @@ Task 3:
 ```
 
 Then retrieve all results:
+
 ```
 TaskOutput calls for each agent_id
 ```
+
 </parallel_agents>
 
 <when_to_use_background>
 **Use background agents for:**
+
 - Long-running analysis (security review, comprehensive code analysis)
 - Multiple independent tasks that can run in parallel
 - Tasks where you want to continue working while waiting
 - Research tasks that may take significant time
 
 **Don't use background for:**
+
 - Quick operations (< 10 seconds)
 - Tasks that depend on each other sequentially
 - Tasks where immediate results are needed for next step
 - Simple single-file operations
 
 **Pattern: Parallel Analysis Pipeline**
+
 ```
 1. Launch multiple analysis agents in background
 2. Continue with other work or wait
 3. Collect all results
 4. Synthesize findings in main conversation
 ```
+
 </when_to_use_background>
 
 <resuming_agents>
@@ -356,15 +374,17 @@ Run `/agents` for an interactive interface to:
 
 <manual_editing>
 You can also edit subagent files directly:
+
 - Project: `.claude/agents/subagent-name.md`
 - User: `~/.claude/agents/subagent-name.md`
-</manual_editing>
-</management>
+  </manual_editing>
+  </management>
 
 <reference>
 **Core references**:
 
 **Subagent usage and configuration**: [references/subagents.md](references/subagents.md)
+
 - File format and configuration
 - Model selection (Sonnet 4.5 + Haiku 4.5 orchestration)
 - Tool security and least privilege
@@ -373,6 +393,7 @@ You can also edit subagent files directly:
 - Complete examples
 
 **Writing effective prompts**: [references/writing-subagent-prompts.md](references/writing-subagent-prompts.md)
+
 - Core principles and XML structure
 - Description field optimization for routing
 - Extended thinking for complex reasoning
@@ -382,35 +403,40 @@ You can also edit subagent files directly:
 **Advanced topics**:
 
 **Evaluation and testing**: [references/evaluation-and-testing.md](references/evaluation-and-testing.md)
+
 - Evaluation metrics (task completion, tool correctness, robustness)
 - Testing strategies (offline, simulation, online monitoring)
 - Evaluation-driven development
 - G-Eval for custom criteria
 
 **Error handling and recovery**: [references/error-handling-and-recovery.md](references/error-handling-and-recovery.md)
+
 - Common failure modes and causes
 - Recovery strategies (graceful degradation, retry, circuit breakers)
 - Structured communication and observability
 - Anti-patterns to avoid
 
 **Context management**: [references/context-management.md](references/context-management.md)
+
 - Memory architecture (STM, LTM, working memory)
 - Context strategies (summarization, sliding window, scratchpads)
 - Managing long-running tasks
 - Prompt caching interaction
 
 **Orchestration patterns**: [references/orchestration-patterns.md](references/orchestration-patterns.md)
+
 - Sequential, parallel, hierarchical, coordinator patterns
 - Sonnet + Haiku orchestration for cost/performance
 - Multi-agent coordination
 - Pattern selection guidance
 
 **Debugging and troubleshooting**: [references/debugging-agents.md](references/debugging-agents.md)
+
 - Logging, tracing, and correlation IDs
 - Common failure types (hallucinations, format errors, tool misuse)
 - Diagnostic procedures
 - Continuous monitoring
-</reference>
+  </reference>
 
 <success_criteria>
 A well-configured subagent has:
@@ -422,4 +448,4 @@ A well-configured subagent has:
 - Description field optimized for automatic routing
 - Successfully tested on representative tasks
 - Model selection appropriate for task complexity (Sonnet for reasoning, Haiku for simple tasks)
-</success_criteria>
+  </success_criteria>

package/claude-code-config/skills/{setup-ralph → ralph-loop}/steps/step-00-init.md

@@ -134,9 +134,8 @@ fi
 
 ```bash
 # Make script executable and run it
-# Note: Use the skill_dir variable which resolves to ~/.claude/skills/setup-ralph
-chmod +x {skill_dir}/scripts/setup.sh
-{skill_dir}/scripts/setup.sh "{project_path}" "{feature_name}"
+chmod +x /Users/melvynx/.claude/skills/setup-ralph/scripts/setup.sh
+/Users/melvynx/.claude/skills/setup-ralph/scripts/setup.sh "{project_path}" "{feature_name}"
 ```
 
 The setup script creates:

package/claude-code-config/skills/utils-fix-errors/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: fix-errors
+description: Fix all ESLint and TypeScript errors with parallel processing using snipper agents
+allowed-tools: Bash(pnpm :*), Bash(tsc :*), Bash(npm :*), Read, Task, Grep
+---
+
+# Fix Errors
+
+Fix all ESLint and TypeScript errors by breaking them into areas and processing in parallel.
+
+## Workflow
+
+1. **DISCOVER COMMANDS**: Check `package.json` for exact script names
+   - Look for: `lint`, `typecheck`, `type-check`, `tsc`, `eslint`, `prettier`, `format`
+
+2. **RUN DIAGNOSTICS**:
+   - Run `pnpm run lint` (or equivalent)
+   - Run `pnpm run typecheck` or `tsc --noEmit`
+   - Capture all error output
+
+3. **ANALYZE ERRORS**:
+   - Extract file paths from error messages
+   - Group errors by file location
+   - Count total errors and affected files
+
+4. **CREATE ERROR AREAS**:
+   - **MAX 5 FILES PER AREA**
+   - Group related files together (same directory/feature)
+   - Example: `Area 1: [file1, file2, file3, file4, file5]`
+
+5. **PARALLEL PROCESSING**: Launch snipper agents for each area
+   - Use Task tool with multiple agents simultaneously
+   - Each agent processes one area (max 5 files)
+   - Provide specific error details for each file
+
+6. **VERIFICATION**: Re-run diagnostics after fixes
+   - Wait for all agents to complete
+   - Re-run lint and typecheck
+   - Report remaining errors
+
+7. **FORMAT CODE**: Apply Prettier (if available)
+   - Run `pnpm run format` or equivalent
+
+## Snipper Agent Instructions
+
+```
+Fix all ESLint and TypeScript errors in these files:
+[list of files with their specific errors]
+
+Focus only on these files. Make minimal changes to fix errors while preserving functionality.
+```
+
+## Rules
+
+- ALWAYS check package.json first for correct commands
+- ONLY fix linting and TypeScript errors
+- NO feature additions - minimal fixes only
+- PARALLEL ONLY - use Task tool for concurrent processing
+- Every error must be assigned to an area
+
+User: $ARGUMENTS

package/claude-code-config/skills/utils-fix-grammar/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: fix-grammar
+description: Fix grammar and spelling errors in one or multiple files while preserving formatting
+allowed-tools: Read, Edit, Write, MultiEdit, Task
+argument-hint: <file-path> [additional-files...]
+---
+
+# Fix Grammar
+
+Fix grammar and spelling errors in files while preserving formatting and meaning.
+
+## Workflow
+
+1. **PARSE FILES**: Split arguments into individual file paths
+   - **STOP** if no files specified - ask user for file paths
+
+2. **DETERMINE STRATEGY**:
+   - **Single file**: Process directly
+   - **Multiple files**: Launch parallel fix-grammar agents
+
+3. **SINGLE FILE MODE**:
+   - `Read` the file completely
+   - Apply grammar and spelling corrections
+   - `Edit` to update file with corrections
+
+4. **MULTIPLE FILES MODE**:
+   - Use Task tool to launch fix-grammar agent for each file
+   - Process all files simultaneously
+   - Wait for all agents to complete
+
+5. **REPORT**: Show files processed and confirm corrections
+
+## Correction Rules
+
+- Fix ONLY spelling and grammar errors
+- **DO NOT** change meaning or word order
+- **DO NOT** translate anything
+- **DO NOT** modify special tags (MDX, custom syntax, code blocks)
+- **PRESERVE**: All formatting, structure, technical terms
+- Remove any `"""` markers if present
+- Keep the same language used in each sentence
+- Handle multilingual content (keep anglicisms, technical terms)
+
+## Output Format
+
+```
+✓ Fixed grammar in [filename]
+- [number] corrections made
+```
+
+## Rules
+
+- ONLY spelling and grammar corrections
+- PARALLEL processing for multiple files
+- PRESERVE everything: formatting, structure, technical terms
+- MINIMAL changes - corrections only, no improvements
+- Never add explanations or commentary to file content
+
+User: $ARGUMENTS

package/claude-code-config/skills/utils-oneshot/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: oneshot
+description: Ultra-fast feature implementation using Explore → Code → Test workflow. Use when implementing focused features, single tasks, or when speed over completeness is priority.
+argument-hint: <feature-description>
+---
+
+# OneShot
+
+Implement `$ARGUMENTS` at maximum speed. Ship fast, iterate later.
+
+## Workflow
+
+### 1. EXPLORE (minimal)
+
+Gather minimum viable context:
+- Use `Glob` to find 2-3 key files by pattern
+- Use `Grep` to search for specific patterns
+- Quick `WebSearch` only if library-specific API knowledge needed
+- NO exploration tours - find examples/edit targets and move on
+
+### 2. CODE (main phase)
+
+Execute changes immediately:
+- Follow existing codebase patterns exactly
+- Clear variable/method names over comments
+- Stay STRICTLY in scope - change only what's needed
+- NO comments unless genuinely complex
+- NO refactoring beyond requirements
+- Run formatters if available (`npm run format`)
+
+### 3. TEST (validate)
+
+Check quality:
+- Run: `npm run lint && npm run typecheck` (or equivalent)
+- If fails: fix only what you broke, re-run
+- NO full test suite unless explicitly requested
+
+## Output
+
+When complete, return:
+
+```
+## Done
+
+**Task:** {what was implemented}
+**Files changed:** {list}
+**Validation:** ✓ lint ✓ typecheck
+```
+
+## Constraints
+
+- ONE task only - no tangential improvements
+- NO documentation files unless requested
+- NO refactoring outside immediate scope
+- NO "while I'm here" additions
+- If stuck >2 attempts: report blocker and stop