Upload 47 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+9001AFB3-063D-4B72-AD44-79E61CC65111.webp filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,89 @@
----
-title: maximus-im
-emoji: 🐳
-colorFrom: yellow
-colorTo: blue
-sdk: static
-pinned: false
-tags:
-  - deepsite
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Quantum NLP Framework
+
+A Python-based Flask web application with spaCy NLP processing, quantum-inspired recursive functions, and OpenAI API integration. This framework implements a multi-dimensional, layered thinking process inspired by quantum computing concepts.
+
+## Features
+
+- Natural language processing using spaCy
+- Recursive function simulating quantum-inspired thinking processes
+- OpenAI API integration for generating human-like text
+- Flask web interface with input fields for text processing
+- Multi-dimensional, layered thinking simulation
+
+## Requirements
+
+- Python 3.x
+- Flask
+- spaCy (with the English model)
+- OpenAI Python client
+- requests
+
+## Installation on Replit
+
+1. **Create a new Replit project**
+   - Choose Python as the language
+
+2. **Install dependencies**
+   ```
+   pip install flask spacy openai
+   python -m spacy download en_core_web_sm
+   ```
+
+3. **Set up your OpenAI API key**
+   - In Replit, go to the "Secrets" tab in the Tools panel
+   - Add a new secret with the key `OPENAI_API_KEY` and your OpenAI API key as the value
+
+4. **Run the application**
+   - Click the "Run" button in Replit
+   - The application will be available at `https://your-repl-name.your-username.repl.co`
+
+## Usage
+
+1. Enter text in the input field
+2. Select the depth of quantum analysis (1-4 dimensions)
+3. Toggle the option to use OpenAI for enhanced analysis
+4. Click "Analyze Text" to process the input
+5. View the results in the three results sections:
+   - NLP Analysis
+   - Quantum Thinking Results
+   - AI Analysis (if OpenAI is enabled)
+
+## How It Works
+
+### NLP Processing
+
+The application uses spaCy to process text input, extracting:
+- Named entities
+- Part-of-speech tags
+- Noun chunks
+- Text statistics
+
+### Quantum-Inspired Recursive Thinking
+
+The recursive function simulates a multi-dimensional, layered thinking process by:
+1. Extracting key concepts from the input text
+2. For each concept, creating a "thought path" for recursive exploration
+3. Applying "superposition" by allowing paths to influence each other
+4. Synthesizing meta-insights from all paths
+5. Computing a "quantum probability" score
+
+### OpenAI Integration
+
+When enabled, the application:
+1. Creates a prompt that incorporates the quantum thinking results
+2. Sends the prompt to OpenAI's API
+3. Displays the AI-generated response
+
+## Project Structure
+
+- `main.py`: Entry point for the application
+- `app.py`: Main Flask application code
+- `nlp_processor.py`: spaCy NLP processing functions
+- `quantum_thinking.py`: Quantum-inspired recursive thinking implementation
+- `openai_integration.py`: Functions for working with the OpenAI API
+- `templates/`: HTML templates for the web interface
+- `static/`: CSS and JavaScript files
+
+## License
+
+This project is open-source and available under the MIT License.

ai-conv-client.pid

@@ -0,0 +1 @@
+57093

ai-conv-server.log

@@ -0,0 +1,5 @@
+npm error Missing script: "start:prod"
+npm error
+npm error To see a list of scripts, run:
+npm error   npm run
+npm error A complete log of this run can be found in: /Users/lattm/.npm/_logs/2025-04-17T17_24_51_380Z-debug-0.log

ai-conv-server.pid

@@ -0,0 +1 @@
+57090

animations.css

@@ -0,0 +1,500 @@
+/* 
+ * Quantum Animation Styles
+ * Provides visual effects for the quantum transitions and particle animations
+ */
+
+/* Particle Canvas */
+.particle-canvas {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  pointer-events: none;
+  z-index: 1000;
+  backdrop-filter: blur(3px);
+  opacity: 0;
+  transition: opacity 0.3s ease;
+}
+
+.particle-canvas.active {
+  opacity: 1;
+}
+
+/* Quantum Overlay */
+#quantum-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background-color: rgba(10, 10, 16, 0.92);
+  display: none;
+  justify-content: center;
+  align-items: center;
+  z-index: 2000;
+  opacity: 0;
+  transition: opacity 0.3s ease-in-out;
+  overflow: hidden;
+}
+
+#quantum-overlay::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: url('/static/images/quantum-bg.svg');
+  background-size: cover;
+  opacity: 0.2;
+  z-index: -1;
+  filter: blur(2px);
+  animation: quantum-bg-pulse 8s infinite alternate;
+}
+
+#quantum-overlay::after {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: radial-gradient(
+    circle at center,
+    rgba(218, 75, 134, 0.15),
+    rgba(10, 10, 16, 0.2) 60%
+  );
+  z-index: -1;
+  animation: quantum-pulse 4s infinite alternate;
+}
+
+#quantum-overlay.active {
+  opacity: 1;
+}
+
+@keyframes quantum-bg-pulse {
+  0% {
+    opacity: 0.1;
+    transform: scale(1);
+  }
+  100% {
+    opacity: 0.3;
+    transform: scale(1.05);
+  }
+}
+
+/* Quantum Loader */
+.quantum-loader {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  perspective: 1000px;
+}
+
+.quantum-spinner {
+  position: relative;
+  width: 150px;
+  height: 150px;
+  transform-style: preserve-3d;
+  animation: quantum-spin 8s linear infinite;
+}
+
+.quantum-message {
+  margin-top: 20px;
+  color: white;
+  font-size: 1.2rem;
+  font-weight: 300;
+  letter-spacing: 2px;
+  animation: quantum-pulse 2s infinite;
+}
+
+/* Quantum Orbits */
+.q-orbit {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  border-radius: 50%;
+  border: 2px solid transparent;
+}
+
+.q-orbit-1 {
+  border-top-color: #da4b86;
+  border-bottom-color: #da4b86;
+  animation: orbit-spin-1 3s linear infinite;
+  box-shadow: 0 0 10px rgba(218, 75, 134, 0.5);
+}
+
+.q-orbit-2 {
+  width: 120px;
+  height: 120px;
+  margin: 15px;
+  border-left-color: #6f42c1;
+  border-right-color: #6f42c1;
+  animation: orbit-spin-2 4s linear infinite;
+  box-shadow: 0 0 10px rgba(111, 66, 193, 0.5);
+}
+
+.q-orbit-3 {
+  width: 80px;
+  height: 80px;
+  margin: 35px;
+  border-top-color: #0dcaf0;
+  border-right-color: #0dcaf0;
+  animation: orbit-spin-3 2s linear infinite;
+  box-shadow: 0 0 10px rgba(13, 202, 240, 0.5);
+}
+
+.q-core {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: 30px;
+  height: 30px;
+  margin-top: -15px;
+  margin-left: -15px;
+  background: radial-gradient(circle, #da4b86, #6f42c1);
+  border-radius: 50%;
+  box-shadow: 0 0 20px #da4b86, 0 0 40px #6f42c1;
+  animation: pulse 2s ease-in-out infinite alternate;
+}
+
+/* Animation for result cards */
+.card {
+  transition: all 0.5s cubic-bezier(0.215, 0.610, 0.355, 1.000);
+}
+
+.quantum-reveal {
+  animation: quantum-reveal 0.8s cubic-bezier(0.215, 0.610, 0.355, 1.000) forwards;
+}
+
+/* Special effects for quantum visualization */
+.quantum-visualized {
+  position: relative;
+  overflow: hidden;
+}
+
+.quantum-visualized::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: radial-gradient(circle, transparent 50%, rgba(66, 133, 244, 0.1) 100%);
+  pointer-events: none;
+  animation: quantum-pulse 8s infinite alternate;
+}
+
+/* Define animations */
+@keyframes quantum-spin {
+  0% {
+    transform: rotateY(0) rotateX(0);
+  }
+  25% {
+    transform: rotateY(90deg) rotateX(45deg);
+  }
+  50% {
+    transform: rotateY(180deg) rotateX(0);
+  }
+  75% {
+    transform: rotateY(270deg) rotateX(-45deg);
+  }
+  100% {
+    transform: rotateY(360deg) rotateX(0);
+  }
+}
+
+@keyframes orbit-spin-1 {
+  from { transform: rotateZ(0deg); }
+  to { transform: rotateZ(360deg); }
+}
+
+@keyframes orbit-spin-2 {
+  from { transform: rotateY(0deg) rotateX(60deg); }
+  to { transform: rotateY(360deg) rotateX(60deg); }
+}
+
+@keyframes orbit-spin-3 {
+  from { transform: rotateY(60deg) rotateX(0deg); }
+  to { transform: rotateY(60deg) rotateX(360deg); }
+}
+
+@keyframes pulse {
+  from { 
+    transform: scale(0.8);
+    box-shadow: 0 0 20px #da4b86, 0 0 40px #6f42c1;
+  }
+  to { 
+    transform: scale(1.1);
+    box-shadow: 0 0 30px #da4b86, 0 0 60px #0dcaf0;
+  }
+}
+
+@keyframes quantum-pulse {
+  0% {
+    opacity: 0.6;
+  }
+  50% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 0.6;
+  }
+}
+
+@keyframes quantum-reveal {
+  from {
+    opacity: 0;
+    transform: translateY(30px) scale(0.95);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
+
+/* Smoke dispersion effect */
+.smoke-particle {
+  position: absolute;
+  border-radius: 50%;
+  background-color: rgba(255, 255, 255, 0.8);
+  filter: blur(10px);
+  pointer-events: none;
+}
+
+/* Tumbleweed whirlwind effect */
+.tumbleweed {
+  position: absolute;
+  width: 50px;
+  height: 50px;
+  border-radius: 50%;
+  background: radial-gradient(circle, rgba(120, 120, 120, 0.8), rgba(80, 80, 80, 0.5));
+  filter: blur(5px);
+  transition: transform 0.5s, opacity 0.5s;
+  pointer-events: none;
+}
+
+/* Dynamic transition effect */
+.transition-fade {
+  opacity: 0;
+  transition: opacity 0.5s ease;
+}
+
+.transition-fade.show {
+  opacity: 1;
+}
+
+/* Text to vision transition */
+.text-to-vision {
+  position: relative;
+  overflow: hidden;
+}
+
+.text-to-vision::after {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: linear-gradient(to right, transparent, rgba(66, 133, 244, 0.2), transparent);
+  transform: translateX(-100%);
+  animation: text-scan 2s linear infinite;
+}
+
+/* Text-to-vision transition with smoke effect */
+.text-to-vision-active {
+  animation: smoke-disperse 1.5s ease-out forwards;
+}
+
+/* Smoke transition effect */
+@keyframes smoke-disperse {
+  0% {
+    filter: blur(0);
+    opacity: 1;
+    transform: scale(1);
+  }
+  50% {
+    filter: blur(5px);
+    opacity: 0.7;
+    transform: scale(1.02) translateY(5px);
+  }
+  100% {
+    filter: blur(0);
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+@keyframes text-scan {
+  0% {
+    transform: translateX(-100%);
+  }
+  100% {
+    transform: translateX(100%);
+  }
+}
+
+/* Quantum pulse animation for visualized elements */
+.quantum-visualized {
+  --quantum-pulse-intensity: 0.5;
+}
+
+.quantum-visualized::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: radial-gradient(
+    circle at center,
+    rgba(66, 133, 244, calc(0.1 * var(--quantum-pulse-intensity))),
+    transparent 70%
+  );
+  opacity: 0.7;
+  z-index: -1;
+  animation: quantum-pulse calc(8s / var(--quantum-pulse-intensity)) infinite alternate;
+}
+
+/* Special effect for quantum score badge */
+.quantum-score {
+  position: relative;
+  transition: all 0.3s ease;
+  animation: score-pulse 3s infinite alternate;
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.quantum-score::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: linear-gradient(45deg, 
+    rgba(218, 75, 134, 0.3),
+    rgba(111, 66, 193, 0.3),
+    rgba(13, 202, 240, 0.3)
+  );
+  opacity: 0.3;
+  z-index: -1;
+}
+
+.quantum-score:hover {
+  transform: scale(1.1);
+  box-shadow: 0 0 15px rgba(218, 75, 134, 0.5);
+}
+
+@keyframes score-pulse {
+  0% {
+    box-shadow: 0 0 5px rgba(218, 75, 134, 0.4);
+    text-shadow: 0 0 3px rgba(218, 75, 134, 0.4);
+  }
+  50% {
+    box-shadow: 0 0 8px rgba(111, 66, 193, 0.5);
+    text-shadow: 0 0 5px rgba(111, 66, 193, 0.5);
+  }
+  100% {
+    box-shadow: 0 0 12px rgba(13, 202, 240, 0.6);
+    text-shadow: 0 0 8px rgba(13, 202, 240, 0.6);
+  }
+}
+
+/* Tumbleweed/whirlwind effect with smoke-like appearance */
+.tumbleweed {
+  position: absolute;
+  border-radius: 50%;
+  background: radial-gradient(circle at 30% 30%, 
+    rgba(255, 255, 255, 0.3),
+    rgba(218, 75, 134, 0.15) 20%,
+    rgba(111, 66, 193, 0.1) 40%,
+    rgba(13, 202, 240, 0.05) 60%,
+    transparent 80%
+  );
+  box-shadow: 0 0 12px rgba(218, 75, 134, 0.2);
+  opacity: 0.7;
+  pointer-events: none;
+  filter: blur(3px);
+  transform-origin: center center;
+  animation: tumbleweed-rotate 10s linear infinite;
+}
+
+@keyframes tumbleweed-rotate {
+  0% { transform: rotate(0deg) scale(1); }
+  25% { transform: rotate(90deg) scale(1.2); }
+  50% { transform: rotate(180deg) scale(1); }
+  75% { transform: rotate(270deg) scale(0.8); }
+  100% { transform: rotate(360deg) scale(1); }
+}
+
+/* Quantum particle effect */
+.quantum-particle {
+  position: fixed;
+  width: 3px;
+  height: 3px;
+  border-radius: 50%;
+  pointer-events: none;
+  z-index: 1000;
+  opacity: 0.7;
+  box-shadow: 0 0 4px currentColor;
+  animation: particle-fade 1s ease-out forwards;
+}
+
+@keyframes particle-fade {
+  0% {
+    transform: scale(1);
+    opacity: 0.7;
+  }
+  100% {
+    transform: scale(0);
+    opacity: 0;
+  }
+}
+
+/* Quantum reveal animation for cards */
+.quantum-card {
+  opacity: 0;
+  transform: translateY(20px);
+  transition: opacity 0.5s ease, transform 0.5s ease;
+}
+
+.quantum-card.quantum-reveal {
+  opacity: 1;
+  transform: translateY(0);
+}
+
+/* Quantum pulse animation for the background */
+@keyframes quantum-pulse {
+  0% {
+    opacity: 0.3;
+    transform: scale(0.95);
+  }
+  50% {
+    opacity: 0.5;
+    transform: scale(1.05);
+  }
+  100% {
+    opacity: 0.3;
+    transform: scale(0.95);
+  }
+}
+
+/* Atom spin animation for the icon */
+.quantum-spin {
+  display: inline-block;
+  animation: atom-spin 10s linear infinite;
+}
+
+@keyframes atom-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}

animations.js

@@ -0,0 +1,550 @@
+/**
+ * Quantum Transition Animations
+ * Provides dynamic transitions and particle effects for the Quantum NLP Framework
+ */
+
+// Wait for document to be fully loaded
+document.addEventListener('DOMContentLoaded', function() {
+  // Initialize animations when page loads
+  initQuantumAnimations();
+  
+  // Add event listener for analyze button to trigger animations
+  const analyzeBtn = document.getElementById('analyze-btn');
+  if (analyzeBtn) {
+    analyzeBtn.addEventListener('click', function() {
+      // Only trigger animation if form is valid
+      const form = document.getElementById('process-form');
+      if (form.checkValidity()) {
+        showQuantumTransition();
+      }
+    });
+    
+    // Enhanced button effects
+    analyzeBtn.addEventListener('mouseover', function() {
+      triggerSmallParticleEffect(this);
+    });
+  }
+  
+  // Initialize text-to-vision transitions
+  initTextToVisionTransitions();
+  
+  // Check if results are present and apply animations
+  const resultsContainer = document.getElementById('results-container');
+  if (resultsContainer && resultsContainer.children.length > 0) {
+    applyResultsAnimations(resultsContainer);
+  }
+});
+
+/**
+ * Initialize text-to-vision transitions with staggered timing
+ */
+function initTextToVisionTransitions() {
+  const visionElements = document.querySelectorAll('.text-to-vision');
+  visionElements.forEach((elem, index) => {
+    // Add a staggered delay for smoother visual effect
+    const delay = 300 + (index * 150);
+    setTimeout(() => {
+      elem.classList.add('text-to-vision-active');
+      
+      // Reset the animation after it completes to allow replaying
+      setTimeout(() => {
+        elem.classList.remove('text-to-vision-active');
+      }, 1500);
+    }, delay);
+  });
+}
+
+/**
+ * Apply animations to results container
+ */
+function applyResultsAnimations(container) {
+  // Add entrance animation
+  container.style.opacity = '0';
+  container.style.transform = 'translateY(20px)';
+  
+  setTimeout(() => {
+    container.style.transition = 'opacity 0.5s ease, transform 0.5s ease';
+    container.style.opacity = '1';
+    container.style.transform = 'translateY(0)';
+    
+    // Apply smoke dispersion effect to each card
+    const cards = container.querySelectorAll('.quantum-card');
+    cards.forEach((card, index) => {
+      setTimeout(() => {
+        card.classList.add('quantum-reveal');
+      }, 300 + (index * 150));
+    });
+  }, 200);
+}
+
+/**
+ * Trigger a small particle effect around an element
+ */
+function triggerSmallParticleEffect(element) {
+  // Create a few particles around the button
+  const rect = element.getBoundingClientRect();
+  const centerX = rect.left + rect.width / 2;
+  const centerY = rect.top + rect.height / 2;
+  
+  // Create 5-10 particles
+  const count = Math.floor(Math.random() * 5) + 5;
+  for (let i = 0; i < count; i++) {
+    const particle = document.createElement('div');
+    particle.className = 'quantum-particle';
+    
+    // Random position around the element
+    const angle = Math.random() * Math.PI * 2;
+    const distance = Math.random() * 20 + 10;
+    const x = centerX + Math.cos(angle) * distance;
+    const y = centerY + Math.sin(angle) * distance;
+    
+    // Random size
+    const size = Math.random() * 4 + 2;
+    
+    // Set styles
+    particle.style.left = x + 'px';
+    particle.style.top = y + 'px';
+    particle.style.width = size + 'px';
+    particle.style.height = size + 'px';
+    particle.style.backgroundColor = getQuantumParticleColor();
+    
+    // Add to body
+    document.body.appendChild(particle);
+    
+    // Animate and remove
+    setTimeout(() => {
+      particle.remove();
+    }, 1000);
+  }
+}
+
+/**
+ * Initialize all quantum animations and effects
+ */
+function initQuantumAnimations() {
+  // Create canvas for particle effects
+  createParticleCanvas();
+  
+  // Pre-load any assets needed for animations
+  preloadAnimationAssets();
+}
+
+/**
+ * Create canvas for particle animations
+ */
+function createParticleCanvas() {
+  const canvas = document.createElement('canvas');
+  canvas.id = 'quantum-particles';
+  canvas.className = 'particle-canvas';
+  canvas.width = window.innerWidth;
+  canvas.height = window.innerHeight;
+  
+  // Add canvas to the body but keep it hidden initially
+  canvas.style.display = 'none';
+  canvas.style.position = 'fixed';
+  canvas.style.top = 0;
+  canvas.style.left = 0;
+  canvas.style.pointerEvents = 'none';
+  canvas.style.zIndex = 1000;
+  document.body.appendChild(canvas);
+  
+  // Handle window resize
+  window.addEventListener('resize', function() {
+    canvas.width = window.innerWidth;
+    canvas.height = window.innerHeight;
+  });
+}
+
+/**
+ * Preload any assets needed for animations
+ */
+function preloadAnimationAssets() {
+  // Add any image preloading here if needed
+}
+
+/**
+ * Show the quantum transition animation when analyzing text
+ */
+function showQuantumTransition() {
+  // Get input and display areas
+  const inputArea = document.querySelector('.card-body:has(#input_text)');
+  const resultsArea = document.querySelector('#results-container');
+  
+  // Show loading overlay
+  showLoadingOverlay();
+  
+  // Show particle effects
+  triggerParticleEffect();
+  
+  // The actual form submission happens normally, but we add visual effects
+}
+
+/**
+ * Show a quantum-themed loading overlay
+ */
+function showLoadingOverlay() {
+  // Create overlay if it doesn't exist
+  let overlay = document.getElementById('quantum-overlay');
+  
+  if (!overlay) {
+    overlay = document.createElement('div');
+    overlay.id = 'quantum-overlay';
+    overlay.innerHTML = `
+      <div class="quantum-loader">
+        <div class="quantum-spinner">
+          <div class="q-orbit q-orbit-1"></div>
+          <div class="q-orbit q-orbit-2"></div>
+          <div class="q-orbit q-orbit-3"></div>
+          <div class="q-core"></div>
+        </div>
+        <div class="quantum-message">Quantum Processing</div>
+      </div>
+    `;
+    document.body.appendChild(overlay);
+  }
+  
+  // Show the overlay with animation
+  overlay.style.display = 'flex';
+  setTimeout(() => {
+    overlay.classList.add('active');
+  }, 10);
+}
+
+/**
+ * Hide the quantum loading overlay
+ */
+function hideLoadingOverlay() {
+  const overlay = document.getElementById('quantum-overlay');
+  if (overlay) {
+    overlay.classList.remove('active');
+    setTimeout(() => {
+      overlay.style.display = 'none';
+    }, 500);
+  }
+}
+
+/**
+ * Trigger the particle whirlwind effect
+ */
+function triggerParticleEffect() {
+  const canvas = document.getElementById('quantum-particles');
+  if (!canvas) return;
+  
+  // Show canvas with fade-in
+  canvas.style.display = 'block';
+  setTimeout(() => {
+    canvas.classList.add('active');
+  }, 10);
+  
+  // Get canvas context
+  const ctx = canvas.getContext('2d');
+  ctx.clearRect(0, 0, canvas.width, canvas.height);
+  
+  // Create particles for the whirlwind effect
+  const particles = [];
+  const particleCount = 150;
+  
+  // Initialize particles
+  for (let i = 0; i < particleCount; i++) {
+    particles.push({
+      x: canvas.width / 2,
+      y: canvas.height / 2,
+      size: Math.random() * 5 + 1,
+      color: getQuantumParticleColor(),
+      speedX: (Math.random() - 0.5) * 10,
+      speedY: (Math.random() - 0.5) * 10,
+      rotationRadius: Math.random() * 100 + 50,
+      rotationSpeed: Math.random() * 0.1 + 0.02,
+      rotationAngle: Math.random() * Math.PI * 2,
+      opacity: Math.random() * 0.7 + 0.3,
+      fadeSpeed: Math.random() * 0.02 + 0.005
+    });
+  }
+  
+  // Animation variables
+  let frame = 0;
+  const maxFrames = 120;
+  
+  // Animate particles
+  function animateParticles() {
+    // Clear canvas
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    
+    // Update and draw particles
+    for (let i = 0; i < particles.length; i++) {
+      const p = particles[i];
+      
+      // Update rotation angle
+      p.rotationAngle += p.rotationSpeed;
+      
+      // Calculate position with spiral effect
+      const spiralFactor = 1 + (frame / maxFrames) * 3;
+      const rotRadius = p.rotationRadius * (1 - frame / maxFrames);
+      
+      p.x = canvas.width / 2 + Math.cos(p.rotationAngle) * rotRadius * spiralFactor;
+      p.y = canvas.height / 2 + Math.sin(p.rotationAngle) * rotRadius;
+      
+      // Add dispersion effect in later frames
+      if (frame > maxFrames * 0.7) {
+        p.x += p.speedX;
+        p.y += p.speedY;
+        p.opacity -= p.fadeSpeed;
+      }
+      
+      // Draw particle
+      ctx.globalAlpha = Math.max(0, p.opacity);
+      ctx.fillStyle = p.color;
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
+      ctx.fill();
+    }
+    
+    // Increment frame
+    frame++;
+    
+    // Continue animation or clean up
+    if (frame <= maxFrames) {
+      requestAnimationFrame(animateParticles);
+    } else {
+      // End animation with fade-out
+      canvas.classList.remove('active');
+      
+      // After fade-out, hide the canvas completely
+      setTimeout(() => {
+        canvas.style.display = 'none';
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+      }, 300);
+    }
+  }
+  
+  // Start animation
+  animateParticles();
+  
+  // Set timeout to match form submission time
+  setTimeout(function() {
+    hideLoadingOverlay();
+    
+    // Add reveal animation to results when they load
+    const resultElements = document.querySelectorAll('.card');
+    resultElements.forEach((el, index) => {
+      if (el.closest('#results-container')) {
+        // Add a staggered delay for each card
+        setTimeout(() => {
+          el.classList.add('quantum-reveal');
+        }, index * 150);
+      }
+    });
+  }, 2000); // Adjust timing as needed to match server response time
+}
+
+/**
+ * Get a color for quantum particles
+ */
+function getQuantumParticleColor() {
+  const colors = [
+    '#4285F4', // Blue
+    '#0F9D58', // Green
+    '#DB4437', // Red
+    '#F4B400', // Yellow
+    '#9C27B0', // Purple
+    '#00BCD4', // Cyan
+    '#3F51B5'  // Indigo
+  ];
+  return colors[Math.floor(Math.random() * colors.length)];
+}
+
+/**
+ * Apply visualization effect to quantum results
+ */
+function visualizeQuantumResults() {
+  const quantumScoreEl = document.querySelector('.quantum-score');
+  if (quantumScoreEl) {
+    // Get the quantum score
+    const score = parseFloat(quantumScoreEl.textContent);
+    
+    // Create a visualization canvas for the score
+    createQuantumScoreVisualization(quantumScoreEl, score);
+    
+    // Apply visualization to the entire container
+    const container = document.querySelector('.quantum-visualized');
+    if (container) {
+      applyQuantumVisualization(container, score);
+    }
+  }
+}
+
+/**
+ * Create a visualization for the quantum score
+ */
+function createQuantumScoreVisualization(element, score) {
+  // Add special particle effects around the score
+  const parentEl = element.closest('.text-end');
+  if (!parentEl) return;
+  
+  // Create a canvas for the visualization
+  const canvas = document.createElement('canvas');
+  canvas.className = 'quantum-score-canvas';
+  canvas.width = 200;
+  canvas.height = 100;
+  canvas.style.position = 'absolute';
+  canvas.style.top = '0';
+  canvas.style.right = '0';
+  canvas.style.pointerEvents = 'none';
+  canvas.style.zIndex = '1';
+  
+  // Insert canvas
+  parentEl.style.position = 'relative';
+  parentEl.appendChild(canvas);
+  
+  // Create particles
+  const ctx = canvas.getContext('2d');
+  const particles = [];
+  const particleCount = Math.round(score * 50); // More particles for higher scores
+  
+  // Create particles based on score
+  for (let i = 0; i < particleCount; i++) {
+    particles.push({
+      x: canvas.width * 0.75,
+      y: canvas.height * 0.5,
+      size: Math.random() * 3 + 1,
+      color: getScoreColor(score),
+      speedX: (Math.random() - 0.5) * 2,
+      speedY: (Math.random() - 0.5) * 2,
+      opacity: Math.random() * 0.5 + 0.3,
+      life: Math.random() * 100 + 50
+    });
+  }
+  
+  // Animate particles
+  function animate() {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    
+    let remainingParticles = 0;
+    
+    for (let i = 0; i < particles.length; i++) {
+      const p = particles[i];
+      
+      if (p.life > 0) {
+        p.x += p.speedX;
+        p.y += p.speedY;
+        p.opacity = Math.max(0, p.opacity - 0.005);
+        p.life--;
+        
+        ctx.globalAlpha = p.opacity;
+        ctx.fillStyle = p.color;
+        ctx.beginPath();
+        ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
+        ctx.fill();
+        
+        remainingParticles++;
+      }
+    }
+    
+    if (remainingParticles > 0) {
+      requestAnimationFrame(animate);
+    }
+  }
+  
+  // Start animation
+  animate();
+}
+
+/**
+ * Apply quantum visualization to an element
+ */
+function applyQuantumVisualization(element, score) {
+  // Add the visualized class
+  element.classList.add('quantum-visualized');
+  
+  // Create dynamic quantum effect based on score
+  const intensity = score || 0.5;
+  
+  // Add a pulsing background effect
+  element.style.setProperty('--quantum-pulse-intensity', intensity);
+  
+  // Create tumbleweed whirlwind effect
+  createTumbleweeds(element, Math.round(intensity * 10));
+}
+
+/**
+ * Create tumbleweed whirlwind particles inside an element
+ */
+function createTumbleweeds(element, count) {
+  for (let i = 0; i < count; i++) {
+    const tumbleweed = document.createElement('div');
+    tumbleweed.className = 'tumbleweed';
+    
+    // Random position within the element
+    const rect = element.getBoundingClientRect();
+    const x = Math.random() * rect.width;
+    const y = Math.random() * rect.height;
+    
+    // Random size
+    const size = Math.random() * 20 + 10;
+    
+    // Set styles
+    tumbleweed.style.left = x + 'px';
+    tumbleweed.style.top = y + 'px';
+    tumbleweed.style.width = size + 'px';
+    tumbleweed.style.height = size + 'px';
+    
+    // Add to the element
+    element.appendChild(tumbleweed);
+    
+    // Animate the tumbleweed
+    animateTumbleweed(tumbleweed, rect);
+  }
+}
+
+/**
+ * Animate a tumbleweed particle
+ */
+function animateTumbleweed(element, containerRect) {
+  const duration = Math.random() * 8000 + 4000; // 4-12 seconds
+  let startTime = null;
+  
+  // The animation function
+  function animate(timestamp) {
+    if (!startTime) startTime = timestamp;
+    const elapsed = timestamp - startTime;
+    const progress = Math.min(elapsed / duration, 1);
+    
+    // Spiral motion
+    const angle = progress * Math.PI * 6; // 3 full rotations
+    const radius = progress * 100; // Expand outward
+    const centerX = containerRect.width / 2;
+    const centerY = containerRect.height / 2;
+    
+    const x = centerX + Math.cos(angle) * radius;
+    const y = centerY + Math.sin(angle) * radius;
+    
+    // Apply position
+    element.style.transform = `translate(${x}px, ${y}px) rotate(${angle * 180 / Math.PI}deg)`;
+    
+    // Fade out towards the end
+    if (progress > 0.7) {
+      element.style.opacity = 1 - ((progress - 0.7) / 0.3);
+    }
+    
+    // Continue animation if not complete
+    if (progress < 1) {
+      requestAnimationFrame(animate);
+    } else {
+      // Remove element when animation completes
+      element.remove();
+    }
+  }
+  
+  // Start the animation
+  requestAnimationFrame(animate);
+}
+
+/**
+ * Get color based on score value
+ */
+function getScoreColor(score) {
+  if (score < 0.3) return '#dc3545'; // Low - red
+  if (score < 0.6) return '#ffc107'; // Medium - yellow
+  if (score < 0.8) return '#0dcaf0'; // Good - cyan
+  return '#198754'; // High - green
+}

app.py

@@ -0,0 +1,251 @@
+import os
+import logging
+from flask import Flask, render_template, request, jsonify, flash, redirect, url_for
+import spacy
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy.orm import DeclarativeBase
+
+from nlp_processor import process_text
+from quantum_thinking import quantum_recursive_thinking
+from openai_integration import generate_completion
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Create the base class for SQLAlchemy models
+class Base(DeclarativeBase):
+    pass
+
+# Initialize SQLAlchemy
+db = SQLAlchemy(model_class=Base)
+
+# Create Flask app
+app = Flask(__name__)
+app.secret_key = os.environ.get("SESSION_SECRET")
+
+# Configure database
+app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DATABASE_URL")
+app.config["SQLALCHEMY_ENGINE_OPTIONS"] = {
+    "pool_recycle": 300,
+    "pool_pre_ping": True,
+}
+
+# Initialize the extensions
+db.init_app(app)
+
+# Import models and create database tables
+with app.app_context():
+    import models  # This has to be imported after db is initialized
+    db.create_all()
+    
+    # Initialize the task scheduler
+    from task_scheduler import scheduler
+    scheduler.start()
+    
+    logger.info("Database tables created and task scheduler started")
+
+# Load spaCy model (English)
+try:
+    nlp = spacy.load("en_core_web_sm")
+    logger.info("Successfully loaded spaCy English model")
+except OSError:
+    logger.warning("Downloading spaCy model...")
+    logger.warning("Please run: python -m spacy download en_core_web_sm")
+    # Fallback: use a smaller model
+    try:
+        nlp = spacy.load("en")
+    except:
+        logger.error("Failed to load spaCy model. Using blank model.")
+        nlp = spacy.blank("en")
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/settings')
+def settings():
+    """Settings page with user preferences for the application."""
+    api_key = os.environ.get("OPENAI_API_KEY", "")
+    api_key_masked = "••••••••" + api_key[-4:] if api_key else ""
+    api_key_status = bool(api_key)
+    ai_model = "gpt-4o"  # Default to the newest model
+    
+    return render_template(
+        'settings.html',
+        api_key_masked=api_key_masked,
+        api_key_status=api_key_status,
+        ai_model=ai_model
+    )
+
+@app.route('/zap-integrations')
+def zap_integrations():
+    integrations = [
+        {
+            "name": "OpenAI Connector",
+            "description": "Connect the quantum framework to OpenAI's GPT models",
+            "icon": "fa-robot",
+            "status": "active" if os.environ.get("OPENAI_API_KEY") else "inactive"
+        },
+        {
+            "name": "Language Processing Pipeline",
+            "description": "NLP processing workflow with quantum enhancement",
+            "icon": "fa-code-branch",
+            "status": "active"
+        },
+        {
+            "name": "Quantum Discord Notifier",
+            "description": "Send multi-dimensional analysis results to Discord",
+            "icon": "fa-bell",
+            "status": "pending"
+        },
+        {
+            "name": "JSON Export Automation",
+            "description": "Export quantum thinking results to JSON format",
+            "icon": "fa-file-export",
+            "status": "active"
+        },
+        {
+            "name": "Email Summarization",
+            "description": "Generate quantum-enhanced summaries of emails",
+            "icon": "fa-envelope",
+            "status": "pending"
+        }
+    ]
+    return render_template('zap_integrations.html', integrations=integrations)
+
+@app.route('/automation-workflow')
+def automation_workflow():
+    workflow_steps = [
+        {
+            "id": 1,
+            "name": "Text Input",
+            "description": "User enters text for quantum processing",
+            "status": "completed",
+            "color": "#da4b86"
+        },
+        {
+            "id": 2,
+            "name": "NLP Processing",
+            "description": "Initial language processing with spaCy",
+            "status": "completed",
+            "color": "#6f42c1"
+        },
+        {
+            "id": 3,
+            "name": "Quantum Thinking",
+            "description": "Multi-dimensional recursive thinking algorithm",
+            "status": "active",
+            "color": "#0dcaf0"
+        },
+        {
+            "id": 4,
+            "name": "Pattern Recognition",
+            "description": "Identifying patterns across quantum dimensions",
+            "status": "pending",
+            "color": "#6f42c1"
+        },
+        {
+            "id": 5,
+            "name": "Response Generation",
+            "description": "Creating AI response with quantum insights",
+            "status": "pending",
+            "color": "#da4b86"
+        }
+    ]
+    return render_template('automation_workflow.html', workflow_steps=workflow_steps)
+
+@app.route('/process', methods=['POST'])
+def process():
+    try:
+        input_text = request.form.get('input_text', '')
+        
+        if not input_text:
+            flash('Please enter some text to process', 'warning')
+            return redirect(url_for('index'))
+        
+        # Process with NLP
+        nlp_results = process_text(nlp, input_text)
+        
+        # Process with quantum-inspired recursive thinking
+        depth = int(request.form.get('depth', 3))
+        quantum_results = quantum_recursive_thinking(input_text, depth)
+        
+        # Generate OpenAI completion
+        use_ai = request.form.get('use_ai') == 'on'
+        ai_response = None
+        
+        if use_ai:
+            try:
+                ai_response = generate_completion(input_text, quantum_results)
+            except Exception as e:
+                logger.error(f"OpenAI API error: {str(e)}")
+                flash(f"Error with OpenAI API: {str(e)}", 'danger')
+        
+        return render_template(
+            'index.html', 
+            input_text=input_text,
+            nlp_results=nlp_results,
+            quantum_results=quantum_results,
+            ai_response=ai_response,
+            depth=depth
+        )
+        
+    except Exception as e:
+        logger.error(f"Error processing request: {str(e)}")
+        flash(f"An error occurred: {str(e)}", 'danger')
+        return redirect(url_for('index'))
+
+@app.route('/save-api-key', methods=['POST'])
+def save_api_key():
+    """Save OpenAI API key."""
+    api_key = request.form.get('api_key', '')
+    ai_model = request.form.get('ai_model', 'gpt-4o')
+    
+    # For a production app, we would need to securely store this API key
+    # For this demo, we will just flash a message
+    if api_key:
+        flash('API key settings updated successfully!', 'success')
+    else:
+        flash('API key has been cleared.', 'warning')
+    
+    return redirect(url_for('settings'))
+
+@app.route('/api/process', methods=['POST'])
+def api_process():
+    try:
+        data = request.get_json()
+        input_text = data.get('input_text', '')
+        depth = data.get('depth', 3)
+        use_ai = data.get('use_ai', False)
+        
+        if not input_text:
+            return jsonify({'error': 'No input text provided'}), 400
+        
+        # Process with NLP
+        nlp_results = process_text(nlp, input_text)
+        
+        # Process with quantum-inspired recursive thinking
+        quantum_results = quantum_recursive_thinking(input_text, depth)
+        
+        # Generate OpenAI completion
+        ai_response = None
+        if use_ai:
+            try:
+                ai_response = generate_completion(input_text, quantum_results)
+            except Exception as e:
+                logger.error(f"OpenAI API error: {str(e)}")
+                return jsonify({'error': f'OpenAI API error: {str(e)}'}), 500
+        
+        return jsonify({
+            'nlp_results': nlp_results,
+            'quantum_results': quantum_results,
+            'ai_response': ai_response
+        })
+        
+    except Exception as e:
+        logger.error(f"API Error: {str(e)}")
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=5000, debug=True)

automation_workflow.html

@@ -0,0 +1,426 @@
+{% extends 'layout.html' %}
+
+{% block content %}
+<div class="row mb-4">
+    <div class="col-12">
+        <div class="glass-card">
+            <div class="p-4">
+                <h1 class="display-5 quantum-glow">
+                    <i class="fas fa-cogs me-2"></i> Automation Workflow
+                </h1>
+                <p class="lead">Visualize and manage the multi-dimensional quantum processing pipeline.</p>
+                <div class="vision-progress">
+                    <div class="vision-progress-bar"></div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<div class="row">
+    <div class="col-md-8">
+        <div class="glass-card mb-4">
+            <div class="card-body p-4">
+                <h3 class="h4 mb-4 quantum-glow">Quantum Processing Pipeline</h3>
+                
+                <!-- Pyramid Workflow Visualization -->
+                <div class="workflow-pyramid-container">
+                    <div class="workflow-pyramid position-relative">
+                        {% for step in workflow_steps %}
+                        <div class="workflow-step {% if step.status == 'completed' %}completed{% elif step.status == 'active' %}active{% else %}pending{% endif %}"
+                             data-step-id="{{ step.id }}" style="--step-color: {{ step.color }};">
+                            <div class="step-indicator">
+                                <div class="step-number">{{ step.id }}</div>
+                                <div class="step-line"></div>
+                            </div>
+                            <div class="step-content">
+                                <h4 class="step-title">{{ step.name }}</h4>
+                                <p class="step-desc">{{ step.description }}</p>
+                                <span class="step-status badge {% if step.status == 'completed' %}bg-success{% elif step.status == 'active' %}bg-info{% else %}bg-secondary{% endif %} quantum-score">
+                                    {{ step.status | capitalize }}
+                                </span>
+                            </div>
+                            
+                            <!-- LED tracer lines connecting steps -->
+                            {% if not loop.last %}
+                            <div class="step-connector" style="--connector-color: {{ step.color }};"></div>
+                            {% endif %}
+                        </div>
+                        {% endfor %}
+                        
+                        <!-- 3D Tetrahedron visualization at the bottom -->
+                        <div class="tetrahedron-container">
+                            <div class="tetrahedron">
+                                <div class="tetra-face tetra-face-1"></div>
+                                <div class="tetra-face tetra-face-2"></div>
+                                <div class="tetra-face tetra-face-3"></div>
+                                <div class="tetra-face tetra-face-4"></div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <div class="col-md-4">
+        <div class="glass-card mb-4">
+            <div class="card-body p-4">
+                <h3 class="h4 mb-4 quantum-glow">Workflow Status</h3>
+                
+                <div class="mb-4">
+                    <div class="d-flex justify-content-between align-items-center mb-2">
+                        <span>Overall Progress</span>
+                        <span class="badge bg-info quantum-score">60%</span>
+                    </div>
+                    <div class="progress" style="height: 8px;">
+                        <div class="progress-bar progress-bar-striped progress-bar-animated bg-info" role="progressbar" style="width: 60%" aria-valuenow="60" aria-valuemin="0" aria-valuemax="100"></div>
+                    </div>
+                </div>
+                
+                <div class="workflow-stats">
+                    <div class="stat-item mb-3">
+                        <div class="d-flex justify-content-between">
+                            <span>Completed Steps</span>
+                            <span class="fw-bold text-success">2</span>
+                        </div>
+                    </div>
+                    <div class="stat-item mb-3">
+                        <div class="d-flex justify-content-between">
+                            <span>Active Steps</span>
+                            <span class="fw-bold text-info">1</span>
+                        </div>
+                    </div>
+                    <div class="stat-item mb-3">
+                        <div class="d-flex justify-content-between">
+                            <span>Pending Steps</span>
+                            <span class="fw-bold text-secondary">2</span>
+                        </div>
+                    </div>
+                    <div class="stat-item mb-3">
+                        <div class="d-flex justify-content-between">
+                            <span>Total Execution Time</span>
+                            <span class="fw-bold">2.4s</span>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="mt-4 d-grid">
+                    <button class="btn btn-outline-light quantum-btn">
+                        <i class="fas fa-play me-2"></i> Run Workflow
+                    </button>
+                </div>
+            </div>
+        </div>
+        
+        <div class="glass-card">
+            <div class="card-body p-4">
+                <h3 class="h4 mb-4 quantum-glow">Current Activity</h3>
+                
+                <div class="activity-log" id="activity-log">
+                    <div class="activity-item">
+                        <div class="activity-timestamp">11:15:30</div>
+                        <div class="activity-content">
+                            <span class="badge bg-success me-1">Step 2</span>
+                            NLP Processing completed
+                        </div>
+                    </div>
+                    <div class="activity-item">
+                        <div class="activity-timestamp">11:15:28</div>
+                        <div class="activity-content">
+                            <span class="badge bg-info me-1">Step 3</span>
+                            Starting Quantum Thinking algorithm
+                        </div>
+                    </div>
+                    <div class="activity-item">
+                        <div class="activity-timestamp">11:15:25</div>
+                        <div class="activity-content">
+                            <span class="badge bg-success me-1">Step 1</span>
+                            Text input received (128 chars)
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<style>
+    /* Workflow Pyramid Container */
+    .workflow-pyramid-container {
+        padding: 20px 0;
+        position: relative;
+    }
+    
+    .workflow-pyramid {
+        display: flex;
+        flex-direction: column;
+        gap: 30px;
+        padding: 20px;
+        position: relative;
+    }
+    
+    /* Workflow Steps */
+    .workflow-step {
+        --step-bg: rgba(30, 41, 59, 0.4);
+        --step-border: var(--step-color);
+        
+        display: flex;
+        background: var(--step-bg);
+        border-radius: 12px;
+        padding: 15px;
+        position: relative;
+        transition: all 0.3s ease;
+        box-shadow: 0 3px 15px rgba(0, 0, 0, 0.1);
+        border-left: 3px solid var(--step-border);
+    }
+    
+    .workflow-step:hover {
+        transform: translateY(-5px);
+    }
+    
+    .workflow-step.completed {
+        --step-bg: rgba(40, 167, 69, 0.1);
+    }
+    
+    .workflow-step.active {
+        --step-bg: rgba(13, 202, 240, 0.1);
+        animation: step-pulse 2s infinite alternate;
+    }
+    
+    @keyframes step-pulse {
+        0% { box-shadow: 0 0 5px var(--step-color); }
+        100% { box-shadow: 0 0 15px var(--step-color); }
+    }
+    
+    /* Step Connector - LED Tracer Lines */
+    .step-connector {
+        position: absolute;
+        left: 24px;
+        top: 100%;
+        height: 30px;
+        width: 2px;
+        background: linear-gradient(to bottom, var(--connector-color), transparent);
+        z-index: 1;
+        animation: pulse-connector 2s infinite alternate;
+    }
+    
+    @keyframes pulse-connector {
+        0% { opacity: 0.5; }
+        100% { opacity: 1; }
+    }
+    
+    /* Step Content */
+    .step-indicator {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        margin-right: 15px;
+    }
+    
+    .step-number {
+        width: 32px;
+        height: 32px;
+        border-radius: 50%;
+        background: var(--step-color);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-weight: bold;
+        color: white;
+        box-shadow: 0 0 10px var(--step-color);
+    }
+    
+    .step-line {
+        width: 2px;
+        height: 100%;
+        background-color: var(--step-color);
+        opacity: 0.5;
+    }
+    
+    .step-content {
+        flex: 1;
+    }
+    
+    .step-title {
+        font-size: 1.1rem;
+        margin-bottom: 5px;
+        color: var(--step-color);
+    }
+    
+    .step-desc {
+        font-size: 0.9rem;
+        opacity: 0.8;
+        margin-bottom: 10px;
+    }
+    
+    /* 3D Tetrahedron */
+    .tetrahedron-container {
+        margin-top: 30px;
+        height: 150px;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        perspective: 1000px;
+    }
+    
+    .tetrahedron {
+        width: 100px;
+        height: 100px;
+        position: relative;
+        transform-style: preserve-3d;
+        animation: tetra-rotate 15s linear infinite;
+    }
+    
+    @keyframes tetra-rotate {
+        0% { transform: rotateX(0) rotateY(0); }
+        100% { transform: rotateX(360deg) rotateY(360deg); }
+    }
+    
+    .tetra-face {
+        position: absolute;
+        width: 0;
+        height: 0;
+        border-style: solid;
+        opacity: 0.7;
+        backface-visibility: visible;
+    }
+    
+    .tetra-face-1 {
+        border-width: 0 50px 86.6px 50px;
+        border-color: transparent transparent rgba(218, 75, 134, 0.5) transparent;
+        transform: rotateX(30deg) translateY(-50px) translateZ(28.87px);
+    }
+    
+    .tetra-face-2 {
+        border-width: 0 50px 86.6px 50px;
+        border-color: transparent transparent rgba(111, 66, 193, 0.5) transparent;
+        transform: rotateX(30deg) rotateY(120deg) translateY(-50px) translateZ(28.87px);
+    }
+    
+    .tetra-face-3 {
+        border-width: 0 50px 86.6px 50px;
+        border-color: transparent transparent rgba(13, 202, 240, 0.5) transparent;
+        transform: rotateX(30deg) rotateY(240deg) translateY(-50px) translateZ(28.87px);
+    }
+    
+    .tetra-face-4 {
+        border-width: 0 50px 86.6px 50px;
+        border-color: transparent transparent rgba(255, 255, 255, 0.3) transparent;
+        transform: rotateX(-30deg) rotateY(0deg) translateY(50px) translateZ(28.87px);
+    }
+    
+    /* Activity Log */
+    .activity-log {
+        display: flex;
+        flex-direction: column;
+        gap: 15px;
+        height: 200px;
+        overflow-y: auto;
+    }
+    
+    .activity-item {
+        display: flex;
+        gap: 10px;
+        font-size: 0.9rem;
+        padding-bottom: 10px;
+        border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+    }
+    
+    .activity-timestamp {
+        color: rgba(255, 255, 255, 0.6);
+        white-space: nowrap;
+    }
+    
+    .activity-content {
+        flex: 1;
+    }
+</style>
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    // Animate the workflow steps on load
+    const steps = document.querySelectorAll('.workflow-step');
+    
+    steps.forEach((step, index) => {
+        setTimeout(() => {
+            step.classList.add('fade-in');
+        }, index * 200);
+    });
+    
+    // Simulate activity log updates
+    const activityLog = document.getElementById('activity-log');
+    const activities = [
+        { time: '11:15:35', step: 3, message: 'Processing quantum dimension 1/3' },
+        { time: '11:15:42', step: 3, message: 'Processing quantum dimension 2/3' },
+        { time: '11:15:50', step: 3, message: 'Processing quantum dimension 3/3' }
+    ];
+    
+    let i = 0;
+    const activityTimer = setInterval(() => {
+        if (i >= activities.length) {
+            clearInterval(activityTimer);
+            return;
+        }
+        
+        const activity = activities[i];
+        const activityItem = document.createElement('div');
+        activityItem.className = 'activity-item';
+        activityItem.innerHTML = `
+            <div class="activity-timestamp">${activity.time}</div>
+            <div class="activity-content">
+                <span class="badge bg-info me-1">Step ${activity.step}</span>
+                ${activity.message}
+            </div>
+        `;
+        
+        activityLog.insertBefore(activityItem, activityLog.firstChild);
+        
+        // Apply fade-in effect
+        activityItem.style.opacity = '0';
+        setTimeout(() => {
+            activityItem.style.transition = 'opacity 0.5s ease';
+            activityItem.style.opacity = '1';
+        }, 10);
+        
+        i++;
+    }, 5000);
+    
+    // Add particle effects to the tetrahedron
+    const tetrahedron = document.querySelector('.tetrahedron');
+    
+    setInterval(() => {
+        const rect = tetrahedron.getBoundingClientRect();
+        const x = rect.left + rect.width / 2;
+        const y = rect.top + rect.height / 2;
+        
+        // Random position around the tetrahedron
+        const angle = Math.random() * Math.PI * 2;
+        const distance = 20 + Math.random() * 30;
+        const particleX = x + Math.cos(angle) * distance;
+        const particleY = y + Math.sin(angle) * distance;
+        
+        // Create particle
+        createParticle(particleX, particleY);
+    }, 300);
+    
+    function createParticle(x, y) {
+        const colors = ['#da4b86', '#6f42c1', '#0dcaf0'];
+        const color = colors[Math.floor(Math.random() * colors.length)];
+        
+        const particle = document.createElement('div');
+        particle.className = 'quantum-particle';
+        particle.style.left = x + 'px';
+        particle.style.top = y + 'px';
+        particle.style.color = color;
+        
+        document.body.appendChild(particle);
+        
+        // Remove after animation
+        setTimeout(() => {
+            particle.remove();
+        }, 1000);
+    }
+});
+</script>
+{% endblock %}

