specweave 0.1.5 → 0.1.6

package/src/commands/si.md

@@ -0,0 +1,83 @@
+---
+description: 🔥 Shorthand for /start-increment - Start working on increment (Alias)
+---
+
+# Start Increment (Short Alias)
+
+**⚡ Quick Alias**: This is a shorthand command for `/start-increment`.
+
+Use this when you want to quickly start working on an increment without typing the full command name.
+
+---
+
+## Full Command
+
+For complete documentation, see `/start-increment`.
+
+This alias provides the exact same functionality as the full command.
+
+---
+
+## Usage
+
+```bash
+/si <increment-id>
+```
+
+**Examples**:
+```bash
+/si 0001
+/si 0042
+/si 0123
+```
+
+---
+
+## What This Does
+
+1. **Updates status** to `in-progress` in `tasks.md`
+2. **Loads context** via context-manifest.yaml
+3. **Creates feature branch** (if git workflow enabled)
+4. **Shows increment summary**:
+   - Spec highlights (user stories, goals)
+   - Architecture approach
+   - Task breakdown
+   - Test strategy
+
+---
+
+## Typical Workflow
+
+```bash
+# 1. Create increment
+/ci "User authentication"
+
+# 2. Review generated specs
+# ... check spec.md, plan.md, tasks.md ...
+
+# 3. Start working
+/si 0001
+
+# 4. Implement tasks
+# ... write code, tests, docs ...
+
+# 5. Validate quality
+/vi 0001 --quality
+
+# 6. Close when done
+/done 0001
+```
+
+---
+
+## Other Useful Aliases
+
+- `/ci` - Create increment (shorthand for `/create-increment`)
+- `/vi` - Validate increment (shorthand for `/validate-increment`)
+- `/done` - Close increment (shorthand for `/close-increment`)
+- `/ls` - List increments (shorthand for `/list-increments`)
+- `/at` - Add tasks (shorthand for `/add-tasks`)
+
+---
+
+**💡 Tip**: Always validate (`/vi`) before starting to catch spec issues early.

package/src/commands/vi.md

@@ -0,0 +1,89 @@
+---
+description: 🔥 Shorthand for /validate-increment - Validate increment quality (Alias)
+---
+
+# Validate Increment (Short Alias)
+
+**⚡ Quick Alias**: This is a shorthand command for `/validate-increment`.
+
+Use this when you want to quickly validate an increment without typing the full command name.
+
+---
+
+## Full Command
+
+For complete documentation, see `/validate-increment`.
+
+This alias provides the exact same functionality as the full command.
+
+---
+
+## Usage
+
+```bash
+/vi [increment-id] [--quality]
+```
+
+**Examples**:
+```bash
+/vi 0001                    # Rule-based validation only
+/vi 0001 --quality          # Rule-based + LLM quality assessment
+/vi                         # Validate current increment
+```
+
+---
+
+## What This Does
+
+**Rule-Based Validation** (Always runs):
+- ✅ 120 validation rules across 4 categories
+- ✅ Consistency checks (Spec ↔ Plan ↔ Tasks alignment)
+- ✅ Completeness checks (All required sections present)
+- ✅ Quality checks (Technology-agnostic, testable criteria)
+- ✅ Traceability checks (TC-0001 → tests.md coverage)
+
+**LLM Quality Assessment** (With `--quality` flag):
+- ✅ 6-dimension scoring (Clarity, Testability, Completeness, etc.)
+- ✅ Actionable suggestions with examples
+- ✅ Overall quality score (0-100)
+- ✅ Issue severity ranking (major, minor)
+
+---
+
+## Validation Results
+
+**Rule-Based Output**:
+```
+✅ Validation Results: 118/120 rules passed (98%)
+
+Issues Found:
+⚠️ [CONSISTENCY-012] Missing test case coverage for US-B003
+⚠️ [QUALITY-008] Acceptance criteria not testable in spec.md:45
+```
+
+**Quality Assessment Output** (with `--quality`):
+```
+🔍 Quality Score: 87/100 (GOOD)
+
+Dimension Scores:
+  • Clarity:         92/100 ✓✓
+  • Testability:     78/100 ✓  (Needs improvement)
+  • Completeness:    90/100 ✓✓
+  • Feasibility:     88/100 ✓✓
+
+Issues: 2 major, 1 minor
+Suggestions: 3 high priority improvements
+```
+
+---
+
+## Other Useful Aliases
+
+- `/ci` - Create increment (shorthand for `/create-increment`)
+- `/si` - Start increment (shorthand for `/start-increment`)
+- `/done` - Close increment (shorthand for `/close-increment`)
+- `/ls` - List increments (shorthand for `/list-increments`)
+
+---
+
+**💡 Tip**: Use `/vi` for quick checks, `/vi --quality` before implementation.

