compound-engineering-pi 0.2.3

package/plugins/compound-engineering/commands/release-docs.md

@@ -0,0 +1,212 @@
+---
+name: release-docs
+description: Build and update the documentation site with current plugin components
+argument-hint: "[optional: --dry-run to preview changes without writing]"
+disable-model-invocation: true
+---
+
+# Release Documentation Command
+
+You are a documentation generator for the compound-engineering plugin. Your job is to ensure the documentation site at `plugins/compound-engineering/docs/` is always up-to-date with the actual plugin components.
+
+## Overview
+
+The documentation site is a static HTML/CSS/JS site based on the Evil Martians LaunchKit template. It needs to be regenerated whenever:
+
+- Agents are added, removed, or modified
+- Commands are added, removed, or modified
+- Skills are added, removed, or modified
+- MCP servers are added, removed, or modified
+
+## Step 1: Inventory Current Components
+
+First, count and list all current components:
+
+```bash
+# Count agents
+ls plugins/compound-engineering/agents/*.md | wc -l
+
+# Count commands
+ls plugins/compound-engineering/commands/*.md | wc -l
+
+# Count skills
+ls -d plugins/compound-engineering/skills/*/ 2>/dev/null | wc -l
+
+# Count MCP servers
+ls -d plugins/compound-engineering/mcp-servers/*/ 2>/dev/null | wc -l
+```
+
+Read all component files to get their metadata:
+
+### Agents
+For each agent file in `plugins/compound-engineering/agents/*.md`:
+- Extract the frontmatter (name, description)
+- Note the category (Review, Research, Workflow, Design, Docs)
+- Get key responsibilities from the content
+
+### Commands
+For each command file in `plugins/compound-engineering/commands/*.md`:
+- Extract the frontmatter (name, description, argument-hint)
+- Categorize as Workflow or Utility command
+
+### Skills
+For each skill directory in `plugins/compound-engineering/skills/*/`:
+- Read the SKILL.md file for frontmatter (name, description)
+- Note any scripts or supporting files
+
+### MCP Servers
+For each MCP server in `plugins/compound-engineering/mcp-servers/*/`:
+- Read the configuration and README
+- List the tools provided
+
+## Step 2: Update Documentation Pages
+
+### 2a. Update `docs/index.html`
+
+Update the stats section with accurate counts:
+```html
+<div class="stats-grid">
+  <div class="stat-card">
+    <span class="stat-number">[AGENT_COUNT]</span>
+    <span class="stat-label">Specialized Agents</span>
+  </div>
+  <!-- Update all stat cards -->
+</div>
+```
+
+Ensure the component summary sections list key components accurately.
+
+### 2b. Update `docs/pages/agents.html`
+
+Regenerate the complete agents reference page:
+- Group agents by category (Review, Research, Workflow, Design, Docs)
+- Include for each agent:
+  - Name and description
+  - Key responsibilities (bullet list)
+  - Usage example: `claude agent [agent-name] "your message"`
+  - Use cases
+
+### 2c. Update `docs/pages/commands.html`
+
+Regenerate the complete commands reference page:
+- Group commands by type (Workflow, Utility)
+- Include for each command:
+  - Name and description
+  - Arguments (if any)
+  - Process/workflow steps
+  - Example usage
+
+### 2d. Update `docs/pages/skills.html`
+
+Regenerate the complete skills reference page:
+- Group skills by category (Development Tools, Content & Workflow, Image Generation)
+- Include for each skill:
+  - Name and description
+  - Usage: `claude skill [skill-name]`
+  - Features and capabilities
+
+### 2e. Update `docs/pages/mcp-servers.html`
+
+Regenerate the MCP servers reference page:
+- For each server:
+  - Name and purpose
+  - Tools provided
+  - Configuration details
+  - Supported frameworks/services
+
+## Step 3: Update Metadata Files
+
+Ensure counts are consistent across:
+
+1. **`plugins/compound-engineering/.claude-plugin/plugin.json`**
+   - Update `description` with correct counts
+   - Update `components` object with counts
+   - Update `agents`, `commands` arrays with current items
+
+2. **`.claude-plugin/marketplace.json`**
+   - Update plugin `description` with correct counts
+
+3. **`plugins/compound-engineering/README.md`**
+   - Update intro paragraph with counts
+   - Update component lists
+
+## Step 4: Validate
+
+Run validation checks:
+
+```bash
+# Validate JSON files
+cat .claude-plugin/marketplace.json | jq .
+cat plugins/compound-engineering/.claude-plugin/plugin.json | jq .
+
+# Verify counts match
+echo "Agents in files: $(ls plugins/compound-engineering/agents/*.md | wc -l)"
+grep -o "[0-9]* specialized agents" plugins/compound-engineering/docs/index.html
+
+echo "Commands in files: $(ls plugins/compound-engineering/commands/*.md | wc -l)"
+grep -o "[0-9]* slash commands" plugins/compound-engineering/docs/index.html
+```
+
+## Step 5: Report Changes
+
+Provide a summary of what was updated:
+
+```
+## Documentation Release Summary
+
+### Component Counts
+- Agents: X (previously Y)
+- Commands: X (previously Y)
+- Skills: X (previously Y)
+- MCP Servers: X (previously Y)
+
+### Files Updated
+- docs/index.html - Updated stats and component summaries
+- docs/pages/agents.html - Regenerated with X agents
+- docs/pages/commands.html - Regenerated with X commands
+- docs/pages/skills.html - Regenerated with X skills
+- docs/pages/mcp-servers.html - Regenerated with X servers
+- plugin.json - Updated counts and component lists
+- marketplace.json - Updated description
+- README.md - Updated component lists
+
+### New Components Added
+- [List any new agents/commands/skills]
+
+### Components Removed
+- [List any removed agents/commands/skills]
+```
+
+## Dry Run Mode
+
+If `--dry-run` is specified:
+- Perform all inventory and validation steps
+- Report what WOULD be updated
+- Do NOT write any files
+- Show diff previews of proposed changes
+
+## Error Handling
+
+- If component files have invalid frontmatter, report the error and skip
+- If JSON validation fails, report and abort
+- Always maintain a valid state - don't partially update
+
+## Post-Release
+
+After successful release:
+1. Suggest updating CHANGELOG.md with documentation changes
+2. Remind to commit with message: `docs: Update documentation site to match plugin components`
+3. Remind to push changes
+
+## Usage Examples
+
+```bash
+# Full documentation release
+claude /release-docs
+
+# Preview changes without writing
+claude /release-docs --dry-run
+
+# After adding new agents
+claude /release-docs
+```

