opencodekit 0.15.20 → 0.16.0

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

@@ -1,650 +0,0 @@
----
-description: Create a new feature with discovery, spec, plan, and sub-tasks
-argument-hint: "<feature-name> [--priority=<0-4>] [--type=<type>] [--worktree] [--quick]"
-agent: plan
----
-
-# New Feature: $ARGUMENTS
-
-Create a complete feature track with Epic → Task → Subtask hierarchy, proper worktree isolation, and subagent delegation.
-
-## Load Skills
-
-```typescript
-skill({ name: "beads" });
-skill({ name: "brainstorming" });
-skill({ name: "swarm-coordination" }); // For parallel task execution with Kimi K2.5 PARL
-```
-
-## Parse Arguments
-
-| Argument     | Default  | Options                              |
-| ------------ | -------- | ------------------------------------ |
-| Feature name | required | Descriptive name                     |
-| `--priority` | 2        | 0 (critical) to 4 (backlog)          |
-| `--type`     | feature  | feature, bug, refactor, chore        |
-| `--worktree` | false    | Create git worktree for isolation    |
-| `--quick`    | false    | Skip brainstorming, use minimal spec |
-
----
-
-## Hierarchy Model
-
-```
-Epic (feature-level)
-├── Task 1 (domain or phase)
-│   ├── Subtask 1.1 (atomic work unit)
-│   └── Subtask 1.2
-├── Task 2 (blocked by Task 1)
-│   └── Subtask 2.1
-└── Task 3 (blocked by Task 2)
-```
-
-| Level   | Scope        | Typical Duration | Agent Work                |
-| ------- | ------------ | ---------------- | ------------------------- |
-| Epic    | Full feature | Days-weeks       | Coordinate, not implement |
-| Task    | Domain/phase | Hours-day        | May implement or delegate |
-| Subtask | Atomic unit  | 30min-2hrs       | Implement directly        |
-
----
-
-## Phase 1: Context Gathering
-
-Before creating anything, understand the landscape.
-
-### Parallel Subagent Research
-
-```typescript
-// Run both in parallel - multiple Task calls in one message
-Task({
-  subagent_type: "explore",
-  description: "Explore codebase for feature",
-  prompt: `Research codebase for "${$ARGUMENTS}":
-    1. Find similar implementations or patterns
-    2. Identify likely affected directories
-    3. Find existing tests in related areas
-    4. Check for related beads (open or closed)
-    Return: File paths, patterns, test locations, related beads`,
-});
-
-Task({
-  subagent_type: "scout",
-  description: "Research best practices",
-  prompt: `Research best practices for "${$ARGUMENTS}":
-    1. Industry patterns for this type of feature
-    2. Library/framework recommendations
-    3. Common pitfalls to avoid
-    Return: Recommendations, code examples, warnings`,
-});
-
-// Both run in parallel, results available immediately
-```
-
-### Check Existing Work
-
-```bash
-bd list --status all --limit 20 | grep -i "[relevant-terms]"
-git log --oneline -10 -- src/[relevant-path]/
-```
-
-**Report:**
-
-```
-Context Analysis
-━━━━━━━━━━━━━━━━
-
-Related beads:
-- bd-abc123: "User auth system" (closed)
-- bd-def456: "Session management" (in_progress)
-
-Codebase signals:
-- Similar patterns in: src/auth/, src/api/
-- Test patterns: src/__tests__/*.test.ts
-- Recent activity: 3 commits this week
-
-External research:
-- [Key findings from scout]
-```
-
----
-
-## Phase 2: Brainstorming (unless --quick)
-
-Before filling templates, explore the problem space.
-
-### Discovery Questions
-
-Ask the user (or infer from context):
-
-1. **Problem**: What specific problem are we solving?
-2. **Users**: Who benefits from this feature?
-3. **Success**: How will we know it's working?
-4. **Alternatives**: What other approaches exist?
-5. **Risks**: What could go wrong?
-6. **Dependencies**: What does this need to work?
-7. **Scope**: What's explicitly NOT included?
-
-### Present Options
-
-```
-Brainstorming: [Feature Name]
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Problem understood:
-[Summarize the core problem]
-
-Considered approaches:
-1. [Approach A] - Pros: [...] Cons: [...]
-2. [Approach B] - Pros: [...] Cons: [...]
-3. [Approach C] - Pros: [...] Cons: [...]
-
-Recommended approach: [X]
-Rationale: [Why this approach]
-
-Key risks identified:
-- [Risk 1]: Mitigation: [...]
-- [Risk 2]: Mitigation: [...]
-
-```
-
-**STOP. Use question tool to get user approval:**
-
-```typescript
-question({
-  questions: [
-    {
-      header: "Approve",
-      question: "Should I proceed with creating the specification for $ARGUMENTS?",
-      options: [
-        {
-          label: "Yes, proceed",
-          description: "Approach looks good, create spec",
-        },
-        {
-          label: "Modify approach",
-          description: "Need changes to brainstorming",
-        },
-        { label: "Explore more", description: "Need more research first" },
-      ],
-    },
-  ],
-});
-```
-
-**Wait for user's answer before proceeding to spec creation.**
-
----
-
-## Phase 3: Create Epic Bead
-
-```bash
-bd create "[Feature Name]" -t epic -p [priority]
-```
-
-Capture the bead ID (e.g., `bd-a1b2c3`) for artifact creation.
-
-```bash
-mkdir -p .beads/artifacts/[bead-id]
-```
-
----
-
-## Phase 4: Create Specification
-
-Write `.beads/artifacts/[bead-id]/spec.md`:
-
-```markdown
-# [Feature Name] Specification
-
-## Overview
-
-[1-2 paragraph summary of the feature]
-
-## Problem Statement
-
-**Current state:** [What exists now / what's broken]
-**Desired state:** [What we want to achieve]
-**Gap:** [The specific problem to solve]
-
-## User Stories
-
-- As a [user type], I want [goal], so that [benefit]
-- As a [user type], I want [goal], so that [benefit]
-
-## Acceptance Criteria
-
-Must-have (P0):
-
-- [ ] [Criterion 1]
-- [ ] [Criterion 2]
-
-Should-have (P1):
-
-- [ ] [Criterion 3]
-
-Nice-to-have (P2):
-
-- [ ] [Criterion 4]
-
-## Technical Design
-
-### Approach
-
-[Chosen approach from brainstorming]
-
-### Architecture Changes
-
-- [Component 1]: [Change description]
-- [Component 2]: [Change description]
-
-### Files Affected
-
-| File      | Change         |
-| --------- | -------------- |
-| `src/...` | [What changes] |
-
-### Dependencies
-
-- External: [APIs, services, libraries]
-- Internal: [Other features, beads]
-
-## Estimation
-
-| Size       | Effort      | Confidence        |
-| ---------- | ----------- | ----------------- |
-| [S/M/L/XL] | [X-Y hours] | [High/Medium/Low] |
-
-## Risks
-
-| Risk     | Likelihood | Impact | Mitigation      |
-| -------- | ---------- | ------ | --------------- |
-| [Risk 1] | Medium     | High   | [How to handle] |
-
-## Out of Scope
-
-- [Thing 1]
-- [Thing 2]
-
-## Success Metrics
-
-- [ ] [Metric 1]: [Target]
-- [ ] [Metric 2]: [Target]
-```
-
----
-
-## Phase 5: Create Task Breakdown
-
-Decompose epic into tasks, tasks into subtasks.
-
-### Decomposition Rules
-
-| Signal                                        | Create Separate Task |
-| --------------------------------------------- | -------------------- |
-| Different domain (frontend vs backend)        | Yes                  |
-| Natural phase boundary                        | Yes                  |
-| Could be done in parallel by different agents | Yes                  |
-| Strong dependency chain                       | Yes, with blockers   |
-| Same file, same concern                       | No - keep together   |
-
-### Task Creation with Dependencies
-
-```bash
-# Phase 1: Foundation (no blockers - starts immediately)
-bd create "Setup database schema" -t task -p 2
-# Returns: bd-xxx1
-
-# Phase 2: Core (blocked by Phase 1)
-bd create "Implement core API endpoints" -t task -p 2
-bd dep add bd-xxx2 bd-xxx1 --type blocks
-# Returns: bd-xxx2
-
-# Phase 3: Frontend (blocked by Phase 2)
-bd create "Build UI components" -t task -p 2
-bd dep add bd-xxx3 bd-xxx2 --type blocks
-# Returns: bd-xxx3
-
-# Phase 4: Integration (blocked by Phase 3)
-bd create "Integration and E2E tests" -t task -p 2
-bd dep add bd-xxx4 bd-xxx3 --type blocks
-# Returns: bd-xxx4
-
-# Link all tasks to epic
-bd dep add bd-xxx1 [epic-id]
-bd dep add bd-xxx2 [epic-id]
-bd dep add bd-xxx3 [epic-id]
-bd dep add bd-xxx4 [epic-id]
-```
-
-### Subtask Creation (for complex tasks)
-
-```bash
-# For Task 2 (API endpoints), create subtasks:
-bd create "POST /api/users endpoint" -t subtask -p 2
-bd dep add bd-xxx2.1 bd-xxx2
-
-bd create "GET /api/users/:id endpoint" -t subtask -p 2
-bd dep add bd-xxx2.2 bd-xxx2
-bd dep add bd-xxx2.2 bd-xxx2.1 --type blocks  # Sequential if needed
-```
-
-### Verify Hierarchy
-
-```bash
-bd dep tree [epic-id]
-```
-
-Expected output:
-
-```
-bd-epic: [Feature Name]
-├── bd-xxx1: Setup database schema ← READY
-├── bd-xxx2: Implement core API (blocked by bd-xxx1)
-│   ├── bd-xxx2.1: POST /api/users
-│   └── bd-xxx2.2: GET /api/users/:id (blocked by bd-xxx2.1)
-├── bd-xxx3: Build UI components (blocked by bd-xxx2)
-└── bd-xxx4: Integration tests (blocked by bd-xxx3)
-```
-
----
-
-## Phase 6: Create Implementation Plan
-
-Write `.beads/artifacts/[bead-id]/plan.md`:
-
-```markdown
-# [Feature Name] Implementation Plan
-
-**Epic:** [bead-id]
-**Estimated effort:** [X-Y hours total]
-**Approach:** [Selected from brainstorming]
-
-## Task 1: [Title] [S/M]
-
-**Bead:** bd-xxx1
-**Estimate:** 2-4 hours
-**Blocked by:** None (start immediately)
-
-Work:
-
-- [ ] [Specific task]
-- [ ] [Specific task]
-
-Verify: `[command to verify]`
-
----
-
-## Task 2: [Title] [M]
-
-**Bead:** bd-xxx2  
-**Estimate:** 4-6 hours
-**Blocked by:** Task 1
-
-Subtasks:
-
-- bd-xxx2.1: [Subtask title]
-- bd-xxx2.2: [Subtask title]
-
-Work:
-
-- [ ] [Specific task]
-
-Verify: `[command to verify]`
-
----
-
-[Continue for all tasks...]
-
-## Verification Checklist
-
-- [ ] All acceptance criteria met
-- [ ] Tests pass: `npm test`
-- [ ] Types check: `npm run typecheck`
-- [ ] Lint clean: `npm run lint`
-
-## Rollback Plan
-
-If issues detected:
-
-1. [Step 1]
-2. [Step 2]
-```
-
----
-
-## Phase 7: Worktree Setup (if --worktree)
-
-For epic-level work, create an isolated workspace:
-
-```typescript
-skill({ name: "using-git-worktrees" });
-```
-
-```bash
-# Ensure .gitignore has worktree directory
-grep -q "^\.worktrees/$" .gitignore || echo ".worktrees/" >> .gitignore
-
-# Get current branch (parent branch)
-PARENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
-
-# Create readable branch name from feature name
-FEATURE_SLUG=$(echo "[feature-name]" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | cut -c1-40)
-
-# Create branch: <parent>/feat/<epic-id>-<description>
-BRANCH_NAME="${PARENT_BRANCH}/feat/[epic-id]-${FEATURE_SLUG}"
-
-# Create worktree for the epic with readable branch
-git worktree add ".worktrees/[epic-id]" -b "$BRANCH_NAME"
-
-# Setup in worktree
-cd .worktrees/[epic-id]
-npm install  # or appropriate setup
-
-# Verify clean baseline
-npm test
-```
-
-**Worktree + Beads Integration:**
-
-- `.beads/` database is shared (main repo)
-- All `bd` commands work normally
-- Commits go to the feature branch
-- Merge back to main when epic complete
-
----
-
-## Phase 8: Parallel Task Execution with Swarm (Kimi K2.5 PARL)
-
-If multiple tasks are READY (no blockers), execute them in parallel using swarm coordination:
-
-### Step 1: Analyze Tasks for Parallelization
-
-```bash
-# Check what's ready
-bd ready --json
-```
-
-```typescript
-// Get all READY tasks
-const readyTasks = await getReadyTasks($ARGUMENTS);
-
-// Analyze if swarm mode is beneficial
-const analysis = await swarm_plan({
-  operation: "analyze",
-  task: `Implement ${$ARGUMENTS} with ${readyTasks.length} parallel tasks`,
-  files: readyTasks.map((t) => t.files).join(","),
-});
-
-console.log(`Classification: ${analysis.classification.type}`);
-console.log(`Recommended agents: ${analysis.classification.recommended_agents}`);
-```
-
-### Step 2: Setup Swarm Coordination
-
-```typescript
-const teamName = `${$ARGUMENTS}-swarm-${Date.now()}`;
-
-// Create delegation packets for each READY task
-for (const task of readyTasks) {
-  swarm_delegate({
-    bead_id: task.id,
-    title: `Execute ${task.id}: ${task.title}`,
-    expected_outcome: "Task completed with verification passing",
-    required_tools: "read, grep, lsp, edit, bash",
-    must_do: "LSP before edits, run verification, report progress via swarm-monitor",
-    must_not_do: "No new deps, don't edit files outside task scope",
-    acceptance_checks: "typecheck: npm run typecheck, lint: npm run lint, test: npm test",
-    context: `Part of epic ${$ARGUMENTS}. Team: ${teamName}`,
-    write: true,
-  });
-}
-```
-
-### Step 3: Spawn Worker Swarm
-
-```typescript
-// Launch all workers in parallel
-for (const task of readyTasks) {
-  Task({
-    subagent_type: "build",
-    description: `Execute ${task.id}`,
-    prompt: `Execute bead ${task.id}: ${task.title}
-
-## Delegation
-Read: .beads/artifacts/${task.id}/delegation.md
-
-## Coordination
-Team: ${teamName}
-Worker: worker-${task.id}
-
-## Protocol
-1. Read delegation packet
-2. Report START: swarm-monitor({ operation: "progress_update", team_name: "${teamName}", worker_id: "worker-${task.id}", phase: "implement", progress: 0, status: "working" })
-3. Execute task
-4. Report PROGRESS (every 25%): swarm-monitor({ operation: "progress_update", ...progress: 25/50/75, file: "current-file.ts" })
-5. Run acceptance checks
-6. Report DONE: swarm-monitor({ operation: "progress_update", ...progress: 100, status: "completed" })
-7. Send completion: swarm-monitor({ operation: "mail_send", team_name: "${teamName}", from_worker: "worker-${task.id}", message: "DONE: ${task.title} completed" })
-8. Close bead: bd close ${task.id} --reason "Completed via swarm"`,
-  });
-}
-```
-
-### Step 4: Monitor with TUI
-
-```typescript
-// Monitor loop with beautiful UI
-let allComplete = false;
-while (!allComplete) {
-  // Render TUI block
-  const ui = await swarm_monitor({
-    operation: "render_block",
-    team_name: teamName
-  });
-  console.log(ui);
-
-  // Check status
-  const status = await swarm_monitor({
-    operation: "status",
-    team_name: teamName
-  });
-  const stats = JSON.parse(status).summary;
-
-  allComplete = stats.completed === stats.total_workers;
-
-  if (!allComplete) {
-    await new Promise(r => setTimeout(r, 3000));
-  }
-}
-
-// Cleanup
-await swarm_monitor({ operation: "clear", team_name: teamName });
-
-// Check newly unblocked tasks
-bd ready  // → Tasks that were blocked now READY
-```
-
-**Swarm Execution Rules:**
-
-- Only fire tasks that are READY (no unresolved blockers)
-- Use `swarm-plan analyze` to determine optimal agent count
-- Workers report progress via `swarm-monitor progress_update`
-- Monitor with `swarm-monitor render_block` for TUI
-- Cleanup with `swarm-monitor clear` when done
-
----
-
-## Phase 9: Sync and Report
-
-```bash
-bd sync
-```
-
-**Output:**
-
-```
-Feature Created: [Feature Name]
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Epic: [bead-id]
-Priority: P[X]
-Estimated effort: [X-Y hours]
-
-Artifacts:
-├── .beads/artifacts/[bead-id]/spec.md
-└── .beads/artifacts/[bead-id]/plan.md
-
-Hierarchy:
-├── [task-id-1]: [Title] [S] ← READY
-├── [task-id-2]: [Title] [M] → blocked by task-1
-│   ├── [subtask-2.1]: [Title]
-│   └── [subtask-2.2]: [Title]
-├── [task-id-3]: [Title] [M] → blocked by task-2
-└── [task-id-4]: [Title] [S] → blocked by task-3
-
-Workspace: [main | worktree: .worktrees/[epic-id]]
-
-Next Steps:
-├── Start first task: /start [task-id-1]
-├── View ready work: bd ready
-└── View full tree: bd dep tree [epic-id]
-```
-
----
-
-## Quick Mode (--quick)
-
-Skip brainstorming, minimal spec:
-
-- No discovery questions
-- Single-paragraph spec
-- Flat task list (no subtasks)
-- No worktree
-
-Use for: Small features, bug fixes, well-understood work.
-
----
-
-## Subagent Delegation Summary
-
-| Phase              | Subagent   | Purpose                    |
-| ------------------ | ---------- | -------------------------- |
-| Context gathering  | `@explore` | Find codebase patterns     |
-| Context gathering  | `@scout`   | Research best practices    |
-| Brainstorming      | None       | Interactive with user      |
-| Spec/Plan creation | None       | Planner writes artifacts   |
-| Implementation     | `@build`   | `/start` then `/implement` |
-
-**Key Rule:** Planner creates structure, Build executes work. Subagents research, leaders act.
-
----
-
-## Related Commands
-
-| Need                 | Command                     |
-| -------------------- | --------------------------- |
-| Start first task     | `/start <task-id>`          |
-| View feature status  | `bd dep tree <epic-id>`     |
-| Import external plan | `/import-plan`              |
-| Complete feature     | `/finish <epic-id>`         |
-| Abandon feature      | `/revert-feature <epic-id>` |

