@holoscript/core 2.0.1 → 2.0.2

package/src/traits/VoiceInputTrait.js

@@ -1,284 +0,0 @@
-/**
- * @holoscript/core VoiceInput Trait
- *
- * Enables voice-driven interactions for HoloScript+ objects
- * Integrates speech recognition with confidence-based command parsing
- */
-/**
- * VoiceInputTrait - Enables speech recognition on HoloScript+ objects
- */
-export class VoiceInputTrait {
-    constructor(config) {
-        this.recognition = null;
-        this.isListening = false;
-        this.listeners = new Set();
-        this.interimTranscript = '';
-        this.commandCache = new Map();
-        this.config = {
-            showTranscript: false,
-            audioFeedback: true,
-            timeout: 10000,
-            ...config,
-        };
-        this.initializeRecognition();
-        this.buildCommandCache();
-    }
-    /**
-     * Initialize Web Speech API
-     */
-    initializeRecognition() {
-        // Use native Web Speech API or polyfill
-        const SpeechRecognition = globalThis.SpeechRecognition ||
-            globalThis.webkitSpeechRecognition;
-        if (!SpeechRecognition) {
-            console.error('Web Speech API not supported');
-            return;
-        }
-        this.recognition = new SpeechRecognition();
-        this.setupRecognitionHandlers();
-    }
-    /**
-     * Setup Web Speech API event handlers
-     */
-    setupRecognitionHandlers() {
-        if (!this.recognition)
-            return;
-        this.recognition.continuous = this.config.mode === 'continuous';
-        this.recognition.interimResults = true;
-        this.recognition.lang = this.config.languages?.[0] || 'en-US';
-        this.recognition.onstart = () => {
-            this.isListening = true;
-            this.interimTranscript = '';
-            if (this.config.audioFeedback) {
-                this.playBeep('start');
-            }
-        };
-        this.recognition.onresult = (event) => {
-            this.interimTranscript = '';
-            for (let i = event.resultIndex; i < event.results.length; i++) {
-                const transcript = event.results[i][0].transcript;
-                const confidence = event.results[i][0].confidence;
-                const isFinal = event.results[i].isFinal;
-                if (isFinal) {
-                    this.processVoiceCommand(transcript, confidence);
-                }
-                else {
-                    this.interimTranscript += transcript;
-                }
-            }
-            if (this.config.showTranscript) {
-                this.emitEvent({
-                    type: 'interim',
-                    result: {
-                        transcript: this.interimTranscript,
-                        confidence: 0,
-                        isFinal: false,
-                        language: this.recognition.lang,
-                        timestamp: Date.now(),
-                    },
-                    hologramId: '',
-                });
-            }
-        };
-        this.recognition.onerror = (_event) => {
-            this.emitEvent({
-                type: 'error',
-                result: {
-                    transcript: '',
-                    confidence: 0,
-                    isFinal: false,
-                    language: this.recognition.lang,
-                    timestamp: Date.now(),
-                },
-                hologramId: '',
-            });
-        };
-        this.recognition.onend = () => {
-            this.isListening = false;
-            if (this.config.audioFeedback) {
-                this.playBeep('end');
-            }
-        };
-    }
-    /**
-     * Process voice command with fuzzy matching
-     */
-    processVoiceCommand(transcript, confidence) {
-        if (confidence < this.config.confidenceThreshold) {
-            return;
-        }
-        const normalized = transcript.toLowerCase().trim();
-        let bestMatch = null;
-        let bestScore = 0;
-        // Try to find matching command
-        for (const command of this.config.commands || []) {
-            const cmdConfidence = command.confidence || this.config.confidenceThreshold;
-            // Exact match
-            if (normalized === command.phrase.toLowerCase()) {
-                if (confidence >= cmdConfidence) {
-                    bestMatch = command;
-                    bestScore = 1.0;
-                    break;
-                }
-            }
-            // Fuzzy match with aliases
-            const allPhrases = [command.phrase, ...(command.aliases || [])];
-            for (const phrase of allPhrases) {
-                const score = this.fuzzyMatch(normalized, phrase.toLowerCase());
-                if (score > bestScore && score >= 0.7) {
-                    bestScore = score;
-                    bestMatch = command;
-                }
-            }
-        }
-        // Emit recognition result
-        this.emitEvent({
-            type: 'final',
-            result: {
-                transcript: normalized,
-                confidence,
-                isFinal: true,
-                language: this.recognition.lang,
-                matchedCommand: bestMatch || undefined,
-                timestamp: Date.now(),
-            },
-            hologramId: '',
-        });
-        if (bestMatch) {
-            if (this.config.audioFeedback) {
-                this.playBeep('success');
-            }
-        }
-    }
-    /**
-     * Fuzzy string matching (simple Levenshtein-like approach)
-     */
-    fuzzyMatch(input, target) {
-        if (input === target)
-            return 1.0;
-        if (input.length === 0 || target.length === 0)
-            return 0;
-        // Check if input is substring of target
-        if (target.includes(input)) {
-            return Math.min(1.0, input.length / target.length);
-        }
-        // Simple edit distance estimation
-        const distance = Math.abs(input.length - target.length);
-        const maxLen = Math.max(input.length, target.length);
-        return Math.max(0, 1.0 - distance / maxLen);
-    }
-    /**
-     * Build command index for faster lookup
-     */
-    buildCommandCache() {
-        for (const command of this.config.commands || []) {
-            this.commandCache.set(command.phrase.toLowerCase(), command);
-            for (const alias of command.aliases || []) {
-                this.commandCache.set(alias.toLowerCase(), command);
-            }
-        }
-    }
-    /**
-     * Start listening for voice input
-     */
-    startListening() {
-        if (!this.recognition || this.isListening)
-            return;
-        try {
-            this.recognition.start();
-        }
-        catch (error) {
-            console.error('Failed to start speech recognition:', error);
-        }
-    }
-    /**
-     * Stop listening for voice input
-     */
-    stopListening() {
-        if (!this.recognition || !this.isListening)
-            return;
-        try {
-            this.recognition.stop();
-        }
-        catch (error) {
-            console.error('Failed to stop speech recognition:', error);
-        }
-    }
-    /**
-     * Toggle listening state
-     */
-    toggleListening() {
-        if (this.isListening) {
-            this.stopListening();
-        }
-        else {
-            this.startListening();
-        }
-    }
-    /**
-     * Add command listener
-     */
-    on(listener) {
-        this.listeners.add(listener);
-    }
-    /**
-     * Remove command listener
-     */
-    off(listener) {
-        this.listeners.delete(listener);
-    }
-    /**
-     * Emit voice event to all listeners
-     */
-    emitEvent(event) {
-        for (const listener of this.listeners) {
-            listener(event);
-        }
-    }
-    /**
-     * Play audio feedback beep
-     */
-    playBeep(type) {
-        // AudioContext beep generation
-        try {
-            const audioContext = new globalThis.AudioContext();
-            const oscillator = audioContext.createOscillator();
-            const gainNode = audioContext.createGain();
-            oscillator.connect(gainNode);
-            gainNode.connect(audioContext.destination);
-            const now = audioContext.currentTime;
-            const duration = 0.1;
-            // Vary beep frequency by type
-            oscillator.frequency.value = type === 'start' ? 800 : type === 'success' ? 1000 : 600;
-            gainNode.gain.setValueAtTime(0.3, now);
-            gainNode.gain.exponentialRampToValueAtTime(0.01, now + duration);
-            oscillator.start(now);
-            oscillator.stop(now + duration);
-        }
-        catch (error) {
-            // Silently fail if audio not available
-        }
-    }
-    /**
-     * Get current listening state
-     */
-    isActive() {
-        return this.isListening;
-    }
-    /**
-     * Dispose and cleanup
-     */
-    dispose() {
-        if (this.recognition) {
-            this.recognition.abort();
-        }
-        this.listeners.clear();
-        this.commandCache.clear();
-    }
-}
-/**
- * HoloScript+ @voice_input trait factory
- */
-export function createVoiceInputTrait(config) {
-    return new VoiceInputTrait(config);
-}

