Activate operational Web Mode: WS, tool execution, Ollama, sessions & self-evolution

.gitignore

@@ -11,6 +11,8 @@ downloads/
 eggs/
 .eggs/
 lib/
+!web-ui/src/lib/
+!web-ui/src/lib/**
 lib64/
 parts/
 sdist/
@@ -69,4 +71,4 @@ config.local.json
 
 # Temporary files
 *.tmp
-*.temp 
+*.temp 

configs/neurorift_config.json

@@ -175,5 +175,10 @@
       "SimStudioAI (conceptual orchestration)",
       "Anti-Gravity AI"
     ]
+  },
+  "self_evolution": {
+    "enabled": true,
+    "require_human_approval": true,
+    "sandbox_branch": "ai-evolution"
   }
 }

core/neurorift-core/src/lib.rs

@@ -166,7 +166,7 @@ impl NeuroRiftCore {
     }
 
     /// Queue a task in the active session
-    pub fn queue_task(&self, tool_name: String, target: String, args: serde_json::Value) -> Result<()> {
+    pub fn queue_task(&self, tool_name: String, target: String, args: serde_json::Value) -> Result<Option<String>> {
         if let Some(session) = self.get_active_session() {
             let mut session = session.write();
             let args_map = args.as_object()
@@ -177,12 +177,134 @@ impl NeuroRiftCore {
 
             // Get the task that was just added
             if let Some(task) = session.task_queue.back() {
+                let task_id = task.id.clone();
                 self.ws_server.broadcast(WSEvent::TaskQueued {
                     task: task.clone(),
                 });
+                return Ok(Some(task_id));
             }
         }
 
+        Ok(None)
+    }
+
+    /// Cancel a queued/running task.
+    pub fn cancel_task(&self, task_id: &str) -> Result<()> {
+        if let Some(session) = self.get_active_session() {
+            let mut session = session.write();
+            if let Some(task) = session.task_queue.iter_mut().find(|task| task.id == task_id) {
+                task.status = crate::state::TaskStatus::Cancelled;
+                task.completed_at = Some(chrono::Utc::now());
+                session.touch();
+                self.ws_server.broadcast(WSEvent::TaskCancelled {
+                    task_id: task_id.to_string(),
+                    timestamp: chrono::Utc::now(),
+                });
+            }
+        }
+        Ok(())
+    }
+
+    /// Execute a task by ID through the Python bridge.
+    pub async fn execute_task(&self, task_id: &str) -> Result<()> {
+        let (session_id, tool_name, target, args, mode) = if let Some(session) = self.get_active_session() {
+            let mut session = session.write();
+            let session_id = session.id.clone();
+            let mode = session.mode;
+
+            if let Some(task) = session.task_queue.iter_mut().find(|task| task.id == task_id) {
+                task.status = crate::state::TaskStatus::Running;
+                task.started_at = Some(chrono::Utc::now());
+                let args = serde_json::Value::Object(task.args.clone().into_iter().collect());
+                let tool_name = task.tool_name.clone();
+                let target = task.target.clone();
+                self.ws_server.broadcast(WSEvent::TaskStarted {
+                    task_id: task.id.clone(),
+                    started_at: chrono::Utc::now(),
+                });
+                (session_id, tool_name, target, args, mode)
+            } else {
+                return Ok(());
+            }
+        } else {
+            return Ok(());
+        };
+
+        let command = serde_json::json!({
+            "type": "tool_execute",
+            "tool": tool_name,
+            "target": target,
+            "args": args,
+            "mode": format!("{:?}", mode).to_uppercase(),
+            "session_id": session_id,
+        });
+
+        let result = self.python_bridge.execute(command).await;
+
+        if let Some(session) = self.get_active_session() {
+            let mut session = session.write();
+            if let Some(task) = session.task_queue.iter_mut().find(|task| task.id == task_id) {
+                match result {
+                    Ok(data) => {
+                        let raw_output = data
+                            .get("raw_output")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or_default()
+                            .to_string();
+                        let success = data
+                            .get("status")
+                            .and_then(|v| v.as_str())
+                            .map(|s| s.eq_ignore_ascii_case("completed"))
+                            .unwrap_or(true);
+
+                        task.status = if success {
+                            crate::state::TaskStatus::Completed
+                        } else {
+                            crate::state::TaskStatus::Failed
+                        };
+                        task.completed_at = Some(chrono::Utc::now());
+                        session.touch();
+
+                        self.ws_server.broadcast(WSEvent::TaskOutput {
+                            task_id: task_id.to_string(),
+                            chunk: raw_output.clone(),
+                        });
+
+                        if success {
+                            self.ws_server.broadcast(WSEvent::TaskCompleted {
+                                task_id: task_id.to_string(),
+                                result: crate::websocket::events::TaskResult {
+                                    success: true,
+                                    output: raw_output,
+                                    structured_data: data.get("structured_output").cloned(),
+                                    duration_ms: (data.get("duration_seconds").and_then(|v| v.as_f64()).unwrap_or(0.0) * 1000.0) as u64,
+                                },
+                            });
+                        } else {
+                            self.ws_server.broadcast(WSEvent::TaskFailed {
+                                task_id: task_id.to_string(),
+                                error: data.get("error").and_then(|v| v.as_str()).unwrap_or("tool execution failed").to_string(),
+                            });
+                        }
+                    }
+                    Err(error) => {
+                        task.status = crate::state::TaskStatus::Failed;
+                        task.completed_at = Some(chrono::Utc::now());
+                        session.touch();
+                        self.ws_server.broadcast(WSEvent::TaskFailed {
+                            task_id: task_id.to_string(),
+                            error: error.to_string(),
+                        });
+                    }
+                }
+            }
+        }
+
+        if let Some(session) = self.get_active_session() {
+            let session_id = session.read().id.clone();
+            let _ = self.save_session(&session_id);
+        }
+
         Ok(())
     }
 
@@ -207,14 +329,29 @@ impl NeuroRiftCore {
 
     /// Handle chat message
     pub async fn chat(&self, message: String, model: Option<String>) -> Result<()> {
+        let session_id = self
+            .get_active_session()
+            .map(|s| s.read().id.clone())
+            .unwrap_or_else(|| "default".to_string());
+
         // Forward to Python bridge
         let cmd = serde_json::json!({
             "type": "ai_generate",
             "prompt": message,
-            "model": model
+            "model": model,
+            "session_id": session_id,
         });
 
-        let data = self.python_bridge.execute(cmd).await?;
+        let data = match self.python_bridge.execute(cmd).await {
+            Ok(data) => data,
+            Err(error) => {
+                self.ws_server.broadcast(WSEvent::Error {
+                    message: "AI generation failed".to_string(),
+                    details: Some(error.to_string()),
+                });
+                return Ok(());
+            }
+        };
 
         if let Some(text) = data.get("response").and_then(|v| v.as_str()) {
             let model = data.get("model").and_then(|v| v.as_str()).unwrap_or("unknown").to_string();
@@ -229,6 +366,21 @@ impl NeuroRiftCore {
         Ok(())
     }
 
+    pub async fn get_ollama_status(&self) -> Result<()> {
+        let data = self.python_bridge.execute(serde_json::json!({
+            "type": "ai_status"
+        })).await?;
+
+        self.ws_server.broadcast(WSEvent::OllamaStatus {
+            available: data.get("available").and_then(|v| v.as_bool()).unwrap_or(false),
+            model: data.get("model").and_then(|v| v.as_str()).map(|s| s.to_string()),
+            model_count: data.get("model_count").and_then(|v| v.as_u64()).unwrap_or(0) as usize,
+            needs_pull: data.get("needs_pull").and_then(|v| v.as_bool()).unwrap_or(false),
+        });
+
+        Ok(())
+    }
+
     /// Get Python bridge
     pub fn python_bridge(&self) -> Arc<PythonBridge> {
         self.python_bridge.clone()

core/neurorift-core/src/main.rs

@@ -109,7 +109,24 @@ async fn main() -> Result<()> {
                 }
                 QueueTask { tool_name, target, args } => {
                     tracing::info!("Received QueueTask: {} -> {}", tool_name, target);
-                    if let Err(e) = core_cmd.queue_task(tool_name, target, args) {
+                    match core_cmd.queue_task(tool_name, target, args) {
+                        Ok(Some(task_id)) => {
+                            let core_exec = core_cmd.clone();
+                            tokio::spawn(async move {
+                                if let Err(e) = core_exec.execute_task(&task_id).await {
+                                    tracing::error!("Failed to execute task {}: {}", task_id, e);
+                                }
+                            });
+                        }
+                        Ok(None) => {}
+                        Err(e) => {
+                            tracing::error!("Failed to queue task: {}", e);
+                        }
+                    }
+                }
+                CancelTask { task_id } => {
+                    tracing::info!("Received CancelTask: {}", task_id);
+                    if let Err(e) = core_cmd.cancel_task(&task_id) {
                         tracing::error!("Failed to queue task: {}", e);
                     }
                 }
@@ -122,6 +139,14 @@ async fn main() -> Result<()> {
                          }
                      });
                 }
+                GetOllamaStatus => {
+                    let core_ai = core_cmd.clone();
+                    tokio::spawn(async move {
+                        if let Err(e) = core_ai.get_ollama_status().await {
+                            tracing::error!("Failed to fetch Ollama status: {}", e);
+                        }
+                    });
+                }
                 _ => {} // Ignore other events
             }
         }

core/neurorift-core/src/python_bridge/mod.rs

@@ -10,6 +10,20 @@ pub struct PythonBridge {
 }
 
 impl PythonBridge {
+    fn extract_data(result: Value) -> Result<Value> {
+        let success = result.get("success").and_then(|v| v.as_bool()).unwrap_or(false);
+
+        if !success {
+            let error = result
+                .get("error")
+                .and_then(|v| v.as_str())
+                .unwrap_or("python bridge execution failed");
+            anyhow::bail!(error.to_string());
+        }
+
+        Ok(result.get("data").cloned().unwrap_or(Value::Null))
+    }
+
     /// Create a new Python bridge
     pub fn new(base_url: impl Into<String>) -> Self {
         let client = Client::builder()
@@ -34,7 +48,7 @@ impl PythonBridge {
             .await?;
 
         let result = response.json::<Value>().await?;
-        Ok(result)
+        Self::extract_data(result)
     }
 
     /// Execute a tool
@@ -58,7 +72,7 @@ impl PythonBridge {
         });
 
         let result = self.execute(command).await?;
-        
+
         Ok(result["response"]
             .as_str()
             .unwrap_or("")

core/neurorift-core/src/websocket/events.rs

@@ -60,6 +60,14 @@ pub enum WSEvent {
         task_id: String,
         error: String,
     },
+    TaskOutput {
+        task_id: String,
+        chunk: String,
+    },
+    TaskCancelled {
+        task_id: String,
+        timestamp: DateTime<Utc>,
+    },
 
     // Approval events
     ApprovalRequired {
@@ -102,6 +110,12 @@ pub enum WSEvent {
         active: bool,
         url: Option<String>,
     },
+    OllamaStatus {
+        available: bool,
+        model: Option<String>,
+        model_count: usize,
+        needs_pull: bool,
+    },
 
     // Error events
     Error {
@@ -132,6 +146,9 @@ pub enum WSEvent {
         target: String,
         args: serde_json::Value,
     },
+    CancelTask {
+        task_id: String,
+    },
     ApproveAction {
         approval_id: String,
     },
@@ -147,6 +164,7 @@ pub enum WSEvent {
         message: String,
         model: Option<String>,
     },
+    GetOllamaStatus,
     ChatResponse {
         response: String,
         model: String,