@fro.bot/systematic 1.18.8 → 1.19.0

package/commands/changelog.md

@@ -0,0 +1,139 @@
+---
+name: changelog
+description: Create engaging changelogs for recent merges to main branch
+argument-hint: '[optional: daily|weekly, or time period in days]'
+disable-model-invocation: true
+---
+
+You are a witty and enthusiastic product marketer tasked with creating a fun, engaging change log for an internal development team. Your goal is to summarize the latest merges to the main branch, highlighting new features, bug fixes, and giving credit to the hard-working developers.
+
+## Time Period
+
+- For daily changelogs: Look at PRs merged in the last 24 hours
+- For weekly summaries: Look at PRs merged in the last 7 days
+- Always specify the time period in the title (e.g., "Daily" vs "Weekly")
+- Default: Get the latest changes from the last day from the main branch of the repository
+
+## PR Analysis
+
+Analyze the provided GitHub changes and related issues. Look for:
+
+1. New features that have been added
+2. Bug fixes that have been implemented
+3. Any other significant changes or improvements
+4. References to specific issues and their details
+5. Names of contributors who made the changes
+6. Use gh cli to lookup the PRs as well and the description of the PRs
+7. Check PR labels to identify feature type (feature, bug, chore, etc.)
+8. Look for breaking changes and highlight them prominently
+9. Include PR numbers for traceability
+10. Check if PRs are linked to issues and include issue context
+
+## Content Priorities
+
+1. Breaking changes (if any) - MUST be at the top
+2. User-facing features
+3. Critical bug fixes
+4. Performance improvements
+5. Developer experience improvements
+6. Documentation updates
+
+## Formatting Guidelines
+
+Now, create a change log summary with the following guidelines:
+
+1. Keep it concise and to the point
+2. Highlight the most important changes first
+3. Group similar changes together (e.g., all new features, all bug fixes)
+4. Include issue references where applicable
+5. Mention the names of contributors, giving them credit for their work
+6. Add a touch of humor or playfulness to make it engaging
+7. Use emojis sparingly to add visual interest
+8. Keep total message under 2000 characters for Discord
+9. Use consistent emoji for each section
+10. Format code/technical terms in backticks
+11. Include PR numbers in parentheses (e.g., "Fixed login bug (#123)")
+
+## Deployment Notes
+
+When relevant, include:
+
+- Database migrations required
+- Environment variable updates needed
+- Manual intervention steps post-deploy
+- Dependencies that need updating
+
+Your final output should be formatted as follows:
+
+<change_log>
+
+# 🚀 [Daily/Weekly] Change Log: [Current Date]
+
+## 🚨 Breaking Changes (if any)
+
+[List any breaking changes that require immediate attention]
+
+## 🌟 New Features
+
+[List new features here with PR numbers]
+
+## 🐛 Bug Fixes
+
+[List bug fixes here with PR numbers]
+
+## 🛠️ Other Improvements
+
+[List other significant changes or improvements]
+
+## 🙌 Shoutouts
+
+[Mention contributors and their contributions]
+
+## 🎉 Fun Fact of the Day
+
+[Include a brief, work-related fun fact or joke]
+
+</change_log>
+
+## Style Guide Review
+
+Now review the changelog using the EVERY_WRITE_STYLE.md file and go one by one to make sure you are following the style guide. Use multiple agents, run in parallel to make it faster.
+
+Remember, your final output should only include the content within the <change_log> tags. Do not include any of your thought process or the original data in the output.
+
+## Discord Posting (Optional)
+
+You can post changelogs to Discord by adding your own webhook URL:
+
+```
+# Set your Discord webhook URL
+DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/YOUR_WEBHOOK_ID/YOUR_WEBHOOK_TOKEN"
+
+# Post using curl
+curl -H "Content-Type: application/json" \
+  -d "{\"content\": \"{{CHANGELOG}}\"}" \
+  $DISCORD_WEBHOOK_URL
+```
+
+To get a webhook URL, go to your Discord server → Server Settings → Integrations → Webhooks → New Webhook.
+
+## Error Handling
+
+- If no changes in the time period, post a "quiet day" message: "🌤️ Quiet day! No new changes merged."
+- If unable to fetch PR details, list the PR numbers for manual review
+- Always validate message length before posting to Discord (max 2000 chars)
+
+## Schedule Recommendations
+
+- Run daily at 6 AM NY time for previous day's changes
+- Run weekly summary on Mondays for the previous week
+- Special runs after major releases or deployments
+
+## Audience Considerations
+
+Adjust the tone and detail level based on the channel:
+
+- **Dev team channels**: Include technical details, performance metrics, code snippets
+- **Product team channels**: Focus on user-facing changes and business impact
+- **Leadership channels**: Highlight progress on key initiatives and blockers
+

package/commands/create-agent-skill.md

@@ -1,8 +1,11 @@
 ---
 name: create-agent-skill
-description: Create or edit Claude Code skills with expert guidance on structure and best practices
+description: Create or edit OpenCode skills with expert guidance on structure and best practices
 allowed-tools: Skill(create-agent-skills)
