@sugar-crash-studios/vibe-forge 0.4.0

package/bin/dashboard/frontend/src/lib/stores/voice.js

@@ -0,0 +1,275 @@
+import { writable, get } from 'svelte/store';
+
+// ---------------------------------------------------------------------------
+// Persistence
+// localStorage is the session override; server config is the default.
+// Boot order:
+//   1. Fetch /api/config for server-side default (dashboard_voice)
+//   2. If localStorage has an explicit override, honour it
+//   3. Otherwise use server default
+// ---------------------------------------------------------------------------
+const STORAGE_KEY = 'vibe-forge-voice-enabled';
+const STORAGE_OVERRIDE_KEY = 'vibe-forge-voice-overridden';
+
+function _readStoredEnabled() {
+    if (typeof localStorage === 'undefined') return false;
+    const overridden = localStorage.getItem(STORAGE_OVERRIDE_KEY) === 'true';
+    if (overridden) return localStorage.getItem(STORAGE_KEY) === 'true';
+    return null; // means "use server default"
+}
+
+export const voiceEnabled = writable(_readStoredEnabled() ?? false);
+export const voiceSpeaking = writable(false);
+
+// Persist explicit user toggles
+voiceEnabled.subscribe(val => {
+    if (typeof localStorage !== 'undefined') {
+        localStorage.setItem(STORAGE_KEY, String(val));
+    }
+});
+
+// Fetch server config and apply default if user hasn't overridden
+if (typeof window !== 'undefined' && _readStoredEnabled() === null) {
+    fetch('/api/config')
+        .then(r => r.ok ? r.json() : null)
+        .catch(() => null)
+        .then(cfg => {
+            if (cfg?.dashboard_voice === true) {
+                voiceEnabled.set(true);
+            }
+        });
+}
+
+// ---------------------------------------------------------------------------
+// Agent voice profiles
+// gender: 'male' | 'female'
+// pitch:  0.0–2.0  (1.0 = default)
+// rate:   0.1–10   (1.0 = default)
+// ---------------------------------------------------------------------------
+const PROFILES = {
+    'planning-hub': { gender: 'male',   pitch: 0.80, rate: 0.88 }, // deep, measured authority
+    'forge-master': { gender: 'male',   pitch: 0.80, rate: 0.88 },
+    'oracle':       { gender: 'female', pitch: 1.00, rate: 0.92 }, // thoughtful, unhurried
+    'architect':    { gender: 'male',   pitch: 0.85, rate: 0.85 }, // calm, deliberate
+    'aegis':        { gender: 'female', pitch: 1.10, rate: 1.15 }, // sharp, urgent
+    'pixel':        { gender: 'female', pitch: 1.18, rate: 1.05 }, // warm, expressive
+    'ember':        { gender: 'male',   pitch: 0.92, rate: 1.02 }, // practical, even
+    'anvil':        { gender: 'male',   pitch: 1.00, rate: 1.05 }, // direct, energetic
+    'furnace':      { gender: 'male',   pitch: 0.88, rate: 1.00 }, // solid, reliable
+    'crucible':     { gender: 'female', pitch: 1.02, rate: 0.98 }, // precise, skeptical cadence
+    'temper':       { gender: 'male',   pitch: 0.95, rate: 0.90 }, // composed, measured
+    'scribe':       { gender: 'female', pitch: 1.05, rate: 0.88 }, // clear, articulate
+    'herald':       { gender: 'male',   pitch: 1.00, rate: 1.12 }, // bright, announcement energy
+    'loki':         { gender: 'male',   pitch: 1.12, rate: 1.08 }, // bright, quicksilver energy
+    'system':       { gender: 'female', pitch: 1.00, rate: 1.00 },
+};
+
+const DEFAULT_PROFILE = { gender: 'male', pitch: 1.0, rate: 1.0 };
+
+// ---------------------------------------------------------------------------
+// Voice pool — loaded once, then cached
+// ---------------------------------------------------------------------------
+let _maleVoices   = [];
+let _femaleVoices = [];
+let _voicesReady  = false;
+
+const FEMALE_HINTS = /female|zira|samantha|victoria|fiona|kate|moira|veena|tessa|karen|susan|linda|heather|allison|ava|nicky|sandy|shelley/i;
+const MALE_HINTS   = /\bmale\b|david|mark|alex|daniel|james|richard|george|thomas|reed|fred|ralph|bruce|lee/i;
+
+function _loadVoices() {
+    if (!('speechSynthesis' in window)) return;
+    const all = window.speechSynthesis.getVoices();
+    if (all.length === 0) return;
+
+    // Prefer English voices
+    const en = all.filter(v => v.lang.startsWith('en'));
+    const pool = en.length > 0 ? en : all;
+
+    _femaleVoices = pool.filter(v => FEMALE_HINTS.test(v.name));
+    _maleVoices   = pool.filter(v => MALE_HINTS.test(v.name));
+
+    // If heuristics came up empty, split the pool evenly as fallback
+    if (_femaleVoices.length === 0 && _maleVoices.length === 0) {
+        _maleVoices   = pool.filter((_, i) => i % 2 === 0);
+        _femaleVoices = pool.filter((_, i) => i % 2 === 1);
+    } else {
+        // Ensure neither pool is empty
+        if (_femaleVoices.length === 0) _femaleVoices = _maleVoices;
+        if (_maleVoices.length   === 0) _maleVoices   = _femaleVoices;
+    }
+
+    _voicesReady = true;
+}
+
+// Deterministic: same agent always gets the same voice from its pool
+function _pickVoice(agentName, gender) {
+    const pool = gender === 'female' ? _femaleVoices : _maleVoices;
+    if (pool.length === 0) return null;
+    let hash = 0;
+    for (const ch of agentName) hash = (hash * 31 + ch.charCodeAt(0)) & 0xffffffff;
+    return pool[Math.abs(hash) % pool.length];
+}
+
+// ---------------------------------------------------------------------------
+// Server TTS probe — check once whether /api/tts is available
+// ---------------------------------------------------------------------------
+let _serverTtsAvailable = null; // null = unknown, true/false = known
+
+async function _probeServerTts() {
+    if (_serverTtsAvailable !== null) return _serverTtsAvailable;
+    try {
+        const r = await fetch('/api/tts?text=ok&agent=system');
+        _serverTtsAvailable = r.ok;
+        // Drain the response body so the connection is released cleanly
+        if (r.ok) r.blob().catch(() => {});
+    } catch {
+        _serverTtsAvailable = false;
+    }
+    return _serverTtsAvailable;
+}
+
+// ---------------------------------------------------------------------------
+// Audio queue — prevents utterances from trampling each other
+// Supports both Audio (server TTS) and SpeechSynthesisUtterance (Web Speech)
+// ---------------------------------------------------------------------------
+let _queue = [];
+let _busy  = false;
+let _currentAudio = null; // for server-TTS Audio objects
+
+function _flush() {
+    if (_busy || _queue.length === 0) return;
+    const item = _queue.shift();
+    _busy = true;
+    voiceSpeaking.set(true);
+
+    const done = () => {
+        _busy = false;
+        _currentAudio = null;
+        voiceSpeaking.set(_queue.length > 0);
+        _flush();
+    };
+
+    if (item.audio) {
+        _currentAudio = item.audio;
+        item.audio.onended = done;
+        item.audio.onerror = done;
+        item.audio.play().catch(done);
+    } else {
+        item.utt.onend = done;
+        item.utt.onerror = done;
+        window.speechSynthesis.speak(item.utt);
+    }
+}
+
+function _cancelAll() {
+    _queue = [];
+    if (_currentAudio) {
+        _currentAudio.pause();
+        _currentAudio.src = '';
+        _currentAudio = null;
+    }
+    if ('speechSynthesis' in window) window.speechSynthesis.cancel();
+    _busy = false;
+    voiceSpeaking.set(false);
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Speak text in an agent's voice (server TTS preferred, Web Speech fallback).
+ * @param {string} text
+ * @param {string} [agentName]  — key from PROFILES (e.g. 'aegis')
+ * @param {boolean} [interrupt] — cancel current speech and go immediately
+ */
+export async function speak(text, agentName = 'system', interrupt = false) {
+    if (!get(voiceEnabled)) return;
+    if (!text || !text.trim()) return;
+
+    if (interrupt) _cancelAll();
+
+    // Cap queue at 4 to avoid stale backlogs
+    if (_queue.length >= 4) return;
+
+    const agent = agentName.toLowerCase();
+
+    // Try server-side Edge TTS first
+    const serverAvailable = await _probeServerTts().catch(() => false);
+    if (serverAvailable) {
+        try {
+            const params = new URLSearchParams({ text: text.trim(), agent });
+            const res = await fetch(`/api/tts?${params}`);
+            if (res.ok) {
+                const blob = await res.blob();
+                const audio = new Audio(URL.createObjectURL(blob));
+                _queue.push({ audio });
+                _flush();
+                return;
+            }
+            // non-OK response — fall through to Web Speech
+            _serverTtsAvailable = false;
+        } catch {
+            _serverTtsAvailable = false;
+        }
+    }
+
+    // Fallback: Web Speech API
+    if (!('speechSynthesis' in window)) return;
+    if (!_voicesReady) _loadVoices();
+
+    const profile = PROFILES[agent] || DEFAULT_PROFILE;
+    const voice   = _pickVoice(agent, profile.gender);
+
+    const utt = new SpeechSynthesisUtterance(text);
+    utt.pitch  = profile.pitch;
+    utt.rate   = profile.rate;
+    utt.volume = 1.0;
+    if (voice) utt.voice = voice;
+
+    _queue.push({ utt });
+    _flush();
+}
+
+export function stopSpeaking() {
+    _cancelAll();
+}
+
+export function toggleVoice() {
+    voiceEnabled.update(v => {
+        if (v) stopSpeaking();
+        const next = !v;
+        // Mark as explicitly overridden so server default no longer applies
+        if (typeof localStorage !== 'undefined') {
+            localStorage.setItem(STORAGE_OVERRIDE_KEY, 'true');
+        }
+        return next;
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Infer agent from a notification object (best-effort)
+// ---------------------------------------------------------------------------
+const AGENT_NAMES = Object.keys(PROFILES);
+
+export function inferAgent(notification) {
+    if (notification?.agent) return notification.agent.toLowerCase();
+
+    // Scan the message text for a known agent name
+    const haystack = `${notification?.title || ''} ${notification?.message || ''}`.toLowerCase();
+    for (const name of AGENT_NAMES) {
+        if (haystack.includes(name)) return name;
+    }
+    return 'system';
+}
+
+// ---------------------------------------------------------------------------
+// Initialise voice pool as early as possible
+// ---------------------------------------------------------------------------
+if (typeof window !== 'undefined' && 'speechSynthesis' in window) {
+    if (window.speechSynthesis.getVoices().length > 0) {
+        _loadVoices();
+    } else {
+        window.speechSynthesis.addEventListener('voiceschanged', _loadVoices, { once: true });
+    }
+}

package/bin/dashboard/frontend/src/lib/stores/websocket.js

@@ -0,0 +1,295 @@
+import { writable, get } from 'svelte/store';
+import { tasks, tasksLoading, tasksError } from './tasks.js';
+import { agents, agentsLoading, agentsError } from './agents.js';
+import { issues, issuesLoading, issuesError } from './issues.js';
+import { addNotification } from './notifications.js';
+import { fetchTasks, fetchAgents, fetchIssues } from '../utils/api.js';
+import { speak, inferAgent } from './voice.js';
+
+// Configuration
+const CONFIG = {
+    RECONNECT_DELAY: 3000,
+    RECONNECT_MAX_DELAY: 30000,
+    MIN_LOADING_TIME: 300,
+};
+
+// WebSocket state
+export const wsConnected = writable(false);
+export const lastUpdated = writable(null);
+export const showConnectionBanner = writable(false);
+
+let ws = null;
+let reconnectAttempts = 0;
+let reconnectTimeout = null;
+
+// Get WebSocket URL
+function getWsUrl() {
+    const protocol = window.location.protocol === 'https:' ? 'wss' : 'ws';
+    return `${protocol}://${window.location.host}/ws`;
+}
+
+// Connect to WebSocket
+export function connectWebSocket() {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+        return;
+    }
+
+    ws = new WebSocket(getWsUrl());
+
+    ws.onopen = () => {
+        wsConnected.set(true);
+        reconnectAttempts = 0;
+        showConnectionBanner.set(false);
+
+        // Refresh all data on reconnect
+        refreshAll();
+    };
+
+    ws.onmessage = (event) => {
+        try {
+            const data = JSON.parse(event.data);
+            handleWebSocketMessage(data);
+        } catch (e) {
+            console.error('Failed to parse WebSocket message:', e);
+        }
+    };
+
+    ws.onclose = () => {
+        wsConnected.set(false);
+        scheduleReconnect();
+    };
+
+    ws.onerror = (error) => {
+        console.error('WebSocket error:', error);
+        wsConnected.set(false);
+    };
+}
+
+function scheduleReconnect() {
+    if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+    }
+
+    const delay = Math.min(
+        CONFIG.RECONNECT_DELAY * Math.pow(2, reconnectAttempts),
+        CONFIG.RECONNECT_MAX_DELAY
+    );
+
+    reconnectAttempts++;
+
+    if (reconnectAttempts > 3) {
+        showConnectionBanner.set(true);
+    }
+
+    reconnectTimeout = setTimeout(connectWebSocket, delay);
+}
+
+function handleWebSocketMessage(data) {
+    switch (data.event || data.type) {
+        case 'task-created':
+        case 'task-updated':
+        case 'task-status-changed':
+            refreshTasks();
+            if (data.task) {
+                addNotification({
+                    type: 'info',
+                    title: 'Task Updated',
+                    message: `${data.task.id}: ${data.task.title || 'Status changed'}`,
+                });
+                speak(`Task updated. ${data.task.title || data.task.id}`, 'forge-master');
+            }
+            break;
+
+        case 'agent-status-changed':
+            refreshAgents();
+            if (data.agent && data.status) {
+                speak(`${data.agent} is now ${data.status}.`, data.agent);
+            }
+            break;
+
+        case 'issue-detected':
+            refreshIssues();
+            addNotification({
+                type: 'warning',
+                title: 'New Issue Detected',
+                message: data.issue?.title || 'Check the Issues panel',
+            });
+            speak(`Issue detected. ${data.issue?.title || 'Check the issues panel.'}`, 'aegis');
+            break;
+
+        case 'dispatch-success':
+            refreshTasks();
+            refreshIssues();
+            speak('Task dispatched.', 'forge-master');
+            break;
+
+        case 'notification': {
+            const notif = data.notification;
+            addNotification(notif);
+            const agent = inferAgent(notif);
+            speak(notif?.message || notif?.title || '', agent);
+            break;
+        }
+
+        case 'heartbeat':
+            updateLastUpdated();
+            break;
+
+        case 'connected':
+        case 'pong':
+        case 'subscribed':
+            // Server handshake messages — no action needed
+            break;
+
+        default:
+            console.log('Unknown WebSocket message:', data);
+    }
+}
+
+function updateLastUpdated() {
+    lastUpdated.set(new Date().toISOString());
+}
+
+// Force reconnect
+export function reconnect() {
+    reconnectAttempts = 0;
+    if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+    }
+    connectWebSocket();
+}
+
+// Data refresh functions
+export async function refreshTasks() {
+    const startTime = Date.now();
+    tasksLoading.set(true);
+    tasksError.set(null);
+
+    try {
+        const data = await fetchTasks();
+
+        // Ensure minimum loading time
+        const elapsed = Date.now() - startTime;
+        if (elapsed < CONFIG.MIN_LOADING_TIME) {
+            await new Promise(r => setTimeout(r, CONFIG.MIN_LOADING_TIME - elapsed));
+        }
+
+        // API returns tasks grouped by directory: { pending: [], 'in-progress': [], review: [], completed: [] }
+        // Flatten to a single array with status normalized from the directory key
+        if (data && (data.pending || data['in-progress'] || data.review || data.completed)) {
+            const flatTasks = [
+                ...(data.pending || []).map(t => ({ ...t, status: t.status === 'unknown' ? 'pending' : t.status })),
+                ...(data['in-progress'] || []).map(t => ({ ...t, status: t.status === 'unknown' ? 'in-progress' : t.status })),
+                ...(data.review || []).map(t => ({ ...t, status: t.status === 'unknown' ? 'review' : t.status })),
+                ...(data.completed || []).map(t => ({ ...t, status: t.status === 'unknown' ? 'completed' : t.status })),
+            ];
+            tasks.set(flatTasks);
+        } else {
+            tasks.set(data.tasks || data || []);
+        }
+        tasksLoading.set(false);
+    } catch (error) {
+        console.error('Failed to fetch tasks:', error);
+        tasksError.set(error.message);
+        tasksLoading.set(false);
+    }
+}
+
+export async function refreshAgents() {
+    const startTime = Date.now();
+    agentsLoading.set(true);
+    agentsError.set(null);
+
+    try {
+        const data = await fetchAgents();
+
+        const elapsed = Date.now() - startTime;
+        if (elapsed < CONFIG.MIN_LOADING_TIME) {
+            await new Promise(r => setTimeout(r, CONFIG.MIN_LOADING_TIME - elapsed));
+        }
+
+        agents.set(data.agents || data || []);
+        agentsLoading.set(false);
+    } catch (error) {
+        console.error('Failed to fetch agents:', error);
+        agentsError.set(error.message);
+        agentsLoading.set(false);
+    }
+}
+
+export async function refreshIssues() {
+    const startTime = Date.now();
+    issuesLoading.set(true);
+    issuesError.set(null);
+
+    try {
+        const data = await fetchIssues();
+
+        const elapsed = Date.now() - startTime;
+        if (elapsed < CONFIG.MIN_LOADING_TIME) {
+            await new Promise(r => setTimeout(r, CONFIG.MIN_LOADING_TIME - elapsed));
+        }
+
+        issues.set(data.issues || data || []);
+        issuesLoading.set(false);
+    } catch (error) {
+        console.error('Failed to fetch issues:', error);
+        issuesError.set(error.message);
+        issuesLoading.set(false);
+    }
+}
+
+export async function refreshAll() {
+    await Promise.all([
+        refreshTasks(),
+        refreshAgents(),
+        refreshIssues(),
+    ]);
+    updateLastUpdated();
+}
+
+// Setup periodic refresh as fallback
+let periodicRefreshInterval = null;
+
+export function startPeriodicRefresh() {
+    if (periodicRefreshInterval) return;
+
+    periodicRefreshInterval = setInterval(() => {
+        if (!get(wsConnected)) {
+            refreshAll();
+        }
+    }, 30000);
+}
+
+export function stopPeriodicRefresh() {
+    if (periodicRefreshInterval) {
+        clearInterval(periodicRefreshInterval);
+        periodicRefreshInterval = null;
+    }
+}
+
+// Disconnect WebSocket and cleanup all resources
+export function disconnectWebSocket() {
+    // Clear reconnect timeout
+    if (reconnectTimeout) {
+        clearTimeout(reconnectTimeout);
+        reconnectTimeout = null;
+    }
+
+    // Stop periodic refresh
+    stopPeriodicRefresh();
+
+    // Close WebSocket connection
+    if (ws) {
+        ws.onclose = null; // Prevent scheduleReconnect from being called
+        ws.onerror = null;
+        ws.onmessage = null;
+        ws.onopen = null;
+        ws.close();
+        ws = null;
+    }
+
+    // Reset state
+    wsConnected.set(false);
+    reconnectAttempts = 0;
+}

package/bin/dashboard/frontend/src/lib/utils/api.js

@@ -0,0 +1,101 @@
+const API_BASE = window.location.origin;
+
+async function fetchApi(endpoint, options = {}) {
+    const response = await fetch(`${API_BASE}${endpoint}`, {
+        headers: {
+            'Content-Type': 'application/json',
+            ...options.headers,
+        },
+        ...options,
+    });
+
+    if (!response.ok) {
+        const error = new Error(`HTTP ${response.status}`);
+        error.status = response.status;
+        try {
+            error.data = await response.json();
+        } catch (e) {
+            error.data = null;
+        }
+        throw error;
+    }
+
+    return response.json();
+}
+
+export async function fetchTasks() {
+    return fetchApi('/api/tasks');
+}
+
+export async function fetchAgents() {
+    return fetchApi('/api/agents');
+}
+
+export async function fetchIssues() {
+    // Issues endpoint may not exist yet, mock data for now
+    try {
+        return await fetchApi('/api/issues');
+    } catch (e) {
+        // Return mock issues for demonstration
+        return {
+            issues: [
+                {
+                    id: 'issue-1',
+                    category: 'doc',
+                    title: 'Stale Docs: README.md',
+                    target: 'README.md',
+                    details: 'Last updated 45 days ago',
+                    meta: 'Threshold: 30 days | Severity: Medium',
+                    agent: 'scribe',
+                    priority: 'medium',
+                },
+                {
+                    id: 'issue-2',
+                    category: 'test',
+                    title: 'Failing Test: auth.test.js',
+                    target: 'auth.test.js',
+                    details: '2 tests failing: testLogin, testLogout',
+                    meta: 'First failed: yesterday 3:45 PM',
+                    agent: 'crucible',
+                    priority: 'high',
+                },
+                {
+                    id: 'issue-3',
+                    category: 'sec',
+                    title: 'Security: lodash vulnerability',
+                    target: 'package.json',
+                    details: 'CVE-2021-23337 (high severity)',
+                    meta: 'Affects: lodash < 4.17.21',
+                    agent: 'aegis',
+                    priority: 'critical',
+                },
+                {
+                    id: 'issue-4',
+                    category: 'cov',
+                    title: 'Low Coverage: utils.js',
+                    target: 'src/utils.js',
+                    details: '34% coverage (threshold: 80%)',
+                    meta: 'Missing: 12 uncovered functions',
+                    agent: 'crucible',
+                    priority: 'medium',
+                },
+            ],
+        };
+    }
+}
+
+export async function dispatchTask(issue) {
+    return fetchApi('/api/dispatch', {
+        method: 'POST',
+        body: JSON.stringify({
+            type: issue.category,
+            target: issue.target,
+            agent: issue.agent,
+            context: {
+                title: issue.title,
+                details: issue.details,
+                priority: issue.priority,
+            },
+        }),
+    });
+}