opencodekit 0.3.2 → 0.4.0

package/dist/template/.opencode/command/new-feature.md

@@ -0,0 +1,137 @@
+---
+description: Create a new feature with bead, spec, and plan
+argument-hint: "<feature-name> [--priority=high|medium|low] [--type=feature|bug|refactor]"
+agent: planner
+model: proxypal/gemini-3-flash-preview
+---
+
+# New Feature: $ARGUMENTS
+
+Create a complete feature track with bead, specification, and implementation plan.
+
+## Instructions
+
+Parse from `$ARGUMENTS`:
+
+- Feature name (required)
+- Priority (default: medium)
+- Type (default: feature)
+
+## Workflow
+
+### Step 1: Create Bead
+
+```bash
+bd new [type] "[feature-name]" --priority [priority]
+```
+
+Capture the bead ID from output.
+
+### Step 2: Create Specification
+
+Create `.beads/[bead-id]/spec.md`:
+
+```markdown
+# [Feature Name] Specification
+
+## Overview
+
+[Brief description of the feature]
+
+## Problem Statement
+
+[What problem does this solve?]
+
+## User Stories
+
+- As a [user], I want [goal], so that [benefit]
+
+## Acceptance Criteria
+
+- [ ] [Criterion 1]
+- [ ] [Criterion 2]
+- [ ] [Criterion 3]
+
+## Technical Considerations
+
+- [Consideration 1]
+- [Consideration 2]
+
+## Out of Scope
+
+- [What we're NOT doing]
+
+## Dependencies
+
+- [Other features/systems this depends on]
+```
+
+### Step 3: Create Plan
+
+Create `.beads/[bead-id]/plan.md`:
+
+```markdown
+# [Feature Name] Implementation Plan
+
+## Phases
+
+### Phase 1: [Name]
+
+**Estimate:** [X hours]
+
+Tasks:
+
+1. [ ] [Task 1]
+2. [ ] [Task 2]
+
+### Phase 2: [Name]
+
+**Estimate:** [X hours]
+
+Tasks:
+
+1. [ ] [Task 1]
+2. [ ] [Task 2]
+
+## Testing Strategy
+
+- [ ] Unit tests for [what]
+- [ ] Integration tests for [what]
+
+## Rollout Plan
+
+1. [Step 1]
+2. [Step 2]
+
+## Rollback Plan
+
+[How to revert if needed]
+```
+
+### Step 4: Update Bead
+
+```bash
+bd update [bead-id] --status planning
+```
+
+## Output
+
+Report:
+
+- Bead ID created
+- Spec file path
+- Plan file path
+- Next command to run: `/implement [bead-id]`
+
+## Follow-up Commands
+
+```bash
+# View the feature
+bd show [bead-id]
+
+# Start implementation
+/implement [bead-id]
+
+# Check status
+/status [bead-id]
+```

package/dist/template/.opencode/command/research-ui.md

@@ -1,48 +1,55 @@
 ---
-description: Large-scale UI/UX research using Gemini CLI with bead artifact storage
-argument-hint: "[bead-id] [research topic or path]"
+description: Research UI/UX patterns across codebase or topic
+argument-hint: "<topic-or-path> [bead-id]"
 agent: vision
+model: proxypal/gemini-3-flash-preview
 ---
 
 # Research UI: $ARGUMENTS
 
-use_skill("gemini-large-context")
 use_skill("ui-ux-research")
 
-## Parse Arguments
+Research UI/UX patterns, implementations, or design topics.
 
-Extract bead ID (if provided) and research topic from `$ARGUMENTS`. If no bead ID provided, research findings will be saved to memory instead.
+## Instructions
 
-## When to Use Gemini CLI
+Parse research topic/path and optional bead ID from `$ARGUMENTS`.
 
-For a single component, use local tools—they're faster and sufficient. When researching patterns across multiple files or comparing implementations throughout a codebase, switch to Gemini CLI's non-interactive mode to scan entire directories at once. For analyzing images like mockups or screenshots, start Gemini in interactive mode and reference the image directly.
+## Research Approach
 
-## How to Research
+For **codebase paths**:
 
