recoder-code 2.3.0 → 2.3.4

package/plugins/team-collaboration-plugin.js.bak

@@ -0,0 +1,208 @@
+// Team Collaboration Plugin for Recoder
+// Handle chalk properly
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  name: 'team-collaboration',
+  version: '1.0.0',
+  description: 'Enhanced team collaboration features and workflows',
+  author: 'Recoder Team',
+  enabled: true,
+
+  async init() {
+    console.log(chalk.green('✅ Team collaboration plugin initialized'));
+  },
+
+  async cleanup() {
+    console.log('Team collaboration plugin cleaned up');
+  },
+
+  commands: {
+    'team-setup': async (args, context) => {
+      const chat = context.chat;
+      if (!chat.collaborationManager) {
+        return '❌ Collaboration manager not available';
+      }
+
+      let response = '🤝 Team Setup Quick Guide:\n\n';
+      response += '1. Create a team workspace:\n   /workspace create "My Team" "Project description"\n\n';
+      response += '2. Invite team members:\n   /team invite alice\n   /team invite bob\n\n';
+      response += '3. Share your current session:\n   /share session\n\n';
+      response += '4. Start collaborating:\n   /collaborate start\n\n';
+      response += 'Team Features:\n';
+      response += '• Shared conversations across team members\n';
+      response += '• File sharing and collaborative editing\n';
+      response += '• Real-time messaging and notifications\n';
+      response += '• Workspace-based project organization\n';
+      response += '• Session broadcasting and synchronization\n';
+      
+      return response;
+    },
+
+    'quick-share': async (args, context) => {
+      const chat = context.chat;
+      if (!chat.collaborationManager) {
+        return '❌ Collaboration manager not available';
+      }
+
+      // Quick share current conversation
+      const currentConv = chat.getCurrentConversation();
+      const quickSessionData = {
+        name: currentConv.name,
+        model: currentConv.model,
+        conversation: {
+          ...currentConv,
+          created: currentConv.created.toISOString(),
+          lastActive: currentConv.lastActive.toISOString()
+        },
+        timestamp: new Date().toISOString()
+      };
+
+      const sharedId = await chat.collaborationManager.createSharedSession(quickSessionData);
+      return `🚀 Quick share created! ID: ${sharedId}\nShare this with your team: /share join ${sharedId}`;
+    },
+
+    'team-status': async (args, context) => {
+      const chat = context.chat;
+      if (!chat.collaborationManager) {
+        return '❌ Collaboration manager not available';
+      }
+
+      const status = chat.collaborationManager.getCollaborationStatus();
+      const workspaces = chat.collaborationManager.listTeamWorkspaces();
+      const sharedSessions = chat.collaborationManager.listSharedSessions();
+
+      let response = '👥 Team Status Dashboard:\n\n';
+      response += `Collaboration Mode: ${status.mode}\n`;
+      response += `Team Members: ${status.teamMembers.length}\n`;
+      response += `Workspaces: ${workspaces.length}\n`;
+      response += `Shared Sessions: ${sharedSessions.length}\n`;
+
+      if (status.collaborationId) {
+        response += `\n🤝 Active Collaboration: ${status.collaborationId}\n`;
+        response += `Role: ${status.isHost ? 'Host' : 'Participant'}\n`;
+      }
+
+      if (workspaces.length > 0) {
+        response += '\n📁 Recent Workspaces:\n';
+        workspaces.slice(0, 3).forEach(ws => {
+          response += `• ${ws.name} (${ws.members.length} members)\n`;
+        });
+      }
+
+      return response;
+    },
+
+    'sync': async (args, context) => {
+      const chat = context.chat;
+      if (!chat.collaborationManager) {
+        return '❌ Collaboration manager not available';
+      }
+
+      const status = chat.collaborationManager.getCollaborationStatus();
+      if (status.mode === 'none') {
+        return '⚠️  Not in collaboration mode. Use /collaborate start to begin.';
+      }
+
+      // Simulate syncing with team
+      const currentConv = chat.getCurrentConversation();
+      await chat.collaborationManager.broadcastMessage(
+        `Syncing conversation: ${currentConv.name}`,
+        {
+          type: 'sync',
+          conversationId: chat.currentConversationId,
+          messageCount: currentConv.history.length,
+          model: currentConv.model
+        }
+      );
+
+      return '✅ Conversation synced with team';
+    },
+
+    'invite-link': async (args, context) => {
+      const chat = context.chat;
+      if (!chat.collaborationManager) {
+        return '❌ Collaboration manager not available';
+      }
+
+      const workspaceId = args[0];
+      if (!workspaceId) {
+        return '❌ Usage: /invite-link <workspace-id>';
+      }
+
+      // Generate a shareable invitation link (simulated)
+      const inviteCode = require('crypto').randomBytes(6).toString('hex');
+      
+      let response = `🔗 Workspace Invitation Generated!\n\n`;
+      response += `Workspace ID: ${workspaceId}\n`;
+      response += `Invite Code: ${inviteCode}\n\n`;
+      response += `Share this with team members:\n`;
+      response += `"Join our workspace with: /workspace join ${workspaceId}"\n\n`;
+      response += `💡 Tip: Team members can also use /team-setup for guidance`;
+
+      return response;
+    }
+  },
+
+  // Process messages for collaboration suggestions
+  onMessage: async (message, context) => {
+    const lowerMessage = message.toLowerCase();
+    
+    // Suggest collaboration features
+    if (lowerMessage.includes('team') || lowerMessage.includes('collaborate')) {
+      return '💡 Tip: Use /team-setup for collaboration quick start';
+    }
+    
+    if (lowerMessage.includes('share') || lowerMessage.includes('send to')) {
+      return '💡 Tip: Use /quick-share to instantly share current conversation';
+    }
+    
+    if (lowerMessage.includes('workspace') || lowerMessage.includes('project')) {
+      return '💡 Tip: Use /workspace create to set up team workspace';
+    }
+
+    if (lowerMessage.includes('invite') || lowerMessage.includes('add member')) {
+      return '💡 Tip: Use /team invite <username> to add team members';
+    }
+    
+    return null;
+  },
+
+  // Hook into conversation events
+  onResponse: async (response, context) => {
+    const chat = context.chat;
+    
+    // Auto-sync important responses in collaboration mode
+    if (chat.collaborationManager?.getCollaborationStatus().mode !== 'none') {
+      if (response.includes('```') || response.length > 500) {
+        // This is likely code or a significant response
+        console.log(chalk.gray('🔄 Auto-syncing significant response with team'));
+        
+        await chat.collaborationManager.broadcastMessage(
+          'Significant AI response generated',
+          {
+            type: 'ai_response',
+            length: response.length,
+            hasCode: response.includes('```'),
+            conversationId: chat.currentConversationId
+          }
+        );
+      }
+    }
+  },
+
+  hooks: {
+    beforeResponse: async (data) => {
+      // Could add team input processing here
+      return data;
+    },
+    
+    afterResponse: async (data) => {
+      // Could add team notification features here
+      return data;
+    }
+  }
+};