package/dist/template/.opencode/commands/opensrc.md

@@ -1,58 +0,0 @@
----
-description: Clone a repo and enhance with AGENTS.md knowledge base
----
-
-Clone a repository using opensrc and generate hierarchical AGENTS.md documentation.
-
-## Workflow
-
-### Step 1: Load opensrc skill
-
-```
-skill({ name: 'opensrc' })
-```
-
-### Step 2: Clone the repository
-
-```bash
-npx opensrc <repo>
-```
-
-Where `<repo>` is extracted from the user request (supports `owner/repo`, `github:owner/repo`, full URL, etc.)
-
-### Step 3: Navigate to cloned repo
-
-After clone completes, cd into the repo:
-
-```bash
-cd opensrc/repos/github.com/<owner>/<repo>/
-```
-
-Parse owner/repo from the input or from `opensrc/sources.json` after clone.
-
-### Step 4: Load index-knowledge skill
-
-```
-skill({ name: 'index-knowledge' })
-```
-
-Execute in **update mode** (default) - modify existing AGENTS.md + create new where warranted.
-
-### Step 5: Report completion
-
-```
-=== opensrc Complete ===
-
-Repository: <owner>/<repo>
-Location: opensrc/repos/github.com/<owner>/<repo>/
-
-AGENTS.md files generated:
-  ✓ ./AGENTS.md (root)
-  ✓ ./src/... (if applicable)
-
-The repository is now enhanced with agent context.
-```
-
-<user-request>
-$ARGUMENTS
-</user-request>