@decido/plugin-planta-erp 1.0.0

package/src/components/SwarmCanvas.tsx

@@ -0,0 +1,133 @@
+import React, { useState, useEffect } from 'react';
+import { kernel } from '@decido/kernel-bridge';
+import { ReactFlow, Background, BackgroundVariant, Controls } from '@xyflow/react';
+import { nodeTypes, edgeTypes } from '@decido/canvas-core';
+import '@xyflow/react/dist/style.css';
+
+// Pre-posiciones estáticas para los agentes más comunes en el clúster
+const KNOWN_NODE_POSITIONS: Record<string, { x: number, y: number }> = {
+    'user-client': { x: 50, y: 250 },
+    'dev-master': { x: 400, y: 100 },
+    'ui-morpher': { x: 400, y: 400 },
+    'system-orchestrator': { x: 750, y: 250 }
+};
+
+export const SwarmCanvas: React.FC = () => {
+    const [nodes, setNodes] = useState<any[]>([]);
+    const [edges, setEdges] = useState<any[]>([]);
+
+    const [activeAgents, setActiveAgents] = useState<Set<string>>(new Set(['user-client', 'dev-master']));
+
+    useEffect(() => {
+        // Al montar, registrar nodes base
+        const baseNodes = Array.from(activeAgents).map((id, i) => ({
+            id,
+            type: 'moduleNode',
+            position: KNOWN_NODE_POSITIONS[id] || { x: 200 + (i * 100), y: 200 + (Math.random() * 100) },
+            data: {
+                label: id === 'user-client' ? 'Web Client' : id,
+                status: 'active',
+                description: id === 'dev-master' ? 'Rust Orchestrator' : 'Enjambre'
+            }
+        }));
+        setNodes(baseNodes);
+    }, []);
+
+    // Escuchar el Kernel Universal Córtex para Eventos del Enjambre
+    useEffect(() => {
+        const unsubscribe = kernel.onEvent((evt: any) => {
+            if (!evt || !evt.event_type) return;
+
+            // Detectamos si es un mensaje de chat o un Action command
+            if (evt.event_type === 'MessageSent' || evt.event_type === 'AgentCommand') {
+                const messageData = evt.data || {};
+                const from = evt.agent_id || messageData.sender || 'unknown';
+                const to = messageData.target || 'broadcast';
+                const intent = messageData.intent || evt.event_type;
+
+                // Si descubrimos un agente nuevo, lo agreamos al canvas
+                setActiveAgents(prev => {
+                    const next = new Set(prev);
+                    let changed = false;
+                    if (!next.has(from)) { next.add(from); changed = true; }
+                    if (to !== 'broadcast' && !next.has(to)) { next.add(to); changed = true; }
+
+                    if (changed) {
+                        // Actualizar Nodos
+                        const allAgents = Array.from(next);
+                        setNodes(allAgents.map((id) => ({
+                            id,
+                            type: 'moduleNode',
+                            position: KNOWN_NODE_POSITIONS[id] || { x: 300 + (Math.random() * 300), y: 150 + (Math.random() * 300) },
+                            data: { label: id, status: 'active' }
+                        })));
+                    }
+                    return next;
+                });
+
+                // Crear Edge Animado (Sonda Visual)
+                const edgeId = `edge-${Date.now()}-${Math.random()}`;
+                const newEdge = {
+                    id: edgeId,
+                    source: from,
+                    target: to === 'broadcast' ? 'dev-master' : to, // Fallback visual
+                    type: 'animatedEdge',
+                    animated: true,
+                    data: { label: intent }
+                };
+
+                setEdges(prev => [...prev, newEdge]);
+
+                // Remover el edge después de 4 segundos para no saturar el canvas (efecto "pulso")
+                setTimeout(() => {
+                    setEdges(prev => prev.filter(e => e.id !== edgeId));
+                }, 4000);
+            }
+        });
+
+        // También escuchamos nuestro propio evento sintético (como fallback a eventos en la memoria local del navegador)
+        const handleSynthetic = (_e: any) => {
+            // Este fallback es solo por si kernel.onEvent falla en la configuración hibrida.
+            // Pero con el Proxy Relay de Node esto debería llegar nativamente por redis stream.
+        };
+
+        window.addEventListener('kernel-synthetic-message', handleSynthetic);
+
+        return () => {
+            unsubscribe();
+            window.removeEventListener('kernel-synthetic-message', handleSynthetic);
+        };
+    }, []);
+
+    return (
+        <div className="w-full h-full bg-[#0a0a0a] rounded-xl overflow-hidden border border-white/10 relative">
+            <div className="absolute top-4 left-4 z-10 bg-black/60 backdrop-blur-md px-4 py-2 rounded-lg border border-primary/20">
+                <h3 className="text-white font-bold flex items-center gap-2">
+                    <span className="w-2 h-2 rounded-full bg-green-500 animate-pulse"></span>
+                    Swarm Flow Probes
+                </h3>
+                <p className="text-xs text-gray-400 mt-1">Interceptando Redis/RPC Bus</p>
+            </div>
+            <ReactFlow
+                nodes={nodes}
+                edges={edges}
+                onNodesChange={(changes: any) => {
+                    // Mapear cambios localmente si se arrastran interactuando
+                    setNodes(nds => nds.map(n => {
+                        const change = changes.find((c: any) => c.id === n.id);
+                        if (change && change.type === 'position' && change.position) {
+                            return { ...n, position: change.position };
+                        }
+                        return n;
+                    }));
+                }}
+                nodeTypes={nodeTypes}
+                edgeTypes={edgeTypes as any}
+                fitView
+            >
+                <Background variant={BackgroundVariant.Dots} color="rgba(0, 255, 136, 0.15)" />
+                <Controls />
+            </ReactFlow>
+        </div>
+    );
+};

