@fro.bot/systematic 1.22.7 → 1.23.0

package/skills/report-bug/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: report-bug
+description: Report a bug in the Systematic plugin
+argument-hint: '[optional: brief description of the bug]'
+disable-model-invocation: true
+---
+
+# Report a Systematic Plugin Bug
+
+Report bugs encountered while using the Systematic plugin. This command gathers structured information and creates a GitHub issue for the maintainer.
+
+## Step 1: Gather Bug Information
+
+Use the question 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 ~/.config/opencode/plugins/installed_plugins.json 2>/dev/null | grep -A5 "systematic" | head -10 || echo "Plugin info not found"
+
+# Get OpenCode version
+opencode --version 2>/dev/null || echo "OpenCode 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]
+- **OpenCode Version:** [from opencode --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 marcusrbrown/systematic \
+  --title "[systematic] Bug: [Brief description]" \
+  --body "[Formatted bug report from Step 3]" \
+  --label "bug,systematic"
+```
+
+**Note:** If labels don't exist, create without labels:
+```bash
+gh issue create \
+  --repo marcusrbrown/systematic \
+  --title "[systematic] 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/marcusrbrown/systematic/issues/[NUMBER]
+Title: [systematic] Bug: [description]
+
+Thank you for helping improve the Systematic 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/skills/reproduce-bug/SKILL.md

@@ -0,0 +1,101 @@
+---
+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/skills/resolve_parallel/SKILL.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/skills/resolve_todo_parallel/SKILL.md

@@ -0,0 +1,38 @@
+---
+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/skills/slfg/SKILL.md

@@ -0,0 +1,33 @@
+---
+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. Do not stop between steps — complete every step through to the end.
+
+## Sequential Phase
+
+1. **Optional:** If the `ralph-wiggum` skill is available, run `/ralph-wiggum:ralph-loop "finish all slash commands" --completion-promise "DONE"`. If not available or it fails, skip and continue to step 2 immediately.
+2. `/ce:plan $ARGUMENTS`
+3. `/systematic:deepen-plan`
+4. `/ce: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. `/ce:review` — spawn as background Task agent
+6. `/systematic:test-browser` — spawn as background Task agent
+
+Wait for both to complete before continuing.
+
+## Finalize Phase
+
+7. `/systematic:resolve_todo_parallel` — resolve any findings from the review
+8. `/systematic: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.
+