package/plugins/voice-commands-plugin.js

@@ -11,7 +11,7 @@ module.exports = {
   enabled: true,
 
   async init() {
-    console.log(chalk.green('✅ Voice commands plugin initialized'));
+//     console.log(chalk.green('✅ Voice commands plugin initialized'));
   },
 
   async cleanup() {

package/plugins/voice-commands-plugin.js.bak

@@ -0,0 +1,136 @@
+// Voice Commands Plugin for Recoder
+// Handle chalk properly
+const chalkModule = require('chalk');
+const chalk = chalkModule.default || chalkModule;
+
+module.exports = {
+  name: 'voice-commands',
+  version: '1.0.0',
+  description: 'Enhanced voice command processing and shortcuts',
+  author: 'Recoder Team',
+  enabled: true,
+
+  async init() {
+    console.log(chalk.green('✅ Voice commands plugin initialized'));
+  },
+
+  async cleanup() {
+    console.log('Voice commands plugin cleaned up');
+  },
+
+  commands: {
+    listen: async (args, context) => {
+      const chat = context.chat;
+      if (!chat.voiceManager) {
+        return '❌ Voice manager not available';
+      }
+
+      if (!chat.voiceManager.speechToTextEnabled) {
+        return '❌ Speech-to-text not enabled. Use /voice stt on first.';
+      }
+
+      // Start listening mode
+      if (chat.voiceManager.isRecording) {
+        return '⚠️  Already listening. Use /record to stop.';
+      }
+
+      const started = await chat.voiceManager.startRecording();
+      if (started) {
+        return '🎤 Voice listening activated. Press Enter to stop and process.';
+      } else {
+        return '❌ Failed to start voice recording';
+      }
+    },
+
+    quiet: async (args, context) => {
+      const chat = context.chat;
+      if (!chat.voiceManager) {
+        return '❌ Voice manager not available';
+      }
+
+      await chat.voiceManager.stopSpeaking();
+      return '🔇 Voice output stopped';
+    },
+
+    'voice-setup': async (args, context) => {
+      const chat = context.chat;
+      if (!chat.voiceManager) {
+        return '❌ Voice manager not available';
+      }
+
+      const status = chat.voiceManager.getStatus();
+      
+      let response = '🎤 Voice Setup Quick Guide:\n\n';
+      
+      if (!status.textToSpeechEnabled) {
+        response += '🔊 Enable Text-to-Speech: /voice tts on\n';
+      } else {
+        response += '✅ Text-to-Speech is enabled\n';
+      }
+      
+      if (!status.speechToTextEnabled) {
+        response += '🎙️ Enable Speech-to-Text: /voice stt on\n';
+      } else {
+        response += '✅ Speech-to-Text is enabled\n';
+      }
+      
+      response += '\nVoice Commands:\n';
+      response += '• /record - Start/stop voice recording\n';
+      response += '• /speak <text> - Speak text aloud\n';
+      response += '• /listen - Quick voice input\n';
+      response += '• /quiet - Stop current speech\n';
+      response += '• /voice voices - List available voices\n';
+      response += '• /voice set <name> - Change voice\n';
+      
+      return response;
+    }
+  },
+
+  // Process messages for voice-related suggestions
+  onMessage: async (message, context) => {
+    const lowerMessage = message.toLowerCase();
+    
+    // Suggest voice commands for common phrases
+    if (lowerMessage.includes('speak') || lowerMessage.includes('say')) {
+      return '💡 Tip: Use /speak <text> to hear responses aloud';
+    }
+    
+    if (lowerMessage.includes('listen') || lowerMessage.includes('voice input')) {
+      return '💡 Tip: Use /record or /listen for voice input';
+    }
+    
+    if (lowerMessage.includes('voice') || lowerMessage.includes('audio')) {
+      return '💡 Tip: Use /voice to manage voice settings';
+    }
+    
+    return null;
+  },
+
+  // Hook into response processing to add voice features
+  onResponse: async (response, context) => {
+    const chat = context.chat;
+    
+    // Check if response contains code - don't speak code blocks
+    if (response.includes('```') && chat.voiceManager?.textToSpeechEnabled) {
+      console.log(chalk.gray('🔇 Skipping TTS for code response'));
+      
+      // Stop any current speech and don't speak this response
+      await chat.voiceManager.stopSpeaking();
+      
+      // You could override the TTS behavior here
+      // by temporarily disabling it for this response
+    }
+  },
+
+  hooks: {
+    beforeResponse: async (data) => {
+      // Could process voice commands before sending to AI
+      return data;
+    },
+    
+    afterResponse: async (data) => {
+      // Could add voice feedback after responses
+      return data;
+    }
+  }
+};

package/plugins/weather-plugin.js

@@ -10,7 +10,7 @@ module.exports = {
 
   // Plugin initialization
   async init() {
-    console.log('Weather plugin initialized');
+//     console.log('Weather plugin initialized');
   },
 
   // Plugin cleanup

package/plugins/weather-plugin.js.bak

@@ -0,0 +1,83 @@
+// Example Weather Plugin for Recoder
+const axios = require('axios');
+
+module.exports = {
+  name: 'weather',
+  version: '1.0.0',
+  description: 'Get weather information for any city',
+  author: 'Recoder Team',
+  enabled: true,
+
+  // Plugin initialization
+  async init() {
+    console.log('Weather plugin initialized');
+  },
+
+  // Plugin cleanup
+  async cleanup() {
+    console.log('Weather plugin cleaned up');
+  },
+
+  // Custom commands
+  commands: {
+    weather: async (args, context) => {
+      if (!args.length) {
+        return 'Usage: /weather <city>';
+      }
+      
+      const city = args.join(' ');
+      try {
+        // Using a free weather API (OpenWeatherMap alternative)
+        const response = await axios.get(`https://wttr.in/${encodeURIComponent(city)}?format=j1`);
+        const data = response.data;
+        
+        if (!data.current_condition) {
+          return `Weather data not found for ${city}`;
+        }
+
+        const current = data.current_condition[0];
+        const location = data.nearest_area[0];
+        
+        return `🌤️ Weather in ${location.areaName[0].value}, ${location.country[0].value}:
+Temperature: ${current.temp_C}°C (${current.temp_F}°F)
+Condition: ${current.weatherDesc[0].value}
+Humidity: ${current.humidity}%
+Wind: ${current.windspeedKmph} km/h ${current.winddir16Point}
+Feels like: ${current.FeelsLikeC}°C`;
+        
+      } catch (error) {
+        return `Failed to fetch weather data: ${error.message}`;
+      }
+    }
+  },
+
+  // Hook into message processing
+  onMessage: async (message, context) => {
+    // Auto-detect weather requests
+    const weatherKeywords = ['weather', 'temperature', 'forecast', 'climate'];
+    const cityPattern = /weather in (\w+)/i;
+    
+    if (weatherKeywords.some(keyword => message.toLowerCase().includes(keyword))) {
+      const match = message.match(cityPattern);
+      if (match) {
+        const city = match[1];
+        context.suggestedCommand = `/weather ${city}`;
+        return `💡 Suggestion: Use /weather ${city} for current weather`;
+      }
+    }
+    return null;
+  },
+
+  // Hooks for various events
+  hooks: {
+    beforeResponse: async (data) => {
+      // Could modify the response before it's sent
+      return data;
+    },
+    
+    afterResponse: async (data) => {
+      // Could perform actions after response is sent
+      return data;
+    }
+  }
+};