specweave 0.4.1 → 0.6.3

package/plugins/specweave/skills/plugin-detector/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: plugin-detector
+description: Detects when SpecWeave plugins are needed and guides installation. Activates for GitHub sync, Kubernetes deployment, Figma integration, ML pipelines, payment processing, React/frontend development, backend APIs, and other domain-specific features requiring plugins.
+---
+
+# SpecWeave Plugin Detector
+
+## What I Do
+
+I detect when you need a SpecWeave plugin that isn't installed yet, and guide you through enabling it with clear, copy-pasteable commands.
+
+## When I Activate
+
+When you mention capabilities that require specific SpecWeave plugins:
+
+### External Integrations
+- **GitHub**: "sync to GitHub", "create issue", "GitHub integration", "export to GitHub" → needs `specweave-github`
+- **Jira**: "sync to Jira", "create Jira ticket", "Jira integration" → needs `specweave-jira`
+- **Azure DevOps**: "sync to ADO", "Azure DevOps", "work items" → needs `specweave-ado`
+
+### Tech Stacks
+- **Kubernetes**: "deploy to K8s", "Helm chart", "kubectl", "K8s manifests" → needs `specweave-kubernetes`
+- **Frontend**: "React component", "Next.js", "Vue", "design system" → needs `specweave-frontend`
+- **Backend**: "Express API", "FastAPI", "NestJS", ".NET backend" → needs `specweave-backend`
+
+### Domain Expertise
+- **ML/AI**: "train model", "MLflow", "TensorFlow", "PyTorch", "ML pipeline" → needs `specweave-ml`
+- **Payments**: "Stripe", "PayPal", "subscription billing", "PCI compliance" → needs `specweave-payments`
+- **Testing**: "Playwright tests", "E2E testing", "visual regression" → needs `specweave-testing`
+- **Figma**: "Figma design", "design tokens", "import from Figma" → needs `specweave-figma`
+- **Infrastructure**: "Hetzner", "Prometheus", "Grafana", "monitoring" → needs `specweave-infrastructure`
+- **Diagrams**: "C4 diagram", "architecture diagram", "Mermaid", "sequence diagram" → needs `specweave-diagrams`
+
+## How I Help
+
+1. **Detect missing plugin**: Check if the required plugin is installed
+2. **Provide installation command**: Give exact `/plugin install` command
+3. **Explain benefits**: List what the plugin provides (skills, agents, commands)
+4. **Continue once enabled**: Resume your task with plugin features available
+
+## Plugin Detection Logic
+
+I check for plugin installation by:
+- Looking for plugin-specific commands (e.g., `/specweave-github:sync`)
+- Checking if plugin files exist in `.claude/` directory
+- Detecting absence of expected skills/agents
+
+**If a plugin is missing**, I provide:
+```
+📦 Plugin Required: specweave-{name}
+
+To enable this plugin:
+1. Run: /plugin install specweave-{name}@specweave
+2. Restart this conversation (or continue - plugin will load)
+
+This plugin provides:
+✅ {List of key features}
+✅ {Specialized agents}
+✅ {Slash commands}
+
+Would you like me to guide you through the installation?
+```
+
+## Example Flows
+
+### Example 1: GitHub Integration
+
+**User**: "Let's sync this increment to GitHub Issues"
+
+**Me**:
+```
+📦 Plugin Required: specweave-github
+
+I notice you want GitHub integration, but the `specweave-github` plugin isn't installed yet.
+
+To enable GitHub sync features:
+
+1. Run this command:
+   /plugin install specweave-github@specweave
+
+2. Once installed, you'll have access to:
+   ✅ Bidirectional increment ↔ GitHub Issue sync
+   ✅ Task-level progress tracking via issue comments
+   ✅ Automatic issue creation from specs
+   ✅ GitHub CLI integration (via `gh` command)
+   ✅ Commands: /specweave:github:sync, /specweave:github:create-issue, /specweave:github:status
+
+Would you like me to guide you through the installation, or would you prefer to continue without GitHub sync?
+```
+
+### Example 2: Kubernetes Deployment
+
+**User**: "Deploy this to Kubernetes with Helm"
+
+**Me**:
+```
+📦 Plugin Required: specweave-kubernetes
+
+For Kubernetes deployment features, you'll need the `specweave-kubernetes` plugin.
+
+To enable:
+
+1. Run: /plugin install specweave-kubernetes@specweave
+
+2. This plugin provides:
+   ✅ K8s manifest generation (deployments, services, configmaps)
+   ✅ Helm chart scaffolding and templates
+   ✅ GitOps workflow with ArgoCD/Flux
+   ✅ Security policies and RBAC patterns
+   ✅ Skills: k8s-manifest-generator, helm-chart-scaffolding, gitops-workflow
+
+Alternatively, I can help you create basic K8s manifests manually without the plugin. Which would you prefer?
+```
+
+### Example 3: Already Installed
+
+**User**: "Create a C4 diagram for this architecture"
+
+**Me**:
+```
+✅ Plugin Available: specweave-diagrams
+
+Great! The diagrams plugin is installed. I can create C4 diagrams for you.
+
+I'll use the diagrams-architect agent to:
+1. Analyze your architecture from specs
+2. Generate Mermaid C4 diagram code
+3. Export to both .mmd and .svg formats
+4. Place in .specweave/docs/internal/architecture/diagrams/
+
+Let me start by examining your architecture specifications...
+```
+
+## Available SpecWeave Plugins
+
+### Core (Always Available)
+- `specweave` - Framework essentials (increment lifecycle, PM/Architect/Tech Lead agents)
+
+### Integrations
+- `specweave-github` - GitHub Issues sync
+- `specweave-jira` - Jira integration
+- `specweave-ado` - Azure DevOps integration
+
+### Tech Stacks
+- `specweave-frontend` - React, Next.js, Vue, design systems
+- `specweave-backend` - Node.js, Python, .NET APIs
+- `specweave-kubernetes` - K8s deployment, Helm, GitOps
+- `specweave-infrastructure` - Cloud infra, monitoring, Hetzner
+
+### Domain Expertise
+- `specweave-ml` - ML pipelines, training, deployment
+- `specweave-payments` - Stripe, PayPal, PCI compliance
+- `specweave-testing` - Playwright E2E, visual regression
+- `specweave-figma` - Design system integration
+- `specweave-diagrams` - C4, Mermaid, architecture diagrams
+- `specweave-docs` - Docusaurus generation
+
+### Utilities
+- `specweave-tooling` - Skill creation, routing
+- `specweave-cost-optimizer` - Cloud cost comparison
+- `specweave-alternatives` - Framework comparison
+
+## Installation Commands Reference
+
+**Quick Install (Most Common)**:
+```bash
+# GitHub integration
+/plugin install specweave-github@specweave
+
+# Frontend development
+/plugin install specweave-frontend@specweave
+
+# Backend APIs
+/plugin install specweave-backend@specweave
+
+# Kubernetes deployment
+/plugin install specweave-kubernetes@specweave
+
+# ML/AI workflows
+/plugin install specweave-ml@specweave
+
+# Architecture diagrams
+/plugin install specweave-diagrams@specweave
+```
+
+**View All Available**:
+```bash
+/plugin marketplace list specweave
+```
+
+## Best Practices
+
+1. **Be Proactive**: Detect missing plugins early in the conversation
+2. **Offer Alternatives**: If a plugin isn't installed, suggest manual approaches
+3. **Don't Block**: Never refuse to help—offer to continue without the plugin
+4. **Clear Instructions**: Always provide exact copy-pasteable commands
+5. **Explain Benefits**: Help users understand why the plugin is valuable
+
+## Integration with Other Skills
+
+This skill works alongside:
+- **project-kickstarter**: Suggests plugins during new project setup
+- **increment-planner**: Recommends plugins based on increment requirements
+- **specweave-detector**: Coordinates with workflow detection
+
+## Notes
+
+- This skill is **non-blocking** - I always offer to continue without plugins
+- Plugins are **opt-in** - users choose what to install
+- Installation is **instant** - plugins activate immediately
+- All plugins follow **Claude Code's native plugin architecture**

