specweave 0.3.13 → 0.4.0

package/src/commands/specweave.tdd-red.md

@@ -0,0 +1,135 @@
+Write comprehensive failing tests following TDD red phase principles.
+
+[Extended thinking: Generates failing tests that properly define expected behavior using test-automator agent.]
+
+## Role
+
+Generate failing tests using Task tool with subagent_type="unit-testing::test-automator".
+
+## Prompt Template
+
+"Generate comprehensive FAILING tests for: $ARGUMENTS
+
+## Core Requirements
+
+1. **Test Structure**
+   - Framework-appropriate setup (Jest/pytest/JUnit/Go/RSpec)
+   - Arrange-Act-Assert pattern
+   - should_X_when_Y naming convention
+   - Isolated fixtures with no interdependencies
+
+2. **Behavior Coverage**
+   - Happy path scenarios
+   - Edge cases (empty, null, boundary values)
+   - Error handling and exceptions
+   - Concurrent access (if applicable)
+
+3. **Failure Verification**
+   - Tests MUST fail when run
+   - Failures for RIGHT reasons (not syntax/import errors)
+   - Meaningful diagnostic error messages
+   - No cascading failures
+
+4. **Test Categories**
+   - Unit: Isolated component behavior
+   - Integration: Component interaction
+   - Contract: API/interface contracts
+   - Property: Mathematical invariants
+
+## Framework Patterns
+
+**JavaScript/TypeScript (Jest/Vitest)**
+- Mock dependencies with `vi.fn()` or `jest.fn()`
+- Use `@testing-library` for React components
+- Property tests with `fast-check`
+
+**Python (pytest)**
+- Fixtures with appropriate scopes
+- Parametrize for multiple test cases
+- Hypothesis for property-based tests
+
+**Go**
+- Table-driven tests with subtests
+- `t.Parallel()` for parallel execution
+- Use `testify/assert` for cleaner assertions
+
+**Ruby (RSpec)**
+- `let` for lazy loading, `let!` for eager
+- Contexts for different scenarios
+- Shared examples for common behavior
+
+## Quality Checklist
+
+- Readable test names documenting intent
+- One behavior per test
+- No implementation leakage
+- Meaningful test data (not 'foo'/'bar')
+- Tests serve as living documentation
+
+## Anti-Patterns to Avoid
+
+- Tests passing immediately
+- Testing implementation vs behavior
+- Complex setup code
+- Multiple responsibilities per test
+- Brittle tests tied to specifics
+
+## Edge Case Categories
+
+- **Null/Empty**: undefined, null, empty string/array/object
+- **Boundaries**: min/max values, single element, capacity limits
+- **Special Cases**: Unicode, whitespace, special characters
+- **State**: Invalid transitions, concurrent modifications
+- **Errors**: Network failures, timeouts, permissions
+
+## Output Requirements
+
+- Complete test files with imports
+- Documentation of test purpose
+- Commands to run and verify failures
+- Metrics: test count, coverage areas
+- Next steps for green phase"
+
+## Validation
+
+After generation:
+1. Run tests - confirm they fail
+2. Verify helpful failure messages
+3. Check test independence
+4. Ensure comprehensive coverage
+
+## Example (Minimal)
+
+```typescript
+// auth.service.test.ts
+describe('AuthService', () => {
+  let authService: AuthService;
+  let mockUserRepo: jest.Mocked<UserRepository>;
+
+  beforeEach(() => {
+    mockUserRepo = { findByEmail: jest.fn() } as any;
+    authService = new AuthService(mockUserRepo);
+  });
+
+  it('should_return_token_when_valid_credentials', async () => {
+    const user = { id: '1', email: 'test@example.com', passwordHash: 'hashed' };
+    mockUserRepo.findByEmail.mockResolvedValue(user);
+
+    const result = await authService.authenticate('test@example.com', 'pass');
+
+    expect(result.success).toBe(true);
+    expect(result.token).toBeDefined();
+  });
+
+  it('should_fail_when_user_not_found', async () => {
+    mockUserRepo.findByEmail.mockResolvedValue(null);
+
+    const result = await authService.authenticate('none@example.com', 'pass');
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('INVALID_CREDENTIALS');
+  });
+});
+```
+
+Test requirements: $ARGUMENTS

