aiwf 0.3.1 → 0.3.2

package/claude-code/aiwf/ko/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/claude-code/aiwf/ko/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/claude-code/aiwf/ko/bin/aiwf-create.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+import { createProject } from '../scripts/create-project.js';
+import { createProjectOffline, isOnline } from '../scripts/create-offline.js';
+import chalk from 'chalk';
+
+export async function main(args = process.argv.slice(2)) {
+  
+  // 오프라인 모드 체크
+  if (args.includes('--offline')) {
+    console.log(chalk.yellow('⚠️  오프라인 모드로 실행합니다.'));
+    // 오프라인 생성 로직
+    const template = args[0];
+    const projectName = args[1];
+    
+    if (!template || !projectName) {
+      console.log(chalk.red('사용법: aiwf create --offline <template> <project-name>'));
+      process.exit(1);
+    }
+    
+    try {
+      await createProjectOffline(template, projectName, projectName);
+    } catch (error) {
+      console.error(chalk.red('오류:', error.message));
+      process.exit(1);
+    }
+    
+    return;
+  }
+
+  // 네트워크 연결 확인
+  const online = await isOnline();
+  
+  if (!online) {
+    console.log(chalk.yellow('\n⚠️  인터넷 연결을 확인할 수 없습니다.'));
+    console.log(chalk.yellow('오프라인 모드로 전환합니다.\n'));
+    console.log(chalk.gray('온라인 모드를 강제하려면 --online 플래그를 사용하세요.'));
+    
+    // 오프라인 모드로 자동 전환
+    if (!args.includes('--online')) {
+      // 오프라인 프로젝트 생성 로직
+      return;
+    }
+  }
+
+  // 온라인 모드 (대화형)
+  createProject();
+}
+
+// CLI로 직접 실행된 경우에만 main 함수 호출
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(error => {
+    console.error(chalk.red('오류:', error.message));
+    process.exit(1);
+  });
+}

package/claude-code/aiwf/ko/bin/aiwf.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+// AIWF (AI Workflow Framework) Binary
+// This is a wrapper that forwards to the main index.js file
+
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const mainScript = path.join(__dirname, '../../index.js');
+
+// Forward all arguments to the main script
+const args = process.argv.slice(2);
+const command = `node "${mainScript}" ${args.join(' ')}`;
+
+try {
+    execSync(command, { stdio: 'inherit', cwd: process.cwd() });
+} catch (error) {
+    process.exit(error.status || 1);
+}