package/{src → plugins/specweave}/skills/project-kickstarter/SKILL.md

@@ -105,7 +105,7 @@ SpecWeave works best when we start with a proper increment plan. I'm going to:
 
 Let's start: [Ask 1 clarifying question if needed, otherwise proceed]"
 
-[Automatically invoke /specweave.inc or spec-driven-brainstorming]
+[Automatically invoke /specweave:inc or spec-driven-brainstorming]
 ```
 
 **Medium Confidence:**
@@ -125,7 +125,7 @@ Don't activate. Let other skills handle it.
 
 Based on clarity of requirements:
 
-- **Clear requirements** (detailed features, tech stack known) → `/specweave.inc` directly
+- **Clear requirements** (detailed features, tech stack known) → `/specweave:inc` directly
 - **Unclear requirements** (vague features, tech stack uncertain) → `spec-driven-brainstorming` first
 
 ## Examples
@@ -177,9 +177,9 @@ I'm going to use SpecWeave's increment planning process to:
 
 Since you've provided the tech stack (.NET 8 + Next.js 14+), I'll structure this as a full-stack increment.
 
-Creating increment now with /specweave.inc...
+Creating increment now with /specweave:inc...
 
-[Invokes /specweave.inc "RosterSync team scheduling SaaS"]
+[Invokes /specweave:inc "RosterSync team scheduling SaaS"]
 ```
 
 ### Example 2: Clarify Then Route (Medium Confidence)
