open-swarm 0.1.1743070217__py3-none-any.whl → 0.1.1743362777__py3-none-any.whl

swarm/static/rest_mode/js/debug.js

@@ -0,0 +1,63 @@
+// src/swarm/static/rest_mode/js/debug.js
+
+import { showToast } from './toast.js';
+import { chatHistory } from './modules/state.js'; 
+import { contextVariables } from './modules/state.js'; 
+export { debugLog } from './modules/debugLogger.js'; 
+
+/**
+ * Toggles the Debug pane.
+ * Displays raw messages and key info from the most recent message.
+ */
+export function toggleDebugPane() {
+    const debugPane = document.getElementById("debugPane");
+    if (!debugPane) return;
+
+    if (debugPane.style.display === "block") {
+        debugPane.style.display = "none";
+        showToast("🐞 Debug pane hidden.", "info");
+    } else {
+        debugPane.style.display = "block";
+        showToast("🐞 Debug pane shown.", "info");
+        renderRelevantDebugInfo();
+    }
+}
+
+/**
+ * Handles Tech Support Button Click Inside Debug Pane
+ */
+export function handleTechSupport() {
+    showToast("🛠️ Tech Support feature coming soon!", "info");
+}
+
+/**
+ * Renders relevant debug information from the most recent message in chatHistory.
+ */
+function renderRelevantDebugInfo() {
+    const debugContent = document.getElementById("debugContent");
+    if (!debugContent) return;
+
+    if (chatHistory.length === 0) {
+        debugContent.innerHTML = "<p>No messages yet.</p>";
+        return;
+    }
+
+    const latestMessage = chatHistory[chatHistory.length - 1];
+    const { role, content, sender, metadata } = latestMessage;
+
+    debugContent.innerHTML = `
+        <p><strong>Role:</strong> ${role}</p>
+        <p><strong>Sender:</strong> ${sender}</p>
+        <p><strong>Content:</strong> ${content || "No content provided."}</p>
+        <p><strong>Metadata:</strong> <pre>${JSON.stringify(metadata || {}, null, 2)}</pre></p>
+    `;
+
+    if (contextVariables.active_agent_name) {
+        const activeAgentElement = document.createElement("div");
+        activeAgentElement.className = "debug-active-agent";
+        activeAgentElement.innerHTML = `<strong>Active Agent:</strong> ${contextVariables.active_agent_name}`;
+        debugContent.appendChild(activeAgentElement);
+    }
+
+    debugContent.scrollTop = debugContent.scrollHeight;
+}

swarm/static/rest_mode/js/events.js

