opencodekit 0.10.0 → 0.11.1

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

@@ -1,13 +1,302 @@
 ---
-description: Brainstorm and explore ideas with code
-argument-hint: "[topic]"
+description: Brainstorm and explore ideas with structured ideation
+argument-hint: "<topic or bead-id> [--quick]"
 agent: build
 ---
 
 # Brainstorm: $ARGUMENTS
 
-skill({ name: "brainstorming" })
+## Load Beads Skill
 
-Follow the skill for ideation, then explore the codebase to validate feasibility. Create quick prototypes or code spikes if helpful.
+```typescript
+skill({ name: "beads" });
+```
 
-If bead exists, use `.beads/artifacts/<bead-id>/spec.md` as constraints.
+## Options
+
+- `--quick`: 15-minute time box (default: 30 minutes)
+
+## Phase 1: Load Context
+
+**Load skill:**
+
+```typescript
+skill({ name: "brainstorming" });
+```
+
+**Check for bead context:**
+
+If `$ARGUMENTS` is a bead ID:
+
+```typescript
+bd_show({ id: "$ARGUMENTS" });
+```
+
+Load constraints from `.beads/artifacts/<bead-id>/spec.md` if it exists.
+
+**Check for prior thinking:**
+
+```typescript
+memory - search({ query: "[topic keywords]" });
+```
+
+## Phase 2: Set Boundaries
+
+Before brainstorming, establish:
+
+```
+Brainstorm Session: $ARGUMENTS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Topic: [what we're exploring]
+Goal: [what decision/outcome we need]
+Constraints: [hard limits from spec or user]
+Time box: [15/30 minutes]
+
+Out of scope:
+- [what we're NOT considering]
+```
+
+## Phase 3: Diverge (Generate Ideas)
+
+**Goal:** Quantity over quality. No evaluation yet.
+
+Generate 5-10 ideas rapidly:
+
+```
+Ideas:
+━━━━━━
+
+1. [Idea name]
+   Brief: [1-2 sentences]
+
+2. [Idea name]
+   Brief: [1-2 sentences]
+
+3. [Idea name]
+   Brief: [1-2 sentences]
+
+... continue to 5-10 ideas
+```
+
+**Techniques:**
+
+- **Inversion:** What's the opposite approach?
+- **Analogy:** How do others solve similar problems?
+- **Constraint removal:** What if [constraint] didn't exist?
+- **Combination:** Can we merge two partial solutions?
+- **Extreme:** What's the simplest? Most complex?
+
+## Phase 4: Explore Codebase
+
+Validate feasibility against existing code:
+
+```typescript
+// Find related patterns
+grep({ pattern: "[related concept]", include: "*.ts" });
+ast - grep({ pattern: "[code pattern]" });
+
+// Understand existing architecture
+lsp_document_symbols({ filePath: "<relevant file>" });
+```
+
+For each promising idea, note:
+
+- Existing code that supports it
+- Existing code that conflicts
+- New code required
+
+## Phase 5: Converge (Evaluate Ideas)
+
+Rate each idea on 4 dimensions:
+
+| Idea | Feasibility | Impact | Effort | Risk  | Score  |
+| ---- | ----------- | ------ | ------ | ----- | ------ |
+| 1    | H/M/L       | H/M/L  | S/M/L  | H/M/L | [1-10] |
+| 2    | H/M/L       | H/M/L  | S/M/L  | H/M/L | [1-10] |
+| ...  |             |        |        |       |        |
+
+**Scoring guide:**
+
+- **Feasibility:** Can we actually build this? (H=easy, L=very hard)
+- **Impact:** How much value does this deliver? (H=high value)
+- **Effort:** How much work? (S=small, L=large)
+- **Risk:** What could go wrong? (H=high risk)
+
+**Score formula:** (Feasibility × Impact) / (Effort × Risk)
+
+## Phase 6: Deep Dive Top 3
+
+For the top 3 scoring ideas:
+
+### Idea [N]: [Name]
+
+**Approach:**
+[2-3 sentence description]
+
+**How it works:**
+
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+**Pros:**
+
+- [Advantage 1]
+- [Advantage 2]
+
+**Cons:**
+
+- [Disadvantage 1]
+- [Disadvantage 2]
+
+**Code sketch:**
+
+```typescript
+// Quick pseudocode or structure
+```
+
+**Open questions:**
+
+- [Uncertainty 1]
+- [Uncertainty 2]
+
+## Phase 7: Prototype (Optional)
+
+For the most promising idea, create a quick spike:
+
+```
+Prototype Goal:
+━━━━━━━━━━━━━━━
+
+Question to answer: [what are we validating?]
+Time limit: 15 minutes
+Success criteria: [how we know it works]
+```
+
+Create throwaway code to validate:
+
+```bash
+# Create spike branch
+git checkout -b spike/brainstorm-$ARGUMENTS
+```
+
+Build minimal proof of concept. Delete or keep based on learnings.
+
+## Phase 8: Capture Decision
+
+Save brainstorm results:
+
+**If bead exists:**
+
+Write to `.beads/artifacts/<bead-id>/brainstorm.md`:
+
+```markdown
+# Brainstorm: [Topic]
+
+**Date:** [date]
+**Duration:** [N] minutes
+**Bead:** <bead-id>
+
+## Goal
+
+[What we were exploring]
+
+## Ideas Considered
+
+| Idea | Feasibility | Impact | Effort | Risk | Score |
+| ---- | ----------- | ------ | ------ | ---- | ----- |
+| [1]  | H           | H      | M      | L    | 8     |
+| [2]  | M           | H      | S      | M    | 6     |
+| [3]  | L           | M      | L      | H    | 2     |
+
+## Recommendation
+
+**Chosen approach:** [Idea N]
+
+**Rationale:** [Why this approach]
+
+## Next Steps
+
+- [ ] [Action 1]
+- [ ] [Action 2]
+```
+
+**Create observation for reusable insights:**
+
+```typescript
+observation({
+  type: "discovery",
+  title: "Brainstorm: [topic]",
+  content: `
+## Key Insight
+[What we learned]
+
+## Approach Chosen
+[Brief description]
+
+## Why Others Rejected
+[Brief notes on alternatives]
+  `,
+  concepts: "[topic keywords]",
+  bead_id: "<bead-id>",
+});
+```
+
+## Phase 9: Create Follow-up Beads
+
+For promising ideas that need more work:
+
+```typescript
+bd_add({
+  title: "[Idea name]",
+  type: "task",
+  pri: 2,
+  desc: "From brainstorm: [topic]. Needs research/prototyping.",
+  tags: ["brainstorm"],
+});
+```
+
+## Output
+
+```
+Brainstorm Complete: $ARGUMENTS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Duration: [N] minutes
+Ideas generated: [N]
+Ideas evaluated: [N]
+
+Top 3:
+1. [Idea 1] - Score: [N]
+2. [Idea 2] - Score: [N]
+3. [Idea 3] - Score: [N]
+
+Recommendation: [Chosen approach]
+Confidence: [High/Medium/Low]
+
+Artifacts:
+- .beads/artifacts/<bead-id>/brainstorm.md (if bead)
+- Observation created ✓
+
+Follow-up beads: [N] created
+```
+
+**Next steps:**
+
+```
+If ready to proceed:
+  /research <bead-id>   # Validate approach
+  /plan <bead-id>       # Create implementation plan
+
+If need more exploration:
+  /brainstorm <new-aspect>   # Continue ideation
+```
+
+## Anti-Patterns
+
+- ❌ **Evaluating during divergence** - Generate first, judge later
+- ❌ **Falling in love with first idea** - Explore alternatives
+- ❌ **Infinite brainstorming** - Time box and decide
+- ❌ **No decision** - Brainstorming must produce a recommendation
+- ❌ **No capture** - Undocumented ideas are lost ideas

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

