aiwf 0.3.0 → 0.3.2

package/.aiwf/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*

package/.aiwf/ai-tools/windsurf/template/.windsurf/windsurf.config.js

@@ -0,0 +1,312 @@
+/**
+ * Windsurf AI Configuration for AIWF Projects
+ * 
+ * This configuration enables Windsurf to understand and work with
+ * the AI Workflow Framework (AIWF) structure and conventions.
+ */
+
+module.exports = {
+  // Project context
+  projectType: 'aiwf',
+  frameworkVersion: '1.0.0',
+  
+  // AIWF structure recognition
+  projectStructure: {
+    root: '.aiwf',
+    features: '.aiwf/06_FEATURE_LEDGERS',
+    sprints: '.aiwf/03_SPRINTS',
+    personas: '.aiwf/personas',
+    templates: '.aiwf/99_TEMPLATES'
+  },
+  
+  // Code generation patterns
+  patterns: {
+    // Feature-based patterns
+    feature: {
+      template: 'aiwf-feature',
+      metadata: ['featureId', 'taskId', 'sprintId', 'persona'],
+      validation: 'always',
+      documentation: 'required'
+    },
+    
+    // Service patterns
+    service: {
+      template: 'aiwf-service',
+      includes: ['feature-validation', 'error-handling', 'logging'],
+      baseClass: 'AiwfService'
+    },
+    
+    // Component patterns
+    component: {
+      template: 'aiwf-component',
+      style: 'functional',
+      hooks: ['useFeature', 'useTask', 'usePersona']
+    }
+  },
+  
+  // Context providers
+  contextProviders: [
+    {
+      name: 'featureLedger',
+      path: '.aiwf/06_FEATURE_LEDGERS',
+      parser: 'markdown',
+      cache: true
+    },
+    {
+      name: 'currentSprint',
+      path: '.aiwf/03_SPRINTS',
+      parser: 'aiwf-sprint',
+      watch: true
+    },
+    {
+      name: 'activePersona',
+      path: '.aiwf/current_persona.json',
+      parser: 'json',
+      watch: true
+    }
+  ],
+  
+  // Code suggestions behavior
+  suggestions: {
+    // Prioritize AIWF patterns
+    priorityPatterns: [
+      'feature-reference',
+      'task-implementation',
+      'sprint-alignment',
+      'persona-specific'
+    ],
+    
+    // Auto-include metadata
+    autoInclude: {
+      featureId: true,
+      taskId: true,
+      persona: true,
+      timestamp: false
+    },
+    
+    // Validation rules
+    validation: {
+      requireFeatureId: true,
+      checkFeatureStatus: true,
+      validateTaskAlignment: true
+    }
+  },
+  
+  // Persona-specific configurations
+  personas: {
+    architect: {
+      focus: ['design-patterns', 'architecture', 'scalability'],
+      suggestions: ['interfaces', 'abstractions', 'patterns'],
+      documentation: 'extensive'
+    },
+    security: {
+      focus: ['validation', 'sanitization', 'authentication'],
+      suggestions: ['security-checks', 'audit-logging', 'encryption'],
+      warnings: 'aggressive'
+    },
+    frontend: {
+      focus: ['ui-components', 'user-experience', 'performance'],
+      suggestions: ['react-patterns', 'optimization', 'accessibility'],
+      style: 'modern'
+    },
+    backend: {
+      focus: ['api-design', 'data-flow', 'scalability'],
+      suggestions: ['rest-patterns', 'database-optimization', 'caching'],
+      testing: 'comprehensive'
+    },
+    data_analyst: {
+      focus: ['data-processing', 'visualization', 'insights'],
+      suggestions: ['pandas-patterns', 'chart-types', 'statistics'],
+      documentation: 'detailed'
+    }
+  },
+  
+  // Integration with AIWF commands
+  commands: {
+    // Feature operations
+    'Create Feature': {
+      command: 'aiwf ledger create',
+      shortcut: 'ctrl+shift+f',
+      context: 'always'
+    },
+    'Update Task': {
+      command: 'aiwf task update',
+      shortcut: 'ctrl+shift+t',
+      context: 'in-task'
+    },
+    'Switch Persona': {
+      command: 'aiwf persona use',
+      shortcut: 'ctrl+shift+p',
+      context: 'always'
+    }
+  },
+  
+  // Code templates
+  templates: {
+    // Feature implementation template
+    'aiwf-feature': `/**
+ * @feature {{featureId}} - {{featureName}}
+ * @task {{taskId}} - {{taskName}}
+ * @sprint {{sprintId}}
+ * @persona {{activePersona}}
+ */
+
+import { FeatureLedger, TaskManager } from '@aiwf/core';
+
+export class {{className}} {
+  constructor(
+    private ledger: FeatureLedger,
+    private taskManager: TaskManager
+  ) {
+    this.validateFeature();
+  }
+  
+  private async validateFeature() {
+    const feature = await this.ledger.getFeature('{{featureId}}');
+    if (feature.status !== 'active') {
+      throw new Error(\`Feature {{featureId}} is not active\`);
+    }
+  }
+  
+  // Implementation here
+}`,
+    
+    // Service template
+    'aiwf-service': `/**
+ * {{serviceName}} Service
+ * @feature {{featureId}}
+ * @layer service
+ */
+
+import { BaseService } from '@aiwf/core';
+import { Logger } from '@aiwf/logging';
+
+export class {{serviceName}}Service extends BaseService {
+  private logger: Logger;
+  
+  constructor() {
+    super('{{featureId}}');
+    this.logger = new Logger('{{serviceName}}Service');
+  }
+  
+  // Service methods
+}`,
+    
+    // Test template
+    'aiwf-test': `/**
+ * Tests for {{featureName}}
+ * @feature {{featureId}}
+ * @task {{taskId}}
+ */
+
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { {{className}} } from './{{fileName}}';
+
+describe('Feature {{featureId}}: {{featureName}}', () => {
+  describe('Task {{taskId}}: {{taskName}}', () => {
+    let instance: {{className}};
+    
+    beforeEach(() => {
+      instance = new {{className}}();
+    });
+    
+    describe('Acceptance Criteria', () => {
+      it('should meet criteria 1', async () => {
+        // Test implementation
+      });
+    });
+  });
+});`
+  },
+  
+  // Import organization
+  importOrganization: {
+    order: [
+      'external',
+      '@aiwf/core',
+      '@aiwf/*',
+      'project',
+      'feature',
+      'relative'
+    ],
+    grouping: true,
+    sorting: 'alphabetical'
+  },
+  
+  // Error handling patterns
+  errorHandling: {
+    style: 'contextual',
+    includeFeatureContext: true,
+    standardErrors: {
+      'FeatureNotActive': 'Feature {{featureId}} is not active',
+      'TaskNotFound': 'Task {{taskId}} not found in sprint {{sprintId}}',
+      'PersonaMismatch': 'Current persona {{current}} does not match required {{required}}'
+    }
+  },
+  
+  // Documentation generation
+  documentation: {
+    style: 'jsdoc',
+    required: ['feature', 'task', 'params', 'returns'],
+    autoGenerate: {
+      feature: true,
+      task: true,
+      sprint: true,
+      persona: true
+    }
+  },
+  
+  // Performance optimization
+  performance: {
+    enableProfiling: true,
+    featureMetrics: true,
+    suggestions: {
+      memoization: true,
+      lazyLoading: true,
+      codeSpitting: true
+    }
+  },
+  
+  // Security patterns
+  security: {
+    enableChecks: true,
+    patterns: {
+      inputValidation: 'always',
+      outputSanitization: 'always',
+      authentication: 'feature-based',
+      authorization: 'role-based'
+    }
+  },
+  
+  // Git integration
+  git: {
+    commitFormat: '{{type}}({{featureId}}): {{message}}',
+    branchFormat: 'feature/{{featureId}}-{{name}}',
+    prTemplate: `## Feature: {{featureId}}
+## Task: {{taskId}}
+## Sprint: {{sprintId}}
+
+### Changes
+- 
+
+### Testing
+- [ ] Unit tests pass
+- [ ] Integration tests pass
+- [ ] Acceptance criteria met
+
+### Documentation
+- [ ] Code documented
+- [ ] Feature ledger updated
+- [ ] Sprint log updated`
+  },
+  
+  // Project-specific overrides
+  projectRules: {
+    // Add your project-specific rules here
+  },
+  
+  // Disabled features
+  disabled: [
+    // Add any features to disable
+  ]
+};