@@ -0,0 +1,98 @@
+// src/swarm/static/rest_mode/js/events.js
+
+import { toggleSidebar } from './sidebar.js';
+import { handleChatHistoryClick } from './modules/chatHistory.js';
+import { deleteChat } from './modules/apiService.js';
+import { handleUpload, handleVoiceRecord } from './modules/userInteractions.js';
+import { fetchBlueprintMetadata } from './modules/apiService.js';
+import { handleSubmit } from './modules/messageProcessor.js';
+import { toggleDebugPane, handleTechSupport } from './debug.js';
+import { showToast } from './toast.js';
+import { handleLogout } from './auth.js';
+import { debugLog } from './modules/debugLogger.js';
+
+/**
+ * Handles "Search" button click.
+ */
+function handleSearch() {
+    showToast("🔍 Search feature is under development.", "info");
+}
+
+/**
+ * Handles "New Chat" button click.
+ */
+function handleNewChat() {
+    showToast("📝 Starting a new chat...", "info");
+    // Implement new chat functionality as needed
+}
+
+/**
+ * Attaches event listeners to chat history items.
+ */
+function setupChatHistoryListeners() {
+    const chatHistoryItems = document.querySelectorAll('.chat-history-pane li');
+    chatHistoryItems.forEach((item) => {
+        item.addEventListener('click', () => handleChatHistoryClick(item));
+
+        const trashCan = item.querySelector('.trash-can');
+        if (trashCan) {
+            trashCan.addEventListener('click', (e) => {
+                e.stopPropagation();
+                deleteChat(item);
+            });
+        }
+    });
+}
+
+/**
+ * Attaches event listeners to main application buttons and elements.
+ */
+function setupGlobalEventListeners() {
+    // Sidebar toggles
+    document.getElementById("settingsToggleButton")?.addEventListener('click', () => toggleSidebar('options', true));
+    document.getElementById("optionsSidebarHideBtn")?.addEventListener('click', () => toggleSidebar('options', false));
+    document.getElementById("chatHistoryToggleButton")?.addEventListener('click', () => toggleSidebar('left', true));
+    document.getElementById("leftSidebarHideBtn")?.addEventListener('click', () => toggleSidebar('left', false));
+
+    // Top buttons
+    // document.getElementById("searchButton")?.addEventListener('click', handleSearch);
+    document.getElementById("newChatButton")?.addEventListener('click', handleNewChat);
+
+    // Functional buttons
+    document.getElementById("logoutButton")?.addEventListener('click', handleLogout);
+    document.getElementById("uploadButton")?.addEventListener('click', handleUpload);
+    document.getElementById("voiceRecordButton")?.addEventListener('click', handleVoiceRecord);
+    document.getElementById("submitButton")?.addEventListener("click", handleSubmit);
+
+    // User input submission with Enter key
+    const userInput = document.getElementById("userInput");
+    userInput?.addEventListener("keypress", (e) => {
+        if (e.key === "Enter") {
+            e.preventDefault();
+            handleSubmit();
+        }
+    });
+
+    // Debug pane toggles
+    document.getElementById("debugButton")?.addEventListener('click', toggleDebugPane);
+    document.getElementById("techSupportButtonInsideDebug")?.addEventListener('click', handleTechSupport);
+}
+
+/**
+ * Sets up all event listeners for the application.
+ */
+export function setupEventListeners() {
+    setupGlobalEventListeners();
+    setupChatHistoryListeners();
+    debugLog('All event listeners have been set up.');
+}
+
+/**
+ * Initialize the application.
+ */
+export function initializeApplication() {
+    debugLog('[DEBUG] Initializing application...');
+    fetchBlueprintMetadata(); // Fetch blueprint metadata and display it
+    setupEventListeners();    // Set up event listeners
+    debugLog('[DEBUG] Application initialized.');
+}

swarm/static/rest_mode/js/main.js

@@ -0,0 +1,19 @@
+// main.js - Main application entry point
+
+import { initializeSplashScreen } from './splash.js';
+import { initializeUI } from './ui.js';
+import { debugLog } from './settings.js';
+
+document.addEventListener('DOMContentLoaded', () => {
+    debugLog("DOM Content Loaded. Initializing application...");
+
+    try {
+        initializeSplashScreen();
+        debugLog("Splash screen initialization complete.");
+
+        initializeUI();
+        debugLog("UI initialization complete.");
+    } catch (error) {
+        debugLog(`Initialization failed: ${error.message}`, "error");
+    }
+});

swarm/static/rest_mode/js/messages.js

