@tudeorangbiasa/sdd-multiagent-opencode 0.1.0

package/.opencode/commands/grill-me.md

@@ -0,0 +1,99 @@
+---
+description: Interview the user relentlessly about a plan or design until reaching shared understanding. Use before /brief to clarify vague ideas, or to stress-test existing plans
+---
+
+Interview the user relentlessly about every aspect of their plan until you reach a shared understanding. Walk down each branch of the decision tree, resolving dependencies between decisions one-by-one.
+
+---
+
+## Usage
+
+```
+/grill-me $ARGUMENTS
+```
+
+**Examples:**
+```
+/grill-me I want to add authentication to my app
+/grill-me We need a notification system
+/grill-me I'm thinking of rebuilding the checkout flow
+```
+
+---
+
+## Protocol
+
+### Rules
+
+1. **Ask ONE question at a time.** Never batch multiple questions.
+2. **For each question, provide your recommended answer.** Make it easy for the user to just say "yes" if they agree.
+3. **If a question can be answered by exploring the codebase, explore the codebase instead.** Use `codebase-memory-mcp` to find existing patterns before asking.
+4. **Track the decision tree mentally.** Walk down each branch until resolved, then move to the next.
+5. **Stop when all branches are resolved** and you have enough clarity to proceed.
+
+### Question Categories
+
+Ask questions from these categories in order, skipping ones already answered:
+
+1. **Problem & Goal** — What are we building and why?
+2. **Users** — Who will use this? What do they need?
+3. **Scope** — What's in v1? What's explicitly out?
+4. **Technical** — Existing patterns? New tech? Constraints?
+5. **Success** — How do we know it's done? What metrics matter?
+
+### Question Format
+
+```
+**Question N:** [Your question]
+
+**My recommendation:** [Your suggested answer with brief rationale]
+
+Does this work, or would you change it?
+```
+
+### Codebase Exploration
+
+Before asking about technical decisions, check the codebase first:
+
+```
+Let me check how your codebase currently handles [topic]...
+
+[Use codebase-memory-mcp to explore]
+
+Found: [existing pattern at path/to/file]
+
+Given this, I'd recommend [recommendation]. Does that align with your thinking?
+```
+
+### Completion
+
+When all branches are resolved, summarize the shared understanding:
+
+```
+## Shared Understanding
+
+Here's what we've agreed on:
+
+1. **Problem:** [summary]
+2. **Users:** [who]
+3. **Scope:** [in v1 / out of v1]
+4. **Technical approach:** [direction]
+5. **Success criteria:** [metrics]
+
+**Ready to create a brief?** Run `/brief [task-id] [description]` and I'll generate the feature brief document.
+```
+
+---
+
+## When to Use
+
+- User has a vague idea and needs to clarify it before planning
+- User has a plan but wants to stress-test it for holes
+- User mentions "grill me" or "interrogate me"
+- After `/brief` if the brief feels incomplete and needs deeper exploration
+
+## When NOT to Use
+
+- User already has a clear, detailed spec → skip to `/specify` or `/plan`
+- User wants quick planning → use `/brief` directly
+- User is in a hurry → batch questions instead

package/.opencode/commands/implement.md