@@ -1,39 +1,253 @@
 ---
 description: Commit with verification and optional bead traceability
-argument-hint: "[bead-id]"
+argument-hint: "[bead-id] [--amend]"
+agent: build
 ---
 
 # Commit
 
-skill({ name: "verification-before-completion" })
+**Load skills:**
 
-## Workflow
+```typescript
+skill({ name: "beads" }); // Session protocol
+skill({ name: "verification-before-completion" });
+```
+
+## Options
+
+- `--amend`: Amend the last commit (only if not pushed and you created it)
+
+## Phase 1: Check Git State
+
+```bash
+git status --porcelain
+git diff --stat
+git diff --cached --stat
+```
 
-1. Run all tests/lints
-2. Verify output shows success
-3. Commit with conventional message format
+Report:
 
-## Bead Integration (Optional)
+```
+Git State:
+━━━━━━━━━━
+
+Staged:
+- [file1] (modified)
+- [file2] (new)
 
-If a bead ID is provided (`$ARGUMENTS`), include it in the commit message for traceability:
+Unstaged:
+- [file3] (modified)
 
+Untracked:
+- [file4]
 ```
-<type>(<scope>): <description>
 
-<bead-id>: <what was done for this bead>
+If nothing staged: "No changes staged. Run `git add <files>` first."
+
+## Phase 2: Run Verification Gates
 
-[optional body]
+Detect project type and run gates:
+
+```bash
+ls package.json Cargo.toml pyproject.toml go.mod Makefile 2>/dev/null
 ```
 
-**Example:**
+| Project | Test Command    | Lint Command                         |
+| ------- | --------------- | ------------------------------------ |
+| Node.js | `npm test`      | `npm run lint && npm run type-check` |
+| Rust    | `cargo test`    | `cargo clippy -- -D warnings`        |
+| Python  | `pytest`        | `ruff check . && mypy .`             |
+| Go      | `go test ./...` | `golangci-lint run`                  |
+
+```
+Verification:
+━━━━━━━━━━━━━
 
+Tests: [✓/✗/skipped]
+Lint:  [✓/✗/skipped]
+Types: [✓/✗/skipped]
 ```