@@ -0,0 +1,264 @@
+import { debugLog } from './debug.js';
+import { enableSlidingToolbar } from './ui.js';
+// import { marked } from '../../contrib/markedjs/marked.min.js';
+import { marked } from "https://cdn.jsdelivr.net/npm/marked/lib/marked.esm.js";
+
+let quickPrompts = ["What is Open-Swarm?", "Explain the architecture.", "How do I set up a new blueprint?"];
+
+export function renderMessage(role, content, sender, metadata) {
+    debugLog('Rendering message...', { role, content, sender, metadata });
+
+    const messageContainer = document.getElementById('messageHistory');
+    if (!messageContainer) {
+        debugLog('Message container not found.');
+        return;
+    }
+
+    let messageContent = content.content || content.text || '';
+
+    // 🛑 Ignore empty messages immediately
+    if (!messageContent.trim()) {
+        debugLog('Skipping empty message.');
+        return;
+    }
+
+    // 🔄 Detect assistant handoff JSON
+    let isHandoff = false;
+    try {
+        const parsedContent = JSON.parse(messageContent);
+        if (parsedContent.assistant && typeof parsedContent.assistant === 'string') {
+            messageContent = `<em>🔄 Handoff to <strong>${parsedContent.assistant}</strong></em>`;
+            role = 'system';
+            isHandoff = true;
+        }
+    } catch (e) {
+        // Not a JSON object, proceed
+    }
+
+    if (!isHandoff) {
+        messageContent = `<strong>${sender}:</strong> ${marked.parse(messageContent)}`;
+    }
+
+    // ❌ Prevent rendering assistant messages with "No content"
+    if (role === "assistant" && messageContent.includes("<p>No content</p>")) {
+        debugLog("Skipping assistant message with 'No content'.");
+        return; // 🛑 Stop execution here
+    }
+
+    // ✅ Create the message
+    const messageDiv = document.createElement('div');
+    messageDiv.className = `message ${role}`;
+    
+    messageDiv.innerHTML = `
+        <div class="message-text">${messageContent}</div>
+        <div class="message-toolbar">
+            <button class="toolbar-btn" aria-label="Copy Message">
+                <img src="/static/rest_mode/svg/copy.svg" alt="Copy Icon" class="icon-svg" />
+            </button>
+            <button class="toolbar-btn" aria-label="Delete Message">
+                <img src="/static/rest_mode/svg/trash.svg" alt="Trash Icon" class="icon-svg" />
+            </button>
+        </div>
+    `;
+
+    messageContainer.appendChild(messageDiv);
+    debugLog('Message rendered successfully.');
+}
+
+/**
+ * Appends a raw message object into the chat UI.
+ */
+let isAppendingMessage = false; // Prevent duplicate appending
+
+export function appendRawMessage(role, content, sender, metadata) {
+    if (isAppendingMessage) {
+        debugLog('Duplicate appendRawMessage call detected. Skipping execution.', { role, content, sender, metadata });
+        return;
+    }
+
+    isAppendingMessage = true; // Set the flag
+    debugLog('Appending raw message...', { role, content, sender, metadata });
+
+    renderMessage(role, content, sender, metadata);
+
+    const messageContainer = document.getElementById('messageHistory');
+    if (messageContainer) {
+        messageContainer.scrollTop = messageContainer.scrollHeight;
+        debugLog('Scrolled to the bottom of the message history.');
+    }
+
+    isAppendingMessage = false; // Reset the flag
+}
+
+
+
+/**
+ * Renders quick prompts in the UI.
+ */
+export function renderQuickPrompts() {
+    const quickPromptsContainer = document.getElementById('quickPrompts');
+    if (!quickPromptsContainer) {
+        debugLog('Quick prompts container not found.');
+        return;
+    }
+
+    quickPromptsContainer.innerHTML = quickPrompts
+        .map(
+            (prompt, index) => `
+            <button class="quick-prompt-button" data-index="${index}">
+                ${prompt}
+            </button>`
+        )
+        .join('');
+
+    document.querySelectorAll('.quick-prompt-button').forEach((button) =>
+        button.addEventListener('click', (e) => handleQuickPromptSelection(e))
+    );
+    debugLog('Quick prompts rendered successfully.');
+}
+
+/**
+ * Handles quick prompt selection.
+ */
+function handleQuickPromptSelection(event) {
+    const promptIndex = event.target.getAttribute('data-index');
+    const promptText = quickPrompts[promptIndex];
+
+    appendRawMessage('user', { content: promptText }, 'User', {});
+    clearQuickPrompts();
+}
+
+/**
+ * Clears all quick prompts from the UI.
+ */
+function clearQuickPrompts() {
+    const quickPromptsContainer = document.getElementById('quickPrompts');
+    if (quickPromptsContainer) {
+        quickPromptsContainer.innerHTML = '';
+        debugLog('Quick prompts cleared.');
+    }
+}
+
+/**
+ * Allows adding a new quick prompt dynamically.
+ */
+export function addQuickPrompt(prompt) {
+    quickPrompts.push(prompt);
+    renderQuickPrompts();
+    debugLog('Quick prompt added.', { prompt });
+}
+
+/**
+ * Removes a quick prompt by index.
+ */
+export function removeQuickPrompt(index) {
+    if (index < 0 || index >= quickPrompts.length) {
+        debugLog('Invalid quick prompt index.', { index });
+        return;
+    }
+    quickPrompts.splice(index, 1);
+    renderQuickPrompts();
+    debugLog('Quick prompt removed.', { index });
+}
+
+/**
+ * Clears all messages from the chat history UI.
+ */
+export function clearMessages() {
+    debugLog('Clearing all messages from the chat history.');
+
+    const messageContainer = document.getElementById('messageHistory');
+    if (messageContainer) {
+        messageContainer.innerHTML = '';
+        debugLog('Chat history cleared successfully.');
+    }
+}
+
+/**
+ * Attaches toolbar actions to a message element.
+ */
+function attachToolbarActions(messageDiv) {
+    const persistentMessage = document.getElementById("persistentMessage");
+
+    messageDiv.addEventListener("click", (event) => {
+        const target = event.target.closest('button');
+        if (!target) return;
+
+        const action = target.getAttribute('aria-label');
+
+        switch (action) {
+            case 'Thumbs Up':
+                debugLog('Thumbs up clicked.');
+                break;
+            case 'Thumbs Down':
+                debugLog('Thumbs down clicked.');
+                break;
+            case 'Append to Persistent Message':
+                appendToPersistentMessage(messageDiv, persistentMessage);
+                break;
+            case 'Edit Message':
+                editMessage(messageDiv);
+                break;
+            case 'Copy Message':
+                copyMessageToClipboard(messageDiv);
+                break;
+            case 'Delete Message':
+                deleteMessage(messageDiv);
+                break;
+        }
+    });
+}
+
+/**
+ * Appends the content of a message to the persistent message area.
+ */
+function appendToPersistentMessage(messageDiv, persistentMessageElement) {
+    if (!persistentMessageElement) {
+        console.error("Persistent message element not found (firstUserMessage).");
+        return;
+    }
+
+    const content = messageDiv.querySelector('span')?.innerText || "No content";
+    const persistentMessageContent = persistentMessageElement.querySelector('.message span');
+
+    if (persistentMessageContent) {
+        persistentMessageContent.innerText = content;
+        debugLog('Message appended to persistent message area.', { content });
+    } else {
+        console.error("Persistent message content element not found.");
+    }
+}
+
+/**
+ * Allows the user to edit a message.
+ */
+function editMessage(messageDiv) {
+    const span = messageDiv.querySelector('span');
+    const content = span.innerText;
+    const newContent = prompt('Edit your message:', content);
+    if (newContent !== null) {
+        span.innerText = newContent;
+        debugLog('Message edited successfully.', { newContent });
+    }
+}
+
+/**
+ * Copies a message's content to the clipboard.
+ */
+function copyMessageToClipboard(messageDiv) {
+    const content = messageDiv.querySelector('span').innerText;
+    navigator.clipboard.writeText(content).then(() => {
+        alert('Message copied to clipboard!');
+        debugLog('Message copied to clipboard.', { content });
+    });
+}
+
+/**
+ * Deletes a message from the chat history.
+ */
+function deleteMessage(messageDiv) {
+    if (confirm('Are you sure you want to delete this message?')) {
+        messageDiv.remove();
+        debugLog('Message deleted successfully.');
+    }
+}