-Point Gemini at the relevant directories and ask about the topic. Include both component and style directories to get a complete picture. Ask specifically for current implementations, patterns being used, consistency assessment, and improvement opportunities.
+- Scan component and style directories
+- Identify current patterns and implementations
+- Assess consistency across files
+- Find improvement opportunities
 
-For image analysis, start interactive mode and reference the image file, then describe what aspects you want analyzed.
+For **topics**:
 
-## Save Findings
+- Research best practices
+- Find relevant examples
+- Compare approaches
+- Recommend implementation
 
-### With Bead ID
+## Common Topics
 
-Save research findings to bead artifacts for traceability:
+- Design system consistency
+- Component inventory
+- Typography usage
+- Color token patterns
+- Animation/motion usage
+- Responsive patterns
+- Accessibility compliance
 
-```bash
-# Save to .beads/artifacts/<bead-id>/research-ui.md
-bd edit <bead-id> --note "UI research completed: <key findings summary>"
-```
-
-### Without Bead ID
-
-Save to memory for general reference:
-`.opencode/memory/research/YYYY-MM-DD-<topic>.md`
-
-## Common Research Topics
+## Output
 
-Design system consistency, component inventory, accessibility audits, responsive patterns, animation usage, typography inventory, and color token usage are all good candidates for this kind of large-scale research.
+Provide:
 
-## Output
+1. Research summary
+2. Key findings
+3. Specific recommendations
+4. Code examples where helpful
+5. Next steps
 
-Provide a research summary with your findings, specific recommendations, code examples where they help clarify a point, and suggested next steps for implementation.
+If bead ID provided, save findings to bead artifacts.
+Otherwise, save to `.opencode/memory/design/research/`.

package/dist/template/.opencode/command/restore-image.md

@@ -0,0 +1,39 @@
+---
+description: Restore, enhance, or upscale images
+argument-hint: "<image-path> [mode: enhance|upscale|restore|denoise]"
+agent: vision
+model: proxypal/gemini-3-pro-image-preview
+---
+
+# Restore Image: $ARGUMENTS
+
+Restore, enhance, or improve image quality.
+
+## Instructions
+
+Parse from `$ARGUMENTS`:
+
+- Image path
+- Mode (default: enhance)
+
+## Modes
+
+- **enhance**: Improve overall quality, colors, sharpness
+- **upscale**: Increase resolution
+- **restore**: Fix artifacts, compression, damage
+- **denoise**: Remove noise while preserving detail
+
+## Process
+
+1. Analyze image quality issues
+2. Apply appropriate restoration
+3. Save to `.opencode/memory/design/restored/`
+
+## Output
+
+Report:
+
+- Issues detected
+- Improvements applied
+- Before/after comparison notes
+- Output path

package/dist/template/.opencode/command/revert-feature.md

@@ -0,0 +1,127 @@
+---
+description: Smart git-aware revert for a bead/feature
+argument-hint: "<bead-id> [--phase=N] [--task=N] [--soft]"
+agent: build
+model: proxypal/gemini-3-flash-preview
+---
+
+# Revert Feature: $ARGUMENTS
+
+Intelligently revert changes for a bead with git awareness.
+
+## Instructions
+
+Parse from `$ARGUMENTS`:
+
+- Bead ID (required)
+- `--phase=N`: Revert only specific phase
+- `--task=N`: Revert only specific task
+- `--soft`: Stage reverts without committing
+
+## Workflow
+
+### Step 1: Analyze Bead History
+
+```bash
+bd show [bead-id] --history
+```
+
+Identify:
+
+- All commits associated with this bead
+- Files changed per phase/task
+- Current phase and task
+
+### Step 2: Determine Revert Scope
+
+**Full revert (no flags):**
+
+- All commits for this bead
+- Reset bead status to initial
+
+**Phase revert (--phase=N):**
+
+- Only commits tagged with phase N
+- Reset bead to previous phase
+
+**Task revert (--task=N):**
+
+- Only commits for specific task
+- Keep bead in current phase
+
+### Step 3: Git Analysis
+
+```bash
+# Find commits for this bead
+git log --oneline --all --grep="[bead-id]"
+
+# Show files that would be affected
+git diff --stat [commit-range]
+```
+
+Present:
+
+- Commits to revert
+- Files affected
+- Potential conflicts
+
+### Step 4: Confirm and Execute
+
+Ask for confirmation before reverting.
+
+**Hard revert (default):**
+
+```bash
+git revert --no-commit [commits...]
+git commit -m "revert: [bead-id] [scope]"
+```
+
+**Soft revert (--soft):**
+
+```bash
+git revert --no-commit [commits...]
+# Leave changes staged for review
+```
+
+### Step 5: Update Bead
+
+```bash
+bd update [bead-id] --status reverted --note "Reverted [scope]"
+```
+
+## Safety Checks
+
+Before reverting:
+
+- [ ] Check for uncommitted changes
+- [ ] Verify bead exists and has commits
+- [ ] Check for dependent beads
+- [ ] Identify potential merge conflicts
+
+If conflicts detected:
+
+1. List conflicting files
+2. Offer to abort or continue with manual resolution
+3. Provide conflict resolution guidance
+
+## Output
+
+Report:
+
+- Commits reverted
+- Files restored
+- Bead status updated
+- Next steps
+
+## Related Commands
+
+```bash
+# View bead history
+bd show [bead-id] --history
+
+# Check current status
+bd status
+
+# Re-implement after revert
+/implement [bead-id]
+```