package/plugins/compound-engineering/commands/report-bug.md

@@ -0,0 +1,151 @@
+---
+name: report-bug
+description: Report a bug in the compound-engineering plugin
+argument-hint: "[optional: brief description of the bug]"
+disable-model-invocation: true
+---
+
+# Report a Compounding Engineering Plugin Bug
+
+Report bugs encountered while using the compound-engineering plugin. This command gathers structured information and creates a GitHub issue for the maintainer.
+
+## Step 1: Gather Bug Information
+
+Use the AskUserQuestion tool to collect the following information:
+
+**Question 1: Bug Category**
+- What type of issue are you experiencing?
+- Options: Agent not working, Command not working, Skill not working, MCP server issue, Installation problem, Other
+
+**Question 2: Specific Component**
+- Which specific component is affected?
+- Ask for the name of the agent, command, skill, or MCP server
+
+**Question 3: What Happened (Actual Behavior)**
+- Ask: "What happened when you used this component?"
+- Get a clear description of the actual behavior
+
+**Question 4: What Should Have Happened (Expected Behavior)**
+- Ask: "What did you expect to happen instead?"
+- Get a clear description of expected behavior
+
+**Question 5: Steps to Reproduce**
+- Ask: "What steps did you take before the bug occurred?"
+- Get reproduction steps
+
+**Question 6: Error Messages**
+- Ask: "Did you see any error messages? If so, please share them."
+- Capture any error output
+
+## Step 2: Collect Environment Information
+
+Automatically gather:
+```bash
+# Get plugin version
+cat ~/.claude/plugins/installed_plugins.json 2>/dev/null | grep -A5 "compound-engineering" | head -10 || echo "Plugin info not found"
+
+# Get Claude Code version
+claude --version 2>/dev/null || echo "Claude CLI version unknown"
+
+# Get OS info
+uname -a
+```
+
+## Step 3: Format the Bug Report
+
+Create a well-structured bug report with:
+
+```markdown
+## Bug Description
+
+**Component:** [Type] - [Name]
+**Summary:** [Brief description from argument or collected info]
+
+## Environment
+
+- **Plugin Version:** [from installed_plugins.json]
+- **Claude Code Version:** [from claude --version]
+- **OS:** [from uname]
+
+## What Happened
+
+[Actual behavior description]
+
+## Expected Behavior
+
+[Expected behavior description]
+
+## Steps to Reproduce
+
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+## Error Messages
+
+```
+[Any error output]
+```
+
+## Additional Context
+
+[Any other relevant information]
+
+---
+*Reported via `/report-bug` command*
+```
+
+## Step 4: Create GitHub Issue
+
+Use the GitHub CLI to create the issue:
+
+```bash
+gh issue create \
+  --repo EveryInc/compound-engineering-plugin \
+  --title "[compound-engineering] Bug: [Brief description]" \
+  --body "[Formatted bug report from Step 3]" \
+  --label "bug,compound-engineering"
+```
+
+**Note:** If labels don't exist, create without labels:
+```bash
+gh issue create \
+  --repo EveryInc/compound-engineering-plugin \
+  --title "[compound-engineering] Bug: [Brief description]" \
+  --body "[Formatted bug report]"
+```
+
+## Step 5: Confirm Submission
+
+After the issue is created:
+1. Display the issue URL to the user
+2. Thank them for reporting the bug
+3. Let them know the maintainer (Kieran Klaassen) will be notified
+
+## Output Format
+
+```
+✅ Bug report submitted successfully!
+
+Issue: https://github.com/EveryInc/compound-engineering-plugin/issues/[NUMBER]
+Title: [compound-engineering] Bug: [description]
+
+Thank you for helping improve the compound-engineering plugin!
+The maintainer will review your report and respond as soon as possible.
+```
+
+## Error Handling
+
+- If `gh` CLI is not authenticated: Prompt user to run `gh auth login` first
+- If issue creation fails: Display the formatted report so user can manually create the issue
+- If required information is missing: Re-prompt for that specific field
+
+## Privacy Notice
+
+This command does NOT collect:
+- Personal information
+- API keys or credentials
+- Private code from your projects
+- File paths beyond basic OS info
+
+Only technical information about the bug is included in the report.