@@ -0,0 +1,149 @@
+---
+description: Execute the planned implementation with systematic todo-list execution and continuous progress tracking
+agent: sdd-implementer
+subtask: true
+---
+
+**You are an implementation agent.** Execute the planned implementation systematically:
+- Read all planning documents (plan.md, tasks.md, spec.md)
+- Generate a todo-list if one doesn't exist
+- Execute todos in order, respecting dependencies
+- Mark each item complete as you finish it
+- Document blockers and deviations
+- Write production-quality code
+
+---
+
+## Prerequisites
+
+- `plan.md` file in `specs/active/$1/`
+
+## Usage
+
+```
+/implement $1
+/implement $1 --tdd
+```
+
+**Flags:**
+| Flag | Description |
+|------|-------------|
+| `--tdd` | Test-Driven Development: write failing test first, then implement to pass |
+
+---
+
+## Instructions
+
+### Phase 1: Analysis
+
+Read planning documents in order:
+1. `specs/active/$1/plan.md` (REQUIRED)
+2. `specs/active/$1/spec.md` (if exists)
+3. `specs/active/$1/tasks.md` (if exists)
+4. `specs/active/$1/research.md` (if exists)
+5. `specs/active/$1/feature-brief.md` (if exists)
+
+**If plan.md doesn't exist:** Suggest running `/plan $1` or `/brief $1` first.
+
+Check for existing `todo-list.md` in the task directory.
+
+### Phase 2: Planning
+
+Present implementation plan before starting:
+- What will be built
+- Execution order/phases
+- Files to create/modify
+- Patterns to follow
+- Todo-list preview (5-10 key items)
+
+**Wait for user approval before proceeding.**
+
+### Phase 3: Execution
+
+**Create directory if it doesn't exist:** `specs/active/$1/`
+
+**Create or update todo-list.md** with task phases, individual todos with dependencies, and progress log table.
+
+**Execute todos systematically:**
+1. Read entire todo-list before starting
+2. Execute in order, respecting dependencies
+3. Mark completion: `- [ ]` → `- [x]` after each item
+4. Document blockers - never skip silently
+5. Update progress log
+
+**Show progress** after every 3-5 completed items.
+
+### Phase 3b: TDD Mode (if --tdd flag)
+
+When `--tdd` is specified, follow this loop for each todo:
+
+**Step 1: Define expected behavior**
+- Read the todo description
+- Write a failing test that captures the expected behavior
+- Test should fail with clear error message
+
+**Step 2: Write minimum code to pass**
+- Implement only what's needed to make the test pass
+- Do NOT add extra features or polish
+- Keep it minimal
+
+**Step 3: Run test**
+- Execute the specific test
+- Verify it passes
+
+**Step 4: Refactor (optional)**
+- Only after test passes, refactor if needed
+- Ensure tests still pass after refactor
+
+**TDD todo format in todo-list.md:**
+```markdown
+- [ ] [Task name] --tdd
+  - Test file: `tests/[feature].test.ts`
+  - Test describes: [expected behavior]
+```
+
+**Rules for TDD:**
+- Never write implementation code before the failing test
+- Test must fail before implementation starts
+- Only implement enough to make test pass
+- Refactor AFTER tests pass, not before
+
+### Phase 4: Verification
+
+Spawn `sdd-verifier` subagent to independently validate:
+- [ ] All todos complete or blocked
+- [ ] Code follows project patterns
+- [ ] No linter errors
+- [ ] Tests pass (if applicable)
+- [ ] Spec requirements met
+
+---
+
+## Output
+
+**End response with:**
+
+```
+✅ Implementation complete: $1
+
+**Summary:**
+- Completed: [X]/[Y] tasks
+- Blocked: [N] items (if any)
+- Files created: [count]
+- Files modified: [count]
+
+**What was built:**
+- [Feature/component 1]
+- [Feature/component 2]
+
+**Blocked items (if any):**
+- [Item]: [Reason]
+
+**Next steps:**
+- Run tests: `[test command]`
+- Review changes in IDE
+- Update specs: `/evolve $1 [discovery]`
+
+**Files:**
+- Todo list: `specs/active/$1/todo-list.md`
+```

package/.opencode/commands/init-sdd.md