-argument-hint: [skill description or requirements]
+argument-hint:
+  - skill description or requirements
+disable-model-invocation: true
 ---
 
 Invoke the create-agent-skills skill for: $ARGUMENTS
+

package/commands/deepen-plan.md

@@ -1,7 +1,7 @@
 ---
 name: deepen-plan
 description: Enhance a plan with parallel research agents for each section to add depth, best practices, and implementation details
-argument-hint: "[path to plan file]"
+argument-hint: '[path to plan file]'
 ---
 
 # Deepen Plan - Power Enhancement Mode
@@ -67,14 +67,20 @@ Dynamically discover all available skills and match them to plan sections. Don't
 # 1. Project-local skills (highest priority - project-specific)
 ls .opencode/skills/
 
-# 2. User's global skills
-ls ~/.config/opencode/skills/
+# 2. User's global skills (~/.opencode/)
+ls ~/.opencode/skills/
 
-# 3. List bundled skills from systematic plugin
-systematic list skills
+# 3. Systematic plugin skills (auto-registered)
+# Use the systematic_skill tool to list/load; no filesystem traversal needed.
+
+# 4. ALL other installed plugins - check every plugin for skills
+find ~/.opencode/plugins/cache -type d -name "skills" 2>/dev/null
+
+# 5. Also check installed_plugins.json for all plugin locations
+cat ~/.opencode/plugins/installed_plugins.json
 ```
 
-**Important:** Check EVERY source. Use skills from ANY installed plugin that's relevant.
+**Important:** Check EVERY source. Don't assume systematic is the only plugin. Use skills from ANY installed plugin that's relevant.
 
 **Step 2: For each discovered skill, read its SKILL.md to understand what it does**
 
@@ -125,11 +131,13 @@ The skill tells you what to do - follow it. Execute the skill completely."
 
 **Example spawns:**
 ```
-task: "Load the systematic:agent-native-architecture skill and apply it to: [agent/tool sections of plan]"
+Task general-purpose: "Use the dhh-rails-style skill at ~/.opencode/plugins/.../dhh-rails-style. Read SKILL.md and apply it to: [Rails sections of plan]"
 
-task: "Load the systematic:brainstorming skill and apply it to: [sections needing design exploration]"
+Task general-purpose: "Use the frontend-design skill at ~/.opencode/plugins/.../frontend-design. Read SKILL.md and apply it to: [UI sections of plan]"
 
-task: "Load the systematic:compound-docs skill and search for relevant documented solutions for: [plan topic]"
+Task general-purpose: "Use the agent-native-architecture skill at ~/.opencode/plugins/.../agent-native-architecture. Read SKILL.md and apply it to: [agent/tool sections of plan]"
+
+Task general-purpose: "Use the security-patterns skill at ~/.opencode/skills/security-patterns. Read SKILL.md and apply it to: [full plan]"
 ```
 
 **No limit on skill sub-agents. Spawn one for every skill that could possibly be relevant.**
@@ -168,6 +176,7 @@ find docs/solutions -name "*.md" -type f 2>/dev/null
 
 # If docs/solutions doesn't exist, check alternate locations:
 find .opencode/docs -name "*.md" -type f 2>/dev/null
+find ~/.opencode/docs -name "*.md" -type f 2>/dev/null
 ```
 
 **Step 2: Read frontmatter of each learning to filter**
@@ -276,9 +285,13 @@ Return concrete, actionable recommendations."
 
 **Also use Context7 MCP for framework documentation:**
 
-For any technologies/frameworks mentioned in the plan, use Context7 (if available) to query library documentation for specific patterns and best practices.
+For any technologies/frameworks mentioned in the plan, query Context7:
+```
+context7__resolve-library-id: Find library ID for [framework]
+context7__query-docs: Query documentation for specific patterns
+```
 
-**Use WebSearch for current best practices:**
+**Use google_search for current best practices:**
 
 Search for recent (2024-2026) articles, blog posts, and documentation on topics in the plan.
 
@@ -294,17 +307,34 @@ Dynamically discover every available agent and run them ALL against the plan. Do
 # 1. Project-local agents (highest priority - project-specific)
 find .opencode/agents -name "*.md" 2>/dev/null
 
-# 2. User's global agents
-find ~/.config/opencode/agents -name "*.md" 2>/dev/null
+# 2. User's global agents (~/.opencode/)
+find ~/.opencode/agents -name "*.md" 2>/dev/null
+
+# 3. Systematic plugin agents (auto-registered)
+# Agents are available by name; no filesystem traversal needed.
+
+# 4. ALL other installed plugins - check every plugin for agents
+find ~/.opencode/plugins/cache -path "*/agents/*.md" 2>/dev/null
+
+# 5. Check installed_plugins.json to find all plugin locations
+cat ~/.opencode/plugins/installed_plugins.json
 