package/src/dev-mount.tsx

@@ -0,0 +1,10 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import { PhysicalCanvas } from './components/DigitalTwin/PhysicalCanvas';
+import './index.css';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+    <React.StrictMode>
+        <PhysicalCanvas />
+    </React.StrictMode>
+);

package/src/index.css

@@ -0,0 +1,3 @@
+@import "tailwindcss";
+@import "@decido/ui-kit/src/tokens.css";
+@import "@decido/ui-kit/src/primitives.css";

package/src/logic/rules.ts

@@ -0,0 +1,39 @@
+import { MachineType } from '../types';
+
+/**
+ * Agente: SLA Sentinel
+ * Regla: < 5 láminas = 24h, >= 5 láminas = 72h
+ */
+export const calculateSLA = (sheets: number): number => {
+    return sheets < 5 ? 24 : 72;
+};
+
+/**
+ * Agente: Router AI
+ * Regla: Asignación de máquinas según material y complejidad
+ */
+export const assignMachine = (material: string, sheets: number): MachineType => {
+    const mat = material.toLowerCase();
+
+    if (mat.includes('perforacion') || mat.includes('diseño') || mat.includes('cnc')) {
+        return 'HOMAG'; // CNC para cosas complejas
+    }
+
+    if (sheets > 10 || mat.includes('grueso') || mat.includes('18mm')) {
+        return 'GABBIANI'; // Trabajo pesado
+    }
+
+    return 'SIGMA'; // Corte rápido estándar
+};
+
+/**
+ * Agente: Phone Doctor
+ * Regla: Asegurar formato +57 para WhatsApp
+ */
+export const sanitizePhone = (phone: string): string => {
+    const digits = phone.replace(/\D/g, '');
+    if (!digits.startsWith('57')) {
+        return `+57 ${digits}`;
+    }
+    return `+${digits}`;
+};

package/src/logic/workflowGuard.ts

@@ -0,0 +1,45 @@
+import { MadefrontOrder, OrderStatus } from '../types';
+
+interface TransitionResult {
+    allowed: boolean;
+    reason?: string;
+}
+
+// Mapa de transiciones permitidas (Máquina de Estados)
+const ALLOWED_TRANSITIONS: Record<OrderStatus, OrderStatus[]> = {
+    'DISEÑO': ['OPTIMIZACION', 'CAJA'], // Puede saltar a caja si no requiere despiece
+    'OPTIMIZACION': ['CAJA'],
+    'CAJA': ['PRODUCCION'],
+    'PRODUCCION': ['DESPACHO'],
+    'DESPACHO': ['ENTREGADO'],
+    'ENTREGADO': []
+};
+
+export const canTransition = (order: MadefrontOrder, targetStatus: OrderStatus): TransitionResult => {
+    const currentStatus = order.status;
+
+    // 1. Validar que la ruta exista en el grafo
+    const validNextStates = ALLOWED_TRANSITIONS[currentStatus] || [];
+    if (!validNextStates.includes(targetStatus)) {
+        return {
+            allowed: false,
+            reason: `Flujo inválido: No se puede pasar de ${currentStatus} a ${targetStatus}.`
+        };
+    }
+
+    // 2. Reglas Hardcore de Negocio (Las que nos dio Ana)
+    if (targetStatus === 'PRODUCCION') {
+        if (!order.isPaid) {
+            return { allowed: false, reason: 'Bloqueo de Caja: El pedido debe estar pagado para entrar a Planta.' };
+        }
+    }
+
+    if (targetStatus === 'DESPACHO') {
+        // En el futuro: validar que la máquina (Sigma/Homag) haya emitido el evento de fin
+        if (order.status !== 'PRODUCCION') {
+            return { allowed: false, reason: 'El pedido debe salir de producción antes de despacharse.' };
+        }
+    }
+
+    return { allowed: true };
+};

