appiq-solution 1.2.0 → 1.3.0

package/#Tools/APPIQ-METHOD/deployment/build/slash-commands/ide-integrations/windsurf-appiq.md

@@ -0,0 +1,698 @@
+# Windsurf IDE Integration - Universal APPIQ Method
+
+## Implementation für Windsurf IDE
+
+Die APPIQ Method Commands in Windsurf unterstützen alle Projekttypen: Web, Desktop, Mobile und Backend Development mit intelligenter Projekt-Erkennung und nahtloser Integration in Windsurf's AI-powered Development Environment.
+
+## Verfügbare Commands
+
+### `/start` - Universal Project Launcher (EMPFOHLEN)
+```yaml
+command: /start
+description: Universal APPIQ Method Launcher mit intelligenter Projekt-Erkennung
+category: Development
+supported_projects: [web, desktop, mobile, backend]
+```
+
+### `/appiq` - Universal Project Launcher (Legacy-Support)
+```yaml
+command: /appiq
+description: Universeller APPIQ Method Launcher (erweitert von Mobile-only)
+category: Development
+supported_projects: [web, desktop, mobile, backend]
+legacy_support: true
+```
+
+## Integration Strategy
+
+### Chat-Based Implementation
+Windsurf's AI chat interface ist perfekt für den interaktiven APPIQ Method Workflow mit intelligenter Projekt-Erkennung.
+
+### Universal Project Context Integration
+Leverages Windsurf's project understanding für automatische Detection aller Projekttypen (Web, Desktop, Mobile, Backend).
+
+## Chat Command Implementation
+
+### Universal Command Recognition
+```typescript
+// Windsurf universal command detection
+const APPIQ_COMMAND_PATTERNS = {
+  start: /^\/start(?:\s+(.*))?$/i,
+  appiq: /^\/appiq(?:\s+(.*))?$/i
+};
+
+function handleChatMessage(message: string, context: WindsurfContext): WindsurfResponse {
+  if (APPIQ_COMMAND_PATTERNS.start.test(message) || APPIQ_COMMAND_PATTERNS.appiq.test(message)) {
+    return initializeUniversalAppiqWorkflow(context);
+  }
+  return null;
+}
+```
+
+### Universal State Management
+```typescript
+interface WindsurfUniversalAppiqSession {
+  sessionId: string;
+  projectPath: string;
+  projectContext: WindsurfProjectContext;
+  state: {
+    projectType: 'greenfield' | 'brownfield' | null;
+    applicationCategory: 'web' | 'desktop' | 'mobile' | 'backend' | 'auto-detect' | null;
+    platform?: 'flutter' | 'react-native' | 'electron' | 'react' | 'vue' | 'angular';
+    framework?: string;
+    currentStep: AppiqStep;
+    detectedProject?: ProjectDetection;
+  };
+  chatHistory: ChatMessage[];
+}
+
+enum AppiqStep {
+  PROJECT_STATUS = 'project-status',
+  PROJECT_TYPE = 'project-type', 
+  AUTO_DETECTION = 'auto-detection',
+  PLATFORM_SELECTION = 'platform-selection',
+  WORKFLOW_LAUNCH = 'workflow-launch'
+}
+
+interface ProjectDetection {
+  type: 'web' | 'desktop' | 'mobile' | 'backend' | 'unknown';
+  framework: string;
+  platform?: string;
+  confidence: number;
+  indicators: string[];
+}
+```
+
+### Universal Workflow Implementation
+
+#### Welcome and Universal Project Analysis
+```typescript
+class WindsurfUniversalAppiqHandler {
+  constructor(private context: WindsurfContext) {}
+  
+  async initializeWorkflow(): Promise<WindsurfResponse> {
+    // Analyze current project structure for all types
+    const projectAnalysis = await this.analyzeUniversalProject();
+    
+    const welcomeMessage = this.createUniversalWelcomeMessage(projectAnalysis);
+    
+    return {
+      message: welcomeMessage,
+      actions: [
+        { type: 'highlight-files', files: this.getRelevantFiles(projectAnalysis) },
+        { type: 'set-context', context: { appiq_active: true, project_type: 'universal' } }
+      ]
+    };
+  }
+  
+  private createUniversalWelcomeMessage(analysis: UniversalProjectAnalysis): string {
+    let message = `🚀 **APPIQ Method Universal Launcher**\n\n`;
+    
+    if (analysis.detectedProject) {
+      message += `🔍 **Project Analysis Results:**\n`;
+      message += `- Detected: ${analysis.detectedProject.type} ${analysis.detectedProject.framework}\n`;
+      message += `- Confidence: ${Math.round(analysis.detectedProject.confidence * 100)}%\n`;
+      message += `- Indicators: ${analysis.detectedProject.indicators.join(', ')}\n\n`;
+    }
+    
+    message += `Arbeiten wir an einem neuen oder bestehenden Projekt?\n\n`;
+    message += `**1.** 🆕 Neues Projekt (Greenfield) - Wir bauen von Grund auf\n`;
+    message += `**2.** 🔧 Bestehendes Projekt (Brownfield) - Wir erweitern/verbessern etwas\n\n`;
+    
+    if (analysis.recommendation) {
+      message += `💡 **Recommendation:** ${analysis.recommendation}\n\n`;
+    }
+    
+    message += `Antworte mit **1** oder **2**:`;
+    
+    return message;
+  }
+}
+```
+
+#### Universal Project Analysis Integration
+```typescript
+interface UniversalProjectAnalysis {
+  detectedProject?: ProjectDetection;
+  projectStructure: string;
+  recommendation?: string;
+  confidence: number;
+  supportedWorkflows: string[];
+}
+
+class WindsurfUniversalProjectAnalyzer {
+  async analyzeUniversalProject(projectPath: string): Promise<UniversalProjectAnalysis> {
+    const files = await this.scanProjectFiles(projectPath);
+    const detectedProject = await this.detectProjectType(files, projectPath);
+    
+    if (detectedProject.type !== 'unknown') {
+      return {
+        detectedProject,
+        projectStructure: this.getProjectStructureDescription(detectedProject),
+        recommendation: this.getRecommendation(detectedProject),
+        confidence: detectedProject.confidence,
+        supportedWorkflows: this.getSupportedWorkflows(detectedProject.type)
+      };
+    }
+    
+    return {
+      projectStructure: 'Projekttyp nicht automatisch erkennbar',
+      recommendation: 'Wir führen Sie durch die manuelle Auswahl',
+      confidence: 0.5,
+      supportedWorkflows: ['universal-launcher']
+    };
+  }
+  
+  private async detectProjectType(files: string[], projectPath: string): Promise<ProjectDetection> {
+    const indicators: string[] = [];
+    
+    // Flutter Detection
+    if (files.includes('pubspec.yaml')) {
+      return {
+        type: 'mobile',
+        framework: 'Flutter',
+        platform: 'flutter',
+        confidence: 0.95,
+        indicators: ['pubspec.yaml', 'Dart project structure']
+      };
+    }
+    
+    // Package.json Analysis
+    if (files.includes('package.json')) {
+      const packageJson = await this.readPackageJson(projectPath);
+      
+      // Electron Detection
+      if (packageJson.dependencies?.electron || packageJson.devDependencies?.electron) {
+        return {
+          type: 'desktop',
+          framework: 'Electron',
+          platform: 'electron',
+          confidence: 0.90,
+          indicators: ['electron dependency', 'desktop app structure']
+        };
+      }
+      
+      // React Native Detection
+      if (this.hasReactNativeDependencies(packageJson)) {
+        return {
+          type: 'mobile',
+          framework: 'React Native',
+          platform: 'react-native',
+          confidence: 0.90,
+          indicators: ['react-native dependencies', 'mobile app structure']
+        };
+      }
+      
+      // Web Framework Detection
+      const webFramework = this.detectWebFramework(packageJson);
+      if (webFramework) {
+        return {
+          type: 'web',
+          framework: webFramework.name,
+          platform: webFramework.platform,
+          confidence: webFramework.confidence,
+          indicators: [`${webFramework.name} dependencies`, 'web app structure']
+        };
+      }
+      
+      // Backend Detection
+      const backendFramework = this.detectBackendFramework(packageJson);
+      if (backendFramework) {
+        return {
+          type: 'backend',
+          framework: backendFramework.name,
+          platform: backendFramework.platform,
+          confidence: backendFramework.confidence,
+          indicators: [`${backendFramework.name} dependencies`, 'backend service structure']
+        };
+      }
+    }
+    
+    // Python Backend Detection
+    if (files.includes('requirements.txt')) {
+      const pythonFramework = await this.detectPythonFramework(projectPath);
+      if (pythonFramework) {
+        return {
+          type: 'backend',
+          framework: pythonFramework,
+          confidence: 0.85,
+          indicators: ['requirements.txt', 'Python backend structure']
+        };
+      }
+    }
+    
+    // Java Backend Detection
+    if (files.includes('pom.xml') || files.includes('build.gradle')) {
+      const javaFramework = files.includes('pom.xml') ? 'Maven/Spring' : 'Gradle/Spring';
+      return {
+        type: 'backend',
+        framework: javaFramework,
+        confidence: 0.80,
+        indicators: ['Java build configuration', 'backend service structure']
+      };
+    }
+    
+    return {
+      type: 'unknown',
+      framework: 'Unknown',
+      confidence: 0,
+      indicators: []
+    };
+  }
+}
+```
+
+#### Universal Project Type Selection
+```typescript
+private async handleProjectTypeSelection(input: string, session: WindsurfUniversalAppiqSession): Promise<WindsurfResponse> {
+  const validInputs = ['1', '2', '3', '4', '5'];
+  
+  if (!validInputs.includes(input)) {
+    return this.showInvalidResponse(this.createProjectTypeSelectionMessage());
+  }
+  
+  switch (input) {
+    case '1':
+      session.state.applicationCategory = 'web';
+      return this.proceedToWorkflowLaunch(session);
+    case '2':
+      session.state.applicationCategory = 'desktop';
+      return this.proceedToWorkflowLaunch(session);
+    case '3':
+      session.state.applicationCategory = 'mobile';
+      return this.handleMobilePlatformSelection(session);
+    case '4':
+      session.state.applicationCategory = 'backend';
+      return this.proceedToWorkflowLaunch(session);
+    case '5':
+      return this.showAutoDetection(session);
+  }
+}
+
+private createProjectTypeSelectionMessage(): string {
+  return `📋 **Lass mich verstehen, was wir bauen...**
+
+Was für eine Art von Anwendung ist das?
+
+**1.** 🌐 Web-Anwendung (läuft im Browser)
+**2.** 💻 Desktop-Anwendung (Electron, Windows/Mac App)
+**3.** 📱 Mobile App (iOS/Android)
+**4.** ⚙️ Backend/API Service (Server, Database)
+**5.** 🤔 Bin mir nicht sicher - lass APPIQ entscheiden
+
+Antworte mit **1**, **2**, **3**, **4** oder **5**:`;
+}
+
+private async showAutoDetection(session: WindsurfUniversalAppiqSession): Promise<WindsurfResponse> {
+  if (session.state.projectType === 'brownfield') {
+    // Brownfield: Analyze existing project
+    const detection = await this.analyzeExistingProject(session.projectPath);
+    session.state.detectedProject = detection;
+    
+    if (detection.type !== 'unknown') {
+      session.state.applicationCategory = detection.type;
+      if (detection.platform) {
+        session.state.platform = detection.platform;
+      }
+      
+      return {
+        message: `🎯 **Erkannt: ${this.getProjectTypeDisplayName(detection.type)} (${detection.framework})**\n\nConfidence: ${Math.round(detection.confidence * 100)}%\nIndicators: ${detection.indicators.join(', ')}\n\nSoll ich mit diesem Projekttyp fortfahren? (yes/no)`,
+        actions: [
+          { type: 'highlight-detected-files', files: this.getDetectionFiles(detection) }
+        ]
+      };
+    }
+  }
+  
+  // Greenfield: Ask for description
+  return {
+    message: `🔍 **Lass uns gemeinsam herausfinden, was das beste für dein Projekt ist...**
+
+Beschreibe kurz dein Projekt in 1-2 Sätzen:
+(z.B. "Eine E-Commerce Website mit Admin-Panel" oder "Eine Todo-App für Windows")
+
+Basierend auf deiner Beschreibung erkenne ich automatisch den Projekttyp.`,
+    actions: [
+      { type: 'set-input-mode', mode: 'project-description' }
+    ]
+  };
+}
+```
+
+### Universal Workflow Launch with Windsurf Features
+
+```typescript
+class WindsurfUniversalWorkflowLauncher {
+  async launchWorkflow(session: WindsurfUniversalAppiqSession): Promise<WindsurfResponse> {
+    const { projectType, applicationCategory, platform } = session.state;
+    
+    const workflowConfig = this.getUniversalWorkflowConfig(projectType, applicationCategory, platform);
+    const launchMessage = this.generateUniversalLaunchMessage(workflowConfig);
+    
+    // Set up Windsurf project context
+    await this.setupWindsurfUniversalContext(session, workflowConfig);
+    
+    return {
+      message: launchMessage,
+      actions: [
+        { type: 'set-workflow', workflow: workflowConfig.id },
+        { type: 'create-task-list', tasks: workflowConfig.steps },
+        { type: 'highlight-next-action', action: workflowConfig.firstStep },
+        { type: 'open-relevant-files', files: workflowConfig.relevantFiles }
+      ]
+    };
+  }
+  
+  private getUniversalWorkflowConfig(projectType: string, category: string, platform?: string): UniversalWorkflowConfig {
+    const workflowMapping = {
+      // Greenfield Workflows
+      'greenfield-web': 'greenfield-fullstack.yaml',
+      'greenfield-desktop': 'greenfield-fullstack.yaml',
+      'greenfield-mobile-flutter': 'mobile-greenfield-flutter.yaml',
+      'greenfield-mobile-react-native': 'mobile-greenfield-react-native.yaml',
+      'greenfield-backend': 'greenfield-service.yaml',
+      
+      // Brownfield Workflows
+      'brownfield-web': 'brownfield-fullstack.yaml',
+      'brownfield-desktop': 'brownfield-fullstack.yaml',
+      'brownfield-mobile-flutter': 'mobile-brownfield-flutter.yaml',
+      'brownfield-mobile-react-native': 'mobile-brownfield-react-native.yaml',
+      'brownfield-backend': 'brownfield-service.yaml'
+    };
+    
+    const workflowKey = platform ? 
+      `${projectType}-${category}-${platform}` : 
+      `${projectType}-${category}`;
+    
+    const workflowFile = workflowMapping[workflowKey];
+    
+    return {
+      id: workflowFile,
+      displayName: this.getWorkflowDisplayName(projectType, category, platform),
+      firstAgent: 'analyst',
+      contextMessage: this.getContextMessage(category, platform),
+      steps: this.getWorkflowSteps(category, projectType),
+      relevantFiles: this.getRelevantFiles(category, platform)
+    };
+  }
+  
+  private generateUniversalLaunchMessage(config: UniversalWorkflowConfig): string {
+    return `✅ **Perfect! ${config.displayName} erkannt.**
+
+🎯 **Starte ${config.displayName}...**
+📍 **Fokus:** ${config.contextMessage}
+📂 **Workflow:** \`${config.id}\`
+🎬 **Erster Agent:** ${config.firstAgent}
+
+**Der Workflow führt Sie durch:**
+${config.steps.map((step, i) => `${i + 1}. ${step}`).join('\n')}
+
+---
+
+**@${config.firstAgent}** - ${this.getAnalystInstructions(config)}`;
+  }
+  
+  private async setupWindsurfUniversalContext(session: WindsurfUniversalAppiqSession, config: UniversalWorkflowConfig): Promise<void> {
+    // Set Windsurf workspace context for all project types
+    await this.windsurf.workspace.setContext({
+      appiq_workflow: config.id,
+      project_category: session.state.applicationCategory,
+      platform: session.state.platform,
+      project_type: session.state.projectType,
+      workflow_step: 1,
+      expected_outputs: config.expectedOutputs
+    });
+    
+    // Create universal task tracking
+    await this.windsurf.tasks.create({
+      title: `APPIQ Method - ${config.displayName}`,
+      steps: config.steps.map(step => ({ description: step, completed: false })),
+      category: session.state.applicationCategory,
+      dueDate: this.calculateEstimatedCompletion(config)
+    });
+  }
+  
+  private getWorkflowDisplayName(projectType: string, category: string, platform?: string): string {
+    const typeDisplay = projectType.charAt(0).toUpperCase() + projectType.slice(1);
+    const categoryDisplayMap = {
+      web: "Web-Anwendung",
+      desktop: "Desktop-Anwendung", 
+      mobile: platform === 'flutter' ? "Flutter Mobile App" : "React Native Mobile App",
+      backend: "Backend Service"
+    };
+    
+    const categoryDisplay = categoryDisplayMap[category] || "Anwendung";
+    const actionType = typeDisplay === 'Greenfield' ? 'Development' : 'Enhancement';
+    
+    return `${categoryDisplay} ${actionType}`;
+  }
+}
+```
+
+### Universal Windsurf-Specific Features
+
+#### Smart File Navigation für alle Projekttypen
+```typescript
+class WindsurfUniversalNavigationHelper {
+  async highlightRelevantFiles(category: string, platform?: string): Promise<string[]> {
+    const relevantFiles = [];
+    
+    switch (category) {
+      case 'web':
+        relevantFiles.push(
+          'package.json',
+          'src/**/*.tsx',
+          'src/**/*.ts',
+          'src/**/*.jsx',
+          'src/**/*.js',
+          'public/**/*',
+          'components/**/*'
+        );
+        break;
+        
+      case 'desktop':
+        relevantFiles.push(
+          'package.json',
+          'src/**/*.tsx',
+          'src/**/*.ts',
+          'main.js',
+          'main.ts',
+          'electron/**/*'
+        );
+        break;
+        
+      case 'mobile':
+        if (platform === 'flutter') {
+          relevantFiles.push(
+            'pubspec.yaml',
+            'lib/main.dart',
+            'lib/**/*.dart',
+            'test/**/*.dart',
+            'android/**/*',
+            'ios/**/*'
+          );
+        } else if (platform === 'react-native') {
+          relevantFiles.push(
+            'package.json',
+            'src/**/*.tsx',
+            'src/**/*.ts',
+            '__tests__/**/*.test.ts',
+            'android/**/*',
+            'ios/**/*'
+          );
+        }
+        break;
+        
+      case 'backend':
+        relevantFiles.push(
+          'package.json',
+          'src/**/*.ts',
+          'src/**/*.js',
+          'requirements.txt',
+          'pom.xml',
+          'build.gradle',
+          'config/**/*',
+          'migrations/**/*'
+        );
+        break;
+    }
+    
+    // Common files for all project types
+    relevantFiles.push(
+      'docs/**/*.md',
+      'README.md',
+      '.env*',
+      'docker*',
+      'Dockerfile'
+    );
+    
+    return relevantFiles;
+  }
+}
+```
+
+#### Universal Progress Tracking
+```typescript
+class WindsurfUniversalProgressTracker {
+  async updateWorkflowProgress(step: string, completed: boolean, category: string): Promise<void> {
+    await this.windsurf.progress.update({
+      workflowId: `appiq-${category}-development`,
+      currentStep: step,
+      completed,
+      nextActions: this.getNextActions(step, category)
+    });
+  }
+  
+  async showProgressSidebar(category: string): Promise<void> {
+    const categoryDisplayMap = {
+      web: 'Web Development',
+      desktop: 'Desktop Development',
+      mobile: 'Mobile Development',
+      backend: 'Backend Development'
+    };
+    
+    await this.windsurf.sidebar.show('appiq-progress', {
+      title: `APPIQ Method ${categoryDisplayMap[category]} Progress`,
+      content: this.generateProgressHTML(category)
+    });
+  }
+}
+```
+
+## Universal Usage in Windsurf
+
+### Chat-Based Interaction Examples
+
+#### Web Application Example
+```
+User: /start
+
+🚀 APPIQ Method Universal Launcher
+
+🔍 Project Analysis Results:
+- Detected: web React
+- Confidence: 90%
+- Indicators: react dependency, web app structure
+
+Arbeiten wir an einem neuen oder bestehenden Projekt?
+
+1. 🆕 Neues Projekt (Greenfield)
+2. 🔧 Bestehendes Projekt (Brownfield)
+
+User: 2
+
+📋 Lass mich verstehen, was wir bauen...
+
+Was für eine Art von Anwendung ist das?
+
+1. 🌐 Web-Anwendung
+2. 💻 Desktop-Anwendung
+3. 📱 Mobile App
+4. ⚙️ Backend/API Service
+5. 🤔 Bin mir nicht sicher
+
+User: 1
+
+✅ Perfect! Web-Anwendung Enhancement erkannt.
+
+🎯 Starte Web-Anwendung Enhancement...
+📍 Fokus: Full-Stack Web-Anwendung mit Frontend und Backend Komponenten
+📂 Workflow: brownfield-fullstack.yaml
+🎬 Erster Agent: analyst
+
+[Windsurf opens relevant files and creates task tracking]
+```
+
+#### Desktop Application Example
+```
+User: /appiq
+
+User: 1 (Neues Projekt)
+User: 2 (Desktop-Anwendung)
+
+✅ Perfect! Desktop-Anwendung Development erkannt.
+
+🎯 Starte Desktop-Anwendung Development...
+📍 Fokus: Electron Desktop-Anwendung mit plattformspezifischen Optimierungen
+📂 Workflow: greenfield-fullstack.yaml
+🎬 Erster Agent: analyst
+
+Der Workflow führt Sie durch:
+1. Desktop-App Konzeption
+2. Electron-spezifische Requirements
+3. Cross-Platform UI Design
+4. Desktop-Architektur
+5. Platform-spezifische Implementierung
+
+@analyst - Bitte erstelle einen Projekt-Brief für die Desktop-Anwendung...
+```
+
+### Integration mit Windsurf Features
+
+1. **Smart File Navigation**: Automatisch highlights relevante Files für alle Projekttypen
+2. **Universal Task Tracking**: Erstellt project tasks für alle Workflow-Typen
+3. **Progress Monitoring**: Zeigt Workflow-Progress für Web/Desktop/Mobile/Backend
+4. **Context Awareness**: Behält universellen Projekt-Kontext zwischen Sessions
+5. **Intelligent Templates**: Generiert und öffnet relevante Templates basierend auf Projekttyp
+
+### Advanced Universal Features
+
+#### Enhanced Auto-Detection für alle Projekttypen
+```typescript
+async detectUniversalProjectDetails(): Promise<UniversalProjectDetails> {
+  const analysis = await this.windsurf.ai.analyzeProject({
+    includeFiles: ['package.json', 'pubspec.yaml', 'requirements.txt', 'pom.xml', 'build.gradle'],
+    analysisType: 'universal-project-detection'
+  });
+  
+  return {
+    projectType: analysis.detectedType,
+    framework: analysis.framework,
+    platform: analysis.platform,
+    confidence: analysis.confidence,
+    recommendations: analysis.recommendations,
+    supportedWorkflows: analysis.availableWorkflows
+  };
+}
+```
+
+#### Intelligent Universal Workflow Suggestions
+```typescript
+async suggestUniversalWorkflow(projectContext: UniversalProjectContext): Promise<UniversalWorkflowSuggestion> {
+  const suggestion = await this.windsurf.ai.suggest({
+    context: projectContext,
+    domain: 'universal-development',
+    supportedTypes: ['web', 'desktop', 'mobile', 'backend'],
+    goal: 'optimize-development-workflow'
+  });
+  
+  return {
+    recommendedWorkflow: suggestion.workflow,
+    projectCategory: suggestion.category,
+    reasoning: suggestion.reasoning,
+    alternativeOptions: suggestion.alternatives,
+    estimatedDuration: suggestion.timeline
+  };
+}
+```
+
+## Best Practices für Windsurf Integration
+
+### Performance Optimierungen
+```typescript
+interface WindsurfUniversalPerformanceConfig {
+  lazyLoading: boolean;          // Lade Workflows nur bei Bedarf
+  cacheDetection: boolean;       // Cache Universal-Projekt-Erkennung
+  batchOperations: boolean;      // Batch File-System-Operationen
+  intelligentPreload: boolean;   // Preload basierend auf Projekt-Patterns
+  universalContext: boolean;     // Universeller Context für alle Projekttypen
+}
+```
+
+### User Experience Enhancements
+- **Universal Progress Indicators**: Zeige Fortschritt für alle Projekttypen
+- **Smart Suggestions**: Basierend auf erkannten Universal-Patterns
+- **Context Preservation**: Behalte Universal-Workflow-Kontext zwischen Sessions
+- **Intelligent Error Recovery**: Universal fallback bei Detection-Fehlern für alle Projekttypen
+
+Diese Implementation bietet eine nahtlose Experience mit Windsurf's AI-powered Development Environment und unterstützt alle Projekttypen (Web, Desktop, Mobile, Backend) mit intelligenter Universal-Erkennung und optimaler Integration in bestehende Windsurf Features.