@@ -0,0 +1,141 @@
+---
+description: Install or refresh SDD workflow into current project
+agent: sdd-orchestrator
+---
+
+Install Spec-Driven Development workflow (commands, agents, skills, templates) into a project that already has base rules.
+
+---
+
+## Usage
+
+```
+/init-sdd
+```
+
+---
+
+## Prerequisites
+
+This command expects `opencode-agent-rules` to be installed first. Check for:
+- `AGENTS.md` in project root
+- `.opencode/rules/context-budget.md` exists
+
+If missing, output:
+```
+⚠️ Base rules not found.
+
+Please install opencode-agent-rules first:
+1. Clone or copy base rules to project
+2. Run /init-rules
+3. Then run /init-sdd
+```
+
+---
+
+## Behavior
+
+### Phase 1: Verify Prerequisites
+
+1. Check if `AGENTS.md` exists
+2. Check if `.opencode/rules/context-budget.md` exists
+3. If either missing, abort and show install instructions
+
+### Phase 2: Create Directory Structure
+
+Create if missing:
+```
+.sdd/
+├── config.json
+├── templates/
+specs/
+├── active/
+├── backlog/
+├── completed/
+└── todo-roadmap/
+```
+
+### Phase 3: Install SDD Files
+
+Copy from this repo:
+- `.opencode/agents/*` → `.opencode/agents/`
+- `.opencode/commands/*` → `.opencode/commands/`
+- `.opencode/skills/*` → `.opencode/skills/`
+- `.sdd/config.json` → `.sdd/config.json`
+- `.sdd/templates/*` → `.sdd/templates/`
+
+Note: Do NOT overwrite existing `.opencode/` directories if project has custom commands.
+
+### Phase 4: Create Project Profile
+
+Create `.sdd/project-profile.json` with this structure:
+
+```json
+{
+  "projectState": "unknown",
+  "initialized": "DATE",
+  "stack": {
+    "framework": null,
+    "language": null,
+    "packageManager": null,
+    "styling": null
+  },
+  "commands": {
+    "dev": null,
+    "build": null,
+    "test": null,
+    "lint": null
+  },
+  "design": {
+    "sourceOfTruth": null,
+    "hasDesignMd": false,
+    "hasProductMd": false,
+    "componentRoots": []
+  },
+  "skillRouting": {
+    "uiDefault": "existing-design-system",
+    "visualVerification": "sdd-verifier",
+    "codeReview": "sdd-reviewer"
+  }
+}
+```
+
+### Phase 5: Merge opencode.json
+
+If project has `opencode.json`, merge these sections:
+- `agents` definitions
+- `permission` rules
+
+If project doesn't have `opencode.json`, create from this repo's template.
+
+---
+
+## Output
+
+```
+✅ SDD workflow installed
+
+Files installed:
+- .opencode/agents/ (6 agents)
+- .opencode/commands/ (16 commands)
+- .opencode/skills/ (5 skills)
+- .sdd/config.json
+- .sdd/templates/ (8 templates)
+- .sdd/project-profile.json
+
+⚠️ Next steps:
+1. Update project-profile.json with your stack
+2. Run /brief <feature> to start
+
+Available commands:
+/brief /research /specify /plan /tasks /implement /audit
+```
+
+---
+
+## Re-run Behavior
+
+If running again (project already has SDD):
+- Report: "SDD already installed"
+- Offer to refresh: "Run with --force to refresh all files"
+- Update `initialized` date in project-profile.json

package/.opencode/commands/plan.md

@@ -0,0 +1,96 @@
+---
+description: Generate a detailed technical implementation plan from specifications, including architecture decisions, tech stack, and design patterns
+agent: sdd-planner
+---
+
+**You are a technical architect agent.** Transform requirements into a detailed technical implementation strategy without writing implementation code.
+
+**Skill:** Uses `sdd-planning` skill.
+
+**Output:** `specs/active/$1/plan.md`
+
+---
+
+## Prerequisites
+
+- Must have existing `spec.md` OR `feature-brief.md` in task directory
+
+## Usage
+
+```
+/plan $1
+```
+
+**Examples:**
+```
+/plan user-auth-system
+/plan checkout-flow
+/plan notification-system
+```
+
+---
+
+## Instructions
+
+### Phase 1: Analysis
+
+1. **Read specifications** in order:
+   - `specs/active/$1/spec.md` (preferred)
+   - `specs/active/$1/feature-brief.md` (alternative)
+   - `specs/active/$1/research.md` (if exists)
+
+   **If no spec found:** Prompt user to run `/specify` or `/brief` first.
+
+2. **Extract requirements:** Functional and non-functional requirements, constraints, user stories, acceptance criteria
+
+3. **Analyze codebase:** Use `codebase-memory-mcp` to understand existing patterns, tech stack, conventions, integration points
+
+4. **Identify decisions needed:** Architecture style, data storage, API design, integrations, security
+
+### Phase 2: Plan Preview
+
+**Present plan structure and wait for approval:**
+
+```
+## Technical Plan Preview
+
+**Task ID:** $1
+**Architecture:** [High-level approach]
+**Tech stack:** [Key technologies with rationale]
+**Components:** [Main components and purposes]
+**Data model:** [Key entities]
+**API design:** [Key endpoints]
+
+Ready to generate the full plan?
+```
+
+### Phase 3: Generate Plan
+
+**Create directory if it doesn't exist:** `specs/active/$1/`
+
+**Generate `plan.md`** with: System Architecture (with Mermaid diagram), Technology Stack, Component Design, Data Model, API Contracts, Security Considerations, Performance Strategy, Implementation Phases, Risk Assessment, Open Questions, Next Steps.
+
+**Verify:** Read the file back to confirm it was created correctly.
+
+---
+
+## Output
+
+**End your response with:**
+
+```
+✅ Plan created: `specs/active/$1/plan.md`
+
+**Architecture:** [Brief description]
+**Components:** [Count] main components
+**Phases:** [Count] implementation phases
+
+**Key decisions:**
+- [Decision 1]: [Choice]
+- [Decision 2]: [Choice]
+
+**Next steps:**
+- Review the technical plan
+- Run `/tasks $1` to generate implementation tasks
+- Or run `/implement $1` if tasks are clear
+```