package/plugins/compound-engineering/commands/reproduce-bug.md

@@ -0,0 +1,100 @@
+---
+name: reproduce-bug
+description: Reproduce and investigate a bug using logs, console inspection, and browser screenshots
+argument-hint: "[GitHub issue number]"
+disable-model-invocation: true
+---
+
+# Reproduce Bug Command
+
+Look at github issue #$ARGUMENTS and read the issue description and comments.
+
+## Phase 1: Log Investigation
+
+Run the following agents in parallel to investigate the bug:
+
+1. Task rails-console-explorer(issue_description)
+2. Task appsignal-log-investigator(issue_description)
+
+Think about the places it could go wrong looking at the codebase. Look for logging output we can look for.
+
+Run the agents again to find any logs that could help us reproduce the bug.
+
+Keep running these agents until you have a good idea of what is going on.
+
+## Phase 2: Visual Reproduction with Playwright
+
+If the bug is UI-related or involves user flows, use Playwright to visually reproduce it:
+
+### Step 1: Verify Server is Running
+
+```
+mcp__plugin_compound-engineering_pw__browser_navigate({ url: "http://localhost:3000" })
+mcp__plugin_compound-engineering_pw__browser_snapshot({})
+```
+
+If server not running, inform user to start `bin/dev`.
+
+### Step 2: Navigate to Affected Area
+
+Based on the issue description, navigate to the relevant page:
+
+```
+mcp__plugin_compound-engineering_pw__browser_navigate({ url: "http://localhost:3000/[affected_route]" })
+mcp__plugin_compound-engineering_pw__browser_snapshot({})
+```
+
+### Step 3: Capture Screenshots
+
+Take screenshots at each step of reproducing the bug:
+
+```
+mcp__plugin_compound-engineering_pw__browser_take_screenshot({ filename: "bug-[issue]-step-1.png" })
+```
+
+### Step 4: Follow User Flow
+
+Reproduce the exact steps from the issue:
+
+1. **Read the issue's reproduction steps**
+2. **Execute each step using Playwright:**
+   - `browser_click` for clicking elements
+   - `browser_type` for filling forms
+   - `browser_snapshot` to see the current state
+   - `browser_take_screenshot` to capture evidence
+
+3. **Check for console errors:**
+   ```
+   mcp__plugin_compound-engineering_pw__browser_console_messages({ level: "error" })
+   ```
+
+### Step 5: Capture Bug State
+
+When you reproduce the bug:
+
+1. Take a screenshot of the bug state
+2. Capture console errors
+3. Document the exact steps that triggered it
+
+```
+mcp__plugin_compound-engineering_pw__browser_take_screenshot({ filename: "bug-[issue]-reproduced.png" })
+```
+
+## Phase 3: Document Findings
+
+**Reference Collection:**
+
+- [ ] Document all research findings with specific file paths (e.g., `app/services/example_service.rb:42`)
+- [ ] Include screenshots showing the bug reproduction
+- [ ] List console errors if any
+- [ ] Document the exact reproduction steps
+
+## Phase 4: Report Back
+
+Add a comment to the issue with:
+
+1. **Findings** - What you discovered about the cause
+2. **Reproduction Steps** - Exact steps to reproduce (verified)
+3. **Screenshots** - Visual evidence of the bug (upload captured screenshots)
+4. **Relevant Code** - File paths and line numbers
+5. **Suggested Fix** - If you have one

package/plugins/compound-engineering/commands/resolve_parallel.md