package/src/commands/specweave.tdd-refactor.md

@@ -0,0 +1,165 @@
+Refactor code with confidence using comprehensive test safety net:
+
+[Extended thinking: This tool uses the tdd-orchestrator agent (opus model) for sophisticated refactoring while maintaining all tests green. It applies design patterns, improves code quality, and optimizes performance with the safety of comprehensive test coverage.]
+
+## Usage
+
+Use Task tool with subagent_type="tdd-orchestrator" to perform safe refactoring.
+
+Prompt: "Refactor this code while keeping all tests green: $ARGUMENTS. Apply TDD refactor phase:
+
+## Core Process
+
+**1. Pre-Assessment**
+- Run tests to establish green baseline
+- Analyze code smells and test coverage
+- Document current performance metrics
+- Create incremental refactoring plan
+
+**2. Code Smell Detection**
+- Duplicated code → Extract methods/classes
+- Long methods → Decompose into focused functions
+- Large classes → Split responsibilities
+- Long parameter lists → Parameter objects
+- Feature Envy → Move methods to appropriate classes
+- Primitive Obsession → Value objects
+- Switch statements → Polymorphism
+- Dead code → Remove
+
+**3. Design Patterns**
+- Apply Creational (Factory, Builder, Singleton)
+- Apply Structural (Adapter, Facade, Decorator)
+- Apply Behavioral (Strategy, Observer, Command)
+- Apply Domain (Repository, Service, Value Objects)
+- Use patterns only where they add clear value
+
+**4. SOLID Principles**
+- Single Responsibility: One reason to change
+- Open/Closed: Open for extension, closed for modification
+- Liskov Substitution: Subtypes substitutable
+- Interface Segregation: Small, focused interfaces
+- Dependency Inversion: Depend on abstractions
+
+**5. Refactoring Techniques**
+- Extract Method/Variable/Interface
+- Inline unnecessary indirection
+- Rename for clarity
+- Move Method/Field to appropriate classes
+- Replace Magic Numbers with constants
+- Encapsulate fields
+- Replace Conditional with Polymorphism
+- Introduce Null Object
+
+**6. Performance Optimization**
+- Profile to identify bottlenecks
+- Optimize algorithms and data structures
+- Implement caching where beneficial
+- Reduce database queries (N+1 elimination)
+- Lazy loading and pagination
+- Always measure before and after
+
+**7. Incremental Steps**
+- Make small, atomic changes
+- Run tests after each modification
+- Commit after each successful refactoring
+- Keep refactoring separate from behavior changes
+- Use scaffolding when needed
+
+**8. Architecture Evolution**
+- Layer separation and dependency management
+- Module boundaries and interface definition
+- Event-driven patterns for decoupling
+- Database access pattern optimization
+
+**9. Safety Verification**
+- Run full test suite after each change
+- Performance regression testing
+- Mutation testing for test effectiveness
+- Rollback plan for major changes
+
+**10. Advanced Patterns**
+- Strangler Fig: Gradual legacy replacement
+- Branch by Abstraction: Large-scale changes
+- Parallel Change: Expand-contract pattern
+- Mikado Method: Dependency graph navigation
+
+## Output Requirements
+
+- Refactored code with improvements applied
+- Test results (all green)
+- Before/after metrics comparison
+- Applied refactoring techniques list
+- Performance improvement measurements
+- Remaining technical debt assessment
+
+## Safety Checklist
+
+Before committing:
+- ✓ All tests pass (100% green)
+- ✓ No functionality regression
+- ✓ Performance metrics acceptable
+- ✓ Code coverage maintained/improved
+- ✓ Documentation updated
+
+## Recovery Protocol
+
+If tests fail:
+- Immediately revert last change
+- Identify breaking refactoring
+- Apply smaller incremental changes
+- Use version control for safe experimentation
+
+## Example: Extract Method Pattern
+
+**Before:**
+```typescript
+class OrderProcessor {
+  processOrder(order: Order): ProcessResult {
+    // Validation
+    if (!order.customerId || order.items.length === 0) {
+      return { success: false, error: "Invalid order" };
+    }
+
+    // Calculate totals
+    let subtotal = 0;
+    for (const item of order.items) {
+      subtotal += item.price * item.quantity;
+    }
+    let total = subtotal + (subtotal * 0.08) + (subtotal > 100 ? 0 : 15);
+
+    // Process payment...
+    // Update inventory...
+    // Send confirmation...
+  }
+}
+```
+
+**After:**
+```typescript
+class OrderProcessor {
+  async processOrder(order: Order): Promise<ProcessResult> {
+    const validation = this.validateOrder(order);
+    if (!validation.isValid) return ProcessResult.failure(validation.error);
+
+    const orderTotal = OrderTotal.calculate(order);
+    const inventoryCheck = await this.inventoryService.checkAvailability(order.items);
+    if (!inventoryCheck.available) return ProcessResult.failure(inventoryCheck.reason);
+
+    await this.paymentService.processPayment(order.paymentMethod, orderTotal.total);
+    await this.inventoryService.reserveItems(order.items);
+    await this.notificationService.sendOrderConfirmation(order, orderTotal);
+
+    return ProcessResult.success(order.id, orderTotal.total);
+  }
+
+  private validateOrder(order: Order): ValidationResult {
+    if (!order.customerId) return ValidationResult.invalid("Customer ID required");
+    if (order.items.length === 0) return ValidationResult.invalid("Order must contain items");
+    return ValidationResult.valid();
+  }
+}
+```
+
+**Applied:** Extract Method, Value Objects, Dependency Injection, Async patterns
+
+Code to refactor: $ARGUMENTS"

