Elizabeth data update 2025-08-23 17:33

elizabeth_memory.db

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c8308069b94201cea8de296f67b0bc87ced80efc320564781de3dfc145147017
-size 5480448
+oid sha256:b821f43479f7e991aa42123fd6f4550aab786a073db7520c4d470b04cee25dce
+size 6025216

manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0",
-  "timestamp": "2025-08-23T16:57:46.908916",
+  "timestamp": "2025-08-23T17:33:09.802721",
   "elizabeth_version": "v0.0.2",
   "data_sources": [
     {

repository/scripts/elizabeth-training.service

@@ -0,0 +1,31 @@
+[Unit]
+Description=Elizabeth AI Training Monitor
+After=network.target
+StartLimitIntervalSec=500
+StartLimitBurst=5
+
+[Service]
+Type=simple
+User=x
+Group=x
+WorkingDirectory=/workspace/elizabeth-repo
+ExecStart=/usr/bin/python3 /workspace/elizabeth-repo/scripts/training_monitor.py --start --max-restarts 20 --restart-delay 30
+Restart=always
+RestartSec=10
+Environment=PYTHONUNBUFFERED=1
+Environment=HF_TOKEN=
+Environment=HUGGINGFACE_HUB_ENABLE_HF_TRANSFER=1
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=elizabeth-training
+
+# Security
+NoNewPrivileges=yes
+ProtectSystem=strict
+ProtectHome=yes
+PrivateTmp=yes
+
+[Install]
+WantedBy=multi-user.target

repository/scripts/keep_alive.sh

@@ -0,0 +1,87 @@
+#!/bin/bash
+# Elizabeth Training Keep-Alive Script
+# Provides periodic input to keep training sessions active
+
+echo "=== Elizabeth Training Keep-Alive ==="
+echo "Started: $(date)"
+
+# Training prompts to keep session active
+TRAINING_PROMPTS=(
+    "Please continue your training and analysis"
+    "Share your latest insights and learning progress"
+    "What have you discovered in your recent training?"
+    "Continue with your autonomous learning cycle"
+    "Provide a status update on your training progress"
+    "What patterns are you identifying in your learning?"
+    "Continue your analysis and share key findings"
+)
+
+# Find active Elizabeth training process
+find_elizabeth_pid() {
+    ps aux | grep "python3.*elizabeth_main.py.*interactive" | grep -v grep | awk '{print $2}' | head -1
+}
+
+# Send input to process
+send_training_prompt() {
+    local pid=$1
+    local prompt=$2
+    
+    # Check if process exists and is interactive
+    if [ -n "$pid" ] && [ -e "/proc/$pid/fd/0" ]; then
+        echo "Sending training prompt to PID $pid: $prompt"
+        echo "$prompt" > /proc/$pid/fd/0
+        return 0
+    else
+        echo "No active interactive training process found"
+        return 1
+    fi
+}
+
+# Main keep-alive loop
+COUNTER=0
+MAX_ITERATIONS=100
+SLEEP_DURATION=300  # 5 minutes
+
+while [ $COUNTER -lt $MAX_ITERATIONS ]; do
+    echo ""
+    echo "[$(date)] Keep-alive iteration $((COUNTER + 1))/$MAX_ITERATIONS"
+    
+    # Find active training process
+    TRAINING_PID=$(find_elizabeth_pid)
+    
+    if [ -n "$TRAINING_PID" ]; then
+        echo "Found training process: PID $TRAINING_PID"
+        
+        # Select random prompt
+        PROMPT_INDEX=$((RANDOM % ${#TRAINING_PROMPTS[@]}))
+        SELECTED_PROMPT="${TRAINING_PROMPTS[$PROMPT_INDEX]}"
+        
+        # Send keep-alive prompt
+        if send_training_prompt "$TRAINING_PID" "$SELECTED_PROMPT"; then
+            echo "Keep-alive prompt sent successfully"
+        else
+            echo "Failed to send keep-alive prompt"
+        fi
+    else
+        echo "No active training process found - checking for restart..."
+        
+        # Check if training manager is running
+        if ! ps aux | grep -q "training_manager.py" | grep -v grep; then
+            echo "Training manager not running, attempting to restart..."
+            cd /workspace/elizabeth-repo
+            nohup python3 scripts/training_manager.py --start --mode interactive > /workspace/elizabeth_logs/training_manager.log 2>&1 &
+            echo "Training manager restarted"
+        fi
+    fi
+    
+    # Wait before next iteration
+    echo "Sleeping for $SLEEP_DURATION seconds..."
+    sleep $SLEEP_DURATION
+    
+    COUNTER=$((COUNTER + 1))
+done
+
+echo ""
+echo "=== Keep-Alive Completed ==="
+echo "Finished: $(date)"
+echo "Total iterations: $COUNTER"

repository/scripts/monitoring_dashboard.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+# Elizabeth Training Monitoring Dashboard
+
+echo "=== Elizabeth Training Monitoring Dashboard ==="
+echo "Timestamp: $(date)"
+echo ""
+
+# Check training manager
+echo "📊 Training Manager Status:"
+if ps aux | grep -q "training_manager.py" | grep -v grep; then
+    echo "  ✅ RUNNING - Training manager active"
+    MANAGER_PID=$(ps aux | grep "training_manager.py" | grep -v grep | awk '{print $2}')
+    echo "  PID: $MANAGER_PID"
+else
+    echo "  ❌ STOPPED - Training manager not running"
+fi
+
+echo ""
+
+# Check Elizabeth processes
+echo "🤖 Elizabeth Processes:"
+ELIZABETH_PROCS=$(ps aux | grep "python3.*elizabeth" | grep -v grep)
+if [ -n "$ELIZABETH_PROCS" ]; then
+    echo "$ELIZABETH_PROCS" | while read line; do
+        echo "  ✅ $line"
+    done
+    COUNT=$(echo "$ELIZABETH_PROCS" | wc -l)
+    echo "  Total processes: $COUNT"
+else
+    echo "  ❌ No Elizabeth processes found"
+fi
+
+echo ""
+
+# Check logs
+echo "📋 Log Files:"
+LOG_FILES=$(ls -la /workspace/elizabeth_logs/ 2>/dev/null)
+if [ -n "$LOG_FILES" ]; then
+    echo "  Log directory: /workspace/elizabeth_logs/"
+    echo "  Files:"
+    ls -la /workspace/elizabeth_logs/ | tail -5 | while read line; do
+        echo "    $line"
+    done
+else
+    echo "  ❌ No log directory found"
+fi
+
+echo ""
+
+# Check training history
+echo "📈 Training History:"
+if [ -f "/workspace/elizabeth_logs/training_history.json" ]; then
+    SESSIONS=$(jq '.total_sessions' /workspace/elizabeth_logs/training_history.json 2>/dev/null)
+    RESTARTS=$(jq '.total_restarts' /workspace/elizabeth_logs/training_history.json 2>/dev/null)
+    echo "  Total sessions: ${SESSIONS:-0}"
+    echo "  Total restarts: ${RESTARTS:-0}"
+else
+    echo "  No training history found"
+fi
+
+echo ""
+
+# System status
+echo "🖥️  System Status:"
+CPU=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}')
+MEM=$(free -m | awk '/Mem:/ {printf "%.1f%%", $3/$2*100}')
+echo "  CPU Usage: $CPU%"
+echo "  Memory Usage: $MEM"
+
+echo ""
+echo "=== Dashboard Refresh: $(date) ==="
+echo "Run this script periodically to monitor training status"

repository/scripts/start_training.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# Elizabeth Training Startup Script
+# Auto-restarting training monitor
+
+echo "=== Starting Elizabeth Training Monitor ==="
+echo "Timestamp: $(date)"
+echo "Working directory: $(pwd)"
+
+# Set environment variables
+export HF_TOKEN=${HF_TOKEN:-}
+export HUGGINGFACE_HUB_ENABLE_HF_TRANSFER=1
+export PYTHONUNBUFFERED=1
+
+# Create logs directory
+mkdir -p /workspace/elizabeth_logs
+
+# Maximum restarts
+MAX_RESTARTS=20
+RESTART_DELAY=30
+
+echo "Max restarts: $MAX_RESTARTS"
+echo "Restart delay: ${RESTART_DELAY}s"
+echo ""
+
+RESTART_COUNT=0
+
+while [ $RESTART_COUNT -le $MAX_RESTARTS ]; do
+    echo "[$(date)] Starting training session (Attempt $((RESTART_COUNT + 1))/$((MAX_RESTARTS + 1)))..."
+    
+    # Start Elizabeth training
+    python3 /workspace/elizabeth-repo/src/elizabeth_main.py --interactive --version v0.0.2
+    
+    EXIT_CODE=$?
+    echo "[$(date)] Training session ended with exit code: $EXIT_CODE"
+    
+    if [ $EXIT_CODE -eq 0 ]; then
+        echo "Training completed successfully!"
+        break
+    fi
+    
+    RESTART_COUNT=$((RESTART_COUNT + 1))
+    
+    if [ $RESTART_COUNT -le $MAX_RESTARTS ]; then
+        echo "Restarting in $RESTART_DELAY seconds..."
+        sleep $RESTART_DELAY
+    else
+        echo "Maximum restart attempts reached!"
+        echo "Total restarts: $RESTART_COUNT"
+        break
+    fi
+done
+
+echo "=== Training Monitor Finished ==="
+echo "Final restart count: $RESTART_COUNT"
+echo "End time: $(date)"

repository/scripts/test_databases.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Test script to verify all DataOps database connections for Elizabeth
+"""
+
+import os
+import sys
+import redis
+import chromadb
+import psycopg2
+import pymongo
+import qdrant_client
+from datetime import datetime
+
+def test_redis():
+    """Test Redis connection"""
+    try:
+        client = redis.Redis(host='localhost', port=6379, decode_responses=True)
+        client.ping()
+        print("✅ Redis: Connected successfully")
+        return True
+    except Exception as e:
+        print(f"❌ Redis: Connection failed - {e}")
+        return False
+
+def test_postgresql():
+    """Test PostgreSQL connection"""
+    try:
+        conn = psycopg2.connect(
+            host="localhost",
+            database="novadb",
+            user="postgres",
+            password="nova_db_pass"
+        )
+        cursor = conn.cursor()
+        cursor.execute("SELECT version();")
+        version = cursor.fetchone()
+        print(f"✅ PostgreSQL: Connected successfully - {version[0]}")
+        conn.close()
+        return True
+    except Exception as e:
+        print(f"❌ PostgreSQL: Connection failed - {e}")
+        return False
+
+def test_mongodb():
+    """Test MongoDB connection"""
+    try:
+        client = pymongo.MongoClient("mongodb://localhost:27017/")
+        db = client["nova_documents"]
+        # Test connection by listing collections
+        collections = db.list_collection_names()
+        print(f"✅ MongoDB: Connected successfully - Collections: {len(collections)}")
+        return True
+    except Exception as e:
+        print(f"❌ MongoDB: Connection failed - {e}")
+        return False
+
+def test_chromadb():
+    """Test ChromaDB connection"""
+    try:
+        client = chromadb.PersistentClient(path="/data/chromadb")
+        collections = client.list_collections()
+        print(f"✅ ChromaDB: Connected successfully - Collections: {len(collections)}")
+        return True
+    except Exception as e:
+        print(f"❌ ChromaDB: Connection failed - {e}")
+        return False
+
+def test_qdrant():
+    """Test Qdrant connection"""
+    try:
+        client = qdrant_client.QdrantClient(
+            host="localhost", 
+            port=17000,
+            prefer_grpc=False
+        )
+        collections = client.get_collections()
+        print(f"✅ Qdrant: Connected successfully - Collections: {len(collections.collections)}")
+        return True
+    except Exception as e:
+        print(f"❌ Qdrant: Connection failed - {e}")
+        return False
+
+def test_dragonfly():
+    """Test DragonFly connection"""
+    try:
+        client = redis.Redis(host='localhost', port=18000, decode_responses=True)
+        client.ping()
+        print("✅ DragonFly: Connected successfully")
+        return True
+    except Exception as e:
+        print(f"❌ DragonFly: Connection failed - {e}")
+        return False
+
+def main():
+    """Main test function"""
+    print("🔍 Testing Elizabeth DataOps Database Connections")
+    print("=" * 60)
+    
+    results = {}
+    
+    # Test all databases
+    results["redis"] = test_redis()
+    results["postgresql"] = test_postgresql()
+    results["mongodb"] = test_mongodb()
+    results["chromadb"] = test_chromadb()
+    results["qdrant"] = test_qdrant()
+    results["dragonfly"] = test_dragonfly()
+    
+    print("=" * 60)
+    
+    # Summary
+    successful = sum(results.values())
+    total = len(results)
+    
+    print(f"📊 Connection Summary: {successful}/{total} successful")
+    
+    if successful == total:
+        print("🎉 All DataOps databases connected successfully!")
+        print("Elizabeth can now utilize the complete infrastructure.")
+    else:
+        print("⚠️  Some connections failed. Elizabeth will use available databases.")
+    
+    return all(results.values())
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

repository/scripts/training_manager.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+"""
+Elizabeth Training Manager
+Advanced training management with multiple training modes and robust monitoring
+"""
+
+import os
+import sys
+import time
+import subprocess
+import signal
+import logging
+import json
+from datetime import datetime
+from pathlib import Path
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('/workspace/elizabeth_logs/training_manager.log'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+class TrainingManager:
+    """Advanced training management for Elizabeth"""
+    
+    def __init__(self):
+        self.script_path = "/workspace/elizabeth-repo/src/elizabeth_main.py"
+        self.max_restarts = 20
+        self.restart_delay = 30
+        self.process = None
+        self.restart_count = 0
+        self.training_mode = "interactive"  # interactive, autonomous, learning, conversation
+        
+        # Training configurations
+        self.training_configs = {
+            "interactive": {
+                "args": ["--interactive", "--version", "v0.0.2"],
+                "description": "Interactive session with human guidance"
+            },
+            "autonomous": {
+                "args": ["--interactive", "--version", "v0.0.2"],
+                "description": "Fully autonomous learning mode"
+            },
+            "learning": {
+                "args": ["--version", "v0.0.2"],
+                "input_file": "/workspace/training_data/learning_prompts.txt",
+                "description": "Focused learning from training data"
+            }
+        }
+        
+        # Ensure directories exist
+        os.makedirs("/workspace/elizabeth_logs", exist_ok=True)
+        os.makedirs("/workspace/training_data", exist_ok=True)
+        
+        # Set environment
+        self.set_environment()
+    
+    def set_environment(self):
+        """Set training environment variables"""
+        os.environ["HF_TOKEN"] = os.getenv("HF_TOKEN", "")
+        os.environ["HUGGINGFACE_HUB_ENABLE_HF_TRANSFER"] = "1"
+        os.environ["PYTHONUNBUFFERED"] = "1"
+    
+    def start_training(self, mode="interactive"):
+        """Start training session with specified mode"""
+        try:
+            config = self.training_configs.get(mode, self.training_configs["interactive"])
+            
+            logger.info(f"Starting {mode} training session...")
+            logger.info(f"Description: {config['description']}")
+            
+            # Build command
+            cmd = [sys.executable, self.script_path] + config["args"]
+            
+            # Handle input file if specified
+            stdin = None
+            if "input_file" in config and os.path.exists(config["input_file"]):
+                stdin = open(config["input_file"], "r")
+            
+            self.process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+                universal_newlines=True,
+                stdin=stdin
+            )
+            
+            logger.info(f"Training process started with PID: {self.process.pid}")
+            logger.info(f"Command: {' '.join(cmd)}")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to start {mode} training: {e}")
+            return False
+    
+    def monitor_training(self, timeout=3600):
+        """Monitor training process with timeout"""
+        start_time = time.time()
+        
+        try:
+            while True:
+                # Check timeout
+                if time.time() - start_time > timeout:
+                    logger.warning(f"Training timeout after {timeout} seconds")
+                    return "timeout"
+                
+                # Check process status
+                return_code = self.process.poll()
+                if return_code is not None:
+                    logger.info(f"Training process completed with code: {return_code}")
+                    return "completed"
+                
+                # Read output
+                if self.process.stdout:
+                    output = self.process.stdout.readline()
+                    if output:
+                        logger.info(f"TRAINING_OUT: {output.strip()}")
+                
+                if self.process.stderr:
+                    error = self.process.stderr.readline()
+                    if error:
+                        logger.error(f"TRAINING_ERR: {error.strip()}")
+                
+                # Check for stalls (no output for 5 minutes)
+                if time.time() - start_time > 300:
+                    # Check if process is still responsive
+                    try:
+                        os.kill(self.process.pid, 0)  # Check if process exists
+                    except OSError:
+                        logger.warning("Process appears to be unresponsive")
+                        return "stalled"
+                
+                time.sleep(1)
+                
+        except Exception as e:
+            logger.error(f"Monitoring error: {e}")
+            return "error"
+    
+    def graceful_shutdown(self):
+        """Gracefully shutdown training"""
+        if self.process:
+            try:
+                logger.info("Initiating graceful shutdown...")
+                
+                # Try gentle termination first
+                self.process.terminate()
+                
+                # Wait for clean shutdown
+                for i in range(10):
+                    if self.process.poll() is not None:
+                        break
+                    time.sleep(1)
+                
+                # Force kill if necessary
+                if self.process.poll() is None:
+                    logger.warning("Process not terminating, forcing kill...")
+                    self.process.kill()
+                
+                logger.info("Training shutdown complete")
+                
+            except Exception as e:
+                logger.error(f"Shutdown error: {e}")
+    
+    def run_continuous_training(self):
+        """Main continuous training loop"""
+        logger.info("🚀 Starting Elizabeth Continuous Training Manager")
+        logger.info(f"Mode: {self.training_mode}")
+        logger.info(f"Max restarts: {self.max_restarts}")
+        
+        training_sessions = []
+        
+        while self.restart_count <= self.max_restarts:
+            session_start = datetime.now()
+            
+            try:
+                # Start training session
+                if not self.start_training(self.training_mode):
+                    logger.error("Failed to start training session")
+                    break
+                
+                # Monitor session
+                result = self.monitor_training()
+                session_end = datetime.now()
+                duration = (session_end - session_start).total_seconds()
+                
+                # Record session
+                session_info = {
+                    "start": session_start.isoformat(),
+                    "end": session_end.isoformat(),
+                    "duration": duration,
+                    "result": result,
+                    "restart_count": self.restart_count,
+                    "pid": self.process.pid if self.process else None
+                }
+                training_sessions.append(session_info)
+                
+                logger.info(f"Session completed: {result}, Duration: {duration:.1f}s")
+                
+                # Handle session result
+                if result == "completed":
+                    logger.info("Training session completed successfully")
+                    break
+                elif self.restart_count < self.max_restarts:
+                    self.restart_count += 1
+                    logger.warning(f"Restarting training ({self.restart_count}/{self.max_restarts})...")
+                    logger.info(f"Waiting {self.restart_delay} seconds before restart...")
+                    
+                    # Save session history
+                    self.save_session_history(training_sessions)
+                    
+                    time.sleep(self.restart_delay)
+                else:
+                    logger.error("Max restart attempts reached")
+                    break
+                    
+            except KeyboardInterrupt:
+                logger.info("Received interrupt signal")
+                break
+            except Exception as e:
+                logger.error(f"Unexpected error: {e}")
+                self.restart_count += 1
+                if self.restart_count <= self.max_restarts:
+                    logger.info(f"Restarting after error... ({self.restart_count}/{self.max_restarts})")
+                    time.sleep(self.restart_delay)
+                else:
+                    break
+        
+        # Final cleanup and reporting
+        self.graceful_shutdown()
+        self.save_session_history(training_sessions)
+        
+        logger.info("Training manager shutting down")
+        logger.info(f"Total sessions: {len(training_sessions)}")
+        logger.info(f"Total restarts: {self.restart_count}")
+    
+    def save_session_history(self, sessions):
+        """Save training session history"""
+        try:
+            history_file = "/workspace/elizabeth_logs/training_history.json"
+            with open(history_file, 'w') as f:
+                json.dump({
+                    "sessions": sessions,
+                    "total_sessions": len(sessions),
+                    "total_restarts": self.restart_count,
+                    "last_update": datetime.now().isoformat()
+                }, f, indent=2)
+        except Exception as e:
+            logger.error(f"Failed to save session history: {e}")
+    
+    def get_status(self):
+        """Get current status"""
+        return {
+            "training_mode": self.training_mode,
+            "restart_count": self.restart_count,
+            "max_restarts": self.max_restarts,
+            "process_active": self.process and self.process.poll() is None,
+            "process_pid": self.process.pid if self.process else None,
+            "timestamp": datetime.now().isoformat()
+        }
+
+def main():
+    """Command line interface"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Elizabeth Training Manager")
+    parser.add_argument("--start", action="store_true", help="Start continuous training")
+    parser.add_argument("--mode", choices=['interactive', 'autonomous', 'learning'], 
+                       default='interactive', help="Training mode")
+    parser.add_argument("--status", action="store_true", help="Show status")
+    parser.add_argument("--stop", action="store_true", help="Stop training")
+    parser.add_argument("--max-restarts", type=int, default=20, help="Max restart attempts")
+    parser.add_argument("--restart-delay", type=int, default=30, help="Restart delay in seconds")
+    
+    args = parser.parse_args()
+    
+    manager = TrainingManager()
+    manager.max_restarts = args.max_restarts
+    manager.restart_delay = args.restart_delay
+    manager.training_mode = args.mode
+    
+    if args.start:
+        manager.run_continuous_training()
+    elif args.status:
+        status = manager.get_status()
+        print("Training Manager Status:")
+        for key, value in status.items():
+            print(f"  {key}: {value}")
+    elif args.stop:
+        manager.graceful_shutdown()
+        print("Shutdown signal sent")
+    else:
+        print("No action specified. Use --help for options.")
+
+if __name__ == "__main__":
+    main()

repository/scripts/training_monitor.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+Elizabeth Training Monitor
+Monitors training processes and automatically restarts if needed
+"""
+
+import os
+import sys
+import time
+import subprocess
+import signal
+import logging
+from datetime import datetime
+from pathlib import Path
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('/workspace/elizabeth_logs/training_monitor.log'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
+
+class TrainingMonitor:
+    """Monitor and manage Elizabeth training processes"""
+    
+    def __init__(self):
+        self.training_script = "/workspace/elizabeth-repo/src/elizabeth_main.py"
+        self.max_restarts = 10
+        self.restart_delay = 30  # seconds
+        self.process = None
+        self.restart_count = 0
+        
+        # Ensure logs directory exists
+        os.makedirs("/workspace/elizabeth_logs", exist_ok=True)
+    
+    def start_training(self):
+        """Start the training process"""
+        try:
+            logger.info("Starting Elizabeth training session...")
+            
+            # Start Elizabeth in interactive mode with enhanced capabilities
+            self.process = subprocess.Popen(
+                [
+                    sys.executable, self.training_script,
+                    "--interactive",
+                    "--version", "v0.0.2"
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            
+            logger.info(f"Training process started with PID: {self.process.pid}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to start training: {e}")
+            return False
+    
+    def monitor_process(self):
+        """Monitor the training process and handle output"""
+        try:
+            # Monitor stdout and stderr
+            while True:
+                if self.process.stdout:
+                    output = self.process.stdout.readline()
+                    if output:
+                        logger.info(f"TRAINING: {output.strip()}")
+                
+                if self.process.stderr:
+                    error = self.process.stderr.readline()
+                    if error:
+                        logger.error(f"TRAINING_ERROR: {error.strip()}")
+                
+                # Check if process is still alive
+                return_code = self.process.poll()
+                if return_code is not None:
+                    logger.warning(f"Training process exited with code: {return_code}")
+                    return return_code
+                
+                time.sleep(1)
+                
+        except Exception as e:
+            logger.error(f"Monitoring error: {e}")
+            return -1
+    
+    def graceful_shutdown(self):
+        """Gracefully shutdown the training process"""
+        if self.process:
+            try:
+                logger.info("Sending graceful shutdown signal...")
+                self.process.terminate()
+                
+                # Wait for process to terminate
+                for _ in range(10):
+                    if self.process.poll() is not None:
+                        break
+                    time.sleep(1)
+                
+                # Force kill if still running
+                if self.process.poll() is None:
+                    logger.warning("Process not terminating, forcing kill...")
+                    self.process.kill()
+                
+                logger.info("Training process shutdown complete")
+                
+            except Exception as e:
+                logger.error(f"Shutdown error: {e}")
+    
+    def run_monitoring_loop(self):
+        """Main monitoring loop with automatic restarts"""
+        logger.info("🚀 Starting Elizabeth Training Monitor")
+        logger.info(f"Max restarts: {self.max_restarts}")
+        logger.info(f"Restart delay: {self.restart_delay}s")
+        
+        while self.restart_count <= self.max_restarts:
+            try:
+                # Start training
+                if not self.start_training():
+                    logger.error("Failed to start training process")
+                    break
+                
+                # Monitor process
+                return_code = self.monitor_process()
+                
+                # Check if we should restart
+                if return_code == 0:
+                    logger.info("Training completed successfully")
+                    break
+                elif self.restart_count < self.max_restarts:
+                    self.restart_count += 1
+                    logger.warning(f"Restarting training ({self.restart_count}/{self.max_restarts})...")
+                    logger.info(f"Waiting {self.restart_delay} seconds before restart...")
+                    time.sleep(self.restart_delay)
+                else:
+                    logger.error("Max restart attempts reached")
+                    break
+                    
+            except KeyboardInterrupt:
+                logger.info("Received interrupt signal, shutting down...")
+                break
+            except Exception as e:
+                logger.error(f"Unexpected error in monitoring loop: {e}")
+                self.restart_count += 1
+                if self.restart_count <= self.max_restarts:
+                    logger.info(f"Restarting after error... ({self.restart_count}/{self.max_restarts})")
+                    time.sleep(self.restart_delay)
+                else:
+                    break
+        
+        # Cleanup
+        self.graceful_shutdown()
+        logger.info("Training monitor shutting down")
+    
+    def get_status(self):
+        """Get current monitoring status"""
+        return {
+            "restart_count": self.restart_count,
+            "max_restarts": self.max_restarts,
+            "process_active": self.process and self.process.poll() is None,
+            "process_pid": self.process.pid if self.process else None,
+            "timestamp": datetime.now().isoformat()
+        }
+
+def main():
+    """Command line interface"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Elizabeth Training Monitor")
+    parser.add_argument("--start", action="store_true", help="Start monitoring")
+    parser.add_argument("--status", action="store_true", help="Show status")
+    parser.add_argument("--stop", action="store_true", help="Stop monitoring")
+    parser.add_argument("--max-restarts", type=int, default=10, help="Max restart attempts")
+    parser.add_argument("--restart-delay", type=int, default=30, help="Restart delay in seconds")
+    
+    args = parser.parse_args()
+    
+    monitor = TrainingMonitor()
+    monitor.max_restarts = args.max_restarts
+    monitor.restart_delay = args.restart_delay
+    
+    if args.start:
+        monitor.run_monitoring_loop()
+    elif args.status:
+        status = monitor.get_status()
+        print("Training Monitor Status:")
+        for key, value in status.items():
+            print(f"  {key}: {value}")
+    elif args.stop:
+        monitor.graceful_shutdown()
+        print("Shutdown signal sent")
+    else:
+        print("No action specified. Use --help for options.")
+
+if __name__ == "__main__":
+    main()

repository/versions/v0_0_2/elizabeth_enhanced.py

@@ -21,6 +21,10 @@ from typing import List, Dict, Optional, Any, Tuple
 import re
 import subprocess
 import shutil
+try:
+    import qdrant_client
+except ImportError:
+    qdrant_client = None
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.panel import Panel
@@ -105,51 +109,76 @@ IMPORTANT: You are Elizabeth responding TO Chase. Never confuse these roles.
 Use your tool belt responsibly to enhance our collaboration."""
     
     def setup_databases(self):
-        """Initialize all database connections for full autonomy"""
+        """Initialize all database connections for full autonomy with complete DataOps integration"""
         
-        # SQLite for local storage (primary)
+        # SQLite for local storage (primary fallback)
         self.sqlite_db = "/workspace/elizabeth_memory.db"
         self.init_sqlite()
         
-        # Redis for fast retrieval
+        # Redis for fast retrieval (Nova-required)
         try:
             self.redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)
             self.redis_client.ping()
-            console.print("[green]✅ Redis connected for fast memory[/green]")
+            console.print("[green]✅ Redis connected for working memory[/green]")
         except:
             self.redis_client = None
-            console.print("[yellow]⚠️ Redis not available, using SQLite[/yellow]")
+            console.print("[yellow]⚠️ Redis not available, using SQLite fallback[/yellow]")
         
-        # ChromaDB for semantic search
-        try:
-            self.chroma_client = chromadb.PersistentClient(path="/workspace/elizabeth_chroma")
-            self.chroma_collection = self.chroma_client.get_or_create_collection("elizabeth_memory")
-            console.print("[green]✅ ChromaDB connected for semantic memory[/green]")
-        except:
-            self.chroma_client = None
-            console.print("[yellow]⚠️ ChromaDB not available[/yellow]")
-        
-        # PostgreSQL for production data (optional)
+        # PostgreSQL for structured data (Nova-required)
         try:
             self.pg_conn = psycopg2.connect(
                 host="localhost",
-                database="elizabeth_prod",
-                user="elizabeth",
-                password=os.getenv("PG_PASSWORD", "")
+                database="novadb",
+                user="postgres",
+                password="nova_db_pass"
             )
-            console.print("[green]✅ PostgreSQL connected for production data[/green]")
+            console.print("[green]✅ PostgreSQL connected for structured data[/green]")
         except:
             self.pg_conn = None
             console.print("[yellow]⚠️ PostgreSQL not available[/yellow]")
         
-        # MongoDB for document storage (optional)
+        # MongoDB for document storage (Nova-required)
         try:
             self.mongo_client = pymongo.MongoClient("mongodb://localhost:27017/")
-            self.mongo_db = self.mongo_client["elizabeth_documents"]
+            self.mongo_db = self.mongo_client["nova_documents"]
             console.print("[green]✅ MongoDB connected for document storage[/green]")
         except:
             self.mongo_client = None
             console.print("[yellow]⚠️ MongoDB not available[/yellow]")
+        
+        # ChromaDB for semantic memory (Nova-required)
+        try:
+            self.chroma_client = chromadb.PersistentClient(path="/data/chromadb")
+            self.chroma_collection = self.chroma_client.get_or_create_collection("elizabeth_memory")
+            console.print("[green]✅ ChromaDB connected for semantic memory[/green]")
+        except:
+            self.chroma_client = None
+            console.print("[yellow]⚠️ ChromaDB not available[/yellow]")
+        
+        # Qdrant for advanced vector search (Enhanced DataOps)
+        try:
+            import qdrant_client
+            self.qdrant_client = qdrant_client.QdrantClient(
+                host="localhost", 
+                port=17000,
+                prefer_grpc=False,
+                check_compatibility=False  # Disable version check for compatibility
+            )
+            # Test connection
+            self.qdrant_client.get_collections()
+            console.print("[green]✅ Qdrant connected for advanced vector memory[/green]")
+        except Exception as e:
+            self.qdrant_client = None
+            console.print(f"[yellow]⚠️ Qdrant not available: {e}[/yellow]")
+        
+        # DragonFly cluster for high-performance caching (Enhanced DataOps)
+        try:
+            self.dragonfly_client = redis.Redis(host='localhost', port=18000, decode_responses=True)
+            self.dragonfly_client.ping()
+            console.print("[green]✅ DragonFly connected for high-performance cache[/green]")
+        except:
+            self.dragonfly_client = None
+            console.print("[yellow]⚠️ DragonFly not available[/yellow]")
     
     def initialize_tool_belt(self) -> Dict[str, Any]:
         """Initialize the full autonomy tool belt"""