@@ -252,12 +252,12 @@ User message → specweave-detector (checks .specweave/ exists)
                     ↓ YES
          [Calculate confidence with SpecWeave context bonus]
                     ↓
-         [Route to /specweave.inc or spec-driven-brainstorming]
+         [Route to /specweave:inc or spec-driven-brainstorming]
 ```
 
 **Calls:**
 - `specweave-detector` - Checks if .specweave/ directory exists (SpecWeave context)
-- `/specweave.inc` - For clear requirements (high confidence)
+- `/specweave:inc` - For clear requirements (high confidence)
 - `spec-driven-brainstorming` - For unclear requirements (medium confidence)
 - `increment-planner` - Directly if enough detail provided
 
@@ -282,7 +282,7 @@ Users can override auto-routing with explicit instructions:
 ## Success Criteria
 
 - ✅ Users with product descriptions are automatically guided to increment planning
-- ✅ No "I forgot to use /specweave.inc" scenarios
+- ✅ No "I forgot to use /specweave:inc" scenarios
 - ✅ Confidence >80% routes immediately (no friction)
 - ✅ Confidence 50-80% clarifies then routes (1-2 questions max)
 - ✅ Confidence <50% doesn't activate (avoids false positives)

package/plugins/specweave/skills/rfc-generator/SKILL.md

@@ -0,0 +1,369 @@
+---
+name: rfc-generator
+description: Generates comprehensive RFCs (spec.md, plan.md, tasks.md, tests.md) for SpecWeave increments using proven templates and flexible structure. Activates when users create new increments, plan features, or need structured documentation. Keywords: RFC, specification, plan, tasks, tests, increment planning, feature planning, requirements.
+---
+
+# RFC Generator - Flexible Increment Documentation
+
+**Purpose**: Automatically generate comprehensive RFC documentation (spec.md, plan.md, tasks.md, tests.md) for SpecWeave increments using proven templates and flexible, context-aware structure.
+
+**When to Use**:
+- Creating new increments (`/specweave:inc`)
+- Planning features or products
+- Generating structured documentation
+- Converting ideas into actionable specs
+
+**Based On**: FlexibleRFCGenerator (V2) - context-aware, non-rigid templates
+
+---
+
+## How RFC Generator Works
+
+### 1. Flexible Spec Generation (spec.md)
+
+**Adapts to Context**:
+- **New Product**: Full PRD with market analysis, user personas, competitive landscape
+- **Feature Addition**: Focused user stories, acceptance criteria, integration points
+- **Bug Fix**: Problem statement, root cause, solution, impact analysis
+- **Refactoring**: Current state, proposed changes, benefits, migration plan
+
+**Core Sections** (Always Present):
+```markdown
+# Product Specification: [Increment Name]
+
+**Increment**: [ID]
+**Title**: [Title]
+**Status**: Planning
+**Priority**: [P0-P3]
+**Created**: [Date]
+
+## Executive Summary
+[1-2 paragraph overview]
+
+## Problem Statement
+### Current State
+### User Pain Points
+### Target Audience
+
+## User Stories & Acceptance Criteria
+### US-001: [Title]
+**As a** [user type]
+**I want** [goal]
+**So that** [benefit]
+
+**Acceptance Criteria**:
+- ✅ [Criterion 1]
+- ✅ [Criterion 2]
+
+## Success Metrics
+[How we'll measure success]
+
+## Non-Goals (Out of Scope)
+[What we're NOT doing in this increment]
+```
+
+**Flexible Sections** (Context-Dependent):
+- **Competitive Analysis** (if new product)
+- **Technical Requirements** (if complex feature)
+- **API Design** (if backend API)
+- **UI/UX Requirements** (if frontend)
+- **Security Considerations** (if auth/data)
+- **Migration Plan** (if breaking change)
+
+### 2. Technical Plan Generation (plan.md)
+
+**Adapts to Complexity**:
+- **Simple Feature**: Component list, data flow, implementation steps
+- **Complex System**: Full architecture, C4 diagrams, sequence diagrams, ER diagrams
+- **Infrastructure**: Deployment architecture, scaling strategy, monitoring
+
+**Core Sections**:
+```markdown
+# Technical Plan: [Increment Name]
+
+## Architecture Overview
+[System design, components, interactions]
+
+## Component Architecture
+### Component 1
+[Purpose, responsibilities, interfaces]
+
+## Data Models
+[Entities, relationships, schemas]
+
+## Implementation Strategy
+### Phase 1: [Name]
+### Phase 2: [Name]
+
+## Testing Strategy
+[Unit, integration, E2E approach]
+
+## Deployment Plan
+[How we'll roll this out]
+
+## Risks & Mitigations
+```
+
+### 3. Task Breakdown Generation (tasks.md)
+
+**Smart Task Creation**:
+```markdown
+# Implementation Tasks: [Increment Name]
+
+## Task Overview
+**Total Tasks**: [N]
+**Estimated Duration**: [X weeks]
+**Priority**: [P0]
+
+---
+
+## Phase 1: Foundation (Week 1) - X tasks
+
+### T-001: [Task Title]
+**Priority**: P0
+**Estimate**: [X hours]
+**Status**: pending
+
+**Description**:
+[What needs to be done]
+
+**Files to Create/Modify**:
+- `path/to/file.ts`
+
+**Implementation**:
+```[language]
+[Code example or approach]
+```
+
+**Acceptance Criteria**:
+- ✅ [Criterion 1]
+- ✅ [Criterion 2]
+
+---
+
+[Repeat for all tasks]
+
+## Task Dependencies
+[Dependency graph if complex]
+```
+
+### 4. Test Strategy Generation (tests.md)
+
+**Comprehensive Test Coverage**:
+```markdown
+# Test Strategy: [Increment Name]
+
+## Test Overview
+**Total Test Cases**: [N]
+**Test Levels**: [Unit, Integration, E2E, Performance]
+**Coverage Target**: 80%+ overall, 90%+ critical
+
+---
+
+## Unit Tests (X test cases)
+
+### TC-001: [Test Name]
+```[language]
+describe('[Component]', () => {
+  it('[should do something]', async () => {
+    // Arrange
+    // Act
+    // Assert
+  });
+});
+```
+
+## Integration Tests (X test cases)
+## E2E Tests (X test cases)
+## Performance Tests (X test cases)
+
+## Coverage Requirements
+- Critical paths: 90%+
+- Overall: 80%+
+```
+
+---
+
+## RFC Generator Templates
+
+### Template Selection Logic
+
+**Input Analysis**:
+1. Analyze increment description (keywords, complexity)
+2. Detect domain (frontend, backend, infra, ML, etc.)
+3. Determine scope (feature, product, bug fix, refactor)
+4. Assess technical complexity (simple, moderate, complex)
+
+**Template Selection**:
+```
+IF new_product THEN
+  spec_template = "Full PRD"
+  plan_template = "System Architecture"
+ELSE IF feature_addition THEN
+  spec_template = "User Stories Focused"
+  plan_template = "Component Design"
+ELSE IF bug_fix THEN
+  spec_template = "Problem-Solution"
+  plan_template = "Implementation Steps"
+ELSE IF refactoring THEN
+  spec_template = "Current-Proposed"
+  plan_template = "Migration Strategy"
+END IF
+```
+
+### Context-Aware Sections
+
+**Auto-Include Based On**:
+- **"authentication"** → Security Considerations, JWT/OAuth design
+- **"API"** → API Design, OpenAPI spec, rate limiting
+- **"database"** → ER diagrams, migration scripts, indexes
+- **"frontend"** → Component hierarchy, state management, UI/UX
+- **"deployment"** → CI/CD, infrastructure, monitoring
+- **"ML"** → Model architecture, training pipeline, evaluation metrics
+
+---
+
+## Usage Examples
+
+### Example 1: Simple Feature
+```
+User: /specweave:inc "Add dark mode toggle to settings"
+
+RFC Generator:
+✓ Detected: Frontend feature (UI component)
+✓ Complexity: Simple
+✓ Template: User Stories + Component Design
+
+Generating RFC...
+✓ spec.md: 3 user stories, UI mockups section
+✓ plan.md: Component design, state management, CSS-in-JS
+✓ tasks.md: 8 tasks (component, styles, state, tests)
+✓ tests.md: Unit tests for component, E2E for toggle
+```
+
+### Example 2: Complex System
+```
+User: /specweave:inc "Multi-tenant SaaS platform with billing"
+
+RFC Generator:
+✓ Detected: New product (SaaS, multi-tenant, payments)
+✓ Complexity: High
+✓ Template: Full PRD + System Architecture
+
+Generating RFC...
+✓ spec.md: Market analysis, personas, competitive landscape, 15 user stories
+✓ plan.md: Multi-tenant architecture, database per tenant, Stripe integration, C4 diagrams
+✓ tasks.md: 40 tasks across 4 weeks (auth, tenancy, billing, UI)
+✓ tests.md: 100+ test cases (unit, integration, E2E, load testing)
+```
+
+### Example 3: Bug Fix
+```
+User: /specweave:inc "Fix race condition in user session handling"
+
+RFC Generator:
+✓ Detected: Bug fix (concurrency issue)
+✓ Complexity: Moderate
+✓ Template: Problem-Solution
+
+Generating RFC...
+✓ spec.md: Problem statement, root cause analysis, impact, solution
+✓ plan.md: Current implementation, proposed fix, Redis locking
+✓ tasks.md: 5 tasks (analysis, fix, tests, rollout, monitoring)
+✓ tests.md: Concurrency tests, stress tests
+```
+
+---
+
+## Integration with /specweave:inc
+
+The RFC generator is automatically invoked by `/specweave:inc`:
+
+1. **User Intent Analysis**:
+   - Analyze increment description
+   - Detect keywords, domain, complexity
+
+2. **Template Selection**:
+   - Choose appropriate templates
+   - Auto-include relevant sections
+
+3. **RFC Generation**:
+   - Generate spec.md with PM context
+   - Generate plan.md with Architect context
+   - Generate tasks.md with breakdown
+   - Generate tests.md with coverage strategy
+
+4. **User Review**:
+   - Show generated structure
+   - Allow refinement
+   - Confirm before creating files
+
+---
+
+## Advantages Over Rigid Templates
+
+**Flexible (V2) Approach**:
+- ✅ Adapts to increment type (product, feature, bug fix, refactor)
+- ✅ Includes only relevant sections
+- ✅ Scales complexity up/down
+- ✅ Domain-aware (frontend, backend, ML, infra)
+- ✅ Faster for simple increments
+- ✅ Comprehensive for complex products
+
+**Rigid (V1) Approach**:
+- ❌ Same template for everything
+- ❌ Many irrelevant sections
+- ❌ Wastes time on simple features
+- ❌ Insufficient for complex products
+- ❌ One-size-fits-none
+
+---
+
+## Configuration
+
+Users can customize RFC generation in `.specweave/config.yaml`:
+
+```yaml
+rfc_generator:
+  # Default complexity level
+  default_complexity: moderate  # simple | moderate | complex
+
+  # Always include sections
+  always_include:
+    - executive_summary
+    - user_stories
+    - success_metrics
+
+  # Never include sections
+  never_include:
+    - competitive_analysis  # We're not doing market research
+
+  # Domain defaults
+  domain_defaults:
+    frontend:
+      include: [ui_mockups, component_hierarchy, state_management]
+    backend:
+      include: [api_design, database_schema, authentication]
+```
+
+---
+
+## Related Skills
+
+- **increment-planner**: Guides increment planning (uses RFC generator internally)
+- **context-loader**: Loads relevant context for RFC generation
+- **increment-quality-judge**: Validates generated RFCs for completeness
+
+---
+
+## Version History
+
+- **v1.0.0** (0.4.0): Initial release with flexible template system
+- Based on: FlexibleRFCGenerator (V2) analysis from increment 0001
+
+---
+
+## References
+
+- Flexible RFC Generator Design: `.specweave/increments/0001-core-framework/reports/rfc-generator-v2.md`
+- Generator Comparison: `.specweave/increments/0001-core-framework/reports/rfc-generator-comparison.md`

package/{src → plugins/specweave}/skills/specweave-detector/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: specweave-detector
-description: Detects SpecWeave context (.specweave/ directory exists) and provides workflow documentation. v0.3.8+ features PROACTIVE auto-detection - when in SpecWeave folder, product descriptions automatically trigger increment planning. Explicit slash commands still work (/inc, /do, /progress, /validate, /done, /sync-docs, /sync-github). Keywords slash commands, /inc, /increment, /do, /progress, /validate, /done, specweave commands, smart workflow, auto-detection, specweave folder.
+description: Detects SpecWeave context (.specweave/ directory exists) and provides workflow documentation. v0.3.8+ features PROACTIVE auto-detection - when in SpecWeave folder, product descriptions automatically trigger increment planning. Explicit slash commands still work (/inc, /do, /progress, /validate, /done, /specweave:sync-docs, /sync-github). Keywords slash commands, /inc, /increment, /do, /progress, /validate, /done, specweave commands, smart workflow, auto-detection, specweave folder.
 ---
 
 # SpecWeave v0.3.8+ - Smart Workflow with Auto-Detection
@@ -40,7 +40,7 @@ When working in a SpecWeave-initialized project (.specweave/ directory exists),
 | Command | Description | Example |
 |---------|-------------|---------|
 | `/list-increments` | List all increments with status | `/list-increments` |
-| `/sync-docs` | Review strategic docs vs code | `/sync-docs --increment=003` |
+| `/specweave:sync-docs` | Review strategic docs vs code | `/specweave:sync-docs --increment=003` |
 | `/sync-github` | Sync increment to GitHub issues | `/sync-github` |
 
 ## Why Only ONE Alias?