package/.aiwf/ai-tools/windsurf/template/windsurf.config.json

@@ -0,0 +1,63 @@
+{
+  "windsurf": {
+    "version": "1.0.0",
+    "aiwf_integration": {
+      "enabled": true,
+      "feature_ledger": {
+        "path": ".aiwf/feature-ledger/",
+        "auto_reference": true,
+        "validation": true
+      },
+      "personas": {
+        "path": ".aiwf/personas/",
+        "default": "developer",
+        "auto_switch": true
+      },
+      "sprints": {
+        "path": ".aiwf/03_SPRINTS/",
+        "track_progress": true,
+        "task_integration": true
+      },
+      "context": {
+        "compression_threshold": 1000,
+        "auto_compress": true,
+        "cache_compressed": true
+      }
+    },
+    "cascade_settings": {
+      "aiwf_aware": true,
+      "feature_suggestions": true,
+      "task_context": true,
+      "persona_based_flow": true
+    },
+    "workspace": {
+      "feature_first": true,
+      "sprint_aligned": true,
+      "documentation_sync": true
+    },
+    "ai_settings": {
+      "model_preferences": {
+        "fast_tasks": "cascade-small",
+        "complex_tasks": "cascade-large",
+        "architecture": "cascade-architect"
+      },
+      "context_management": {
+        "max_tokens": 100000,
+        "compression_enabled": true,
+        "feature_context_priority": true
+      }
+    },
+    "shortcuts": {
+      "check_feature": "cmd+shift+f",
+      "update_task": "cmd+shift+t",
+      "switch_persona": "cmd+shift+p",
+      "compress_context": "cmd+shift+c"
+    },
+    "automation": {
+      "auto_update_task_status": true,
+      "auto_reference_features": true,
+      "auto_compress_large_files": true,
+      "auto_sync_documentation": true
+    }
+  }
+}

