aiwf 0.3.7 → 0.3.12

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

@@ -1,260 +0,0 @@
-# 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/claude-code/aiwf/ko/ai-tools/windsurf/template/.windsurf/windsurf.config.js

@@ -1,312 +0,0 @@
-/**
- * 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/claude-code/aiwf/ko/ai-tools/windsurf/template/windsurf.config.json

@@ -1,63 +0,0 @@
-{
-  "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
-    }
-  }
-}