+//
+// );
+// };
+// export default ActivateConnectionModal;
diff --git a/frontend/src/components/ApiCalls.tsx b/frontend/src/components/ApiCalls.tsx
new file mode 100644
index 0000000..36d42ec
--- /dev/null
+++ b/frontend/src/components/ApiCalls.tsx
@@ -0,0 +1,23 @@
+import React from 'react';
+import { DataTable } from 'primereact/datatable';
+import { Column } from 'primereact/column';
+import { useApiLogStore } from '../services/apiLogStore';
+
+const ApiCalls = () => {
+ const apiLogs = useApiLogStore((state) => state.apiLogs);
+
+ return (
+
+//
+//
+//
+//
+//
+
+ {/*
+
+ );
+};
+
+export default ApiCalls;
diff --git a/frontend/src/components/AuthWrapper.tsx b/frontend/src/components/AuthWrapper.tsx
new file mode 100644
index 0000000..5e208b3
--- /dev/null
+++ b/frontend/src/components/AuthWrapper.tsx
@@ -0,0 +1,40 @@
+import { useLocation, useNavigate } from 'react-router-dom';
+import { getExpirationDateFromToken, useAuth } from '../hooks/useAuth';
+import { useEffect } from 'react';
+
+const AuthWrapper = ({ children }) => {
+ const location = useLocation();
+ const navigate = useNavigate();
+ const { logout } = useAuth();
+
+ useEffect(() => {
+ const user = localStorage.getItem('user');
+ const isLoginPage = location.pathname === '/login';
+
+ if (!user && !isLoginPage) {
+ navigate('/', { replace: true });
+ }
+
+ checkUserToken();
+ }, [location.pathname, navigate]);
+
+ const checkUserToken = () => {
+ const user = localStorage.getItem('user');
+ if (!user) return navigate('/');
+
+ const parsedUser = JSON.parse(user);
+ if (parsedUser) {
+ let expiredDate = getExpirationDateFromToken(parsedUser.token);
+ const currentDate = new Date();
+
+ if (expiredDate < currentDate) {
+ logout();
+ navigate('/');
+ }
+ }
+ };
+
+ return <>{children};
+};
+
+export default AuthWrapper;
diff --git a/frontend/src/components/Avatar.tsx b/frontend/src/components/Avatar.tsx
new file mode 100644
index 0000000..a9a2f75
--- /dev/null
+++ b/frontend/src/components/Avatar.tsx
@@ -0,0 +1,32 @@
+import React from 'react';
+
+interface AvatarProps {
+ avatarUrl: string;
+ name: string;
+ type: 'CFO' | 'CPO' | 'CTO'; // Specific types
+ speech?: string;
+}
+
+const Avatar: React.FCAPI Calls
+
+ {/* Avatar Image */}
+
+);
+
+export default Avatar;
diff --git a/frontend/src/components/Chat.tsx b/frontend/src/components/Chat.tsx
new file mode 100644
index 0000000..9d51c44
--- /dev/null
+++ b/frontend/src/components/Chat.tsx
@@ -0,0 +1,110 @@
+// import React, { useState, useEffect, useRef } from 'react';
+// import { InputText } from 'primereact/inputtext';
+// import { Button } from 'primereact/button';
+// import { Toast } from 'primereact/toast';
+// import { Dialog } from 'primereact/dialog';
+// import { Card } from 'primereact/card';
+// import io, { Socket } from 'socket.io-client';
+
+// interface ChatProps {
+// serverUrl: string;
+// }
+
+// const Chat: React.FC
+ 
+
+ {/* Name and Type */}
+ {name}
+ {type}
+ {/* Speech Bubble */}
+ {speech && (
+
+ {speech}
+
+ )}
+
+//
+//
+// Click to chat
+//
+
+ {tableData.columns.map(col => (
+
+
+ );
+};
\ No newline at end of file
diff --git a/frontend/src/components/CouncilAI/CouncilAI.tsx b/frontend/src/components/CouncilAI/CouncilAI.tsx
new file mode 100644
index 0000000..c3eeef8
--- /dev/null
+++ b/frontend/src/components/CouncilAI/CouncilAI.tsx
@@ -0,0 +1,103 @@
+import { useState } from 'react';
+import Avatar from '../Avatar';
+import { InputText } from 'primereact/inputtext';
+import Button from '../../shared/components/_V2/Button';
+import maleAvatar from '../../assets/male-avatar.png';
+import femaleAvatar from '../../assets/female-avatar.png';
+import { useChatStore } from '../../state/stores/useChatStore';
+
+const PromptBoxModal = ({ response }) => {
+ return response ? (
+
+ Assistant: {response}
+
+ ) : null;
+};
+
+const PromptBox = ({ onSubmit, activeRole }) => {
+ const [input, setInput] = useState('');
+
+ const handleSubmit = (e) => {
+ e.preventDefault();
+ if (input.trim()) {
+ onSubmit(input);
+ setInput('');
+ }
+ };
+
+ return (
+
+ );
+};
+
+export default function AvatarPromptScreen() {
+ const [responses, setResponses] = useState({ cfo: '', cpo: '' });
+ const [activeRole, setActiveRole] = useState('CFO');
+ const { sendChatRequest } = useChatStore();
+
+ const handlePromptSubmit = async (message) => {
+ console.log(`Prompt submitted for ${activeRole}:`, message);
+ const requestData = { keywords: ['example', 'test'], data: message };
+ try {
+ const result = await sendChatRequest('/chat/completions', requestData);
+ const responseText = result.responseText || 'No response from server';
+ setResponses((prev) => ({
+ ...prev,
+ [activeRole.toLowerCase()]: responseText,
+ }));
+ } catch (error) {
+ console.error('API request failed:', error);
+ setResponses((prev) => ({
+ ...prev,
+ [activeRole.toLowerCase()]: 'Error communicating with server',
+ }));
+ }
+ };
+
+ return (
+
+
+ );
+}
diff --git a/frontend/src/components/CouncilAI/PromptBoxModal.tsx b/frontend/src/components/CouncilAI/PromptBoxModal.tsx
new file mode 100644
index 0000000..374f090
--- /dev/null
+++ b/frontend/src/components/CouncilAI/PromptBoxModal.tsx
@@ -0,0 +1,84 @@
+import { useState } from 'react';
+import PropTypes from 'prop-types';
+import { Dialog } from 'primereact/dialog';
+import { InputText } from 'primereact/inputtext';
+import Button from '../../shared/components/_V2/Button';
+import { useChatStore } from '../../state/stores/useChatStore';
+
+const PromptBoxModal = ({ onSubmit }) => {
+ const [promptMessage, setPromptMessage] = useState('');
+ const [latestMessage, setLatestMessage] = useState({ user: '', response: '' });
+ const [isModalOpen, setIsModalOpen] = useState(false);
+ const { sendChatRequest } = useChatStore();
+
+ const handleFormSubmit = async (event) => {
+ event.preventDefault();
+ if (promptMessage.trim()) {
+ const requestData = {
+ keywords: ['example', 'test'],
+ data: promptMessage,
+ };
+
+ setLatestMessage({ user: promptMessage, response: '' });
+
+ try {
+ const result = await sendChatRequest('/chat/completions', requestData);
+ const responseText = result.responseText || 'No response from server';
+ setLatestMessage({ user: promptMessage, response: responseText });
+ setIsModalOpen(true);
+ } catch (error) {
+ console.error('API request failed:', error);
+ setLatestMessage({ user: promptMessage, response: 'Error communicating with server' });
+ setIsModalOpen(true);
+ }
+
+ onSubmit(requestData);
+ setPromptMessage('');
+ }
+ };
+
+ return (
+
+ {/* CFO (Column 2) */}
+
+
+ {/* Full Width Input Box */}
+
+
+
+ {/* CPO (Column 5) */}
+ setActiveRole('CFO')}>
+
+
+
+ setActiveRole('CPO')}>
+
+
+
+
+
+
+ {/* Modal for Latest Question & Response */}
+
+
+ );
+};
+
+PromptBoxModal.propTypes = {
+ onSubmit: PropTypes.func.isRequired,
+};
+
+export default PromptBoxModal;
diff --git a/frontend/src/components/FuseMind/Avatar/MoleculeAvatar.tsx b/frontend/src/components/FuseMind/Avatar/MoleculeAvatar.tsx
new file mode 100644
index 0000000..09a62f6
--- /dev/null
+++ b/frontend/src/components/FuseMind/Avatar/MoleculeAvatar.tsx
@@ -0,0 +1,83 @@
+import React from 'react';
+
+const MoleculeAvatar: React.FC = () => {
+ return (
+
+
+
+
+
+
+ );
+};
+
+export default MoleculeAvatar;
diff --git a/frontend/src/components/FuseMind/Chat/ChatBubble.tsx b/frontend/src/components/FuseMind/Chat/ChatBubble.tsx
new file mode 100644
index 0000000..f12626c
--- /dev/null
+++ b/frontend/src/components/FuseMind/Chat/ChatBubble.tsx
@@ -0,0 +1,54 @@
+import React from 'react';
+import { Message } from '../../../types/fusemind/messages';
+
+interface ChatBubbleProps {
+ message: Message | null;
+ position: 'left' | 'right';
+ bgColor?: string;
+ isVisible?: boolean;
+}
+
+const ChatBubble: React.FC
+
+ );
+};
+
+export default ChatBubble;
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/FuseMind.tsx b/frontend/src/components/FuseMind/FuseMind.tsx
new file mode 100644
index 0000000..8645ab9
--- /dev/null
+++ b/frontend/src/components/FuseMind/FuseMind.tsx
@@ -0,0 +1,17 @@
+import React from 'react';
+import { useLocation } from 'react-router-dom';
+import FuseMindHome from './FuseMindHome';
+
+const FuseMind: React.FC = () => {
+ const location = useLocation();
+ const path = location.pathname.split('/').pop() || 'home';
+
+ // If we're at the home route, render FuseMindHome directly
+ if (path === 'home' || path === 'fusemind') {
+ return
+
+
+
+ + {message.content} +
++ {formatTime(message.timestamp)} +
+
+
+ );
+};
+
+export default FuseMindHome;
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/README.md b/frontend/src/components/FuseMind/README.md
new file mode 100644
index 0000000..b66cf68
--- /dev/null
+++ b/frontend/src/components/FuseMind/README.md
@@ -0,0 +1,189 @@
+# FuseMind Memory System Architecture
+
+## Overview
+FuseMind implements a sophisticated memory system that combines psychological memory models with modern LLM capabilities. The system is designed to be modular and extensible, allowing for gradual implementation and refinement.
+
+## Core Concepts
+
+### Memory Types
+1. **Episodic Memory**
+ - Stores specific events and experiences
+ - Includes temporal and emotional context
+ - Used for conversation history and user interactions
+
+2. **Semantic Memory**
+ - Stores general knowledge and facts
+ - Includes relationships between concepts
+ - Used for system knowledge and agent capabilities
+
+3. **Procedural Memory**
+ - Stores skills and procedures
+ - Includes conditions and exceptions
+ - Used for agent behaviors and capabilities
+
+4. **Life Event Memory**
+ - Stores significant life events
+ - Tracks emotional impact and phases
+ - Influences memory formation and retrieval
+
+### Emotional Context
+- Tracks emotional state (mood, energy, stress, focus)
+- Manages emotional triggers and biases
+- Influences memory formation and retrieval
+- Handles emotional volatility and stability
+
+### Temporal Context
+- Tracks life events and their duration
+- Manages memory decay and importance
+- Handles period-specific biases
+- Influences memory relevance
+
+## Technical Implementation
+
+### Memory Service
+The `MemoryService` class handles all memory operations:
+- Memory storage and retrieval
+- Emotional state management
+- Life event tracking
+- Memory consolidation
+
+### Database Schema
+Memories are stored with the following structure:
+```typescript
+interface DatabaseMemory {
+ id: string;
+ type: MemoryType;
+ content: string; // JSON stringified
+ temporal: string; // JSON stringified
+ emotional: string; // JSON stringified
+ connections: string; // JSON stringified
+ created_at: Date;
+ updated_at: Date;
+}
+```
+
+### React Integration
+The system provides a `useFusemindMemory` hook for React components:
+```typescript
+const {
+ activeMemories,
+ emotionalState,
+ storeMemory,
+ retrieveMemories,
+ updateEmotionalState
+} = useFusemindMemory();
+```
+
+## Implementation Roadmap
+
+### Phase 1: Core Memory System
+- [x] Basic memory types and interfaces
+- [x] Memory service implementation
+- [x] React integration
+- [ ] Database integration
+
+### Phase 2: Emotional Context
+- [ ] Emotional state tracking
+- [ ] Trigger management
+- [ ] Bias handling
+- [ ] Emotional influence on memory
+
+### Phase 3: Life Events
+- [ ] Life event tracking
+- [ ] Event phase management
+- [ ] Recovery and healing
+- [ ] Temporal context influence
+
+### Phase 4: LLM Integration
+- [ ] Context window management
+- [ ] Embedding storage and retrieval
+- [ ] Prompt template management
+- [ ] Memory-augmented generation
+
+## Usage Examples
+
+### Storing a Memory
+```typescript
+const memory: MemoryUnit = {
+ id: generateId(),
+ type: 'episodic',
+ content: {
+ data: { /* memory content */ },
+ metadata: { /* additional info */ }
+ },
+ temporal: {
+ created: new Date(),
+ modified: new Date(),
+ lastAccessed: new Date(),
+ decayRate: 0.1,
+ importance: 0.8
+ },
+ emotional: {
+ valence: 0.5,
+ arousal: 0.3,
+ emotionalTags: ['positive', 'exciting']
+ },
+ connections: []
+};
+
+await memoryService.storeMemory(memory);
+```
+
+### Retrieving Memories
+```typescript
+const memories = await memoryService.retrieveMemory({
+ query: 'search term',
+ context: {
+ currentTask: 'task description',
+ emotionalState: 'current state'
+ },
+ filters: {
+ type: 'episodic',
+ timeRange: [startDate, endDate]
+ }
+});
+```
+
+## Best Practices
+
+1. **Memory Formation**
+ - Always include temporal and emotional context
+ - Consider current life events
+ - Track memory importance and decay
+
+2. **Memory Retrieval**
+ - Use appropriate filters
+ - Consider emotional context
+ - Account for temporal relevance
+
+3. **Life Event Management**
+ - Track event phases
+ - Monitor emotional impact
+ - Handle event transitions
+
+4. **Emotional State**
+ - Update state gradually
+ - Consider multiple factors
+ - Handle state transitions
+
+## Future Enhancements
+
+1. **Advanced Memory Processing**
+ - Machine learning for memory importance
+ - Automated memory consolidation
+ - Dynamic decay rates
+
+2. **Enhanced Emotional Context**
+ - Multi-dimensional emotional states
+ - Complex trigger patterns
+ - Emotional memory networks
+
+3. **Improved LLM Integration**
+ - Context-aware prompting
+ - Memory-augmented generation
+ - Dynamic context management
+
+4. **Visualization Tools**
+ - Memory network visualization
+ - Emotional state tracking
+ - Life event timeline
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/GridCellIndicator.tsx b/frontend/src/components/FuseMind/modals/GridCellIndicator.tsx
new file mode 100644
index 0000000..360c5c6
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/GridCellIndicator.tsx
@@ -0,0 +1,117 @@
+import React from 'react';
+
+interface GridCellIndicatorProps {
+ startCol: number;
+ startRow: number;
+ width: number;
+ height: number;
+ onResize?: (newWidth: number, newHeight: number) => void;
+}
+
+const GridCellIndicator: React.FC
+ {/* Grid Container */}
+
+
+
+
+
+
+ {/* Grid Lines and Labels */}
+
+
+ {/* Grid Cells with Coordinates */}
+ {Array.from({ length: 160 }).map((_, i) => {
+ const col = i % 20;
+ const row = Math.floor(i / 20);
+ const colLabel = String.fromCharCode(65 + col);
+ const rowLabel = row + 1;
+ return (
+
+ {/* Modal Container */}
+
+
+ {`${colLabel}${rowLabel}`}
+
+
+ );
+ })}
+
+
+
+ {messages.map((message) => (
+
+
+
+ ))}
+
+
+
+
+
+
+
+ handleResizeStart(e, 'se')}
+ />
+ setInputValue(e.target.value)}
+ rows={5}
+ cols={50}
+ />
+
+ );
+};
+
+export default DeleteModal;
diff --git a/frontend/src/state/stores/useAuthStore.ts b/frontend/src/state/stores/useAuthStore.ts
new file mode 100644
index 0000000..73987a8
--- /dev/null
+++ b/frontend/src/state/stores/useAuthStore.ts
@@ -0,0 +1,63 @@
+import { create } from 'zustand';
+import { api } from '../../services/api';
+
+type User = {
+ id: number;
+ username: string;
+ roles: string[];
+};
+
+type AuthStore = {
+ user: User | null;
+ token: string | null;
+ isLoggedIn: boolean;
+ login: (username: string, password: string) => Promise;
+ logout: () => void;
+};
+
+export const useAuthStore = create((set) => ({
+ user: JSON.parse(localStorage.getItem('user') || 'null'),
+ token: localStorage.getItem('token'),
+ isLoggedIn: !!localStorage.getItem('token'),
+
+ login: async (username: string, password: string) => {
+ try {
+ const response = await api('post', '/api/v1/app/users/login', { username, password });
+ const { success, data } = response.data;
+
+ if (success) {
+ const { token, user } = data;
+ localStorage.setItem('user', JSON.stringify(user));
+ localStorage.setItem('token', token);
+
+ set({ user, token, isLoggedIn: true });
+ } else {
+ throw new Error('Login failed');
+ }
+ } catch (error) {
+ console.error('Failed to login:', error);
+ throw new Error('Login failed');
+ }
+ },
+
+ logout: () => {
+ localStorage.removeItem('user');
+ localStorage.removeItem('token');
+ set({ user: null, token: null, isLoggedIn: false });
+ },
+}));
+
+function parseJwt(token) {
+ const base64Url = token.split('.')[1];
+ const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+ const jsonPayload = decodeURIComponent(
+ atob(base64)
+ .split('')
+ .map(function (c) {
+ return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+ })
+ .join('')
+ );
+
+ return JSON.parse(jsonPayload);
+}
diff --git a/frontend/src/state/stores/useChatStore.ts b/frontend/src/state/stores/useChatStore.ts
new file mode 100644
index 0000000..76c1b8b
--- /dev/null
+++ b/frontend/src/state/stores/useChatStore.ts
@@ -0,0 +1,41 @@
+import { create } from 'zustand';
+import { api } from '../../services/api';
+
+interface ChatRequestData {
+ data: string;
+ responseFormat?: 'text' | 'json';
+ model?: string;
+}
+
+type ChatStore = {
+ sendChatRequest: (endpoint: string, data: ChatRequestData) => Promise;
+};
+
+export const useChatStore = create(() => ({
+ sendChatRequest: async (endpoint, requestData) => {
+ try {
+ if (
+ !requestData.data ||
+ typeof requestData.data !== 'string' ||
+ requestData.data.trim() === ''
+ ) {
+ throw new Error("Invalid input: 'data' must be a non-empty string.");
+ }
+
+ const formattedRequest = {
+ data: requestData.data,
+ // model: requestData.model || 'gpt-4o-mini',
+ model: requestData.model || 'o4-mini',
+ response_format: requestData.responseFormat === 'json' ? { type: 'json_object' } : undefined
+ };
+
+ console.log('Sending formatted request:', formattedRequest);
+ const response = await api('post', `/council${endpoint}`, formattedRequest, undefined, 'json', 60, true);
+ console.log('Got API response:', response);
+ return response.data;
+ } catch (error) {
+ console.error(`Failed to send chat request to ${endpoint}:`, error);
+ throw error;
+ }
+ },
+}));
diff --git a/frontend/src/state/stores/useSystemStore.ts b/frontend/src/state/stores/useSystemStore.ts
new file mode 100644
index 0000000..52043ec
--- /dev/null
+++ b/frontend/src/state/stores/useSystemStore.ts
@@ -0,0 +1,30 @@
+// Adjusting the store to handle SystemDropdownOption properly
+import { create } from 'zustand';
+import { Enterprise } from '../../components/SystemSelectionModal';
+
+export type System = {
+ id: number;
+ name: string;
+ logo: string;
+};
+
+export type SystemDropdownOption = {
+ id: number;
+ label: string;
+ businessLabel: string;
+ urlSlug: string;
+ logo: string;
+ enterprises?: Enterprise[];
+};
+
+type SystemStore = {
+ currentSystem: SystemDropdownOption | null;
+ setSystem: (system: SystemDropdownOption) => void;
+ clearSystem: () => void;
+};
+
+export const useSystemStore = create((set) => ({
+ currentSystem: null,
+ setSystem: (system: SystemDropdownOption) => set({ currentSystem: system }),
+ clearSystem: () => set({ currentSystem: null }),
+}));
diff --git a/frontend/src/types/DataTable.types.ts b/frontend/src/types/DataTable.types.ts
new file mode 100644
index 0000000..0860996
--- /dev/null
+++ b/frontend/src/types/DataTable.types.ts
@@ -0,0 +1 @@
+export type TSizeOptionValue = 'small' | 'normal' | 'large';
diff --git a/frontend/src/types/fusemind/avatar.ts b/frontend/src/types/fusemind/avatar.ts
new file mode 100644
index 0000000..c455794
--- /dev/null
+++ b/frontend/src/types/fusemind/avatar.ts
@@ -0,0 +1,13 @@
+export type AvatarPosition = 'left' | 'center' | 'right';
+
+export interface AvatarState {
+ position: AvatarPosition;
+ isVisible: boolean;
+ isAnimating: boolean;
+}
+
+export interface AvatarConfig {
+ size: number;
+ color: string;
+ animationDuration: number;
+}
\ No newline at end of file
diff --git a/frontend/src/types/fusemind/memory.ts b/frontend/src/types/fusemind/memory.ts
new file mode 100644
index 0000000..ca8aed2
--- /dev/null
+++ b/frontend/src/types/fusemind/memory.ts
@@ -0,0 +1,371 @@
+// Core memory interfaces
+export interface MemoryUnit {
+ id: string;
+ type: MemoryType;
+ content: MemoryContent;
+ temporal: TemporalProperties;
+ emotional: EmotionalProperties;
+ connections: MemoryConnection[];
+}
+
+export type MemoryType = 'episodic' | 'semantic' | 'procedural' | 'sensory' | 'llm_context' | 'embedding' | 'prompt' | 'life_event';
+
+export interface MemoryContent {
+ data: any;
+ metadata: Record;
+ confidence: number; // 0-1 scale
+ source: string;
+}
+
+export interface TemporalProperties {
+ created: Date;
+ modified: Date;
+ lastAccessed: Date;
+ decayRate: number; // How quickly the memory fades (0-1)
+ importance: number; // 0-1 scale
+ lifeEvents: {
+ eventId: string;
+ type: 'personal' | 'professional' | 'social' | 'health';
+ startDate: Date;
+ endDate?: Date;
+ intensity: number; // 0-1 scale
+ emotionalImpact: {
+ valence: number; // -1 to 1
+ arousal: number; // 0-1
+ persistence: number; // How long the impact lasts
+ };
+ relatedMemories: string[]; // IDs of memories formed during this period
+ }[];
+ temporalContext: {
+ period: string; // e.g., "post-breakup", "during-pandemic"
+ moodState: string; // e.g., "depressed", "euphoric"
+ cognitiveBias: string[]; // e.g., "overestimation", "pessimism"
+ };
+}
+
+export interface EmotionalProperties {
+ valence: number; // -1 to 1 (negative to positive)
+ arousal: number; // 0-1 scale
+ emotionalTags: string[];
+ triggers: {
+ type: 'memory' | 'sensory' | 'contextual';
+ source: string;
+ intensity: number;
+ associatedEvent?: string; // ID of related life event
+ biasEffect: {
+ type: 'amplification' | 'distortion' | 'suppression';
+ strength: number;
+ duration: number; // How long the bias lasts
+ };
+ }[];
+ emotionalState: {
+ baseline: number; // Normal emotional state
+ current: number; // Current emotional state
+ volatility: number; // How easily emotions change
+ };
+}
+
+export interface MemoryConnection {
+ targetId: string;
+ type: ConnectionType;
+ strength: number; // 0-1 scale
+ context: string;
+ emotionalContext: {
+ formedDuring: string; // Life event ID
+ emotionalBias: number; // How much the connection is influenced by emotions
+ temporalRelevance: number; // How relevant the connection is to the current period
+ };
+ triggers: {
+ type: string;
+ intensity: number;
+ associatedEvent?: string;
+ }[];
+}
+
+export type ConnectionType = 'association' | 'causation' | 'similarity' | 'contrast';
+
+// Specialized memory types
+export interface EpisodicMemory extends MemoryUnit {
+ type: 'episodic';
+ content: {
+ data: {
+ event: {
+ type: 'conversation' | 'interaction' | 'system_event';
+ participants: string[];
+ location?: string;
+ duration?: number;
+ };
+ narrative: string;
+ keyPoints: string[];
+ };
+ metadata: {
+ context: Record;
+ emotionalSignificance: number;
+ };
+ };
+}
+
+export interface SemanticMemory extends MemoryUnit {
+ type: 'semantic';
+ content: {
+ data: {
+ concept: string;
+ definition: string;
+ examples: string[];
+ relationships: {
+ type: string;
+ targetId: string;
+ description: string;
+ }[];
+ };
+ metadata: {
+ category: string;
+ reliability: number;
+ };
+ };
+}
+
+export interface ProceduralMemory extends MemoryUnit {
+ type: 'procedural';
+ content: {
+ data: {
+ skill: string;
+ steps: string[];
+ conditions: string[];
+ exceptions: string[];
+ };
+ metadata: {
+ proficiency: number;
+ lastPracticed: Date;
+ };
+ };
+}
+
+// Working memory (active processing)
+export interface WorkingMemory {
+ activeUnits: MemoryUnit[];
+ focus: {
+ primary: string;
+ secondary: string[];
+ attentionWeights: Record;
+ };
+ context: {
+ currentTask: string;
+ relevantMemories: string[];
+ emotionalState: EmotionalState;
+ };
+}
+
+export interface EmotionalState {
+ mood: number; // -1 to 1
+ energy: number; // 0-1
+ stress: number; // 0-1
+ focus: number; // 0-1
+}
+
+// Memory processing interfaces
+export interface MemoryRetrieval {
+ query: string;
+ context: Record;
+ filters: {
+ type?: MemoryType;
+ timeRange?: [Date, Date];
+ emotionalThreshold?: number;
+ confidenceThreshold?: number;
+ };
+}
+
+export interface MemoryConsolidation {
+ sourceMemories: string[];
+ newMemory: Partial;
+ consolidationStrength: number;
+}
+
+// Database schema mapping
+export interface DatabaseMemory {
+ id: string;
+ type: MemoryType;
+ content: string; // JSON stringified MemoryContent
+ temporal: string; // JSON stringified TemporalProperties
+ emotional: string; // JSON stringified EmotionalProperties
+ connections: string; // JSON stringified MemoryConnection[]
+ created_at: Date;
+ updated_at: Date;
+}
+
+// LLM-specific memory types
+export interface LLMContextMemory extends MemoryUnit {
+ type: 'llm_context';
+ content: {
+ data: {
+ model: string;
+ contextWindow: number;
+ tokens: {
+ prompt: string;
+ completion: string;
+ total: number;
+ };
+ parameters: {
+ temperature: number;
+ top_p: number;
+ frequency_penalty: number;
+ presence_penalty: number;
+ };
+ conversation: {
+ role: 'system' | 'user' | 'assistant';
+ content: string;
+ timestamp: Date;
+ }[];
+ };
+ metadata: {
+ modelVersion: string;
+ contextType: 'conversation' | 'instruction' | 'retrieval';
+ performance: {
+ latency: number;
+ tokensPerSecond: number;
+ };
+ };
+ };
+}
+
+export interface EmbeddingMemory extends MemoryUnit {
+ type: 'embedding';
+ content: {
+ data: {
+ text: string;
+ embedding: number[];
+ dimensions: number;
+ model: string;
+ };
+ metadata: {
+ similarityThreshold: number;
+ retrievalMethod: 'cosine' | 'euclidean' | 'dot';
+ };
+ };
+}
+
+export interface PromptMemory extends MemoryUnit {
+ type: 'prompt';
+ content: {
+ data: {
+ template: string;
+ variables: Record;
+ examples: {
+ input: any;
+ output: any;
+ }[];
+ constraints: string[];
+ };
+ metadata: {
+ category: string;
+ successRate: number;
+ averageTokens: number;
+ };
+ };
+}
+
+// LLM-specific connection types
+export type LLMConnectionType = ConnectionType |
+ 'token_similarity' |
+ 'embedding_distance' |
+ 'prompt_chain' |
+ 'context_flow';
+
+// Enhanced working memory for LLM context
+export interface LLMWorkingMemory extends WorkingMemory {
+ llmContext: {
+ currentModel: string;
+ contextWindow: {
+ used: number;
+ available: number;
+ };
+ recentPrompts: string[];
+ temperature: number;
+ systemPrompt: string;
+ };
+ embeddings: {
+ model: string;
+ cache: Map;
+ similarityThreshold: number;
+ };
+}
+
+// LLM-specific retrieval interface
+export interface LLMMemoryRetrieval extends MemoryRetrieval {
+ llmFilters: {
+ model?: string;
+ contextWindow?: number;
+ temperature?: number;
+ embeddingSimilarity?: number;
+ promptTemplate?: string;
+ };
+}
+
+// Life event memory type
+export interface LifeEventMemory extends MemoryUnit {
+ type: 'life_event';
+ content: {
+ data: {
+ event: {
+ type: 'breakup' | 'loss' | 'achievement' | 'trauma' | 'transition';
+ description: string;
+ participants: string[];
+ location?: string;
+ duration: {
+ start: Date;
+ end?: Date;
+ phases?: {
+ phase: string;
+ start: Date;
+ end?: Date;
+ characteristics: string[];
+ }[];
+ };
+ };
+ impact: {
+ emotional: {
+ immediate: string[];
+ longTerm: string[];
+ triggers: string[];
+ };
+ cognitive: {
+ biases: string[];
+ thoughtPatterns: string[];
+ copingMechanisms: string[];
+ };
+ behavioral: {
+ changes: string[];
+ adaptations: string[];
+ };
+ };
+ };
+ metadata: {
+ recoveryStage?: string;
+ healingProgress: number;
+ relatedEvents: string[];
+ };
+ };
+}
+
+// Memory formation context
+export interface MemoryFormationContext {
+ temporalContext: {
+ period: string;
+ lifeEvent?: string;
+ emotionalState: string;
+ };
+ cognitiveState: {
+ biases: string[];
+ attention: number;
+ clarity: number;
+ };
+ emotionalInfluence: {
+ currentMood: number;
+ emotionalTriggers: string[];
+ biasEffects: {
+ type: string;
+ strength: number;
+ direction: 'positive' | 'negative';
+ }[];
+ };
+}
\ No newline at end of file
diff --git a/frontend/src/types/fusemind/messages.ts b/frontend/src/types/fusemind/messages.ts
new file mode 100644
index 0000000..606c565
--- /dev/null
+++ b/frontend/src/types/fusemind/messages.ts
@@ -0,0 +1,23 @@
+export type MessageType = 'user' | 'system';
+
+export interface Message {
+ id: string;
+ content: string;
+ type: MessageType;
+ timestamp: Date;
+}
+
+export interface ChatConfig {
+ model: string;
+ temperature: number;
+ maxTokens: number;
+}
+
+export interface ChatResponse {
+ message: Message;
+ usage?: {
+ promptTokens: number;
+ completionTokens: number;
+ totalTokens: number;
+ };
+}
\ No newline at end of file
diff --git a/frontend/src/types/systems.ts b/frontend/src/types/systems.ts
new file mode 100644
index 0000000..1d4c6e7
--- /dev/null
+++ b/frontend/src/types/systems.ts
@@ -0,0 +1,19 @@
+export enum Systems {
+ piggy = 'piggy',
+}
+
+export type TSystem = {
+ createdAt: Date;
+ updatedAt: Date;
+ name: string;
+ id: number;
+ label: string;
+ src: string;
+ logoSrc?: string;
+// connections: any[];
+ nextPage: string;
+ hasNextPage: boolean;
+ previousPage: string;
+ hasPreviousPage: boolean;
+ lastPage: number;
+};
diff --git a/frontend/src/vite-env.d.ts b/frontend/src/vite-env.d.ts
new file mode 100644
index 0000000..11f02fe
--- /dev/null
+++ b/frontend/src/vite-env.d.ts
@@ -0,0 +1 @@
+/// => {
const orm = await MikroORM.init({ ...mikroOrmConfig });
// Register CORS, JWT, and Cookies
- app.register(fastifyCors, { origin: '*', methods: ['GET', 'POST', 'PUT', 'DELETE'] });
+ app.register(fastifyCors, {
+ origin: ['http://localhost:3000', 'http://localhost:3001', 'http://localhost:8080', 'http://localhost:8081'],
+ methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+ allowedHeaders: ['Content-Type', 'Authorization', 'Accept'],
+ credentials: true,
+ maxAge: 86400
+ });
+
app.register(fjwt, { secret: process.env.JWT_SECRET || 'your-secret-here' });
app.register(fCookie);
handleResizeStart(e, 'e')}
+ />
+ = ({
+ visible,
+ onHide,
+ onConfirm,
+ confirmLabel,
+ cancelLabel,
+ onCancel,
+}) => {
+ const [inputValue, setInputValue] = useState('');
+ const deleteKeyword = 'DELETE';
+
+ const isDeleteMatch = inputValue === deleteKeyword;
+
+ const onCloseModal = () => {
+ setInputValue('');
+ onHide();
+ }
+
+ const onCancelModal = () => {
+ setInputValue('');
+ onCancel();
+ }
+
+ const onConfirmModal = () => {
+ setInputValue('');
+ onConfirm();
+ }
+
+ return (
+
+ }
+ >
+ handleResizeStart(e, 's')}
+ />
+
+ );
+};
+
+export default GridCellIndicator;
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/ModalContainer.tsx b/frontend/src/components/FuseMind/modals/ModalContainer.tsx
new file mode 100644
index 0000000..1599997
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/ModalContainer.tsx
@@ -0,0 +1,51 @@
+import React from 'react';
+import { ModalConfig } from './core/types';
+import ModalFactory from './ModalFactory';
+
+interface TableContent {
+ columns: Array<{
+ field: string;
+ header: string;
+ }>;
+ data: Array>;
+}
+
+interface ModalContainerProps {
+ modals: ModalConfig[];
+ onClose: (id: string) => void;
+}
+
+const ModalContainer: React.FC = ({ modals, onClose }) => {
+ return (
+ >;
+}
+
+interface ModalFactoryProps {
+ id: string;
+ type: ModalType;
+ position: ModalPosition;
+ style?: {
+ backgroundColor?: string;
+ };
+ content?: TableContent | React.ReactNode;
+ onClose: (id: string) => void;
+}
+
+const ModalFactory: React.FC = ({ id, type, position, style, content, onClose }) => {
+ const renderContent = (): React.ReactNode => {
+ if (!content) return >;
+}
+
+interface TableModalProps {
+ content: TableContent;
+}
+
+declare const TableModal: React.FC;
+
+export default TableModal;
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/TableModal.tsx b/frontend/src/components/FuseMind/modals/TableModal.tsx
new file mode 100644
index 0000000..06a5f4e
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/TableModal.tsx
@@ -0,0 +1,144 @@
+import React from 'react';
+import { DataTable } from 'primereact/datatable';
+import { Column } from 'primereact/column';
+
+interface TableModalProps {
+ content: {
+ columns: Array<{
+ field: string;
+ header: string;
+ }>;
+ data: Array>;
+ };
+}
+
+const TableModal: React.FC = ({ content }) => {
+ return (
+ = ({
+ id,
+ type,
+ position,
+ style,
+ content
+}) => {
+ const { removeModal } = useModal();
+
+ const handleClose = () => {
+ removeModal(id);
+ };
+
+ return (
+ ;
+ removeModal: (id: string) => void;
+ updateModalStyle: (id: string, style: { backgroundColor?: string }) => void;
+}
+
+const ModalContext = createContext(undefined);
+
+export const ModalProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+ const [modals, setModals] = useState([]);
+
+ const createModal = useCallback((params: { type: ModalType; position?: ModalPosition; content: unknown }) => {
+ const newModal: ModalConfig = {
+ id: Date.now().toString(),
+ type: params.type,
+ position: params.position || {
+ x: 0,
+ y: 0,
+ width: '100%',
+ height: '100%'
+ },
+ content: params.content
+ };
+
+ return new Promise((resolve) => {
+ setModals(prev => {
+ const newModals = [...prev, newModal];
+ resolve(newModal);
+ return newModals;
+ });
+ });
+ }, []);
+
+ const removeModal = useCallback((id: string) => {
+ setModals(prev => prev.filter(modal => modal.id !== id));
+ }, []);
+
+ const updateModalStyle = useCallback((id: string, style: { backgroundColor?: string }) => {
+ setModals(prev =>
+ prev.map(modal =>
+ modal.id === id ? { ...modal, style: { ...modal.style, ...style } } : modal
+ )
+ );
+ }, []);
+
+ return (
+
+ {children}
+
+ );
+};
+
+export const useModal = () => {
+ const context = useContext(ModalContext);
+ if (context === undefined) {
+ throw new Error('useModal must be used within a ModalProvider');
+ }
+ return context;
+};
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/context/ModalProvider.tsx b/frontend/src/components/FuseMind/modals/context/ModalProvider.tsx
new file mode 100644
index 0000000..309833e
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/context/ModalProvider.tsx
@@ -0,0 +1,10 @@
+import React from 'react';
+import { ModalProvider as Provider } from './ModalContext';
+
+export const ModalProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+ return (
+
+ {children}
+
+ );
+};
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/core/types.ts b/frontend/src/components/FuseMind/modals/core/types.ts
new file mode 100644
index 0000000..6efccbe
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/core/types.ts
@@ -0,0 +1,44 @@
+export type ModalPosition = {
+ x: number;
+ y: number;
+ width: string;
+ height: string;
+};
+
+export type ModalType = 'table' | 'default';
+
+export type ModalId = string;
+
+export interface Modal {
+ id: ModalId;
+ type: ModalType;
+ position: ModalPosition;
+ style?: {
+ backgroundColor?: string;
+ };
+ content?: unknown;
+}
+
+export interface ModalConfig {
+ id: ModalId;
+ type: ModalType;
+ position: ModalPosition;
+ content: unknown;
+ style?: {
+ backgroundColor?: string;
+ borderRadius?: string;
+ padding?: string;
+ };
+}
+
+export type ModalAction =
+ | { type: 'CREATE_MODAL'; payload: Omit }
+ | { type: 'UPDATE_MODAL'; payload: { id: ModalId } & Partial }
+ | { type: 'DELETE_MODAL'; payload: { id: ModalId } }
+ | { type: 'UPDATE_POSITION'; payload: { id: ModalId; position: Partial } }
+ | { type: 'UPDATE_STYLE'; payload: { id: ModalId; style: Partial } };
+
+export interface ModalState {
+ modals: Record;
+ activeModal: ModalId | null;
+}
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/hooks/useModalCommands.ts b/frontend/src/components/FuseMind/modals/hooks/useModalCommands.ts
new file mode 100644
index 0000000..0c40c8c
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/hooks/useModalCommands.ts
@@ -0,0 +1,113 @@
+import { useState, useCallback } from 'react';
+import { ModalType, ModalPosition, ModalConfig } from '../core/types';
+
+export const useModalCommands = () => {
+ const [modals, setModals] = useState([]);
+ const [layout, setLayout] = useState<'horizontal' | 'vertical'>('horizontal');
+
+ const calculatePositions = useCallback((count: number, layout: 'horizontal' | 'vertical') => {
+ const positions: ModalPosition[] = [];
+ const gap = 10;
+
+ if (layout === 'horizontal') {
+ const width = (100 - gap * (count - 1)) / count;
+ for (let i = 0; i < count; i++) {
+ positions.push({
+ x: i * (width + gap),
+ y: 0,
+ width: `${width}%`,
+ height: '100%'
+ });
+ }
+ } else {
+ const height = (100 - gap * (count - 1)) / count;
+ for (let i = 0; i < count; i++) {
+ positions.push({
+ x: 0,
+ y: i * (height + gap),
+ width: '100%',
+ height: `${height}%`
+ });
+ }
+ }
+
+ return positions;
+ }, []);
+
+ const createModal = useCallback((params: { type: ModalType; position?: ModalPosition; content: unknown }) => {
+ const newModal: ModalConfig = {
+ id: Date.now().toString(),
+ type: params.type,
+ position: params.position || {
+ x: 0,
+ y: 0,
+ width: '100%',
+ height: '100%'
+ },
+ content: params.content
+ };
+
+ return new Promise((resolve) => {
+ setModals(prev => {
+ const newModals = [...prev, newModal];
+ resolve(newModal);
+ return newModals;
+ });
+ });
+ }, []);
+
+ const removeModal = useCallback((id: string) => {
+ setModals(prev => prev.filter(modal => modal.id !== id));
+ }, []);
+
+ const updateModalStyle = useCallback((id: string, style: { backgroundColor?: string }) => {
+ setModals(prev =>
+ prev.map(modal =>
+ modal.id === id ? { ...modal, style: { ...modal.style, ...style } } : modal
+ )
+ );
+ }, []);
+
+ const splitScreen = useCallback((modalIds: string[], newLayout: 'horizontal' | 'vertical') => {
+ setLayout(newLayout);
+ setModals(prev => {
+ const targetModals = prev.filter(modal => modalIds.includes(modal.id));
+ const otherModals = prev.filter(modal => !modalIds.includes(modal.id));
+
+ const positions = calculatePositions(targetModals.length, newLayout);
+ const updatedTargetModals = targetModals.map((modal, index) => ({
+ ...modal,
+ position: positions[index]
+ }));
+
+ return [...otherModals, ...updatedTargetModals];
+ });
+ }, [calculatePositions]);
+
+ const getModalsByPosition = useCallback((position: 'left' | 'right' | 'top' | 'bottom') => {
+ return modals.filter(modal => {
+ switch (position) {
+ case 'left':
+ return modal.position.x === 0;
+ case 'right':
+ return modal.position.x > 0;
+ case 'top':
+ return modal.position.y === 0;
+ case 'bottom':
+ return modal.position.y > 0;
+ default:
+ return false;
+ }
+ });
+ }, [modals]);
+
+ return {
+ modals,
+ createModal,
+ removeModal,
+ updateModalStyle,
+ splitScreen,
+ getModalsByPosition,
+ layout
+ };
+};
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/hooks/useModalGrid.d.ts b/frontend/src/components/FuseMind/modals/hooks/useModalGrid.d.ts
new file mode 100644
index 0000000..8c717d5
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/hooks/useModalGrid.d.ts
@@ -0,0 +1,21 @@
+import { ModalPosition } from '../core/types';
+
+export interface GridPosition {
+ x: number;
+ y: number;
+ width: number;
+ height: number;
+}
+
+export interface GridModal {
+ id: string;
+ position: GridPosition;
+}
+
+export const useModalGrid: () => {
+ addModal: (id: string, width: number, height: number) => GridPosition | null;
+ removeModal: (id: string) => void;
+ moveModal: (id: string, newPos: GridPosition) => boolean;
+ modals: GridModal[];
+ gridState: boolean[][];
+};
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/hooks/useModalGrid.ts b/frontend/src/components/FuseMind/modals/hooks/useModalGrid.ts
new file mode 100644
index 0000000..223e9f5
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/hooks/useModalGrid.ts
@@ -0,0 +1,111 @@
+import { useState, useCallback } from 'react';
+
+interface GridPosition {
+ x: number;
+ y: number;
+ width: number;
+ height: number;
+}
+
+interface GridModal {
+ id: string;
+ position: GridPosition;
+}
+
+const GRID_COLS = 20;
+const GRID_ROWS = 8;
+
+export const useModalGrid = () => {
+ const [gridState, setGridState] = useState(
+ Array(GRID_ROWS).fill(null).map(() => Array(GRID_COLS).fill(false))
+ );
+ const [modals, setModals] = useState([]);
+
+ // Check if a position is available in the grid
+ const isPositionAvailable = useCallback((pos: GridPosition) => {
+ for (let y = pos.y; y < pos.y + pos.height; y++) {
+ for (let x = pos.x; x < pos.x + pos.width; x++) {
+ if (y >= GRID_ROWS || x >= GRID_COLS || gridState[y][x]) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }, [gridState]);
+
+ // Find next available position for given dimensions
+ const findNextPosition = useCallback((width: number, height: number): GridPosition | null => {
+ for (let y = 0; y <= GRID_ROWS - height; y++) {
+ for (let x = 0; x <= GRID_COLS - width; x++) {
+ const pos = { x, y, width, height };
+ if (isPositionAvailable(pos)) {
+ return pos;
+ }
+ }
+ }
+ return null;
+ }, [isPositionAvailable]);
+
+ // Update grid state for a position
+ const updateGridState = useCallback((pos: GridPosition, value: boolean) => {
+ setGridState(prev => {
+ const newState = prev.map(row => [...row]);
+ for (let y = pos.y; y < pos.y + pos.height; y++) {
+ for (let x = pos.x; x < pos.x + pos.width; x++) {
+ newState[y][x] = value;
+ }
+ }
+ return newState;
+ });
+ }, []);
+
+ // Add a new modal to the grid
+ const addModal = useCallback((id: string, width: number, height: number) => {
+ const position = findNextPosition(width, height);
+ if (!position) return null;
+
+ const newModal = { id, position };
+ setModals(prev => [...prev, newModal]);
+ updateGridState(position, true);
+ return position;
+ }, [findNextPosition, updateGridState]);
+
+ // Remove a modal from the grid
+ const removeModal = useCallback((id: string) => {
+ setModals(prev => {
+ const modal = prev.find(m => m.id === id);
+ if (modal) {
+ updateGridState(modal.position, false);
+ }
+ return prev.filter(m => m.id !== id);
+ });
+ }, [updateGridState]);
+
+ // Move a modal to a new position
+ const moveModal = useCallback((id: string, newPos: GridPosition) => {
+ if (!isPositionAvailable(newPos)) return false;
+
+ setModals(prev => {
+ const modal = prev.find(m => m.id === id);
+ if (!modal) return prev;
+
+ updateGridState(modal.position, false);
+ updateGridState(newPos, true);
+
+ return prev.map(m =>
+ m.id === id ? { ...m, position: newPos } : m
+ );
+ });
+ return true;
+ }, [isPositionAvailable, updateGridState]);
+
+ return {
+ addModal,
+ removeModal,
+ moveModal,
+ modals,
+ gridState
+ };
+};
+
+export type { GridPosition, GridModal };
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/store/modalStore.ts b/frontend/src/components/FuseMind/modals/store/modalStore.ts
new file mode 100644
index 0000000..e037319
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/store/modalStore.ts
@@ -0,0 +1,85 @@
+import create from 'zustand';
+import { ModalState, ModalAction, ModalConfig, ModalId } from '../core/types';
+import { nanoid } from 'nanoid';
+
+const initialState: ModalState = {
+ modals: {},
+ activeModal: null
+};
+
+export const useModalStore = create void;
+}>((set) => ({
+ ...initialState,
+ dispatch: (action) => {
+ set((state) => {
+ switch (action.type) {
+ case 'CREATE_MODAL':
+ const id = nanoid();
+ return {
+ ...state,
+ modals: {
+ ...state.modals,
+ [id]: {
+ ...action.payload,
+ id
+ }
+ }
+ };
+
+ case 'UPDATE_MODAL':
+ return {
+ ...state,
+ modals: {
+ ...state.modals,
+ [action.payload.id]: {
+ ...state.modals[action.payload.id],
+ ...action.payload
+ }
+ }
+ };
+
+ case 'DELETE_MODAL':
+ const { [action.payload.id]: _, ...remainingModals } = state.modals;
+ return {
+ ...state,
+ modals: remainingModals,
+ activeModal: state.activeModal === action.payload.id ? null : state.activeModal
+ };
+
+ case 'UPDATE_POSITION':
+ return {
+ ...state,
+ modals: {
+ ...state.modals,
+ [action.payload.id]: {
+ ...state.modals[action.payload.id],
+ position: {
+ ...state.modals[action.payload.id].position,
+ ...action.payload.position
+ }
+ }
+ }
+ };
+
+ case 'UPDATE_STYLE':
+ return {
+ ...state,
+ modals: {
+ ...state.modals,
+ [action.payload.id]: {
+ ...state.modals[action.payload.id],
+ style: {
+ ...state.modals[action.payload.id].style,
+ ...action.payload.style
+ }
+ }
+ }
+ };
+
+ default:
+ return state;
+ }
+ });
+ }
+}));
\ No newline at end of file
diff --git a/frontend/src/components/LoginModal.tsx b/frontend/src/components/LoginModal.tsx
new file mode 100644
index 0000000..9c976ea
--- /dev/null
+++ b/frontend/src/components/LoginModal.tsx
@@ -0,0 +1,91 @@
+import { useState, useEffect } from 'react';
+import { Card } from 'primereact/card';
+import { useNavigate } from 'react-router-dom';
+import Button from '../shared/components/_V2/Button';
+import Input from '../shared/components/_V2/InputText';
+import { useAuthStore } from '../state/stores/useAuthStore';
+
+interface LoginModalProps {
+ redirectUrl?: string;
+ onLoginSuccess?: () => void;
+}
+
+const LoginModal: React.FC = ({ redirectUrl = '/dashboard', onLoginSuccess }) => {
+ const navigate = useNavigate();
+ const { login } = useAuthStore();
+ const [username, setUsername] = useState('');
+ const [password, setPassword] = useState('');
+ const [isTransitioning, setIsTransitioning] = useState(false);
+
+ const handleLogin = async () => {
+ setIsTransitioning(true);
+ try {
+ await login(username, password);
+ if (onLoginSuccess) {
+ onLoginSuccess();
+ }
+ navigate(redirectUrl, { replace: true });
+ } catch (error) {
+ console.error('Login failed:', error);
+ } finally {
+ setIsTransitioning(false);
+ }
+ };
+
+
+ const handleKeyDown = (event: React.KeyboardEvent) => {
+ if (event.key === 'Enter') {
+ handleLogin();
+ }
+ };
+
+ const header = () => = ({ onSubmit }) => {
+ const [promptMessage, setPromptMessage] = useState('');
+
+ const handleFormSubmit = (event: React.FormEvent) => {
+ event.preventDefault();
+ if (promptMessage.trim()) {
+ onSubmit(promptMessage);
+ setPromptMessage('');
+ }
+ };
+
+ return (
+ (null);
+ const [selectedEnterprise, setSelectedEnterprise] = useState(null);
+ const { setSystem } = useSystemStore();
+
+ useEffect(() => {
+ [fusero_logo].forEach((image) => {
+ const img = new Image();
+ img.src = image;
+ });
+ if (systemDetails) {
+ setSelectedSystem(systemDetails);
+ setSystem(systemDetails);
+ }
+ }, [systemDetails, setSystem]);
+
+ const handleSystemChange = useCallback(
+ (e: { value: SystemDropdownOption }) => {
+ setSelectedSystem(e.value);
+ setSystem(e.value);
+ },
+ [setSystem]
+ );
+
+ const handleSelectSystem = () => {
+ if (selectedSystem) {
+ navigate(`/dashboard/${selectedSystem.urlSlug}`); // JUST GO TO BASE PATH
+ }
+ };
+
+ const handleEnterpriseChange = useCallback((e: { value: number }) => {
+ setSelectedEnterprise(e.value);
+ }, []);
+
+ return (
+ <>
+
+ ({
+ label: enterprise.name,
+ value: enterprise.id,
+ }))}
+ onChange={handleEnterpriseChange}
+ placeholder='Select an enterprise'
+ />
+ )}
+
+
+ {selectedSystem && (
+ 
+ )}
+
+ );
+};
+
+export default SystemSelectionModal;
diff --git a/frontend/src/components/TenantProfile.tsx b/frontend/src/components/TenantProfile.tsx
new file mode 100644
index 0000000..6a38f7a
--- /dev/null
+++ b/frontend/src/components/TenantProfile.tsx
@@ -0,0 +1,110 @@
+import { useState, useEffect } from 'react';
+import logo_fusero from '../assets/fusero_logo.svg';
+import Divider from '../shared/components/_V1/Divider';
+import Button from '../shared/components/_V2/Button';
+import { useAuthStore } from '../state/stores/useAuthStore';
+import { TabPanel, TabView } from 'primereact/tabview';
+import 'primereact/resources/themes/saga-blue/theme.css'; // Import theme for TabView
+import 'primereact/resources/primereact.min.css'; // Core CSS for TabView
+import ApiCalls from './ApiCalls'; // Import the new component
+
+const Notifications = () => (
+ ;
+ logout: () => void;
+}
+
+type DecodedToken = {
+ tenantId: string;
+};
+
+type Token = {
+ user: {
+ id: number;
+ name: string;
+ };
+ roles: string[];
+ exp: number;
+ iat: number;
+};
+
+const useAuth = (): AuthHook => {
+ const [user, setUser] = useState(null);
+
+ useEffect(() => {
+ const storedUser = localStorage.getItem('user');
+ if (storedUser) {
+ setUser(JSON.parse(storedUser));
+ }
+ }, []);
+
+ const login = async (username: string, password: string): Promise => {
+ const response = await api('post', '/login', { username, password });
+ const user = response;
+
+ const decodedToken: DecodedToken = jwtDecode(user.data.token);
+ user.data.tenantId = decodedToken.tenantId;
+
+ localStorage.setItem('user', JSON.stringify(user.data));
+ setUser(user.data.data);
+ return user.data;
+ };
+
+ const logout = (): void => {
+ localStorage.removeItem('user');
+ localStorage.removeItem('connectionId');
+ setUser(null);
+ };
+
+ return { user, login, logout };
+};
+
+export const getExpirationDateFromToken = (token: string) => {
+ const decoded: Token = jwtDecode(token);
+
+ if (decoded && decoded.exp) {
+ const expirationTimestamp = decoded.exp;
+ // Convert to miliseconds, Date constructs using miliseconds
+ return new Date(expirationTimestamp * 1000);
+ }
+ return null;
+};
+
+export { useAuth };
diff --git a/frontend/src/hooks/useFusemindMemory.ts b/frontend/src/hooks/useFusemindMemory.ts
new file mode 100644
index 0000000..f94e6a0
--- /dev/null
+++ b/frontend/src/hooks/useFusemindMemory.ts
@@ -0,0 +1,46 @@
+import { useState, useEffect } from 'react';
+import { memoryService } from '../services/fusemind/memoryService';
+import { MemoryUnit, MemoryRetrieval, EmotionalState } from '../types/fusemind/memory';
+
+export const useFusemindMemory = () => {
+ const [activeMemories, setActiveMemories] = useState([]);
+ const [emotionalState, setEmotionalState] = useState(
+ memoryService.getCurrentEmotionalState()
+ );
+
+ // Store a new memory
+ const storeMemory = async (memory: MemoryUnit) => {
+ const id = await memoryService.storeMemory(memory);
+ return id;
+ };
+
+ // Retrieve memories based on query
+ const retrieveMemories = async (query: MemoryRetrieval) => {
+ const memories = await memoryService.retrieveMemory(query);
+ setActiveMemories(memories);
+ return memories;
+ };
+
+ // Update emotional state
+ const updateEmotionalState = (update: Partial) => {
+ memoryService.updateEmotionalState(update);
+ setEmotionalState(memoryService.getCurrentEmotionalState());
+ };
+
+ // Effect to sync with memory service
+ useEffect(() => {
+ const interval = setInterval(() => {
+ setEmotionalState(memoryService.getCurrentEmotionalState());
+ }, 1000); // Update every second
+
+ return () => clearInterval(interval);
+ }, []);
+
+ return {
+ activeMemories,
+ emotionalState,
+ storeMemory,
+ retrieveMemories,
+ updateEmotionalState
+ };
+};
\ No newline at end of file
diff --git a/frontend/src/index.css b/frontend/src/index.css
new file mode 100644
index 0000000..d666d0d
--- /dev/null
+++ b/frontend/src/index.css
@@ -0,0 +1,185 @@
+@import 'primereact/resources/themes/saga-blue/theme.css';
+@import 'primereact/resources/primereact.min.css';
+@import 'primeicons/primeicons.css';
+
+@layer tailwind-base, primereact, tailwind-utilities;
+
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+/* li > a {
+ margin: 6px 0;
+} */
+
+/* src/index.css */
+.custom-tabview .p-tabview-nav li {
+ display: inline-flex;
+ align-items: center;
+ padding: 0.5rem 1rem;
+ cursor: pointer;
+ /* color: #0d9488; text-teal-700 */
+ transition: color 0.3s;
+}
+
+.custom-tabview .p-tabview-nav li:hover a {
+ color: #14b8a6; /* text-teal-500 */
+}
+
+.custom-tabview .p-tabview-nav li.p-highlight a {
+ color: #0f766e; /* text-teal-600 */
+ /* font-weight: 600; font-semibold */
+}
+
+.custom-tabview .p-tabview-nav li.p-highlight {
+ border-bottom: 2px solid #14b8a6; /* border-teal-500 */
+}
+
+/*
+* {
+ overflow: auto;
+ -ms-overflow-style: none;
+ scrollbar-width: none;
+}
+*/
+
+/* .p-highlight {
+ background-color: #212f4d !important;
+} */
+
+/* ICONS */
+.p-icon.p-checkbox-icon {
+ border: 1px solid teal;
+ color: #fff;
+ background-color: teal;
+}
+
+/* DATA TABLE */
+.p-dialog .p-dialog-header {
+ padding-top: 32px !important;
+ padding-bottom: 0px !important;
+}
+
+.p-datatable.p-datatable-gridlines .p-datatable-header {
+ /* padding: 10px 8px 10px 8px !important; */
+}
+
+.p-datatable-header {
+ top: 0;
+ z-index: 10;
+ padding: 0 !important;
+}
+
+/* .p-datatable-header > div {
+ display: flex;
+ }*/
+
+.p-datatable-header > div > div {
+ padding: 0 0 18px 0;
+}
+.p-datatable-header > div > div > div > button {
+ width: 100px;
+}
+
+.p-datatable .p-datatable-header {
+ position: sticky;
+ padding: 0.3rem 1rem !important;
+ width: 100%;
+ background-color: #fff;
+}
+
+.p-datatable-thead {
+ position: sticky;
+ /* top: 114px; */
+ top: 87.5px;
+ z-index: 10;
+ margin: 0 !important;
+ padding: 0 !important;
+ background-color: #fff;
+}
+
+.p-sortable-column,
+thead tr th {
+ /* padding: 12px; */
+ box-shadow: inset 0 -1px 0 #dee2e6;
+ /* width: 100%; */
+ background-color: #fff;
+}
+.p-dropdownpanel {
+ width: 365px !important;
+}
+
+.p-datatable {
+ width: 100%;
+ /* margin-top: 32px; */
+}
+
+.p-datatable-tbody {
+ margin-top: 32px;
+}
+
+.p-datatable > .p-datatable-wrapper {
+ overflow: initial !important;
+ margin: 0 0 80px 0;
+ width: 100%;
+}
+
+/* search bar data table */
+.p-datatable-header .p-inputtext.p-component {
+ padding: 6px 64px;
+ margin-left: -8px;
+ border: 1px solid #222;
+}
+
+.p-paginator.p-component.p-paginator-bottom {
+ position: fixed;
+ bottom: 0;
+ box-shadow: inset 0 1px 0 #dee2e6;
+ width: 86%;
+ margin: 0;
+}
+
+
+.pi.pi-search {
+ margin: -8px 14px;
+}
+
+.p-inputtext.p-component {
+ /* padding: 6px 64px; */
+ /* margin-left: -8px; */
+ border: 1px solid #222;
+}
+
+.p-component.p-highlight {
+ outline: none !important;
+ background-color: teal;
+ border: 0px solid;
+}
+.p-button {
+ outline: none !important;
+ /* border: 0px solid; */
+ padding: 10px !important;
+ margin: 8px 0px;
+}
+
+/* in place element removal to make own clickable area*/
+.p-inplace .p-inplace-display {
+ display: block !important;
+ padding: 0 !important;
+ cursor: pointer;
+}
+
+/* .p-tabview-ink-bar {
+ width: 0 !important;
+} */
+
+.link-style {
+ color: blue;
+ text-decoration: none;
+ cursor: pointer;
+}
+
+.link-style:hover {
+ text-decoration: underline;
+ color: blue;
+}
diff --git a/frontend/src/layouts/DualModal.tsx b/frontend/src/layouts/DualModal.tsx
new file mode 100644
index 0000000..e6c19ac
--- /dev/null
+++ b/frontend/src/layouts/DualModal.tsx
@@ -0,0 +1,117 @@
+import React, { useEffect, useState } from 'react';
+import { useParams, useNavigate, Outlet, Navigate } from 'react-router-dom';
+import { useAuthStore } from '../state/stores/useAuthStore';
+import SystemSelectionModal from '../components/SystemSelectionModal';
+import TenantProfile from '../components/TenantProfile';
+import Sidebar from './Sidebar';
+import LoginModal from '../components/LoginModal';
+
+const DualModalComponent = () => {
+ const { systemId } = useParams();
+ const navigate = useNavigate();
+ const { isLoggedIn } = useAuthStore();
+ const [isExpanded, setIsExpanded] = useState(false);
+ const [showOutlet, setShowOutlet] = useState(false);
+ const [logoPath, setLogoPath] = useState('');
+ const [systemDetails, setSystemDetails] = useState(null);
+ const [animationFinished, setAnimationFinished] = useState(false);
+ const animationSpeed = 500;
+
+ const [redirectTo, setRedirectTo] = useState(null);
+
+ useEffect(() => {
+ console.log(`useEffect triggered: systemId=${systemId}, isLoggedIn=${isLoggedIn}`);
+ if (!isLoggedIn) {
+ setIsExpanded(false);
+ setShowOutlet(false);
+ setAnimationFinished(false); // Reset animation
+ } else if (systemId && systemId !== 'default') {
+ setIsExpanded(true);
+ setShowOutlet(true);
+ setTimeout(() => setAnimationFinished(true), animationSpeed);
+ } else {
+ setIsExpanded(false);
+ setShowOutlet(false);
+ setAnimationFinished(false); // Reset animation
+ }
+ }, [systemId, isLoggedIn]);
+
+ const handleSystemSelected = (systemData) => {
+ console.log(`System selected: ${systemData.urlSlug}`);
+ setRedirectTo(`/dashboard/${systemData.urlSlug}`);
+ setIsExpanded(true);
+ setShowOutlet(true);
+ setLogoPath(systemData.logo);
+ setSystemDetails(systemData);
+ setAnimationFinished(false);
+ };
+
+ const handleLogoChange = (newLogoPath) => {
+ setLogoPath(newLogoPath);
+ };
+
+ const [isCollapsed, setIsCollapsed] = useState(false);
+
+ if (redirectTo) {
+ return
+
+);
diff --git a/frontend/src/router.tsx b/frontend/src/router.tsx
new file mode 100644
index 0000000..5fbf6a2
--- /dev/null
+++ b/frontend/src/router.tsx
@@ -0,0 +1,43 @@
+import { createBrowserRouter, Navigate } from 'react-router-dom';
+import DualModalComponent from './layouts/DualModal';
+
+import CouncilAI from './components/CouncilAI/CouncilAI';
+import FuseMindHome from './components/FuseMind/FuseMindHome';
+import { useParams } from 'react-router-dom';
+
+const FuseMindHomeWrapper = () => {
+ const { systemId } = useParams();
+ return systemId === 'fusemind' ? = {
+ [x: string]: any;
+ data: T;
+ status: number;
+};
+
+export async function api(
+ method: THttpMethod,
+ url: string,
+ data?: any,
+ params?: any,
+ responseType: ResponseType = 'json',
+ timeoutInSeconds: number = DEFAULT_TIMEOUT,
+ skipAuth: boolean = false
+): Promise> {
+ const user = JSON.parse(localStorage.getItem('user') || '{}');
+ const token = user?.token || '';
+
+ const headers: Record = {
+ 'Content-Type': 'application/json'
+ };
+
+ // Only add auth headers if not skipping auth
+ if (!skipAuth && token) {
+ headers['Authorization'] = `Bearer ${token}`;
+ }
+
+ const axiosInstance = axios.create({
+ baseURL: serverPath,
+ timeout: timeoutInSeconds * 1000,
+ headers,
+ withCredentials: !skipAuth, // Only use credentials if not skipping auth
+ responseType,
+ });
+
+ const logApiCall = useApiLogStore.getState().logApiCall;
+
+ try {
+ const requestOptions: any = {
+ method,
+ url,
+ data,
+ params,
+ };
+
+ const start = performance.now();
+ const response: AxiosResponse = await axiosInstance.request(requestOptions);
+ const end = performance.now();
+
+ const apiResponse: ApiResponse = {
+ data: response.data,
+ status: response.status,
+ };
+
+ logApiCall({
+ method,
+ url,
+ status: response.status,
+ responseTime: end - start,
+ timestamp: new Date().toISOString(),
+ });
+
+ return apiResponse;
+ } catch (error) {
+ console.error('API Error:', {
+ url,
+ method,
+ error: error.response?.data || error.message,
+ status: error.response?.status,
+ });
+
+ logApiCall({
+ method,
+ url,
+ status: error.response?.status || 500,
+ responseTime: 0,
+ timestamp: new Date().toISOString(),
+ });
+
+ throw error;
+ }
+}
diff --git a/frontend/src/services/apiLogStore.ts b/frontend/src/services/apiLogStore.ts
new file mode 100644
index 0000000..e8d0d9d
--- /dev/null
+++ b/frontend/src/services/apiLogStore.ts
@@ -0,0 +1,19 @@
+import { create } from 'zustand';
+
+type ApiLog = {
+ method: string;
+ url: string;
+ status: number;
+ responseTime: number;
+ timestamp: string;
+};
+
+type ApiLogStore = {
+ apiLogs: ApiLog[];
+ logApiCall: (log: ApiLog) => void;
+};
+
+export const useApiLogStore = create((set) => ({
+ apiLogs: [],
+ logApiCall: (log) => set((state) => ({ apiLogs: [...state.apiLogs, log] })),
+}));
diff --git a/frontend/src/services/fusemind/chatService.ts b/frontend/src/services/fusemind/chatService.ts
new file mode 100644
index 0000000..6052118
--- /dev/null
+++ b/frontend/src/services/fusemind/chatService.ts
@@ -0,0 +1,76 @@
+import { Message, ChatConfig, ChatResponse } from '../../types/fusemind/messages';
+
+class ChatService {
+ private config: ChatConfig = {
+ model: 'gpt-4',
+ temperature: 0.7,
+ maxTokens: 2000
+ };
+
+ private context: Message[] = [];
+
+ async sendMessage(message: Message): Promise {
+ try {
+ // Add message to context
+ this.context.push(message);
+
+ // Prepare the messages for ChatGPT
+ const messages = this.context.map(msg => ({
+ role: msg.type === 'user' ? 'user' : 'assistant',
+ content: msg.content
+ }));
+
+ // Make API call to ChatGPT
+ const response = await fetch('/api/chat', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify({
+ messages,
+ ...this.config
+ })
+ });
+
+ if (!response.ok) {
+ throw new Error('Failed to get response from ChatGPT');
+ }
+
+ const data = await response.json();
+
+ // Create response message
+ const responseMessage: Message = {
+ id: Date.now().toString(),
+ content: data.message,
+ type: 'system',
+ timestamp: new Date()
+ };
+
+ // Add response to context
+ this.context.push(responseMessage);
+
+ // Return formatted response
+ return {
+ message: responseMessage,
+ usage: data.usage
+ };
+ } catch (error) {
+ console.error('Error in ChatService:', error);
+ throw error;
+ }
+ }
+
+ setConfig(config: Partial) {
+ this.config = { ...this.config, ...config };
+ }
+
+ clearContext() {
+ this.context = [];
+ }
+
+ getContext(): Message[] {
+ return [...this.context];
+ }
+}
+
+export const chatService = new ChatService();
\ No newline at end of file
diff --git a/frontend/src/services/fusemind/memoryService.ts b/frontend/src/services/fusemind/memoryService.ts
new file mode 100644
index 0000000..93d6d8c
--- /dev/null
+++ b/frontend/src/services/fusemind/memoryService.ts
@@ -0,0 +1,439 @@
+import {
+ MemoryUnit,
+ MemoryType,
+ WorkingMemory,
+ MemoryRetrieval,
+ MemoryConsolidation,
+ DatabaseMemory,
+ EmotionalState,
+ LLMWorkingMemory,
+ LLMContextMemory,
+ EmbeddingMemory,
+ PromptMemory,
+ TemporalProperties,
+ MemoryFormationContext,
+ EmotionalProperties
+} from '../../types/fusemind/memory';
+
+class MemoryService {
+ private workingMemory: LLMWorkingMemory;
+ private emotionalState: EmotionalState;
+ private activeLifeEvents: Map;
+
+ constructor() {
+ this.workingMemory = {
+ activeUnits: [],
+ focus: {
+ primary: '',
+ secondary: [],
+ attentionWeights: {}
+ },
+ context: {
+ currentTask: '',
+ relevantMemories: [],
+ emotionalState: {
+ mood: 0,
+ energy: 1,
+ stress: 0,
+ focus: 1
+ }
+ },
+ llmContext: {
+ currentModel: 'gpt-4',
+ contextWindow: {
+ used: 0,
+ available: 8192
+ },
+ recentPrompts: [],
+ temperature: 0.7,
+ systemPrompt: 'You are a helpful AI assistant.'
+ },
+ embeddings: {
+ model: 'text-embedding-ada-002',
+ cache: new Map(),
+ similarityThreshold: 0.8
+ }
+ };
+ this.emotionalState = this.workingMemory.context.emotionalState;
+ this.activeLifeEvents = new Map();
+ }
+
+ // Memory Operations
+ async storeMemory(memory: MemoryUnit, formationContext?: MemoryFormationContext): Promise {
+ // Add life event context if available
+ if (formationContext?.temporalContext.lifeEvent) {
+ const event = this.activeLifeEvents.get(formationContext.temporalContext.lifeEvent);
+ if (event) {
+ memory.temporal.lifeEvents.push(event);
+ memory.temporal.temporalContext = formationContext.temporalContext;
+
+ // Apply emotional biases
+ memory.emotional.triggers.push(...formationContext.emotionalInfluence.biasEffects.map(bias => ({
+ type: 'contextual',
+ source: 'life_event',
+ intensity: bias.strength,
+ associatedEvent: formationContext.temporalContext.lifeEvent,
+ biasEffect: {
+ type: bias.type as 'amplification' | 'distortion' | 'suppression',
+ strength: bias.strength,
+ duration: event.emotionalImpact.persistence
+ }
+ })));
+ }
+ }
+
+ // Convert to database format
+ const dbMemory: DatabaseMemory = {
+ id: memory.id,
+ type: memory.type,
+ content: JSON.stringify(memory.content),
+ temporal: JSON.stringify(memory.temporal),
+ emotional: JSON.stringify(memory.emotional),
+ connections: JSON.stringify(memory.connections),
+ created_at: new Date(),
+ updated_at: new Date()
+ };
+
+ // TODO: Implement database storage
+ // await db.memories.insert(dbMemory);
+
+ // Update working memory if relevant
+ this.updateWorkingMemory(memory);
+
+ return memory.id;
+ }
+
+ async retrieveMemory(query: MemoryRetrieval): Promise {
+ const memories = await this.retrieveMemoryFromStorage(query);
+
+ // Apply emotional and temporal context filters
+ return memories.filter(memory => {
+ // Check if memory is relevant to current life events
+ const isRelevantToCurrentEvents = memory.temporal.lifeEvents.some(event =>
+ this.activeLifeEvents.has(event.eventId)
+ );
+
+ // Check emotional triggers
+ const hasActiveTriggers = memory.emotional.triggers.some(trigger =>
+ trigger.associatedEvent && this.activeLifeEvents.has(trigger.associatedEvent)
+ );
+
+ return isRelevantToCurrentEvents || hasActiveTriggers;
+ });
+ }
+
+ async consolidateMemories(consolidation: MemoryConsolidation): Promise {
+ const memories = await Promise.all(
+ consolidation.sourceMemories.map(id => this.retrieveMemory({ query: id }))
+ ).then(results => results.flat());
+
+ // Calculate emotional influence
+ const emotionalInfluence = this.calculateEmotionalInfluence(memories);
+
+ // Create new memory with emotional context
+ const newMemory: MemoryUnit = {
+ id: this.generateId(),
+ type: 'semantic',
+ content: this.mergeMemoryContents(memories),
+ temporal: {
+ ...this.calculateTemporalProperties(memories),
+ lifeEvents: memories.flatMap(m => m.temporal.lifeEvents),
+ temporalContext: this.getCurrentTemporalContext()
+ },
+ emotional: {
+ ...this.calculateEmotionalProperties(memories),
+ triggers: emotionalInfluence.triggers,
+ emotionalState: {
+ baseline: emotionalInfluence.baseline,
+ current: this.emotionalState.mood,
+ volatility: emotionalInfluence.volatility
+ }
+ },
+ connections: this.buildMemoryConnections(memories)
+ };
+
+ await this.storeMemory(newMemory);
+ return newMemory;
+ }
+
+ // Working Memory Management
+ private updateWorkingMemory(memory: MemoryUnit) {
+ // Add to active units if not already present
+ if (!this.workingMemory.activeUnits.find(u => u.id === memory.id)) {
+ this.workingMemory.activeUnits.push(memory);
+ }
+
+ // Update focus based on memory importance
+ this.updateFocus(memory);
+ }
+
+ private updateFocus(memory: MemoryUnit) {
+ const importance = memory.temporal.importance;
+
+ if (importance > 0.8) {
+ // High importance memories become primary focus
+ this.workingMemory.focus.primary = memory.id;
+ } else if (importance > 0.5) {
+ // Medium importance memories become secondary focus
+ if (!this.workingMemory.focus.secondary.includes(memory.id)) {
+ this.workingMemory.focus.secondary.push(memory.id);
+ }
+ }
+
+ // Update attention weights
+ this.workingMemory.focus.attentionWeights[memory.id] = importance;
+ }
+
+ // Helper Methods
+ private matchesQuery(memory: MemoryUnit, query: MemoryRetrieval): boolean {
+ // Implement query matching logic
+ return true; // Placeholder
+ }
+
+ private generateId(): string {
+ return Math.random().toString(36).substring(2, 15);
+ }
+
+ private mergeMemoryContents(memories: MemoryUnit[]): any {
+ // Implement memory content merging logic
+ return {}; // Placeholder
+ }
+
+ private calculateTemporalProperties(memories: MemoryUnit[]): any {
+ // Implement temporal properties calculation
+ return {}; // Placeholder
+ }
+
+ private calculateEmotionalProperties(memories: MemoryUnit[]): any {
+ // Implement emotional properties calculation
+ return {}; // Placeholder
+ }
+
+ private buildMemoryConnections(memories: MemoryUnit[]): any[] {
+ // Implement memory connections building
+ return []; // Placeholder
+ }
+
+ // Emotional State Management
+ updateEmotionalState(update: Partial) {
+ this.emotionalState = {
+ ...this.emotionalState,
+ ...update
+ };
+ this.workingMemory.context.emotionalState = this.emotionalState;
+ }
+
+ getCurrentEmotionalState(): EmotionalState {
+ return this.emotionalState;
+ }
+
+ // LLM-specific operations
+ async storeLLMContext(context: LLMContextMemory): Promise {
+ // Update working memory context
+ this.workingMemory.llmContext = {
+ ...this.workingMemory.llmContext,
+ currentModel: context.content.data.model,
+ contextWindow: {
+ used: context.content.data.tokens.total,
+ available: context.content.data.contextWindow
+ },
+ temperature: context.content.data.parameters.temperature
+ };
+
+ return this.storeMemory(context);
+ }
+
+ async storeEmbedding(embedding: EmbeddingMemory): Promise {
+ // Cache the embedding
+ this.workingMemory.embeddings.cache.set(
+ embedding.content.data.text,
+ embedding.content.data.embedding
+ );
+
+ return this.storeMemory(embedding);
+ }
+
+ async storePrompt(prompt: PromptMemory): Promise {
+ // Update recent prompts
+ this.workingMemory.llmContext.recentPrompts.push(
+ prompt.content.data.template
+ );
+
+ // Keep only last 10 prompts
+ if (this.workingMemory.llmContext.recentPrompts.length > 10) {
+ this.workingMemory.llmContext.recentPrompts.shift();
+ }
+
+ return this.storeMemory(prompt);
+ }
+
+ async retrieveSimilarMemories(query: string, threshold: number = 0.8): Promise {
+ // Get embedding for query
+ const queryEmbedding = await this.getEmbedding(query);
+
+ // Find similar memories
+ const similarMemories: MemoryUnit[] = [];
+
+ for (const [text, embedding] of this.workingMemory.embeddings.cache) {
+ const similarity = this.calculateSimilarity(queryEmbedding, embedding);
+ if (similarity >= threshold) {
+ const memories = await this.retrieveMemory({
+ query: text,
+ context: {},
+ filters: {}
+ });
+ similarMemories.push(...memories);
+ }
+ }
+
+ return similarMemories;
+ }
+
+ // Helper methods for LLM operations
+ private async getEmbedding(text: string): Promise {
+ // Check cache first
+ if (this.workingMemory.embeddings.cache.has(text)) {
+ return this.workingMemory.embeddings.cache.get(text)!;
+ }
+
+ // TODO: Implement actual embedding generation
+ // const embedding = await openai.embeddings.create({
+ // model: this.workingMemory.embeddings.model,
+ // input: text
+ // });
+
+ // For now, return placeholder
+ return new Array(1536).fill(0).map(() => Math.random());
+ }
+
+ private calculateSimilarity(embedding1: number[], embedding2: number[]): number {
+ // Implement cosine similarity
+ const dotProduct = embedding1.reduce((sum, val, i) => sum + val * embedding2[i], 0);
+ const norm1 = Math.sqrt(embedding1.reduce((sum, val) => sum + val * val, 0));
+ const norm2 = Math.sqrt(embedding2.reduce((sum, val) => sum + val * val, 0));
+
+ return dotProduct / (norm1 * norm2);
+ }
+
+ // Enhanced memory consolidation for LLM context
+ async consolidateLLMMemories(
+ sourceMemories: string[],
+ llmContext: Partial
+ ): Promise {
+ const memories = await Promise.all(
+ sourceMemories.map(id => this.retrieveMemory({ query: id }))
+ ).then(results => results.flat());
+
+ // Create new consolidated memory with LLM context
+ const newMemory: MemoryUnit = {
+ id: this.generateId(),
+ type: 'llm_context',
+ content: {
+ ...this.mergeMemoryContents(memories),
+ ...llmContext
+ },
+ temporal: this.calculateTemporalProperties(memories),
+ emotional: this.calculateEmotionalProperties(memories),
+ connections: this.buildMemoryConnections(memories)
+ };
+
+ await this.storeMemory(newMemory);
+ return newMemory;
+ }
+
+ // Life event management
+ async registerLifeEvent(event: TemporalProperties['lifeEvents'][0]) {
+ this.activeLifeEvents.set(event.eventId, event);
+
+ // Update emotional state based on event
+ this.updateEmotionalState({
+ mood: event.emotionalImpact.valence,
+ energy: event.emotionalImpact.arousal,
+ stress: 1 - event.emotionalImpact.persistence,
+ focus: 0.5 // Reduced focus during significant events
+ });
+ }
+
+ async endLifeEvent(eventId: string) {
+ const event = this.activeLifeEvents.get(eventId);
+ if (event) {
+ event.endDate = new Date();
+ this.activeLifeEvents.delete(eventId);
+
+ // Gradually return to baseline emotional state
+ this.updateEmotionalState({
+ mood: 0, // Neutral
+ energy: 1,
+ stress: 0,
+ focus: 1
+ });
+ }
+ }
+
+ // Helper methods
+ private calculateEmotionalInfluence(memories: MemoryUnit[]): {
+ triggers: EmotionalProperties['triggers'];
+ baseline: number;
+ volatility: number;
+ } {
+ const triggers: EmotionalProperties['triggers'] = [];
+ let totalValence = 0;
+ let totalArousal = 0;
+ let count = 0;
+
+ memories.forEach(memory => {
+ // Collect triggers
+ triggers.push(...memory.emotional.triggers);
+
+ // Calculate average emotional state
+ totalValence += memory.emotional.valence;
+ totalArousal += memory.emotional.arousal;
+ count++;
+ });
+
+ return {
+ triggers,
+ baseline: count > 0 ? totalValence / count : 0,
+ volatility: count > 0 ? totalArousal / count : 0
+ };
+ }
+
+ private getCurrentTemporalContext(): TemporalProperties['temporalContext'] {
+ const activeEvents = Array.from(this.activeLifeEvents.values());
+ return {
+ period: activeEvents.length > 0 ?
+ activeEvents.map(e => e.type).join('-') :
+ 'normal',
+ moodState: this.getMoodState(),
+ cognitiveBias: this.getActiveBiases()
+ };
+ }
+
+ private getMoodState(): string {
+ const mood = this.emotionalState.mood;
+ if (mood > 0.7) return 'euphoric';
+ if (mood > 0.3) return 'positive';
+ if (mood < -0.7) return 'depressed';
+ if (mood < -0.3) return 'negative';
+ return 'neutral';
+ }
+
+ private getActiveBiases(): string[] {
+ const biases: string[] = [];
+ const mood = this.emotionalState.mood;
+
+ if (mood > 0.5) {
+ biases.push('optimism', 'overestimation');
+ } else if (mood < -0.5) {
+ biases.push('pessimism', 'catastrophizing');
+ }
+
+ if (this.emotionalState.stress > 0.7) {
+ biases.push('anxiety', 'hypervigilance');
+ }
+
+ return biases;
+ }
+}
+
+export const memoryService = new MemoryService();
\ No newline at end of file
diff --git a/frontend/src/shared/components/_V1/BorderSpinner.tsx b/frontend/src/shared/components/_V1/BorderSpinner.tsx
new file mode 100644
index 0000000..91b6d84
--- /dev/null
+++ b/frontend/src/shared/components/_V1/BorderSpinner.tsx
@@ -0,0 +1,13 @@
+import React from 'react';
+import { ProgressSpinner } from 'primereact/progressspinner';
+const BorderSpinner = () => {
+ return (
+ = ({ children }) => {
+ return (
+ {children}
+ );
+};
+
+export default Divider;
\ No newline at end of file
diff --git a/frontend/src/shared/components/_V1/LoadingPage.tsx b/frontend/src/shared/components/_V1/LoadingPage.tsx
new file mode 100644
index 0000000..d13d4b0
--- /dev/null
+++ b/frontend/src/shared/components/_V1/LoadingPage.tsx
@@ -0,0 +1,16 @@
+import BorderSpinner from './BorderSpinner';
+
+const LoadingPage = ({ height = 200, fullScreen = true }) => {
+ return (
+ & {
+ body: any[];
+};
+
+const TableGroup: FunctionComponent = ({ body, ...dataTableProps }) => {
+ return dataTableProps.loading ? (
+ >;
+ sizeOptions: { label: string; value: TSizeOptionValue }[];
+ globalFilterValue: string;
+ onGlobalFilterChange: (e: { target: { value: any } }) => void;
+ onRefresh: () => void;
+ clearFilter: () => void;
+ hasExpandButtons?: boolean;
+ setExpandedRows?: Dispatch>;
+ expandedData?: any[];
+ extraButtonsTemplate?: () => JSX.Element;
+}
+
+export const TableGroupHeader: React.FC = ({
+ size,
+ setSize,
+ sizeOptions,
+ globalFilterValue,
+ onGlobalFilterChange,
+ onRefresh,
+ clearFilter,
+ hasExpandButtons,
+ setExpandedRows,
+ expandedData,
+ extraButtonsTemplate,
+}) => {
+ if (hasExpandButtons && (!setExpandedRows || !expandedData)) {
+ throw new Error(
+ 'When hasExpandButtons is true, setExpandedRows and expandedData are required.'
+ );
+ }
+
+ return (
+ = ({ style, className, disabled, ...buttonProps }) => {
+ const disabledClass = disabled
+ ? 'bg-gray-500 hover:bg-gray-500 text-white'
+ : 'bg-teal-500 hover:bg-white hover:text-teal-500';
+ return (
+ (null);
+ const fileInputRef = useRef(null);
+
+ const localStorageKey = 'userAvatarImage';
+
+ const handleAvatarClick = () => {
+ fileInputRef.current?.click();
+ };
+
+ const handleFileChange = (event: React.ChangeEvent) => {
+ const file = event.target.files?.[0];
+ if (file) {
+ const reader = new FileReader();
+ reader.onloadend = () => {
+ const result = reader.result;
+ setImage(result);
+ if (typeof result === 'string') {
+ localStorage.setItem(localStorageKey, result);
+ }
+ };
+ reader.readAsDataURL(file);
+ }
+ };
+
+ useEffect(() => {
+ const savedImage = localStorage.getItem(localStorageKey);
+ if (savedImage) {
+ setImage(savedImage);
+ }
+ }, []);
+
+ return (
+ = ({ style, className, ...dropdownProps }) => {
+ return (
+ = ({ style, className, ...inputProps }) => {
+ return (
+
+ }
+ >
+
+
+ {modals.map((modal) => (
+
+ );
+};
+
+export default ModalContainer;
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/ModalFactory.tsx b/frontend/src/components/FuseMind/modals/ModalFactory.tsx
new file mode 100644
index 0000000..2e1f729
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/ModalFactory.tsx
@@ -0,0 +1,66 @@
+import React from 'react';
+import { ModalType, ModalPosition } from './core/types';
+import TableModal from './TableModal';
+
+interface TableContent {
+ columns: Array<{
+ field: string;
+ header: string;
+ }>;
+ data: Array
+
+ ))}
+ Empty modal
;
+
+ switch (type) {
+ case 'table':
+ if (typeof content === 'object' && 'columns' in content && 'data' in content) {
+ return Invalid table content
;
+ default:
+ return content as React.ReactNode;
+ }
+ };
+
+ return (
+
+
+ );
+};
+
+export default ModalFactory;
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/TableModal.d.ts b/frontend/src/components/FuseMind/modals/TableModal.d.ts
new file mode 100644
index 0000000..f461195
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/TableModal.d.ts
@@ -0,0 +1,17 @@
+import React from 'react';
+
+interface TableContent {
+ columns: Array<{
+ field: string;
+ header: string;
+ }>;
+ data: Array
+
+ Data Table
+
+
+ {renderContent()}
+
+
+
+
+ {content.columns.map(col => (
+
+
+ );
+};
+
+export default TableModal;
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/commands/parser.ts b/frontend/src/components/FuseMind/modals/commands/parser.ts
new file mode 100644
index 0000000..5598454
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/commands/parser.ts
@@ -0,0 +1,56 @@
+import { ModalType } from '../core/types';
+
+export interface ParsedCommand {
+ type: 'MODAL_COMMAND';
+ action: 'CREATE' | 'SPLIT' | 'UPDATE' | 'STYLE' | 'HELP' | 'RESIZE';
+ params: {
+ modalType?: ModalType;
+ layout?: 'horizontal' | 'vertical';
+ position?: 'left' | 'right' | 'top' | 'bottom';
+ style?: {
+ backgroundColor?: string;
+ };
+ size?: {
+ width?: string;
+ height?: string;
+ };
+ count?: number;
+ content?: unknown;
+ };
+}
+
+export const HELP_TEXT = `
+I can help you with the following commands:
+- Create modals: "show me a table/text/image"
+- Split screen: "show two tables side by side"
+- Style modals: "make right modal blue"
+- Resize modals: "make modal bigger" or "set modal width to 80%"
+- Layout: "arrange modals vertically"
+
+Examples:
+- "show me options" - displays available commands
+- "show me a table" - creates a table modal
+- "make modal 80% wide" - resizes modal width
+- "split screen horizontally" - arranges modals horizontally
+`;
+
+export const COMMAND_PROMPT = `You are a helpful assistant that creates data tables. If the user's message implies they want to see data in a table format (they might mention "table", "data", "information", "stats", etc., or just ask about a topic that would be best shown in a table), create a table about that topic.
+
+Return ONLY a JSON object in this format:
+{
+ "columns": [
+ {"field": "column1", "header": "Column 1"},
+ {"field": "column2", "header": "Column 2"}
+ ],
+ "data": [
+ {"column1": "value1", "column2": "value2"},
+ {"column1": "value3", "column2": "value4"}
+ ]
+}
+
+Rules:
+1. Return ONLY the JSON object, no explanations
+2. Make sure field names in data match column fields exactly
+3. Choose appropriate column names based on the topic
+4. Include at least 5 rows of data
+5. If the user's message doesn't imply they want tabular data, return null`;
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/components/Modal.tsx b/frontend/src/components/FuseMind/modals/components/Modal.tsx
new file mode 100644
index 0000000..9293537
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/components/Modal.tsx
@@ -0,0 +1,53 @@
+import React from 'react';
+import { ModalConfig } from '../core/types';
+import { useModal } from '../context/ModalContext';
+
+interface ModalProps extends ModalConfig {}
+
+export const Modal: React.FC
+
+ );
+};
\ No newline at end of file
diff --git a/frontend/src/components/FuseMind/modals/components/ModalRenderer.tsx b/frontend/src/components/FuseMind/modals/components/ModalRenderer.tsx
new file mode 100644
index 0000000..d4ccb4a
--- /dev/null
+++ b/frontend/src/components/FuseMind/modals/components/ModalRenderer.tsx
@@ -0,0 +1,18 @@
+import React from 'react';
+import { Modal } from './Modal';
+import { useModal } from '../context/ModalContext';
+
+export const ModalRenderer: React.FC = () => {
+ const { modals } = useModal();
+
+ return (
+ <>
+ {modals.map((modal) => (
+
+
+ Data Table
+ +
+ {content}
+
+ Fusero
; + + useEffect(() => { + const timeoutId = setTimeout(() => { + setIsTransitioning(false); + }, 350); + return () => clearTimeout(timeoutId); + }, [isTransitioning]); + + return ( +
+
+
+
+ );
+};
+
+export default LoginModal;
diff --git a/frontend/src/components/PromptBox.tsx b/frontend/src/components/PromptBox.tsx
new file mode 100644
index 0000000..87bd76a
--- /dev/null
+++ b/frontend/src/components/PromptBox.tsx
@@ -0,0 +1,47 @@
+import React, { useState } from 'react';
+import PropTypes from 'prop-types';
+
+type PromptBoxProps = {
+ onSubmit: (message: string) => void;
+};
+
+const PromptBox: React.FC
+
+ setUsername(e.target.value)}
+ className='w-full'
+ />
+
+
+
+ setPassword(e.target.value)}
+ onKeyDown={handleKeyDown}
+ className='w-full'
+ />
+
+
+
+
+
+
+
+ );
+};
+
+PromptBox.propTypes = {
+ onSubmit: PropTypes.func.isRequired,
+};
+
+export default PromptBox;
diff --git a/frontend/src/components/SystemSelectionModal.tsx b/frontend/src/components/SystemSelectionModal.tsx
new file mode 100644
index 0000000..8fbc438
--- /dev/null
+++ b/frontend/src/components/SystemSelectionModal.tsx
@@ -0,0 +1,140 @@
+import { useCallback, useEffect, useState } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { Card } from 'primereact/card';
+import Button from '../shared/components/_V2/Button';
+import Dropdown from '../shared/components/_V2/Dropdown';
+import Divider from '../shared/components/_V1/Divider';
+
+import fusero_logo from '../assets/fusero_logo.svg';
+import { useSystemStore } from '../state/stores/useSystemStore';
+
+export type SystemDropdownOption = {
+ id: number;
+ label: string;
+ businessLabel: string;
+ urlSlug: string;
+ logo: string;
+ category: string;
+ enterprises?: Enterprise[];
+};
+
+export type Enterprise = {
+ id: number;
+ name: string;
+};
+
+export interface SystemSelectionModalProps {
+ systemDetails: SystemDropdownOption | null;
+ onSystemSelected: (systemData: any) => void;
+ onLogoChange: (newLogoPath: string) => void;
+}
+
+// TODO: removed mocked put in db
+const mockedSystems = [
+ {
+ id: 1,
+ label: 'CouncilAI',
+ businessLabel: 'CouncilAI',
+ urlSlug: 'council',
+ logo: fusero_logo,
+ category: 'Apps',
+ },
+ {
+ id: 4,
+ label: 'FuseMind',
+ businessLabel: 'FuseMind (AI)',
+ urlSlug: 'fusemind',
+ logo: fusero_logo,
+ category: 'Apps',
+ },
+];
+
+// Add system default routes configuration
+const systemDefaultRoutes = {
+ council: 'chat',
+ fusemind: 'home',
+};
+
+const SystemSelectionModal = ({ systemDetails }: SystemSelectionModalProps) => {
+ const navigate = useNavigate();
+ const [selectedSystem, setSelectedSystem] = useStateApps & Flows
+
+
+ {selectedSystem && selectedSystem.enterprises && (
+
+
+);
+
+const ProfileDetails = ({ user }) => {
+ if (!user) {
+ return (
+ Notifications
+You have no new notifications.
+
+
+ );
+ }
+
+ return (
+ Profile Details
+No user information available.
+
+
+ );
+};
+
+const TenantProfile = () => {
+ const { user, logout } = useAuthStore();
+ const [isVisible, setIsVisible] = useState(false);
+ const [activeIndex, setActiveIndex] = useState(0);
+
+ useEffect(() => {
+ const timeout = setTimeout(() => setIsVisible(true), 50);
+ return () => clearTimeout(timeout);
+ }, []);
+
+ const handleLogout = () => {
+ setIsVisible(false);
+ setTimeout(() => {
+ logout();
+ }, 500);
+ };
+
+ const username = user ? user.username : 'Guest';
+ const roles = user && user.roles ? user.roles.join(', ') : 'No roles assigned';
+ const tenantId = user ? user.id : 'No tenant ID found';
+
+ return (
+ Profile Details
+Tenant ID: {user.id}
+Username: {user.username}
+Roles: {user.roles.join(', ')}
+
+
+ );
+};
+
+export default TenantProfile;
diff --git a/frontend/src/global.types.d.ts b/frontend/src/global.types.d.ts
new file mode 100644
index 0000000..42563f7
--- /dev/null
+++ b/frontend/src/global.types.d.ts
@@ -0,0 +1,7 @@
+type User = {
+ id: string;
+ username?: string;
+ roles?: string[];
+ token?: string;
+ tenantId: string;
+};
diff --git a/frontend/src/hooks/useAuth.ts b/frontend/src/hooks/useAuth.ts
new file mode 100644
index 0000000..a47f878
--- /dev/null
+++ b/frontend/src/hooks/useAuth.ts
@@ -0,0 +1,67 @@
+import { useEffect, useState } from 'react';
+import { jwtDecode } from 'jwt-decode';
+import { api } from '../services/api';
+
+interface AuthHook {
+ user: User | null;
+ login: (username: string, password: string) => Promise
+
+
+
+
+
+
+ 
+
+
+ Tenant Dashboard
+
+ setActiveIndex(e.index)}
+ className='custom-tabview'
+ >
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Welcome back, {username}!
+ {/*Tenant ID: {tenantId}
+{roles}
*/} ++ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor + incididunt ut labore et dolore magna aliqua. +
+
+
+ );
+};
+
+export default DualModalComponent;
diff --git a/frontend/src/layouts/Sidebar.tsx b/frontend/src/layouts/Sidebar.tsx
new file mode 100644
index 0000000..f89c5ac
--- /dev/null
+++ b/frontend/src/layouts/Sidebar.tsx
@@ -0,0 +1,102 @@
+import React, { useState, useEffect } from 'react';
+import { Link, useLocation, useNavigate } from 'react-router-dom';
+import { Button } from 'primereact/button';
+import fusero_logo from '../assets/fusero_logo.svg';
+
+import 'primeicons/primeicons.css';
+
+const systemConfig = {
+ council: {
+ routes: [{ path: 'chat', label: 'chat', icon: 'pi pi-users' }],
+ logo: fusero_logo,
+ },
+ fusemind: {
+ routes: [
+ { path: 'home', label: 'Home', icon: 'pi pi-home' },
+ { path: 'chat', label: 'Chat', icon: 'pi pi-comments' },
+ { path: 'agents', label: 'Agents', icon: 'pi pi-users' },
+ { path: 'settings', label: 'Settings', icon: 'pi pi-cog' }
+ ],
+ logo: fusero_logo,
+ },
+};
+
+const Sidebar = ({ systemId, isCollapsed, setIsCollapsed }) => {
+ const location = useLocation();
+ const navigate = useNavigate();
+ const system = systemConfig[systemId];
+
+ const [isVisible, setIsVisible] = useState(false);
+
+ useEffect(() => {
+ let timeoutId = setTimeout(() => setIsVisible(true), 50);
+ return () => clearTimeout(timeoutId);
+ }, [systemId, isCollapsed]);
+
+ const handleBackClick = () => {
+ setIsVisible(false);
+ };
+
+ const toggleCollapse = () => setIsCollapsed((prevState) => !prevState);
+
+ if (!systemId || !system) {
+ console.error('Sidebar: systemId is undefined or not supported.');
+ return
+ {isLoggedIn ? (
+ showOutlet && systemId && animationFinished ? (
+
+
+
+
+ {isLoggedIn && showOutlet && systemId ? (
+ 
+ )}
+
+ )}
+
+ No system selected
; + } + + return ( + {
+ if (!isVisible) navigate('/dashboard');
+ }}
+ >
+
+
+
+ +
+ );
+};
+
+export default Sidebar;
diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx
new file mode 100644
index 0000000..99521be
--- /dev/null
+++ b/frontend/src/main.tsx
@@ -0,0 +1,14 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import './index.css';
+import Router from './router'; // Importing the router configuration
+import { RouterProvider } from 'react-router-dom';
+
+const rootElement = document.getElementById('root') as HTMLElement;
+const root = ReactDOM.createRoot(rootElement);
+
+root.render(
+
+
+
+
+
+
+
+ 
+
+
+ + +
-
+ {system.routes.map(({ path, label, icon }) => (
+
- + + + {isCollapsed ? '' : label} + + + ))} +
Error: Page not found here?
, + }, +]); + +export default router; diff --git a/frontend/src/services/api.ts b/frontend/src/services/api.ts new file mode 100644 index 0000000..584c113 --- /dev/null +++ b/frontend/src/services/api.ts @@ -0,0 +1,92 @@ +import axios, { AxiosResponse, ResponseType } from 'axios'; +import { useApiLogStore } from './apiLogStore'; + +// Server path +const serverPath = import.meta.env.VITE_API_BASE_URL as string; + +type THttpMethod = 'get' | 'put' | 'post' | 'delete'; + +const DEFAULT_TIMEOUT = 60; + +export type ApiResponse
+
+ );
+};
+
+export default BorderSpinner;
diff --git a/frontend/src/shared/components/_V1/Divider.tsx b/frontend/src/shared/components/_V1/Divider.tsx
new file mode 100644
index 0000000..956d7d8
--- /dev/null
+++ b/frontend/src/shared/components/_V1/Divider.tsx
@@ -0,0 +1,10 @@
+import { DividerProps, Divider as PrimeDivider } from "primereact/divider";
+import { FunctionComponent } from "react";
+
+const Divider: FunctionComponent
+
+
+
+ );
+};
+
+export default LoadingPage;
diff --git a/frontend/src/shared/components/_V1/TableGroup.tsx b/frontend/src/shared/components/_V1/TableGroup.tsx
new file mode 100644
index 0000000..4f3bcfb
--- /dev/null
+++ b/frontend/src/shared/components/_V1/TableGroup.tsx
@@ -0,0 +1,28 @@
+import { FunctionComponent } from 'react';
+import { DataTable, DataTableProps } from 'primereact/datatable';
+import LoadingPage from './LoadingPage';
+
+type CustomTableGroupProps = DataTableProps
+
+
+ setSize(e.value)}
+ options={sizeOptions}
+ style={{ textAlign: 'center' }}
+ />
+ {hasExpandButtons ? (
+
+ );
+};
+export default TableGroupHeader;
diff --git a/frontend/src/shared/components/_V2/Button.tsx b/frontend/src/shared/components/_V2/Button.tsx
new file mode 100644
index 0000000..9e0274a
--- /dev/null
+++ b/frontend/src/shared/components/_V2/Button.tsx
@@ -0,0 +1,21 @@
+import { Button as PrimeButton, ButtonProps } from 'primereact/button';
+import React from 'react';
+
+interface CustomButtonProps extends ButtonProps {}
+
+const Button: React.FC
+
+ ) : null}
+
+
+
+
+
+
+
+ {extraButtonsTemplate ? extraButtonsTemplate() : null}
+
+
+
+
+ );
+};
+
+export default CustomAvatar;
diff --git a/frontend/src/shared/components/_V2/Dropdown.tsx b/frontend/src/shared/components/_V2/Dropdown.tsx
new file mode 100644
index 0000000..80d34bc
--- /dev/null
+++ b/frontend/src/shared/components/_V2/Dropdown.tsx
@@ -0,0 +1,16 @@
+import { Dropdown as PrimeDropdown, DropdownProps } from 'primereact/dropdown';
+import React from 'react';
+
+interface CustomDropdownProps extends DropdownProps {}
+
+const Dropdown: React.FC{message}
+
+ );
+};
+
+export default ConfirmModal;
diff --git a/frontend/src/shared/components/modals/DeleteModal.tsx b/frontend/src/shared/components/modals/DeleteModal.tsx
new file mode 100644
index 0000000..e9cad04
--- /dev/null
+++ b/frontend/src/shared/components/modals/DeleteModal.tsx
@@ -0,0 +1,78 @@
+import React, { useState } from 'react';
+import { Button } from 'primereact/button';
+import { Dialog } from 'primereact/dialog';
+import { InputTextarea } from 'primereact/inputtextarea';
+
+interface DeleteModalProps {
+ visible: boolean;
+ onHide: () => void;
+ onConfirm: () => void;
+ confirmLabel: string;
+ cancelLabel: string;
+ onCancel: () => void;
+}
+
+const DeleteModal: React.FC