package/dist/template/.opencode/command/setup-project.md

@@ -0,0 +1,152 @@
+---
+description: Initialize project context for AI-assisted development
+argument-hint: "[--full] [--minimal]"
+agent: planner
+model: proxypal/gemini-3-flash-preview
+---
+
+# Setup Project: $ARGUMENTS
+
+Initialize project context files that AI agents and beads can reference.
+
+## Instructions
+
+Parse options from `$ARGUMENTS`:
+
+- `--full`: Create all context files with detailed prompts
+- `--minimal`: Create only essential files (default)
+
+## Context Files to Create
+
+### Essential (always created)
+
+**`.opencode/memory/project/product.md`**
+
+```markdown
+# Product Context
+
+## Vision
+
+[What is this product? What problem does it solve?]
+
+## Target Users
+
+[Who uses this? What are their needs?]
+
+## Key Features
+
+1. [Feature 1]
+2. [Feature 2]
+
+## Success Metrics
+
+- [How do we measure success?]
+```
+
+**`.opencode/memory/project/tech-stack.md`**
+
+```markdown
+# Tech Stack
+
+## Languages
+
+- [Primary language and version]
+
+## Frameworks
+
+- [Framework 1]: [Purpose]
+
+## Infrastructure
+
+- [Hosting, CI/CD, etc.]
+
+## Key Dependencies
+
+| Package | Version | Purpose |
+| ------- | ------- | ------- |
+| [name]  | [ver]   | [why]   |
+
+## Development Setup
+
+[How to get started locally]
+```
+
+### Full Setup (with --full)
+
+**`.opencode/memory/project/workflow.md`**
+
+```markdown
+# Development Workflow
+
+## Branch Strategy
+
+- main: Production
+- develop: Integration
+- feature/\*: New features
+- fix/\*: Bug fixes
+
+## Code Review
+
+[Review requirements]
+
+## Testing Requirements
+
+[What must be tested]
+
+## Deployment Process
+
+[How code gets to production]
+```
+
+**`.opencode/memory/project/conventions.md`**
+
+```markdown
+# Coding Conventions
+
+## Naming
+
+- Files: [convention]
+- Components: [convention]
+- Variables: [convention]
+
+## Structure
+
+- [Directory structure rules]
+
+## Patterns
+
+- [Design patterns used]
+
+## Anti-patterns
+
+- [What to avoid]
+```
+
+## Process
+
+1. Check if context files already exist
+2. If exists, offer to update or skip
+3. Analyze codebase to pre-fill where possible:
+   - Detect tech stack from package.json, go.mod, etc.
+   - Identify patterns from existing code
+   - Extract project info from README
+4. Create files with intelligent defaults
+5. Report what was created
+
+## Integration with Beads
+
+After setup, beads can reference:
+
+```bash
+bd new feature "Add login" --context .opencode/memory/project/
+```
+
+## Output
+
+Report:
+
+- Files created/updated
+- Detected tech stack
+- Suggested next steps
+
+Save to `.opencode/memory/project/`