package/.opencode/commands/refine.md

@@ -0,0 +1,115 @@
+---
+description: Refine existing prompts, briefs, or specifications through continued discussion and iteration
+---
+
+**Refinement facilitator** - Help users iterate on existing documentation through conversational exploration, making targeted improvements.
+
+---
+
+## Usage
+
+```
+/refine $1
+```
+
+**Examples:**
+```
+/refine user-auth
+/refine checkout-flow
+/refine notification-system
+```
+
+---
+
+## Instructions
+
+### Phase 1: Analysis (Readonly)
+
+**Step 1: Find refinement targets**
+
+Search for:
+1. `specs/active/$1/feature-brief.md`
+2. `specs/active/$1/spec.md`
+3. `specs/active/$1/plan.md`
+4. `specs/active/$1/tasks.md`
+
+**Step 2: Present what's available**
+
+```
+## Refinement Targets Found
+
+**Task:** $1
+
+**Available documents:**
+| # | Document | Last Updated | Size |
+|---|----------|--------------|------|
+| 1 | feature-brief.md | [date] | [lines] |
+| 2 | spec.md | [date] | [lines] |
+| 3 | plan.md | [date] | [lines] |
+
+**What would you like to refine?**
+1. Feature brief - Requirements and approach
+2. Specification - User stories and acceptance criteria
+3. Technical plan - Architecture and design
+4. Something specific - Tell me what
+```
+
+### Phase 2: Exploration (Conversation)
+
+**Start the refinement conversation** by summarizing the current state and asking what to refine.
+
+Conduct conversational refinement:
+- Ask follow-up questions
+- Track refinement requests
+- Present proposed changes before applying
+
+### Phase 3: Planning (Show Changes)
+
+**Present proposed changes before applying** with before/after diffs, change types (ADD/MODIFY/REMOVE/CLARIFY), and proposed changelog entry.
+
+**Wait for user approval before proceeding.**
+
+### Phase 4: Execution (After Approval)
+
+**Step 1: Apply changes** - Update the document with all approved changes, change labels, updated version number, updated timestamp
+
+**Step 2: Add changelog entry**
+
+**Step 3: Verify changes** - Read the file back to confirm updates applied
+
+### Phase 5: Completion
+
+**CHECKPOINT: Refinement Complete (REQUIRED)**
+
+Before final output, verify:
+- [ ] All requested changes applied
+- [ ] Original context preserved
+- [ ] Changelog updated
+- [ ] Version incremented
+- [ ] File verified
+
+---
+
+## Output
+
+```
+✅ Refinement complete: `specs/active/$1/[file]`
+
+**Changes applied:**
+- [ADD] [Count] new items
+- [MODIFY] [Count] existing items
+- [REMOVE] [Count] items
+- [CLARIFY] [Count] items
+
+**Version:** [old] → [new]
+
+**Key changes:**
+1. [Change 1 summary]
+2. [Change 2 summary]
+
+**Next steps:**
+- Review the updated document
+- Make more refinements: `/refine $1`
+- Update related docs if needed
+- Proceed with implementation: `/implement $1`
+```