package/src/stores/digitalTwinStore.ts

@@ -0,0 +1,66 @@
+import { create } from 'zustand';
+
+export type MachineState = 'idle' | 'processing' | 'error';
+export type ObjectType = 'machine' | 'order' | 'operator';
+
+export interface SpatialNode {
+    id: string;
+    type: ObjectType;
+    position: [number, number, number]; // [x, y, z]
+    rotation?: [number, number, number];
+    state?: string;
+    metadata?: Record<string, any>;
+}
+
+interface DigitalTwinState {
+    nodes: Record<string, SpatialNode>;
+    addNode: (node: SpatialNode) => void;
+    updateNodePosition: (id: string, position: [number, number, number], rotation?: [number, number, number]) => void;
+    updateNodeState: (id: string, state: string, metadata?: any) => void;
+    removeNode: (id: string) => void;
+}
+
+export const useDigitalTwinStore = create<DigitalTwinState>((set) => ({
+    nodes: {
+        // Mock default physical layout: Workstations
+        'corte-1': { id: 'corte-1', type: 'machine', position: [-4, 0, -2], state: 'idle', metadata: { name: 'Sierra Escuadradora' } },
+        'corte-2': { id: 'corte-2', type: 'machine', position: [4, 0, -2], state: 'processing', metadata: { name: 'CNC Router' } },
+        'ensamble-1': { id: 'ensamble-1', type: 'machine', position: [0, 0, 4], state: 'idle', metadata: { name: 'Zona Ensamble' } },
+    },
+
+    addNode: (node) => set((state) => ({
+        nodes: { ...state.nodes, [node.id]: node }
+    })),
+
+    updateNodePosition: (id, position, rotation) => set((state) => {
+        const node = state.nodes[id];
+        if (!node) return state;
+        return {
+            nodes: {
+                ...state.nodes,
+                [id]: { ...node, position, rotation: rotation || node.rotation }
+            }
+        };
+    }),
+
+    updateNodeState: (id, newState, metadata) => set((state) => {
+        const node = state.nodes[id];
+        if (!node) return state;
+        return {
+            nodes: {
+                ...state.nodes,
+                [id]: {
+                    ...node,
+                    state: newState,
+                    metadata: metadata ? { ...node.metadata, ...metadata } : node.metadata
+                }
+            }
+        };
+    }),
+
+    removeNode: (id) => set((state) => {
+        const newNodes = { ...state.nodes };
+        delete newNodes[id];
+        return { nodes: newNodes };
+    })
+}));

package/src/stores/uiStore.ts

@@ -0,0 +1,19 @@
+import { create } from 'zustand';
+import { ViewType } from '../types';
+
+interface UIState {
+    currentView: ViewType;
+    searchTerm: string;
+
+    // Actions
+    setCurrentView: (view: ViewType) => void;
+    setSearchTerm: (term: string) => void;
+}
+
+export const useUIStore = create<UIState>((set) => ({
+    currentView: 'login',
+    searchTerm: '',
+
+    setCurrentView: (view) => set({ currentView: view }),
+    setSearchTerm: (term) => set({ searchTerm: term })
+}));

package/src/types.ts

@@ -0,0 +1,38 @@
+// 1. Vistas Disponibles en la App
+export type ViewType = 'login' | 'madefront_chat' | 'madefront_kanban' | 'madefront_excel' | 'workflow_admin';
+
+// 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;
+  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' | 'UNKNOWN';
+  payload?: any;
+  message?: string;
+}

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);
+  }
+};

package/src-backend/index.ts