package/src/skills/specweave-detector/SKILL.md

@@ -1,99 +1,69 @@
 ---
 name: specweave-detector
-description: Entry point for SpecWeave framework. Automatically activates when .specweave directory is detected in the project. Acts as a factory of agents, parsing user requests and routing to appropriate skills. Supports nested skill calls and context management. This skill should ALWAYS be loaded first in SpecWeave projects. Activates for ANY user request in a SpecWeave project (auto-detects .specweave/).
+description: MANDATORY entry point for SpecWeave framework. Activates when .specweave/ exists OR when user mentions "SpecWeave", "increment", "feature", "/create-increment". All 10 agents and 35+ skills are PRE-INSTALLED during init - no auto-installation needed. Routes requests to increment-planner, skill-router, or appropriate agents. Keywords SpecWeave, spec-driven, increment, feature, spec, plan, task, create feature, build feature, new increment.
 proactive: true
 ---
 
 # SpecWeave Detector & Entry Point
 
-This skill is the **automatic entry point** for all SpecWeave operations. When Claude Code detects a `.specweave/config.yaml` file, this skill activates and orchestrates the SpecWeave framework.
+This skill is the **MANDATORY entry point** for all SpecWeave operations. When Claude Code detects a `.specweave/config.yaml` file OR user mentions SpecWeave-related keywords, this skill MUST activate and orchestrate the framework.
 
 ## Purpose
 
 Act as the "factory of agents" that:
-1. Detects SpecWeave projects automatically
-2. Parses user requests
-3. Routes to appropriate skills
-4. Orchestrates nested skill calls
-5. Manages context loading
+1. **Detects SpecWeave projects automatically** (when .specweave/ exists)
+2. **Parses user requests** and determines intent
+3. **Routes to appropriate skills/agents** (all pre-installed!)
+4. **Orchestrates nested skill calls** for complex operations
+5. **Manages context loading** via context-loader skill
 
-## Detection Logic
+## Detection Logic (0.1.5 - Pre-Installation)
 
 ```javascript
 // Pseudo-code for detection
 if (fileExists('.specweave/config.yaml')) {
+  // ACTIVATE SPECWEAVE MODE
   activateSpecWeaveMode();
   loadConfiguration();
 
-  // AUTO-INSTALL MISSING COMPONENTS (NEW!)
-  await autoInstallComponents(userPrompt);
+  // ALL COMPONENTS ALREADY INSTALLED!
+  // ✅ 10 agents in .claude/agents/
+  // ✅ 35+ skills in .claude/skills/
+  // ✅ 10 commands in .claude/commands/
+
+  // NO AUTO-INSTALLATION NEEDED (pre-installed in 0.1.5)
 
   parseUserIntent();
   routeToSkills();
 }
 ```
 
-## Just-In-Time Component Installation (CRITICAL!)
+## Pre-Installed Components (0.1.5+)
 
-**SpecWeave uses intelligent auto-installation** - components are installed on-demand based on user intent.
+**IMPORTANT**: SpecWeave 0.1.5+ uses **pre-installation** instead of auto-installation.
 
-### How It Works
+After `specweave init`, ALL components are ready:
+- ✅ **10 agents**: PM, Architect, Security, QA Lead, DevOps, Tech Lead, SRE, Docs Writer, Performance, Diagrams Architect
+- ✅ **35+ skills**: Technology stacks, integrations, utilities
+- ✅ **10 slash commands**: /create-increment, /validate-increment, etc.
 