bridge.log

@@ -0,0 +1 @@
+./start_atlas_unified.sh: line 123: python: command not found

bridge.pid

@@ -0,0 +1 @@
+57095

bridge_server.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Atlas Unified Bridge Server
+This server connects all Atlas platform components together
+"""
+
+import os
+import sys
+import json
+import time
+import logging
+import requests
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import uvicorn
+from pydantic import BaseModel
+from typing import Dict, List, Any, Optional
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("bridge_server.log")
+    ]
+)
+logger = logging.getLogger("atlas_bridge")
+
+# Component endpoints
+OPENMANUS_ENDPOINT = "http://localhost:50505"
+CASIBASE_ENDPOINT = "http://localhost:7777"
+CYPHER_ENDPOINT = "http://localhost:5000"
+QUANTUMVISION_ENDPOINT = "http://localhost:8000"
+CONVERSATION_ENDPOINT = "http://localhost:8001"
+
+# Initialize FastAPI app
+app = FastAPI(title="Atlas Unified Bridge")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Health check endpoint
+@app.get("/health")
+async def health_check():
+    """Health check endpoint to verify if bridge server is running"""
+    status = {
+        "bridge": "operational",
+        "components": {
+            "openmanus": check_component_health(OPENMANUS_ENDPOINT),
+            "casibase": check_component_health(CASIBASE_ENDPOINT),
+            "cypher": check_component_health(CYPHER_ENDPOINT),
+            "quantumvision": check_component_health(QUANTUMVISION_ENDPOINT),
+            "conversation": check_component_health(CONVERSATION_ENDPOINT)
+        },
+        "timestamp": time.time()
+    }
+    return status
+
+def check_component_health(endpoint: str) -> str:
+    """Check if a component is operational"""
+    try:
+        response = requests.get(f"{endpoint}/health", timeout=3)
+        if response.status_code == 200:
+            return "operational"
+    except:
+        pass
+    return "unavailable"
+
+# Main entry point
+if __name__ == "__main__":
+    logger.info("Starting Atlas Unified Bridge Server")
+    uvicorn.run("bridge_server:app", host="0.0.0.0", port=8080, reload=True)

browser_automation.py

@@ -0,0 +1,221 @@
+"""
+Browser automation module for web scraping and analysis.
+This module enables the AI assistant to control a web browser,
+scrape content, and extract information from websites.
+"""
+
+import json
+import logging
+import re
+import urllib.parse
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from models import WebResource, Task, db
+
+logger = logging.getLogger(__name__)
+
+
+class BrowserAutomation:
+    """Class for handling browser automation and web scraping"""
+    
+    def __init__(self, user_agent=None, headers=None):
+        self.user_agent = user_agent or 'QuantumAI Assistant/1.0'
+        self.headers = headers or {
+            'User-Agent': self.user_agent,
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+        }
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        
+    def fetch_page(self, url, task_id=None):
+        """
+        Fetch a webpage and parse its content
+        
+        Args:
+            url (str): The URL to fetch
+            task_id (int, optional): Associated task ID
+            
+        Returns:
+            dict: Result containing status, parsed content, and metadata
+        """
+        try:
+            # Parse and normalize URL
+            parsed_url = urllib.parse.urlparse(url)
+            if not parsed_url.scheme:
+                url = 'https://' + url
+                
+            logger.info(f"Fetching URL: {url}")
+            response = self.session.get(url, timeout=15)
+            response.raise_for_status()
+            
+            # Parse with BeautifulSoup
+            soup = BeautifulSoup(response.text, 'html.parser')
+            title = soup.title.string if soup.title else "No title found"
+            
+            # Store or update the web resource
+            web_resource = self._store_web_resource(url, title, task_id)
+            
+            # Extract main content, remove scripts, styles, etc.
+            for script in soup(["script", "style", "meta", "noscript"]):
+                script.extract()
+                
+            # Get text content and normalize whitespace
+            text_content = soup.get_text(separator=' ')
+            text_content = re.sub(r'\s+', ' ', text_content).strip()
+            
+            return {
+                'status': 'success',
+                'url': url,
+                'title': title,
+                'content': text_content,
+                'html': response.text,
+                'web_resource_id': web_resource.id,
+                'timestamp': datetime.utcnow().isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"Error fetching URL {url}: {str(e)}")
+            return {
+                'status': 'error',
+                'url': url,
+                'error': str(e),
+                'timestamp': datetime.utcnow().isoformat()
+            }
+            
+    def _store_web_resource(self, url, title, task_id=None):
+        """Store or update web resource in the database"""
+        try:
+            web_resource = WebResource.query.filter_by(url=url).first()
+            
+            if not web_resource:
+                web_resource = WebResource(
+                    url=url,
+                    title=title,
+                    category='general',
+                    last_accessed=datetime.utcnow(),
+                )
+                if task_id:
+                    web_resource.task_id = task_id
+                db.session.add(web_resource)
+            else:
+                web_resource.last_accessed = datetime.utcnow()
+                web_resource.title = title
+                
+            db.session.commit()
+            return web_resource
+            
+        except Exception as e:
+            logger.error(f"Error storing web resource: {str(e)}")
+            db.session.rollback()
+            # Return a placeholder object if db operation fails
+            return WebResource(url=url, title=title)
+    
+    def extract_links(self, html):
+        """Extract all links from an HTML document"""
+        soup = BeautifulSoup(html, 'html.parser')
+        links = []
+        
+        for a_tag in soup.find_all('a', href=True):
+            href = a_tag['href']
+            text = a_tag.get_text(strip=True)
+            
+            if href.startswith('#') or href.startswith('javascript:'):
+                continue
+                
+            links.append({
+                'href': href,
+                'text': text[:100] if text else ""
+            })
+            
+        return links
+    
+    def extract_structured_data(self, html):
+        """Extract structured data (JSON-LD, microdata) from an HTML document"""
+        soup = BeautifulSoup(html, 'html.parser')
+        structured_data = []
+        
+        # Extract JSON-LD
+        for script in soup.find_all('script', type='application/ld+json'):
+            try:
+                data = json.loads(script.string)
+                structured_data.append({
+                    'type': 'json-ld',
+                    'data': data
+                })
+            except json.JSONDecodeError:
+                pass
+                
+        # TODO: Add microdata and RDFa extraction if needed
+        
+        return structured_data
+    
+    def analyze_page_content(self, content, url=None):
+        """Analyze page content to extract key information using NLP"""
+        # This will be enhanced with our quantum NLP process
+        # For now, just return a simple analysis
+        word_count = len(content.split())
+        sentences = re.split(r'[.!?]+', content)
+        sentence_count = len(sentences)
+        
+        return {
+            'word_count': word_count,
+            'sentence_count': sentence_count,
+            'average_sentence_length': word_count / max(1, sentence_count),
+            'url': url
+        }
+
+
+# Helper functions for browser automation tasks
+def create_scraping_task(url, title, description=None, scheduled_for=None):
+    """Create a new web scraping task"""
+    task = Task(
+        title=title,
+        description=description or f"Scrape content from {url}",
+        status='pending',
+        task_type='web_scrape',
+        scheduled_for=scheduled_for,
+        config={'url': url}
+    )
+    db.session.add(task)
+    db.session.commit()
+    return task
+
+
+def execute_scraping_task(task_id):
+    """Execute a web scraping task"""
+    task = Task.query.get(task_id)
+    if not task or task.task_type != 'web_scrape':
+        return {'status': 'error', 'message': 'Invalid task'}
+    
+    try:
+        task.status = 'in_progress'
+        db.session.commit()
+        
+        url = task.config.get('url')
+        browser = BrowserAutomation()
+        result = browser.fetch_page(url, task_id=task.id)
+        
+        if result['status'] == 'success':
+            # Also analyze the content
+            analysis = browser.analyze_page_content(result['content'], url)
+            result['analysis'] = analysis
+            
+            task.status = 'completed'
+            task.completed_at = datetime.utcnow()
+            task.result = result
+        else:
+            task.status = 'failed'
+            task.result = result
+            
+        db.session.commit()
+        return result
+        
+    except Exception as e:
+        logger.error(f"Error executing task {task_id}: {str(e)}")
+        task.status = 'failed'
+        task.result = {'error': str(e)}
+        db.session.commit()
+        return {'status': 'error', 'message': str(e)}

contextual_hints.css

@@ -0,0 +1,249 @@
+/* Contextual Hints System - With Quantum Styling
+-------------------------------------------------- */
+
+:root {
+    --hint-bg-color: rgba(30, 30, 35, 0.95);
+    --hint-border-color: rgba(111, 66, 193, 0.7);
+    --hint-text-color: rgba(255, 255, 255, 0.9);
+    --hint-shadow-color: rgba(218, 75, 134, 0.3);
+    --hint-icon-color: rgba(13, 202, 240, 0.9);
+    --hint-glow-color: rgba(111, 66, 193, 0.5);
+    --hint-btn-color: rgba(13, 202, 240, 0.8);
+    --hint-transition-time: 0.3s;
+}
+
+/* Main Hint Container */
+.contextual-hint {
+    position: absolute;
+    width: auto;
+    max-width: 300px;
+    min-width: 230px;
+    padding: 15px;
+    background: var(--hint-bg-color);
+    color: var(--hint-text-color);
+    border-radius: 8px;
+    border: 1px solid var(--hint-border-color);
+    box-shadow: 0 3px 15px var(--hint-shadow-color), 
+                0 0 8px var(--hint-glow-color);
+    z-index: 9999;
+    opacity: 0;
+    transform: translateY(15px) scale(0.95);
+    transition: opacity var(--hint-transition-time) ease, 
+                transform var(--hint-transition-time) ease;
+    backdrop-filter: blur(8px);
+    pointer-events: none;
+}
+
+/* Hint that is currently shown */
+.contextual-hint.active {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+    pointer-events: auto;
+}
+
+/* Hint Title */
+.contextual-hint-title {
+    display: flex;
+    align-items: center;
+    margin-bottom: 10px;
+    padding-bottom: 8px;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.contextual-hint-title i {
+    color: var(--hint-icon-color);
+    margin-right: 8px;
+    font-size: 1.1rem;
+}
+
+.contextual-hint-title h5 {
+    margin: 0;
+    font-size: 1rem;
+    font-weight: 600;
+    color: var(--hint-text-color);
+}
+
+/* Hint Content */
+.contextual-hint-content {
+    font-size: 0.95rem;
+    line-height: 1.4;
+    margin-bottom: 15px;
+}
+
+/* Hint Actions */
+.contextual-hint-actions {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.hint-button {
+    background: transparent;
+    color: var(--hint-btn-color);
+    border: 1px solid var(--hint-btn-color);
+    padding: 5px 10px;
+    border-radius: 4px;
+    font-size: 0.8rem;
+    cursor: pointer;
+    transition: all var(--hint-transition-time) ease;
+}
+
+.hint-button:hover {
+    background: var(--hint-btn-color);
+    color: #000;
+}
+
+.hint-button-primary {
+    background: var(--hint-btn-color);
+    color: #000;
+}
+
+.hint-button-primary:hover {
+    background: transparent;
+    color: var(--hint-btn-color);
+}
+
+.hint-dont-show {
+    font-size: 0.8rem;
+    color: rgba(255, 255, 255, 0.5);
+    cursor: pointer;
+    transition: color var(--hint-transition-time) ease;
+}
+
+.hint-dont-show:hover {
+    color: var(--hint-text-color);
+}
+
+/* Hint Arrow */
+.contextual-hint::before {
+    content: '';
+    position: absolute;
+    width: 10px;
+    height: 10px;
+    background: var(--hint-bg-color);
+    border: 1px solid var(--hint-border-color);
+    transform: rotate(45deg);
+}
+
+/* Position variations */
+.contextual-hint.position-top::before {
+    bottom: -6px;
+    border-top: none;
+    border-left: none;
+}
+
+.contextual-hint.position-bottom::before {
+    top: -6px;
+    border-bottom: none;
+    border-right: none;
+}
+
+.contextual-hint.position-left::before {
+    right: -6px;
+    border-left: none;
+    border-bottom: none;
+}
+
+.contextual-hint.position-right::before {
+    left: -6px;
+    border-right: none;
+    border-top: none;
+}
+
+/* Hover target styling */
+.hint-target {
+    position: relative;
+}
+
+.hint-target::after {
+    content: '';
+    position: absolute;
+    top: -3px;
+    right: -3px;
+    bottom: -3px;
+    left: -3px;
+    border: 2px dashed transparent;
+    border-radius: 5px;
+    transition: border-color var(--hint-transition-time) ease;
+    pointer-events: none;
+}
+
+.hint-target.hint-highlight::after {
+    border-color: var(--hint-icon-color);
+}
+
+/* Pulse animation for important hints */
+@keyframes hint-pulse {
+    0% {
+        box-shadow: 0 0 0 0 rgba(13, 202, 240, 0.4);
+    }
+    70% {
+        box-shadow: 0 0 0 10px rgba(13, 202, 240, 0);
+    }
+    100% {
+        box-shadow: 0 0 0 0 rgba(13, 202, 240, 0);
+    }
+}
+
+.contextual-hint.important {
+    animation: hint-pulse 2s infinite;
+}
+
+/* LED tracer on hints */
+.contextual-hint .led-tracer {
+    position: absolute;
+    height: 2px;
+    background: linear-gradient(90deg, 
+                transparent, 
+                rgba(218, 75, 134, 0.7), 
+                rgba(13, 202, 240, 0.7),
+                transparent);
+    width: 100%;
+    left: 0;
+    bottom: 0;
+    animation: led-trace 2s infinite linear;
+}
+
+@keyframes led-trace {
+    0% {
+        transform: translateX(-100%);
+    }
+    100% {
+        transform: translateX(100%);
+    }
+}
+
+/* Quantum particle effect for hints */
+.contextual-hint.has-particles {
+    overflow: hidden;
+}
+
+.hint-particles {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    pointer-events: none;
+}
+
+.hint-particle {
+    position: absolute;
+    width: 3px;
+    height: 3px;
+    background: var(--hint-icon-color);
+    border-radius: 50%;
+    opacity: 0.5;
+    animation: float-particle 3s infinite ease-in-out;
+}
+
+@keyframes float-particle {
+    0%, 100% {
+        transform: translateY(0) translateX(0);
+        opacity: 0.2;
+    }
+    50% {
+        transform: translateY(-15px) translateX(5px);
+        opacity: 0.5;
+    }
+}

contextual_hints.js

@@ -0,0 +1,534 @@
+/**
+ * Contextual Hint System
+ * 
+ * A subtle, non-intrusive tooltip system providing just-in-time guidance and learning
+ * for the Quantum NLP Framework. This system detects when a user might need help
+ * understanding a feature and provides relevant information without disrupting workflow.
+ */
+
+class ContextualHintSystem {
+    constructor() {
+        this.hints = {};
+        this.activeHint = null;
+        this.hintContainer = null;
+        this.shownHints = [];
+        
+        this.initialize();
+    }
+    
+    /**
+     * Initialize the hint system
+     */
+    initialize() {
+        // Load previously shown hints
+        this.loadShownHints();
+        
+        // Register predefined hints
+        this.registerPredefinedHints();
+        
+        // Initialize scroll listener for detecting visible elements
+        this.initScrollListener();
+        
+        // Create container for hints if it doesn't exist
+        if (!document.getElementById('contextual-hints-container')) {
+            this.hintContainer = document.createElement('div');
+            this.hintContainer.id = 'contextual-hints-container';
+            document.body.appendChild(this.hintContainer);
+        } else {
+            this.hintContainer = document.getElementById('contextual-hints-container');
+        }
+        
+        // Listen for ESC key to dismiss hints
+        document.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape' && this.activeHint) {
+                this.dismissActiveHint();
+            }
+        });
+        
+        // Listen for clicks outside hint to dismiss
+        document.addEventListener('click', (e) => {
+            if (this.activeHint && !this.activeHint.contains(e.target)) {
+                // Check if the click was not on the target element either
+                const activeHintId = this.activeHint.getAttribute('data-hint-id');
+                const targetElement = document.querySelector(`[data-hint="${activeHintId}"]`);
+                
+                if (!targetElement || !targetElement.contains(e.target)) {
+                    this.dismissActiveHint();
+                }
+            }
+        });
+    }
+    
+    /**
+     * Register a hint with the system
+     * @param {string} id - Unique identifier for the hint
+     * @param {object} options - Hint options
+     */
+    registerHint(id, options) {
+        this.hints[id] = {
+            title: options.title || 'Hint',
+            content: options.content || '',
+            position: options.position || 'bottom',
+            important: options.important || false,
+            maxShows: options.maxShows || 3,
+            icon: options.icon || 'fas fa-lightbulb',
+            selector: options.selector || null,
+            particles: options.particles || false,
+            trigger: options.trigger || 'auto', // auto, manual, hover
+            buttonText: options.buttonText || 'Got it',
+            onShown: options.onShown || null,
+            onDismiss: options.onDismiss || null
+        };
+        
+        // Attach triggers for this hint if necessary
+        if (options.selector) {
+            this.attachHintTrigger(id);
+        }
+    }
+    
+    /**
+     * Register all predefined hints for the application
+     */
+    registerPredefinedHints() {
+        // Quantum Dimensions hint
+        this.registerHint('quantum-dimensions', {
+            title: 'Quantum Dimensions',
+            content: 'Increase dimensions for deeper, multi-layered analysis of your text. Higher dimensions explore more interconnected thought paths.',
+            position: 'top',
+            selector: '#depth',
+            icon: 'fas fa-layer-group',
+            trigger: 'hover'
+        });
+        
+        // OpenAI integration hint
+        this.registerHint('openai-integration', {
+            title: 'AI Enhancement',
+            content: 'Enable this to use OpenAI for generating human-like responses based on quantum analysis results. Requires API key in settings.',
+            position: 'right',
+            selector: '#use_ai',
+            icon: 'fas fa-robot',
+            important: !document.body.classList.contains('has-openai-key')
+        });
+        
+        // Analyze button hint
+        this.registerHint('analyze-button', {
+            title: 'Quantum Analysis',
+            content: 'Start the quantum-inspired recursive thinking process to analyze your text through multiple dimensions.',
+            position: 'top',
+            selector: '#analyze-btn',
+            particles: true,
+            maxShows: 2
+        });
+        
+        // Quantum Score hint
+        this.registerHint('quantum-score', {
+            title: 'Quantum Score',
+            content: 'This score represents the confidence and coherence of the quantum analysis across all dimensions.',
+            position: 'left',
+            selector: '.quantum-score-visualization',
+            icon: 'fas fa-chart-line',
+            trigger: 'manual'
+        });
+        
+        // Zap Integrations hint
+        this.registerHint('zap-integrations', {
+            title: 'ZAP Integrations',
+            content: 'Connect the Quantum Framework to other services and applications to extend its capabilities.',
+            position: 'bottom',
+            selector: 'a[href="/zap-integrations"]',
+            icon: 'fas fa-bolt',
+            trigger: 'hover'
+        });
+        
+        // Automation Workflow hint
+        this.registerHint('automation-workflow', {
+            title: 'Automation Workflow',
+            content: 'View and configure automated tasks and workflows using the quantum framework.',
+            position: 'bottom',
+            selector: 'a[href="/automation-workflow"]',
+            icon: 'fas fa-cogs',
+            trigger: 'hover'
+        });
+        
+        // Named Entities hint
+        this.registerHint('named-entities', {
+            title: 'Named Entities',
+            content: 'These are specific objects identified in your text like people, organizations, locations, and more.',
+            position: 'right',
+            selector: '.quantum-entity-item',
+            icon: 'fas fa-fingerprint',
+            trigger: 'manual'
+        });
+    }
+    
+    /**
+     * Attach a trigger to show a hint when interacting with an element
+     * @param {string} hintId - The ID of the hint to trigger
+     */
+    attachHintTrigger(hintId) {
+        const hint = this.hints[hintId];
+        if (!hint || !hint.selector) return;
+        
+        // Find all matching elements
+        const elements = document.querySelectorAll(hint.selector);
+        if (elements.length === 0) return;
+        
+        elements.forEach(element => {
+            // Add data attribute to mark the element as a hint target
+            element.setAttribute('data-hint', hintId);
+            element.classList.add('hint-target');
+            
+            // Attach event listeners based on trigger type
+            if (hint.trigger === 'hover') {
+                element.addEventListener('mouseenter', () => {
+                    this.considerShowingHint(hintId, element);
+                    element.classList.add('hint-highlight');
+                });
+                
+                element.addEventListener('mouseleave', () => {
+                    element.classList.remove('hint-highlight');
+                });
+            } else if (hint.trigger === 'auto') {
+                // For auto triggers, we'll check visibility in the scroll listener
+                // and show the hint when appropriate
+            }
+            
+            // For manual triggers, the hint will be shown programmatically
+        });
+    }
+    
+    /**
+     * Consider whether to show a hint based on whether it's been shown before
+     * @param {string} hintId - The ID of the hint to consider showing
+     * @param {Element} target - The target element for the hint
+     */
+    considerShowingHint(hintId, target) {
+        // Don't show if another hint is active
+        if (this.activeHint) return;
+        
+        const hint = this.hints[hintId];
+        if (!hint) return;
+        
+        // Count how many times this hint has been shown
+        const timesShown = this.shownHints.filter(id => id === hintId).length;
+        
+        // If it's been shown fewer times than the max, show it
+        if (timesShown < hint.maxShows) {
+            this.showHint(hintId, target);
+        }
+    }
+    
+    /**
+     * Show a hint for a specific element
+     * @param {string} hintId - The ID of the hint to show
+     * @param {Element} targetElement - The element to attach the hint to
+     */
+    showHint(hintId, targetElement) {
+        const hint = this.hints[hintId];
+        if (!hint) return;
+        
+        // Dismiss any active hint
+        this.dismissActiveHint();
+        
+        // Create the hint element
+        const hintElement = document.createElement('div');
+        hintElement.className = `contextual-hint position-${hint.position}`;
+        hintElement.setAttribute('data-hint-id', hintId);
+        
+        if (hint.important) {
+            hintElement.classList.add('important');
+        }
+        
+        if (hint.particles) {
+            hintElement.classList.add('has-particles');
+        }
+        
+        // Add LED tracer effect
+        const ledTracer = document.createElement('div');
+        ledTracer.className = 'led-tracer';
+        hintElement.appendChild(ledTracer);
+        
+        // Add content
+        hintElement.innerHTML += `
+            <div class="contextual-hint-title">
+                <i class="${hint.icon}"></i>
+                <h5>${hint.title}</h5>
+            </div>
+            <div class="contextual-hint-content">${hint.content}</div>
+            <div class="contextual-hint-actions">
+                <button class="hint-button hint-button-primary">${hint.buttonText}</button>
+                <span class="hint-dont-show">Don't show again</span>
+            </div>
+        `;
+        
+        // Add particles if enabled
+        if (hint.particles) {
+            const particlesContainer = document.createElement('div');
+            particlesContainer.className = 'hint-particles';
+            
+            // Add several particles
+            for (let i = 0; i < 8; i++) {
+                const particle = document.createElement('div');
+                particle.className = 'hint-particle';
+                particle.style.top = `${Math.random() * 100}%`;
+                particle.style.left = `${Math.random() * 100}%`;
+                particle.style.animationDelay = `${Math.random() * 2}s`;
+                particlesContainer.appendChild(particle);
+            }
+            
+            hintElement.appendChild(particlesContainer);
+        }
+        
+        // Add to DOM
+        this.hintContainer.appendChild(hintElement);
+        
+        // Position relative to target
+        this.positionHint(hintElement, targetElement, hint.position);
+        
+        // Show with animation
+        setTimeout(() => {
+            hintElement.classList.add('active');
+        }, 10);
+        
+        // Set as active hint
+        this.activeHint = hintElement;
+        
+        // Record that this hint has been shown
+        this.markHintAsShown(hintId);
+        
+        // Attach event listeners to buttons
+        const dismissButton = hintElement.querySelector('.hint-button');
+        dismissButton.addEventListener('click', () => {
+            this.dismissActiveHint();
+            
+            // Run onDismiss callback if provided
+            if (typeof hint.onDismiss === 'function') {
+                hint.onDismiss();
+            }
+        });
+        
+        const dontShowAgain = hintElement.querySelector('.hint-dont-show');
+        dontShowAgain.addEventListener('click', () => {
+            // Add to shown hints enough times to reach maxShows
+            for (let i = timesShown; i < hint.maxShows; i++) {
+                this.markHintAsShown(hintId);
+            }
+            
+            this.dismissActiveHint();
+        });
+        
+        // Call onShown callback if provided
+        if (typeof hint.onShown === 'function') {
+            hint.onShown();
+        }
+    }
+    
+    /**
+     * Position a hint element relative to its target
+     * @param {Element} hintElement - The hint element
+     * @param {Element} targetElement - The target element
+     * @param {string} position - The position (top, bottom, left, right)
+     */
+    positionHint(hintElement, targetElement, position) {
+        if (!targetElement) return;
+        
+        const targetRect = targetElement.getBoundingClientRect();
+        const hintRect = hintElement.getBoundingClientRect();
+        
+        let top, left;
+        
+        switch (position) {
+            case 'top':
+                top = targetRect.top - hintRect.height - 15;
+                left = targetRect.left + (targetRect.width / 2) - (hintRect.width / 2);
+                hintElement.querySelector('::before').style.left = '50%';
+                break;
+                
+            case 'bottom':
+                top = targetRect.bottom + 15;
+                left = targetRect.left + (targetRect.width / 2) - (hintRect.width / 2);
+                hintElement.querySelector('::before').style.left = '50%';
+                break;
+                
+            case 'left':
+                top = targetRect.top + (targetRect.height / 2) - (hintRect.height / 2);
+                left = targetRect.left - hintRect.width - 15;
+                hintElement.querySelector('::before').style.top = '50%';
+                break;
+                
+            case 'right':
+                top = targetRect.top + (targetRect.height / 2) - (hintRect.height / 2);
+                left = targetRect.right + 15;
+                hintElement.querySelector('::before').style.top = '50%';
+                break;
+        }
+        
+        // Adjust if the hint would be off-screen
+        const viewportWidth = window.innerWidth;
+        const viewportHeight = window.innerHeight;
+        
+        if (left < 10) left = 10;
+        if (left + hintRect.width > viewportWidth - 10) {
+            left = viewportWidth - hintRect.width - 10;
+        }
+        
+        if (top < 10) top = 10;
+        if (top + hintRect.height > viewportHeight - 10) {
+            top = viewportHeight - hintRect.height - 10;
+        }
+        
+        // Set the position
+        hintElement.style.top = `${top}px`;
+        hintElement.style.left = `${left}px`;
+    }
+    
+    /**
+     * Dismiss the currently active hint
+     */
+    dismissActiveHint() {
+        if (this.activeHint) {
+            this.activeHint.classList.remove('active');
+            
+            // Remove from DOM after animation completes
+            setTimeout(() => {
+                if (this.activeHint && this.activeHint.parentNode) {
+                    this.activeHint.parentNode.removeChild(this.activeHint);
+                }
+                this.activeHint = null;
+            }, 300);
+        }
+    }
+    
+    /**
+     * Mark a hint as having been shown
+     * @param {string} hintId - The ID of the hint
+     */
+    markHintAsShown(hintId) {
+        this.shownHints.push(hintId);
+        this.saveShownHints();
+    }
+    
+    /**
+     * Check if a hint has been shown the maximum number of times
+     * @param {string} hintId - The ID of the hint
+     * @returns {boolean} Whether the hint has been shown max times
+     */
+    hasHintBeenShown(hintId) {
+        const hint = this.hints[hintId];
+        if (!hint) return true;
+        
+        const timesShown = this.shownHints.filter(id => id === hintId).length;
+        return timesShown >= hint.maxShows;
+    }
+    
+    /**
+     * Load the list of shown hints from localStorage
+     */
+    loadShownHints() {
+        const savedHints = localStorage.getItem('shownHints');
+        if (savedHints) {
+            try {
+                this.shownHints = JSON.parse(savedHints);
+            } catch (e) {
+                this.shownHints = [];
+            }
+        }
+    }
+    
+    /**
+     * Save the list of shown hints to localStorage
+     */
+    saveShownHints() {
+        localStorage.setItem('shownHints', JSON.stringify(this.shownHints));
+    }
+    
+    /**
+     * Reset all shown hints so they'll be shown again
+     */
+    resetShownHints() {
+        this.shownHints = [];
+        localStorage.removeItem('shownHints');
+    }
+    
+    /**
+     * Initialize the scroll listener for detecting visible elements
+     */
+    initScrollListener() {
+        // Check initially
+        this.checkVisibleElementsForHints();
+        
+        // Check on scroll
+        window.addEventListener('scroll', () => {
+            this.checkVisibleElementsForHints();
+        });
+        
+        // Check on resize
+        window.addEventListener('resize', () => {
+            this.checkVisibleElementsForHints();
+        });
+        
+        // Check after a short delay (DOM may still be loading)
+        setTimeout(() => {
+            this.checkVisibleElementsForHints();
+        }, 1000);
+    }
+    
+    /**
+     * Check for elements with auto hints that are visible in the viewport
+     */
+    checkVisibleElementsForHints() {
+        // Don't check if a hint is already active
+        if (this.activeHint) return;
+        
+        // Look for elements with auto hints that are in the viewport
+        for (const hintId in this.hints) {
+            const hint = this.hints[hintId];
+            
+            if (hint.trigger !== 'auto') continue;
+            if (this.hasHintBeenShown(hintId)) continue;
+            
+            const elements = document.querySelectorAll(`[data-hint="${hintId}"]`);
+            
+            for (const element of elements) {
+                if (this.isElementInViewport(element)) {
+                    this.considerShowingHint(hintId, element);
+                    break;
+                }
+            }
+        }
+    }
+    
+    /**
+     * Check if an element is in the viewport
+     * @param {Element} el - The element to check
+     * @returns {boolean} Whether the element is in the viewport
+     */
+    isElementInViewport(el) {
+        const rect = el.getBoundingClientRect();
+        
+        return (
+            rect.top >= 0 &&
+            rect.left >= 0 &&
+            rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
+            rect.right <= (window.innerWidth || document.documentElement.clientWidth)
+        );
+    }
+}
+
+// Initialize the hint system when the DOM is ready
+document.addEventListener('DOMContentLoaded', () => {
+    window.contextualHintSystem = new ContextualHintSystem();
+    
+    // Manually show hints for elements that may not be detected automatically
+    setTimeout(() => {
+        const quantumScoreElements = document.querySelectorAll('.quantum-score-visualization');
+        if (quantumScoreElements.length > 0) {
+            window.contextualHintSystem.considerShowingHint('quantum-score', quantumScoreElements[0]);
+        }
+        
+        const entityItems = document.querySelectorAll('.quantum-entity-item');
+        if (entityItems.length > 0) {
+            window.contextualHintSystem.considerShowingHint('named-entities', entityItems[0]);
+        }
+    }, 2000);
+});

fix_openmanus.py

@@ -0,0 +1,556 @@
+#!/usr/bin/env python3
+"""
+OpenManus Integration Fixer
+
+This script fixes common issues with OpenManus installations and ensures 
+proper integration with Casibase and other Atlas components.
+"""
+
+import os
+import sys
+import json
+import shutil
+import subprocess
+import importlib
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Any
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler('openmanus_fix.log')
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+class OpenManusFixer:
+    """Utility class to fix OpenManus integration issues."""
+    
+    def __init__(self, openmanus_path: Optional[str] = None):
+        """Initialize the fixer with the path to OpenManus."""
+        if openmanus_path:
+            self.openmanus_path = Path(openmanus_path)
+        else:
+            # Try to find OpenManus in the current directory or parent
+            current_dir = Path.cwd()
+            if (current_dir / "app").exists() and (current_dir / "requirements.txt").exists():
+                self.openmanus_path = current_dir
+            else:
+                self.openmanus_path = Path(os.path.expanduser("~/OpenManus"))
+        
+        logger.info(f"OpenManus path: {self.openmanus_path}")
+        
+        if not self.openmanus_path.exists():
+            raise FileNotFoundError(f"OpenManus directory not found at {self.openmanus_path}")
+    
+    def fix_requirements(self) -> None:
+        """Fix the requirements.txt file to ensure all dependencies are properly listed."""
+        req_file = self.openmanus_path / "requirements.txt"
+        
+        if not req_file.exists():
+            logger.error(f"Requirements file not found at {req_file}")
+            return
+        
+        logger.info("Fixing requirements.txt...")
+        
+        # Read existing requirements
+        with open(req_file, "r") as f:
+            requirements = f.readlines()
+        
+        # Clean requirements by removing comments and invalid entries
+        cleaned_requirements = []
+        for req in requirements:
+            req = req.strip()
+            
+            # Skip empty lines and comments
+            if not req or req.startswith('#'):
+                cleaned_requirements.append(req)
+                continue
+            
+            # Fix any malformed requirements
+            if ' #' in req:
+                req = req.split(' #')[0].strip()
+            
+            cleaned_requirements.append(req)
+        
+        # Add missing dependencies
+        required_deps = {
+            "flask": "flask~=2.3.3",
+            "flask-cors": "flask-cors~=4.0.0",
+            "requests": "requests~=2.31.0",
+            "pydantic": "pydantic~=2.10.6",
+            "openai": "openai~=1.66.3",
+            "fastapi": "fastapi~=0.115.11",
+            "uvicorn": "uvicorn~=0.34.0",
+            "httpx": "httpx>=0.27.0",
+            "tiktoken": "tiktoken~=0.9.0"
+        }
+        
+        # Check for each required dependency
+        for dep_name, dep_req in required_deps.items():
+            found = False
+            for i, req in enumerate(cleaned_requirements):
+                if req.startswith(f"{dep_name}"):
+                    found = True
+                    # Update the dependency if needed
+                    cleaned_requirements[i] = dep_req
+                    break
+            
+            if not found:
+                cleaned_requirements.append(dep_req)
+        
+        # Write back the fixed requirements
+        with open(req_file, "w") as f:
+            f.write("\n".join(cleaned_requirements) + "\n")
+        
+        logger.info("Requirements file fixed")
+    
+    def install_dependencies(self) -> None:
+        """Install or upgrade required dependencies."""
+        logger.info("Installing/upgrading dependencies...")
+        
+        try:
+            subprocess.run([
+                sys.executable, "-m", "pip", "install", "-r", 
+                str(self.openmanus_path / "requirements.txt"),
+                "--upgrade"
+            ], check=True)
+            logger.info("Dependencies installed successfully")
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to install dependencies: {e}")
+    
+    def ensure_casibase_connector(self) -> None:
+        """Ensure that the Casibase connector exists and is properly configured."""
+        connector_path = self.openmanus_path / "app" / "casibase_connector.py"
+        
+        if not connector_path.exists():
+            logger.info("Creating Casibase connector...")
+            
+            # Check if the directory exists
+            connector_path.parent.mkdir(exist_ok=True)
+            
+            # Create the connector file
+            self.create_casibase_connector(connector_path)
+        else:
+            logger.info("Updating existing Casibase connector...")
+            self.create_casibase_connector(connector_path)
+        
+        logger.info("Casibase connector updated")
+    
+    def create_casibase_connector(self, path: Path) -> None:
+        """Create or update the Casibase connector file."""
+        connector_code = """
+\"\"\"
+Casibase Connector for OpenManus
+This module provides integration with Casibase for document storage, retrieval, and querying.
+\"\"\"
+
+import os
+import json
+import requests
+from typing import Dict, List, Optional, Union, Any
+import logging
+from urllib.parse import urljoin
+
+# Import from current package if possible, otherwise create placeholders
+try:
+    from .exceptions import CasibaseConnectionError
+    from .config import get_config
+    from .logger import get_logger
+    
+    logger = get_logger(__name__)
+except ImportError:
+    # Create minimal implementations if the imports fail
+    class CasibaseConnectionError(Exception):
+        \"\"\"Exception raised for Casibase connection errors.\"\"\"
+        pass
+    
+    def get_config():
+        \"\"\"Get configuration values.\"\"\"
+        return {}
+    
+    # Set up basic logger
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)
+
+class CasibaseConnector:
+    \"\"\"
+    Connector for integrating with Casibase services.
+    \"\"\"
+    
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        store_name: Optional[str] = None,
+        timeout: int = 30
+    ):
+        \"\"\"
+        Initialize the Casibase connector.
+        
+        Args:
+            base_url: Base URL for the Casibase API
+            api_key: API key for authentication
+            store_name: Default store name to use
+            timeout: Request timeout in seconds
+        \"\"\"
+        config = get_config()
+        
+        self.base_url = base_url or config.get("CASIBASE_URL", "http://localhost:7001")
+        self.base_url = self.base_url.rstrip('/')  # Remove trailing slash if present
+        
+        self.api_key = api_key or config.get("CASIBASE_API_KEY", "")
+        self.store_name = store_name or config.get("CASIBASE_STORE", "default")
+        self.timeout = timeout
+        
+        self.headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        }
+        
+        if self.api_key:
+            self.headers["Authorization"] = f"Bearer {self.api_key}"
+        
+        logger.info(f"Initialized Casibase connector with base_url: {self.base_url}")
+    
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        \"\"\"
+        Make a request to the Casibase API.
+        
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            endpoint: API endpoint
+            data: Request data
+            files: Files to upload
+            params: Query parameters
+            
+        Returns:
+            Response data as dictionary
+            
+        Raises:
+            CasibaseConnectionError: If the request fails
+        \"\"\"
+        url = urljoin(self.base_url, endpoint)
+        
+        # If sending files, don't include Content-Type header
+        request_headers = self.headers.copy()
+        if files:
+            request_headers.pop("Content-Type", None)
+        
+        try:
+            if method.upper() == "GET":
+                response = requests.get(
+                    url,
+                    params=params,
+                    headers=request_headers,
+                    timeout=self.timeout
+                )
+            elif method.upper() == "POST":
+                if files:
+                    # Multipart form data for file uploads
+                    response = requests.post(
+                        url,
+                        data=data,  # Form data
+                        files=files,
+                        headers=request_headers,
+                        timeout=self.timeout
+                    )
+                else:
+                    # JSON data
+                    response = requests.post(
+                        url,
+                        json=data,
+                        params=params,
+                        headers=request_headers,
+                        timeout=self.timeout
+                    )
+            else:
+                raise CasibaseConnectionError(f"Unsupported HTTP method: {method}")
+            
+            # Check for errors
+            if response.status_code >= 400:
+                error_msg = f"Casibase API error: {response.status_code} - {response.text}"
+                logger.error(error_msg)
+                raise CasibaseConnectionError(error_msg)
+            
+            # Return JSON response
+            if response.content:
+                return response.json()
+            else:
+                return {"status": "success"}
+                
+        except requests.RequestException as e:
+            error_msg = f"Casibase API request failed: {str(e)}"
+            logger.error(error_msg)
+            raise CasibaseConnectionError(error_msg) from e
+    
+    def query(
+        self,
+        query_text: str,
+        store_name: Optional[str] = None,
+        model_name: Optional[str] = None,
+        top_k: int = 5,
+        system_prompt: Optional[str] = None
+    ) -> Dict[str, Any]:
+        \"\"\"
+        Query Casibase with the given text.
+        
+        Args:
+            query_text: Query text
+            store_name: Store name to query (defaults to instance store_name)
+            model_name: Model name to use for the query
+            top_k: Number of documents to retrieve
+            system_prompt: Optional system prompt to include
+            
+        Returns:
+            Query response
+        \"\"\"
+        store = store_name or self.store_name
+        
+        payload = {
+            "question": query_text,
+            "store": store,
+            "topK": top_k
+        }
+        
+        if model_name:
+            payload["modelName"] = model_name
+            
+        if system_prompt:
+            payload["systemPrompt"] = system_prompt
+        
+        logger.debug(f"Querying Casibase: {payload}")
+        return self._make_request("POST", "/api/query", data=payload)
+    
+    def upload_file(
+        self,
+        file_path: str,
+        store_name: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        \"\"\"
+        Upload a file to Casibase.
+        
+        Args:
+            file_path: Path to the file
+            store_name: Store name to upload to (defaults to instance store_name)
+            metadata: Additional metadata to associate with the file
+            
+        Returns:
+            Upload response
+        \"\"\"
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+        
+        store = store_name or self.store_name
+        metadata = metadata or {}
+        
+        with open(file_path, "rb") as f:
+            files = {"file": (os.path.basename(file_path), f)}
+            data = {"store": store}
+            
+            if metadata:
+                data["metadata"] = json.dumps(metadata)
+            
+            logger.debug(f"Uploading file to Casibase: {file_path} to store {store}")
+            return self._make_request("POST", "/api/upload-file", data=data, files=files)
+    
+    def get_stores(self) -> List[Dict[str, Any]]:
+        \"\"\"
+        Get available Casibase stores.
+        
+        Returns:
+            List of stores
+        \"\"\"
+        response = self._make_request("GET", "/api/get-stores")
+        return response.get("data", [])
+    
+    def search_similar(
+        self,
+        query_text: str,
+        store_name: Optional[str] = None,
+        limit: int = 5
+    ) -> List[Dict[str, Any]]:
+        \"\"\"
+        Search for similar documents in Casibase.
+        
+        Args:
+            query_text: Text to search for
+            store_name: Store to search in (defaults to instance store_name)
+            limit: Maximum number of results
+            
+        Returns:
+            List of similar documents
+        \"\"\"
+        store = store_name or self.store_name
+        
+        payload = {
+            "query": query_text,
+            "store": store,
+            "limit": limit
+        }
+        
+        logger.debug(f"Searching similar documents in Casibase: {payload}")
+        response = self._make_request("POST", "/api/search", data=payload)
+        return response.get("data", [])
+    
+    def get_health(self) -> Dict[str, Any]:
+        \"\"\"
+        Check if the Casibase service is healthy.
+        
+        Returns:
+            Health status
+        \"\"\"
+        try:
+            return self._make_request("GET", "/api/health-check")
+        except CasibaseConnectionError:
+            return {"status": "error", "message": "Casibase service is unreachable"}
+"""
+        
+        with open(path, "w") as f:
+            f.write(connector_code.lstrip())
+    
+    def update_api_server(self) -> None:
+        """Update the API server to include Casibase integration."""
+        api_server_path = self.openmanus_path / "app" / "api_server.py"
+        
+        if not api_server_path.exists():
+            logger.error(f"API server file not found at {api_server_path}")
+            return
+        
+        logger.info("Checking API server for Casibase integration...")
+        
+        with open(api_server_path, "r") as f:
+            content = f.read()
+        
+        # Check if Casibase is already integrated
+        if "CasibaseConnector" in content and "casibase_connector" in content:
+            logger.info("Casibase already integrated in API server")
+            return
+        
+        # Add imports
+        if "import argparse" in content:
+            content = content.replace(
+                "import argparse", 
+                "import argparse\nfrom .casibase_connector import CasibaseConnector"
+            )
+        
+        # Add endpoint for Casibase bridge
+        if "def create_app():" in content:
+            casibase_routes = """
+    # Casibase integration routes
+    @app.route('/api/casibase/health', methods=['GET'])
+    def casibase_health():
+        try:
+            casibase = CasibaseConnector()
+            health_status = casibase.get_health()
+            return jsonify(health_status)
+        except Exception as e:
+            return jsonify({"status": "error", "message": str(e)}), 500
+    
+    @app.route('/api/casibase/query', methods=['POST'])
+    def casibase_query():
+        try:
+            data = request.json
+            query_text = data.get('query_text')
+            store_name = data.get('store_name')
+            model_name = data.get('model_name')
+            
+            if not query_text:
+                return jsonify({"status": "error", "message": "query_text is required"}), 400
+            
+            casibase = CasibaseConnector()
+            result = casibase.query(
+                query_text=query_text,
+                store_name=store_name,
+                model_name=model_name
+            )
+            
+            return jsonify(result)
+        except Exception as e:
+            return jsonify({"status": "error", "message": str(e)}), 500
+    
+    @app.route('/api/casibase/search', methods=['POST'])
+    def casibase_search():
+        try:
+            data = request.json
+            query_text = data.get('query_text')
+            store_name = data.get('store_name')
+            limit = data.get('limit', 5)
+            
+            if not query_text:
+                return jsonify({"status": "error", "message": "query_text is required"}), 400
+            
+            casibase = CasibaseConnector()
+            result = casibase.search_similar(
+                query_text=query_text,
+                store_name=store_name,
+                limit=limit
+            )
+            
+            return jsonify({"status": "success", "data": result})
+        except Exception as e:
+            return jsonify({"status": "error", "message": str(e)}), 500
+"""
+            
+            # Insert the Casibase routes before the return statement
+            if "return app" in content:
+                content = content.replace(
+                    "return app", 
+                    f"{casibase_routes}\n    return app"
+                )
+        
+        # Add imports for Flask if needed
+        if "from flask import " in content:
+            if "jsonify" not in content:
+                content = content.replace(
+                    "from flask import ", 
+                    "from flask import jsonify, "
+                )
+            if "request" not in content:
+                content = content.replace(
+                    "from flask import ", 
+                    "from flask import request, "
+                )
+        
+        # Write back the updated content
+        with open(api_server_path, "w") as f:
+            f.write(content)
+        
+        logger.info("API server updated with Casibase integration")
+    
+    def run_fixes(self) -> None:
+        """Run all fixes."""
+        logger.info("Starting OpenManus fixes...")
+        
+        self.fix_requirements()
+        self.install_dependencies()
+        self.ensure_casibase_connector()
+        self.update_api_server()
+        
+        logger.info("OpenManus fixes completed successfully")
+
+def main():
+    """Main entry point."""
+    try:
+        fixer = OpenManusFixer()
+        fixer.run_fixes()
+        return 0
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

fix_unified_bridge.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+Atlas Intelligence Unified Bridge Fix
+This script patches the unified_bridge.py file to correct integration issues
+between components.
+"""
+
+import os
+import sys
+import shutil
+import re
+
+# Define the path to the unified bridge file
+UNIFIED_BRIDGE_PATH = os.path.expanduser("~/AtlasUnified/unified_bridge.py")
+BACKUP_PATH = os.path.expanduser("~/AtlasUnified/unified_bridge.py.bak")
+
+def backup_original_file():
+    """Create a backup of the original file"""
+    if os.path.exists(UNIFIED_BRIDGE_PATH):
+        print(f"Creating backup at {BACKUP_PATH}")
+        shutil.copy2(UNIFIED_BRIDGE_PATH, BACKUP_PATH)
+        return True
+    else:
+        print(f"Error: Unified bridge file not found at {UNIFIED_BRIDGE_PATH}")
+        return False
+
+def fix_openmanus_integration(content):
+    """Fix OpenManus integration code"""
+    # Find and replace the OpenManus integration section
+    openmanus_pattern = r"# Process with OpenManus if enabled.*?(?=\s{4}# Process with|$)"
+    openmanus_replacement = """# Process with OpenManus if enabled - FIXED code to use ask_tool function correctly
+    if config["integrations"]["enable_openmanus"]:
+        try:
+            sys.path.append(config["paths"]["openmanus"])
+            from app.llm import ask_tool
+            
+            # Using the ask_tool function directly
+            openmanus_result = ask_tool(query_text)
+            results["openmanus"] = {"response": openmanus_result}
+            
+        except Exception as e:
+            logger.error(f"OpenManus processing error: {e}")
+            logger.error(traceback.format_exc())
+            results["openmanus"] = {"error": str(e)}
+    
+"""
+    return re.sub(openmanus_pattern, openmanus_replacement, content, flags=re.DOTALL)
+
+def fix_quantum_vision_integration(content):
+    """Fix QuantumVision integration code"""
+    # Find and replace the QuantumVision integration section
+    quantum_pattern = r"# Process with Quantum Vision if enabled.*?(?=\s{4}return results|$)"
+    quantum_replacement = """# Process with Quantum Vision if enabled - FIXED code to use the correct function
+    if config["integrations"]["enable_quantum_vision"]:
+        try:
+            sys.path.append(config["paths"]["quantum_vision"])
+            try:
+                import nlp_processor
+                import openai_integration
+                import spacy
+                
+                # Load a small spaCy model if available, otherwise use simple processing
+                try:
+                    nlp = spacy.load("en_core_web_sm")
+                except:
+                    # Fallback to a simpler model
+                    try:
+                        nlp = spacy.blank("en")
+                    except:
+                        # If spaCy isn't properly installed/configured
+                        raise ImportError("spaCy models not available")
+                
+                # Use the correct function from nlp_processor
+                quantum_result = nlp_processor.process_text(nlp, query_text)
+                results["quantum_vision"] = {"response": quantum_result}
+                
+            except (ImportError, AttributeError):
+                # Fallback to direct OpenAI integration if available
+                try:
+                    import openai_integration
+                    openai_response = openai_integration.generate_text(query_text)
+                    results["quantum_vision"] = {"fallback_response": openai_response}
+                except:
+                    # If both approaches fail, use a simple response
+                    results["quantum_vision"] = {
+                        "fallback_response": f"Processed query: {query_text}",
+                        "simple_analysis": {"words": len(query_text.split())}
+                    }
+                    
+        except Exception as e:
+            logger.error(f"Quantum Vision processing error: {e}")
+            logger.error(traceback.format_exc())
+            results["quantum_vision"] = {"error": str(e)}
+    
+"""
+    return re.sub(quantum_pattern, quantum_replacement, content, flags=re.DOTALL)
+
+def fix_integration_helper_functions(content):
+    """Fix the helper functions for status checks"""
+    # Fix OpenManus status check
+    openmanus_check_pattern = r"def check_openmanus_status\(\).*?(?=def check_quantum|$)"
+    openmanus_check_replacement = """def check_openmanus_status() -> str:
+    \"\"\"Check if OpenManus is available and working\"\"\"
+    try:
+        if not os.path.exists(config["paths"]["openmanus"]):
+            return "unavailable (path not found)"
+            
+        # Try importing a key module - fixed import
+        sys.path.append(config["paths"]["openmanus"])
+        import app.llm
+        return "available"
+    except Exception as e:
+        logger.error(f"Failed to check OpenManus: {e}")
+        return f"error: {str(e)}"
+
+"""
+
+    content = re.sub(openmanus_check_pattern, openmanus_check_replacement, content, flags=re.DOTALL)
+    
+    # Fix QuantumVision status check
+    quantum_check_pattern = r"def check_quantum_vision_status\(\).*?(?=def check_casibase|$)"
+    quantum_check_replacement = """def check_quantum_vision_status() -> str:
+    \"\"\"Check if QuantumVision is available and working\"\"\"
+    try:
+        if not os.path.exists(config["paths"]["quantum_vision"]):
+            return "unavailable (path not found)"
+            
+        # Try importing the module directly
+        sys.path.append(config["paths"]["quantum_vision"])
+        import nlp_processor
+        return "available"
+    except Exception as e:
+        logger.error(f"Failed to check QuantumVision: {e}")
+        return f"error: {str(e)}"
+
+"""
+    return re.sub(quantum_check_pattern, quantum_check_replacement, content, flags=re.DOTALL)
+
+def create_openai_helper_function():
+    """Create an OpenAI helper function for QuantumVision"""
+    openai_file_path = os.path.expanduser("~/Library/Mobile Documents/com~apple~CloudDocs/Atlas Business/QuantumVision/openai_integration.py")
+    
+    # Check if the function already exists
+    if os.path.exists(openai_file_path):
+        with open(openai_file_path, 'r') as file:
+            content = file.read()
+            if 'def generate_text(' in content:
+                print("OpenAI helper function already exists.")
+                return
+    
+    # Create or update the file with the necessary function
+    with open(openai_file_path, 'a') as file:
+        file.write('''
+
+def generate_text(prompt):
+    """Generate text using OpenAI API
+    
+    Args:
+        prompt: The text prompt to send to OpenAI
+        
+    Returns:
+        str: The generated response
+    """
+    try:
+        import logging
+        logger = logging.getLogger(__name__)
+        
+        import openai
+        from openai import OpenAI
+        
+        # Initialize the OpenAI client with your API key
+        client = OpenAI()
+        
+        logger.info(f"Sending prompt to OpenAI: {prompt[:50]}...")
+        
+        # Make the API call
+        response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=[
+                {"role": "system", "content": "You are a helpful AI assistant."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=500
+        )
+        
+        # Extract and return the response text
+        response_text = response.choices[0].message.content
+        return response_text
+        
+    except Exception as e:
+        logger.error(f"Error generating text with OpenAI: {str(e)}")
+        return f"Error generating response: {str(e)}"
+''')
+
+def main():
+    """Main function to apply all fixes"""
+    # Check if the unified bridge file exists
+    if not os.path.exists(UNIFIED_BRIDGE_PATH):
+        print(f"Error: Unified bridge file not found at {UNIFIED_BRIDGE_PATH}")
+        return False
+    
+    # Create a backup
+    if not backup_original_file():
+        return False
+    
+    # Read the file content
+    with open(UNIFIED_BRIDGE_PATH, 'r') as file:
+        content = file.read()
+    
+    # Apply fixes
+    content = fix_openmanus_integration(content)
+    content = fix_quantum_vision_integration(content)
+    content = fix_integration_helper_functions(content)
+    
+    # Write the updated content back
+    with open(UNIFIED_BRIDGE_PATH, 'w') as file:
+        file.write(content)
+    
+    # Create OpenAI helper function
+    create_openai_helper_function()
+    
+    print("Fixes applied successfully!")
+    print("Restart the Atlas Unified service to apply the changes.")
+    return True
+
+if __name__ == "__main__":
+    main()

index.html

@@ -1,321 +1,580 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Manus AI | Apple x Tesla x Waymo</title>
-    <script src="https://cdn.tailwindcss.com"></script>
-    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
-    <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+{% extends "layout.html" %}
+
+{% block content %}
+<div class="row mb-4">
+    <div class="col-md-12">
+        <div class="glass-card floating">
+            <div class="p-4">
+                <h1 class="display-5 quantum-glow text-center">
+                    <i class="fas fa-atom me-2 quantum-spin"></i> <span class="fw-bold">Quantum</span> NLP Framework
+                </h1>
+                <p class="card-text text-center lead">
+                    A multi-dimensional, layered thinking process inspired by quantum computing concepts
+                </p>
+                <hr class="my-4" style="opacity: 0.1;">
+                <p class="card-text">
+                    This framework combines natural language processing with a recursive function that simulates quantum-inspired 
+                    thinking processes, creating a multi-dimensional analysis of your text. Additionally, it can leverage OpenAI's API 
+                    to generate human-like text responses based on the quantum analysis.
+                </p>
+                <div class="vision-progress">
+                    <div class="vision-progress-bar"></div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<div class="row">
+    <div class="col-md-12">
+        <div class="glass-card mb-4">
+            <div class="p-4">
+                <h4 class="mb-4 quantum-glow"><i class="fas fa-keyboard me-2"></i> Input Text</h4>
+                
+                <form method="POST" action="/process" id="process-form">
+                    <div class="mb-4">
+                        <textarea class="form-control quantum-input" id="input_text" name="input_text" rows="5" placeholder="Enter your text for analysis..." required>{{ input_text }}</textarea>
+                    </div>
+                    
+                    <div class="row mb-4 align-items-center">
+                        <div class="col-md-6">
+                            <label class="d-block mb-2">Quantum Dimensions</label>
+                            <div class="input-group">
+                                <span class="input-group-text"><i class="fas fa-layer-group"></i></span>
+                                <select class="form-select" id="depth" name="depth">
+                                    <option value="1" {% if depth == 1 %}selected{% endif %}>Basic (1 dimension)</option>
+                                    <option value="2" {% if depth == 2 %}selected{% endif %}>Intermediate (2 dimensions)</option>
+                                    <option value="3" {% if depth == 3 or not depth %}selected{% endif %}>Advanced (3 dimensions)</option>
+                                    <option value="4" {% if depth == 4 %}selected{% endif %}>Extreme (4 dimensions)</option>
+                                </select>
+                            </div>
+                        </div>
+                        <div class="col-md-6">
+                            <div class="form-check form-switch">
+                                <input class="form-check-input" type="checkbox" id="use_ai" name="use_ai" {% if ai_response %}checked{% endif %}>
+                                <label class="form-check-label" for="use_ai">Use OpenAI for enhanced analysis 
+                                    <i class="fas fa-robot ms-1"></i>
+                                </label>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <!-- LED tracer progress line -->
+                    <div class="vision-progress mb-4">
+                        <div class="vision-progress-bar"></div>
+                    </div>
+                    
+                    <div class="d-grid">
+                        <button type="submit" class="btn btn-primary quantum-btn" id="analyze-btn">
+                            <span class="quantum-btn-content">
+                                <i class="fas fa-brain me-2"></i> 
+                                Analyze with Quantum Algorithm
+                            </span>
+                        </button>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- Results container with animation support -->
+<div id="results-container" class="quantum-results-container">
+    {% if nlp_results %}
+    <div class="row">
+        <div class="col-md-12">
+            <div class="glass-card mb-4 position-relative overflow-hidden">
+                <div class="p-4">
+                    <h4 class="mb-4 quantum-glow"><i class="fas fa-chart-line me-2"></i> NLP Analysis Results</h4>
+                    
+                    <!-- LED corner tracers -->
+                    <div class="led-corner led-corner-tl"></div>
+                    <div class="led-corner led-corner-tr"></div>
+                    <div class="led-corner led-corner-bl"></div>
+                    <div class="led-corner led-corner-br"></div>
+                    
+                    <div class="row fade-in-staggered">
+                        <div class="col-md-4" style="--stagger-delay: 0.1s;">
+                            <div class="glass-card mb-3 text-to-vision glow-hover p-3 position-relative overflow-hidden">
+                                <h5 class="card-title mb-3"><i class="fas fa-calculator me-2"></i> Text Statistics</h5>
+                                <div class="border-start border-info ps-3 mb-2" style="border-width: 3px !important;">
+                                    <div class="mb-2">Word count: <span class="badge bg-info quantum-score">{{ nlp_results.stats.word_count }}</span></div>
+                                    <div class="mb-2">Sentence count: <span class="badge bg-info quantum-score">{{ nlp_results.stats.sentence_count }}</span></div>
+                                    <div>Average sentence length: <span class="badge bg-info quantum-score">{{ nlp_results.stats.average_sentence_length }}</span> words</div>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="col-md-4" style="--stagger-delay: 0.2s;">
+                            <div class="glass-card mb-3 text-to-vision glow-hover p-3 position-relative overflow-hidden">
+                                <h5 class="card-title mb-3"><i class="fas fa-tag me-2"></i> Top Terms</h5>
+                                <ul class="list-group list-group-flush">
+                                    {% for term, freq in nlp_results.top_terms %}
+                                    <li class="list-group-item d-flex justify-content-between align-items-center bg-transparent border-bottom border-light border-opacity-10 quantum-entity-item">
+                                        {{ term }}
+                                        <span class="badge bg-primary quantum-score">{{ freq }}</span>
+                                    </li>
+                                    {% endfor %}
+                                </ul>
+                            </div>
+                        </div>
+                        <div class="col-md-4" style="--stagger-delay: 0.3s;">
+                            <div class="glass-card mb-3 text-to-vision glow-hover p-3 position-relative overflow-hidden">
+                                <h5 class="card-title mb-3"><i class="fas fa-fingerprint me-2"></i> Named Entities</h5>
+                                {% if nlp_results.entities %}
+                                <ul class="list-group list-group-flush">
+                                    {% for entity in nlp_results.entities[:5] %}
+                                    <li class="list-group-item d-flex justify-content-between align-items-center bg-transparent border-bottom border-light border-opacity-10 quantum-entity-item">
+                                        {{ entity.text }}
+                                        <span class="badge bg-success quantum-score">{{ entity.label }}</span>
+                                    </li>
+                                    {% endfor %}
+                                </ul>
+                                {% else %}
+                                <p class="text-muted">No named entities detected</p>
+                                {% endif %}
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    {% endif %}
+    
+    {% if quantum_results %}
+    <div class="row">
+        <div class="col-md-12">
+            <div class="glass-card mb-4 position-relative overflow-hidden">
+                <div class="p-4">
+                    <h4 class="mb-4 quantum-glow">
+                        <i class="fas fa-atom me-2 quantum-spin"></i> Quantum Thinking Results
+                    </h4>
+                    
+                    <!-- LED corner tracers -->
+                    <div class="led-corner led-corner-tl"></div>
+                    <div class="led-corner led-corner-tr"></div>
+                    <div class="led-corner led-corner-bl"></div>
+                    <div class="led-corner led-corner-br"></div>
+                    
+                    <div class="glass-card mb-4 p-3 position-relative overflow-hidden" style="background: rgba(13, 202, 240, 0.1);">
+                        <div class="row align-items-center">
+                            <div class="col-md-9">
+                                <h5 class="mb-0"><strong>Meta-Insight:</strong></h5>
+                                <p class="lead mb-0 mt-2">{{ quantum_results.meta_insight }}</p>
+                            </div>
+                            <div class="col-md-3 text-center">
+                                <div class="quantum-score-visualization" data-score="{{ quantum_results.quantum_score }}">
+                                    <div class="score-circle">
+                                        <span class="score-value">{{ quantum_results.quantum_score }}</span>
+                                    </div>
+                                    <p class="mt-2 mb-0">Quantum Score</p>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="row mb-3 align-items-center">
+                        <div class="col-md-6">
+                            <div class="d-flex align-items-center">
+                                <i class="fas fa-layer-group me-2 quantum-glow" style="font-size: 1.5rem;"></i>
+                                <h5 class="mb-0">Dimension Level: <span class="badge bg-primary">{{ quantum_results.dimension }}</span></h5>
+                            </div>
+                        </div>
+                        <div class="col-md-6 text-end">
+                            <div class="d-flex align-items-center justify-content-end">
+                                <span class="me-2">Quantum Paths:</span>
+                                <span class="badge bg-primary">{{ quantum_results.paths|length }}</span>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <!-- LED tracer progress line -->
+                    <div class="vision-progress mb-4">
+                        <div class="vision-progress-bar"></div>
+                    </div>
+                    
+                    <div class="accordion quantum-accordion" id="quantumPathsAccordion">
+                        {% for path in quantum_results.paths %}
+                        <div class="accordion-item glass-card text-to-vision mb-3 position-relative fade-in-staggered" style="--stagger-delay: {{ 0.15 * loop.index }}s;">
+                            <h2 class="accordion-header">
+                                <button class="accordion-button {% if loop.index > 1 %}collapsed{% endif %} glass-card" type="button" data-bs-toggle="collapse" data-bs-target="#collapse{{ loop.index }}">
+                                    <div class="path-number me-3">{{ loop.index }}</div>
+                                    <i class="fas fa-route me-2"></i> Path: <span class="ms-2 fw-bold">{{ path.concept }}</span>
+                                </button>
+                            </h2>
+                            <div id="collapse{{ loop.index }}" class="accordion-collapse collapse {% if loop.index == 1 %}show{% endif %}">
+                                <div class="accordion-body glass-card">
+                                    <div class="row">
+                                        <div class="col-md-12 mb-3">
+                                            <div class="glass-card p-3" style="background: rgba(218, 75, 134, 0.05);">
+                                                <h6 class="mb-2"><i class="fas fa-lightbulb me-2"></i>Insight:</h6>
+                                                <p class="mb-0">{{ path.insight }}</p>
+                                            </div>
+                                        </div>
+                                        <div class="col-md-12 mb-3">
+                                            <div class="glass-card p-3" style="background: rgba(111, 66, 193, 0.05);">
+                                                <h6 class="mb-2"><i class="fas fa-comment-dots me-2"></i>Prompt:</h6>
+                                                <p class="mb-0 text-muted">{{ path.prompt }}</p>
+                                            </div>
+                                        </div>
+                                    </div>
+                                    
+                                    {% if path.entangled_insight %}
+                                    <div class="glass-card p-3 mt-3" style="background: rgba(13, 202, 240, 0.05);">
+                                        <h6 class="mb-2"><i class="fas fa-link me-2"></i>Quantum Entanglement:</h6>
+                                        <div class="d-flex align-items-center mb-2">
+                                            <span class="badge bg-info me-2">Entangled with Path: {{ path.entangled_with }}</span>
+                                            <div class="vision-progress" style="flex-grow: 1; height: 2px;">
+                                                <div class="vision-progress-bar"></div>
+                                            </div>
+                                        </div>
+                                        <p class="mb-0">{{ path.entangled_insight }}</p>
+                                    </div>
+                                    {% endif %}
+                                    
+                                    {% if path.sub_dimensions and path.sub_dimensions.paths %}
+                                    <div class="glass-card p-3 mt-3" style="background: rgba(255, 193, 7, 0.05);">
+                                        <h6 class="mb-3"><i class="fas fa-cubes me-2"></i>Sub-dimensions:</h6>
+                                        <div class="row">
+                                            {% for subpath in path.sub_dimensions.paths[:2] %}
+                                            <div class="col-md-6 mb-2">
+                                                <div class="glass-card p-3 h-100">
+                                                    <h6 class="mb-2 text-info">{{ subpath.concept }}</h6>
+                                                    <p class="mb-0 small">{{ subpath.insight }}</p>
+                                                </div>
+                                            </div>
+                                            {% endfor %}
+                                        </div>
+                                    </div>
+                                    {% endif %}
+                                </div>
+                            </div>
+                            
+                            <!-- Path color indicator -->
+                            <div class="path-color-indicator" style="background: 
+                                {% if loop.index % 3 == 1 %}#da4b86{% elif loop.index % 3 == 2 %}#6f42c1{% else %}#0dcaf0{% endif %};"></div>
+                        </div>
+                        {% endfor %}
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+    
     <style>
-        @import url('https://fonts.googleapis.com/css2?family=SF+Pro+Display:wght@300;400;500;600;700&display=swap');
-        
-        :root {
-            --primary: #0071e3;
-            --primary-dark: #0062c4;
-            --dark: #1d1d1f;
-            --light: #f5f5f7;
-            --accent: #e51937;
-            --success: #34c759;
-            --neumorph-light: #2a2a2e;
-            --neumorph-dark: #121214;
-        }
-        
-        body {
-            font-family: 'SF Pro Display', -apple-system, BlinkMacSystemFont, sans-serif;
-            background-color: #1a1a1c;
-            color: #fff;
-            overflow-x: hidden;
-        }
-        
-        .gradient-bg {
-            background: linear-gradient(135deg, #1a1a1c 0%, #1d1d1f 50%, #202023 100%);
-        }
-        
-        .glass-effect {
-            background: rgba(255, 255, 255, 0.05);
-            backdrop-filter: blur(10px);
-            -webkit-backdrop-filter: blur(10px);
-            border: 1px solid rgba(255, 255, 255, 0.1);
-        }
-        
-        /* Neomorphism Styles */
-        .neumorph {
-            background: linear-gradient(145deg, var(--neumorph-light), var(--neumorph-dark));
-            box-shadow:  8px 8px 16px #121214,
-                        -8px -8px 16px #2a2a2e;
-            border: none;
-        }
-        
-        .neumorph-inset {
-            background: linear-gradient(145deg, var(--neumorph-dark), var(--neumorph-light));
-            box-shadow: inset 5px 5px 10px #121214,
-                       inset -5px -5px 10px #2a2a2e;
-            border: none;
-        }
-        
-        .neumorph-btn {
-            background: linear-gradient(145deg, var(--neumorph-light), var(--neumorph-dark));
-            box-shadow:  4px 4px 8px #121214,
-                        -4px -4px 8px #2a2a2e;
-            border: none;
-            transition: all 0.2s ease;
-        }
-        
-        .neumorph-btn:active {
-            box-shadow: inset 3px 3px 6px #121214,
-                       inset -3px -3px 6px #2a2a2e;
-        }
-        
-        .neumorph-btn-primary {
-            background: linear-gradient(145deg, #0062c4, #0071e3);
-            box-shadow:  4px 4px 8px #121214,
-                        -4px -4px 8px #2a2a2e;
+        /* Quantum Score Visualization */
+        .quantum-score-visualization {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            padding: 10px;
+        }
+        
+        .score-circle {
+            width: 80px;
+            height: 80px;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background: radial-gradient(circle, rgba(13, 202, 240, 0.2) 0%, rgba(218, 75, 134, 0.2) 100%);
+            border: 2px solid rgba(111, 66, 193, 0.5);
+            position: relative;
+            box-shadow: 0 0 15px rgba(111, 66, 193, 0.5);
+            animation: pulse-glow 2s infinite alternate;
         }
         
-        .neumorph-btn-primary:active {
-            box-shadow: inset 3px 3px 6px #0056a8,
-                       inset -3px -3px 6px #008cff;
+        @keyframes pulse-glow {
+            0% { box-shadow: 0 0 5px rgba(111, 66, 193, 0.5); }
+            100% { box-shadow: 0 0 20px rgba(111, 66, 193, 0.8); }
         }
         
-        .neumorph-card {
-            background: linear-gradient(145deg, var(--neumorph-light), var(--neumorph-dark));
-            box-shadow:  6px 6px 12px #121214,
-                        -6px -6px 12px #2a2a2e;
-            border-radius: 16px;
-            border: none;
+        .score-value {
+            font-size: 1.5rem;
+            font-weight: bold;
+            color: white;
         }
         
-        .neumorph-circle {
-            background: linear-gradient(145deg, var(--neumorph-light), var(--neumorph-dark));
-            box-shadow:  6px 6px 12px #121214,
-                        -6px -6px 12px #2a2a2e;
-            border: none;
+        /* Path number indicator */
+        .path-number {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            width: 30px;
+            height: 30px;
+            border-radius: 50%;
+            background: rgba(111, 66, 193, 0.2);
+            color: white;
+            font-weight: bold;
+            border: 1px solid rgba(111, 66, 193, 0.5);
         }
         
-        .neumorph-input {
-            background: linear-gradient(145deg, var(--neumorph-dark), var(--neumorph-light));
-            box-shadow: inset 4px 4px 8px #121214,
-                       inset -4px -4px 8px #2a2a2e;
+        /* Path color indicator */
+        .path-color-indicator {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 4px;
+            height: 100%;
+            border-top-left-radius: 4px;
+            border-bottom-left-radius: 4px;
+        }
+        
+        /* Accordion styling */
+        .quantum-accordion .accordion-button {
+            background: rgba(30, 41, 59, 0.4);
+            color: white;
             border: none;
         }
         
-        .terminal-font {
-            font-family: 'SF Mono', Menlo, monospace;
-        }
-        
-        .typing-cursor::after {
-            content: "|";
-            animation: blink 1s step-end infinite;
-        }
-        
-        @keyframes blink {
-            from, to { opacity: 1; }
-            50% { opacity: 0; }
-        }
-        
-        .task-progress {
-            transition: width 0.3s ease;
+        .quantum-accordion .accordion-button:not(.collapsed) {
+            color: white;
+            background: rgba(30, 41, 59, 0.5);
+            box-shadow: none;
         }
         
-        .scrollbar-hide::-webkit-scrollbar {
-            display: none;
+        .quantum-accordion .accordion-button:focus {
+            box-shadow: none;
+            border-color: rgba(111, 66, 193, 0.5);
         }
         
-        .scrollbar-hide {
-            -ms-overflow-style: none;
-            scrollbar-width: none;
+        .quantum-accordion .accordion-button::after {
+            background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='white'%3e%3cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3e%3c/svg%3e");
         }
         
-        .fade-in {
-            animation: fadeIn 0.3s ease-in;
+        /* Staggered fade-in animation */
+        @keyframes fadeInUp {
+            from {
+                opacity: 0;
+                transform: translateY(20px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
         }
         
-        @keyframes fadeIn {
-            from { opacity: 0; transform: translateY(10px); }
-            to { opacity: 1; transform: translateY(0); }
-        }
-        
-        .pulse {
-            animation: pulse 2s infinite;
-        }
-        
-        @keyframes pulse {
-            0% { box-shadow: 0 0 0 0 rgba(0, 113, 227, 0.7); }
-            70% { box-shadow: 0 0 0 10px rgba(0, 113, 227, 0); }
-            100% { box-shadow: 0 0 0 0 rgba(0, 113, 227, 0); }
-        }
-        
-        /* Custom Neumorphic Elements */
-        .neumorph-nav-item {
-            padding: 8px 12px;
-            border-radius: 12px;
-            background: linear-gradient(145deg, var(--neumorph-light), var(--neumorph-dark));
-            box-shadow:  3px 3px 6px #121214,
-                        -3px -3px 6px #2a2a2e;
-            transition: all 0.2s ease;
-        }
-        
-        .neumorph-nav-item:hover {
-            box-shadow: inset 3px 3px 6px #121214,
-                       inset -3px -3px 6px #2a2a2e;
-        }
-        
-        .neumorph-divider {
-            height: 1px;
-            background: rgba(255,255,255,0.1);
-            box-shadow: 0 1px 2px rgba(0,0,0,0.3);
-        }
-        
-        /* Sidebar transitions */
-        .sidebar {
-            transition: transform 0.3s ease, opacity 0.3s ease;
-        }
-        
-        .sidebar-hidden {
-            transform: translateX(-100%);
+        .fade-in-staggered {
             opacity: 0;
-            pointer-events: none;
+            animation: fadeInUp 0.6s ease forwards;
+            animation-delay: var(--stagger-delay, 0s);
         }
-        
-        .sidebar-visible {
-            transform: translateX(0);
-            opacity: 1;
-            pointer-events: all;
-        }
-        
-        /* Page transitions */
-        .page {
-            display: none;
-            opacity: 0;
-            transition: opacity 0.3s ease;
-        }
-        
-        .page-active {
-            display: block;
-            opacity: 1;
-        }
-        
-        /* Settings toggle */
-        .settings-toggle {
-            transition: all 0.3s ease;
+    </style>
+    {% endif %}
+    
+    {% if ai_response %}
+    <div class="row">
+        <div class="col-md-12">
+            <div class="glass-card mb-4 position-relative overflow-hidden">
+                <div class="p-4">
+                    <h4 class="mb-4 quantum-glow">
+                        <i class="fas fa-robot me-2 quantum-spin"></i> AI Analysis
+                    </h4>
+                    
+                    <!-- LED corner tracers -->
+                    <div class="led-corner led-corner-tl"></div>
+                    <div class="led-corner led-corner-tr"></div>
+                    <div class="led-corner led-corner-bl"></div>
+                    <div class="led-corner led-corner-br"></div>
+                    
+                    {% if ai_response.error %}
+                    <div class="glass-card p-4" style="background: rgba(220, 53, 69, 0.1);">
+                        <div class="row align-items-center">
+                            <div class="col-md-1 text-center">
+                                <i class="fas fa-exclamation-triangle fa-2x text-danger"></i>
+                            </div>
+                            <div class="col-md-11">
+                                <h5 class="text-danger">OpenAI API Error</h5>
+                                <p>{{ ai_response.error }}</p>
+                                <div class="mt-3">
+                                    <a href="https://platform.openai.com/signup" target="_blank" class="btn btn-sm btn-outline-info quantum-btn">
+                                        <i class="fas fa-key me-1"></i> Get OpenAI API Key
+                                    </a>
+                                    <button class="btn btn-sm btn-outline-primary quantum-btn ms-2" id="add-api-key-btn">
+                                        <i class="fas fa-plus-circle me-1"></i> Add API Key to Project
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    {% else %}
+                    <div class="glass-card mb-3 fade-in">
+                        <div class="p-3 border-bottom border-info border-opacity-10">
+                            <div class="d-flex justify-content-between align-items-center">
+                                <div>
+                                    <i class="fas fa-brain me-2 text-info"></i>
+                                    <span>Response from <span class="badge bg-info">{{ ai_response.model }}</span></span>
+                                </div>
+                                <div class="d-flex align-items-center">
+                                    <div class="ai-indicator me-2">
+                                        <div class="ai-pulse"></div>
+                                    </div>
+                                    <span class="badge bg-info">AI-Generated</span>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="p-4">
+                            <!-- LED tracer progress line -->
+                            <div class="vision-progress mb-3">
+                                <div class="vision-progress-bar"></div>
+                            </div>
+                            
+                            <div class="ai-response p-2 position-relative">
+                                {{ ai_response.text | safe | replace('\n', '<br>') }}
+                                
+                                <!-- Quantum particles floating around the AI response -->
+                                <div class="quantum-particles-container"></div>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="d-flex justify-content-end mt-3 fade-in" style="animation-delay: 0.3s;">
+                        <button class="btn btn-sm btn-outline-light me-2" id="copy-ai-response">
+                            <i class="fas fa-copy me-1"></i> Copy Response
+                        </button>
+                        <button class="btn btn-sm btn-outline-info" id="regenerate-response">
+                            <i class="fas fa-sync-alt me-1"></i> Regenerate
+                        </button>
+                    </div>
+                    {% endif %}
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <style>
+        /* AI Indicator */
+        .ai-indicator {
+            width: 20px;
+            height: 20px;
+            position: relative;
         }
         
-        .settings-toggle.active {
-            transform: rotate(90deg);
+        .ai-pulse {
+            width: 100%;
+            height: 100%;
+            border-radius: 50%;
+            background: rgba(13, 202, 240, 0.5);
+            position: absolute;
+            animation: ai-pulse 2s infinite;
         }
         
-        /* Tooltip */
-        .tooltip {
-            position: relative;
+        @keyframes ai-pulse {
+            0% {
+                transform: scale(0.5);
+                opacity: 1;
+            }
+            100% {
+                transform: scale(1.5);
+                opacity: 0;
+            }
         }
         
-        .tooltip .tooltip-text {
-            visibility: hidden;
-            width: 120px;
-            background-color: #333;
-            color: #fff;
-            text-align: center;
-            border-radius: 6px;
-            padding: 5px;
+        /* Quantum particles */
+        .quantum-particles-container {
             position: absolute;
-            z-index: 1;
-            bottom: 125%;
-            left: 50%;
-            margin-left: -60px;
-            opacity: 0;
-            transition: opacity 0.3s;
-        }
-        
-        .tooltip:hover .tooltip-text {
-            visibility: visible;
-            opacity: 1;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+            overflow: hidden;
+        }
+        
+        @keyframes float-particle {
+            0% {
+                transform: translateY(0) translateX(0) rotate(0deg);
+                opacity: 0;
+            }
+            10% {
+                opacity: 1;
+            }
+            90% {
+                opacity: 1;
+            }
+            100% {
+                transform: translateY(-100px) translateX(var(--x-drift)) rotate(360deg);
+                opacity: 0;
+            }
         }
     </style>
-</head>
-<body class="gradient-bg min-h-screen flex flex-col">
-    <!-- Top Navigation Bar -->
-    <header class="glass-effect py-3 px-6 flex items-center justify-between border-b border-gray-800">
-        <div class="flex items-center space-x-6">
-            <div class="flex items-center">
-                <div class="w-8 h-8 rounded-full neumorph-circle flex items-center justify-center">
-                    <span class="text-white font-bold">M</span>
-                </div>
-                <span class="ml-2 font-semibold text-lg">Manus AI</span>
-            </div>
-            <nav class="hidden md:flex space-x-3">
-                <a href="#" data-page="home" class="neumorph-nav-item text-white transition page-link">Home</a>
-                <a href="#" data-page="tasks" class="neumorph-nav-item text-gray-300 hover:text-white transition page-link">Tasks</a>
-                <a href="#" data-page="automations" class="neumorph-nav-item text-gray-300 hover:text-white transition page-link">Automations</a>
-                <a href="#" data-page="knowledge" class="neumorph-nav-item text-gray-300 hover:text-white transition page-link">Knowledge</a>
-                <a href="#" data-page="settings" class="neumorph-nav-item text-gray-300 hover:text-white transition page-link">Settings</a>
-            </nav>
-        </div>
-        <div class="flex items-center space-x-4">
-            <div class="relative">
-                <button class="p-2 neumorph-btn rounded-full hover:bg-gray-800 transition">
-                    <i class="fas fa-bell text-gray-300"></i>
-                </button>
-                <span class="absolute top-0 right-0 w-2 h-2 bg-red-500 rounded-full"></span>
-            </div>
-            <div class="hidden md:flex items-center space-x-2 neumorph-card px-3 py-1">
-                <div class="w-6 h-6 rounded-full bg-blue-500 flex items-center justify-center">
-                    <i class="fas fa-robot text-xs text-white"></i>
-                </div>
-                <span class="text-sm">Autonomous Mode: Active</span>
-            </div>
-        </div>
-    </header>
-
-    <!-- Main Content -->
-    <main class="flex flex-1 overflow-hidden">
-        <!-- Sidebar -->
-        <aside id="sidebar" class="sidebar lg:block w-64 bg-black bg-opacity-30 border-r border-gray-800 p-4 overflow-y-auto">
-            <div class="mb-8">
-                <h3 class="text-xs uppercase font-semibold text-gray-500 mb-3">Quick Actions</h3>
-                <div class="space-y-2">
-                    <button id="new-task-btn" class="w-full flex items-center space-x-2 px-3 py-2 neumorph-btn rounded-lg hover:bg-gray-800 transition text-left">
-                        <i class="fas fa-plus text-blue-500"></i>
-                        <span>New Task</span>
-                    </button>
-                    <button id="quick-automation-btn" class="w-full flex items-center space-x-2 px-3 py-2 neumorph-btn rounded-lg hover:bg-gray-800 transition text-left">
-                        <i class="fas fa-bolt text-yellow-500"></i>
-                        <span>Quick Automation</span>
-                    </button>
-                    <button id="ai-training-btn" class="w-full flex items-center space-x-2 px-3 py-2 neumorph-btn rounded-lg hover:bg-gray-800 transition text-left">
-                        <i class="fas fa-brain text-purple-500"></i>
-                        <span>AI Training</span>
-                    </button>
-                </div>
-            </div>
+    
+    <script>
+        document.addEventListener('DOMContentLoaded', function() {
+            // Copy response button
+            const copyBtn = document.getElementById('copy-ai-response');
+            if (copyBtn) {
+                copyBtn.addEventListener('click', function() {
+                    const responseText = document.querySelector('.ai-response').innerText;
+                    navigator.clipboard.writeText(responseText).then(() => {
+                        copyBtn.innerHTML = '<i class="fas fa-check me-1"></i> Copied!';
+                        setTimeout(() => {
+                            copyBtn.innerHTML = '<i class="fas fa-copy me-1"></i> Copy Response';
+                        }, 2000);
+                    });
+                });
+            }
             
-            <div class="mb-8">
-                <h3 class="text-xs uppercase font-semibold text-gray-500 mb-3">Active Tasks</h3>
-                <div class="space-y-3">
-                    <div class="neumorph-card rounded-lg p-3">
-                        <div class="flex justify-between items-center mb-1">
-                            <span class="text-sm font-medium">Market Research</span>
-                            <span class="text-xs text-gray-400">65%</span>
-                        </div>
-                        <div class="w-full neumorph-inset rounded-full h-1.5">
-                            <div class="bg-blue-500 h-1.5 rounded-full task-progress" style="width: 65%"></div>
-                        </div>
-                    </div>
-                    <div class="neumorph-card rounded-lg p-3">
-                        <div class="flex justify-between items-center mb-1">
-                            <span class="text-sm font-medium">Data Analysis</span>
-                            <span class="text-xs text-gray-400">42%</span>
-                        </div>
-                        <div class="w-full neumorph-inset rounded-full h-1.5">
-                            <div class="bg-green-500 h-1.5 rounded-full task-progress" style="width: 42%"></div>
-                        </div>
-                    </div>
-                    <div class="neumorph-card rounded-lg p-3">
-                        <div class="flex justify-between items-center mb-1">
-                            <span class="text-sm font-medium">Content Creation</span>
-                            <span class="text-xs text-gray-400">18%</span>
-                        </div>
-                        <div class="w-full neumorph-inset rounded-full h-1.5">
-                            <div class="bg-purple-500 h
-</html>
+            // Add API key button
+            const apiKeyBtn = document.getElementById('add-api-key-btn');
+            if (apiKeyBtn) {
+                apiKeyBtn.addEventListener('click', function() {
+                    alert('To add your OpenAI API key, please contact the administrator or use environment variables.');
+                });
+            }
+            
+            // Create floating particles in the AI response
+            const particlesContainer = document.querySelector('.quantum-particles-container');
+            if (particlesContainer) {
+                // Create floating particles
+                setInterval(() => {
+                    if (Math.random() > 0.7) {
+                        createFloatingParticle(particlesContainer);
+                    }
+                }, 500);
+            }
+            
+            function createFloatingParticle(container) {
+                const particle = document.createElement('div');
+                particle.className = 'quantum-particle';
+                
+                // Random position at the bottom
+                const xPos = Math.random() * 100;
+                const xDrift = (Math.random() - 0.5) * 100;
+                
+                particle.style.cssText = `
+                    position: absolute;
+                    bottom: 0;
+                    left: ${xPos}%;
+                    width: 4px;
+                    height: 4px;
+                    border-radius: 50%;
+                    background: ${getRandomParticleColor()};
+                    filter: blur(1px);
+                    box-shadow: 0 0 5px currentColor;
+                    --x-drift: ${xDrift}px;
+                    animation: float-particle ${3 + Math.random() * 4}s linear forwards;
+                `;
+                
+                container.appendChild(particle);
+                
+                // Remove after animation completes
+                setTimeout(() => {
+                    particle.remove();
+                }, 7000);
+            }
+            
+            function getRandomParticleColor() {
+                const colors = [
+                    'rgba(13, 202, 240, 0.8)',    // Cyan
+                    'rgba(111, 66, 193, 0.8)',    // Purple
+                    'rgba(218, 75, 134, 0.8)'     // Pink
+                ];
+                return colors[Math.floor(Math.random() * colors.length)];
+            }
+        });
+    </script>
+    {% endif %}
+</div>
+
+{% endblock %}

install.sh

@@ -0,0 +1,900 @@
+#!/bin/bash
+
+# Atlas Intelligence Universal Setup Script
+# Compatible with macOS on Apple Silicon (M1/M2/M3)
+# Created: April 16, 2025
+
+# Exit on error, but allow for custom error handling
+set -o pipefail
+
+# Color codes for better output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+BOLD='\033[1m'
+NC='\033[0m' # No Color
+
+# Paths to project directories
+OPENMANUS_DIR="$HOME/OpenManus"
+CASIBASE_DIR="$HOME/casibase"
+CYPHER_DIR="$HOME/Cypher"
+CLOUD_DIR="$HOME/Library/Mobile Documents/com~apple~CloudDocs/Atlas Business"
+AI_COMPANION_DIR="$CLOUD_DIR/AIConversationCompanion"
+QUANTUM_VISION_DIR="$CLOUD_DIR/QuantumVision"
+UNIFIED_DIR="$HOME/AtlasUnified"
+
+# Log file for the installation process
+LOG_FILE="$QUANTUM_VISION_DIR/install_log.txt"
+
+# Function to log messages to both stdout and log file
+log() {
+  echo -e "$1" | tee -a "$LOG_FILE"
+}
+
+# Function to log errors
+log_error() {
+  echo -e "${RED}ERROR: $1${NC}" | tee -a "$LOG_FILE"
+}
+
+# Function to log warnings
+log_warning() {
+  echo -e "${YELLOW}WARNING: $1${NC}" | tee -a "$LOG_FILE"
+}
+
+# Function to log success
+log_success() {
+  echo -e "${GREEN}$1${NC}" | tee -a "$LOG_FILE"
+}
+
+# Function to log information
+log_info() {
+  echo -e "${BLUE}$1${NC}" | tee -a "$LOG_FILE"
+}
+
+# Clean log file
+> "$LOG_FILE"
+
+log_info "=============================================="
+log_info "     Atlas Intelligence Unified Setup        "
+log_info "=============================================="
+log_info "This script will set up a universal connection between:"
+log "- OpenManus AI Agent Framework"
+log "- Casibase RAG Knowledge Database"
+log "- Cypher"
+log "- AI Conversation Companion"
+log "- Quantum Vision"
+log_info "=============================================="
+log ""
+
+# Check if running on macOS
+if [[ "$(uname)" != "Darwin" ]]; then
+  log_error "This script is designed for macOS. Exiting."
+  exit 1
+fi
+
+# Check for Apple Silicon
+if [[ "$(uname -m)" != "arm64" ]]; then
+  log_warning "You're not running on Apple Silicon (M1/M2/M3). Some optimizations may not work."
+fi
+
+# Check for required tools
+log_info "Checking for required tools..."
+
+# Check for Homebrew
+if ! command -v brew &> /dev/null; then
+  log_warning "Homebrew not found. Installing Homebrew..."
+  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+  
+  # Add Homebrew to PATH for Apple Silicon
+  if [[ "$(uname -m)" == "arm64" ]]; then
+    echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
+    eval "$(/opt/homebrew/bin/brew shellenv)"
+  fi
+else
+  log_success "Homebrew is installed."
+fi
+
+# Check for Python
+if ! command -v python3 &> /dev/null; then
+  log_warning "Python not found. Installing Python..."
+  brew install python@3.11
+else
+  log_success "Python is installed."
+  PYTHON_VERSION=$(python3 --version | cut -d' ' -f2)
+  log_info "Python version: $PYTHON_VERSION"
+fi
+
+# Check for Go
+if ! command -v go &> /dev/null; then
+  log_warning "Go not found. Installing Go..."
+  brew install go
+else
+  log_success "Go is installed."
+  GO_VERSION=$(go version | cut -d' ' -f3)
+  log_info "Go version: $GO_VERSION"
+fi
+
+# Check for Node.js
+if ! command -v node &> /dev/null; then
+  log_warning "Node.js not found. Installing Node.js..."
+  brew install node
+else
+  log_success "Node.js is installed."
+  NODE_VERSION=$(node --version)
+  log_info "Node.js version: $NODE_VERSION"
+fi
+
+# Check for required Python modules
+check_python_module() {
+  if ! python3 -c "import $1" &> /dev/null; then
+    return 1
+  else
+    return 0
+  fi
+}
+
+# Create unified directory if it doesn't exist
+log_info "Setting up unified directory structure..."
+mkdir -p "$UNIFIED_DIR"
+mkdir -p "$UNIFIED_DIR/config"
+mkdir -p "$UNIFIED_DIR/logs"
+mkdir -p "$UNIFIED_DIR/data"
+
+# Set up Python virtual environment with error handling
+log_info "Setting up Python virtual environment..."
+if ! command -v python3 -m venv &> /dev/null; then
+  log_warning "Python venv module not found. Installing venv..."
+  brew reinstall python@3.11
+fi
+
+# Create and activate virtual environment
+python3 -m venv "$UNIFIED_DIR/venv" || {
+  log_error "Failed to create virtual environment. Trying alternative approach..."
+  pip3 install virtualenv
+  virtualenv "$UNIFIED_DIR/venv"
+}
+
+# Source the virtual environment with error handling
+if [ -f "$UNIFIED_DIR/venv/bin/activate" ]; then
+  source "$UNIFIED_DIR/venv/bin/activate"
+  log_success "Virtual environment activated."
+else
+  log_error "Virtual environment activation script not found. Installation may not work correctly."
+  exit 1
+fi
+
+# Upgrade pip and install wheel to avoid common installation issues
+log_info "Upgrading pip and installing wheel..."
+pip install --upgrade pip wheel setuptools
+
+# Install core dependencies that commonly cause issues if not installed first
+log_info "Installing core dependencies..."
+pip install Cython numpy==1.26.4 pandas scikit-learn
+
+# OpenManus dependencies
+log_info "Installing OpenManus dependencies..."
+if [ -f "$OPENMANUS_DIR/requirements.txt" ]; then
+  # Try-catch for OpenManus requirements
+  if ! pip install -r "$OPENMANUS_DIR/requirements.txt"; then
+    log_warning "Some OpenManus dependencies failed to install. Installing essential ones individually..."
+    # Install critical dependencies individually
+    pip install openai tenacity pyyaml loguru
+  fi
+else
+  log_error "OpenManus requirements.txt not found. Skipping OpenManus dependencies."
+fi
+
+# Quantum Vision dependencies - FIX: Instead of installing as a package, install dependencies directly
+log_info "Installing Quantum Vision dependencies..."
+if [ -f "$QUANTUM_VISION_DIR/pyproject.toml" ]; then
+  # Install specific dependencies from pyproject.toml instead of the package itself
+  log_info "Installing specific Quantum Vision dependencies..."
+  pip install beautifulsoup4 email-validator flask flask-sqlalchemy gunicorn 
+  pip install "openai>=1.6.0" psycopg2-binary requests 
+  pip install "spacy>=3.0.0" sqlalchemy trafilatura
+  
+  # Create an empty __init__.py file in the Quantum Vision directory to make it importable
+  touch "$QUANTUM_VISION_DIR/__init__.py"
+  log_success "Quantum Vision dependencies installed."
+else
+  log_error "Quantum Vision pyproject.toml not found. Skipping Quantum Vision dependencies."
+fi
+
+# Cypher dependencies
+log_info "Installing Cypher dependencies..."
+if [ -f "$CYPHER_DIR/requirements.txt" ]; then
+  # Try-catch for Cypher requirements
+  if ! pip install -r "$CYPHER_DIR/requirements.txt"; then
+    log_warning "Some Cypher dependencies failed to install. Installing essential ones individually..."
+    pip install flask requests
+  fi
+else
+  log_warning "Cypher requirements.txt not found. Skipping Cypher dependencies."
+fi
+
+# Install FastAPI and related packages for the unified API
+log_info "Installing FastAPI and related packages for the unified API..."
+pip install fastapi uvicorn pydantic pyyaml
+
+# Set up Casibase
+log_info "Setting up Casibase..."
+if [ -d "$CASIBASE_DIR" ]; then
+  cd "$CASIBASE_DIR"
+  
+  # Check if Docker is installed
+  if ! command -v docker &> /dev/null; then
+    log_warning "Docker not found. Installing Docker..."
+    brew install --cask docker
+    log_warning "Please open Docker Desktop and complete setup, then run this script again."
+    log_warning "Skipping Casibase setup for now."
+  else
+    # Build and run Casibase
+    log_info "Building Casibase..."
+    # Only run build.sh if it exists and is executable
+    if [ -f "./build.sh" ] && [ -x "./build.sh" ]; then
+      # Run build.sh with error handling
+      if ! ./build.sh; then
+        log_warning "Casibase build failed. You may need to run it manually later."
+      else
+        log_success "Casibase build completed successfully."
+      fi
+    else
+      log_warning "Casibase build.sh not found or not executable. Skipping build."
+    fi
+  fi
+  
+  log_success "Casibase setup completed with available components."
+else
+  log_warning "Casibase directory not found. Skipping Casibase setup."
+fi
+
+# Return to original directory
+cd "$QUANTUM_VISION_DIR"
+
+# Set up AI Conversation Companion frontend
+log_info "Setting up AI Conversation Companion..."
+if [ -d "$AI_COMPANION_DIR" ]; then
+  cd "$AI_COMPANION_DIR"
+  
+  # Install npm dependencies
+  if [ -f "package.json" ]; then
+    log_info "Installing npm dependencies for AI Conversation Companion..."
+    # Run npm install with error handling
+    if ! npm install; then
+      log_warning "Some npm packages failed to install. You may need to run 'npm install' manually later."
+    fi
+  else
+    log_warning "package.json not found in AI Conversation Companion. Skipping npm install."
+  fi
+else
+  log_warning "AI Conversation Companion directory not found. Skipping frontend setup."
+fi
+
+# Return to original directory
+cd "$QUANTUM_VISION_DIR"
+
+# Create unified configuration
+log_info "Creating unified configuration..."
+mkdir -p "$UNIFIED_DIR/config"
+cat > "$UNIFIED_DIR/config/unified_config.yaml" << EOF
+# Atlas Intelligence Unified Configuration
+version: 1.0.0
+created: "$(date)"
+
+# Project Paths
+paths:
+  openmanus: "$OPENMANUS_DIR"
+  casibase: "$CASIBASE_DIR"
+  cypher: "$CYPHER_DIR"
+  ai_companion: "$AI_COMPANION_DIR"
+  quantum_vision: "$QUANTUM_VISION_DIR"
+  unified: "$UNIFIED_DIR"
+
+# Integration Settings
+integrations:
+  enable_openmanus: true
+  enable_casibase: true
+  enable_cypher: true
+  enable_ai_companion: true
+  enable_quantum_vision: true
+
+# API Settings
+api:
+  host: "localhost"
+  port: 8080
+  debug: false
+  enable_cors: true
+
+# Database Settings
+database:
+  type: "sqlite" # For development, can be changed to mysql or postgresql
+  path: "$UNIFIED_DIR/data/atlas_unified.db"
+
+# Logging Settings
+logging:
+  level: "info"
+  file: "$UNIFIED_DIR/logs/atlas_unified.log"
+  max_size_mb: 10
+  backup_count: 5
+
+# LLM Integration
+llm:
+  provider: "openai" # Can be openai, anthropic, llama, etc.
+  model: "gpt-4"
+  api_key_env: "OPENAI_API_KEY"
+EOF
+
+# Create the unified bridge script with better error handling and diagnostics
+log_info "Creating unified bridge script..."
+cat > "$UNIFIED_DIR/unified_bridge.py" << EOF
+#!/usr/bin/env python3
+"""
+Atlas Intelligence Unified Bridge
+This script provides a universal bridge between all Atlas Intelligence components.
+"""
+
+import os
+import sys
+import yaml
+import logging
+import traceback
+from pathlib import Path
+from typing import Dict, Any, Optional, Union
+
+# Configure logging first
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger("atlas_unified")
+
+# Setup paths
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+CONFIG_PATH = os.path.join(SCRIPT_DIR, "config", "unified_config.yaml")
+
+# Load configuration with error handling
+try:
+    with open(CONFIG_PATH, "r") as f:
+        config = yaml.safe_load(f)
+    
+    # Now that we have config, setup file logging
+    log_file = config["logging"]["file"]
+    os.makedirs(os.path.dirname(log_file), exist_ok=True)
+    
+    file_handler = logging.FileHandler(log_file)
+    file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+    logger.addHandler(file_handler)
+    
+    logger.setLevel(logging.getLevelName(config["logging"]["level"].upper()))
+except Exception as e:
+    logger.error(f"Failed to load configuration: {e}")
+    logger.error(traceback.format_exc())
+    sys.exit(1)
+
+# Add project paths to Python path with validation
+for key, path in config["paths"].items():
+    if os.path.exists(path):
+        sys.path.append(path)
+        logger.info(f"Added {key} path to system path: {path}")
+    else:
+        logger.warning(f"Path {key} does not exist: {path}")
+
+# Try to import FastAPI with error handling
+try:
+    from fastapi import FastAPI, Request, Response, status
+    from fastapi.middleware.cors import CORSMiddleware
+    import uvicorn
+except ImportError as e:
+    logger.error(f"Failed to import required packages: {e}")
+    logger.error("Please ensure fastapi and uvicorn are installed.")
+    logger.error("Run: pip install fastapi uvicorn")
+    sys.exit(1)
+
+# Initialize FastAPI app
+app = FastAPI(title="Atlas Intelligence Unified API")
+
+# Add CORS middleware
+if config["api"]["enable_cors"]:
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+@app.get("/")
+async def root():
+    """Root endpoint returning welcome message"""
+    return {
+        "message": "Welcome to Atlas Intelligence Unified API",
+        "version": config["version"],
+        "status": "operational"
+    }
+
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    return {"status": "healthy"}
+
+@app.get("/status")
+async def status():
+    """Status endpoint with detailed component information"""
+    components_status = {}
+    
+    # Check OpenManus status
+    if config["integrations"]["enable_openmanus"]:
+        components_status["openmanus"] = check_openmanus_status()
+    else:
+        components_status["openmanus"] = "disabled"
+    
+    # Check QuantumVision status
+    if config["integrations"]["enable_quantum_vision"]:
+        components_status["quantum_vision"] = check_quantum_vision_status()
+    else:
+        components_status["quantum_vision"] = "disabled"
+        
+    # Check Casibase status
+    if config["integrations"]["enable_casibase"]:
+        components_status["casibase"] = check_casibase_status()
+    else:
+        components_status["casibase"] = "disabled"
+    
+    # Check Cypher status
+    if config["integrations"]["enable_cypher"]:
+        components_status["cypher"] = check_cypher_status()
+    else:
+        components_status["cypher"] = "disabled"
+        
+    # Check AI Conversation Companion status
+    if config["integrations"]["enable_ai_companion"]:
+        components_status["ai_companion"] = check_ai_companion_status()
+    else:
+        components_status["ai_companion"] = "disabled"
+    
+    return {
+        "status": "operational",
+        "components": components_status,
+        "version": config["version"]
+    }
+
+def check_openmanus_status() -> str:
+    """Check if OpenManus is available and working"""
+    try:
+        if not os.path.exists(config["paths"]["openmanus"]):
+            return "unavailable (path not found)"
+            
+        # Try importing a key module
+        sys.path.append(config["paths"]["openmanus"])
+        import app.llm as openmanus_llm
+        return "available"
+    except Exception as e:
+        logger.error(f"Failed to check OpenManus: {e}")
+        return f"error: {str(e)}"
+
+def check_quantum_vision_status() -> str:
+    """Check if QuantumVision is available and working"""
+    try:
+        if not os.path.exists(config["paths"]["quantum_vision"]):
+            return "unavailable (path not found)"
+            
+        # Try importing a key module
+        sys.path.append(config["paths"]["quantum_vision"])
+        try:
+            import nlp_processor
+            return "available"
+        except ImportError:
+            # Create simple __init__.py in directory if it doesn't exist
+            if not os.path.exists(f"{config['paths']['quantum_vision']}/__init__.py"):
+                with open(f"{config['paths']['quantum_vision']}/__init__.py", "w") as f:
+                    f.write("# Generated by AtlasUnified installer\n")
+                import nlp_processor
+                return "available (fixed module imports)"
+            return "error: could not import nlp_processor"
+    except Exception as e:
+        logger.error(f"Failed to check QuantumVision: {e}")
+        return f"error: {str(e)}"
+
+def check_casibase_status() -> str:
+    """Check if Casibase is available"""
+    if os.path.exists(config["paths"]["casibase"]):
+        return "path exists (service status unknown)"
+    return "unavailable (path not found)"
+
+def check_cypher_status() -> str:
+    """Check if Cypher is available"""
+    if os.path.exists(config["paths"]["cypher"]):
+        return "path exists (service status unknown)"
+    return "unavailable (path not found)"
+
+def check_ai_companion_status() -> str:
+    """Check if AI Conversation Companion is available"""
+    if os.path.exists(config["paths"]["ai_companion"]):
+        return "path exists (service status unknown)"
+    return "unavailable (path not found)"
+
+@app.post("/query")
+async def query(request: Request, response: Response):
+    """Process a query through available components"""
+    try:
+        data = await request.json()
+    except Exception as e:
+        response.status_code = status.HTTP_400_BAD_REQUEST
+        return {"error": f"Invalid JSON: {str(e)}"}
+        
+    query_text = data.get("query", "")
+    if not query_text:
+        response.status_code = status.HTTP_400_BAD_REQUEST
+        return {"error": "Query text is required"}
+    
+    logger.info(f"Received query: {query_text}")
+    results = {}
+    
+    # Process with OpenManus if enabled
+    if config["integrations"]["enable_openmanus"]:
+        try:
+            sys.path.append(config["paths"]["openmanus"])
+            try:
+                from app.agent import Agent
+                agent = Agent()
+                openmanus_result = agent.run(query_text)
+                results["openmanus"] = openmanus_result
+            except Exception as inner_e:
+                # Fallback to simpler interaction if full agent fails
+                logger.warning(f"Failed to use OpenManus Agent, trying LLM directly: {inner_e}")
+                from app import llm
+                openmanus_result = llm.generate_text(prompt=query_text)
+                results["openmanus"] = {"fallback_response": openmanus_result}
+        except Exception as e:
+            logger.error(f"OpenManus processing error: {e}")
+            logger.error(traceback.format_exc())
+            results["openmanus"] = {"error": str(e)}
+    
+    # Process with Quantum Vision if enabled
+    if config["integrations"]["enable_quantum_vision"]:
+        try:
+            sys.path.append(config["paths"]["quantum_vision"])
+            
+            # Try to import and use nlp_processor
+            try:
+                import nlp_processor
+                processor = nlp_processor.NLPProcessor()
+                quantum_result = processor.process_text(query_text)
+                results["quantum_vision"] = quantum_result
+            except AttributeError:
+                # Fallback to direct OpenAI if NLPProcessor class not found
+                logger.warning("NLPProcessor not found, falling back to OpenAI integration")
+                import openai_integration
+                api_result = openai_integration.process_with_openai(query_text)
+                results["quantum_vision"] = {"fallback_response": api_result}
+        except Exception as e:
+            logger.error(f"Quantum Vision processing error: {e}")
+            logger.error(traceback.format_exc())
+            results["quantum_vision"] = {"error": str(e)}
+    
+    return results
+
+def main():
+    """Run the unified bridge server"""
+    logger.info("Starting Atlas Intelligence Unified Bridge")
+    try:
+        uvicorn.run(
+            "unified_bridge:app", 
+            host=config["api"]["host"], 
+            port=config["api"]["port"],
+            reload=config["api"]["debug"]
+        )
+    except Exception as e:
+        logger.error(f"Failed to start server: {e}")
+        logger.error(traceback.format_exc())
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()
+EOF
+
+# Make the bridge script executable
+chmod +x "$UNIFIED_DIR/unified_bridge.py"
+
+# Create a launch script with improved error handling
+log_info "Creating launch script..."
+cat > "$UNIFIED_DIR/start_unified.sh" << EOF
+#!/bin/bash
+
+# Color codes for better output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+# Check if virtual environment exists
+if [ ! -f "$UNIFIED_DIR/venv/bin/activate" ]; then
+    echo -e "${RED}Error: Virtual environment not found.${NC}"
+    echo -e "${BLUE}Running installation repair...${NC}"
+    
+    # Attempt to fix the virtual environment
+    cd "$UNIFIED_DIR"
+    python3 -m venv venv
+    
+    if [ ! -f "$UNIFIED_DIR/venv/bin/activate" ]; then
+        echo -e "${RED}Failed to create virtual environment. Please run the installation script again.${NC}"
+        exit 1
+    fi
+fi
+
+# Activate the virtual environment
+source "$UNIFIED_DIR/venv/bin/activate" || {
+    echo -e "${RED}Failed to activate virtual environment.${NC}"
+    exit 1
+}
+
+# Check if required packages are installed
+echo -e "${BLUE}Checking required packages...${NC}"
+python -c "import fastapi, uvicorn" &>/dev/null || {
+    echo -e "${YELLOW}Some required packages are missing. Installing...${NC}"
+    pip install fastapi uvicorn pydantic
+}
+
+# Change to the unified directory
+cd "$UNIFIED_DIR" || {
+    echo -e "${RED}Failed to change to unified directory.${NC}"
+    exit 1
+}
+
+# Run the unified bridge
+echo -e "${GREEN}Starting Atlas Intelligence Unified API...${NC}"
+
+if [[ \$1 == "--debug" ]]; then
+    echo -e "${YELLOW}Running in debug mode...${NC}"
+    PYTHONPATH="\$PYTHONPATH:$UNIFIED_DIR" python unified_bridge.py
+else
+    # Run in "production" mode with error logging
+    PYTHONPATH="\$PYTHONPATH:$UNIFIED_DIR" python unified_bridge.py 2> "$UNIFIED_DIR/logs/error.log"
+fi
+EOF
+
+chmod +x "$UNIFIED_DIR/start_unified.sh"
+
+# Create a simple diagnostic tool for troubleshooting
+log_info "Creating diagnostic tool..."
+cat > "$UNIFIED_DIR/diagnose.py" << EOF
+#!/usr/bin/env python3
+"""
+Atlas Intelligence Diagnostic Tool
+Checks if all components are properly configured and working.
+"""
+
+import os
+import sys
+import yaml
+import importlib
+import platform
+import subprocess
+from pathlib import Path
+
+def print_header(text):
+    print(f"\n{'=' * 50}")
+    print(f" {text}")
+    print(f"{'=' * 50}")
+
+def print_success(text):
+    print(f"[✓] {text}")
+
+def print_error(text):
+    print(f"[✗] {text}")
+
+def print_warning(text):
+    print(f"[!] {text}")
+
+def check_python():
+    print_header("Python Environment")
+    print(f"Python version: {platform.python_version()}")
+    print(f"Python executable: {sys.executable}")
+    
+    # Check virtual environment
+    in_venv = sys.prefix != sys.base_prefix
+    if in_venv:
+        print_success(f"Running in virtual environment: {sys.prefix}")
+    else:
+        print_error("Not running in a virtual environment")
+
+def check_core_packages():
+    print_header("Core Python Packages")
+    packages = [
+        "fastapi", "uvicorn", "pydantic", "yaml", "numpy", 
+        "openai", "requests", "flask", "sqlalchemy"
+    ]
+    
+    for package in packages:
+        try:
+            pkg = importlib.import_module(package)
+            version = getattr(pkg, "__version__", "unknown version")
+            print_success(f"{package}: {version}")
+        except ImportError:
+            print_error(f"{package}: Not installed")
+
+def check_components(config):
+    print_header("Component Status")
+    
+    # Check OpenManus
+    if config["integrations"]["enable_openmanus"]:
+        path = config["paths"]["openmanus"]
+        if os.path.exists(path):
+            print_success(f"OpenManus path exists: {path}")
+            # Try to import a key module
+            try:
+                sys.path.append(path)
+                import app.llm
+                print_success("OpenManus modules can be imported")
+            except ImportError as e:
+                print_error(f"Cannot import OpenManus modules: {e}")
+        else:
+            print_error(f"OpenManus path does not exist: {path}")
+    
+    # Check QuantumVision
+    if config["integrations"]["enable_quantum_vision"]:
+        path = config["paths"]["quantum_vision"]
+        if os.path.exists(path):
+            print_success(f"QuantumVision path exists: {path}")
+            # Try to import a key module
+            try:
+                sys.path.append(path)
+                import nlp_processor
+                print_success("QuantumVision modules can be imported")
+            except ImportError as e:
+                print_error(f"Cannot import QuantumVision modules: {e}")
+        else:
+            print_error(f"QuantumVision path does not exist: {path}")
+            
+    # Check Casibase
+    if config["integrations"]["enable_casibase"]:
+        path = config["paths"]["casibase"]
+        if os.path.exists(path):
+            print_success(f"Casibase path exists: {path}")
+        else:
+            print_error(f"Casibase path does not exist: {path}")
+    
+    # Check other components
+    for component in ["cypher", "ai_companion"]:
+        if config["integrations"][f"enable_{component}"]:
+            path = config["paths"][component]
+            if os.path.exists(path):
+                print_success(f"{component} path exists: {path}")
+            else:
+                print_error(f"{component} path does not exist: {path}")
+
+def check_connectivity():
+    print_header("API Connectivity")
+    host = "localhost"
+    port = 8080
+    
+    # Check if something is already running on the port
+    try:
+        import socket
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.settimeout(1)
+        result = s.connect_ex((host, port))
+        if result == 0:
+            print_success(f"Port {port} is open (API may already be running)")
+        else:
+            print_warning(f"Port {port} is not in use (API is not running)")
+        s.close()
+    except Exception as e:
+        print_error(f"Failed to check port: {e}")
+
+def main():
+    print_header("Atlas Intelligence Diagnostic Tool")
+    print(f"Running diagnostics on: {os.path.abspath('.')}")
+    
+    # Check Python environment
+    check_python()
+    
+    # Check core packages
+    check_core_packages()
+    
+    # Load configuration
+    config_path = Path("config/unified_config.yaml")
+    if config_path.exists():
+        try:
+            with open(config_path, "r") as f:
+                config = yaml.safe_load(f)
+            print_success("Configuration loaded successfully")
+            
+            # Check components
+            check_components(config)
+        except Exception as e:
+            print_error(f"Failed to load configuration: {e}")
+    else:
+        print_error(f"Configuration file not found: {config_path}")
+    
+    # Check connectivity
+    check_connectivity()
+    
+    print_header("Diagnostic Complete")
+    print("To start the API server, run: ./start_unified.sh")
+    print("For detailed logs, check the logs directory")
+
+if __name__ == "__main__":
+    main()
+EOF
+
+chmod +x "$UNIFIED_DIR/diagnose.py"
+
+# Create a repair script for common issues
+log_info "Creating repair script..."
+cat > "$UNIFIED_DIR/repair.sh" << EOF
+#!/bin/bash
+
+# Color codes for better output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}==============================================${NC}"
+echo -e "${BLUE}     Atlas Intelligence Repair Tool          ${NC}"
+echo -e "${BLUE}==============================================${NC}"
+
+# Check if running in the correct directory
+if [ ! -f "./config/unified_config.yaml" ]; then
+    echo -e "${RED}Error: Run this script from the AtlasUnified directory.${NC}"
+    exit 1
+fi
+
+# Repair virtual environment
+echo -e "${BLUE}Repairing virtual environment...${NC}"
+rm -rf ./venv
+python3 -m venv venv
+source ./venv/bin/activate
+
+# Install core dependencies
+echo -e "${BLUE}Installing core dependencies...${NC}"
+pip install --upgrade pip wheel setuptools
+pip install fastapi uvicorn pydantic pyyaml numpy
+pip install openai requests flask sqlalchemy
+
+# Fix permissions
+echo -e "${BLUE}Fixing permissions...${NC}"
+chmod +x ./unified_bridge.py
+chmod +x ./start_unified.sh
+chmod +x ./diagnose.py
+
+# Create any missing directories
+echo -e "${BLUE}Creating missing directories...${NC}"
+mkdir -p ./logs
+mkdir -p ./data
+
+# Run diagnostics
+echo -e "${BLUE}Running diagnostics...${NC}"
+python ./diagnose.py
+
+echo -e "${GREEN}Repair complete. You can now run ./start_unified.sh${NC}"
+EOF
+
+chmod +x "$UNIFIED_DIR/repair.sh"
+
+# Make sure we're back in the original directory
+cd "$QUANTUM_VISION_DIR"
+
+log_success "Installation complete!"
+log_info "=============================================="
+log_info "To start the unified system, run:"
+log_success "cd $UNIFIED_DIR && ./start_unified.sh"
+log_info "=============================================="
+log_info "For diagnostics and troubleshooting:"
+log_success "cd $UNIFIED_DIR && python diagnose.py"
+log_info "=============================================="
+log_info "To repair the installation if needed:"
+log_success "cd $UNIFIED_DIR && ./repair.sh"
+log_info "=============================================="
+log_info "The unified API will be available at:"
+log_success "http://localhost:8080"
+log_info "=============================================="
+log_info "Installation log saved to: $LOG_FILE"
+log_info "=============================================="

install_atlas_unified.sh

@@ -0,0 +1,329 @@
+#!/bin/bash
+
+# Atlas Unified Platform Installation Script
+# This script installs all components needed for Atlas Intelligence Platform
+
+# Terminal colors
+CYAN='\033[0;36m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+RESET='\033[0m'
+
+# Utility functions
+log() {
+    echo -e "${CYAN}[INFO]${RESET} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${RESET} $1"
+}
+
+log_warning() {
+    echo -e "${YELLOW}[WARNING]${RESET} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${RESET} $1"
+}
+
+check_command() {
+    if ! command -v "$1" &> /dev/null; then
+        log_error "$1 could not be found. Please install it first."
+        return 1
+    fi
+    return 0
+}
+
+# Base directory
+BASE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# Modified to use actual directory paths as seen in the workspace structure
+PARENT_DIR_OM="/Users/lattm"
+PARENT_DIR_OTHERS="/Users/lattm"
+PARENT_DIR_CLOUD="/Users/lattm/Library/Mobile Documents/com~apple~CloudDocs/Atlas Business"
+
+# Check required tools
+check_command "python3" || exit 1
+check_command "pip3" || exit 1
+check_command "node" || exit 1
+check_command "npm" || exit 1
+
+# Create logs directory
+mkdir -p "$BASE_DIR/logs"
+mkdir -p "$BASE_DIR/pids"
+
+# Function to install OpenManus
+install_openmanus() {
+    log "Installing OpenManus..."
+    OPENMANUS_DIR="$PARENT_DIR_OM/OpenManus"
+    
+    # Check if directory exists
+    if [ ! -d "$OPENMANUS_DIR" ]; then
+        log_error "OpenManus directory not found at: $OPENMANUS_DIR"
+        return 1
+    fi
+    
+    cd "$OPENMANUS_DIR" || exit
+    
+    # Create and activate virtual environment if it doesn't exist
+    if [ ! -d "openmanus_env" ]; then
+        python3 -m venv openmanus_env
+    fi
+    source openmanus_env/bin/activate
+    
+    # Install dependencies
+    pip install -r requirements.txt
+    pip install -e .
+    
+    # Additional dependencies for MCP server
+    pip install fastapi uvicorn pydantic typing-extensions
+
+    log_success "OpenManus installation completed"
+    
+    # Deactivate virtual environment
+    deactivate
+}
+
+# Function to install Casibase
+install_casibase() {
+    log "Installing Casibase..."
+    CASIBASE_DIR="$PARENT_DIR_OTHERS/casibase"
+    
+    # Check if directory exists
+    if [ ! -d "$CASIBASE_DIR" ]; then
+        log_error "Casibase directory not found at: $CASIBASE_DIR"
+        return 1
+    fi
+    
+    cd "$CASIBASE_DIR" || exit
+    
+    # Build Casibase if server doesn't exist
+    if [ ! -f "./server" ]; then
+        ./build.sh
+    fi
+    
+    log_success "Casibase installation completed"
+}
+
+# Function to install Cypher
+install_cypher() {
+    log "Installing Cypher..."
+    CYPHER_DIR="$PARENT_DIR_OTHERS/Cypher"
+    
+    # Check if directory exists
+    if [ ! -d "$CYPHER_DIR" ]; then
+        log_error "Cypher directory not found at: $CYPHER_DIR"
+        return 1
+    fi
+    
+    cd "$CYPHER_DIR" || exit
+    
+    # Install Python dependencies
+    pip3 install -r requirements.txt
+    
+    log_success "Cypher installation completed"
+}
+
+# Function to install QuantumVision
+install_quantumvision() {
+    log "Installing QuantumVision..."
+    QUANTUM_DIR="$BASE_DIR"
+    
+    cd "$QUANTUM_DIR" || exit
+    
+    # Install Python dependencies
+    pip3 install -r requirements.txt
+    
+    # Install additional dependencies
+    pip3 install fastapi uvicorn pydantic typing-extensions openai langchain transformers torch numpy pandas scikit-learn matplotlib seaborn
+    
+    log_success "QuantumVision installation completed"
+}
+
+# Function to install AIConversationCompanion
+install_conversation_companion() {
+    log "Installing AIConversationCompanion..."
+    CONVERSATION_DIR="$PARENT_DIR_CLOUD/AIConversationCompanion"
+    
+    # Make sure directory exists
+    if [ ! -d "$CONVERSATION_DIR" ]; then
+        log_error "AIConversationCompanion directory not found at: $CONVERSATION_DIR"
+        return 1
+    fi
+    
+    cd "$CONVERSATION_DIR" || exit
+    
+    # Install server dependencies
+    cd ./server || exit
+    npm install
+    
+    # Install client dependencies
+    cd ../client || exit
+    npm install
+    
+    cd "$CONVERSATION_DIR" || exit
+    
+    log_success "AIConversationCompanion installation completed"
+    return 0
+}
+
+# Function to install Atlas Unified Bridge
+install_unified_bridge() {
+    log "Installing Atlas Unified Bridge..."
+    BRIDGE_DIR="$BASE_DIR/atlas_bridge"
+    
+    # Create bridge directory if not exists
+    mkdir -p "$BRIDGE_DIR"
+    
+    cd "$BRIDGE_DIR" || exit
+    
+    # Create bridge server file
+    cat > bridge_server.py << 'EOL'
+#!/usr/bin/env python3
+"""
+Atlas Unified Bridge Server
+This server connects all Atlas platform components together
+"""
+
+import os
+import sys
+import json
+import time
+import logging
+import requests
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import uvicorn
+from pydantic import BaseModel
+from typing import Dict, List, Any, Optional
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("bridge_server.log")
+    ]
+)
+logger = logging.getLogger("atlas_bridge")
+
+# Component endpoints
+OPENMANUS_ENDPOINT = "http://localhost:50505"
+CASIBASE_ENDPOINT = "http://localhost:7777"
+CYPHER_ENDPOINT = "http://localhost:5000"
+QUANTUMVISION_ENDPOINT = "http://localhost:8000"
+CONVERSATION_ENDPOINT = "http://localhost:8001"
+
+# Initialize FastAPI app
+app = FastAPI(title="Atlas Unified Bridge")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Health check endpoint
+@app.get("/health")
+async def health_check():
+    """Health check endpoint to verify if bridge server is running"""
+    status = {
+        "bridge": "operational",
+        "components": {
+            "openmanus": check_component_health(OPENMANUS_ENDPOINT),
+            "casibase": check_component_health(CASIBASE_ENDPOINT),
+            "cypher": check_component_health(CYPHER_ENDPOINT),
+            "quantumvision": check_component_health(QUANTUMVISION_ENDPOINT),
+            "conversation": check_component_health(CONVERSATION_ENDPOINT)
+        },
+        "timestamp": time.time()
+    }
+    return status
+
+def check_component_health(endpoint: str) -> str:
+    """Check if a component is operational"""
+    try:
+        response = requests.get(f"{endpoint}/health", timeout=3)
+        if response.status_code == 200:
+            return "operational"
+    except:
+        pass
+    return "unavailable"
+
+# Main entry point
+if __name__ == "__main__":
+    logger.info("Starting Atlas Unified Bridge Server")
+    uvicorn.run("bridge_server:app", host="0.0.0.0", port=8080, reload=True)
+EOL
+    
+    # Create requirements.txt for the bridge
+    cat > requirements.txt << 'EOL'
+fastapi>=0.103.1
+uvicorn>=0.23.2
+requests>=2.31.0
+pydantic>=2.3.0
+python-multipart>=0.0.6
+EOL
+    
+    # Install bridge dependencies
+    pip3 install -r requirements.txt
+    
+    log_success "Atlas Unified Bridge installation completed"
+}
+
+# Create a requirements.txt file for QuantumVision if it doesn't exist
+create_quantum_requirements() {
+    QUANTUM_REQ="$BASE_DIR/requirements.txt"
+    
+    if [ ! -f "$QUANTUM_REQ" ]; then
+        log "Creating QuantumVision requirements file..."
+        cat > "$QUANTUM_REQ" << 'EOL'
+fastapi>=0.103.1
+uvicorn>=0.23.2
+pydantic>=2.3.0
+numpy>=1.24.0
+pandas>=2.0.0
+scikit-learn>=1.3.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+torch>=2.0.0
+transformers>=4.35.0
+openai>=1.0.0
+langchain>=0.0.267
+requests>=2.31.0
+python-dotenv>=1.0.0
+pytest>=7.4.0
+EOL
+        log_success "Requirements file created"
+    fi
+}
+
+# Main installation procedure
+log "Starting Atlas Unified Platform installation..."
+
+# Create requirements file for QuantumVision
+create_quantum_requirements
+
+# Install all components
+install_openmanus
+install_casibase
+install_cypher
+install_quantumvision
+install_conversation_companion
+install_unified_bridge
+
+# Set executable permissions
+chmod +x "$BASE_DIR/start_atlas.sh"
+chmod +x "$BASE_DIR/start_atlas_unified.sh"
+
+log_success "Atlas Unified Platform installation completed"
+log "You can now start the platform using: $BASE_DIR/start_atlas_unified.sh"
+
+# Log the installation
+date > "$BASE_DIR/install_log.txt"
+echo "Atlas Unified Platform installed successfully" >> "$BASE_DIR/install_log.txt"

install_log.txt

@@ -0,0 +1,2 @@
+Thu Apr 17 12:22:40 CDT 2025
+Atlas Unified Platform installed successfully

layout.html

@@ -0,0 +1,135 @@
+<!DOCTYPE html>
+<html lang="en" data-bs-theme="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Quantum NLP Framework</title>
+    <!-- Replit-themed Bootstrap CSS -->
+    <link rel="stylesheet" href="https://cdn.replit.com/agent/bootstrap-agent-dark-theme.min.css">
+    <!-- Custom CSS -->
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <!-- Animation CSS -->
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/animations.css') }}">
+    <!-- Contextual Hints CSS -->
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/contextual_hints.css') }}">
+    <!-- Font Awesome for icons -->
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
+</head>
+<body class="{% if request.environ.get('OPENAI_API_KEY') %}has-openai-key{% endif %}">
+    <!-- Quantum Pyramid LED Tracer Background -->
+    <div class="quantum-tracer">
+        <img src="{{ url_for('static', filename='images/quantum-bg.svg') }}" alt="" style="position: fixed; width: 100%; height: 100%; opacity: 0.5; pointer-events: none;">
+    </div>
+    <nav class="navbar navbar-expand-lg glass-card">
+        <div class="container">
+            <a class="navbar-brand" href="/">
+                <i class="fas fa-atom me-2 quantum-spin"></i>
+                <span class="fw-bold">Quantum</span> NLP Framework
+            </a>
+            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav">
+                <span class="navbar-toggler-icon"></span>
+            </button>
+            <div class="collapse navbar-collapse" id="navbarNav">
+                <ul class="navbar-nav ms-auto">
+                    <li class="nav-item">
+                        <a class="nav-link glow-hover" href="/"><i class="fas fa-home me-1"></i> Home</a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link glow-hover" href="/zap-integrations">
+                            <i class="fas fa-bolt me-1"></i> ZAP Integrations
+                        </a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link glow-hover" href="/automation-workflow">
+                            <i class="fas fa-cogs me-1"></i> Automation Workflow
+                        </a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link glow-hover" href="/settings">
+                            <i class="fas fa-sliders-h me-1"></i> Settings
+                        </a>
+                    </li>
+                    <li class="nav-item">
+                        <a class="nav-link glow-hover" href="https://github.com/yourusername/quantum-nlp-framework" target="_blank">
+                            <i class="fab fa-github me-1"></i> GitHub
+                        </a>
+                    </li>
+                </ul>
+            </div>
+        </div>
+    </nav>
+
+    <main class="container my-4">
+        <!-- Flash messages -->
+        {% with messages = get_flashed_messages(with_categories=true) %}
+            {% if messages %}
+                {% for category, message in messages %}
+                    <div class="alert alert-{{ category }} alert-dismissible fade show" role="alert">
+                        {{ message }}
+                        <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
+                    </div>
+                {% endfor %}
+            {% endif %}
+        {% endwith %}
+
+        <!-- Main content -->
+        {% block content %}{% endblock %}
+    </main>
+
+    <footer class="glass-card py-4 mt-5">
+        <div class="container">
+            <div class="row">
+                <div class="col-md-6">
+                    <h5><i class="fas fa-atom me-2 quantum-spin"></i> <span class="fw-bold">Quantum</span> NLP Framework</h5>
+                    <p>A multi-dimensional, layered thinking process inspired by quantum computing concepts.</p>
+                    <div class="vision-progress">
+                        <div class="vision-progress-bar"></div>
+                    </div>
+                </div>
+                <div class="col-md-3">
+                    <h5 class="quantum-glow">Resources</h5>
+                    <ul class="list-unstyled">
+                        <li><a href="https://spacy.io" target="_blank" class="text-light glow-hover">spaCy Documentation</a></li>
+                        <li><a href="https://platform.openai.com/docs" target="_blank" class="text-light glow-hover">OpenAI API</a></li>
+                        <li><a href="https://flask.palletsprojects.com" target="_blank" class="text-light glow-hover">Flask Docs</a></li>
+                    </ul>
+                </div>
+                <div class="col-md-3">
+                    <h5 class="quantum-glow">About</h5>
+                    <p>Open-source and free quantum-inspired NLP framework for Replit.</p>
+                </div>
+            </div>
+            <div class="text-center mt-4">
+                <p class="mb-0">© 2025 Quantum NLP Framework. Open Source under MIT License.</p>
+            </div>
+        </div>
+    </footer>
+
+    <!-- Canvas for particle animations -->
+    <canvas id="quantum-particles" class="particle-canvas" style="display: none;"></canvas>
+    
+    <!-- Quantum loading overlay -->
+    <div id="quantum-overlay">
+        <div class="quantum-loader">
+            <div class="quantum-spinner">
+                <div class="q-orbit q-orbit-1"></div>
+                <div class="q-orbit q-orbit-2"></div>
+                <div class="q-orbit q-orbit-3"></div>
+                <div class="q-core"></div>
+            </div>
+            <div class="quantum-message">Quantum Dimensional Processing</div>
+        </div>
+    </div>
+
+    <!-- Bootstrap JS Bundle with Popper -->
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
+    <!-- Custom JS -->
+    <script src="{{ url_for('static', filename='js/main.js') }}"></script>
+    <!-- Animation JS -->
+    <script src="{{ url_for('static', filename='js/animations.js') }}"></script>
+    <!-- Contextual Hints JS -->
+    <script src="{{ url_for('static', filename='js/contextual_hints.js') }}"></script>
+    <!-- Page-specific scripts -->
+    {% block scripts %}{% endblock %}
+</body>
+</html>

main.js

@@ -0,0 +1,269 @@
+// Main JavaScript file for the Quantum NLP Framework
+
+document.addEventListener('DOMContentLoaded', function() {
+    // Show loading state on form submission
+    const form = document.getElementById('process-form');
+    const analyzeBtn = document.getElementById('analyze-btn');
+    
+    if (form) {
+        form.addEventListener('submit', function() {
+            if (analyzeBtn) {
+                // Disable button and show loading state
+                analyzeBtn.disabled = true;
+                analyzeBtn.innerHTML = '<i class="fas fa-atom fa-spin me-2"></i> Processing...';
+                
+                // Trigger quantum transition animation if available
+                if (typeof showQuantumTransition === 'function') {
+                    showQuantumTransition();
+                }
+            }
+        });
+    }
+    
+    // Add hover effects to analyze button if present
+    if (analyzeBtn) {
+        analyzeBtn.addEventListener('mouseover', function() {
+            // Add hover class for CSS effects
+            this.classList.add('quantum-btn-hover');
+            
+            // Trigger particle effect if available
+            if (typeof triggerSmallParticleEffect === 'function') {
+                triggerSmallParticleEffect(this);
+            }
+        });
+        
+        analyzeBtn.addEventListener('mouseout', function() {
+            this.classList.remove('quantum-btn-hover');
+        });
+    }
+    
+    // Initialize tooltips
+    const tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'));
+    tooltipTriggerList.map(function(tooltipTriggerEl) {
+        return new bootstrap.Tooltip(tooltipTriggerEl);
+    });
+    
+    // Initialize text-to-vision transitions
+    initTextToVisionTransitions();
+    
+    // Check for results container and apply entrance animations
+    const resultsContainer = document.getElementById('results-container');
+    if (resultsContainer && resultsContainer.children.length > 0) {
+        applyResultsAnimations(resultsContainer);
+    }
+    
+    // Highlight entities in text (if applicable)
+    highlightEntities();
+    
+    // Check if OpenAI key is available for contextual hints
+    const hasOpenaiKey = document.body.classList.contains('has-openai-key');
+    if (!hasOpenaiKey && typeof window.contextualHintSystem !== 'undefined') {
+        setTimeout(() => {
+            const settingsLink = document.querySelector('a[href="/settings"]');
+            if (settingsLink) {
+                window.contextualHintSystem.registerHint('openai-key-needed', {
+                    title: 'OpenAI API Key Needed',
+                    content: 'For enhanced AI-powered analysis, add your OpenAI API key in Settings. Without it, the system uses local fallback processing.',
+                    position: 'bottom',
+                    selector: 'a[href="/settings"]',
+                    icon: 'fas fa-key',
+                    important: true,
+                    maxShows: 2,
+                    buttonText: 'Go to Settings'
+                });
+                window.contextualHintSystem.considerShowingHint('openai-key-needed', settingsLink);
+            }
+        }, 2000);
+    }
+});
+
+/**
+ * Initialize text-to-vision transitions with staggered timing
+ */
+function initTextToVisionTransitions() {
+    const visionElements = document.querySelectorAll('.text-to-vision');
+    visionElements.forEach((elem, index) => {
+        // Add a staggered delay for smoother visual effect
+        const delay = 300 + (index * 150);
+        setTimeout(() => {
+            elem.classList.add('text-to-vision-active');
+            
+            // Reset the animation after it completes to allow replaying
+            setTimeout(() => {
+                elem.classList.remove('text-to-vision-active');
+            }, 1500);
+        }, delay);
+    });
+}
+
+/**
+ * Apply animations to results container
+ */
+function applyResultsAnimations(container) {
+    // Add entrance animation
+    container.style.opacity = '0';
+    container.style.transform = 'translateY(20px)';
+    
+    setTimeout(() => {
+        container.style.transition = 'opacity 0.5s ease, transform 0.5s ease';
+        container.style.opacity = '1';
+        container.style.transform = 'translateY(0)';
+        
+        // Apply the quantum-reveal class to each card with staggered timing
+        const cards = container.querySelectorAll('.quantum-card');
+        cards.forEach((card, index) => {
+            setTimeout(() => {
+                card.classList.add('quantum-reveal');
+            }, 300 + (index * 150));
+        });
+    }, 200);
+}
+
+/**
+ * Highlight named entities in the displayed text
+ */
+function highlightEntities() {
+    // First try the data-entities method
+    const entityContainers = document.querySelectorAll('.highlight-entities');
+    
+    entityContainers.forEach(function(element) {
+        let html = element.innerHTML;
+        const entities = JSON.parse(element.dataset.entities || '[]');
+        
+        // Sort entities by start position in descending order
+        // to avoid offset issues when replacing text
+        entities.sort((a, b) => b.start - a.start);
+        
+        // Replace each entity with highlighted version
+        entities.forEach(function(entity) {
+            const entityText = html.substring(entity.start, entity.end);
+            const replacement = `<span class="entity entity-${entity.label.toLowerCase()}" 
+                                title="${entity.label}">${entityText}</span>`;
+            
+            html = html.substring(0, entity.start) + replacement + html.substring(entity.end);
+        });
+        
+        element.innerHTML = html;
+    });
+    
+    // Add special effects to entity items in lists
+    const entityItems = document.querySelectorAll('.list-group-item:has(.badge.bg-success)');
+    
+    entityItems.forEach(item => {
+        // Extract entity text from the item
+        const entityText = item.textContent.split(/\s+/)[0].trim();
+        const entityType = item.querySelector('.badge')?.textContent || '';
+        
+        // Add quantum hover effects
+        item.classList.add('quantum-entity-item');
+        
+        // Handle hover effects
+        item.addEventListener('mouseover', function() {
+            this.style.backgroundColor = 'rgba(66, 133, 244, 0.1)';
+            this.style.boxShadow = '0 0 10px rgba(66, 133, 244, 0.3)';
+            this.style.transform = 'translateX(5px)';
+            
+            // Create particle effect if the function is available
+            if (typeof triggerSmallParticleEffect === 'function') {
+                triggerSmallParticleEffect(this, 3, 0.3);
+            }
+        });
+        
+        item.addEventListener('mouseout', function() {
+            this.style.backgroundColor = '';
+            this.style.boxShadow = '';
+            this.style.transform = '';
+        });
+        
+        // Try to find and highlight the entity in the original text 
+        highlightEntityInInput(entityText);
+    });
+}
+
+/**
+ * Highlight an entity in the input text area
+ */
+function highlightEntityInInput(entityText) {
+    const textArea = document.getElementById('input_text');
+    if (!textArea || !entityText) return;
+    
+    const text = textArea.value;
+    if (!text) return;
+    
+    // Check if the entity is in the text
+    const regex = new RegExp(`\\b${entityText}\\b`, 'gi');
+    if (!regex.test(text)) return;
+    
+    // We can't highlight directly in textarea, so we can add a custom tooltip
+    // or create a special view mode that shows the marked-up text
+    
+    // For now, we'll just add a subtle animation to the textarea
+    textArea.classList.add('has-entities');
+    
+    // Create a glowing effect in the textarea
+    const glowEffect = document.createElement('div');
+    glowEffect.className = 'textarea-glow';
+    glowEffect.style.position = 'absolute';
+    glowEffect.style.top = '0';
+    glowEffect.style.left = '0';
+    glowEffect.style.width = '100%';
+    glowEffect.style.height = '100%';
+    glowEffect.style.pointerEvents = 'none';
+    glowEffect.style.boxShadow = 'inset 0 0 15px rgba(66, 133, 244, 0.3)';
+    glowEffect.style.opacity = '0';
+    glowEffect.style.transition = 'opacity 0.5s ease';
+    
+    // Add glow effect as sibling to textarea with relative positioning
+    const parent = textArea.parentElement;
+    parent.style.position = 'relative';
+    parent.appendChild(glowEffect);
+    
+    // Show the glow effect
+    setTimeout(() => {
+        glowEffect.style.opacity = '1';
+    }, 300);
+    
+    // Hide after 2 seconds
+    setTimeout(() => {
+        glowEffect.style.opacity = '0';
+        
+        // Remove after fade out
+        setTimeout(() => {
+            glowEffect.remove();
+        }, 500);
+    }, 2000);
+}
+
+/**
+ * Create a basic visualization of quantum score
+ */
+function visualizeQuantumScore(elementId, score) {
+    if (!elementId) return;
+    
+    const element = document.getElementById(elementId);
+    if (!element) return;
+    
+    // Create a simple bar visualization
+    const width = score * 100;
+    const color = getColorForScore(score);
+    
+    element.innerHTML = `
+        <div class="progress">
+            <div class="progress-bar" role="progressbar" 
+                style="width: ${width}%; background-color: ${color};" 
+                aria-valuenow="${score * 100}" aria-valuemin="0" aria-valuemax="100">
+                ${(score * 100).toFixed(0)}%
+            </div>
+        </div>
+    `;
+}
+
+/**
+ * Get color based on score value
+ */
+function getColorForScore(score) {
+    if (score < 0.3) return '#dc3545'; // Low - red
+    if (score < 0.6) return '#ffc107'; // Medium - yellow
+    if (score < 0.8) return '#0dcaf0'; // Good - cyan
+    return '#198754'; // High - green
+}

main.py

@@ -0,0 +1,4 @@
+from app import app
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=5000, debug=True)

models.py

@@ -0,0 +1,55 @@
+from datetime import datetime
+from app import db
+
+
+class Task(db.Model):
+    """Model for storing workflow tasks and scheduled activities"""
+    id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.String(100), nullable=False)
+    description = db.Column(db.Text)
+    status = db.Column(db.String(20), default='pending')  # pending, in_progress, completed, failed
+    priority = db.Column(db.Integer, default=1)  # 1 (low) to 5 (high)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    scheduled_for = db.Column(db.DateTime, nullable=True)
+    completed_at = db.Column(db.DateTime, nullable=True)
+    task_type = db.Column(db.String(50))  # web_scrape, analyze, schedule, etc.
+    
+    # For recursive task dependencies
+    parent_id = db.Column(db.Integer, db.ForeignKey('task.id'), nullable=True)
+    parent = db.relationship('Task', remote_side=[id], backref=db.backref('subtasks', lazy='dynamic'))
+    
+    # Metadata for storing task configuration and results
+    config = db.Column(db.JSON, nullable=True)
+    result = db.Column(db.JSON, nullable=True)
+    
+    def __repr__(self):
+        return f'<Task {self.id}: {self.title}>'
+
+
+class WebResource(db.Model):
+    """Model for storing web resources for browser automation"""
+    id = db.Column(db.Integer, primary_key=True)
+    url = db.Column(db.String(500), nullable=False)
+    title = db.Column(db.String(200))
+    category = db.Column(db.String(50))
+    last_accessed = db.Column(db.DateTime, nullable=True)
+    content_hash = db.Column(db.String(64), nullable=True)  # To detect changes
+    
+    # Relationship with tasks
+    task_id = db.Column(db.Integer, db.ForeignKey('task.id'), nullable=True)
+    task = db.relationship('Task', backref=db.backref('web_resources', lazy='dynamic'))
+    
+    def __repr__(self):
+        return f'<WebResource {self.id}: {self.title}>'
+
+
+class WorkflowTemplate(db.Model):
+    """Model for storing reusable workflow templates"""
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(100), nullable=False)
+    description = db.Column(db.Text)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    steps = db.Column(db.JSON, nullable=False)  # Array of workflow steps
+    
+    def __repr__(self):
+        return f'<WorkflowTemplate {self.id}: {self.name}>'

nlp_processor.py

@@ -0,0 +1,325 @@
+"""
+NLP Processing module that uses spaCy to analyze and process text.
+With fallback to Ollama Llama 3 and LM Studio.
+"""
+import logging
+import json
+import requests
+from typing import Dict, Any, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+# Ollama settings
+OLLAMA_URL = "http://localhost:11434/api/generate"
+OLLAMA_MODEL = "llama3"
+
+# LM Studio fallback settings
+LM_STUDIO_URL = "http://localhost:1234/v1"
+
+def process_text(nlp, text):
+    """
+    Process text using spaCy NLP.
+    
+    Args:
+        nlp: The loaded spaCy NLP model
+        text: Text string to process
+        
+    Returns:
+        dict: Results of NLP processing
+    """
+    try:
+        logger.debug(f"Processing text with spaCy: {text[:50]}...")
+        
+        # Process the text with spaCy
+        doc = nlp(text)
+        
+        # Extract named entities
+        entities = [{
+            'text': ent.text,
+            'label': ent.label_,
+            'start': ent.start_char,
+            'end': ent.end_char
+        } for ent in doc.ents]
+        
+        # Extract noun chunks (phrases)
+        noun_chunks = [chunk.text for chunk in doc.noun_chunks]
+        
+        # Get part-of-speech tags for each token
+        tokens = [{
+            'text': token.text,
+            'lemma': token.lemma_,
+            'pos': token.pos_,
+            'tag': token.tag_,
+            'dep': token.dep_,
+            'is_stop': token.is_stop
+        } for token in doc]
+        
+        # Get sentence boundaries
+        sentences = [sent.text for sent in doc.sents]
+        
+        # Calculate text statistics
+        word_count = len([token for token in doc if not token.is_punct and not token.is_space])
+        sentence_count = len(list(doc.sents))
+        average_sentence_length = word_count / sentence_count if sentence_count > 0 else 0
+        
+        # Calculate token frequencies
+        token_freq = {}
+        for token in doc:
+            if not token.is_punct and not token.is_space and not token.is_stop:
+                if token.lemma_ in token_freq:
+                    token_freq[token.lemma_] += 1
+                else:
+                    token_freq[token.lemma_] = 1
+        
+        # Sort frequencies and get top terms
+        sorted_freq = sorted(token_freq.items(), key=lambda x: x[1], reverse=True)
+        top_terms = sorted_freq[:10]
+        
+        # Prepare results dictionary
+        results = {
+            'entities': entities,
+            'noun_chunks': noun_chunks,
+            'tokens': tokens,
+            'sentences': sentences,
+            'stats': {
+                'word_count': word_count,
+                'sentence_count': sentence_count,
+                'average_sentence_length': round(average_sentence_length, 2)
+            },
+            'top_terms': top_terms
+        }
+        
+        return results
+        
+    except Exception as e:
+        logger.error(f"Error in NLP processing: {str(e)}")
+        return {
+            'error': str(e),
+            'entities': [],
+            'noun_chunks': [],
+            'tokens': [],
+            'sentences': [text],
+            'stats': {
+                'word_count': len(text.split()),
+                'sentence_count': 1,
+                'average_sentence_length': len(text.split())
+            },
+            'top_terms': []
+        }
+
+def process_with_ollama(text: str) -> Dict[str, Any]:
+    """
+    Process text using Ollama Llama 3 model.
+    
+    Args:
+        text: Text string to process
+        
+    Returns:
+        dict: Results from Ollama processing
+    """
+    try:
+        logger.info(f"Processing with Ollama Llama 3: {text[:50]}...")
+        
+        # Prepare the prompt
+        prompt = f"""Analyze the following text and provide insights:
+Text: "{text}"
+
+Please provide:
+1. A summary of the main points
+2. Key entities mentioned
+3. Sentiment analysis (positive, negative, or neutral)
+4. Any actions or requests mentioned
+"""
+        
+        # Call Ollama API
+        payload = {
+            "model": OLLAMA_MODEL,
+            "prompt": prompt,
+            "stream": False
+        }
+        
+        response = requests.post(OLLAMA_URL, json=payload, timeout=30)
+        response.raise_for_status()
+        
+        result = response.json()
+        
+        # Extract the response
+        return {
+            "ollama_response": result.get("response", ""),
+            "processing_type": "ollama_llama3",
+            "prompt_tokens": result.get("prompt_eval_count", 0),
+            "completion_tokens": result.get("eval_count", 0),
+            "total_duration": result.get("total_duration", 0)
+        }
+        
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error connecting to Ollama: {e}")
+        return {
+            "error": f"Ollama service error: {str(e)}",
+            "processing_type": "ollama_failed"
+        }
+    except Exception as e:
+        logger.error(f"Unexpected error in Ollama processing: {str(e)}")
+        return {
+            "error": f"Unexpected error: {str(e)}",
+            "processing_type": "ollama_error"
+        }
+
+def process_with_lm_studio(text: str) -> Dict[str, Any]:
+    """
+    Process text using LM Studio as a fallback.
+    
+    Args:
+        text: Text string to process
+        
+    Returns:
+        dict: Results from LM Studio processing
+    """
+    try:
+        logger.info(f"Falling back to LM Studio: {text[:50]}...")
+        
+        # Prepare the prompt similar to OpenManus approach
+        prompt = f"Analyze this text: {text}"
+        
+        # Call LM Studio API
+        headers = {
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "prompt": prompt,
+            "max_tokens": 500,
+            "temperature": 0.7
+        }
+        
+        response = requests.post(
+            f"{LM_STUDIO_URL}/completions", 
+            headers=headers,
+            json=payload,
+            timeout=30
+        )
+        response.raise_for_status()
+        
+        result = response.json()
+        
+        return {
+            "lm_studio_response": result.get("choices", [{}])[0].get("text", ""),
+            "processing_type": "lm_studio_fallback"
+        }
+        
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error connecting to LM Studio: {e}")
+        return {
+            "error": f"LM Studio service error: {str(e)}",
+            "processing_type": "lm_studio_failed"
+        }
+    except Exception as e:
+        logger.error(f"Unexpected error in LM Studio processing: {str(e)}")
+        return {
+            "error": f"Unexpected error: {str(e)}",
+            "processing_type": "lm_studio_error"
+        }
+
+def enhanced_process_text(text: str) -> Dict[str, Any]:
+    """
+    Process text with multiple fallback methods.
+    First tries spaCy NLP, then Ollama Llama 3, then LM Studio.
+    
+    Args:
+        text: Text string to process
+        
+    Returns:
+        dict: Combined results from available processing methods
+    """
+    results = {}
+    spacy_success = False
+    
+    # First try spaCy
+    try:
+        import spacy
+        try:
+            nlp = spacy.load("en_core_web_sm")
+        except:
+            nlp = spacy.blank("en")
+        
+        spacy_results = process_text(nlp, text)
+        results["spacy"] = spacy_results
+        spacy_success = "error" not in spacy_results
+    except ImportError:
+        logger.warning("spaCy not available")
+        results["spacy"] = {"error": "spaCy not installed or available"}
+    
+    # Try Ollama Llama 3 (regardless of spaCy success)
+    try:
+        ollama_results = process_with_ollama(text)
+        results["ollama"] = ollama_results
+        
+        # If we got a clear error from Ollama, try LM Studio
+        if "error" in ollama_results:
+            lm_studio_results = process_with_lm_studio(text)
+            results["lm_studio"] = lm_studio_results
+    except Exception as e:
+        logger.error(f"Error in Ollama processing: {e}")
+        results["ollama"] = {"error": str(e)}
+        
+        # Try LM Studio as final fallback
+        try:
+            lm_studio_results = process_with_lm_studio(text)
+            results["lm_studio"] = lm_studio_results
+        except Exception as lm_e:
+            logger.error(f"Error in LM Studio fallback: {lm_e}")
+            results["lm_studio"] = {"error": str(lm_e)}
+    
+    # Generate a simplified response
+    simple_response = generate_simple_response(results)
+    results["simple_response"] = simple_response
+    
+    return results
+
+def generate_simple_response(results: Dict[str, Any]) -> str:
+    """
+    Generate a simple, user-friendly response from the processing results.
+    
+    Args:
+        results: The combined processing results
+        
+    Returns:
+        str: A simplified response for the user
+    """
+    # First try to get a response from Ollama
+    if "ollama" in results and "error" not in results["ollama"]:
+        return results["ollama"].get("ollama_response", "")
+    
+    # Fall back to LM Studio
+    if "lm_studio" in results and "error" not in results["lm_studio"]:
+        return results["lm_studio"].get("lm_studio_response", "")
+    
+    # Finally use spaCy results if we have to
+    if "spacy" in results and "error" not in results["spacy"]:
+        spacy_data = results["spacy"]
+        
+        # Create a simple response from spaCy analysis
+        sentences = spacy_data.get("sentences", [])
+        top_terms = spacy_data.get("top_terms", [])
+        entities = spacy_data.get("entities", [])
+        
+        response_parts = []
+        
+        if sentences:
+            response_parts.append(f"I analyzed your text of {len(sentences)} sentence(s).")
+        
+        if top_terms:
+            terms_str = ", ".join([term[0] for term in top_terms[:5]])
+            response_parts.append(f"The key terms are: {terms_str}.")
+        
+        if entities:
+            entity_texts = [e["text"] for e in entities]
+            if entity_texts:
+                entities_str = ", ".join(entity_texts)
+                response_parts.append(f"I identified these entities: {entities_str}.")
+        
+        if response_parts:
+            return " ".join(response_parts)
+    
+    # If all else fails
+    return "I processed your request but couldn't generate a detailed analysis."

openai_integration.py

@@ -0,0 +1,908 @@
+"""
+OpenAI integration module for the Ultimate AI Tool workflow automation assistant.
+
+This module provides enhanced ChatGPT integration with:
+- Quantum layer multidimensional thinking
+- Recursive agent capabilities
+- Task and workflow optimization
+- Web content analysis
+- Support for local LLM solutions (Ollama, LM Studio)
+"""
+import os
+import logging
+import json
+import random
+import datetime
+import requests
+import re
+
+# The newest OpenAI model is "gpt-4o" which was released May 13, 2024.
+# do not change this unless explicitly requested by the user
+MODEL = "gpt-4o"
+EMBEDDING_MODEL = "text-embedding-ada-002"
+
+logger = logging.getLogger(__name__)
+
+# Initialize OpenAI client only if API key is available
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+client = None
+
+# Local LLM Configuration
+LOCAL_LLM_ENABLED = os.environ.get("LOCAL_LLM_ENABLED", "true").lower() == "true"
+LOCAL_LLM_PROVIDER = os.environ.get("LOCAL_LLM_PROVIDER", "ollama").lower()  # "ollama" or "lmstudio"
+LOCAL_LLM_MODEL = os.environ.get("LOCAL_LLM_MODEL", "llama3")
+OLLAMA_URL = os.environ.get("OLLAMA_URL", "http://localhost:11434")
+LM_STUDIO_URL = os.environ.get("LM_STUDIO_URL", "http://localhost:1234/v1")
+
+# Dictionary of local LLM providers and their configurations
+LOCAL_LLM_PROVIDERS = {
+    "lmstudio": {
+        "url": lambda: LM_STUDIO_URL,
+        "chat_endpoint": "/chat/completions",
+        "completions_endpoint": "/completions"
+    },
+    "ollama": {
+        "url": lambda: OLLAMA_URL,
+        "chat_endpoint": "/api/chat",
+        "completions_endpoint": "/api/generate"
+    }
+}
+
+# Conversation history for the recursive agent capability
+CONVERSATION_HISTORY = []
+MAX_HISTORY_LENGTH = 10
+
+try:
+    # Only import the OpenAI module if there's an API key
+    if OPENAI_API_KEY:
+        from openai import OpenAI
+        client = OpenAI(api_key=OPENAI_API_KEY)
+        logger.info("OpenAI client initialized successfully")
+    else:
+        logger.warning("OPENAI_API_KEY environment variable not set - using local LLM if available")
+except ImportError:
+    logger.warning("OpenAI package not imported - using local LLM if available")
+except Exception as e:
+    logger.error(f"Failed to initialize OpenAI client: {str(e)}")
+
+def query_local_llm(prompt=None, provider=None, model=None, messages=None, max_tokens=500, temperature=0.7):
+    """
+    Query a local LLM provider like LM Studio or Ollama
+    
+    Args:
+        prompt: The text prompt to send (used if messages is None)
+        provider: The local LLM provider to use (lmstudio or ollama)
+        model: The model name to use (provider-specific)
+        messages: List of messages in chat format (if None, uses prompt as single user message)
+        max_tokens: Maximum tokens to generate
+        temperature: Temperature for response generation
+        
+    Returns:
+        str: The generated response text
+    """
+    if not LOCAL_LLM_ENABLED:
+        logger.warning("Local LLM is disabled")
+        return "Local LLM is disabled. Please enable it or provide an OpenAI API key."
+    
+    # Use default provider if not specified
+    if not provider:
+        provider = LOCAL_LLM_PROVIDER
+    
+    # Check if the provider is supported
+    if provider not in LOCAL_LLM_PROVIDERS:
+        logger.error(f"Unknown local LLM provider: {provider}")
+        return f"Error: Unknown provider '{provider}'"
+    
+    try:
+        provider_config = LOCAL_LLM_PROVIDERS[provider]
+        base_url = provider_config["url"]()
+        
+        # Default model based on provider
+        if model is None:
+            model = LOCAL_LLM_MODEL
+            if provider == "lmstudio":
+                # Some LM Studio installations use a prefix for model names
+                model = f"openai/{model}" if not model.startswith("openai/") else model
+        
+        # Format request based on whether we have messages or just a prompt
+        if messages:
+            # Handle chat completion format
+            endpoint = provider_config["chat_endpoint"]
+            url = f"{base_url}{endpoint}"
+            
+            if provider == "lmstudio":
+                # LM Studio follows OpenAI format
+                payload = {
+                    "model": model,
+                    "messages": messages,
+                    "temperature": temperature,
+                    "max_tokens": max_tokens
+                }
+            elif provider == "ollama":
+                # Ollama has its own format
+                payload = {
+                    "model": model,
+                    "messages": messages,
+                    "stream": False,
+                    "options": {
+                        "temperature": temperature,
+                        "num_predict": max_tokens
+                    }
+                }
+        else:
+            # Handle completion format with just a prompt
+            endpoint = provider_config["completions_endpoint"]
+            url = f"{base_url}{endpoint}"
+            
+            if provider == "lmstudio":
+                payload = {
+                    "model": model,
+                    "prompt": prompt,
+                    "temperature": temperature,
+                    "max_tokens": max_tokens
+                }
+            elif provider == "ollama":
+                payload = {
+                    "model": model,
+                    "prompt": prompt,
+                    "options": {
+                        "temperature": temperature,
+                        "num_predict": max_tokens
+                    }
+                }
+        
+        # Make the request
+        logger.info(f"Querying {provider} at {url} with model {model}")
+        response = requests.post(url, json=payload, timeout=60)
+        response.raise_for_status()
+        data = response.json()
+        
+        # Handle response based on provider and request type
+        if messages:
+            if provider == "lmstudio":
+                # OpenAI-compatible format
+                return data.get("choices", [{}])[0].get("message", {}).get("content", "")
+            elif provider == "ollama":
+                return data.get("message", {}).get("content", "")
+        else:
+            if provider == "lmstudio":
+                return data.get("choices", [{}])[0].get("text", "")
+            elif provider == "ollama":
+                return data.get("response", "")
+                
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error connecting to {provider}: {e}")
+        return f"Error: Unable to connect to {provider}. {str(e)}"
+    except json.JSONDecodeError as e:
+        logger.error(f"Error parsing JSON response from {provider}: {e}")
+        return f"Error: Invalid response from {provider}"
+    except Exception as e:
+        logger.error(f"Unexpected error with {provider}: {e}")
+        return f"Error: {str(e)}"
+
+def generate_fallback_response(input_text, quantum_results):
+    """
+    Generate a fallback response when OpenAI API is not available.
+    
+    Args:
+        input_text (str): Original input text
+        quantum_results (dict): Results from quantum thinking process
+        
+    Returns:
+        dict: Simulated response
+    """
+    meta_insight = quantum_results.get('meta_insight', '')
+    paths = quantum_results.get('paths', [])
+    
+    # Create a list of template sentences to use in the fallback response
+    templates = [
+        f"The quantum analysis reveals that '{input_text}' contains multiple layers of meaning.",
+        f"Based on the meta-insight: {meta_insight}, we can understand this text from several perspectives.",
+        "The multi-dimensional thinking process uncovers patterns that might not be immediately obvious.",
+        "When we apply quantum-inspired analysis, new connections emerge between concepts."
+    ]
+    
+    # Add insights from paths
+    for path in paths[:2]:
+        if 'concept' in path and 'insight' in path:
+            templates.append(f"The concept of '{path['concept']}' leads to this insight: {path['insight']}")
+        if 'entangled_insight' in path:
+            templates.append(f"Furthermore: {path['entangled_insight']}")
+    
+    # Add concluding statements
+    conclusions = [
+        "This analysis demonstrates how multi-layered thinking can extract deeper meaning from text.",
+        "By considering multiple dimensions simultaneously, we gain a more comprehensive understanding.",
+        f"The quantum score of {quantum_results.get('quantum_score', 0.5)} suggests a significant depth to this analysis.",
+        "To fully appreciate the analysis, consider how these different perspectives interact and inform each other."
+    ]
+    
+    # Construct the response
+    response_parts = []
+    response_parts.extend(random.sample(templates, min(3, len(templates))))
+    response_parts.append("")  # Empty line
+    response_parts.append("In conclusion:")
+    response_parts.extend(random.sample(conclusions, min(2, len(conclusions))))
+    
+    response_text = "\n\n".join(response_parts)
+    
+    return {
+        "text": response_text,
+        "meta_insight": meta_insight,
+        "model": "Quantum Framework (Fallback Mode)"
+    }
+
+def generate_completion(input_text, quantum_results):
+    """
+    Generate a completion using OpenAI's API, local LLM, or fallback to local generation.
+    
+    Args:
+        input_text (str): Original input text
+        quantum_results (dict): Results from quantum thinking process
+        
+    Returns:
+        dict: OpenAI API response, local LLM response, or fallback response
+    """
+    # Try OpenAI first if available
+    if OPENAI_API_KEY and client is not None:
+        try:
+            # Extract meta insights from quantum results
+            meta_insight = quantum_results.get('meta_insight', '')
+            
+            # Create a prompt that incorporates quantum thinking results
+            prompt = create_prompt(input_text, quantum_results)
+            
+            logger.debug(f"Sending prompt to OpenAI: {prompt[:100]}...")
+            
+            # Call OpenAI API
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You are a quantum thinking framework assistant that analyzes text using multi-dimensional, layered thinking processes. Provide insightful, thoughtful responses that consider multiple perspectives and layers of meaning."
+                    },
+                    {
+                        "role": "user",
+                        "content": prompt
+                    }
+                ],
+                max_tokens=500,
+                temperature=0.7
+            )
+            
+            # Extract and return the response text
+            response_text = response.choices[0].message.content if response.choices else ""
+            
+            return {
+                "text": response_text,
+                "meta_insight": meta_insight,
+                "model": MODEL
+            }
+            
+        except Exception as e:
+            logger.error(f"Error calling OpenAI API: {str(e)}")
+            # Fall through to try local LLM
+    
+    # Try local LLM if enabled
+    if LOCAL_LLM_ENABLED:
+        try:
+            # Extract meta insights from quantum results
+            meta_insight = quantum_results.get('meta_insight', '')
+            
+            # Create a prompt that incorporates quantum thinking results
+            prompt = create_prompt(input_text, quantum_results)
+            
+            logger.debug(f"Sending prompt to local LLM ({LOCAL_LLM_PROVIDER}): {prompt[:100]}...")
+            
+            # Create messages for chat format
+            messages = [
+                {
+                    "role": "system",
+                    "content": "You are a quantum thinking framework assistant that analyzes text using multi-dimensional, layered thinking processes. Provide insightful, thoughtful responses that consider multiple perspectives and layers of meaning."
+                },
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ]
+            
+            # Query local LLM
+            response_text = query_local_llm(
+                provider=LOCAL_LLM_PROVIDER,
+                model=LOCAL_LLM_MODEL,
+                messages=messages,
+                max_tokens=500,
+                temperature=0.7
+            )
+            
+            if not response_text.startswith("Error:"):
+                return {
+                    "text": response_text,
+                    "meta_insight": meta_insight,
+                    "model": f"{LOCAL_LLM_PROVIDER}/{LOCAL_LLM_MODEL}"
+                }
+            else:
+                logger.error(f"Error from local LLM: {response_text}")
+                # Fall through to fallback
+                
+        except Exception as e:
+            logger.error(f"Error using local LLM: {str(e)}")
+            # Fall through to fallback
+    
+    # If all else fails, fall back to local generation
+    logger.warning("All LLM options failed - using fallback response generator")
+    return generate_fallback_response(input_text, quantum_results)
+
+def create_prompt(input_text, quantum_results):
+    """
+    Create a detailed prompt for the OpenAI API.
+    
+    Args:
+        input_text (str): Original input text
+        quantum_results (dict): Results from quantum thinking process
+        
+    Returns:
+        str: Formatted prompt
+    """
+    # Extract key elements from quantum results
+    dimension = quantum_results.get('dimension', 0)
+    meta_insight = quantum_results.get('meta_insight', '')
+    paths = quantum_results.get('paths', [])
+    
+    # Build a detailed prompt
+    prompt = f"""
+I've analyzed the following text using a quantum thinking framework:
+
+Original text: "{input_text}"
+
+The analysis explored {dimension} recursive dimensions of thought, resulting in the following meta-insight:
+{meta_insight}
+
+Key conceptual paths explored:
+"""
+
+    # Add information about the paths explored
+    for i, path in enumerate(paths[:3], 1):  # Include up to 3 paths to keep prompt concise
+        concept = path.get('concept', '')
+        insight = path.get('insight', '')
+        entangled_insight = path.get('entangled_insight', '')
+        
+        prompt += f"\nPath {i}: Concept '{concept}'\n"
+        prompt += f"- Insight: {insight}\n"
+        
+        if entangled_insight:
+            prompt += f"- Entangled insight: {entangled_insight}\n"
+    
+    # Add instruction for the response
+    prompt += f"""
+Based on this multi-dimensional analysis, please:
+
+1. Provide a comprehensive interpretation of the original text 
+2. Highlight patterns and insights revealed by the quantum thinking process
+3. Suggest alternative perspectives or implications that might not be immediately obvious
+4. Synthesize a coherent understanding that incorporates multiple layers of meaning
+
+Respond in a clear, insightful manner that demonstrates deep understanding.
+"""
+    
+    return prompt
+
+def analyze_web_content(url, content, metadata=None):
+    """
+    Analyze web content using OpenAI, local LLM, or fallback method.
+    
+    Args:
+        url (str): The URL of the web content
+        content (str): The text content to analyze
+        metadata (dict, optional): Additional metadata about the content
+        
+    Returns:
+        dict: Analysis results
+    """
+    # Try OpenAI first if available
+    if OPENAI_API_KEY and client is not None:
+        try:
+            # Truncate content if too long
+            max_content_length = 3000
+            trimmed_content = content[:max_content_length] + "..." if len(content) > max_content_length else content
+            
+            # Create a system prompt for web content analysis
+            system_prompt = """You are a quantum web analysis assistant. Analyze the provided web content and extract key information:
+1. Main topics and themes
+2. Key entities (people, organizations, places)
+3. Important facts and claims
+4. Sentiment and tone
+5. Potential biases or viewpoints
+
+Provide a comprehensive analysis that would be valuable for someone seeking to understand this content deeply."""
+            
+            # Create a user prompt with the content
+            user_prompt = f"""Analyze the following web content from {url}:
+
+{trimmed_content}
+
+Provide a structured analysis with clear sections for topics, entities, facts, sentiment, and potential biases.
+Include a brief summary at the beginning and key takeaways at the end."""
+            
+            # Call OpenAI API
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                max_tokens=800,
+                temperature=0.5
+            )
+            
+            # Extract the response text
+            analysis_text = response.choices[0].message.content if response.choices else ""
+            
+            return {
+                "status": "success",
+                "url": url,
+                "analysis": analysis_text,
+                "model": MODEL,
+                "timestamp": datetime.datetime.utcnow().isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"Error analyzing web content with OpenAI: {str(e)}")
+            # Fall through to try local LLM
+    
+    # Try local LLM if enabled
+    if LOCAL_LLM_ENABLED:
+        try:
+            # Truncate content if too long
+            max_content_length = 3000
+            trimmed_content = content[:max_content_length] + "..." if len(content) > max_content_length else content
+            
+            # Create messages for chat format
+            messages = [
+                {
+                    "role": "system", 
+                    "content": """You are a web content analysis assistant. Analyze the provided web content and extract key information:
+1. Main topics and themes
+2. Key entities (people, organizations, places)
+3. Important facts and claims
+4. Sentiment and tone
+5. Potential biases or viewpoints
+
+Provide a comprehensive analysis that would be valuable for someone seeking to understand this content deeply."""
+                },
+                {
+                    "role": "user", 
+                    "content": f"""Analyze the following web content from {url}:
+
+{trimmed_content}
+
+Provide a structured analysis with clear sections for topics, entities, facts, sentiment, and potential biases.
+Include a brief summary at the beginning and key takeaways at the end."""
+                }
+            ]
+            
+            # Query local LLM
+            analysis_text = query_local_llm(
+                provider=LOCAL_LLM_PROVIDER,
+                model=LOCAL_LLM_MODEL,
+                messages=messages,
+                max_tokens=800,
+                temperature=0.5
+            )
+            
+            if not analysis_text.startswith("Error:"):
+                return {
+                    "status": "success",
+                    "url": url,
+                    "analysis": analysis_text,
+                    "model": f"{LOCAL_LLM_PROVIDER}/{LOCAL_LLM_MODEL}",
+                    "timestamp": datetime.datetime.utcnow().isoformat()
+                }
+            else:
+                logger.error(f"Error from local LLM for web analysis: {analysis_text}")
+                # Fall through to fallback
+                
+        except Exception as e:
+            logger.error(f"Error analyzing web content with local LLM: {str(e)}")
+            # Fall through to fallback
+    
+    # If all else fails, fall back to local analysis
+    logger.warning("All LLM options failed for web analysis - using fallback web analysis")
+    return fallback_web_analysis(url, content, metadata)
+
+def fallback_web_analysis(url, content, metadata=None):
+    """Generate a fallback web content analysis when OpenAI API is not available."""
+    # Extract basic metrics
+    word_count = len(content.split())
+    sentence_count = len([s for s in content.split('.') if s.strip()])
+    avg_sentence_length = word_count / max(1, sentence_count)
+    
+    # Sample key phrases (very basic implementation)
+    words = content.split()
+    key_phrases = []
+    
+    if len(words) > 20:
+        for i in range(min(5, len(words) // 20)):
+            start_idx = i * (len(words) // 5)
+            phrase = ' '.join(words[start_idx:start_idx + min(5, len(words) - start_idx)])
+            key_phrases.append(phrase)
+    
+    analysis = f"""
+## Web Content Analysis (Fallback Mode)
+
+**URL:** {url}
+
+**Basic Metrics:**
+- Word Count: {word_count}
+- Sentence Count: {sentence_count}
+- Average Sentence Length: {avg_sentence_length:.1f} words
+
+**Sample Content Phrases:**
+"""
+    for phrase in key_phrases:
+        analysis += f"- \"{phrase}\"\n"
+    
+    analysis += """
+**Note:** This is a limited analysis generated by the fallback system. 
+To get more comprehensive analysis capabilities, please provide an OpenAI API key.
+"""
+    
+    return {
+        "status": "limited",
+        "url": url,
+        "analysis": analysis,
+        "model": "Fallback Analysis",
+        "timestamp": datetime.datetime.utcnow().isoformat()
+    }
+
+def process_recursive_agent(user_input, context=None):
+    """
+    Process input using a recursive agent approach that maintains conversation context.
+    
+    Args:
+        user_input (str): User's input text
+        context (dict, optional): Additional context information
+        
+    Returns:
+        dict: Agent response with actions or next steps
+    """
+    global CONVERSATION_HISTORY
+    
+    # Add user input to conversation history
+    CONVERSATION_HISTORY.append({"role": "user", "content": user_input})
+    
+    # Trim history if too long
+    if len(CONVERSATION_HISTORY) > MAX_HISTORY_LENGTH:
+        CONVERSATION_HISTORY = CONVERSATION_HISTORY[-MAX_HISTORY_LENGTH:]
+    
+    # System message for recursive agent
+    system_message = {
+        "role": "system", 
+        "content": """You are an advanced recursive agent with the ability to:
+1. Process and analyze user requests
+2. Break complex tasks into subtasks
+3. Execute tasks in the correct sequence
+4. Learn from previous interactions
+5. Maintain context across conversation turns
+
+Respond in JSON format with the following structure:
+{
+  "understanding": "Your interpretation of the user's request",
+  "thought_process": "Your step-by-step reasoning",
+  "actions": [
+    {"type": "web_search", "query": "search query"},
+    {"type": "analyze", "text": "text to analyze"},
+    {"type": "schedule", "task": "task to schedule", "when": "time"}
+  ],
+  "response": "Your response to the user",
+  "follow_up": "Optional follow-up question or suggestion"
+}"""
+    }
+    
+    # Combine system message with conversation history
+    messages = [system_message] + CONVERSATION_HISTORY
+    
+    # Add context information if provided
+    if context:
+        context_message = {
+            "role": "system",
+            "content": f"Additional context information: {json.dumps(context)}"
+        }
+        messages.append(context_message)
+    
+    # Try OpenAI first if available
+    if OPENAI_API_KEY and client is not None:
+        try:
+            # Call OpenAI API with JSON response format
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=messages,
+                max_tokens=1000,
+                temperature=0.7,
+                response_format={"type": "json_object"}
+            )
+            
+            # Extract and parse the JSON response
+            response_text = response.choices[0].message.content if response.choices else "{}"
+            try:
+                agent_response = json.loads(response_text)
+            except json.JSONDecodeError:
+                agent_response = {
+                    "understanding": "Error parsing response",
+                    "response": "I encountered an error processing your request. Please try again.",
+                    "actions": []
+                }
+            
+            # Add assistant response to conversation history
+            CONVERSATION_HISTORY.append({
+                "role": "assistant", 
+                "content": agent_response.get("response", "")
+            })
+            
+            return {
+                "status": "success",
+                "agent_response": agent_response,
+                "model": MODEL
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in OpenAI recursive agent: {str(e)}")
+            # Fall through to try local LLM
+    
+    # Try local LLM if enabled
+    if LOCAL_LLM_ENABLED:
+        try:
+            # Query local LLM
+            response_text = query_local_llm(
+                provider=LOCAL_LLM_PROVIDER,
+                model=LOCAL_LLM_MODEL,
+                messages=messages,
+                max_tokens=1000,
+                temperature=0.7
+            )
+            
+            if not response_text.startswith("Error:"):
+                # Try to parse JSON response
+                try:
+                    # First, look for JSON structure in the response
+                    json_match = re.search(r'({[\s\S]*})', response_text)
+                    if json_match:
+                        response_text = json_match.group(1)
+                    
+                    agent_response = json.loads(response_text)
+                except json.JSONDecodeError:
+                    # If not valid JSON, create a simplified response
+                    agent_response = {
+                        "understanding": "Processed with local LLM",
+                        "response": response_text,
+                        "actions": []
+                    }
+                
+                # Add assistant response to conversation history
+                CONVERSATION_HISTORY.append({
+                    "role": "assistant", 
+                    "content": agent_response.get("response", response_text)
+                })
+                
+                return {
+                    "status": "success",
+                    "agent_response": agent_response,
+                    "model": f"{LOCAL_LLM_PROVIDER}/{LOCAL_LLM_MODEL}"
+                }
+            else:
+                logger.error(f"Error from local LLM for recursive agent: {response_text}")
+                # Fall through to fallback
+                
+        except Exception as e:
+            logger.error(f"Error in local LLM recursive agent: {str(e)}")
+            # Fall through to fallback
+    
+    # If all else fails, use a simple fallback
+    fallback_response = {
+        "understanding": "Basic understanding of request",
+        "response": "I processed your request but couldn't use advanced features. Please ensure an LLM is available.",
+        "actions": []
+    }
+    
+    # Add assistant response to conversation history
+    CONVERSATION_HISTORY.append({
+        "role": "assistant", 
+        "content": fallback_response.get("response", "")
+    })
+    
+    return {
+        "status": "limited",
+        "agent_response": fallback_response,
+        "model": "Fallback Agent"
+    }
+
+def optimize_workflow(workflow_description, tasks=None):
+    """
+    Optimize a workflow based on description and existing tasks.
+    
+    Args:
+        workflow_description (str): Description of the workflow
+        tasks (list, optional): List of existing tasks in the workflow
+        
+    Returns:
+        dict: Optimized workflow with steps and recommendations
+    """
+    # Create system prompt for workflow optimization
+    system_prompt = """You are a workflow optimization expert. Analyze the provided workflow description and tasks to:
+1. Identify inefficiencies and bottlenecks
+2. Suggest automation opportunities
+3. Optimize task sequencing and dependencies
+4. Recommend parallel processing where possible
+5. Create a step-by-step optimized workflow plan
+
+Respond with a structured optimization plan in JSON format."""
+    
+    # Create user prompt with workflow details
+    tasks_json = json.dumps(tasks) if tasks else "[]"
+    user_prompt = f"""Optimize the following workflow:
+
+Description: {workflow_description}
+
+Current Tasks: {tasks_json}
+
+Provide a comprehensive optimization plan with clear steps, automation recommendations, and efficiency improvements.
+Format your response as a JSON object with 'optimized_workflow', 'recommendations', and 'automation_opportunities' keys."""
+    
+    # Try OpenAI first if available
+    if OPENAI_API_KEY and client is not None:
+        try:
+            # Call OpenAI API with JSON response format
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                max_tokens=1000,
+                temperature=0.7,
+                response_format={"type": "json_object"}
+            )
+            
+            # Extract and parse the JSON response
+            response_text = response.choices[0].message.content if response.choices else "{}"
+            try:
+                optimization_result = json.loads(response_text)
+            except json.JSONDecodeError:
+                optimization_result = {
+                    "optimized_workflow": [],
+                    "recommendations": ["Error parsing optimization results"],
+                    "automation_opportunities": []
+                }
+            
+            return {
+                "status": "success",
+                "optimization": optimization_result,
+                "model": MODEL
+            }
+            
+        except Exception as e:
+            logger.error(f"Error optimizing workflow with OpenAI: {str(e)}")
+            # Fall through to try local LLM
+    
+    # Try local LLM if enabled
+    if LOCAL_LLM_ENABLED:
+        try:
+            # Create messages for chat format
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+            
+            # Query local LLM
+            response_text = query_local_llm(
+                provider=LOCAL_LLM_PROVIDER,
+                model=LOCAL_LLM_MODEL,
+                messages=messages,
+                max_tokens=1000,
+                temperature=0.7
+            )
+            
+            if not response_text.startswith("Error:"):
+                # Try to parse JSON response
+                try:
+                    # First, look for JSON structure in the response
+                    json_match = re.search(r'({[\s\S]*})', response_text)
+                    if json_match:
+                        response_text = json_match.group(1)
+                    
+                    optimization_result = json.loads(response_text)
+                except json.JSONDecodeError:
+                    # If not valid JSON, create a simplified response
+                    optimization_result = {
+                        "optimized_workflow": [],
+                        "recommendations": ["The optimization was processed with a local LLM but couldn't be formatted as JSON. Raw output:", response_text],
+                        "automation_opportunities": []
+                    }
+                
+                return {
+                    "status": "success",
+                    "optimization": optimization_result,
+                    "model": f"{LOCAL_LLM_PROVIDER}/{LOCAL_LLM_MODEL}"
+                }
+            else:
+                logger.error(f"Error from local LLM for workflow optimization: {response_text}")
+                # Fall through to fallback
+                
+        except Exception as e:
+            logger.error(f"Error optimizing workflow with local LLM: {str(e)}")
+            # Fall through to fallback
+    
+    # If all else fails, return a simple fallback
+    return {
+        "status": "error",
+        "message": "No LLM available for workflow optimization",
+        "optimization": {
+            "optimized_workflow": [],
+            "recommendations": ["To enable workflow optimization, please provide an LLM solution."],
+            "automation_opportunities": []
+        }
+    }
+
+def generate_text(prompt):
+    """Generate text using OpenAI API or local LLM
+    
+    Args:
+        prompt: The text prompt to send to the LLM
+        
+    Returns:
+        str: The generated response
+    """
+    # Try OpenAI first if available
+    if OPENAI_API_KEY and client is not None:
+        try:
+            logger.info(f"Sending prompt to OpenAI: {prompt[:50]}...")
+            
+            # Make the API call
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=[
+                    {"role": "system", "content": "You are a helpful AI assistant."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=500
+            )
+            
+            # Extract and return the response text
+            response_text = response.choices[0].message.content
+            return response_text
+            
+        except Exception as e:
+            logger.error(f"Error generating text with OpenAI: {str(e)}")
+            # Fall through to try local LLM
+    
+    # Try local LLM if enabled
+    if LOCAL_LLM_ENABLED:
+        try:
+            logger.info(f"Sending prompt to local LLM ({LOCAL_LLM_PROVIDER}): {prompt[:50]}...")
+            
+            # Create messages for chat format
+            messages = [
+                {"role": "system", "content": "You are a helpful AI assistant."},
+                {"role": "user", "content": prompt}
+            ]
+            
+            # Query local LLM
+            response_text = query_local_llm(
+                provider=LOCAL_LLM_PROVIDER,
+                model=LOCAL_LLM_MODEL,
+                messages=messages
+            )
+            
+            if not response_text.startswith("Error:"):
+                return response_text
+            else:
+                logger.error(f"Error from local LLM: {response_text}")
+                # Fall through to fallback
+                
+        except Exception as e:
+            logger.error(f"Error generating text with local LLM: {str(e)}")
+            # Fall through to fallback
+    
+    # If all else fails, return a simple message
+    return "I'm unable to generate a response at this time. Please ensure an LLM solution is available."

pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "repl-nix-workspace"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.11"
+dependencies = [
+    "beautifulsoup4>=4.13.3",
+    "email-validator>=2.2.0",
+    "flask>=3.1.0",
+    "flask-sqlalchemy>=3.1.1",
+    "gunicorn>=23.0.0",
+    "openai>=1.68.2",
+    "psycopg2-binary>=2.9.10",
+    "requests>=2.32.3",
+    "spacy>=3.8.4",
+    "sqlalchemy>=2.0.39",
+    "trafilatura>=2.0.0",
+]

quantum_thinking.py

@@ -0,0 +1,265 @@
+"""
+Quantum-inspired recursive thinking module.
+
+This module implements a multi-dimensional, layered thinking process 
+inspired by quantum computing concepts, using recursion to simulate
+multiple simultaneous thought paths.
+"""
+import logging
+import random
+from collections import defaultdict
+import re
+
+logger = logging.getLogger(__name__)
+
+def quantum_recursive_thinking(text, depth=3, branch_factor=3, superposition_factor=0.7):
+    """
+    Implements a quantum-inspired recursive thinking process.
+    
+    Args:
+        text (str): The input text to process
+        depth (int): The recursive depth (dimensionality) of thinking
+        branch_factor (int): How many paths to explore at each level
+        superposition_factor (float): How much paths should influence each other
+        
+    Returns:
+        dict: Results of the quantum thinking process
+    """
+    try:
+        logger.debug(f"Quantum thinking on text: {text[:50]}... with depth {depth}")
+        
+        # Base case
+        if depth <= 0 or not text.strip():
+            return {
+                'dimension': 0, 
+                'insight': "Reached base dimension",
+                'paths': []
+            }
+            
+        # Clean and prepare text
+        cleaned_text = clean_text(text)
+        
+        # Extract key concepts from text
+        concepts = extract_key_concepts(cleaned_text)
+        
+        # Ensure we have enough concepts
+        if len(concepts) < branch_factor:
+            # Add some generic concepts to ensure branching
+            generic_concepts = ["analysis", "implication", "perspective", 
+                               "alternative", "synthesis", "insight"]
+            concepts.extend(generic_concepts[:branch_factor - len(concepts)])
+        
+        # Select branch_factor concepts to explore
+        selected_concepts = concepts[:branch_factor]
+        
+        # Create paths for recursive exploration
+        paths = []
+        all_insights = []
+        
+        # For each selected concept, create a new thinking path
+        for i, concept in enumerate(selected_concepts):
+            # Create the thought prompt for this concept
+            thought_prompt = generate_thought_prompt(text, concept, depth)
+            
+            # Recursively explore this path with reduced depth
+            path_result = quantum_recursive_thinking(
+                thought_prompt, 
+                depth - 1, 
+                max(2, branch_factor - 1),  # Reduce branching as we go deeper
+                superposition_factor * 0.9   # Reduce superposition effect as we go deeper
+            )
+            
+            # Generate insight for this path
+            path_insight = generate_insight(text, concept, depth)
+            all_insights.append(path_insight)
+            
+            # Add results to paths
+            paths.append({
+                'concept': concept,
+                'prompt': thought_prompt,
+                'insight': path_insight,
+                'sub_dimensions': path_result
+            })
+        
+        # Apply "superposition" - allow paths to influence each other
+        # This simulates quantum entanglement between thinking paths
+        entangled_paths = apply_superposition(paths, superposition_factor)
+        
+        # Synthesize a meta-insight from all path insights
+        meta_insight = synthesize_insights(text, all_insights, depth)
+        
+        # Compute "quantum probability" score
+        quantum_score = compute_quantum_score(text, entangled_paths, depth)
+        
+        # Return the final results
+        return {
+            'dimension': depth,
+            'meta_insight': meta_insight,
+            'quantum_score': quantum_score,
+            'paths': entangled_paths
+        }
+            
+    except Exception as e:
+        logger.error(f"Error in quantum thinking: {str(e)}")
+        return {
+            'dimension': depth,
+            'error': str(e),
+            'meta_insight': "Error occurred during quantum thinking process",
+            'paths': []
+        }
+
+def clean_text(text):
+    """Clean and normalize the input text."""
+    # Remove extra whitespace
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def extract_key_concepts(text):
+    """Extract key concepts from the text for branching."""
+    # Split into words and filter out common words
+    words = text.lower().split()
+    stopwords = set(["the", "and", "a", "an", "in", "on", "at", "to", "for", "is", "are", 
+                    "was", "were", "be", "been", "being", "have", "has", "had", "do", 
+                    "does", "did", "of", "that", "this", "with", "by"])
+    
+    # Filter out stopwords and short words
+    filtered_words = [w for w in words if w not in stopwords and len(w) > 3]
+    
+    # Count frequency
+    word_freq = defaultdict(int)
+    for word in filtered_words:
+        word_freq[word] += 1
+    
+    # Sort by frequency
+    sorted_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)
+    
+    # Return just the words, not the counts
+    return [word for word, count in sorted_words[:10]]
+
+def generate_thought_prompt(text, concept, depth):
+    """Generate a thought prompt for recursive exploration."""
+    prompts = [
+        f"Exploring the concept of '{concept}' in relation to: {text}",
+        f"How does '{concept}' relate to or illuminate: {text}",
+        f"Considering '{concept}' as a lens to understand: {text}",
+        f"What insights emerge when viewing through the prism of '{concept}': {text}",
+        f"Analyzing the dimensions of '{concept}' within: {text}"
+    ]
+    
+    # Select a prompt based on the current depth (to add variety)
+    prompt_index = (depth - 1) % len(prompts)
+    return prompts[prompt_index]
+
+def generate_insight(text, concept, depth):
+    """Generate an insight for a specific concept and depth."""
+    # Templates for different depth levels
+    templates = {
+        3: [
+            f"The primary aspect of '{concept}' reveals fundamental patterns in the input.",
+            f"At the root level, '{concept}' serves as an organizing principle.",
+            f"The meta-structure of '{concept}' frames our understanding of the whole."
+        ],
+        2: [
+            f"The relationship between '{concept}' and contextual elements creates tension.",
+            f"'{concept}' operates as both cause and effect within this system.",
+            f"The secondary implications of '{concept}' reveal hidden connections."
+        ],
+        1: [
+            f"The granular detail of '{concept}' illuminates microscopic truth.",
+            f"At the most specific level, '{concept}' manifests as concrete instances.",
+            f"The practical application of '{concept}' suggests actionable insights."
+        ]
+    }
+    
+    # Use depth to select appropriate template, default to depth 1 if not found
+    depth_templates = templates.get(depth, templates[1])
+    
+    # Randomly select from available templates for this depth
+    return random.choice(depth_templates)
+
+def apply_superposition(paths, factor):
+    """
+    Apply 'quantum superposition' by allowing paths to influence each other.
+    
+    Args:
+        paths: List of path results
+        factor: How strongly paths should influence each other (0-1)
+        
+    Returns:
+        List of entangled paths
+    """
+    if not paths or len(paths) < 2:
+        return paths
+        
+    entangled_paths = paths.copy()
+    
+    # For each path
+    for i in range(len(paths)):
+        # Skip with probability (1-factor) to maintain some independence
+        if random.random() > factor:
+            continue
+            
+        # Select another random path to entangle with
+        other_idx = random.choice([j for j in range(len(paths)) if j != i])
+        
+        # Extract a concept from the other path
+        other_concept = paths[other_idx]['concept']
+        
+        # Create an entangled insight combining both paths
+        entangled_insight = f"The interaction between '{paths[i]['concept']}' and '{other_concept}' creates a superposition of meaning, suggesting that {random.choice(['patterns emerge from complexity', 'multiple interpretations coexist', 'contextual understanding requires multiple viewpoints', 'dimensional analysis reveals hidden structure'])}"
+        
+        # Update the path with the entangled insight
+        entangled_paths[i]['entangled_insight'] = entangled_insight
+        entangled_paths[i]['entangled_with'] = other_concept
+    
+    return entangled_paths
+
+def synthesize_insights(text, insights, depth):
+    """Synthesize a meta-insight from all path insights."""
+    if not insights:
+        return "Insufficient data for meta-insight synthesis."
+        
+    # Templates for meta-insights
+    meta_templates = [
+        "The recursive analysis reveals that multiple perspectives {}, suggesting {}.",
+        "Quantum-inspired thinking uncovers a superposition where {} and {} coexist.",
+        "The dimensional analysis indicates that {} serves as the foundation for {}.",
+        "At depth {}, the emergent pattern demonstrates how {} relates to {}.",
+        "The entanglement of concepts suggests that {} is fundamentally connected to {}."
+    ]
+    
+    # Create pairs of concepts to insert into templates
+    if len(insights) >= 2:
+        pairs = [
+            ("complexity emerges from simplicity", "underlying patterns exist"),
+            ("surface contradictions resolve at deeper levels", "unity underlies diversity"),
+            ("conceptual frameworks overlap", "interdisciplinary understanding is essential"),
+            ("analytical depth reveals nuance", "binary thinking is insufficient"),
+            ("contextual understanding requires multiple dimensions", "meaning emerges from relationship")
+        ]
+        
+        # Select a template and pair
+        template = random.choice(meta_templates)
+        pair = random.choice(pairs)
+        
+        # Format the template with the pair and depth
+        return template.format(pair[0], pair[1]) if "{}" in template else template.format(depth, pair[0], pair[1])
+    else:
+        return "Single-path analysis suggests limited dimensional exploration."
+
+def compute_quantum_score(text, paths, depth):
+    """Compute a 'quantum probability' score for the analysis."""
+    # Base score from input text complexity
+    base_score = min(0.95, max(0.2, len(text) / 1000))
+    
+    # Add score based on number of paths explored
+    path_score = min(0.3, len(paths) * 0.1)
+    
+    # Add score based on depth
+    depth_score = min(0.4, depth * 0.15)
+    
+    # Compute final score (between 0-1)
+    final_score = min(0.99, base_score + path_score + depth_score)
+    
+    # Return formatted score
+    return round(final_score, 2)

quantumvision.log

@@ -0,0 +1 @@
+./start_atlas_unified.sh: line 95: python: command not found

quantumvision.pid

@@ -0,0 +1 @@
+57088

replit.nix

@@ -0,0 +1,6 @@
+{pkgs}: {
+  deps = [
+    pkgs.postgresql
+    pkgs.openssl
+  ];
+}

requirements.txt

@@ -0,0 +1,5 @@
+fastapi>=0.103.1
+uvicorn>=0.23.2
+requests>=2.31.0
+pydantic>=2.3.0
+python-multipart>=0.0.6

settings.html

@@ -0,0 +1,362 @@
+{% extends "layout.html" %}
+
+{% block content %}
+<div class="row mb-4">
+    <div class="col-md-12">
+        <div class="glass-card floating">
+            <div class="p-4">
+                <h1 class="display-5 quantum-glow">
+                    <i class="fas fa-sliders-h me-2"></i> Settings
+                </h1>
+                <p class="card-text lead">
+                    Configure your Quantum NLP Framework experience
+                </p>
+                <div class="vision-progress">
+                    <div class="vision-progress-bar"></div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<div class="row">
+    <!-- OpenAI API Settings -->
+    <div class="col-md-6 mb-4">
+        <div class="glass-card h-100">
+            <div class="p-4">
+                <h4 class="mb-4 quantum-glow"><i class="fas fa-robot me-2"></i> OpenAI Integration</h4>
+                
+                <form method="POST" action="/save-api-key" id="api-key-form">
+                    <div class="mb-3">
+                        <label for="api_key" class="form-label">OpenAI API Key</label>
+                        <div class="input-group">
+                            <span class="input-group-text"><i class="fas fa-key"></i></span>
+                            <input type="password" class="form-control" id="api_key" name="api_key" 
+                                   placeholder="sk-..." value="{{ api_key_masked }}">
+                            <button class="btn btn-outline-secondary" type="button" id="toggle-api-key">
+                                <i class="fas fa-eye"></i>
+                            </button>
+                        </div>
+                        <div class="form-text">Your API key is stored securely and never shared</div>
+                    </div>
+                    
+                    <div class="mb-3">
+                        <label class="form-label">Status</label>
+                        <div class="d-flex align-items-center">
+                            {% if api_key_status %}
+                            <span class="badge bg-success me-2"><i class="fas fa-check me-1"></i> Connected</span>
+                            {% else %}
+                            <span class="badge bg-warning me-2"><i class="fas fa-exclamation-triangle me-1"></i> Not Connected</span>
+                            {% endif %}
+                            <div class="form-text">
+                                {% if api_key_status %}
+                                Your OpenAI API key is valid and active
+                                {% else %}
+                                Add your OpenAI API key to enable AI-enhanced features
+                                {% endif %}
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="mb-3">
+                        <label for="ai_model" class="form-label">Default AI Model</label>
+                        <select class="form-select" id="ai_model" name="ai_model">
+                            <option value="gpt-4o" {% if ai_model == 'gpt-4o' %}selected{% endif %}>GPT-4o (Recommended)</option>
+                            <option value="gpt-3.5-turbo" {% if ai_model == 'gpt-3.5-turbo' %}selected{% endif %}>GPT-3.5 Turbo (Faster)</option>
+                        </select>
+                        <div class="form-text">Select the AI model to use for enhanced analysis</div>
+                    </div>
+                    
+                    <!-- LED tracer progress line -->
+                    <div class="vision-progress mb-4">
+                        <div class="vision-progress-bar"></div>
+                    </div>
+                    
+                    <div class="d-grid">
+                        <button type="submit" class="btn btn-primary quantum-btn">
+                            <span class="quantum-btn-content">
+                                <i class="fas fa-save me-2"></i> Save API Settings
+                            </span>
+                        </button>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+    
+    <!-- Contextual Hints Settings -->
+    <div class="col-md-6 mb-4">
+        <div class="glass-card h-100">
+            <div class="p-4">
+                <h4 class="mb-4 quantum-glow"><i class="fas fa-lightbulb me-2"></i> Contextual Hints</h4>
+                
+                <div class="mb-4">
+                    <p>Contextual hints provide just-in-time guidance to help you understand the Quantum NLP Framework. They appear subtly when you might need assistance with a feature.</p>
+                    
+                    <div class="form-check form-switch mb-3">
+                        <input class="form-check-input" type="checkbox" id="enable_hints" checked>
+                        <label class="form-check-label" for="enable_hints">Enable Contextual Hints</label>
+                    </div>
+                    
+                    <div class="form-check form-switch mb-3">
+                        <input class="form-check-input" type="checkbox" id="show_particle_effects" checked>
+                        <label class="form-check-label" for="show_particle_effects">Show Quantum Particle Effects</label>
+                    </div>
+                </div>
+                
+                <div class="mb-4">
+                    <label class="form-label">Hint History</label>
+                    <div class="d-flex align-items-center">
+                        <div id="hint-count-display" class="me-2">7 hints shown</div>
+                        <button class="btn btn-sm btn-outline-info ms-auto" id="reset-hints-btn">
+                            <i class="fas fa-redo-alt me-1"></i> Reset All Hints
+                        </button>
+                    </div>
+                    <div class="form-text">Reset to show all hints again, including those you've dismissed</div>
+                </div>
+                
+                <div class="mb-4">
+                    <label for="hint_duration" class="form-label">Hint Display Duration</label>
+                    <select class="form-select" id="hint_duration">
+                        <option value="5">5 seconds</option>
+                        <option value="10" selected>10 seconds</option>
+                        <option value="15">15 seconds</option>
+                        <option value="0">Until dismissed</option>
+                    </select>
+                    <div class="form-text">How long hints will stay visible before auto-dismissing (0 = stay until manually dismissed)</div>
+                </div>
+                
+                <!-- Sample hint preview -->
+                <div class="mb-4">
+                    <label class="form-label">Hint Preview</label>
+                    <div class="contextual-hint position-static active">
+                        <div class="led-tracer"></div>
+                        <div class="contextual-hint-title">
+                            <i class="fas fa-atom"></i>
+                            <h5>Quantum Analysis</h5>
+                        </div>
+                        <div class="contextual-hint-content">This is how hints appear when they provide guidance for using the Quantum NLP Framework.</div>
+                        <div class="contextual-hint-actions">
+                            <button class="hint-button hint-button-primary">Got it</button>
+                            <span class="hint-dont-show">Don't show again</span>
+                        </div>
+                    </div>
+                </div>
+                
+                <!-- LED tracer progress line -->
+                <div class="vision-progress mb-4">
+                    <div class="vision-progress-bar"></div>
+                </div>
+                
+                <div class="d-grid">
+                    <button type="button" id="save-hints-settings" class="btn btn-primary quantum-btn">
+                        <span class="quantum-btn-content">
+                            <i class="fas fa-save me-2"></i> Save Hint Settings
+                        </span>
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<div class="row">
+    <!-- User Interface Settings -->
+    <div class="col-md-12 mb-4">
+        <div class="glass-card">
+            <div class="p-4">
+                <h4 class="mb-4 quantum-glow"><i class="fas fa-palette me-2"></i> User Interface Settings</h4>
+                
+                <div class="row">
+                    <div class="col-md-6 mb-3">
+                        <label class="form-label">Visual Effects</label>
+                        <div class="form-check form-switch mb-2">
+                            <input class="form-check-input" type="checkbox" id="led_tracer_effects" checked>
+                            <label class="form-check-label" for="led_tracer_effects">LED Tracer Lines</label>
+                        </div>
+                        <div class="form-check form-switch mb-2">
+                            <input class="form-check-input" type="checkbox" id="smoke_effects" checked>
+                            <label class="form-check-label" for="smoke_effects">Smoke Effects</label>
+                        </div>
+                        <div class="form-check form-switch mb-2">
+                            <input class="form-check-input" type="checkbox" id="quantum_particles" checked>
+                            <label class="form-check-label" for="quantum_particles">Quantum Particles</label>
+                        </div>
+                    </div>
+                    
+                    <div class="col-md-6 mb-3">
+                        <label class="form-label">Performance Settings</label>
+                        <div class="form-check form-switch mb-2">
+                            <input class="form-check-input" type="checkbox" id="reduced_animations" >
+                            <label class="form-check-label" for="reduced_animations">Reduced Animations</label>
+                        </div>
+                        <div class="form-check form-switch mb-2">
+                            <input class="form-check-input" type="checkbox" id="high_contrast">
+                            <label class="form-check-label" for="high_contrast">High Contrast Mode</label>
+                        </div>
+                        <div class="form-check form-switch mb-2">
+                            <input class="form-check-input" type="checkbox" id="focus_mode">
+                            <label class="form-check-label" for="focus_mode">Focus Mode</label>
+                        </div>
+                    </div>
+                </div>
+                
+                <!-- LED tracer progress line -->
+                <div class="vision-progress mb-4">
+                    <div class="vision-progress-bar"></div>
+                </div>
+                
+                <div class="d-grid">
+                    <button type="button" id="save-ui-settings" class="btn btn-primary quantum-btn">
+                        <span class="quantum-btn-content">
+                            <i class="fas fa-save me-2"></i> Save UI Settings
+                        </span>
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+    document.addEventListener('DOMContentLoaded', function() {
+        // Toggle API key visibility
+        const toggleApiKeyBtn = document.getElementById('toggle-api-key');
+        const apiKeyInput = document.getElementById('api_key');
+        
+        if (toggleApiKeyBtn && apiKeyInput) {
+            toggleApiKeyBtn.addEventListener('click', function() {
+                const type = apiKeyInput.getAttribute('type') === 'password' ? 'text' : 'password';
+                apiKeyInput.setAttribute('type', type);
+                toggleApiKeyBtn.innerHTML = type === 'password' ? '<i class="fas fa-eye"></i>' : '<i class="fas fa-eye-slash"></i>';
+            });
+        }
+        
+        // Reset hints button
+        const resetHintsBtn = document.getElementById('reset-hints-btn');
+        if (resetHintsBtn && window.contextualHintSystem) {
+            resetHintsBtn.addEventListener('click', function() {
+                if (confirm('Are you sure you want to reset all hints? This will show all hints again, including those you\'ve chosen not to see.')) {
+                    window.contextualHintSystem.resetShownHints();
+                    updateHintCountDisplay();
+                    // Show confirmation
+                    alert('All hints have been reset and will be shown again.');
+                }
+            });
+        }
+        
+        // Update hint count display
+        function updateHintCountDisplay() {
+            const hintCountDisplay = document.getElementById('hint-count-display');
+            if (hintCountDisplay && window.contextualHintSystem) {
+                const count = window.contextualHintSystem.shownHints.length;
+                hintCountDisplay.textContent = `${count} hints shown`;
+            }
+        }
+        
+        // Call initially
+        updateHintCountDisplay();
+        
+        // Save hint settings
+        const saveHintsSettingsBtn = document.getElementById('save-hints-settings');
+        if (saveHintsSettingsBtn) {
+            saveHintsSettingsBtn.addEventListener('click', function() {
+                const enableHints = document.getElementById('enable_hints').checked;
+                const showParticleEffects = document.getElementById('show_particle_effects').checked;
+                const hintDuration = document.getElementById('hint_duration').value;
+                
+                // Save to localStorage
+                localStorage.setItem('enableHints', enableHints);
+                localStorage.setItem('showParticleEffects', showParticleEffects);
+                localStorage.setItem('hintDuration', hintDuration);
+                
+                // Apply settings
+                if (window.contextualHintSystem) {
+                    // Logic would be implemented in the hint system
+                }
+                
+                // Show confirmation
+                alert('Hint settings saved successfully.');
+            });
+        }
+        
+        // Save UI settings
+        const saveUISettingsBtn = document.getElementById('save-ui-settings');
+        if (saveUISettingsBtn) {
+            saveUISettingsBtn.addEventListener('click', function() {
+                const ledTracerEffects = document.getElementById('led_tracer_effects').checked;
+                const smokeEffects = document.getElementById('smoke_effects').checked;
+                const quantumParticles = document.getElementById('quantum_particles').checked;
+                const reducedAnimations = document.getElementById('reduced_animations').checked;
+                const highContrast = document.getElementById('high_contrast').checked;
+                const focusMode = document.getElementById('focus_mode').checked;
+                
+                // Save to localStorage
+                localStorage.setItem('ledTracerEffects', ledTracerEffects);
+                localStorage.setItem('smokeEffects', smokeEffects);
+                localStorage.setItem('quantumParticles', quantumParticles);
+                localStorage.setItem('reducedAnimations', reducedAnimations);
+                localStorage.setItem('highContrast', highContrast);
+                localStorage.setItem('focusMode', focusMode);
+                
+                // Apply settings
+                document.body.classList.toggle('reduced-animations', reducedAnimations);
+                document.body.classList.toggle('high-contrast', highContrast);
+                document.body.classList.toggle('focus-mode', focusMode);
+                
+                // Show confirmation
+                alert('UI settings saved successfully.');
+            });
+        }
+        
+        // Load saved settings on page load
+        function loadSavedSettings() {
+            // Load hint settings
+            if (localStorage.getItem('enableHints') !== null) {
+                document.getElementById('enable_hints').checked = localStorage.getItem('enableHints') === 'true';
+            }
+            
+            if (localStorage.getItem('showParticleEffects') !== null) {
+                document.getElementById('show_particle_effects').checked = localStorage.getItem('showParticleEffects') === 'true';
+            }
+            
+            if (localStorage.getItem('hintDuration')) {
+                document.getElementById('hint_duration').value = localStorage.getItem('hintDuration');
+            }
+            
+            // Load UI settings
+            if (localStorage.getItem('ledTracerEffects') !== null) {
+                document.getElementById('led_tracer_effects').checked = localStorage.getItem('ledTracerEffects') === 'true';
+            }
+            
+            if (localStorage.getItem('smokeEffects') !== null) {
+                document.getElementById('smoke_effects').checked = localStorage.getItem('smokeEffects') === 'true';
+            }
+            
+            if (localStorage.getItem('quantumParticles') !== null) {
+                document.getElementById('quantum_particles').checked = localStorage.getItem('quantumParticles') === 'true';
+            }
+            
+            if (localStorage.getItem('reducedAnimations') !== null) {
+                document.getElementById('reduced_animations').checked = localStorage.getItem('reducedAnimations') === 'true';
+                document.body.classList.toggle('reduced-animations', localStorage.getItem('reducedAnimations') === 'true');
+            }
+            
+            if (localStorage.getItem('highContrast') !== null) {
+                document.getElementById('high_contrast').checked = localStorage.getItem('highContrast') === 'true';
+                document.body.classList.toggle('high-contrast', localStorage.getItem('highContrast') === 'true');
+            }
+            
+            if (localStorage.getItem('focusMode') !== null) {
+                document.getElementById('focus_mode').checked = localStorage.getItem('focusMode') === 'true';
+                document.body.classList.toggle('focus-mode', localStorage.getItem('focusMode') === 'true');
+            }
+        }
+        
+        // Call initially
+        loadSavedSettings();
+    });
+</script>
+{% endblock %}

start_atlas.sh

@@ -0,0 +1,101 @@
+#!/bin/bash
+#
+# Atlas Startup Script
+# This script launches all Atlas components
+# Created: April 17, 2025
+
+# Set base directory
+BASE_DIR="$HOME"
+VENV_DIR="$BASE_DIR/atlas_venv"
+
+echo "===== Starting Atlas Unified System ====="
+
+# Check if virtual environment exists
+if [ ! -d "$VENV_DIR" ]; then
+    echo "Virtual environment not found. Please run the installer first."
+    echo "Run: ./install_atlas_unified.sh"
+    exit 1
+fi
+
+# Activate the virtual environment
+source "$VENV_DIR/bin/activate"
+
+# Launch components based on what's available
+echo "Starting core components..."
+
+# OpenManus
+if [ -d "$BASE_DIR/OpenManus" ]; then
+    echo "Starting OpenManus..."
+    cd "$BASE_DIR/OpenManus"
+    python -m app.api_server &
+    OPENMANUS_PID=$!
+    echo "OpenManus started with PID: $OPENMANUS_PID"
+fi
+
+# Casibase
+if [ -d "$BASE_DIR/casibase" ] && [ -f "$BASE_DIR/casibase/casibase" ]; then
+    echo "Starting Casibase..."
+    cd "$BASE_DIR/casibase"
+    ./casibase &
+    CASIBASE_PID=$!
+    echo "Casibase started with PID: $CASIBASE_PID"
+fi
+
+# Cypher
+if [ -d "$BASE_DIR/Cypher" ]; then
+    echo "Starting Cypher..."
+    cd "$BASE_DIR/Cypher"
+    python app.py &
+    CYPHER_PID=$!
+    echo "Cypher started with PID: $CYPHER_PID"
+fi
+
+# QuantumVision
+if [ -d "$BASE_DIR/Library/Mobile Documents/com~apple~CloudDocs/Atlas Business/QuantumVision" ]; then
+    echo "Starting QuantumVision..."
+    cd "$BASE_DIR/Library/Mobile Documents/com~apple~CloudDocs/Atlas Business/QuantumVision"
+    python app.py &
+    QV_PID=$!
+    echo "QuantumVision started with PID: $QV_PID"
+fi
+
+# AIConversationCompanion
+if [ -d "$BASE_DIR/Library/Mobile Documents/com~apple~CloudDocs/Atlas Business/AIConversationCompanion" ]; then
+    echo "Starting AIConversationCompanion..."
+    # Start the server
+    cd "$BASE_DIR/Library/Mobile Documents/com~apple~CloudDocs/Atlas Business/AIConversationCompanion/server"
+    npm start &
+    AI_SERVER_PID=$!
+    
+    # Let server initialize
+    sleep 2
+    
+    # Start the client if dist directory exists, otherwise use development mode
+    if [ -d "$BASE_DIR/Library/Mobile Documents/com~apple~CloudDocs/Atlas Business/AIConversationCompanion/dist" ]; then
+        echo "Starting AIConversationCompanion client (production mode)..."
+        AI_CLIENT_PID=$!
+        echo "AIConversationCompanion started with server PID: $AI_SERVER_PID and client PID: $AI_CLIENT_PID"
+    else
+        echo "Starting AIConversationCompanion client (development mode)..."
+        cd "$BASE_DIR/Library/Mobile Documents/com~apple~CloudDocs/Atlas Business/AIConversationCompanion/client"
+        npm run dev &
+        AI_CLIENT_PID=$!
+        echo "AIConversationCompanion started with server PID: $AI_SERVER_PID and client PID: $AI_CLIENT_PID"
+    fi
+fi
+
+echo "All available components started."
+echo "Open http://localhost:8080 to access the main interface."
+echo "Press Ctrl+C to stop all services."
+
+function cleanup {
+  echo "Stopping all services..."
+  kill $OPENMANUS_PID $CASIBASE_PID $CYPHER_PID $QV_PID $AI_SERVER_PID $AI_CLIENT_PID 2>/dev/null
+  echo "All services stopped."
+  exit 0
+}
+
+trap cleanup SIGINT
+
+# Keep script running
+wait

start_atlas_unified.sh

@@ -0,0 +1,146 @@
+#!/bin/bash
+
+# Atlas Unified Platform Launcher
+# This script starts all Atlas components together
+
+# Configuration
+BASE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+OPENMANUS_DIR="$BASE_DIR/../OpenManus"
+CASIBASE_DIR="$BASE_DIR/../casibase"
+CYPHER_DIR="$BASE_DIR/../Cypher"
+QUANTUM_DIR="$BASE_DIR"
+CONVERSATION_DIR="$BASE_DIR/../AIConversationCompanion"
+BRIDGE_DIR="$BASE_DIR/atlas_bridge"
+
+# Terminal colors
+CYAN='\033[0;36m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+RESET='\033[0m'
+
+# Utility functions
+log() {
+    echo -e "${CYAN}[INFO]${RESET} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${RESET} $1"
+}
+
+log_warning() {
+    echo -e "${YELLOW}[WARNING]${RESET} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${RESET} $1"
+}
+
+check_component() {
+    if [ -d "$1" ]; then
+        return 0
+    else
+        log_warning "Directory not found: $1"
+        return 1
+    fi
+}
+
+# Function to start OpenManus
+start_openmanus() {
+    if check_component "$OPENMANUS_DIR"; then
+        log "Starting OpenManus..."
+        cd "$OPENMANUS_DIR" || return
+        # Activate virtual environment if it exists
+        if [ -d "./openmanus_env" ]; then
+            source ./openmanus_env/bin/activate
+        fi
+        # Start the server in the background
+        python run_mcp_server.py > "$BASE_DIR/logs/openmanus.log" 2>&1 &
+        echo $! > "$BASE_DIR/pids/openmanus.pid"
+        log_success "OpenManus started with PID $(cat "$BASE_DIR/pids/openmanus.pid")"
+        # Deactivate virtual environment if it was activated
+        if [ -d "./openmanus_env" ]; then
+            deactivate
+        fi
+    fi
+}
+
+# Function to start Casibase
+start_casibase() {
+    if check_component "$CASIBASE_DIR"; then
+        log "Starting Casibase..."
+        cd "$CASIBASE_DIR" || return
+        ./server > "$BASE_DIR/logs/casibase.log" 2>&1 &
+        echo $! > "$BASE_DIR/pids/casibase.pid"
+        log_success "Casibase started with PID $(cat "$BASE_DIR/pids/casibase.pid")"
+    fi
+}
+
+# Function to start Cypher
+start_cypher() {
+    if check_component "$CYPHER_DIR"; then
+        log "Starting Cypher..."
+        cd "$CYPHER_DIR" || return
+        python app.py > "$BASE_DIR/logs/cypher.log" 2>&1 &
+        echo $! > "$BASE_DIR/pids/cypher.pid"
+        log_success "Cypher started with PID $(cat "$BASE_DIR/pids/cypher.pid")"
+    fi
+}
+
+# Function to start QuantumVision
+start_quantumvision() {
+    if check_component "$QUANTUM_DIR"; then
+        log "Starting QuantumVision..."
+        cd "$QUANTUM_DIR" || return
+        python app.py > "$BASE_DIR/logs/quantumvision.log" 2>&1 &
+        echo $! > "$BASE_DIR/pids/quantumvision.pid"
+        log_success "QuantumVision started with PID $(cat "$BASE_DIR/pids/quantumvision.pid")"
+    fi
+}
+
+# Function to start AIConversationCompanion
+start_conversation_companion() {
+    if check_component "$CONVERSATION_DIR"; then
+        log "Starting AIConversationCompanion..."
+        cd "$CONVERSATION_DIR" || return
+        # Start the server components
+        cd ./server && npm run start:prod > "$BASE_DIR/logs/ai-conv-server.log" 2>&1 &
+        echo $! > "$BASE_DIR/pids/ai-conv-server.pid"
+        log_success "AIConversationCompanion API server started with PID $(cat "$BASE_DIR/pids/ai-conv-server.pid")"
+        
+        # Start the client components
+        cd ../client && npm run dev > "$BASE_DIR/logs/ai-conv-client.log" 2>&1 &
+        echo $! > "$BASE_DIR/pids/ai-conv-client.pid"
+        log_success "AIConversationCompanion client started with PID $(cat "$BASE_DIR/pids/ai-conv-client.pid")"
+    fi
+}
+
+# Function to start the Unified Bridge
+start_bridge() {
+    if [ -d "$BRIDGE_DIR" ]; then
+        log "Starting Atlas Unified Bridge..."
+        cd "$BRIDGE_DIR" || return
+        python bridge_server.py > "$BASE_DIR/logs/bridge.log" 2>&1 &
+        echo $! > "$BASE_DIR/pids/bridge.pid"
+        log_success "Atlas Unified Bridge started with PID $(cat "$BASE_DIR/pids/bridge.pid")"
+    else
+        log_error "Atlas Unified Bridge directory not found"
+    fi
+}
+
+# Create logs and pids directories
+mkdir -p "$BASE_DIR/logs"
+mkdir -p "$BASE_DIR/pids"
+
+# Start all components
+log "Starting Atlas Unified Platform..."
+
+start_openmanus
+start_casibase
+start_cypher
+start_quantumvision
+start_conversation_companion
+start_bridge
+
+log_success "All components started. Logs available in: $BASE_DIR/logs/"
+log "You can access the Unified Bridge at: http://localhost:8080/"

style.css

@@ -1,28 +1,489 @@
+/* Custom styling for the Quantum NLP Framework */
+
+/* LED corner tracers for the Vision OS-inspired cards */
+.led-corner {
+    position: absolute;
+    width: 15px;
+    height: 15px;
+    z-index: 2;
+}
+
+.led-corner-tl {
+    top: 0;
+    left: 0;
+    border-top: 2px solid #da4b86;
+    border-left: 2px solid #da4b86;
+    border-top-left-radius: 6px;
+    box-shadow: -2px -2px 8px rgba(218, 75, 134, 0.3);
+}
+
+.led-corner-tr {
+    top: 0;
+    right: 0;
+    border-top: 2px solid #6f42c1;
+    border-right: 2px solid #6f42c1;
+    border-top-right-radius: 6px;
+    box-shadow: 2px -2px 8px rgba(111, 66, 193, 0.3);
+}
+
+.led-corner-bl {
+    bottom: 0;
+    left: 0;
+    border-bottom: 2px solid #6f42c1;
+    border-left: 2px solid #6f42c1;
+    border-bottom-left-radius: 6px;
+    box-shadow: -2px 2px 8px rgba(111, 66, 193, 0.3);
+}
+
+.led-corner-br {
+    bottom: 0;
+    right: 0;
+    border-bottom: 2px solid #0dcaf0;
+    border-right: 2px solid #0dcaf0;
+    border-bottom-right-radius: 6px;
+    box-shadow: 2px 2px 8px rgba(13, 202, 240, 0.3);
+}
+
+/* Staggered fade-in animation */
+@keyframes fadeInUp {
+    from {
+        opacity: 0;
+        transform: translateY(20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.fade-in {
+    opacity: 0;
+    animation: fadeInUp 0.6s ease forwards;
+}
+
+.fade-in-staggered {
+    opacity: 0;
+    animation: fadeInUp 0.6s ease forwards;
+    animation-delay: var(--stagger-delay, 0s);
+}
 body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
+    background-color: #0a0a10;
+    background-image: 
+        linear-gradient(rgba(10, 10, 16, 0.97), rgba(10, 10, 16, 0.97));
+    background-size: cover;
+    background-position: center;
+    background-attachment: fixed;
+    position: relative;
+    overflow-x: hidden;
+    min-height: 100vh;
+}
+
+/* Overlay animated smoke effect */
+body::before {
+    content: '';
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: url('/static/images/smoke-bg.svg');
+    background-size: cover;
+    opacity: 0.2;
+    animation: smoke-drift 120s linear infinite;
+    pointer-events: none;
+    z-index: -1;
+}
+
+@keyframes smoke-drift {
+    0% { background-position: 0% 0%; }
+    50% { background-position: 100% 50%; }
+    100% { background-position: 0% 0%; }
+}
+
+/* LED tracer line effect for background */
+.quantum-tracer {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    pointer-events: none;
+    z-index: -1;
+}
+
+/* Make textareas more readable */
+textarea.form-control {
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 16px;
+    transition: all 0.3s ease;
+}
+
+textarea.form-control:focus {
+    box-shadow: 0 0 15px rgba(66, 133, 244, 0.3);
+    border-color: rgba(66, 133, 244, 0.7);
+}
+
+/* Style for named entities */
+.entity {
+    padding: 2px 5px;
+    margin: 0 2px;
+    border-radius: 3px;
+    display: inline-block;
+    transition: all 0.3s ease;
 }
 
-h1 {
-	font-size: 16px;
-	margin-top: 0;
+.entity:hover {
+    box-shadow: 0 0 8px rgba(66, 133, 244, 0.6);
+    transform: scale(1.05);
 }
 
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
+/* Entity items in list */
+.quantum-entity-item {
+    transition: all 0.3s ease;
+    position: relative;
+    overflow: hidden;
 }
 
+.quantum-entity-item::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: -100%;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(
+        to right,
+        transparent,
+        rgba(66, 133, 244, 0.1),
+        transparent
+    );
+    transition: all 0.5s ease;
+}
+
+.quantum-entity-item:hover::before {
+    left: 100%;
+}
+
+/* Style for AI response */
+.ai-response {
+    font-size: 1.05rem;
+    line-height: 1.6;
+    white-space: pre-line;
+}
+
+/* Styles for quantum paths */
+.quantum-path {
+    margin-bottom: 15px;
+    padding: 10px;
+    border-radius: 5px;
+}
+
+/* Add a nice fade-in effect for results */
 .card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
+    animation: fadein 0.5s;
+}
+
+@keyframes fadein {
+    from { opacity: 0; }
+    to   { opacity: 1; }
+}
+
+/* Improve accordion styling */
+.accordion-button:focus {
+    box-shadow: none;
+}
+
+/* Make badges more prominent */
+.badge {
+    font-size: 0.85rem;
+    padding: 0.35em 0.65em;
+}
+
+/* Style for form elements */
+.input-group-text {
+    min-width: 40px;
+    justify-content: center;
+}
+
+/* Improve responsiveness for mobile */
+@media (max-width: 768px) {
+    .card-title {
+        font-size: 1.75rem;
+    }
+    
+    .lead {
+        font-size: 1.1rem;
+    }
+}
+
+/* Add a slight glow effect to the main title */
+h1.card-title {
+    text-shadow: 0 0 10px rgba(13, 110, 253, 0.5);
+}
+
+/* Quantum button effects */
+.quantum-btn {
+    position: relative;
+    overflow: hidden;
+    transition: all 0.3s ease;
+    z-index: 1;
+}
+
+.quantum-btn::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(
+        45deg,
+        rgba(66, 133, 244, 0),
+        rgba(66, 133, 244, 0.1),
+        rgba(66, 133, 244, 0)
+    );
+    z-index: -1;
+    transform: translateX(-100%);
+    transition: transform 0.6s ease;
+}
+
+.quantum-btn:hover::before,
+.quantum-btn-hover::before {
+    transform: translateX(100%);
+}
+
+.quantum-btn:hover {
+    box-shadow: 0 0 15px rgba(66, 133, 244, 0.3);
+    transform: translateY(-2px);
+}
+
+.quantum-btn:active {
+    transform: scale(0.97);
+}
+
+/* Textarea with entities */
+.has-entities {
+    transition: all 0.3s ease;
+}
+
+.textarea-glow {
+    border-radius: 4px;
+    animation: textarea-pulse 2s infinite alternate;
+}
+
+@keyframes textarea-pulse {
+    0% {
+        box-shadow: inset 0 0 10px rgba(66, 133, 244, 0.2);
+    }
+    100% {
+        box-shadow: inset 0 0 20px rgba(66, 133, 244, 0.5);
+    }
+}
+
+/* Card reveal animation */
+.quantum-card {
+    position: relative;
+    transition: all 0.4s cubic-bezier(0.165, 0.84, 0.44, 1);
+}
+
+.quantum-card.quantum-reveal {
+    transform: translateY(0);
+}
+
+.quantum-card:hover {
+    transform: translateY(-5px);
+    box-shadow: 0 10px 20px rgba(0, 0, 0, 0.2);
+}
+
+/* Vision OS-inspired glassy UI elements - Borderless with LED glow */
+.glass-card {
+    background: rgba(20, 25, 40, 0.3);
+    backdrop-filter: blur(12px);
+    border: none;
+    border-radius: 16px;
+    box-shadow: 
+        0 10px 30px rgba(0, 0, 0, 0.2),
+        0 0 0 1px rgba(255, 255, 255, 0.05),
+        0 0 15px rgba(218, 75, 134, 0.15),
+        inset 0 0 20px rgba(218, 75, 134, 0.03);
+    overflow: hidden;
+    position: relative;
+}
+
+/* LED edge glow effect */
+.glass-card::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    height: 1px;
+    background: linear-gradient(90deg, 
+        rgba(218, 75, 134, 0), 
+        rgba(218, 75, 134, 0.8), 
+        rgba(111, 66, 193, 0.8), 
+        rgba(13, 202, 240, 0.8),
+        rgba(218, 75, 134, 0));
+    opacity: 0.7;
+    z-index: 1;
+    animation: led-trace 6s linear infinite;
+}
+
+.glass-card::after {
+    content: '';
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    width: 100%;
+    height: 1px;
+    background: linear-gradient(90deg, 
+        rgba(13, 202, 240, 0), 
+        rgba(13, 202, 240, 0.8), 
+        rgba(111, 66, 193, 0.8),
+        rgba(218, 75, 134, 0.8),
+        rgba(13, 202, 240, 0));
+    opacity: 0.3;
+    transition: opacity 0.3s ease;
+    animation: led-trace-reverse 6s linear infinite;
+}
+
+@keyframes led-trace {
+    0% { background-position: -1000px 0; }
+    100% { background-position: 1000px 0; }
+}
+
+@keyframes led-trace-reverse {
+    0% { background-position: 1000px 0; }
+    100% { background-position: -1000px 0; }
+}
+
+.glass-card:hover::after {
+    opacity: 0.8;
+}
+
+.glass-card .card-header {
+    background: rgba(20, 25, 40, 0.4);
+    border: none;
+    padding: 1rem 1.25rem;
+    position: relative;
+    z-index: 1;
+    backdrop-filter: blur(8px);
+}
+
+.glass-card .card-body {
+    background: linear-gradient(135deg, 
+                rgba(20, 25, 40, 0.2) 0%, 
+                rgba(20, 25, 40, 0.1) 100%);
+    border: none;
+    position: relative;
+    z-index: 1;
+    backdrop-filter: blur(8px);
+}
+
+/* Quantum glow effect on hover */
+.quantum-glow {
+    text-shadow: 0 0 5px rgba(218, 75, 134, 0.7);
+    transition: all 0.3s ease;
+}
+
+.quantum-glow:hover {
+    text-shadow: 0 0 15px rgba(218, 75, 134, 0.9);
+}
+
+/* Floating elements */
+.floating {
+    animation: floating 3s ease-in-out infinite;
+}
+
+@keyframes floating {
+    0% { transform: translateY(0px); }
+    50% { transform: translateY(-10px); }
+    100% { transform: translateY(0px); }
+}
+
+/* Vision OS-inspired progress indicators */
+.vision-progress {
+    height: 2px;
+    background: rgba(30, 41, 59, 0.3);
+    border-radius: 2px;
+    overflow: hidden;
+    margin: 15px 0;
+    position: relative;
+}
+
+.vision-progress::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(13, 202, 240, 0.05);
+    box-shadow: 0 0 15px rgba(13, 202, 240, 0.2);
+    filter: blur(3px);
+}
+
+.vision-progress-bar {
+    height: 100%;
+    background: linear-gradient(90deg, 
+        rgba(13, 202, 240, 0.8), 
+        rgba(111, 66, 193, 0.8), 
+        rgba(218, 75, 134, 0.8));
+    border-radius: 2px;
+    animation: progress-slide 5s ease-in-out infinite alternate;
+    position: relative;
+}
+
+.vision-progress-bar::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    right: 0;
+    width: 15px;
+    height: 100%;
+    background: linear-gradient(90deg, 
+        rgba(255, 255, 255, 0), 
+        rgba(255, 255, 255, 0.8));
+    filter: blur(3px);
+    opacity: 0.8;
+}
+
+@keyframes progress-slide {
+    0% { width: 0%; transform: translateX(0); }
+    10% { width: 30%; }
+    30% { width: 60%; }
+    50% { width: 40%; }
+    70% { width: 75%; }
+    100% { width: 55%; }
+}
+
+/* Hover glow effects */
+.glow-hover {
+    position: relative;
+    transition: all 0.3s ease, text-shadow 0.3s ease;
+    z-index: 1;
+}
+
+.glow-hover:hover {
+    text-shadow: 0 0 8px rgba(218, 75, 134, 0.7);
+    transform: translateY(-2px);
+}
+
+.glow-hover::after {
+    content: '';
+    position: absolute;
+    bottom: -3px;
+    left: 0;
+    width: 100%;
+    height: 1px;
+    background: linear-gradient(90deg, 
+        rgba(218, 75, 134, 0), 
+        rgba(218, 75, 134, 0.7), 
+        rgba(218, 75, 134, 0));
+    opacity: 0;
+    transition: opacity 0.3s ease;
 }
 
-.card p:last-child {
-	margin-bottom: 0;
+.glow-hover:hover::after {
+    opacity: 1;
 }

task_scheduler.py

@@ -0,0 +1,298 @@
+"""
+Task scheduler module for handling background tasks and automation scheduling.
+This module enables the AI assistant to run tasks in the background and
+schedule activities for optimal workflow management.
+"""
+
+import logging
+import threading
+import time
+from datetime import datetime, timedelta
+import json
+from functools import wraps
+
+from models import Task, db
+import browser_automation
+
+logger = logging.getLogger(__name__)
+
+
+# Threading lock for task execution
+task_lock = threading.Lock()
+
+
+def with_db_context(func):
+    """Decorator to ensure DB operations are handled in the correct context"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        from app import app
+        with app.app_context():
+            return func(*args, **kwargs)
+    return wrapper
+
+
+class TaskScheduler:
+    """Class for scheduling and executing tasks in the background"""
+    
+    def __init__(self):
+        self.scheduler_thread = None
+        self.running = False
+        self.task_handlers = {
+            'web_scrape': self.handle_web_scrape_task,
+            'analyze': self.handle_analyze_task,
+            'recursive': self.handle_recursive_task,
+            'workflow': self.handle_workflow_task,
+        }
+        
+    def start(self):
+        """Start the task scheduler thread"""
+        if self.scheduler_thread and self.scheduler_thread.is_alive():
+            logger.warning("Scheduler is already running")
+            return
+            
+        self.running = True
+        self.scheduler_thread = threading.Thread(
+            target=self.scheduler_loop,
+            daemon=True
+        )
+        self.scheduler_thread.start()
+        logger.info("Task scheduler started")
+        
+    def stop(self):
+        """Stop the task scheduler thread"""
+        self.running = False
+        if self.scheduler_thread:
+            self.scheduler_thread.join(timeout=5.0)
+            logger.info("Task scheduler stopped")
+            
+    @with_db_context
+    def scheduler_loop(self):
+        """Main scheduler loop to check and execute scheduled tasks"""
+        while self.running:
+            try:
+                # Find scheduled tasks that are due
+                now = datetime.utcnow()
+                due_tasks = Task.query.filter(
+                    Task.status == 'pending',
+                    Task.scheduled_for <= now
+                ).limit(5).all()
+                
+                # Execute each due task
+                for task in due_tasks:
+                    self.execute_task(task)
+                    
+                # Sleep for a short period before checking again
+                time.sleep(5)
+                
+            except Exception as e:
+                logger.error(f"Error in scheduler loop: {str(e)}")
+                time.sleep(10)  # Sleep longer on error
+    
+    @with_db_context
+    def execute_task(self, task):
+        """Execute a task based on its type"""
+        try:
+            # Lock to prevent multiple executions
+            with task_lock:
+                task.status = 'in_progress'
+                db.session.commit()
+                
+            # Get the appropriate handler for this task type
+            handler = self.task_handlers.get(task.task_type)
+            
+            if handler:
+                result = handler(task)
+                
+                with task_lock:
+                    if result.get('status') == 'success':
+                        task.status = 'completed'
+                        task.completed_at = datetime.utcnow()
+                    else:
+                        task.status = 'failed'
+                        
+                    task.result = result
+                    db.session.commit()
+            else:
+                logger.error(f"No handler for task type: {task.task_type}")
+                with task_lock:
+                    task.status = 'failed'
+                    task.result = {'error': f"No handler for task type: {task.task_type}"}
+                    db.session.commit()
+                
+        except Exception as e:
+            logger.error(f"Error executing task {task.id}: {str(e)}")
+            with task_lock:
+                task.status = 'failed'
+                task.result = {'error': str(e)}
+                db.session.commit()
+    
+    def handle_web_scrape_task(self, task):
+        """Handle a web scraping task"""
+        return browser_automation.execute_scraping_task(task.id)
+    
+    def handle_analyze_task(self, task):
+        """Handle an analysis task"""
+        # Use the quantum thinking process for analysis
+        try:
+            from quantum_thinking import quantum_recursive_thinking
+            
+            # Get the text to analyze from the task config
+            text = task.config.get('text', '')
+            depth = task.config.get('depth', 3)
+            
+            # Run the quantum thinking process
+            quantum_results = quantum_recursive_thinking(text, depth=depth)
+            
+            return {
+                'status': 'success',
+                'quantum_results': quantum_results,
+                'timestamp': datetime.utcnow().isoformat()
+            }
+        except Exception as e:
+            logger.error(f"Error in analyze task: {str(e)}")
+            return {'status': 'error', 'error': str(e)}
+    
+    def handle_recursive_task(self, task):
+        """Handle a recursive task that creates subtasks"""
+        try:
+            # Get the configuration for subtasks
+            subtasks_config = task.config.get('subtasks', [])
+            results = []
+            
+            # Create each subtask
+            for subtask_config in subtasks_config:
+                subtask = Task(
+                    title=subtask_config.get('title', 'Subtask'),
+                    description=subtask_config.get('description', ''),
+                    status='pending',
+                    priority=subtask_config.get('priority', task.priority),
+                    task_type=subtask_config.get('task_type', 'web_scrape'),
+                    scheduled_for=subtask_config.get('scheduled_for'),
+                    config=subtask_config.get('config', {}),
+                    parent_id=task.id
+                )
+                db.session.add(subtask)
+                results.append({
+                    'subtask_title': subtask.title,
+                    'status': 'created'
+                })
+                
+            db.session.commit()
+            
+            return {
+                'status': 'success',
+                'subtasks_created': len(subtasks_config),
+                'results': results
+            }
+        except Exception as e:
+            logger.error(f"Error in recursive task: {str(e)}")
+            return {'status': 'error', 'error': str(e)}
+    
+    def handle_workflow_task(self, task):
+        """Handle a workflow template execution"""
+        try:
+            workflow_id = task.config.get('workflow_id')
+            if not workflow_id:
+                return {'status': 'error', 'error': 'No workflow ID provided'}
+                
+            from models import WorkflowTemplate
+            workflow = WorkflowTemplate.query.get(workflow_id)
+            if not workflow:
+                return {'status': 'error', 'error': f'Workflow ID {workflow_id} not found'}
+                
+            # Create tasks for each workflow step
+            steps = workflow.steps
+            results = []
+            
+            # Schedule with appropriate delays
+            now = datetime.utcnow()
+            delay_minutes = 0
+            
+            for i, step in enumerate(steps):
+                scheduled_time = now + timedelta(minutes=delay_minutes)
+                
+                subtask = Task(
+                    title=f"{workflow.name} - Step {i+1}: {step.get('title', 'Step')}",
+                    description=step.get('description', ''),
+                    status='pending',
+                    task_type=step.get('task_type', 'web_scrape'),
+                    scheduled_for=scheduled_time,
+                    config=step.get('config', {}),
+                    parent_id=task.id
+                )
+                db.session.add(subtask)
+                results.append({
+                    'step': i+1,
+                    'title': subtask.title,
+                    'scheduled_for': scheduled_time.isoformat()
+                })
+                
+                # Increment delay for next task
+                delay_minutes += step.get('delay_minutes', 5)
+                
+            db.session.commit()
+            
+            return {
+                'status': 'success',
+                'workflow_name': workflow.name,
+                'steps_created': len(steps),
+                'results': results
+            }
+        except Exception as e:
+            logger.error(f"Error in workflow task: {str(e)}")
+            return {'status': 'error', 'error': str(e)}
+
+
+# Global scheduler instance
+scheduler = TaskScheduler()
+
+
+# Helper functions for task management
+def schedule_task(title, task_type, config=None, description=None, priority=3, scheduled_for=None):
+    """Schedule a new task"""
+    try:
+        task = Task(
+            title=title,
+            description=description,
+            status='pending',
+            priority=priority,
+            task_type=task_type,
+            scheduled_for=scheduled_for or datetime.utcnow(),
+            config=config or {}
+        )
+        db.session.add(task)
+        db.session.commit()
+        return task.id
+    except Exception as e:
+        logger.error(f"Error scheduling task: {str(e)}")
+        db.session.rollback()
+        return None
+
+
+def get_pending_tasks(limit=10):
+    """Get a list of pending tasks"""
+    return Task.query.filter_by(status='pending').order_by(
+        Task.priority.desc(),
+        Task.scheduled_for.asc()
+    ).limit(limit).all()
+
+
+def get_completed_tasks(limit=10):
+    """Get a list of completed tasks"""
+    return Task.query.filter_by(status='completed').order_by(
+        Task.completed_at.desc()
+    ).limit(limit).all()
+
+
+def get_task_result(task_id):
+    """Get the result of a task"""
+    task = Task.query.get(task_id)
+    if not task:
+        return None
+    return {
+        'id': task.id,
+        'title': task.title,
+        'status': task.status,
+        'result': task.result,
+        'completed_at': task.completed_at.isoformat() if task.completed_at else None
+    }

update_unified_bridge.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Atlas Intelligence Unified Bridge Update
+This script updates the unified_bridge.py file to use the enhanced NLP processor
+with Ollama Llama 3 support and better error handling.
+"""
+
+import os
+import sys
+import shutil
+import re
+
+# Define the path to the unified bridge file
+UNIFIED_BRIDGE_PATH = os.path.expanduser("~/AtlasUnified/unified_bridge.py")
+BACKUP_PATH = os.path.expanduser("~/AtlasUnified/unified_bridge.py.bak")
+
+def backup_original_file():
+    """Create a backup of the original file"""
+    if os.path.exists(UNIFIED_BRIDGE_PATH):
+        print(f"Creating backup at {BACKUP_PATH}")
+        shutil.copy2(UNIFIED_BRIDGE_PATH, BACKUP_PATH)
+        return True
+    else:
+        print(f"Error: Unified bridge file not found at {UNIFIED_BRIDGE_PATH}")
+        return False
+
+def fix_quantum_vision_integration(content):
+    """Update Quantum Vision integration to use enhanced_process_text"""
+    # Find and replace the QuantumVision integration section
+    quantum_pattern = r"# Process with Quantum Vision if enabled.*?(?=\s{4}return results|$)"
+    quantum_replacement = """# Process with Quantum Vision if enabled - UPDATED to use enhanced processing with Ollama Llama 3
+    if config["integrations"]["enable_quantum_vision"]:
+        try:
+            sys.path.append(config["paths"]["quantum_vision"])
+            import nlp_processor
+            
+            # Use the enhanced processing function with multiple fallbacks
+            quantum_result = nlp_processor.enhanced_process_text(query_text)
+            
+            # Extract the simple response for the main response field
+            simple_response = quantum_result.get("simple_response", "")
+            
+            results["quantum_vision"] = {
+                "response": simple_response,
+                "detailed_results": quantum_result
+            }
+                
+        except Exception as e:
+            logger.error(f"Quantum Vision processing error: {e}")
+            logger.error(traceback.format_exc())
+            results["quantum_vision"] = {"error": str(e)}
+    
+"""
+    return re.sub(quantum_pattern, quantum_replacement, content, flags=re.DOTALL)
+
+def main():
+    """Main function to apply all updates"""
+    # Check if the unified bridge file exists
+    if not os.path.exists(UNIFIED_BRIDGE_PATH):
+        print(f"Error: Unified bridge file not found at {UNIFIED_BRIDGE_PATH}")
+        return False
+    
+    # Create a backup
+    if not backup_original_file():
+        return False
+    
+    # Read the file content
+    with open(UNIFIED_BRIDGE_PATH, 'r') as file:
+        content = file.read()
+    
+    # Apply update
+    content = fix_quantum_vision_integration(content)
+    
+    # Write the updated content back
+    with open(UNIFIED_BRIDGE_PATH, 'w') as file:
+        file.write(content)
+    
+    print("Updates applied successfully!")
+    print("Restart the Atlas Unified service to apply the changes.")
+    return True
+
+if __name__ == "__main__":
+    main()

zap_integrations.html

@@ -0,0 +1,290 @@
+{% extends 'layout.html' %}
+
+{% block content %}
+<div class="row mb-4">
+    <div class="col-12">
+        <div class="glass-card">
+            <div class="p-4">
+                <h1 class="display-5 quantum-glow">
+                    <i class="fas fa-bolt me-2"></i> ZAP Integrations
+                </h1>
+                <p class="lead">Connect your Quantum NLP Framework to external services with predefined automation workflows.</p>
+                <div class="vision-progress">
+                    <div class="vision-progress-bar"></div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<div class="row" id="integrations-container">
+    {% for integration in integrations %}
+    <div class="col-md-6 col-lg-4 mb-4 fade-in" style="animation-delay: {{ loop.index * 0.15 }}s">
+        <div class="glass-card h-100 position-relative overflow-hidden">
+            <div class="card-body p-4">
+                <div class="d-flex justify-content-between align-items-start mb-3">
+                    <div class="integration-icon rounded-circle d-flex align-items-center justify-content-center" 
+                         style="width: 60px; height: 60px; background: rgba(20, 25, 40, 0.5);">
+                        <i class="fas {{ integration.icon }} fa-2x text-light"></i>
+                    </div>
+                    <span class="badge {% if integration.status == 'active' %}bg-success{% elif integration.status == 'pending' %}bg-warning{% else %}bg-danger{% endif %} quantum-score">
+                        {{ integration.status | capitalize }}
+                    </span>
+                </div>
+                
+                <h3 class="h4 mb-3">{{ integration.name }}</h3>
+                <p class="text-muted mb-0">{{ integration.description }}</p>
+                
+                <div class="mt-4 d-flex justify-content-between align-items-center">
+                    <button class="btn btn-sm btn-outline-light glow-hover">Configure</button>
+                    <div class="form-check form-switch">
+                        <input class="form-check-input" type="checkbox" id="integration-{{ loop.index }}" {% if integration.status == 'active' %}checked{% endif %}>
+                        <label class="form-check-label" for="integration-{{ loop.index }}">Enabled</label>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- LED corner tracers -->
+            <div class="led-corner led-corner-tl"></div>
+            <div class="led-corner led-corner-tr"></div>
+            <div class="led-corner led-corner-bl"></div>
+            <div class="led-corner led-corner-br"></div>
+        </div>
+    </div>
+    {% endfor %}
+</div>
+
+<div class="row mt-5">
+    <div class="col-12">
+        <div class="glass-card">
+            <div class="card-body p-4">
+                <h3 class="h4 mb-4 quantum-glow">Connect New Service</h3>
+                
+                <form>
+                    <div class="row g-3">
+                        <div class="col-md-6">
+                            <div class="form-floating mb-3">
+                                <input type="text" class="form-control" id="serviceName" placeholder="Service Name">
+                                <label for="serviceName">Service Name</label>
+                            </div>
+                        </div>
+                        <div class="col-md-6">
+                            <div class="form-floating mb-3">
+                                <select class="form-select" id="serviceType">
+                                    <option selected>Select service type</option>
+                                    <option value="api">API Integration</option>
+                                    <option value="webhook">Webhook</option>
+                                    <option value="notification">Notification Service</option>
+                                    <option value="export">Data Export</option>
+                                </select>
+                                <label for="serviceType">Service Type</label>
+                            </div>
+                        </div>
+                        <div class="col-12">
+                            <div class="form-floating mb-3">
+                                <input type="url" class="form-control" id="endpointUrl" placeholder="Endpoint URL">
+                                <label for="endpointUrl">Endpoint URL</label>
+                            </div>
+                        </div>
+                        <div class="col-md-6">
+                            <div class="form-floating mb-3">
+                                <input type="text" class="form-control" id="apiKey" placeholder="API Key">
+                                <label for="apiKey">API Key (if required)</label>
+                            </div>
+                        </div>
+                        <div class="col-md-6">
+                            <div class="form-floating mb-3">
+                                <select class="form-select" id="frequency">
+                                    <option value="realtime">Real-time</option>
+                                    <option value="hourly">Hourly</option>
+                                    <option value="daily">Daily</option>
+                                    <option value="weekly">Weekly</option>
+                                </select>
+                                <label for="frequency">Execution Frequency</label>
+                            </div>
+                        </div>
+                        <div class="col-12 text-end">
+                            <button type="submit" class="btn btn-primary quantum-btn">
+                                <i class="fas fa-plus me-2"></i> Add Integration
+                            </button>
+                        </div>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+</div>
+
+<style>
+    /* LED corner tracers */
+    .led-corner {
+        position: absolute;
+        width: 15px;
+        height: 15px;
+        z-index: 2;
+    }
+    
+    .led-corner-tl {
+        top: 0;
+        left: 0;
+        border-top: 2px solid #da4b86;
+        border-left: 2px solid #da4b86;
+        border-top-left-radius: 6px;
+    }
+    
+    .led-corner-tr {
+        top: 0;
+        right: 0;
+        border-top: 2px solid #6f42c1;
+        border-right: 2px solid #6f42c1;
+        border-top-right-radius: 6px;
+    }
+    
+    .led-corner-bl {
+        bottom: 0;
+        left: 0;
+        border-bottom: 2px solid #6f42c1;
+        border-left: 2px solid #6f42c1;
+        border-bottom-left-radius: 6px;
+    }
+    
+    .led-corner-br {
+        bottom: 0;
+        right: 0;
+        border-bottom: 2px solid #0dcaf0;
+        border-right: 2px solid #0dcaf0;
+        border-bottom-right-radius: 6px;
+    }
+    
+    /* Animation for staggered appearance */
+    @keyframes fadeInUp {
+        from {
+            opacity: 0;
+            transform: translateY(20px);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+    
+    .fade-in {
+        opacity: 0;
+        animation: fadeInUp 0.6s ease forwards;
+    }
+    
+    /* Integration icon pulse */
+    .integration-icon {
+        position: relative;
+        transition: all 0.3s ease;
+        overflow: hidden;
+    }
+    
+    .integration-icon::after {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background: radial-gradient(circle, rgba(218, 75, 134, 0.4) 0%, transparent 70%);
+        opacity: 0;
+        transition: opacity 0.3s ease;
+    }
+    
+    .glass-card:hover .integration-icon::after {
+        opacity: 1;
+    }
+    
+    /* Form styling */
+    .form-control, .form-select {
+        background-color: rgba(30, 41, 59, 0.3);
+        border: 1px solid rgba(255, 255, 255, 0.1);
+        color: #fff;
+    }
+    
+    .form-control:focus, .form-select:focus {
+        background-color: rgba(30, 41, 59, 0.5);
+        border-color: rgba(218, 75, 134, 0.5);
+        box-shadow: 0 0 0 0.25rem rgba(218, 75, 134, 0.25);
+        color: #fff;
+    }
+    
+    .form-floating label {
+        color: rgba(255, 255, 255, 0.7);
+    }
+    
+    .form-floating .form-control:focus ~ label,
+    .form-floating .form-select:focus ~ label {
+        color: rgba(255, 255, 255, 0.9);
+    }
+</style>
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    // Initialize the cards with staggered animation
+    const cards = document.querySelectorAll('.fade-in');
+    
+    // Initialize event listeners for the integration switches
+    const switches = document.querySelectorAll('.form-check-input');
+    switches.forEach(switchEl => {
+        switchEl.addEventListener('change', function() {
+            const card = this.closest('.glass-card');
+            const statusBadge = card.querySelector('.badge');
+            
+            if (this.checked) {
+                statusBadge.className = 'badge bg-success quantum-score';
+                statusBadge.textContent = 'Active';
+                
+                // Show success animation
+                triggerParticleEffect(card, '#28a745');
+            } else {
+                statusBadge.className = 'badge bg-danger quantum-score';
+                statusBadge.textContent = 'Inactive';
+                
+                // Show deactivation animation
+                triggerParticleEffect(card, '#dc3545');
+            }
+        });
+    });
+    
+    // Particle effect function
+    function triggerParticleEffect(element, color) {
+        const rect = element.getBoundingClientRect();
+        const centerX = rect.left + rect.width / 2;
+        const centerY = rect.top + rect.height / 2;
+        
+        // Create particles
+        for (let i = 0; i < 20; i++) {
+            createParticle(centerX, centerY, color);
+        }
+    }
+    
+    function createParticle(x, y, color) {
+        const particle = document.createElement('div');
+        particle.className = 'quantum-particle';
+        particle.style.left = x + 'px';
+        particle.style.top = y + 'px';
+        particle.style.color = color;
+        
+        // Random direction and speed
+        const angle = Math.random() * Math.PI * 2;
+        const speed = 1 + Math.random() * 3;
+        particle.speedX = Math.cos(angle) * speed;
+        particle.speedY = Math.sin(angle) * speed;
+        
+        document.body.appendChild(particle);
+        
+        // Animate and remove
+        setTimeout(() => {
+            particle.style.left = (x + particle.speedX * 40) + 'px';
+            particle.style.top = (y + particle.speedY * 40) + 'px';
+            
+            setTimeout(() => {
+                particle.remove();
+            }, 1000);
+        }, 10);
+    }
+});
+</script>
+{% endblock %}