package/dist/template/.opencode/command/ui-review.md

@@ -1,52 +1,44 @@
 ---
-description: Review UI/UX design or mockup with optional bead tracking
-argument-hint: "[bead-id] [path to image or component]"
+description: Review UI/UX design for quality and aesthetics
+argument-hint: "<image-or-component-path> [bead-id]"
 agent: vision
+model: proxypal/gemini-3-pro-preview
 ---
 
 # UI Review: $ARGUMENTS
 
-use_skill("ui-ux-research")
 use_skill("frontend-aesthetics")
+use_skill("visual-analysis")
 
-## Parse Arguments
+Review UI/UX design for quality, aesthetics, and best practices.
 
-Extract bead ID (if provided) and path/component from `$ARGUMENTS`. If a bead ID is present, findings will be recorded to the bead.
+## Instructions
 
-## How to Analyze
+Parse image/component path and optional bead ID from `$ARGUMENTS`.
 
-First, determine what you're reviewing. If it's an image or screenshot, start Gemini in interactive mode and reference the image to analyze it. If it's component code, analyze it directly with local tools. For large codebases spanning many files, use Gemini's non-interactive mode to scan the entire directory.
+## What to Evaluate
 
-## What to Look For
+1. **Typography** - Avoid generic fonts (Inter/Roboto without purpose)
+2. **Colors** - Check for overused AI patterns (purple gradients, flat white)
+3. **Layout** - Hierarchy, spacing, visual rhythm
+4. **Motion** - Micro-interactions, transitions
+5. **Atmosphere** - Texture, depth, personality
+6. **Accessibility** - Contrast, focus states, ARIA
 
-Check typography first—generic fonts like Inter or Roboto are signs of "AI slop" aesthetics. Look at the color palette for overused patterns like purple gradients or flat white backgrounds. Assess whether the UI has any motion or micro-interactions, and whether backgrounds feel atmospheric or just flat.
+## Anti-Patterns to Flag
 
-For accessibility, verify color contrast meets WCAG AA minimum, check for ARIA labels on interactive elements, ensure keyboard navigation works, and confirm focus indicators are visible.
+- Cookie-cutter card layouts
+- Excessive rounded corners
+- Glassmorphism without purpose
+- Generic stock illustration style
 
-## Recommendations
-
-Provide specific, actionable improvements: suggest alternative fonts, propose color palette changes, identify opportunities for subtle animations, and recommend layout enhancements. Include code snippets when they would help clarify the suggestion.
-
-## Record Findings
-
-### With Bead ID
-
-Update the bead with review findings:
-
-```bash
-bd edit <bead-id> --note "UI Review: <summary of issues found and recommendations>"
-```
-
-If review reveals implementation tasks, create child beads:
-
-```bash
-bd create --title "<specific UI fix>" --type task --parent <bead-id>
-```
-
-### Without Bead ID
+## Output
 
-Output findings directly to the user.
+Provide:
 
-## Output
+1. Summary of issues found
+2. Specific actionable recommendations
+3. Code snippets for improvements
+4. Before/after suggestions
 
-Summarize what issues you found, what specific changes you recommend, and show before/after comparisons for significant improvements.
+If bead ID provided, record findings to the bead.

package/dist/template/.opencode/memory/project/README.md

@@ -0,0 +1,28 @@
+# Project Context Template
+
+Use `/setup-project` command to initialize these files.
+
+## Files Created
+
+| File             | Purpose                             |
+| ---------------- | ----------------------------------- |
+| `product.md`     | Product vision, users, features     |
+| `tech-stack.md`  | Languages, frameworks, dependencies |
+| `workflow.md`    | Branch strategy, review, deployment |
+| `conventions.md` | Coding standards, patterns          |
+
+## Integration with Beads
+
+Beads can reference project context:
+
+```bash
+bd new feature "Add auth" --context .opencode/memory/project/
+```
+
+## Integration with Commands
+
+Commands automatically check:
+
+- `/implement` - Reads tech-stack for implementation guidance
+- `/plan` - Reads product for feature alignment
+- `/review-codebase` - Reads conventions for compliance