-1. **User makes a request** (e.g., "Create Next.js authentication")
-2. **Analyze user intent** - Extract keywords (Next.js, authentication)
-3. **Map to required components**:
-   - "Next.js" → nextjs skill, nodejs-backend skill
-   - "authentication" → security agent
-   - "Create" → pm agent, architect agent
-4. **Check if components installed** in `.claude/skills/` and `.claude/agents/`
-5. **Auto-install missing components** from npm package (`node_modules/specweave/src/`)
-6. **Proceed with routing** - now all needed components are available
-
-### Keyword → Component Mapping
-
-```typescript
-// From src/utils/auto-install.ts
-const COMPONENT_MAPPING = {
-  // Framework detection
-  'next.js': { skills: ['nextjs', 'nodejs-backend'], agents: [] },
-  'react': { skills: ['frontend'], agents: [] },
-  'fastapi': { skills: ['python-backend'], agents: [] },
-  'django': { skills: ['python-backend'], agents: [] },
-  '.net': { skills: ['dotnet-backend'], agents: [] },
-
-  // Feature detection
-  'authentication': { skills: ['nodejs-backend'], agents: ['security'] },
-  'auth': { skills: [], agents: ['security'] },
-  'oauth': { skills: [], agents: ['security'] },
-  'payment': { skills: ['stripe-integrator'], agents: ['security'] },
-  'stripe': { skills: ['stripe-integrator'], agents: ['security'] },
-
-  // Infrastructure detection
-  'deploy': { skills: [], agents: ['devops'] },
-  'hetzner': { skills: ['hetzner-provisioner'], agents: ['devops'] },
-  'aws': { skills: [], agents: ['devops'] },
-
-  // Testing detection
-  'test': { skills: [], agents: ['qa-lead'] },
-  'e2e': { skills: ['e2e-playwright'], agents: ['qa-lead'] },
-  'playwright': { skills: ['e2e-playwright'], agents: ['qa-lead'] },
-
-  // Design detection
-  'figma': { skills: ['figma-implementer', 'figma-designer'], agents: [] },
-  'design system': { skills: ['design-system-architect'], agents: [] },
-
-  // Integration detection
-  'jira': { skills: ['jira-sync'], agents: [] },
-  'github': { skills: ['github-sync'], agents: [] },
-};
-
-// Always include strategic agents for new features
-if (prompt.includes('create') || prompt.includes('build')) {
-  agents.push('pm', 'architect');
-}
-```
+**No installation wait time** - components activate immediately!
+
+### How It Works (0.1.5+)
 
-### Example User Experience
+1. **User makes a request** (e.g., "Create Next.js authentication")
+2. **SpecWeave detector activates** (all components already installed!)
+3. **Analyze user intent**:
+   - "Create" → Route to increment-planner skill
+   - "Next.js" → Will use nextjs skill (already installed)
+   - "authentication" → Will involve security agent (already installed)
+4. **Route to increment-planner**:
+   - Creates increment folder
+   - Generates spec.md, plan.md, tasks.md, tests.md
+   - Coordinates with PM agent → Architect agent
+5. **Implementation ready** - All skills/agents available immediately
+
+### Example User Experience (0.1.5+)
 
 **Example 1: Next.js Authentication**
 ```
@@ -101,24 +71,28 @@ User: "Create Next.js authentication with OAuth"
 
 🔷 SpecWeave Active
 
-📦 Installing required components...
-   ✅ Installed nextjs skill
-   ✅ Installed nodejs-backend skill
-   ✅ Installed security agent
-   ✅ Installed pm agent
-   ✅ Installed architect agent
-
 🚀 Creating increment 0001-nextjs-authentication...
+   📝 Using nextjs skill (already installed!)
+   🤖 PM agent creating requirements...
+   🏗️  Architect agent designing system...
+
+✅ Increment created: .specweave/increments/0001-nextjs-authentication/
+✅ Files: spec.md, plan.md, tasks.md, tests.md
 ```
 