-feat(auth): add OAuth2 login flow
 
-bd-a1b2c3: implement token refresh mechanism
+**If any gate fails:**
 
-- Added refresh token storage
-- Integrated with session manager
 ```
+Cannot commit: [gate] failed.
+
+Fix errors or use `git commit --no-verify` (not recommended).
+```
+
+## Phase 3: Analyze Changes for Message
+
+```bash
+git diff --cached --stat
+git diff --cached
+```
+
+Determine:
+
+- **Type**: What kind of change is this?
+- **Scope**: Which module/component changed?
+- **Summary**: What does this change do?
+
+### Commit Type Guide
+
+| Type       | When to Use                             | Example                            |
+| ---------- | --------------------------------------- | ---------------------------------- |
+| `feat`     | New feature for user                    | `feat(auth): add OAuth login`      |
+| `fix`      | Bug fix                                 | `fix(api): handle null response`   |
+| `refactor` | Code change (no new feature or fix)     | `refactor(utils): simplify parser` |
+| `docs`     | Documentation only                      | `docs: update API reference`       |
+| `test`     | Adding or updating tests                | `test(auth): add login tests`      |
+| `chore`    | Maintenance, deps, tooling              | `chore: update dependencies`       |
+| `style`    | Formatting, whitespace (no code change) | `style: fix indentation`           |
+| `perf`     | Performance improvement                 | `perf(db): add query caching`      |
+| `ci`       | CI/CD changes                           | `ci: add deploy workflow`          |
+
+### Scope Detection
+
+Auto-detect scope from changed files:
 
-If no bead ID is provided, proceed with standard conventional commit format.
+| Changed Files           | Suggested Scope |
+| ----------------------- | --------------- |
+| `src/auth/*`            | auth            |
+| `src/api/*`             | api             |
+| `src/components/*`      | ui              |
+| `tests/*`               | test            |
+| `docs/*`                | docs            |
+| Multiple unrelated dirs | (omit scope)    |
+
+## Phase 4: Generate Commit Message
+
+Propose message based on analysis:
+
+```
+Proposed Commit:
+━━━━━━━━━━━━━━━━
+
+<type>(<scope>): <summary>
+
+[body - what and why, not how]
+
+[footer - bead reference, breaking changes]
+```
+
+**Example with bead:**
+
+```
+feat(auth): add token refresh mechanism
+
+Implement automatic token refresh when access token expires.
+Tokens are stored in secure session storage.
+
+bd-a1b2c3: OAuth implementation
+```
+
+**Example with breaking change:**
+
+```
+feat(api)!: change response format
+
+BREAKING CHANGE: API responses now use camelCase instead of snake_case.
+Migration guide: https://...
+```
+
+Ask user:
+
+```
+Use this message? (yes/edit/cancel)
+```
+
+## Phase 5: Execute Commit
+
+```bash
+git commit -m "<message>"
+```
+
+**If pre-commit hook fails:**
+
+```
+Pre-commit hook failed:
+━━━━━━━━━━━━━━━━━━━━━━━
+
+[hook output]
+
+Options:
+1. Fix issues and retry: /commit [bead-id]
+2. Skip hook (not recommended): git commit --no-verify -m "..."
+```
+
+**Do NOT use --amend** unless:
+
+1. User explicitly requested `--amend`
+2. You created the HEAD commit in this session
+3. Commit has NOT been pushed to remote
+
+## Phase 6: Sync (for multi-agent)
+
+If bead ID was provided:
+
+```typescript
+bd_sync({ reason: "Committed changes for <bead-id>" });
+```
+
+## Output
+
+```
+Committed: [short-hash]
+━━━━━━━━━━━━━━━━━━━━━━━
+
+Message: <type>(<scope>): <summary>
+Files: [N] changed
+Bead: <bead-id> (if provided)
+
+Verification: All gates passed ✓
+```
+
+**Next steps:**
+
+```
+Continue working:
+  [make more changes]
+  /commit [bead-id]
+
+Ready to finish:
+  /finish <bead-id>
+
+Create PR:
+  /pr <bead-id>
+```
+
+## Amend Workflow (--amend)
+
+**Safety checks before amend:**
+
+```bash
+git log -1 --format='%H %s'  # What we're amending
+git status                    # Check if pushed
+```
+
+```
+Amend Safety Check:
+━━━━━━━━━━━━━━━━━━━
+
+HEAD commit: [hash] [message]
+Pushed to remote: [yes/no]
+Created by you: [yes/no]
+```
+
+**If pushed or not created by you: STOP.**
+
+```
+Cannot amend: Commit already pushed or not created by you.
+
+Use a new commit instead:
+  git add <files>
+  /commit [bead-id]
+```
+
+**If safe to amend:**
+
+```bash
+git add <files>
+git commit --amend -m "<updated message>"
+```