appiq-solution 1.3.3 → 1.4.3

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

@@ -1,698 +0,0 @@
-# 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.