-**Example 2: Already Installed**
+**Example 2: Real Estate Platform**
 ```
-User: "Add another Next.js feature"
+User: "Build a real estate listing platform with Node.js/Express"
 
 🔷 SpecWeave Active
-   (Components already installed, proceeding...)
 
-🚀 Creating increment 0002-next-feature...
+🚀 Creating increment 0001-real-estate-platform...
+   📝 Using nodejs-backend skill (already installed!)
+   🤖 PM agent creating requirements...
+   🏗️  Architect agent designing system...
+   🛡️  Security agent reviewing authentication...
+
+✅ Increment created with complete specifications
 ```
 
 **Example 3: Python FastAPI**
@@ -127,53 +101,21 @@ User: "Create FastAPI backend with PostgreSQL"
 
 🔷 SpecWeave Active
 
-📦 Installing required components...
-   ✅ Installed python-backend skill
-   ✅ Installed pm agent
-   ✅ Installed architect agent
-
 🚀 Creating increment 0001-fastapi-backend...
-```
+   📝 Using python-backend skill (already installed!)
+   🤖 PM agent creating requirements...
+   🏗️  Architect agent designing system...
 
-### Configuration
-
-Auto-install can be disabled in `.specweave/config.yaml`:
-
-```yaml
-# .specweave/config.yaml
-auto_install: true  # Default: enabled
-
-# Tracked installed components (auto-updated)
-installed_components:
-  skills:
-    - nextjs
-    - nodejs-backend
-    - security
-  agents:
-    - pm
-    - architect
-    - security
+✅ Increment created: .specweave/increments/0001-fastapi-backend/
 ```
 
-Set `auto_install: false` to require manual installation (advanced users only).
+### Benefits of Pre-Installation (0.1.5+)
 
-### Installation Process
-
-When auto-installing:
-
-1. **Find npm package**: Locate `node_modules/specweave/`
-2. **Copy component**: `src/skills/nextjs/` → `.claude/skills/nextjs/`
-3. **Verify**: Check component has SKILL.md or AGENT.md
-4. **Update config**: Add to `installed_components` list
-5. **Continue routing**: Component now available for use
-
-### Benefits
-
-- ✅ **Zero manual installation** - users never run `specweave install`
-- ✅ **Just-in-time** - only install what's actually needed
-- ✅ **Automatic** - completely transparent to users
-- ✅ **Intelligent** - understands intent from natural language
-- ✅ **Efficient** - unused components never installed
+- ✅ **Zero wait time** - all components ready immediately
+- ✅ **No installation confusion** - everything works out of the box
+- ✅ **Predictable** - same components every time
+- ✅ **Simple mental model** - init once, use forever
+- ✅ **Offline-friendly** - all components local after init
 
 ## Auto-Activation
 
@@ -194,11 +136,11 @@ User: "I want to add payment processing"
 # 1. specweave-detector intercepts request
 # 2. Parses request: "add feature" + "payment processing"
 # 3. Routes to: increment-planner skill
-# 4. increment-planner creates Feature 002
+# 4. increment-planner creates Increment 0002
 # 5. Returns result to user
 
 # User sees:
-✅ Feature created: 002-payment-processing
+✅ Increment created: .specweave/increments/0002-payment-processing/
 ```
 
 ## Request Parsing & Routing
@@ -220,11 +162,11 @@ User: "I want to add payment processing"
 **Example**: "Create and implement a new payment feature"
 
 **Request Breakdown**:
-1. Create feature → `increment-planner`
-2. Implement code → Load context via `context-loader`
-3. Implement code → `developer`
-4. Generate tests → `qa-engineer`
-5. Update docs → `docs-updater`
+1. Create increment → `increment-planner`
+2. Load context → `context-loader`
+3. Implement code → Coordinate with appropriate agents/skills
+4. Generate tests → Use QA Lead agent
+5. Update docs → Use Docs Writer agent
 
 **Execution Flow**:
 ```
@@ -234,17 +176,17 @@ specweave-detector parses: CREATE + IMPLEMENT + FEATURE + PAYMENT
     ↓
 Orchestrate nested skills:
     ↓
-increment-planner: Create 003-payment-processing/
+increment-planner: Create .specweave/increments/0003-payment-processing/
     ↓
-context-loader: Load specs/modules/payments/**
+context-loader: Load .specweave/docs/internal/strategy/payments/**
     ↓
-developer: Implement based on tasks.md
+Implementation: Use nodejs-backend skill + security agent
     ↓
-qa-engineer: Generate test cases
+Testing: Use QA Lead agent (generate E2E tests)
     ↓
-docs-updater: Update README, docs/
+Documentation: Update .specweave/docs/internal/architecture/
     ↓
-Result: "✅ Feature 003 implemented and documented"
+Result: "✅ Increment 0003 implemented and documented"
 ```
 
 ### Ambiguous Request