@@ -0,0 +1,62 @@
+import { Router } from 'express';
+import { Server } from 'socket.io';
+import { IServerPlugin } from '@decido/sdk';
+import { plantaMigrations } from './migrations';
+
+/**
+ * Dependencias físicas de la industria privada proporcionadas
+ * por el Host para inyección y enrutamiento en el Gemelo Digital.
+ */
+export interface PlantaErpBackendDeps {
+    digitalTwinRouter: Router;
+    simulationRouter: Router;
+    simulationStudioRouter: Router;
+    trackingRouter: Router;
+    whatsappAutomationRouter: Router;
+    whatsappWebhookRouter: Router;
+    initServicesHook?: () => Promise<void>;
+    initSocketsHook?: (io: Server) => void;
+}
+
+/**
+ * Crea la Extensión B2B para Planta Industria, conectando
+ * el Engine de Renderizado, Simulaciones y Automatización WA.
+ */
+export const createPlantaErpServerPlugin = (deps: PlantaErpBackendDeps): IServerPlugin => ({
+    name: 'planta_erp_backend',
+
+    mountRoutes: (apiRouter: Router) => {
+        // Enrutamiento Patentado Industrial
+        apiRouter.use('/twin', deps.digitalTwinRouter);
+        apiRouter.use('/simulation', deps.simulationRouter);
+        apiRouter.use('/scenarios', deps.simulationStudioRouter);
+
+        // Alias de retrocompatibilidad
+        apiRouter.use('/simulation/scenarios', deps.simulationStudioRouter);
+
+        apiRouter.use('/track', deps.trackingRouter);
+        apiRouter.use('/whatsapp', deps.whatsappAutomationRouter);
+        apiRouter.use('/webhooks/whatsapp', deps.whatsappWebhookRouter);
+    },
+
+    mountSockets: (io: Server) => {
+        if (deps.initSocketsHook) {
+            deps.initSocketsHook(io);
+        }
+    },
+
+    initServices: async () => {
+        console.log('[PlantaErpServerPlugin] Initializing Industrial services...');
+        if (deps.initServicesHook) {
+            await deps.initServicesHook();
+        }
+    },
+
+    getMigrations: async () => {
+        return {
+            pluginName: 'planta_erp_backend',
+            schemaName: 'planta',
+            migrations: plantaMigrations
+        };
+    }
+});

package/src-backend/migrations.ts

@@ -0,0 +1,33 @@
+export const plantaMigrations = [
+    {
+        name: '001_init_planta_schema',
+        sql: `
+            -- 1. Create Schema
+            CREATE SCHEMA IF NOT EXISTS planta;
+
+            -- 2. Create Base Machine Nodes Table (Industrial Property)
+            CREATE TABLE IF NOT EXISTS planta.machine_nodes (
+                id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+                tenant_id UUID NOT NULL,
+                name VARCHAR(255) NOT NULL,
+                node_type VARCHAR(100) NOT NULL,
+                metadata JSONB DEFAULT '{}',
+                created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+            );
+
+            -- 3. Enforce RLS (Zero-Trust Security)
+            ALTER TABLE planta.machine_nodes ENABLE ROW LEVEL SECURITY;
+            
+            DO $$ 
+            BEGIN
+                IF NOT EXISTS (
+                    SELECT 1 FROM pg_policies 
+                    WHERE schemaname = 'planta' AND tablename = 'machine_nodes' AND policyname = 'tenant_isolation_policy'
+                ) THEN
+                    CREATE POLICY tenant_isolation_policy ON planta.machine_nodes
+                        USING (tenant_id = nullif(current_setting('app.current_tenant', true), '')::uuid);
+                END IF;
+            END $$;
+        `
+    }
+];

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "extends": "../../../tsconfig.base.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "rootDir": ".",
+        "moduleResolution": "Bundler",
+        "lib": [
+            "DOM",
+            "DOM.Iterable",
+            "ES2023"
+        ]
+    },
+    "include": [
+        "index.ts",
+        "manifest.ts",
+        "src/**/*.ts",
+        "src/**/*.tsx"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+    entry: ["index.ts"],
+    format: ["cjs", "esm"],
+    dts: true,
+    clean: true,
+});

package/vite.config.ts

@@ -0,0 +1,39 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+
+export default defineConfig({
+    base: 'http://localhost:5004/',
+    plugins: [
+        tailwindcss(),
+        react()
+    ],
+    server: {
+        host: true,
+        port: 5004,
+        strictPort: true,
+        cors: true
+    },
+    preview: {
+        host: true,
+        port: 5004,
+        strictPort: true,
+        cors: true
+    },
+    build: {
+        modulePreload: false,
+        target: ['chrome89', 'edge89', 'firefox89', 'safari15'],
+        minify: false,
+        cssCodeSplit: false,
+        rollupOptions: {
+            output: {
+                assetFileNames: (assetInfo) => {
+                    if (assetInfo.name === 'style.css' || assetInfo.name?.endsWith('.css')) {
+                        return 'assets/style.css';
+                    }
+                    return 'assets/[name]-[hash][extname]';
+                }
+            }
+        }
+    }
+});