@tudeorangbiasa/sdd-multiagent-opencode 0.1.4 → 0.2.1

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

@@ -1,99 +0,0 @@
----
-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

@@ -1,149 +0,0 @@
----
-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

@@ -1,141 +0,0 @@
----
-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

@@ -1,96 +0,0 @@
----
-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

@@ -1,115 +0,0 @@
----
-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`
-```