package/src/skills/SKILLS-INDEX.md

@@ -2,9 +2,9 @@
 
 **Purpose**: Quick reference for all available skills. Read this file BEFORE starting any task.
 
-**Last Updated**: 2025-10-30T18:08:45.324Z (auto-generated, do not edit manually)
+**Last Updated**: 2025-10-31T06:36:02.949Z (auto-generated, do not edit manually)
 
-**Total Skills**: 34
+**Total Skills**: 35
 
 ---
 
@@ -57,9 +57,9 @@ Step 4: Execute → Follow the increment planning workflow
 
 #### increment-planner
 
-**Description**: Creates comprehensive implementation plans for SpecWeave increments (aka features - both terms are interchangeable). This skill should be used when planning new increments/features, creating specifications, or organizing implementation work. Activates for: increment planning, feature planning, implementation plan, create increment, create feature, plan increment, plan feature, organize work, break down increment, break down feature.
+**Description**: Creates comprehensive implementation plans for SpecWeave increments (aka features - both terms are interchangeable). This skill should be used when planning new increments/features, creating specifications, or organizing implementation work. Activates for: increment planning, feature planning, implementation plan, create increment, create feature, plan increment, plan feature, organize work, break down increment, break down feature, new product, build project, MVP, SaaS, app development, product description, tech stack planning, feature list.
 
-**Activates for**: increment planning, feature planning, implementation plan, create increment, create feature, plan increment, plan feature, organize work, break down increment, break down feature
+**Activates for**: increment planning, feature planning, implementation plan, create increment, create feature, plan increment, plan feature, organize work, break down increment, break down feature, new product, build project, MVP, SaaS, app development, product description, tech stack planning, feature list
 
 **Location**: `.claude/skills/increment-planner/SKILL.md`
 
@@ -93,7 +93,7 @@ Step 4: Execute → Follow the increment planning workflow
 
 #### specweave-detector
 
-**Description**: Documentation skill that explains SpecWeave v0.1.9 smart workflow slash commands. SpecWeave uses EXPLICIT slash commands only - no auto-activation! Use /inc (Plan Increment) or /increment to start. Smart features auto-resume (/do), auto-close (/inc), progress tracking (/progress). Commands /inc, /do, /progress, /validate, /done, /list-increments, /sync-docs, /sync-github. All commands listed in .claude/commands/. Keywords slash commands, /inc, /increment, /do, /progress, /validate, /done, specweave commands, smart workflow, v0.1.9.
+**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.
 
 **Location**: `.claude/skills/specweave-detector/SKILL.md`
 
