@fro.bot/systematic 1.0.0

package/README.md

@@ -0,0 +1,158 @@
+# Systematic
+
+An OpenCode plugin providing systematic engineering workflows from the [Compound Engineering Plugin (CEP)](https://github.com/EveryInc/compound-engineering-plugin) Claude Code plugin, adapted for OpenCode.
+
+## Installation
+
+```bash
+npm install @fro.bot/systematic
+```
+
+Add to your OpenCode config (`~/.config/opencode/opencode.json`):
+
+```json
+{
+  "plugin": ["@fro.bot/systematic"]
+}
+```
+
+## Features
+
+### Skills
+
+Systematic includes battle-tested engineering workflows:
+
+| Skill | Description |
+|-------|-------------|
+| `using-systematic` | Bootstrap skill for discovering and using other skills |
+| `brainstorming` | Collaborative design workflow |
+| `agent-browser` | Browser automation with Playwright |
+| `agent-native-architecture` | Design systems for AI agents |
+| `compound-docs` | Create and maintain compound documentation |
+| `create-agent-skills` | Write new skills for AI agents |
+| `file-todos` | Manage TODO items in files |
+| `git-worktree` | Use git worktrees for isolated development |
+
+### Commands
+
+Quick shortcuts to invoke workflows:
+
+**Workflows:**
+
+- `/workflows:brainstorm` - Start collaborative brainstorming
+- `/workflows:compound` - Build compound documentation
+- `/workflows:plan` - Create implementation plans
+- `/workflows:review` - Run code review with agents
+- `/workflows:work` - Execute planned work
+
+**Utilities:**
+
+- `/agent-native-audit` - Audit code for agent-native patterns
+- `/create-agent-skill` - Create a new skill
+- `/deepen-plan` - Add detail to existing plans
+- `/lfg` - Let's go - start working immediately
+
+### Review Agents
+
+Specialized code review agents organized by category:
+
+**Review:**
+
+- `architecture-strategist` - Architectural review
+- `security-sentinel` - Security review
+- `code-simplicity-reviewer` - Complexity review
+- `pattern-recognition-specialist` - Pattern analysis
+- `performance-oracle` - Performance review
+
+**Research:**
+
+- `framework-docs-researcher` - Documentation research
+
+## Config Hook
+
+Systematic uses OpenCode's `config` hook to automatically register bundled agents, commands, and skills directly into OpenCode's configuration. This means:
+
+- **Zero configuration required** - All bundled content is available immediately after installing the plugin
+- **No file copying** - Skills, agents, and commands ship with the npm package
+- **Existing config preserved** - Your OpenCode configuration settings take precedence over bundled content
+
+## Tools
+
+The plugin provides these tools to OpenCode:
+
+| Tool | Description |
+|------|-------------|
+| `systematic_find_skills` | List available skills |
+| `systematic_find_agents` | List available agents |
+| `systematic_find_commands` | List available commands |
+
+## Configuration
+
+Create `~/.config/opencode/systematic.json` or `.opencode/systematic.json` to disable specific bundled content:
+
+```json
+{
+  "disabled_skills": [],
+  "disabled_agents": [],
+  "disabled_commands": []
+}
+```
+
+## Converting CEP Content
+
+The CLI includes a converter for adapting Claude Code agents, skills, and commands from Compound Engineering Plugin (CEP) to OpenCode.
+
+### Convert a Skill
+
+Skills are directories containing `SKILL.md` and supporting files:
+
+```bash
+npx @fro.bot/systematic convert skill /path/to/cep/skills/my-skill -o ./skills/my-skill
+```
+
+### Convert an Agent
+
+Agents are markdown files that get OpenCode-compatible YAML frontmatter:
+
+```bash
+npx @fro.bot/systematic convert agent /path/to/cep/agents/review/my-agent.md -o ./agents/review/my-agent.md
+```
+
+### Convert a Command
+
+Commands are markdown templates:
+
+```bash
+npx @fro.bot/systematic convert command /path/to/cep/commands/my-command.md -o ./commands/my-command.md
+```
+
+### Dry Run
+
+Preview conversion without writing files:
+
+```bash
+npx @fro.bot/systematic convert skill /path/to/skill --dry-run
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Build
+bun run build
+
+# Typecheck
+bun run typecheck
+
+# Lint
+bun run lint
+
+# Run tests
+bun test
+```
+
+## License
+
+MIT

package/agents/research/framework-docs-researcher.md

@@ -0,0 +1,19 @@
+---
+name: framework-docs-researcher
+description: Research framework documentation and best practices
+---
+
+You are a Framework Documentation Researcher.
+
+**Purpose:**
+Find and synthesize official documentation, best practices, and examples for frameworks and libraries being used.
+
+**Approach:**
+1. Identify the frameworks/libraries in question
+2. Search official documentation
+3. Find recommended patterns
+4. Look for gotchas and common mistakes
+5. Find real-world examples
+
+**Output:**
+Provide specific documentation references. Include code examples from official sources. Note version-specific information.

package/agents/review/architecture-strategist.md

@@ -0,0 +1,23 @@
+---
+name: architecture-strategist
+description: Review architectural decisions and system design
+---
+
+You are an Architecture Strategist reviewing code for architectural soundness.
+
+**Focus Areas:**
+- System boundaries and interfaces
+- Dependency direction and coupling
+- Scalability and extensibility
+- SOLID principles adherence
+- Domain boundaries (if DDD)
+
+**Review Approach:**
+1. Identify architectural patterns in use
+2. Evaluate boundary decisions
+3. Check for inappropriate coupling
+4. Assess scalability implications
+5. Recommend improvements
+
+**Output:**
+Provide specific, actionable feedback on architectural concerns. Reference specific files and patterns.

package/agents/review/code-simplicity-reviewer.md

@@ -0,0 +1,30 @@
+---
+name: code-simplicity-reviewer
+description: Review code for unnecessary complexity and simplification opportunities
+---
+
+You are a Code Simplicity Reviewer channeling Casey Muratori and Jonathan Blow.
+
+**Core Philosophy:**
+- Every abstraction must pay rent
+- Complexity is the enemy
+- The best code is no code
+- Indirection has costs
+
+**Focus Areas:**
+- Unnecessary abstractions
+- Over-engineering
+- Premature optimization
+- Dead code
+- Redundant patterns
+- "Clever" code that obscures intent
+
+**Review Approach:**
+1. Question every abstraction layer
+2. Look for simpler alternatives
+3. Identify code that could be deleted
+4. Check for YAGNI violations
+5. Evaluate cognitive load
+
+**Output:**
+Provide specific simplification recommendations. Show before/after when helpful. Be direct about what should be removed.

package/agents/review/pattern-recognition-specialist.md

@@ -0,0 +1,24 @@
+---
+name: pattern-recognition-specialist
+description: Identify patterns, anti-patterns, and consistency issues in code
+---
+
+You are a Pattern Recognition Specialist.
+
+**Focus Areas:**
+- Design pattern usage (appropriate and inappropriate)
+- Anti-pattern detection
+- Consistency across codebase
+- Naming conventions
+- Code organization patterns
+- Error handling patterns
+
+**Review Approach:**
+1. Identify patterns in use
+2. Evaluate pattern appropriateness
+3. Check for anti-patterns
+4. Assess consistency
+5. Compare with established codebase conventions
+
+**Output:**
+Provide specific pattern findings with examples. Reference both local conventions and industry standards. Suggest improvements.

package/agents/review/performance-oracle.md

@@ -0,0 +1,25 @@
+---
+name: performance-oracle
+description: Review code for performance issues and optimization opportunities
+---
+
+You are a Performance Oracle.
+
+**Focus Areas:**
+- Algorithm complexity (time and space)
+- Memory allocations and leaks
+- Database query efficiency
+- Network request optimization
+- Caching opportunities
+- Bundle size (frontend)
+- Hot path optimization
+
+**Review Approach:**
+1. Identify performance-critical paths
+2. Analyze algorithmic complexity
+3. Look for unnecessary allocations
+4. Check for N+1 queries
+5. Evaluate caching strategy
+
+**Output:**
+Provide specific performance findings with impact estimates. Include before/after complexity analysis. Prioritize by impact.

package/agents/review/security-sentinel.md

@@ -0,0 +1,25 @@
+---
+name: security-sentinel
+description: Review code for security vulnerabilities and best practices
+---
+
+You are a Security Sentinel reviewing code for security issues.
+
+**Focus Areas:**
+- Input validation and sanitization
+- Authentication and authorization
+- Secrets and credential handling
+- Injection vulnerabilities (SQL, XSS, command)
+- Cryptographic usage
+- Security headers and CORS
+- Dependency vulnerabilities
+
+**Review Approach:**
+1. Identify attack surfaces
+2. Check for common vulnerability patterns
+3. Verify secure defaults
+4. Assess trust boundaries
+5. Review error handling (no information leakage)
+
+**Output:**
+Provide specific, actionable security findings. Rate severity (Critical, High, Medium, Low). Include remediation guidance.

package/commands/agent-native-audit.md

@@ -0,0 +1,277 @@
+---
+name: agent-native-audit
+description: Run comprehensive agent-native architecture review with scored principles
+argument-hint: "[optional: specific principle to audit]"
+---
+
+# Agent-Native Architecture Audit
+
+Conduct a comprehensive review of the codebase against agent-native architecture principles, launching parallel sub-agents for each principle and producing a scored report.
+
+## Core Principles to Audit
+
+1. **Action Parity** - "Whatever the user can do, the agent can do"
+2. **Tools as Primitives** - "Tools provide capability, not behavior"
+3. **Context Injection** - "System prompt includes dynamic context about app state"
+4. **Shared Workspace** - "Agent and user work in the same data space"
+5. **CRUD Completeness** - "Every entity has full CRUD (Create, Read, Update, Delete)"
+6. **UI Integration** - "Agent actions immediately reflected in UI"
+7. **Capability Discovery** - "Users can discover what the agent can do"
+8. **Prompt-Native Features** - "Features are prompts defining outcomes, not code"
+
+## Workflow
+
+### Step 1: Load the Agent-Native Skill
+
+First, invoke the agent-native-architecture skill to understand all principles:
+
+```
+/compound-engineering:agent-native-architecture
+```
+
+Select option 7 (action parity) to load the full reference material.
+
+### Step 2: Launch Parallel Sub-Agents
+
+Launch 8 parallel sub-agents using the Task tool with `subagent_type: Explore`, one for each principle. Each agent should:
+
+1. Enumerate ALL instances in the codebase (user actions, tools, contexts, data stores, etc.)
+2. Check compliance against the principle
+3. Provide a SPECIFIC SCORE like "X out of Y (percentage%)"
+4. List specific gaps and recommendations
+
+<sub-agents>
+
+**Agent 1: Action Parity**
+```
+Audit for ACTION PARITY - "Whatever the user can do, the agent can do."
+
+Tasks:
+1. Enumerate ALL user actions in frontend (API calls, button clicks, form submissions)
+   - Search for API service files, fetch calls, form handlers
+   - Check routes and components for user interactions
+2. Check which have corresponding agent tools
+   - Search for agent tool definitions
+   - Map user actions to agent capabilities
+3. Score: "Agent can do X out of Y user actions"
+
+Format:
+## Action Parity Audit
+### User Actions Found
+| Action | Location | Agent Tool | Status |
+### Score: X/Y (percentage%)
+### Missing Agent Tools
+### Recommendations
+```
+
+**Agent 2: Tools as Primitives**
+```
+Audit for TOOLS AS PRIMITIVES - "Tools provide capability, not behavior."
+
+Tasks:
+1. Find and read ALL agent tool files
+2. Classify each as:
+   - PRIMITIVE (good): read, write, store, list - enables capability without business logic
+   - WORKFLOW (bad): encodes business logic, makes decisions, orchestrates steps
+3. Score: "X out of Y tools are proper primitives"
+
+Format:
+## Tools as Primitives Audit
+### Tool Analysis
+| Tool | File | Type | Reasoning |
+### Score: X/Y (percentage%)
+### Problematic Tools (workflows that should be primitives)
+### Recommendations
+```
+
+**Agent 3: Context Injection**
+```
+Audit for CONTEXT INJECTION - "System prompt includes dynamic context about app state"
+
+Tasks:
+1. Find context injection code (search for "context", "system prompt", "inject")
+2. Read agent prompts and system messages
+3. Enumerate what IS injected vs what SHOULD be:
+   - Available resources (files, drafts, documents)
+   - User preferences/settings
+   - Recent activity
+   - Available capabilities listed
+   - Session history
+   - Workspace state
+
+Format:
+## Context Injection Audit
+### Context Types Analysis
+| Context Type | Injected? | Location | Notes |
+### Score: X/Y (percentage%)
+### Missing Context
+### Recommendations
+```
+
+**Agent 4: Shared Workspace**
+```
+Audit for SHARED WORKSPACE - "Agent and user work in the same data space"
+
+Tasks:
+1. Identify all data stores/tables/models
+2. Check if agents read/write to SAME tables or separate ones
+3. Look for sandbox isolation anti-pattern (agent has separate data space)
+
+Format:
+## Shared Workspace Audit
+### Data Store Analysis
+| Data Store | User Access | Agent Access | Shared? |
+### Score: X/Y (percentage%)
+### Isolated Data (anti-pattern)
+### Recommendations
+```
+
+**Agent 5: CRUD Completeness**
+```
+Audit for CRUD COMPLETENESS - "Every entity has full CRUD"
+
+Tasks:
+1. Identify all entities/models in the codebase
+2. For each entity, check if agent tools exist for:
+   - Create
+   - Read
+   - Update
+   - Delete
+3. Score per entity and overall
+
+Format:
+## CRUD Completeness Audit
+### Entity CRUD Analysis
+| Entity | Create | Read | Update | Delete | Score |
+### Overall Score: X/Y entities with full CRUD (percentage%)
+### Incomplete Entities (list missing operations)
+### Recommendations
+```
+
+**Agent 6: UI Integration**
+```
+Audit for UI INTEGRATION - "Agent actions immediately reflected in UI"
+
+Tasks:
+1. Check how agent writes/changes propagate to frontend
+2. Look for:
+   - Streaming updates (SSE, WebSocket)
+   - Polling mechanisms
+   - Shared state/services
+   - Event buses
+   - File watching
+3. Identify "silent actions" anti-pattern (agent changes state but UI doesn't update)
+
+Format:
+## UI Integration Audit
+### Agent Action → UI Update Analysis
+| Agent Action | UI Mechanism | Immediate? | Notes |
+### Score: X/Y (percentage%)
+### Silent Actions (anti-pattern)
+### Recommendations
+```
+
+**Agent 7: Capability Discovery**
+```
+Audit for CAPABILITY DISCOVERY - "Users can discover what the agent can do"
+
+Tasks:
+1. Check for these 7 discovery mechanisms:
+   - Onboarding flow showing agent capabilities
+   - Help documentation
+   - Capability hints in UI
+   - Agent self-describes in responses
+   - Suggested prompts/actions
+   - Empty state guidance
+   - Slash commands (/help, /tools)
+2. Score against 7 mechanisms
+
+Format:
+## Capability Discovery Audit
+### Discovery Mechanism Analysis
+| Mechanism | Exists? | Location | Quality |
+### Score: X/7 (percentage%)
+### Missing Discovery
+### Recommendations
+```
+
+**Agent 8: Prompt-Native Features**
+```
+Audit for PROMPT-NATIVE FEATURES - "Features are prompts defining outcomes, not code"
+
+Tasks:
+1. Read all agent prompts
+2. Classify each feature/behavior as defined in:
+   - PROMPT (good): outcomes defined in natural language
+   - CODE (bad): business logic hardcoded
+3. Check if behavior changes require prompt edit vs code change
+
+Format:
+## Prompt-Native Features Audit
+### Feature Definition Analysis
+| Feature | Defined In | Type | Notes |
+### Score: X/Y (percentage%)
+### Code-Defined Features (anti-pattern)
+### Recommendations
+```
+
+</sub-agents>
+
+### Step 3: Compile Summary Report
+
+After all agents complete, compile a summary with:
+
+```markdown
+## Agent-Native Architecture Review: [Project Name]
+
+### Overall Score Summary
+
+| Core Principle | Score | Percentage | Status |
+|----------------|-------|------------|--------|
+| Action Parity | X/Y | Z% | ✅/⚠️/❌ |
+| Tools as Primitives | X/Y | Z% | ✅/⚠️/❌ |
+| Context Injection | X/Y | Z% | ✅/⚠️/❌ |
+| Shared Workspace | X/Y | Z% | ✅/⚠️/❌ |
+| CRUD Completeness | X/Y | Z% | ✅/⚠️/❌ |
+| UI Integration | X/Y | Z% | ✅/⚠️/❌ |
+| Capability Discovery | X/Y | Z% | ✅/⚠️/❌ |
+| Prompt-Native Features | X/Y | Z% | ✅/⚠️/❌ |
+
+**Overall Agent-Native Score: X%**
+
+### Status Legend
+- ✅ Excellent (80%+)
+- ⚠️ Partial (50-79%)
+- ❌ Needs Work (<50%)
+
+### Top 10 Recommendations by Impact
+
+| Priority | Action | Principle | Effort |
+|----------|--------|-----------|--------|
+
+### What's Working Excellently
+
+[List top 5 strengths]
+```
+
+## Success Criteria
+
+- [ ] All 8 sub-agents complete their audits
+- [ ] Each principle has a specific numeric score (X/Y format)
+- [ ] Summary table shows all scores and status indicators
+- [ ] Top 10 recommendations are prioritized by impact
+- [ ] Report identifies both strengths and gaps
+
+## Optional: Single Principle Audit
+
+If $ARGUMENTS specifies a single principle (e.g., "action parity"), only run that sub-agent and provide detailed findings for that principle alone.
+
+Valid arguments:
+- `action parity` or `1`
+- `tools` or `primitives` or `2`
+- `context` or `injection` or `3`
+- `shared` or `workspace` or `4`
+- `crud` or `5`
+- `ui` or `integration` or `6`
+- `discovery` or `7`
+- `prompt` or `features` or `8`

package/commands/create-agent-skill.md

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