package/src/traits/VoiceInputTrait.test.js

@@ -1,226 +0,0 @@
-/**
- * VoiceInputTrait Tests
- *
- * Comprehensive tests for voice recognition and command matching
- */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { VoiceInputTrait } from '../traits/VoiceInputTrait';
-describe('VoiceInputTrait', () => {
-    let trait;
-    let config;
-    beforeEach(() => {
-        config = {
-            mode: 'continuous',
-            confidenceThreshold: 0.7,
-            commands: [
-                {
-                    phrase: 'turn on',
-                    aliases: ['activate', 'power up'],
-                    action: 'activate',
-                },
-                {
-                    phrase: 'move forward',
-                    aliases: ['go forward', 'advance'],
-                    action: 'move',
-                    params: { direction: 'forward' },
-                },
-                {
-                    phrase: 'stop',
-                    aliases: ['halt', 'pause'],
-                    action: 'stop',
-                },
-            ],
-        };
-        trait = new VoiceInputTrait(config);
-    });
-    describe('Initialization', () => {
-        it('should initialize with config', () => {
-            expect(trait).toBeDefined();
-        });
-        it('should not be listening initially', () => {
-            expect(trait.isActive()).toBe(false);
-        });
-        it('should accept custom confidence threshold', () => {
-            const customTrait = new VoiceInputTrait({
-                mode: 'push-to-talk',
-                confidenceThreshold: 0.85,
-            });
-            expect(customTrait).toBeDefined();
-        });
-    });
-    describe('Listening Control', () => {
-        it('should start listening', () => {
-            trait.startListening();
-            // Note: Web Speech API not available in test env, so this just tests the method exists
-            expect(trait).toBeDefined();
-        });
-        it('should stop listening', () => {
-            trait.stopListening();
-            expect(trait.isActive()).toBe(false);
-        });
-        it('should toggle listening state', () => {
-            const initialState = trait.isActive();
-            trait.toggleListening();
-            // Can't easily test state change without Web Speech API
-            expect(trait).toBeDefined();
-        });
-    });
-    describe('Event Listeners', () => {
-        it('should register event listener', () => {
-            const listener = vi.fn();
-            trait.on(listener);
-            expect(listener).not.toHaveBeenCalled();
-        });
-        it('should unregister event listener', () => {
-            const listener = vi.fn();
-            trait.on(listener);
-            trait.off(listener);
-            expect(trait).toBeDefined();
-        });
-        it('should allow multiple listeners', () => {
-            const listener1 = vi.fn();
-            const listener2 = vi.fn();
-            trait.on(listener1);
-            trait.on(listener2);
-            expect(trait).toBeDefined();
-        });
-    });
-    describe('Configuration', () => {
-        it('should support continuous mode', () => {
-            const continuousTrait = new VoiceInputTrait({
-                mode: 'continuous',
-                confidenceThreshold: 0.7,
-            });
-            expect(continuousTrait).toBeDefined();
-        });
-        it('should support push-to-talk mode', () => {
-            const pushTrait = new VoiceInputTrait({
-                mode: 'push-to-talk',
-                confidenceThreshold: 0.7,
-            });
-            expect(pushTrait).toBeDefined();
-        });
-        it('should support always-listening mode', () => {
-            const alwaysTrait = new VoiceInputTrait({
-                mode: 'always-listening',
-                confidenceThreshold: 0.5,
-            });
-            expect(alwaysTrait).toBeDefined();
-        });
-        it('should accept multiple languages', () => {
-            const multiLangTrait = new VoiceInputTrait({
-                mode: 'continuous',
-                confidenceThreshold: 0.7,
-                languages: ['en-US', 'es-ES', 'fr-FR'],
-            });
-            expect(multiLangTrait).toBeDefined();
-        });
-        it('should support audio feedback toggle', () => {
-            const feedbackTrait = new VoiceInputTrait({
-                mode: 'continuous',
-                confidenceThreshold: 0.7,
-                audioFeedback: true,
-            });
-            expect(feedbackTrait).toBeDefined();
-        });
-        it('should support transcript display', () => {
-            const transcriptTrait = new VoiceInputTrait({
-                mode: 'continuous',
-                confidenceThreshold: 0.7,
-                showTranscript: true,
-            });
-            expect(transcriptTrait).toBeDefined();
-        });
-    });
-    describe('Command Configuration', () => {
-        it('should support command phrases', () => {
-            const commands = [
-                { phrase: 'hello', action: 'greet' },
-            ];
-            const cmdTrait = new VoiceInputTrait({
-                mode: 'continuous',
-                confidenceThreshold: 0.7,
-                commands,
-            });
-            expect(cmdTrait).toBeDefined();
-        });
-        it('should support command aliases', () => {
-            const commands = [
-                {
-                    phrase: 'turn on',
-                    aliases: ['activate', 'power up', 'enable'],
-                    action: 'activate',
-                },
-            ];
-            const cmdTrait = new VoiceInputTrait({
-                mode: 'continuous',
-                confidenceThreshold: 0.7,
-                commands,
-            });
-            expect(cmdTrait).toBeDefined();
-        });
-        it('should support per-command confidence', () => {
-            const commands = [
-                {
-                    phrase: 'critical action',
-                    action: 'critical',
-                    confidence: 0.95,
-                },
-                {
-                    phrase: 'normal action',
-                    action: 'normal',
-                    confidence: 0.7,
-                },
-            ];
-            const cmdTrait = new VoiceInputTrait({
-                mode: 'continuous',
-                confidenceThreshold: 0.7,
-                commands,
-            });
-            expect(cmdTrait).toBeDefined();
-        });
-        it('should support command parameters', () => {
-            const commands = [
-                {
-                    phrase: 'go to location',
-                    action: 'navigate',
-                    params: { target: 'location' },
-                },
-            ];
-            const cmdTrait = new VoiceInputTrait({
-                mode: 'continuous',
-                confidenceThreshold: 0.7,
-                commands,
-            });
-            expect(cmdTrait).toBeDefined();
-        });
-    });
-    describe('Timeout Configuration', () => {
-        it('should support custom timeout', () => {
-            const timeoutTrait = new VoiceInputTrait({
-                mode: 'continuous',
-                confidenceThreshold: 0.7,
-                timeout: 5000,
-            });
-            expect(timeoutTrait).toBeDefined();
-        });
-        it('should use default timeout if not specified', () => {
-            const defaultTrait = new VoiceInputTrait({
-                mode: 'continuous',
-                confidenceThreshold: 0.7,
-            });
-            expect(defaultTrait).toBeDefined();
-        });
-    });
-    describe('Cleanup', () => {
-        it('should dispose resources', () => {
-            trait.dispose();
-            expect(trait).toBeDefined();
-        });
-        it('should stop listening on dispose', () => {
-            trait.startListening();
-            trait.dispose();
-            expect(trait.isActive()).toBe(false);
-        });
-    });
-});