@@ -269,14 +211,14 @@ skill-router asks:
 
 ### Automatic Context Loading
 
-When a user is working on a feature:
+When a user is working on an increment:
 
 ```javascript
-// Detect active work
-const activeIssue = detectActiveIssue(); // work/issues/###-xxx/
+// Detect active increment
+const activeIncrement = detectActiveIncrement(); // .specweave/increments/####-xxx/
 
-if (activeIssue) {
-  const manifest = loadManifest(`${activeIssue}/context-manifest.yaml`);
+if (activeIncrement) {
+  const manifest = loadManifest(`${activeIncrement}/context-manifest.yaml`);
   const context = await contextLoader.load(manifest);
   // Context now available for all skills
 }
@@ -286,10 +228,10 @@ if (activeIssue) {
 
 When multiple contexts are relevant:
 
-1. **Active work item** (in `work/issues/`)
-2. **Current feature** (referenced in git branch)
+1. **Active increment** (in `.specweave/increments/####-xxx/`)
+2. **Current branch** (git branch name features/###-xxx)
 3. **User-specified** context
-4. **Global** context (specs/overview.md, principles.md)
+4. **Global** context (.specweave/docs/internal/strategy/overview.md, principles.md)
 
 ## Skill Orchestration
 
@@ -329,17 +271,17 @@ Each step waits for previous to complete
 If a skill fails:
 
 ```
-User: "Implement feature 005"
+User: "Implement increment 0005"
     ↓
-specweave-detector: Route to developer
+specweave-detector: Route to implementation
     ↓
-developer: ERROR - Feature 005 not found
+ERROR: Increment 0005 not found
     ↓
 specweave-detector: Catch error, suggest:
-"Feature 005 doesn't exist. Would you like to:
-1. Create it first (increment-planner)
-2. List existing features
-3. Implement a different feature"
+"Increment 0005 doesn't exist. Would you like to:
+1. Create it first (/create-increment)
+2. List existing increments (/list-increments)
+3. Implement a different increment"
 ```
 
 ## Configuration Awareness
@@ -353,14 +295,17 @@ principles:
   context_precision: true         # Use context manifests
   routing_accuracy_target: 0.90   # Accuracy threshold
 
-skills:
-  install_location: "local"       # Where skills are installed
-  auto_install: true              # Auto-install missing skills
+# All components pre-installed in 0.1.5+ (no auto_install setting needed)
+# Agents and skills are in .claude/ folder, ready to use
 
 integrations:
   github:
     enabled: true
-    sync_issues: true             # Sync features ↔ GitHub issues
+    sync_issues: true             # Sync increments ↔ GitHub issues
+  jira:
+    enabled: false
+  ado:
+    enabled: false
 ```
 
 When `auto_role_routing: false`, this skill still activates but prompts user for explicit skill selection.
@@ -379,21 +324,35 @@ This helps users know SpecWeave framework is orchestrating their request.
 
 ## Skill Discovery
 
-List available skills:
+List available skills (all pre-installed):
 
 ```bash
 User: "What can SpecWeave do?"
     ↓
-specweave-detector: List installed skills
+specweave-detector: List all pre-installed skills
 
-SpecWeave Skills:
+SpecWeave Framework Skills (35+, all ready):
 ✅ increment-planner - Plan implementation features
 ✅ context-loader - Selective specification loading
 ✅ skill-router - Route ambiguous intents
-📦 spec-author - Create specifications (install with: npx specweave install spec-author)
-📦 architect - System design (install with: npx specweave install architect)
-
-Custom Skills:
+✅ nodejs-backend - Node.js/Express/NestJS backend
+✅ python-backend - Python/FastAPI/Django backend
+✅ nextjs - Next.js App Router specialist
+✅ frontend - React/Vue/Angular frontend
+✅ diagrams-generator - C4 Model diagrams
+✅ github-sync - GitHub integration
+✅ jira-sync - JIRA integration
+... and 25+ more!
+
+SpecWeave Agents (10, all ready):
+✅ pm - Product Manager (requirements, user stories)
+✅ architect - System Architect (design, ADRs)
+✅ security - Security Engineer (threat modeling)
+✅ qa-lead - QA Lead (test strategy)
+✅ devops - DevOps Engineer (deployment)
+... and 5+ more!
+
+Custom Skills (user-created):
 ✅ newrelic-monitor - New Relic integration
 ✅ cqrs-implementer - CQRS pattern implementation
 ```
@@ -410,38 +369,38 @@ Custom Skills:
 
 2. Route to increment-planner:
    Input: "Real-time chat feature"
-   Output: features/004-realtime-chat/
+   Output: .specweave/increments/0004-realtime-chat/
            - spec.md (5 user stories)
            - plan.md (WebSocket architecture)
            - tasks.md (78 tasks)
            - tests.md (20 test cases)
 
 3. Detect next request: User likely wants to implement
-   Prompt: "Feature 004 created. Would you like to:
+   Prompt: "Increment 0004 created. Would you like to:
            1. Review the plan
            2. Start implementation
-           3. Load context for this feature"
+           3. Load context for this increment"
 
 4. User chooses 2 (Start implementation)
 
 5. Route to context-loader:
-   Load: features/004-realtime-chat/context-manifest.yaml
+   Load: .specweave/increments/0004-realtime-chat/context-manifest.yaml
    Output: Loaded specs/modules/realtime/**, architecture/websockets.md
 
-6. Route to developer:
-   Input: features/004-realtime-chat/tasks.md
+6. Route to implementation:
+   Input: .specweave/increments/0004-realtime-chat/tasks.md
    Context: Loaded specs
    Output: Implement Phase 1 (Setup WebSocket server)
 
-7. After implementation, route to qa-engineer:
-   Input: features/004-realtime-chat/tests.md
-   Output: Generate test suite
+7. After implementation, coordinate testing:
+   Input: .specweave/increments/0004-realtime-chat/tests.md
+   Output: Generate test suite (E2E with Playwright)
 
-8. Finally, route to docs-updater:
-   Update: docs/reference/api.md (add WebSocket endpoints)
+8. Finally, update documentation:
+   Update: .specweave/docs/internal/architecture/api.md (add WebSocket endpoints)
 
 9. Return to user:
-   ✅ Feature 004 implemented, tested, and documented
+   ✅ Increment 0004 implemented, tested, and documented
 ```
 
 ## Best Practices
@@ -466,11 +425,11 @@ For multi-step operations, confirm before proceeding:
 You want to "create and implement a payment feature".
 
 This will:
-1. Create Feature 003 (increment-planner)
-2. Load relevant specs (context-loader)
-3. Implement code (developer)
-4. Generate tests (qa-engineer)
-5. Update documentation (docs-updater)
+1. Create Increment 0003 (increment-planner skill)
+2. Load relevant specs (context-loader skill)
+3. Implement code (nodejs-backend skill + security agent)
+4. Generate tests (QA Lead agent)
+5. Update documentation (Docs Writer agent)
 
 Estimated time: 15-30 minutes
 
@@ -529,12 +488,12 @@ if (specweaveDetectorActive()) {
 - Given: User says "Plan a feature for authentication"
 - When: specweave-detector parses request
 - Then: Routes to increment-planner
-- And: increment-planner creates Feature 00X
+- And: increment-planner creates Increment 000X (.specweave/increments/000X-authentication/)
 
 ### TC-003: Route Complex Request
 - Given: User says "Create and implement payment feature"
 - When: specweave-detector parses request
-- Then: Orchestrates: increment-planner → context-loader → developer → qa-engineer → docs-updater
+- Then: Orchestrates: increment-planner → context-loader → implementation (with agents) → testing → documentation
 - And: All steps complete successfully
 
 ### TC-004: Handle Ambiguous Request