opencodekit 0.3.3 → 0.5.0

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

@@ -0,0 +1,40 @@
+---
+description: Edit image with natural language instructions
+argument-hint: "<image-path> <edit-instruction>"
+agent: vision
+model: proxypal/gemini-3-pro-image-preview
+---
+
+# Edit Image: $ARGUMENTS
+
+Edit an existing image using natural language.
+
+## Instructions
+
+Parse from `$ARGUMENTS`:
+
+- Image path (first argument)
+- Edit instruction (remaining text)
+
+## Examples
+
+- `screenshot.png remove the background`
+- `logo.png change the color to blue`
+- `photo.jpg add a sunset sky`
+- `ui.png make the button larger`
+
+## Process
+
+1. Load and analyze the source image
+2. Understand the edit request
+3. Apply the edit preserving unaffected areas
+4. Save to `.opencode/memory/design/edited/` with descriptive name
+
+## Output
+
+Report:
+
+- Original image analysis
+- Edit applied
+- Output path
+- Offer refinements

package/dist/template/.opencode/command/generate-diagram.md

@@ -0,0 +1,48 @@
+---
+description: Generate technical diagrams, flowcharts, wireframes
+argument-hint: "<description> [type: flowchart|wireframe|architecture|erd|sequence]"
+agent: vision
+model: proxypal/gemini-3-flash-preview
+---
+
+# Generate Diagram: $ARGUMENTS
+
+Generate technical diagrams and visual documentation.
+
+## Instructions
+
+Parse from `$ARGUMENTS`:
+
+- Diagram description
+- Type (default: flowchart)
+
+## Types
+
+- **flowchart**: Process flows, decision trees
+- **wireframe**: UI layouts, screen mockups
+- **architecture**: System architecture, components
+- **erd**: Entity relationship diagrams
+- **sequence**: Interaction sequences
+
+## Output Formats
+
+Generate both:
+
+1. Visual image (PNG)
+2. Mermaid/PlantUML code equivalent
+
+## Process
+
+1. Parse the description into structural elements
+2. Create clean, professional diagram
+3. Use consistent styling
+4. Include legend if complex
+
+## Output
+
+Save to `.opencode/memory/design/diagrams/`:
+
+- Diagram image
+- Mermaid code file (.mmd)
+
+Report files and display the Mermaid code inline.

package/dist/template/.opencode/command/generate-icon.md

@@ -0,0 +1,40 @@
+---
+description: Generate app icons in multiple sizes
+argument-hint: "<description> [platform: ios|android|web|all] [style: flat|3d|minimal]"
+agent: vision
+model: proxypal/gemini-3-pro-image-preview
+---
+
+# Generate Icon: $ARGUMENTS
+
+Generate app icons optimized for different platforms.
+
+## Instructions
+
+Parse from `$ARGUMENTS`:
+
+- Description of icon
+- Platform (default: all)
+- Style (default: minimal)
+
+## Platforms & Sizes
+
+**iOS**: 1024x1024, 180x180, 120x120, 60x60
+**Android**: 512x512, 192x192, 144x144, 96x96, 48x48
+**Web**: favicon.ico, 32x32, 16x16, apple-touch-icon
+
+## Style Options
+
+- **flat**: Clean, no shadows
+- **3d**: Depth, gradients, shadows
+- **minimal**: Simple shapes, limited colors
+
+## Output
+
+Save to `.opencode/memory/design/icons/`:
+
+- Master icon at highest resolution
+- All platform-specific sizes
+- Include manifest.json for web
+
+Report all generated files.

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

@@ -0,0 +1,27 @@
+---
+description: Generate images using Gemini image models
+argument-hint: "<prompt> [--style=<style>] [--pro]"
+agent: vision
+model: proxypal/gemini-3-pro-image-preview
+---
+
+# Generate Image: $ARGUMENTS
+
+Generate an image based on the provided prompt.
+
+## Instructions
+
+Parse the prompt and any style modifiers from `$ARGUMENTS`.
+
+If `--pro` flag is present, confirm using the Pro model for higher quality.
+
+Create a detailed image generation prompt that includes:
+
+- The core subject/scene from user's prompt
+- Style direction if `--style` was specified
+- Composition and lighting suggestions
+- Any relevant artistic details
+
+Generate the image and save to `.opencode/memory/design/images/` with a descriptive filename.
+
+Report the generated image path and offer to refine if needed.

package/dist/template/.opencode/command/generate-pattern.md

@@ -0,0 +1,41 @@
+---
+description: Generate seamless patterns and textures
+argument-hint: "<description> [type: geometric|organic|abstract|texture] [colors: <palette>]"
+agent: vision
+model: proxypal/gemini-3-pro-image-preview
+---
+
+# Generate Pattern: $ARGUMENTS
+
+Generate seamless, tileable patterns and textures.
+
+## Instructions
+
+Parse from `$ARGUMENTS`:
+
+- Pattern description
+- Type (default: geometric)
+- Color palette (optional)
+
+## Types
+
+- **geometric**: Shapes, grids, lines
+- **organic**: Nature-inspired, flowing
+- **abstract**: Artistic, experimental
+- **texture**: Material surfaces (wood, marble, fabric)
+
+## Requirements
+
+- Must tile seamlessly in all directions
+- Generate at 512x512 minimum
+- Include both light and dark variants if useful
+
+## Output
+
+Save to `.opencode/memory/design/patterns/`:
+
+- Main pattern file
+- Tiled preview showing seamless repeat
+- CSS snippet for background usage
+
+Report generated files and usage example.

package/dist/template/.opencode/command/generate-storyboard.md

