Removes outdated prompt files

Removes the `Chat Prompt.txt`, `VSCode Agent/Prompt.txt`, `Warp.dev/Prompt.txt`, and `v0 Prompts and Tools/Prompt.txt` files.

These files likely contain outdated prompts or configurations that are no longer needed in the current project. Removing them helps to clean up the codebase and prevent potential confusion or conflicts.

Nowhere_AI_Agent/backend/src/voice/voice-processor.ts

@@ -0,0 +1,317 @@
+import { Logger } from '../utils/logger';
+
+export interface VoiceCommand {
+  text: string;
+  confidence: number;
+  intent: string;
+  entities: any[];
+}
+
+export interface VoiceResponse {
+  text: string;
+  audio?: Buffer;
+  mode: 'brief' | 'detailed' | 'silent' | 'interactive';
+}
+
+export interface VoiceSettings {
+  enabled: boolean;
+  language: string;
+  voice: string;
+  speed: number;
+  volume: number;
+}
+
+export class VoiceProcessor {
+  private logger: Logger;
+  private settings: VoiceSettings;
+  private isListening: boolean = false;
+
+  constructor() {
+    this.logger = new Logger('VoiceProcessor');
+    this.settings = {
+      enabled: true,
+      language: 'en-US',
+      voice: 'default',
+      speed: 1.0,
+      volume: 1.0
+    };
+  }
+
+  /**
+   * Process voice input (speech recognition)
+   */
+  async processVoiceInput(audioData: Buffer): Promise<VoiceCommand> {
+    try {
+      this.logger.info('Processing voice input', { 
+        audioSize: audioData.length,
+        language: this.settings.language 
+      });
+
+      // Mock speech recognition - in real implementation would use Azure Speech Services
+      const mockText = this.mockSpeechRecognition(audioData);
+      const intent = await this.analyzeVoiceIntent(mockText);
+      const entities = await this.extractVoiceEntities(mockText);
+
+      const command: VoiceCommand = {
+        text: mockText,
+        confidence: 0.85,
+        intent: intent.type,
+        entities
+      };
+
+      this.logger.info('Voice command processed', { 
+        text: command.text, 
+        intent: command.intent,
+        confidence: command.confidence 
+      });
+
+      return command;
+
+    } catch (error) {
+      this.logger.error('Voice processing failed', { error: error.message });
+      throw new Error(`Voice processing failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Generate voice response (text-to-speech)
+   */
+  async generateVoiceResponse(response: VoiceResponse): Promise<Buffer> {
+    try {
+      this.logger.info('Generating voice response', { 
+        text: response.text.substring(0, 50) + '...',
+        mode: response.mode 
+      });
+
+      // Mock TTS - in real implementation would use Azure Speech Services
+      const audioBuffer = this.mockTextToSpeech(response.text, this.settings);
+
+      this.logger.info('Voice response generated', { 
+        audioSize: audioBuffer.length,
+        textLength: response.text.length 
+      });
+
+      return audioBuffer;
+
+    } catch (error) {
+      this.logger.error('Voice response generation failed', { error: error.message });
+      throw new Error(`Voice response generation failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Process voice command from text
+   */
+  async processVoiceCommand(command: any): Promise<any> {
+    try {
+      this.logger.info('Processing voice command', { command });
+
+      // Parse voice command and convert to action
+      const action = await this.parseVoiceCommand(command);
+      
+      return {
+        success: true,
+        message: 'Voice command processed successfully',
+        data: action
+      };
+
+    } catch (error) {
+      this.logger.error('Voice command processing failed', { error: error.message });
+      return {
+        success: false,
+        message: 'Voice command processing failed',
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Start voice listening mode
+   */
+  async startListening(): Promise<void> {
+    if (this.isListening) {
+      throw new Error('Already listening');
+    }
+
+    this.isListening = true;
+    this.logger.info('Voice listening started');
+  }
+
+  /**
+   * Stop voice listening mode
+   */
+  async stopListening(): Promise<void> {
+    if (!this.isListening) {
+      throw new Error('Not currently listening');
+    }
+
+    this.isListening = false;
+    this.logger.info('Voice listening stopped');
+  }
+
+  /**
+   * Update voice settings
+   */
+  async updateSettings(settings: Partial<VoiceSettings>): Promise<void> {
+    this.settings = { ...this.settings, ...settings };
+    this.logger.info('Voice settings updated', { settings: this.settings });
+  }
+
+  /**
+   * Get voice processor status
+   */
+  async getStatus(): Promise<any> {
+    return {
+      enabled: this.settings.enabled,
+      listening: this.isListening,
+      settings: this.settings,
+      lastUpdated: new Date().toISOString()
+    };
+  }
+
+  // Private helper methods
+
+  private mockSpeechRecognition(audioData: Buffer): string {
+    // Mock speech recognition - in real implementation would use Azure Speech Services
+    const mockResponses = [
+      'Nowhere, analyze this code',
+      'Create a new React component',
+      'Search for documentation',
+      'Enable autopilot mode',
+      'What do you remember from our conversation?',
+      'Run the tests and show me the results'
+    ];
+
+    // Use audio data hash to deterministically select a response
+    const hash = this.simpleHash(audioData);
+    const index = hash % mockResponses.length;
+    
+    return mockResponses[index];
+  }
+
+  private async analyzeVoiceIntent(text: string): Promise<any> {
+    // Mock intent analysis - in real implementation would use NLP
+    const intents = {
+      'analyze': 'code_analysis',
+      'create': 'file_operation',
+      'search': 'web_search',
+      'autopilot': 'autopilot_toggle',
+      'remember': 'memory_query',
+      'run': 'terminal_command',
+      'test': 'terminal_command'
+    };
+
+    const words = text.toLowerCase().split(' ');
+    for (const word of words) {
+      if (intents[word]) {
+        return { type: intents[word], confidence: 0.9 };
+      }
+    }
+
+    return { type: 'general', confidence: 0.5 };
+  }
+
+  private async extractVoiceEntities(text: string): Promise<any[]> {
+    // Mock entity extraction - in real implementation would use NLP
+    const entities: any[] = [];
+
+    // Extract file names
+    const fileMatch = text.match(/(\w+\.\w+)/);
+    if (fileMatch) {
+      entities.push({
+        type: 'file',
+        value: fileMatch[1],
+        confidence: 0.8
+      });
+    }
+
+    // Extract commands
+    const commandMatch = text.match(/run\s+(.+)/i);
+    if (commandMatch) {
+      entities.push({
+        type: 'command',
+        value: commandMatch[1],
+        confidence: 0.7
+      });
+    }
+
+    // Extract search queries
+    const searchMatch = text.match(/search\s+(.+)/i);
+    if (searchMatch) {
+      entities.push({
+        type: 'query',
+        value: searchMatch[1],
+        confidence: 0.8
+      });
+    }
+
+    return entities;
+  }
+
+  private async parseVoiceCommand(command: any): Promise<any> {
+    // Convert voice command to executable action
+    const { intent, entities } = command;
+
+    switch (intent) {
+      case 'code_analysis':
+        return {
+          action: 'analyze_code',
+          target: entities.find(e => e.type === 'file')?.value || 'current'
+        };
+
+      case 'file_operation':
+        return {
+          action: 'create_file',
+          target: entities.find(e => e.type === 'file')?.value || 'new_file'
+        };
+
+      case 'web_search':
+        return {
+          action: 'search_web',
+          query: entities.find(e => e.type === 'query')?.value || 'general'
+        };
+
+      case 'autopilot_toggle':
+        return {
+          action: 'toggle_autopilot',
+          enabled: true
+        };
+
+      case 'memory_query':
+        return {
+          action: 'query_memory',
+          query: 'recent interactions'
+        };
+
+      case 'terminal_command':
+        return {
+          action: 'execute_command',
+          command: entities.find(e => e.type === 'command')?.value || 'ls'
+        };
+
+      default:
+        return {
+          action: 'general_response',
+          message: 'I heard your command, let me help you with that.'
+        };
+    }
+  }
+
+  private mockTextToSpeech(text: string, settings: VoiceSettings): Buffer {
+    // Mock TTS - in real implementation would use Azure Speech Services
+    // For now, return a mock audio buffer
+    const mockAudio = Buffer.alloc(1024);
+    mockAudio.fill(0); // Silent audio buffer
+    
+    return mockAudio;
+  }
+
+  private simpleHash(buffer: Buffer): number {
+    let hash = 0;
+    for (let i = 0; i < Math.min(buffer.length, 100); i++) {
+      hash = ((hash << 5) - hash) + buffer[i];
+      hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash);
+  }
+}