sdlc-subagents 0.1.0 → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Roy Zalta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,19 +1,72 @@
-# sdlc-subagents
+<div align="center">
 
-Configure [OpenCode](https://opencode.ai) as an orchestrator of multiple coding agent CLIs.
+# SDLC Sub-Agents
 
-Run one command and your OpenCode agent learns how to delegate tasks to the right sub-agent CLI based on the task type.
+### Turn OpenCode into a multi-agent orchestrator
 
-## Supported Sub-Agents
+**One command. Six coding agents. Zero config.**
 
-| Agent | Command | Best For |
-|-------|---------|----------|
-| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | `gemini` | Context engineering, large codebase analysis, research |
-| [GitHub Copilot CLI](https://githubnext.com/projects/copilot-cli) | `copilot` | PR creation, issue management, GitHub workflows |
-| [Claude Code](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/overview) | `claude` | Complex refactoring, architecture changes, debugging |
-| [Aider](https://aider.chat) | `aider` | Pair programming, auto-commits, any LLM provider |
-| [Kimi CLI](https://github.com/MoonshotAI/kimi-cli) | `kimi` | Front-end development, UI components, long-context |
-| [Cursor CLI](https://cursor.sh) | `agent` | IDE-grade coding, cloud handoff, rapid prototyping |
+[![npm version](https://img.shields.io/npm/v/sdlc-subagents?style=flat-square&color=CB3837&logo=npm&logoColor=white)](https://www.npmjs.com/package/sdlc-subagents)
+[![license](https://img.shields.io/npm/l/sdlc-subagents?style=flat-square&color=blue)](./LICENSE)
+[![node](https://img.shields.io/node/v/sdlc-subagents?style=flat-square&color=417E38&logo=nodedotjs&logoColor=white)](https://nodejs.org)
+[![zero deps](https://img.shields.io/badge/dependencies-0-brightgreen?style=flat-square)](./package.json)
+
+<br />
+
+<img src="https://opencode.ai/favicon.ico" width="28" alt="OpenCode" />&nbsp;&nbsp;Built for [**OpenCode**](https://opencode.ai) — the open-source AI coding agent for the terminal
+
+<br />
+
+```
+npx sdlc-subagents
+```
+
+<br />
+
+[Quick Start](#-quick-start) · [Supported Agents](#-supported-agents) · [How It Works](#-how-it-works) · [Usage](#-usage-in-opencode) · [Install CLIs](#-installing-the-sub-agent-clis)
+
+</div>
+
+---
+
+## The Problem
+
+You have access to multiple AI coding agents — Gemini, Claude, Copilot, Aider, Kimi, Cursor — each with different strengths. But switching between them is manual, context is lost, and there's no unified workflow.
+
+## The Solution
+
+`sdlc-subagents` configures [OpenCode](https://opencode.ai) as a **meta-orchestrator** that knows when and how to delegate tasks to the right sub-agent CLI. It generates [Agent Skills](https://opencode.ai/docs/skills/) that teach OpenCode the strengths, invocation patterns, and routing logic for each agent.
+
+```
+                          ┌─────────────────┐
+                          │    OpenCode      │
+                          │  (orchestrator)  │
+                          └────────┬────────┘
+                                   │
+             ┌──────────┬──────────┼──────────┬──────────┬──────────┐
+             ▼          ▼          ▼          ▼          ▼          ▼
+         ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐
+         │ Gemini │ │Copilot │ │ Claude │ │ Aider  │ │  Kimi  │ │ Cursor │
+         │  CLI   │ │  CLI   │ │  Code  │ │        │ │  CLI   │ │  CLI   │
+         └────────┘ └────────┘ └────────┘ └────────┘ └────────┘ └────────┘
+          Research    GitHub    Refactor     Pair      Front-end   IDE-grade
+          & Context  Workflows  & Debug    Programming  & UI      Prototyping
+```
+
+---
+
+## Supported Agents
+
+| Agent | CLI | Best For | Install |
+|:------|:----|:---------|:--------|
+| <img src="https://www.gstatic.com/lamda/images/gemini_favicon_f069958c85030456e93de685481c559f160ea06b.png" width="16" />&nbsp; [Gemini CLI](https://github.com/google-gemini/gemini-cli) | `gemini` | Large codebase analysis, research, documentation | `npm i -g @google/gemini-cli` |
+| <img src="https://github.githubassets.com/favicons/favicon-dark.svg" width="16" />&nbsp; [GitHub Copilot CLI](https://githubnext.com/projects/copilot-cli) | `copilot` | PR creation, issue management, GitHub workflows | `npm i -g @github/copilot` |
+| <img src="https://mintlify.s3.us-west-1.amazonaws.com/anthropic/logo/light.svg" width="16" />&nbsp; [Claude Code](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/overview) | `claude` | Complex refactoring, architecture changes, debugging | `npm i -g @anthropic-ai/claude-code` |
+| <img src="https://aider.chat/assets/icons/favicon-32x32.png" width="16" />&nbsp; [Aider](https://aider.chat) | `aider` | Pair programming, auto-commits, any LLM provider | `pipx install aider-chat` |
+| <img src="https://raw.githubusercontent.com/nicepkg/gpt-runner/main/docs/public/logo.svg" width="16" />&nbsp; [Kimi CLI](https://github.com/MoonshotAI/kimi-cli) | `kimi` | Front-end development, UI components, long-context | `uv tool install --python 3.13 kimi-cli` |
+| <img src="https://cursor.sh/favicon.ico" width="16" />&nbsp; [Cursor CLI](https://cursor.sh) | `agent` | IDE-grade coding, cloud handoff, rapid prototyping | `curl https://cursor.sh/cli -fsS \| bash` |
+
+---
 
 ## Quick Start
 
@@ -21,54 +74,81 @@ Run one command and your OpenCode agent learns how to delegate tasks to the righ
 npx sdlc-subagents
 ```
 
-That's it. The tool will:
+That's it. No flags, no wizard, no config files to write. The tool will:
 
 1. **Detect** which coding agent CLIs are installed on your system
-2. **Generate** OpenCode skill files (`.agents/skills/*/SKILL.md`) for each agent
-3. **Configure** `opencode.json` with permissions and `/delegate` commands
+2. **Generate** OpenCode skill files for all 6 agents (even uninstalled ones — install later)
+3. **Create** `opencode.json` with permissions and `/delegate` custom commands
+4. **Merge** safely into existing config (idempotent — re-run anytime)
 
-## What Gets Created
+### What gets created
 
 ```
 your-project/
-  .agents/
-    skills/
-      sdlc-orchestrator/SKILL.md    # Master routing skill
-      gemini-cli/SKILL.md           # Gemini CLI delegation
-      copilot-cli/SKILL.md          # GitHub Copilot delegation
-      claude-code/SKILL.md          # Claude Code delegation
-      aider/SKILL.md                # Aider delegation
-      kimi-cli/SKILL.md             # Kimi CLI delegation
-      cursor-cli/SKILL.md           # Cursor CLI delegation
-  opencode.json                     # Permissions + custom commands
+├── .agents/
+│   └── skills/
+│       ├── sdlc-orchestrator/SKILL.md   ← Master routing logic
+│       ├── gemini-cli/SKILL.md          ← Gemini delegation patterns
+│       ├── copilot-cli/SKILL.md         ← Copilot delegation patterns
+│       ├── claude-code/SKILL.md         ← Claude delegation patterns
+│       ├── aider/SKILL.md               ← Aider delegation patterns
+│       ├── kimi-cli/SKILL.md            ← Kimi delegation patterns
+│       └── cursor-cli/SKILL.md          ← Cursor delegation patterns
+└── opencode.json                        ← Permissions + /delegate commands
 ```
 
-## Usage in OpenCode
+---
 
-After running `npx sdlc-subagents`, open your project with OpenCode. The agent will automatically discover the skills.
+## How It Works
+
+Each generated skill file teaches OpenCode:
+
+| Section | What it contains |
+|:--------|:-----------------|
+| **When to delegate** | Task types the agent excels at |
+| **How to invoke** | Exact CLI commands for non-interactive use |
+| **Delegation patterns** | Bash patterns for capturing output |
+| **Important notes** | Auth requirements, flags, gotchas |
+
+The master **`sdlc-orchestrator`** skill provides a routing table that maps task types to the best agent:
+
+| Task Type | Routed To |
+|:----------|:----------|
+| Large codebase analysis, research, documentation | Gemini CLI |
+| GitHub PRs, issues, code review, repo management | Copilot CLI |
+| Complex refactoring, architecture changes, debugging | Claude Code |
+| Incremental changes with git commits, multi-model | Aider |
+| Front-end development, UI components, styling | Kimi CLI |
+| IDE-grade coding, cloud handoff, rapid prototyping | Cursor CLI |
+
+---
 
-### Auto-routing
+## Usage in OpenCode
+
+After scaffolding, open your project with OpenCode. The skills are discovered automatically.
 
-Ask OpenCode to delegate and it will pick the best agent:
+### Auto-routing — let OpenCode choose
 
 ```
 /delegate Analyze the entire codebase and generate API documentation
 ```
 
-OpenCode routes this to Gemini CLI (large context + research).
+> OpenCode reads the orchestrator skill, identifies this as a research/documentation task, and routes to **Gemini CLI**.
 
 ### Force a specific agent
 
 ```
-/delegate-claude-code Refactor the auth module to use strategy pattern
-/delegate-copilot-cli Create a PR for the current branch changes
-/delegate-aider Add input validation to all API endpoints
-/delegate-kimi-cli Build a responsive dashboard with Tailwind
+/delegate-claude-code   Refactor the auth module to use strategy pattern
+/delegate-copilot-cli   Create a PR for the current branch changes
+/delegate-aider         Add input validation to all API endpoints
+/delegate-kimi-cli      Build a responsive dashboard with Tailwind
+/delegate-gemini-cli    Explain how the payment system works across all services
+/delegate-cursor-cli    Prototype a new CLI tool for data migration
 ```
 
-### Natural language
+### Natural language — no commands needed
 
-You don't even need the commands. Just describe your task and OpenCode will load the orchestrator skill and route to the right agent:
+Just describe your task. OpenCode loads the orchestrator skill and routes automatically:
 
 ```
 > Use Gemini to research how the payment system works across all microservices
@@ -76,49 +156,72 @@ You don't even need the commands. Just describe your task and OpenCode will load
 > Ask Aider to add tests for the auth module, commit each test separately
 ```
 
-## How It Works
+### Multi-agent workflows
 
-The tool generates [OpenCode Agent Skills](https://opencode.ai/docs/skills/) - markdown files that teach OpenCode when and how to delegate to each sub-agent CLI.
+Chain agents for complex SDLC workflows:
 
-Each skill contains:
-- **When to delegate**: Task types the agent excels at
-- **How to invoke**: Exact CLI commands for non-interactive use
-- **Delegation patterns**: Copy-paste bash patterns for capturing output
-- **Important notes**: Auth requirements, flags, gotchas
+```
+1. /delegate-gemini-cli   Analyze the requirements and existing auth code
+2. /delegate-claude-code  Implement the new OAuth2 flow based on Gemini's analysis
+3. /delegate-kimi-cli     Build the login UI components
+4. /delegate-aider        Add integration tests, commit each one
+5. /delegate-copilot-cli  Create a PR with a detailed description
+```
 
-The master `sdlc-orchestrator` skill provides a routing table that maps task types to the recommended agent.
+---
 
 ## Re-running
 
-Running `npx sdlc-subagents` again is safe. It will:
-- Update skill files with latest templates
-- Merge new config into existing `opencode.json` (preserves your customizations)
-- Re-detect installed CLIs
+```bash
+npx sdlc-subagents
+```
+
+Safe to run multiple times. It will:
+
+- Update skill files with the latest templates
+- Merge new config into existing `opencode.json` without overwriting your customizations
+- Re-detect installed CLIs and update status
+
+---
 
 ## Installing the Sub-Agent CLIs
 
-The tool works even if not all CLIs are installed - it scaffolds skills for all agents so you can install them later. Install commands:
+Skills are generated for **all agents** regardless of installation status. Install any agent when you're ready:
 
 ```bash
-# Gemini CLI
+# Gemini CLI — Google's 1M token context agent
 npm install -g @google/gemini-cli
 
-# GitHub Copilot CLI
+# GitHub Copilot CLI — GitHub-native workflow agent
 npm install -g @github/copilot
 
-# Claude Code
+# Claude Code — Anthropic's deep reasoning agent
 npm install -g @anthropic-ai/claude-code
 
-# Aider
+# Aider — Model-agnostic pair programmer
 pipx install aider-chat
 
-# Kimi CLI
+# Kimi CLI — Moonshot's long-context agent
 uv tool install --python 3.13 kimi-cli
 
-# Cursor CLI
+# Cursor CLI — IDE-grade terminal agent
 curl https://cursor.sh/cli -fsS | bash
 ```
 
+---
+
+## Requirements
+
+- **Node.js** >= 18
+- **OpenCode** — [install from opencode.ai](https://opencode.ai)
+- At least one sub-agent CLI installed (or install later)
+
+---
+
+## Contributing
+
+Contributions are welcome! If you'd like to add support for a new coding agent CLI or improve the delegation skills, please open an issue or PR.
+
 ## License
 
-MIT
+[MIT](./LICENSE) — Roy Zalta

package/commands/commit.md

@@ -0,0 +1,7 @@
+Create a new commit for all of our uncommitted changes
+run git status && git diff HEAD && git status --porcelain to see what files are uncommitted
+add the untracked and changed files
+
+Add an atomic commit message with an appropriate message
+
+add a tag such as "feat", "fix", "docs", etc. that reflects our work

package/commands/create-prd.md

@@ -0,0 +1,151 @@
+---
+description: Create a Product Requirements Document from conversation
+argument-hint: [output-filename]
+---
+
+# Create PRD: Generate Product Requirements Document
+
+## Overview
+
+Generate a comprehensive Product Requirements Document (PRD) based on the current conversation context and requirements discussed. Use the structure and sections defined below to create a thorough, professional PRD.
+
+## Output File
+
+Write the PRD to: `$ARGUMENTS` (default: `PRD.md`)
+
+## PRD Structure
+
+Create a well-structured PRD with the following sections. Adapt depth and detail based on available information:
+
+### Required Sections
+
+**1. Executive Summary**
+- Concise product overview (2-3 paragraphs)
+- Core value proposition
+- MVP goal statement
+
+**2. Mission**
+- Product mission statement
+- Core principles (3-5 key principles)
+
+**3. Target Users**
+- Primary user personas
+- Technical comfort level
+- Key user needs and pain points
+
+**4. MVP Scope**
+- **In Scope:** Core functionality for MVP (use ✅ checkboxes)
+- **Out of Scope:** Features deferred to future phases (use ❌ checkboxes)
+- Group by categories (Core Functionality, Technical, Integration, Deployment)
+
+**5. User Stories**
+- Primary user stories (5-8 stories) in format: "As a [user], I want to [action], so that [benefit]"
+- Include concrete examples for each story
+- Add technical user stories if relevant
+
+**6. Core Architecture & Patterns**
+- High-level architecture approach
+- Directory structure (if applicable)
+- Key design patterns and principles
+- Technology-specific patterns
+
+**7. Tools/Features**
+- Detailed feature specifications
+- If building an agent: Tool designs with purpose, operations, and key features
+- If building an app: Core feature breakdown
+
+**8. Technology Stack**
+- Backend/Frontend technologies with versions
+- Dependencies and libraries
+- Optional dependencies
+- Third-party integrations
+
+**9. Security & Configuration**
+- Authentication/authorization approach
+- Configuration management (environment variables, settings)
+- Security scope (in-scope and out-of-scope)
+- Deployment considerations
+
+**10. API Specification** (if applicable)
+- Endpoint definitions
+- Request/response formats
+- Authentication requirements
+- Example payloads
+
+**11. Success Criteria**
+- MVP success definition
+- Functional requirements (use ✅ checkboxes)
+- Quality indicators
+- User experience goals
+
+**12. Implementation Phases**
+- Break down into 3-4 phases
+- Each phase includes: Goal, Deliverables (✅ checkboxes), Validation criteria
+- Realistic timeline estimates
+
+**13. Future Considerations**
+- Post-MVP enhancements
+- Integration opportunities
+- Advanced features for later phases
+
+**14. Risks & Mitigations**
+- 3-5 key risks with specific mitigation strategies
+
+**15. Appendix** (if applicable)
+- Related documents
+- Key dependencies with links
+- Repository/project structure
+
+## Instructions
+
+### 1. Extract Requirements
+- Review the entire conversation history
+- Identify explicit requirements and implicit needs
+- Note technical constraints and preferences
+- Capture user goals and success criteria
+
+### 2. Synthesize Information
+- Organize requirements into appropriate sections
+- Fill in reasonable assumptions where details are missing
+- Maintain consistency across sections
+- Ensure technical feasibility
+
+### 3. Write the PRD
+- Use clear, professional language
+- Include concrete examples and specifics
+- Use markdown formatting (headings, lists, code blocks, checkboxes)
+- Add code snippets for technical sections where helpful
+- Keep Executive Summary concise but comprehensive
+
+### 4. Quality Checks
+- ✅ All required sections present
+- ✅ User stories have clear benefits
+- ✅ MVP scope is realistic and well-defined
+- ✅ Technology choices are justified
+- ✅ Implementation phases are actionable
+- ✅ Success criteria are measurable
+- ✅ Consistent terminology throughout
+
+## Style Guidelines
+
+- **Tone:** Professional, clear, action-oriented
+- **Format:** Use markdown extensively (headings, lists, code blocks, tables)
+- **Checkboxes:** Use ✅ for in-scope items, ❌ for out-of-scope
+- **Specificity:** Prefer concrete examples over abstract descriptions
+- **Length:** Comprehensive but scannable (typically 30-60 sections worth of content)
+
+## Output Confirmation
+
+After creating the PRD:
+1. Confirm the file path where it was written
+2. Provide a brief summary of the PRD contents
+3. Highlight any assumptions made due to missing information
+4. Suggest next steps (e.g., review, refinement, planning)
+
+## Notes
+
+- If critical information is missing, ask clarifying questions before generating
+- Adapt section depth based on available details
+- For highly technical products, emphasize architecture and technical stack
+- For user-facing products, emphasize user stories and experience
+- This command contains the complete PRD template structure - no external references needed

package/commands/create-rules.md

@@ -0,0 +1,156 @@
+---
+description: Create global rules (CLAUDE.md) from codebase analysis
+---
+
+# Create Global Rules
+
+Generate a CLAUDE.md file by analyzing the codebase and extracting patterns.
+
+---
+
+## Objective
+
+Create project-specific global rules that give Claude context about:
+- What this project is
+- Technologies used
+- How the code is organized
+- Patterns and conventions to follow
+- How to build, test, and validate
+
+---
+
+## Phase 1: DISCOVER
+
+### Identify Project Type
+
+First, determine what kind of project this is:
+
+| Type | Indicators |
+|------|------------|
+| Web App (Full-stack) | Separate client/server dirs, API routes |
+| Web App (Frontend) | React/Vue/Svelte, no server code |
+| API/Backend | Express/Fastify/etc, no frontend |
+| Library/Package | `main`/`exports` in package.json, publishable |
+| CLI Tool | `bin` in package.json, command-line interface |
+| Monorepo | Multiple packages, workspaces config |
+| Script/Automation | Standalone scripts, task-focused |
+
+### Analyze Configuration
+
+Look at root configuration files:
+
+```
+package.json       → dependencies, scripts, type
+tsconfig.json      → TypeScript settings
+vite.config.*      → Build tool
+*.config.js/ts     → Various tool configs
+```
+
+### Map Directory Structure
+
+Explore the codebase to understand organization:
+- Where does source code live?
+- Where are tests?
+- Any shared code?
+- Configuration locations?
+
+---
+
+## Phase 2: ANALYZE
+
+### Extract Tech Stack
+
+From package.json and config files, identify:
+- Runtime/Language (Node, Bun, Deno, browser)
+- Framework(s)
+- Database (if any)
+- Testing tools
+- Build tools
+- Linting/formatting
+
+### Identify Patterns
+
+Study existing code for:
+- **Naming**: How are files, functions, classes named?
+- **Structure**: How is code organized within files?
+- **Errors**: How are errors created and handled?
+- **Types**: How are types/interfaces defined?
+- **Tests**: How are tests structured?
+
+### Find Key Files
+
+Identify files that are important to understand:
+- Entry points
+- Configuration
+- Core business logic
+- Shared utilities
+- Type definitions
+
+---
+
+## Phase 3: GENERATE
+
+### Create CLAUDE.md
+
+Use the template at `.agents/CLAUDE-template.md` as a starting point.
+
+**Output path**: `CLAUDE.md` (project root)
+
+**Adapt to the project:**
+- Remove sections that don't apply
+- Add sections specific to this project type
+- Keep it concise - focus on what's useful
+
+**Key sections to include:**
+
+1. **Project Overview** - What is this and what does it do?
+2. **Tech Stack** - What technologies are used?
+3. **Commands** - How to dev, build, test, lint?
+4. **Structure** - How is the code organized?
+5. **Patterns** - What conventions should be followed?
+6. **Key Files** - What files are important to know?
+
+**Optional sections (add if relevant):**
+- Architecture (for complex apps)
+- API endpoints (for backends)
+- Component patterns (for frontends)
+- Database patterns (if using a DB)
+- On-demand context references
+
+---
+
+## Phase 4: OUTPUT
+
+```markdown
+## Global Rules Created
+
+**File**: `CLAUDE.md`
+
+### Project Type
+
+{Detected project type}
+
+### Tech Stack Summary
+
+{Key technologies detected}
+
+### Structure
+
+{Brief structure overview}
+
+### Next Steps
+
+1. Review the generated `CLAUDE.md`
+2. Add any project-specific notes
+3. Remove any sections that don't apply
+4. Optionally create reference docs in `.agents/reference/`
+```
+
+---
+
+## Tips
+
+- Keep CLAUDE.md focused and scannable
+- Don't duplicate information that's in other docs (link instead)
+- Focus on patterns and conventions, not exhaustive documentation
+- Update it as the project evolves

package/commands/e2e-test.md

@@ -0,0 +1,13 @@
+---
+description: Run comprehensive end-to-end testing using agent-browser
+---
+
+# E2E Test: Full Application Testing
+
+## Objective
+
+Run comprehensive end-to-end testing of the application. This launches parallel research agents, then systematically tests every user journey using the browser, takes screenshots, validates database records, and fixes any issues found.
+
+## Instructions
+
+Load the `e2e-test` skill and follow its instructions exactly, starting from the Pre-flight Check through to the final Report.