@@ -0,0 +1,41 @@
+---
+description: Generate sequential images for visual storytelling
+argument-hint: "<story-description> [frames: N] [style: comic|realistic|sketch]"
+agent: vision
+model: proxypal/gemini-3-pro-image-preview
+---
+
+# Generate Storyboard: $ARGUMENTS
+
+Generate a sequence of images telling a visual story.
+
+## Instructions
+
+Parse from `$ARGUMENTS`:
+
+- Story description or script
+- Number of frames (default: 4)
+- Visual style (default: sketch)
+
+## Styles
+
+- **comic**: Bold lines, panels, speech bubbles
+- **realistic**: Photo-realistic scenes
+- **sketch**: Hand-drawn, rough storyboard style
+
+## Process
+
+1. Break story into key moments
+2. Maintain visual consistency (characters, settings)
+3. Generate each frame with clear narrative progression
+4. Number frames sequentially
+
+## Output
+
+Save to `.opencode/memory/design/storyboards/<story-name>/`:
+
+- Individual frame images (01.png, 02.png, etc.)
+- Combined storyboard sheet
+- Scene descriptions text file
+
+Report generated sequence.

package/dist/template/.opencode/command/init.md

@@ -0,0 +1,176 @@
+---
+description: Initialize project for AI-assisted development (creates AGENTS.md + memory files)
+argument-hint: "[--deep] [--skip-questions]"
+agent: planner
+---
+
+# Init: $ARGUMENTS
+
+One command to onboard a project. Creates project-root AGENTS.md and populates memory files.
+
+## Options
+
+- `--deep`: Comprehensive research (~100+ tool calls). Git history, patterns, contributors.
+- `--skip-questions`: Skip upfront questions, infer from git config.
+
+Default: Standard research (~20-50 tool calls).
+
+## Phase 1: Upfront Questions
+
+Unless `--skip-questions`, ask in one message:
+
+1. **Identity**: "Which git contributor are you?" (show top 5 from `git shortlog -sn --all | head -5`)
+2. **Communication**: "Terse or detailed responses?"
+3. **Workflow**: "Auto-commit or ask-first?"
+4. **Rules**: "Any rules I should always follow?"
+
+If skipped, infer identity from `git config user.name` and `git config user.email`.
+
+## Phase 2: Detect Project
+
+### Always Check
+
+- `package.json`, `go.mod`, `pyproject.toml`, `Cargo.toml` - tech stack
+- `README.md` - project description
+- `.github/workflows/`, `.gitlab-ci.yml` - CI/CD
+- `Makefile`, `justfile` - build commands
+- Existing rules: `.cursor/rules/`, `.cursorrules`, `.github/copilot-instructions.md`
+
+### With --deep
+
+- `git shortlog -sn --all | head -10` - contributors
+- `git log --format="%s" -50` - commit conventions
+- `git branch -a` - branching strategy
+- Source file analysis for patterns
+
+## Phase 3: Create Project-Root AGENTS.md
+
+Create `./AGENTS.md` (project root, ~20-30 lines):
+
+```markdown
+## Build/Lint/Test Commands
+
+**Build**: [detected command]
+**Test**: [detected command, include single-test syntax]
+**Lint**: [detected command]
+
+## Code Style
+
+**Imports**: [detected pattern]
+**Formatting**: [tool used, e.g., prettier, black]
+**Types**: [strict, optional, none]
+**Naming**: [conventions detected]
+**Error Handling**: [pattern detected]
+
+## Project-Specific Rules
+
+[Include any rules from .cursorrules, copilot-instructions, or user-provided]
+```
+
+If AGENTS.md exists, improve it - don't overwrite blindly.
+
+## Phase 4: Populate Memory Files
+
+### .opencode/memory/user.md
+
+```markdown
+---
+purpose: User identity, preferences, communication style
+updated: [today]
+---
+
+# User Profile
+
+## Identity
+
+- Name: [from git/questions]
+- Git contributor: [email/username]
+
+## Preferences
+
+- Communication: [terse/detailed]
+- Workflow: [auto-commit/ask-first]
+
+## Rules
+
+[from Phase 1]
+```
+
+### .opencode/memory/project/commands.md
+
+```markdown
+---
+purpose: Build, test, lint, deploy commands
+updated: [today]
+---
+
+# Commands
+
+## Build
+
+[detected]
+
+## Test
+
+[detected, include single-test example]
+
+## Lint
+
+[detected]
+```
+
+### .opencode/memory/project/architecture.md
+
+```markdown
+---
+purpose: Key modules, directory structure
+updated: [today]
+---
+
+# Architecture
+
+## Structure
+
+[detected directory layout]
+
+## Key Modules
+
+[identified entry points, core modules]
+```
+
+### With --deep, also create:
+
+- `project/conventions.md` - from git log analysis
+- `project/gotchas.md` - from bug-fix patterns in history
+
+## Phase 5: Reflection
+
+Before finishing:
+
+1. Did you create both AGENTS.md AND memory files?
+2. Are commands accurate and tested?
+3. Any typos or unclear descriptions?
+4. Would this help your future self?
+
+Fix issues found.
+
+## Phase 6: Summary
+
+Report:
+
+- Files created/updated
+- Tech stack detected
+- Key findings
+- Suggested next steps (e.g., "Run /review-codebase to check conventions")
+
+## File Locations
+
+```
+./AGENTS.md                              # Project-specific rules (created)
+.opencode/AGENTS.md                      # Global rules (untouched)
+.opencode/memory/user.md                 # User preferences (created)
+.opencode/memory/project/commands.md     # Build commands (created)
+.opencode/memory/project/architecture.md # Structure (created)
+.opencode/memory/project/conventions.md  # Patterns (--deep only)
+.opencode/memory/project/gotchas.md      # Warnings (--deep only)
+```

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