aiwf 0.3.1 → 0.3.2

package/claude-code/aiwf/ko/ai-tools/windsurf/README.md

@@ -0,0 +1,355 @@
+# Windsurf AIWF Integration Template
+
+## Overview
+
+This template provides deep integration between Windsurf IDE and the AI Workflow Framework (AIWF). It leverages Windsurf's Cascade AI and flow-based development to create a seamless AIWF development experience.
+
+## Features
+
+- **Cascade AI + AIWF**: AI-powered development with AIWF context awareness
+- **Flow-Based Task Management**: Visual task flows aligned with sprint tasks  
+- **Multi-Agent Personas**: Different AI agents for different development contexts
+- **Automatic Context Management**: Smart compression and loading
+- **Visual Progress Tracking**: See AIWF task progress in Windsurf's UI
+- **Integrated Feature Validation**: Real-time Feature Ledger checking
+
+## Installation
+
+```bash
+# Install Windsurf template
+aiwf ai-tool install windsurf
+
+# Or manually copy template files
+cp -r .aiwf/ai-tools/windsurf/template/* .
+```
+
+## Configuration
+
+The template includes:
+
+1. **windsurf.config.json**: Main configuration
+   - AIWF integration settings
+   - Cascade AI configuration
+   - Automation rules
+   - Keyboard shortcuts
+
+2. **.windsurf/aiwf-rules.md**: Integration rules
+   - Code generation patterns
+   - Flow templates
+   - Best practices
+   - Context management
+
+## Usage
+
+### 1. Cascade AI with AIWF Context
+
+Use Cascade with AIWF awareness:
+
+```
+@cascade Show me feature FL-001 implementation status
+
+@cascade Using architect persona, design the payment system
+
+@cascade What tasks are in the current sprint?
+
+@cascade Implement task T13_S03 following acceptance criteria
+```
+
+### 2. Flow-Based Development
+
+Create AIWF-aligned flows:
+
+**Start a Feature Flow**:
+```
+@cascade start-flow --feature FL-001 --task T13_S03
+```
+
+Windsurf creates a flow with:
+- Feature validation
+- Implementation steps
+- Test requirements
+- Documentation updates
+- Task completion
+
+### 3. AI Persona Switching
+
+Different agents for different tasks:
+
+```javascript
+// @persona architect
+// Cascade switches to architecture-focused responses
+
+// @persona developer
+// Cascade provides implementation details
+
+// @persona reviewer  
+// Cascade analyzes code quality
+```
+
+### 4. Visual Task Management
+
+See AIWF tasks in Windsurf UI:
+- Current sprint tasks in sidebar
+- Task progress indicators
+- Feature dependencies graph
+- Real-time status updates
+
+### 5. Smart Context Loading
+
+Automatic context management:
+
+```javascript
+// @load-feature FL-001
+// Loads feature spec into context
+
+// @load-sprint
+// Loads current sprint tasks
+
+// @compress-context
+// Compresses large files automatically
+```
+
+## Windsurf-Specific Features
+
+### 1. Flow Templates
+
+Pre-built AIWF flows:
+
+**Feature Implementation Flow**:
+- Validates against Feature Ledger
+- Creates implementation structure
+- Generates tests
+- Updates documentation
+- Completes task
+
+**Bug Fix Flow**:
+- Identifies related feature
+- Implements fix
+- Adds regression tests
+- Updates feature status
+
+**Architecture Flow**:
+- Uses architect persona
+- Creates ADR
+- Updates system design
+- Validates with ledger
+
+### 2. Multi-Agent Collaboration
+
+Cascade agents by persona:
+
+```json
+{
+  "agents": {
+    "architect": {
+      "model": "cascade-architect",
+      "focus": "design patterns, system architecture"
+    },
+    "developer": {
+      "model": "cascade-large",
+      "focus": "implementation, optimization"
+    },
+    "reviewer": {
+      "model": "cascade-reviewer",
+      "focus": "code quality, security"
+    }
+  }
+}
+```
+
+### 3. Keyboard Shortcuts
+
+Quick AIWF actions:
+
+- `Cmd+Shift+F`: Check Feature Ledger
+- `Cmd+Shift+T`: Update task status
+- `Cmd+Shift+P`: Switch persona
+- `Cmd+Shift+C`: Compress context
+- `Cmd+Shift+S`: Show sprint tasks
+
+### 4. Automation Features
+
+Automatic workflows:
+
+- **Task Status**: Updates based on file changes
+- **Documentation**: Syncs docs with code
+- **Feature Validation**: Checks on save
+- **Context Compression**: For large files
+- **Test Running**: On task completion
+
+## Best Practices
+
+### 1. Flow-First Development
+
+Start with flows:
+
+```
+@cascade create-flow --type feature --id FL-001
+```
+
+### 2. Context Efficiency
+
+Manage context smartly:
+
+```javascript
+// Good - Reference by ID
+// @feature FL-001
+
+// Avoid - Full feature description
+// @feature "Complete user authentication system with OAuth..."
+```
+
+### 3. Progressive Enhancement
+
+Build incrementally:
+
+1. Start with feature validation
+2. Implement core functionality
+3. Add tests progressively
+4. Update documentation
+5. Complete task
+
+### 4. Visual Feedback
+
+Use Windsurf's UI:
+- Check flow progress visually
+- Monitor task status in sidebar
+- View feature dependencies
+- Track sprint progress
+
+## Advanced Configuration
+
+### 1. Custom Flow Templates
+
+Create `.windsurf/flows/`:
+
+```json
+{
+  "name": "api-endpoint",
+  "steps": [
+    "validate-feature",
+    "create-route",
+    "implement-controller",
+    "add-validation",
+    "write-tests",
+    "update-docs"
+  ]
+}
+```
+
+### 2. Cascade Fine-Tuning
+
+Configure AI behavior:
+
+```json
+{
+  "cascade": {
+    "temperature": {
+      "architect": 0.7,
+      "developer": 0.3,
+      "reviewer": 0.1
+    },
+    "max_tokens": {
+      "design": 2000,
+      "implementation": 5000,
+      "review": 1000
+    }
+  }
+}
+```
+
+### 3. Integration Hooks
+
+Add to `windsurf.config.json`:
+
+```json
+{
+  "hooks": {
+    "pre-commit": "aiwf task validate",
+    "post-save": "aiwf ledger sync",
+    "flow-complete": "aiwf task complete"
+  }
+}
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Cascade not recognizing AIWF**
+   - Check windsurf.config.json
+   - Verify AIWF rules loaded
+   - Restart Windsurf
+
+2. **Flow not updating tasks**
+   - Ensure task ID is correct
+   - Check automation settings
+   - Verify permissions
+
+3. **Context overflow**
+   - Enable auto-compression
+   - Clear old context
+   - Use feature references
+
+### Debug Mode
+
+Enable debugging:
+
+```json
+{
+  "debug": {
+    "aiwf": true,
+    "cascade": true,
+    "flows": true
+  }
+}
+```
+
+## Performance Tips
+
+### 1. Context Optimization
+
+- Compress files > 1000 lines
+- Use feature IDs not descriptions  
+- Clear context between tasks
+- Cache frequently used features
+
+### 2. Flow Efficiency
+
+- Create reusable flow templates
+- Use checkpoints for long flows
+- Parallelize independent steps
+- Cache flow results
+
+### 3. Cascade Optimization
+
+- Use appropriate model sizes
+- Batch similar requests
+- Cache common queries
+- Minimize context switches
+
+## Updates
+
+Stay current:
+
+```bash
+# Check for updates
+aiwf ai-tool check windsurf
+
+# Update template
+aiwf ai-tool update windsurf
+
+# Verify integration
+aiwf ai-tool verify windsurf
+```
+
+## Resources
+
+- [Windsurf Documentation](https://windsurf.ai/docs)
+- [AIWF Documentation](https://aiwf.dev/docs)
+- [Cascade AI Guide](https://windsurf.ai/cascade)
+- [Community Forum](https://forum.aiwf.dev/windsurf)
+
+---
+
+*Windsurf Integration Template v1.0.0*

package/claude-code/aiwf/ko/ai-tools/windsurf/config.json

@@ -0,0 +1,29 @@
+{
+  "name": "windsurf",
+  "version": "1.0.0",
+  "description": "Windsurf IDE integration template for AIWF",
+  "compatible_aiwf_version": ">=0.1.0",
+  "features": {
+    "feature_ledger": true,
+    "ai_persona": true,
+    "context_compression": true,
+    "offline_cache": true,
+    "cascade_flow": true
+  },
+  "setup_commands": [],
+  "files_to_copy": [
+    {
+      "source": "template/.windsurf",
+      "destination": ".windsurf"
+    },
+    {
+      "source": "template/windsurf.config.json",
+      "destination": "windsurf.config.json"
+    }
+  ],
+  "settings": {
+    "aiwf_cascade_integration": true,
+    "feature_flow_tracking": true,
+    "ai_persona_switching": true
+  }
+}

package/claude-code/aiwf/ko/ai-tools/windsurf/template/.windsurf/aiwf-rules.md

@@ -0,0 +1,260 @@
+# Windsurf AIWF Integration Rules
+
+## Overview
+
+These rules configure Windsurf IDE to work seamlessly with the AI Workflow Framework (AIWF), leveraging Windsurf's Cascade AI and flow-based development features.
+
+## Core Integration Principles
+
+### 1. Feature-Driven Flow
+
+Every development flow in Windsurf should:
+- Start with Feature Ledger validation
+- Reference feature IDs throughout the flow
+- Update feature status upon completion
+- Maintain feature dependency tracking
+
+### 2. Cascade + AIWF Synergy
+
+Leverage Cascade AI with AIWF context:
+- Cascade understands Feature Ledger structure
+- AI suggestions align with current sprint tasks
+- Persona-based responses for different contexts
+- Automatic context compression for large files
+
+### 3. Sprint Task Flow
+
+Windsurf flows are aligned with sprint tasks:
+- Each flow corresponds to a sprint task
+- Task status updates automatically
+- Acceptance criteria guide the flow
+- Progress tracked in real-time
+
+## Windsurf-Specific Features
+
+### 1. Cascade Prompts with AIWF Context
+
+```
+@cascade implement feature FL-001 following the ledger specification
+
+@cascade using architect persona, design the system architecture
+
+@cascade check current sprint tasks and suggest next steps
+```
+
+### 2. Flow Templates
+
+**Feature Implementation Flow**:
+1. Check Feature Ledger
+2. Verify dependencies
+3. Implement with tests
+4. Update documentation
+5. Complete task status
+
+**Sprint Task Flow**:
+1. Load task details
+2. Review acceptance criteria
+3. Implement solution
+4. Run tests
+5. Update task log
+
+### 3. Multi-Agent Collaboration
+
+Different Cascade agents for different personas:
+- **Architect Agent**: System design and patterns
+- **Developer Agent**: Implementation and optimization
+- **Reviewer Agent**: Code quality and security
+- **Tester Agent**: Test scenarios and validation
+
+## Code Generation Rules
+
+### Feature Reference Pattern
+
+```javascript
+/**
+ * @flow Feature Implementation
+ * @feature FL-XXX - Feature Name
+ * @sprint S##
+ * @task T##_S##
+ * @cascade-model cascade-large
+ */
+
+import { FeatureLedger } from '@aiwf/core';
+
+class FeatureImplementation {
+  featureId = 'FL-XXX';
+  
+  constructor() {
+    this.validateWithLedger();
+  }
+  
+  async validateWithLedger() {
+    const ledger = new FeatureLedger();
+    const feature = await ledger.getFeature(this.featureId);
+    // Validate implementation against specification
+  }
+}
+```
+
+### Flow Metadata
+
+```javascript
+// @flow-start Task Implementation
+// @windsurf-flow-id: T##_S##
+// @aiwf-context: {
+//   "feature": "FL-XXX",
+//   "sprint": "S##",
+//   "persona": "developer"
+// }
+
+// Implementation follows...
+
+// @flow-end Update task status to completed
+```
+
+## Cascade Configuration
+
+### Model Selection by Task Type
+
+```javascript
+// @cascade-config
+{
+  "feature_design": {
+    "model": "cascade-architect",
+    "persona": "architect",
+    "context": ["feature-ledger", "adrs"]
+  },
+  "implementation": {
+    "model": "cascade-large",
+    "persona": "developer",
+    "context": ["current-task", "related-features"]
+  },
+  "review": {
+    "model": "cascade-reviewer",
+    "persona": "reviewer",
+    "context": ["code-changes", "test-results"]
+  }
+}
+```
+
+## Context Management
+
+### Automatic Compression
+
+Files over 1000 lines are automatically compressed:
+
+```javascript
+// @windsurf-compress auto
+// Large file will be compressed for context efficiency
+// Original: 5000 lines -> Compressed: 500 tokens
+```
+
+### Feature Context Loading
+
+```javascript
+// @load-feature FL-001
+// Automatically loads feature specification into context
+
+// @load-sprint-context
+// Loads current sprint and active tasks
+
+// @load-persona architect
+// Switches to architect persona context
+```
+
+## Workflow Automation
+
+### Task Status Updates
+
+```javascript
+// @auto-task-status
+// Windsurf automatically updates task status based on:
+// - File saves (in_progress)
+// - Test completion (testing)
+// - All tests passing (review)
+// - PR merged (done)
+```
+
+### Documentation Sync
+
+```javascript
+// @auto-doc-sync
+// Changes to implementation automatically update:
+// - Feature documentation
+// - API documentation  
+// - README files
+// - ADRs if architectural changes
+```
+
+## Best Practices
+
+### 1. Flow Initialization
+
+Always start flows with:
+```
+@cascade init-aiwf-flow --task T##_S## --feature FL-XXX
+```
+
+### 2. Context Optimization
+
+Keep context focused:
+- Load only relevant features
+- Use compressed versions of large files
+- Reference by ID when possible
+- Clear context between major tasks
+
+### 3. Persona Switching
+
+Use appropriate personas:
+```
+@cascade switch-persona architect
+// For design decisions
+
+@cascade switch-persona developer  
+// For implementation
+
+@cascade switch-persona reviewer
+// For code review
+```
+
+### 4. Progress Tracking
+
+Maintain flow progress:
+```
+@cascade flow-progress
+// Shows current task progress and remaining steps
+
+@cascade flow-checkpoint
+// Saves current state for later continuation
+```
+
+## Integration Commands
+
+Quick commands for Windsurf command palette:
+
+- `AIWF: Check Feature` - Validate against Feature Ledger
+- `AIWF: Update Task` - Update current task status
+- `AIWF: Switch Persona` - Change active AI persona
+- `AIWF: Compress Context` - Compress current file
+- `AIWF: Load Sprint` - Load current sprint context
+- `AIWF: Flow Status` - Show current flow progress
+
+## Prohibited Actions
+
+- NO skipping Feature Ledger validation
+- NO implementing without task assignment
+- NO merging without updating task status
+- NO ignoring sprint boundaries
+- NO bypassing test requirements
+
+## Windsurf + AIWF Advantages
+
+1. **Flow-Based Development**: Natural alignment with AIWF's structured approach
+2. **Multi-Agent Support**: Different AI agents for different personas
+3. **Visual Progress**: See task progress in Windsurf's flow view
+4. **Automatic Context**: Smart context loading based on current work
+5. **Integrated Testing**: Test flows integrated with task completion
+
+---
+
+*Windsurf AIWF Integration Rules v1.0.0*