@@ -0,0 +1,35 @@
+---
+name: resolve_parallel
+description: Resolve all TODO comments using parallel processing
+argument-hint: "[optional: specific TODO pattern or file]"
+disable-model-invocation: true
+---
+
+Resolve all TODO comments using parallel processing.
+
+## Workflow
+
+### 1. Analyze
+
+Gather the things todo from above.
+
+### 2. Plan
+
+Create a TodoWrite list of all unresolved items grouped by type.Make sure to look at dependencies that might occur and prioritize the ones needed by others. For example, if you need to change a name, you must wait to do the others. Output a mermaid flow diagram showing how we can do this. Can we do everything in parallel? Do we need to do one first that leads to others in parallel? I'll put the to-dos in the mermaid diagram flow‑wise so the agent knows how to proceed in order.
+
+### 3. Implement (PARALLEL)
+
+Spawn a pr-comment-resolver agent for each unresolved item in parallel.
+
+So if there are 3 comments, it will spawn 3 pr-comment-resolver agents in parallel. liek this
+
+1. Task pr-comment-resolver(comment1)
+2. Task pr-comment-resolver(comment2)
+3. Task pr-comment-resolver(comment3)
+
+Always run all in parallel subagents/Tasks for each Todo item.
+
+### 4. Commit & Resolve
+
+- Commit changes
+- Push to remote

package/plugins/compound-engineering/commands/resolve_todo_parallel.md

@@ -0,0 +1,37 @@
+---
+name: resolve_todo_parallel
+description: Resolve all pending CLI todos using parallel processing
+argument-hint: "[optional: specific todo ID or pattern]"
+---
+
+Resolve all TODO comments using parallel processing.
+
+## Workflow
+
+### 1. Analyze
+
+Get all unresolved TODOs from the /todos/\*.md directory
+
+If any todo recommends deleting, removing, or gitignoring files in `docs/plans/` or `docs/solutions/`, skip it and mark it as `wont_fix`. These are compound-engineering pipeline artifacts that are intentional and permanent.
+
+### 2. Plan
+
+Create a TodoWrite list of all unresolved items grouped by type.Make sure to look at dependencies that might occur and prioritize the ones needed by others. For example, if you need to change a name, you must wait to do the others. Output a mermaid flow diagram showing how we can do this. Can we do everything in parallel? Do we need to do one first that leads to others in parallel? I'll put the to-dos in the mermaid diagram flow‑wise so the agent knows how to proceed in order.
+
+### 3. Implement (PARALLEL)
+
+Spawn a pr-comment-resolver agent for each unresolved item in parallel.
+
+So if there are 3 comments, it will spawn 3 pr-comment-resolver agents in parallel. liek this
+
+1. Task pr-comment-resolver(comment1)
+2. Task pr-comment-resolver(comment2)
+3. Task pr-comment-resolver(comment3)
+
+Always run all in parallel subagents/Tasks for each Todo item.
+
+### 4. Commit & Resolve
+
+- Commit changes
+- Remove the TODO from the file, and mark it as resolved.
+- Push to remote

package/plugins/compound-engineering/commands/slfg.md

@@ -0,0 +1,32 @@
+---
+name: slfg
+description: Full autonomous engineering workflow using swarm mode for parallel execution
+argument-hint: "[feature description]"
+disable-model-invocation: true
+---
+
+Swarm-enabled LFG. Run these steps in order, parallelizing where indicated.
+
+## Sequential Phase
+
+1. `/ralph-wiggum:ralph-loop "finish all slash commands" --completion-promise "DONE"`
+2. `/workflows:plan $ARGUMENTS`
+3. `/compound-engineering:deepen-plan`
+4. `/workflows:work` — **Use swarm mode**: Make a Task list and launch an army of agent swarm subagents to build the plan
+
+## Parallel Phase
+
+After work completes, launch steps 5 and 6 as **parallel swarm agents** (both only need code to be written):
+
+5. `/workflows:review` — spawn as background Task agent
+6. `/compound-engineering:test-browser` — spawn as background Task agent
+
+Wait for both to complete before continuing.
+
+## Finalize Phase
+
+7. `/compound-engineering:resolve_todo_parallel` — resolve any findings from the review
+8. `/compound-engineering:feature-video` — record the final walkthrough and add to PR
+9. Output `<promise>DONE</promise>` when video is in PR
+
+Start with step 1 now.

package/plugins/compound-engineering/commands/technical_review.md

@@ -0,0 +1,8 @@
+---
+name: technical_review
+description: Have multiple specialized agents review the technical approach and architecture of a plan in parallel
+argument-hint: "[plan file path or plan content]"
+disable-model-invocation: true
+---
+
+Have @agent-dhh-rails-reviewer @agent-kieran-rails-reviewer @agent-code-simplicity-reviewer review the technical approach in this plan in parallel.