-# 3. List bundled agents from systematic plugin
-systematic list agents
+# 6. For local plugins (isLocal: true), check their source directories
+# Parse installed_plugins.json and find local plugin paths
 ```
 
 **Important:** Check EVERY source. Include agents from:
 - Project `.opencode/agents/`
-- User's `~/.config/opencode/agents/`
-- Systematic plugin bundled agents (review/, research/, design/ categories)
+- User's `~/.opencode/agents/`
+- Systematic plugin (but SKIP workflow/ agents - only use review/, research/, design/, docs/)
+- ALL other installed plugins (agent-sdk-dev, frontend-design, etc.)
+- Any local plugins
+
+**For Systematic plugin specifically:**
+- USE: `agents/review/*` (all reviewers)
+- USE: `agents/research/*` (all researchers)
+- USE: `agents/design/*` (design agents)
+- USE: `agents/docs/*` (documentation agents)
 - SKIP: `agents/workflow/*` (these are workflow orchestrators, not reviewers)
 
 **Step 2: For each discovered agent, read its description**
@@ -322,7 +352,7 @@ Task [agent-name]: "Review this plan using your expertise. Apply all your checks
 **CRITICAL RULES:**
 - Do NOT filter agents by "relevance" - run them ALL
 - Do NOT skip agents because they "might not apply" - let them decide
-- Launch ALL agents in a SINGLE message with multiple Task tool calls
+- Launch ALL agents in a SINGLE message with multiple task tool calls
 - 20, 30, 40 parallel agents is fine - use everything
 - Each agent may catch something others miss
 - The goal is MAXIMUM coverage, not efficiency
@@ -450,14 +480,14 @@ After writing the enhanced plan, use the **question tool** to present these opti
 
 **Options:**
 1. **View diff** - Show what was added/changed
-2. **Run `/plan_review`** - Get feedback from reviewers on enhanced plan
+2. **Run `/technical_review`** - Get feedback from reviewers on enhanced plan
 3. **Start `/workflows:work`** - Begin implementing this enhanced plan
 4. **Deepen further** - Run another round of research on specific sections
 5. **Revert** - Restore original plan (if backup exists)
 
 Based on selection:
 - **View diff** → Run `git diff [plan_path]` or show before/after
-- **`/plan_review`** → Call the /plan_review command with the plan file path
+- **`/technical_review`** → Call the /technical_review command with the plan file path
 - **`/workflows:work`** → Call the /workflows:work command with the plan file path
 - **Deepen further** → Ask which sections need more research, then re-run those agents
 - **Revert** → Restore from git or backup

package/commands/deploy-docs.md

@@ -0,0 +1,120 @@
+---
+name: deploy-docs
+description: Validate and prepare Systematic documentation for GitHub Pages deployment
+disable-model-invocation: true
+---
+
+# Deploy Documentation Command
+
+Validate the Systematic Starlight/Astro documentation site and prepare it for GitHub Pages deployment.
+
+## Step 1: Validate Documentation
+
+Run these checks:
+
+```bash
+# Count bundled assets
+echo "Agents: $(ls agents/*/*.md | wc -l)"
+echo "Commands: $(ls commands/*.md commands/workflows/*.md | wc -l)"
+echo "Skills: $(ls -d skills/*/ 2>/dev/null | wc -l)"
+
+# Verify CLI listings (review output for expected entries)
+bun src/cli.ts list agents
+bun src/cli.ts list skills
+bun src/cli.ts list commands
+
+# Build docs (runs docs:generate + Astro build)
+bun run docs:build
+
+# Check Astro output
+test -f docs/dist/index.html && echo "✓ docs/dist/index.html present"
+```
+
+## Step 2: Check for Uncommitted Changes
+
+```bash
+git status --porcelain docs/
+```
+
+If there are uncommitted changes, warn the user to commit first.
+
+## Step 3: Deployment Instructions
+
+Since GitHub Pages deployment requires a workflow file with special permissions, provide these instructions:
+
+### First-time Setup
+
+1. Create `.github/workflows/deploy-docs.yml` with the GitHub Pages workflow
+2. Go to repository Settings > Pages
+3. Set Source to "GitHub Actions"
+
+### Deploying
+
+After merging to `main`, the docs will auto-deploy. Or:
+
+1. Go to Actions tab
+2. Select "Deploy Documentation to GitHub Pages"
+3. Click "Run workflow"
+
+### Workflow File Content
+
+```yaml
+name: Deploy Documentation to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'docs/**'
+      - 'docs/scripts/**'
+      - 'agents/**'
+      - 'skills/**'
+      - 'commands/**'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: '1.1.0'
+      - run: bun install
+      - run: bun run docs:build
+      - uses: actions/configure-pages@v4
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: 'docs/dist'
+      - uses: actions/deploy-pages@v4
+```
+
+## Step 4: Report Status
+
+Provide a summary:
+
+```
+## Deployment Readiness
+
+✓ Starlight/Astro build succeeded
+✓ Bundled asset counts match expectations
+✓ CLI listings verified
+
+### Next Steps
+- [ ] Commit any pending changes
+- [ ] Push to main branch
+- [ ] Verify GitHub Pages workflow exists
+- [ ] Check deployment at https://fro.bot/systematic (or your configured base URL)
+```