@@ -120,7 +120,7 @@ Step 4: Execute → Follow the increment planning workflow
 
 #### skill-router
 
-**Description**: Intelligent routing system that parses ambiguous user requests and routes them to appropriate SpecWeave skills with >90% accuracy. Acts as the "traffic controller" for all skill invocations. Activates when user intent is unclear or when multiple skills could handle a request. Keywords: route, clarify, ambiguous, which skill, help me decide.
+**Description**: Intelligent routing system that parses ambiguous user requests and routes them to appropriate SpecWeave skills with >90% accuracy. Acts as the "traffic controller" for all skill invocations. Activates when user intent is unclear or when multiple skills could handle a request. Also activates proactively when detecting product description patterns (name + features + tech stack + timeline) in SpecWeave folders. Keywords: route, clarify, ambiguous, which skill, help me decide, product description, new project, feature list, tech stack, build this.
 
 **Location**: `.claude/skills/skill-router/SKILL.md`
 
@@ -196,9 +196,9 @@ Step 4: Execute → Follow the increment planning workflow
 
 #### spec-driven-brainstorming
 
-**Description**: Refines rough ideas into spec-ready designs through structured Socratic questioning, alternative exploration, and incremental validation. Use BEFORE creating increments - transforms vague concepts into clear requirements. Activates for: brainstorm, explore idea, refine concept, design thinking, what should I build, help me think through, ultrathink design, deep thinking, architecture exploration.
+**Description**: Refines rough ideas into spec-ready designs through structured Socratic questioning, alternative exploration, and incremental validation. Use BEFORE creating increments - transforms vague concepts into clear requirements. Activates for: brainstorm, explore idea, refine concept, design thinking, what should I build, help me think through, ultrathink, ultrathink on, think through this, deep thinking, architecture exploration, analyze this idea, evaluate approach, explore options.
 
-**Activates for**: brainstorm, explore idea, refine concept, design thinking, what should I build, help me think through, ultrathink design, deep thinking, architecture exploration
+**Activates for**: brainstorm, explore idea, refine concept, design thinking, what should I build, help me think through, ultrathink, ultrathink on, think through this, deep thinking, architecture exploration, analyze this idea, evaluate approach, explore options
 
 **Location**: `.claude/skills/spec-driven-brainstorming/SKILL.md`
 
@@ -355,6 +355,14 @@ Step 4: Execute → Follow the increment planning workflow
 
 ---
 
+#### project-kickstarter
+
+**Description**: Proactively detects product/project descriptions and guides users through SpecWeave increment planning. Activates when user provides product name, features, tech stack, timeline, or problem description. Keywords: project, product, SaaS, app, MVP, build, new project, features, tech stack, core functionality, monetization, timeline, I want to build, let's build, quick build, core features.
+
+**Location**: `.claude/skills/project-kickstarter/SKILL.md`
+
+---
+
 #### spec-kit-expert
 
 **Description**: SPEC-KIT Subject Matter Expert for dynamic gap analysis. Deeply understands spec-kit framework and performs on-demand comparison analysis against current SpecWeave state. Analyzes actual code, features, and specs to generate fresh comparison reports. Activates for "compare to spec-kit", "spec-kit vs SpecWeave", "gap analysis", "what does spec-kit have", "benefits comparison", "should I use spec-kit or SpecWeave", "spec-kit features", "how does spec-kit handle X", "GitHub spec-kit".
@@ -419,8 +427,8 @@ Step 4: Execute → Follow the increment planning workflow
 This index simulates Claude Code's native progressive disclosure:
 - Claude pre-loads skill metadata at startup (name + description)
 - Other tools read this index file for same benefit
-- Single file read replaces 34 individual file scans
-- Token savings: ~97% (1 file vs 34 files)
+- Single file read replaces 35 individual file scans
+- Token savings: ~97% (1 file vs 35 files)
 
 **How to use in your AI tool**:
 1. Load this file at session start