package/.aiwf/config/language.json

@@ -0,0 +1,6 @@
+{
+  "language": "ko",
+  "auto_detect": true,
+  "last_updated": "2025-07-08T15:00:50.870Z",
+  "fallback": "en"
+}

package/.aiwf/feature-ledger/FL-001-authentication.json

@@ -0,0 +1,52 @@
+{
+  "id": "FL-001",
+  "name": "User Authentication System",
+  "description": "Complete user authentication system with JWT tokens, 2FA support, and session management",
+  "status": "implemented",
+  "priority": "high",
+  "created_at": "2025-01-01T00:00:00Z",
+  "updated_at": "2025-01-08T00:00:00Z",
+  "sprint": "S01",
+  "dependencies": [],
+  "specifications": {
+    "requirements": [
+      "JWT-based authentication",
+      "Two-factor authentication support",
+      "Session management with refresh tokens",
+      "Password reset functionality",
+      "Account lockout after failed attempts"
+    ],
+    "api_endpoints": [
+      "POST /auth/login",
+      "POST /auth/logout",
+      "POST /auth/refresh",
+      "POST /auth/forgot-password",
+      "POST /auth/reset-password",
+      "POST /auth/2fa/enable",
+      "POST /auth/2fa/verify"
+    ],
+    "security_considerations": [
+      "Passwords hashed with bcrypt",
+      "JWT tokens expire after 15 minutes",
+      "Refresh tokens expire after 7 days",
+      "Rate limiting on authentication endpoints"
+    ]
+  },
+  "implementation": {
+    "files": [
+      "src/auth/auth.service.js",
+      "src/auth/auth.controller.js",
+      "src/auth/strategies/jwt.strategy.js",
+      "src/auth/guards/auth.guard.js"
+    ],
+    "tests": [
+      "tests/auth/auth.service.test.js",
+      "tests/auth/auth.e2e.test.js"
+    ],
+    "documentation": [
+      "docs/api/authentication.md",
+      "docs/guides/2fa-setup.md"
+    ]
+  },
+  "tags": ["auth", "security", "core"]
+}

package/.aiwf/feature-ledger/feature-index.json

@@ -0,0 +1,20 @@
+{
+  "features": [
+    {
+      "id": "FL-001",
+      "name": "User Authentication System",
+      "status": "implemented",
+      "file": "FL-001-authentication.json"
+    }
+  ],
+  "total_features": 1,
+  "status_summary": {
+    "proposed": 0,
+    "approved": 0,
+    "in_progress": 0,
+    "implemented": 1,
+    "tested": 0,
+    "deployed": 0
+  },
+  "last_updated": "2025-01-08T17:00:00Z"
+}