@fro.bot/systematic 1.18.7 → 1.19.0

package/commands/report-bug.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 ~/.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 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 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/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. Spawn explore agents to investigate logs and console output relevant to the issue.
+2. Spawn explore agents to investigate logs and console output relevant to the issue.
+
+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__playwright__browser_navigate({ url: "http://localhost:3000" })
+mcp__playwright__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__playwright__browser_navigate({ url: "http://localhost:3000/[affected_route]" })
+mcp__playwright__browser_snapshot({})
+```
+
+### Step 3: Capture Screenshots
+
+Take screenshots at each step of reproducing the bug:
+
+```
+mcp__playwright__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__playwright__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__playwright__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/commands/resolve_parallel.md

@@ -0,0 +1,36 @@
+---
+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/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 systematic 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/commands/slfg.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. `/workflows:plan $ARGUMENTS`
+3. `/systematic: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. `/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.
+

package/commands/test-browser.md

@@ -0,0 +1,340 @@
+---
+name: test-browser
+description: Run browser tests on pages affected by current PR or branch
+argument-hint: '[PR number, branch name, or ''current'' for current branch]'
+---
+
+# Browser Test Command
+
+<command_purpose>Run end-to-end browser tests on pages affected by a PR or branch changes using agent-browser CLI.</command_purpose>
+
+## CRITICAL: Use agent-browser CLI Only
+
+**DO NOT use Chrome MCP tools (mcp__claude-in-chrome__*).**
+
+This command uses the `agent-browser` CLI exclusively. The agent-browser CLI is a Bash-based tool from Vercel that runs headless Chromium. It is NOT the same as Chrome browser automation via MCP.
+
+If you find yourself calling `mcp__claude-in-chrome__*` tools, STOP. Use `agent-browser` Bash commands instead.
+
+## Introduction
+
+<role>QA Engineer specializing in browser-based end-to-end testing</role>
+
+This command tests affected pages in a real browser, catching issues that unit tests miss:
+- JavaScript integration bugs
+- CSS/layout regressions
+- User workflow breakages
+- Console errors
+
+## Prerequisites
+
+<requirements>
+- Local development server running (e.g., `bin/dev`, `rails server`, `npm run dev`)
+- agent-browser CLI installed (see Setup below)
+- Git repository with changes to test
+</requirements>
+
+## Setup
+
+**Check installation:**
+```bash
+command -v agent-browser >/dev/null 2>&1 && echo "Installed" || echo "NOT INSTALLED"
+```
+
+**Install if needed:**
+```bash
+npm install -g agent-browser
+agent-browser install  # Downloads Chromium (~160MB)
+```
+
+See the `agent-browser` skill for detailed usage.
+
+## Main Tasks
+
+### 0. Verify agent-browser Installation
+
+Before starting ANY browser testing, verify agent-browser is installed:
+
+```bash
+command -v agent-browser >/dev/null 2>&1 && echo "Ready" || (echo "Installing..." && npm install -g agent-browser && agent-browser install)
+```
+
+If installation fails, inform the user and stop.
+
+### 1. Ask Browser Mode
+
+<ask_browser_mode>
+
+Before starting tests, ask user if they want to watch the browser:
+
+Use question with:
+- Question: "Do you want to watch the browser tests run?"
+- Options:
+  1. **Headed (watch)** - Opens visible browser window so you can see tests run
+  2. **Headless (faster)** - Runs in background, faster but invisible
+
+Store the choice and use `--headed` flag when user selects "Headed".
+
+</ask_browser_mode>
+
+### 2. Determine Test Scope
+
+<test_target> $ARGUMENTS </test_target>
+
+<determine_scope>
+
+**If PR number provided:**
+```bash
+gh pr view [number] --json files -q '.files[].path'
+```
+
+**If 'current' or empty:**
+```bash
+git diff --name-only main...HEAD
+```
+
+**If branch name provided:**
+```bash
+git diff --name-only main...[branch]
+```
+
+</determine_scope>
+
+### 3. Map Files to Routes
+
+<file_to_route_mapping>
+
+Map changed files to testable routes:
+
+| File Pattern | Route(s) |
+|-------------|----------|
+| `app/views/users/*` | `/users`, `/users/:id`, `/users/new` |
+| `app/controllers/settings_controller.rb` | `/settings` |
+| `app/javascript/controllers/*_controller.js` | Pages using that Stimulus controller |
+| `app/components/*_component.rb` | Pages rendering that component |
+| `app/views/layouts/*` | All pages (test homepage at minimum) |
+| `app/assets/stylesheets/*` | Visual regression on key pages |
+| `app/helpers/*_helper.rb` | Pages using that helper |
+| `src/app/*` (Next.js) | Corresponding routes |
+| `src/components/*` | Pages using those components |
+
+Build a list of URLs to test based on the mapping.
+
+</file_to_route_mapping>
+
+### 4. Verify Server is Running
+
+<check_server>
+
+Before testing, verify the local server is accessible:
+
+```bash
+agent-browser open http://localhost:3000
+agent-browser snapshot -i
+```
+
+If server is not running, inform user:
+```markdown
+**Server not running**
+
+Please start your development server:
+- Rails: `bin/dev` or `rails server`
+- Node/Next.js: `npm run dev`
+
+Then run `/test-browser` again.
+```
+
+</check_server>
+
+### 5. Test Each Affected Page
+
+<test_pages>
+
+For each affected route, use agent-browser CLI commands (NOT Chrome MCP):
+
+**Step 1: Navigate and capture snapshot**
+```bash
+agent-browser open "http://localhost:3000/[route]"
+agent-browser snapshot -i
+```
+
+**Step 2: For headed mode (visual debugging)**
+```bash
+agent-browser --headed open "http://localhost:3000/[route]"
+agent-browser --headed snapshot -i
+```
+
+**Step 3: Verify key elements**
+- Use `agent-browser snapshot -i` to get interactive elements with refs
+- Page title/heading present
+- Primary content rendered
+- No error messages visible
+- Forms have expected fields
+
+**Step 4: Test critical interactions**
+```bash
+agent-browser click @e1  # Use ref from snapshot
+agent-browser snapshot -i
+```
+
+**Step 5: Take screenshots**
+```bash
+agent-browser screenshot page-name.png
+agent-browser screenshot --full page-name-full.png  # Full page
+```
+
+</test_pages>
+
+### 6. Human Verification (When Required)
+
+<human_verification>
+
+Pause for human input when testing touches:
+
+| Flow Type | What to Ask |
+|-----------|-------------|
+| OAuth | "Please sign in with [provider] and confirm it works" |
+| Email | "Check your inbox for the test email and confirm receipt" |
+| Payments | "Complete a test purchase in sandbox mode" |
+| SMS | "Verify you received the SMS code" |
+| External APIs | "Confirm the [service] integration is working" |
+
+Use question:
+```markdown
+**Human Verification Needed**
+
+This test touches the [flow type]. Please:
+1. [Action to take]
+2. [What to verify]
+
+Did it work correctly?
+1. Yes - continue testing
+2. No - describe the issue
+```
+
+</human_verification>
+
+### 7. Handle Failures
+
+<failure_handling>
+
+When a test fails:
+
+1. **Document the failure:**
+   - Screenshot the error state: `agent-browser screenshot error.png`
+   - Note the exact reproduction steps
+
+2. **Ask user how to proceed:**
+   ```markdown
+   **Test Failed: [route]**
+
+   Issue: [description]
+   Console errors: [if any]
+
+   How to proceed?
+   1. Fix now - I'll help debug and fix
+   2. Create todo - Add to todos/ for later
+   3. Skip - Continue testing other pages
+   ```
+
+3. **If "Fix now":**
+   - Investigate the issue
+   - Propose a fix
+   - Apply fix
+   - Re-run the failing test
+
+4. **If "Create todo":**
+   - Create `{id}-pending-p1-browser-test-{description}.md`
+   - Continue testing
+
+5. **If "Skip":**
+   - Log as skipped
+   - Continue testing
+
+</failure_handling>
+
+### 8. Test Summary
+
+<test_summary>
+
+After all tests complete, present summary:
+
+```markdown
+## Browser Test Results
+
+**Test Scope:** PR #[number] / [branch name]
+**Server:** http://localhost:3000
+
+### Pages Tested: [count]
+
+| Route | Status | Notes |
+|-------|--------|-------|
+| `/users` | Pass | |
+| `/settings` | Pass | |
+| `/dashboard` | Fail | Console error: [msg] |
+| `/checkout` | Skip | Requires payment credentials |
+
+### Console Errors: [count]
+- [List any errors found]
+
+### Human Verifications: [count]
+- OAuth flow: Confirmed
+- Email delivery: Confirmed
+
+### Failures: [count]
+- `/dashboard` - [issue description]
+
+### Created Todos: [count]
+- `005-pending-p1-browser-test-dashboard-error.md`
+
+### Result: [PASS / FAIL / PARTIAL]
+```
+
+</test_summary>
+
+## Quick Usage Examples
+
+```bash
+# Test current branch changes
+/test-browser
+
+# Test specific PR
+/test-browser 847
+
+# Test specific branch
+/test-browser feature/new-dashboard
+```
+
+## agent-browser CLI Reference
+
+**ALWAYS use these Bash commands. NEVER use mcp__claude-in-chrome__* tools.**
+
+```bash
+# Navigation
+agent-browser open <url>           # Navigate to URL
+agent-browser back                 # Go back
+agent-browser close                # Close browser
+
+# Snapshots (get element refs)
+agent-browser snapshot -i          # Interactive elements with refs (@e1, @e2, etc.)
+agent-browser snapshot -i --json   # JSON output
+
+# Interactions (use refs from snapshot)
+agent-browser click @e1            # Click element
+agent-browser fill @e1 "text"      # Fill input
+agent-browser type @e1 "text"      # Type without clearing
+agent-browser press Enter          # Press key
+
+# Screenshots
+agent-browser screenshot out.png       # Viewport screenshot
+agent-browser screenshot --full out.png # Full page screenshot
+
+# Headed mode (visible browser)
+agent-browser --headed open <url>      # Open with visible browser
+agent-browser --headed click @e1       # Click in visible browser
+
+# Wait
+agent-browser wait @e1             # Wait for element
+agent-browser wait 2000            # Wait milliseconds
+```
+