@decido/plugin-chameleon 1.0.0

package/src/types.ts

@@ -0,0 +1,39 @@
+// 1. Vistas Disponibles en la App
+export type ViewType = 'login' | 'madefront_chat' | 'madefront_kanban' | 'madefront_excel' | 'workflow_admin' | 'kuspide_dashboard' | 'discovery_admin' | 'database_admin' | 'dataway_studio';
+
+// 2. Roles del Sistema (Los Cortex)
+export type Role = 'NONE' | 'GERENCIA' | 'CAJA' | 'PLANTA' | 'DESPACHO';
+
+// 3. Estados del Pedido (El Flujo)
+export type OrderStatus = 'DISEÑO' | 'OPTIMIZACION' | 'CAJA' | 'PRODUCCION' | 'DESPACHO' | 'ENTREGADO';
+
+// 4. Máquinas Disponibles
+export type MachineType = 'SIGMA' | 'GABBIANI' | 'HOMAG' | 'PENDIENTE';
+
+// 5. El Pedido Maestro
+export interface MadefrontOrder {
+  id: string;              // MF-2026-001
+  client: string;
+  whatsapp: string;        // +57...
+  material: string;        // Ej: Rh 15mm Blanco
+  measurements: string;    // Texto o Link
+  sheets: number;          // Cantidad de láminas (Para el SLA)
+
+  // Datos Calculados por el "Agente"
+  status: OrderStatus;
+  rawStage?: string;
+  machine: MachineType;
+  slaHours: number;        // 24 o 72
+  createdAt: string;       // ISO Date
+  isUrgent?: boolean;      // Bandera de prioridad
+
+  // Trazabilidad
+  isPaid: boolean;         // Bloqueo de Caja
+  logs: string[];          // Historial de cambios
+}
+
+export interface AgentCommand {
+  action: 'CHANGE_VIEW' | 'SEARCH_ORDER' | 'UPDATE_STATUS' | 'UNKNOWN';
+  payload?: any;
+  message?: string;
+}

package/src/useAgent.ts

@@ -0,0 +1,89 @@
+import { useState, useCallback, useRef } from 'react';
+import { AgentCommand } from './types';
+
+export function useAgent(onCommand: (command: AgentCommand) => void) {
+  const [isListening, setIsListening] = useState(false);
+  const [transcript, setTranscript] = useState('');
+  const [isProcessing, setIsProcessing] = useState(false);
+  const recognitionRef = useRef<any>(null);
+
+  const processInput = useCallback(async (text: string) => {
+    setIsProcessing(true);
+    try {
+      const baseUrl = (import.meta as any).env?.VITE_API_BASE_URL || 'http://localhost:3001';
+      const response = await fetch(`${baseUrl}/api/copilot/ask`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': 'dev_ak_chameleon_studio_99x'
+        },
+        body: JSON.stringify({ message: text })
+      });
+
+      if (!response.ok) {
+        throw new Error(`Failed to process input: ${response.statusText}`);
+      }
+
+      const commandString = await response.text();
+      const command = JSON.parse(commandString) as AgentCommand;
+
+      onCommand(command);
+    } catch (error) {
+      console.error("Error processing input with Backend Copilot:", error);
+      onCommand({ action: 'UNKNOWN', message: 'Lo siento, tuve problemas para procesar eso con el servidor.' });
+    } finally {
+      setIsProcessing(false);
+    }
+  }, [onCommand]);
+
+  const startListening = useCallback(() => {
+    if (!('webkitSpeechRecognition' in window) && !('SpeechRecognition' in window)) {
+      alert("Speech recognition is not supported in this browser.");
+      return;
+    }
+
+    const SpeechRecognition = (window as any).SpeechRecognition || (window as any).webkitSpeechRecognition;
+    const recognition = new SpeechRecognition();
+    recognition.lang = 'es-ES'; // Spanish as requested by user
+    recognition.interimResults = false;
+    recognition.maxAlternatives = 1;
+
+    recognition.onstart = () => {
+      setIsListening(true);
+      setTranscript('');
+    };
+
+    recognition.onresult = (event: any) => {
+      const speechResult = event.results[0][0].transcript;
+      setTranscript(speechResult);
+      processInput(speechResult);
+    };
+
+    recognition.onerror = (event: any) => {
+      console.error("Speech recognition error", event.error);
+      setIsListening(false);
+    };
+
+    recognition.onend = () => {
+      setIsListening(false);
+    };
+
+    recognitionRef.current = recognition;
+    recognition.start();
+  }, [processInput]);
+
+  const stopListening = useCallback(() => {
+    if (recognitionRef.current) {
+      recognitionRef.current.stop();
+    }
+  }, []);
+
+  return {
+    isListening,
+    isProcessing,
+    transcript,
+    startListening,
+    stopListening,
+    processInput
+  };
+}

package/src/utils/sounds.ts

@@ -0,0 +1,52 @@
+export const playUISound = (type: 'pop' | 'swoosh' | 'success' | 'error') => {
+  try {
+    const AudioContextClass = window.AudioContext || (window as any).webkitAudioContext;
+    if (!AudioContextClass) return;
+    
+    const ctx = new AudioContextClass();
+    const osc = ctx.createOscillator();
+    const gain = ctx.createGain();
+    
+    osc.connect(gain);
+    gain.connect(ctx.destination);
+
+    const now = ctx.currentTime;
+
+    if (type === 'pop') {
+      osc.type = 'sine';
+      osc.frequency.setValueAtTime(400, now);
+      osc.frequency.exponentialRampToValueAtTime(600, now + 0.1);
+      gain.gain.setValueAtTime(0.1, now);
+      gain.gain.exponentialRampToValueAtTime(0.01, now + 0.1);
+      osc.start(now);
+      osc.stop(now + 0.1);
+    } else if (type === 'swoosh') {
+      osc.type = 'triangle';
+      osc.frequency.setValueAtTime(150, now);
+      osc.frequency.exponentialRampToValueAtTime(300, now + 0.25);
+      gain.gain.setValueAtTime(0.05, now);
+      gain.gain.exponentialRampToValueAtTime(0.01, now + 0.25);
+      osc.start(now);
+      osc.stop(now + 0.25);
+    } else if (type === 'success') {
+      osc.type = 'sine';
+      osc.frequency.setValueAtTime(440, now); // A4
+      osc.frequency.setValueAtTime(554.37, now + 0.1); // C#5
+      gain.gain.setValueAtTime(0.1, now);
+      gain.gain.setValueAtTime(0.1, now + 0.1);
+      gain.gain.linearRampToValueAtTime(0, now + 0.3);
+      osc.start(now);
+      osc.stop(now + 0.3);
+    } else if (type === 'error') {
+      osc.type = 'sawtooth';
+      osc.frequency.setValueAtTime(200, now);
+      osc.frequency.exponentialRampToValueAtTime(100, now + 0.2);
+      gain.gain.setValueAtTime(0.1, now);
+      gain.gain.linearRampToValueAtTime(0, now + 0.2);
+      osc.start(now);
+      osc.stop(now + 0.2);
+    }
+  } catch (e) {
+    console.error("Audio playback failed", e);
+  }
+};