Upload 3 files

Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "rustyclaw"
+version = "0.6.0"
+edition = "2021"
+
+[[bin]]
+name = "rustyclaw"
+path = "src/main.rs"
+
+[dependencies]
+anyhow          = "1.0"
+bytes           = "1.5"
+chrono          = { version = "0.4", features = ["serde"] }
+crossterm       = "0.27"
+dirs            = "5.0"
+rand            = "0.8"
+ratatui         = "0.25"
+regex           = "1.10"
+reqwest         = { version = "0.11", features = ["json"] }
+serde           = { version = "1.0", features = ["derive"] }
+serde_json      = "1.0"
+serde_yaml      = "0.9"
+tokio           = { version = "1.35", features = ["full", "process"] }
+tracing         = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter", "time", "chrono"] }
+walkdir         = "2"
+warp            = "0.3"

main.rs

@@ -0,0 +1,1161 @@
+// ============================================================
+//  RustyClaw v0.6.0 – single‑file TUI with permanent logo
+// ============================================================
+
+// ──────────────────────────────────────────────────────────────
+//  Imports
+// ──────────────────────────────────────────────────────────────
+use anyhow::{Context, Result};
+use crossterm::event::{self, Event, KeyCode, KeyEventKind};
+use ratatui::{
+    layout::{Alignment, Constraint, Direction, Layout},
+    style::{Color, Modifier, Style},
+    text::{Line, Span},
+    widgets::{Block, Borders, List, ListItem, Paragraph},
+    Frame,
+};
+use serde::{Deserialize, Serialize};
+use std::collections::VecDeque;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::fs;
+use tokio::io::AsyncWriteExt;
+use tokio::process::Command;
+use tokio::sync::{mpsc, RwLock};
+use tokio::time;
+use tracing::{error, info, warn};
+use walkdir::WalkDir;
+use regex::Regex;
+use warp::Filter;
+
+// ---------- Config ----------
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Config {
+    pub ollama_url: String,
+    pub ollama_model: String,
+    pub api_port: u16,
+    pub root_dir: PathBuf,
+    pub bio_file: PathBuf,
+    pub heartbeat_log: PathBuf,
+    pub memory_sync_interval_secs: u64,
+    pub max_log_lines: usize,
+    pub git_auto_commit: bool,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
+        let root_dir = home.join(".rustyclaw");
+        Self {
+            ollama_url: "http://localhost:11434".to_string(),
+            ollama_model: "qwen2.5:0.5b".to_string(),
+            api_port: 3030,
+            root_dir: root_dir.clone(),
+            bio_file: root_dir.join("bio.md"),
+            heartbeat_log: root_dir.join("data/logs/heartbeat.log"),
+            memory_sync_interval_secs: 3600,
+            max_log_lines: 200,
+            git_auto_commit: true,
+        }
+    }
+}
+
+impl Config {
+    pub async fn load(path: &Path) -> Result<Self> {
+        if path.exists() {
+            let raw = fs::read_to_string(path).await?;
+            let cfg: Config = serde_yaml::from_str(&raw)?;
+            Ok(cfg)
+        } else {
+            Ok(Config::default())
+        }
+    }
+
+    pub async fn save(&self, path: &Path) -> Result<()> {
+        let yaml = serde_yaml::to_string(self)?;
+        fs::write(path, yaml).await?;
+        Ok(())
+    }
+}
+
+// ---------- JsonLogger ----------
+struct JsonLogger {
+    log_file: PathBuf,
+}
+
+impl JsonLogger {
+    fn new(log_file: PathBuf) -> Self {
+        Self { log_file }
+    }
+
+    fn init_global(&self) -> Result<()> {
+        tracing_subscriber::fmt()
+            .with_env_filter(
+                tracing_subscriber::EnvFilter::from_default_env()
+                    .add_directive(tracing::Level::INFO.into()),
+            )
+            .with_target(true)
+            .with_timer(tracing_subscriber::fmt::time::ChronoLocal::rfc_3339())
+            .init();
+        info!("JsonLogger initialized → {}", self.log_file.display());
+        Ok(())
+    }
+}
+
+// ---------- Agent ----------
+pub struct Agent {
+    config: Arc<RwLock<Config>>,
+    bio_path: PathBuf,
+    heartbeat_log_path: PathBuf,
+}
+
+impl Agent {
+    pub async fn new(config: Arc<RwLock<Config>>) -> Result<Self> {
+        let cfg = config.read().await;
+        let bio_path = cfg.bio_file.clone();
+        let heartbeat_log_path = cfg.heartbeat_log.clone();
+        drop(cfg);
+
+        if let Some(parent) = bio_path.parent() {
+            fs::create_dir_all(parent).await?;
+        }
+        if let Some(parent) = heartbeat_log_path.parent() {
+            fs::create_dir_all(parent).await?;
+        }
+
+        if !bio_path.exists() {
+            let template = format!(
+                r#"# BIO.MD – Living Agent Identity
+**Last Updated:** {}
+**Agent Role:** Local Assistant
+
+## SOUL
+Core personality, values, constraints, and behavioral rules.
+- You are a local-only agent running on Ollama with no internet access.
+- Stay sandboxed and respect the host system's security.
+- Personality traits: concise, reflective, self-improving, helpful.
+
+## SKILLS
+Reusable capabilities and "how-to" instructions.
+- Read and write local files using incremental edits.
+- Execute safe, whitelisted shell commands.
+- Summarize interactions and distill insights.
+
+## MEMORY
+Curated long-term knowledge and history.
+
+## CONTEXT
+Current runtime state.
+- Operating System: Debian Linux
+- Working Directory: {}
+- Config: {}
+
+## SESSION TREE
+Pointers or summaries of active conversation branches.
+"#,
+                chrono::Utc::now().to_rfc3339(),
+                std::env::current_dir().unwrap_or_default().display(),
+                config.read().await.ollama_model
+            );
+            fs::write(&bio_path, template).await?;
+            info!("Created initial bio.md at {}", bio_path.display());
+        }
+
+        if !heartbeat_log_path.exists() {
+            fs::File::create(&heartbeat_log_path).await?;
+            info!("Created heartbeat log at {}", heartbeat_log_path.display());
+        }
+
+        Ok(Self {
+            config,
+            bio_path,
+            heartbeat_log_path,
+        })
+    }
+
+    pub fn bio_path(&self) -> &Path {
+        &self.bio_path
+    }
+
+    pub async fn read_bio(&self) -> Result<String> {
+        fs::read_to_string(&self.bio_path).await.context("Failed to read bio.md")
+    }
+
+    pub async fn update_bio_timestamp(&self) -> Result<()> {
+        let content = self.read_bio().await?;
+        let now = chrono::Utc::now().to_rfc3339();
+        let updated = content
+            .lines()
+            .map(|line| {
+                if line.starts_with("**Last Updated:**") {
+                    format!("**Last Updated:** {}", now)
+                } else {
+                    line.to_string()
+                }
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+        fs::write(&self.bio_path, updated).await?;
+        Ok(())
+    }
+
+    pub async fn append_heartbeat(&self, user_msg: &str, assistant_reply: &str) -> Result<()> {
+        let timestamp = chrono::Utc::now().to_rfc3339();
+        let entry = format!(
+            r#"{{"timestamp":"{}","user":{},"assistant":{}}}"#,
+            timestamp,
+            serde_json::to_string(user_msg)?,
+            serde_json::to_string(assistant_reply)?
+        );
+        let mut file = fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&self.heartbeat_log_path)
+            .await?;
+        file.write_all(entry.as_bytes()).await?;
+        file.write_all(b"\n").await?;
+        Ok(())
+    }
+
+    pub async fn consolidate_memory(&self) -> Result<()> {
+        let heartbeat_content = fs::read_to_string(&self.heartbeat_log_path).await?;
+        let entries: Vec<serde_json::Value> = heartbeat_content
+            .lines()
+            .filter_map(|line| serde_json::from_str(line).ok())
+            .collect();
+
+        if entries.is_empty() {
+            return Ok(());
+        }
+
+        let mut summary_text = String::new();
+        for entry in entries.iter().take(20) {
+            let user = entry["user"].as_str().unwrap_or("");
+            let assistant = entry["assistant"].as_str().unwrap_or("");
+            summary_text.push_str(&format!("User: {}\nAssistant: {}\n\n", user, assistant));
+        }
+
+        let cfg = self.config.read().await;
+        let prompt = format!(
+            "You are a memory summarizer. Please distill the following recent interactions into a concise note for the agent's MEMORY section. Keep it factual and useful.\n\n{}",
+            summary_text
+        );
+        let summary = match ollama_generate(&cfg.ollama_url, &cfg.ollama_model, &prompt).await {
+            Ok(s) => s,
+            Err(e) => {
+                error!("Memory summarization failed: {}", e);
+                return Ok(());
+            }
+        };
+        drop(cfg);
+
+        let mut bio = self.read_bio().await?;
+        let memory_marker = "## MEMORY";
+        if let Some(pos) = bio.find(memory_marker) {
+            let insert_pos = pos + memory_marker.len();
+            let memory_block = format!(
+                "\n### Summary for {}\n{}\n",
+                chrono::Utc::now().format("%Y-%m-%d %H:%M:%S"),
+                summary
+            );
+            bio.insert_str(insert_pos, &memory_block);
+            fs::write(&self.bio_path, bio).await?;
+            info!("Memory consolidated and bio.md updated.");
+        } else {
+            warn!("MEMORY section not found in bio.md");
+        }
+        Ok(())
+    }
+
+    pub async fn chat(&self, user_msg: &str) -> Result<String> {
+        let bio_content = self.read_bio().await?;
+        let cfg = self.config.read().await;
+        ollama_generate_with_system(
+            &cfg.ollama_url,
+            &cfg.ollama_model,
+            &bio_content,
+            user_msg,
+        )
+        .await
+    }
+}
+
+// ---------- Ollama functions ----------
+#[derive(Debug, Serialize)]
+struct OllamaChatRequest {
+    model: String,
+    messages: Vec<ChatMessage>,
+    stream: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct ChatMessage {
+    role: String,
+    content: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct OllamaChatResponse {
+    message: ChatMessage,
+}
+
+async fn ollama_generate_with_system(
+    base_url: &str,
+    model: &str,
+    system: &str,
+    user: &str,
+) -> Result<String> {
+    let client = reqwest::Client::new();
+    let req = OllamaChatRequest {
+        model: model.to_string(),
+        messages: vec![
+            ChatMessage {
+                role: "system".to_string(),
+                content: system.to_string(),
+            },
+            ChatMessage {
+                role: "user".to_string(),
+                content: user.to_string(),
+            },
+        ],
+        stream: false,
+    };
+    let url = format!("{}/api/chat", base_url);
+    let resp = client
+        .post(&url)
+        .json(&req)
+        .timeout(Duration::from_secs(60))
+        .send()
+        .await
+        .context("Failed to contact Ollama")?;
+    let body: OllamaChatResponse = resp.json().await.context("Failed to parse Ollama response")?;
+    Ok(body.message.content)
+}
+
+async fn ollama_generate(base_url: &str, model: &str, prompt: &str) -> Result<String> {
+    let client = reqwest::Client::new();
+    #[derive(Debug, Serialize)]
+    struct GenerateRequest {
+        model: String,
+        prompt: String,
+        stream: bool,
+    }
+    #[derive(Debug, Deserialize)]
+    struct GenerateResponse {
+        response: String,
+    }
+    let req = GenerateRequest {
+        model: model.to_string(),
+        prompt: prompt.to_string(),
+        stream: false,
+    };
+    let url = format!("{}/api/generate", base_url);
+    let resp = client
+        .post(&url)
+        .json(&req)
+        .timeout(Duration::from_secs(30))
+        .send()
+        .await
+        .context("Failed to contact Ollama")?;
+    let body: GenerateResponse = resp.json().await.context("Failed to parse Ollama response")?;
+    Ok(body.response)
+}
+
+#[derive(Debug, Deserialize)]
+pub struct OllamaTagsResponse {
+    pub models: Vec<OllamaModelInfo>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct OllamaModelInfo {
+    pub name: String,
+    pub size: u64,
+    pub modified_at: String,
+}
+
+async fn list_ollama_models(base_url: &str) -> Result<Vec<OllamaModelInfo>> {
+    let url = format!("{}/api/tags", base_url);
+    let resp = reqwest::get(&url)
+        .await
+        .context("Failed to fetch models")?
+        .json::<OllamaTagsResponse>()
+        .await?;
+    Ok(resp.models)
+}
+
+// ---------- Sandbox ----------
+fn normalize_path(path: &Path) -> PathBuf {
+    let mut components = Vec::new();
+    for comp in path.components() {
+        match comp {
+            std::path::Component::ParentDir => {
+                components.pop();
+            }
+            std::path::Component::Normal(c) => components.push(c),
+            _ => {}
+        }
+    }
+    let mut result = PathBuf::new();
+    for comp in components {
+        result.push(comp);
+    }
+    result
+}
+
+fn sanitize_path(root: &Path, relative: &str) -> Result<PathBuf> {
+    let full = root.join(relative);
+    if full.exists() {
+        let resolved = full.canonicalize().context("Failed to canonicalize path")?;
+        if !resolved.starts_with(root) {
+            anyhow::bail!("Access denied: path outside sandbox");
+        }
+        Ok(resolved)
+    } else {
+        let normalized = normalize_path(&full);
+        if !normalized.starts_with(root) {
+            anyhow::bail!("Access denied: path would be outside sandbox");
+        }
+        Ok(normalized)
+    }
+}
+
+// ---------- Safe command ----------
+async fn run_safe_command(cmd: &str, args: &[&str], cwd: &PathBuf) -> Result<String> {
+    let allowed = ["ls", "cat", "echo", "git", "pwd"];
+    if !allowed.contains(&cmd) {
+        anyhow::bail!("Command not allowed: {}", cmd);
+    }
+    let output = Command::new(cmd)
+        .args(args)
+        .current_dir(cwd)
+        .output()
+        .await?;
+    let stdout = String::from_utf8(output.stdout)?;
+    let stderr = String::from_utf8(output.stderr)?;
+    if output.status.success() {
+        Ok(format!("{}{}", stdout, stderr))
+    } else {
+        anyhow::bail!("Command failed: {}", stderr)
+    }
+}
+
+// ---------- AppCommand ----------
+#[derive(Debug)]
+pub enum AppCommand {
+    Chat(String),
+    ConsolidateMemory,
+    WriteFile { path: String, content: String },
+    ReadFile { path: String },
+    ListModels,
+    SelectModel(String),
+    ListDir(String),
+    SearchFiles(String),
+    RunCommand(String),
+    GitStatus,
+    GitLog(usize),
+    GitCommit(String),
+    Quit,
+}
+
+// ---------- Command dispatcher ----------
+async fn run_command(
+    cmd: AppCommand,
+    agent: Arc<Agent>,
+    config: Arc<RwLock<Config>>,
+    log_tx: mpsc::Sender<String>,
+) -> Result<()> {
+    match cmd {
+        AppCommand::Chat(prompt) => {
+            let _ = log_tx.send(format!("🤖 Thinking: {}", prompt)).await;
+            match agent.chat(&prompt).await {
+                Ok(reply) => {
+                    let _ = log_tx.send(format!("💬 {}", reply)).await;
+                    if let Err(e) = agent.append_heartbeat(&prompt, &reply).await {
+                        let _ = log_tx.send(format!("❌ Failed to log heartbeat: {e}")).await;
+                    } else if let Err(e) = agent.update_bio_timestamp().await {
+                        let _ = log_tx.send(format!("❌ Failed to update bio timestamp: {e}")).await;
+                    }
+                }
+                Err(e) => {
+                    let _ = log_tx.send(format!("❌ Ollama error: {e}")).await;
+                }
+            }
+        }
+        AppCommand::ConsolidateMemory => {
+            let _ = log_tx.send("🧠 Consolidating memory...".to_string()).await;
+            match agent.consolidate_memory().await {
+                Ok(_) => {
+                    let _ = log_tx.send("✅ Memory consolidated.".to_string()).await;
+                }
+                Err(e) => {
+                    let _ = log_tx.send(format!("❌ Consolidation error: {e}")).await;
+                }
+            }
+        }
+        AppCommand::WriteFile { path, content } => {
+            let _ = log_tx.send(format!("✍️ Writing file: {}", path)).await;
+            let cfg = config.read().await;
+            let data_root = cfg.root_dir.join("data");
+            drop(cfg);
+            let full_path = sanitize_path(&data_root, &path)?;
+            if let Some(parent) = full_path.parent() {
+                tokio::fs::create_dir_all(parent).await?;
+            }
+            tokio::fs::write(&full_path, content).await?;
+            let _ = log_tx.send(format!("✅ File written: {}", full_path.display())).await;
+
+            let auto_commit = config.read().await.git_auto_commit;
+            if auto_commit {
+                let repo_path = data_root;
+                let file_rel = path;
+                let msg = format!("Agent write: {}", file_rel);
+                let result = run_safe_command("git", &["add", &file_rel], &repo_path).await;
+                if let Err(e) = result {
+                    let _ = log_tx.send(format!("⚠️ Git add failed: {e}")).await;
+                } else {
+                    let result = run_safe_command("git", &["commit", "-m", &msg], &repo_path).await;
+                    if let Err(e) = result {
+                        let _ = log_tx.send(format!("⚠️ Git commit failed: {e}")).await;
+                    } else {
+                        let _ = log_tx.send(format!("✅ Committed: {}", msg)).await;
+                    }
+                }
+            }
+        }
+        AppCommand::ReadFile { path } => {
+            let _ = log_tx.send(format!("📖 Reading file: {}", path)).await;
+            let cfg = config.read().await;
+            let data_root = cfg.root_dir.join("data");
+            drop(cfg);
+            let full_path = sanitize_path(&data_root, &path)?;
+            let content = fs::read_to_string(&full_path).await?;
+            let _ = log_tx.send(format!("📄 Content of {}:\n{}", full_path.display(), content)).await;
+        }
+        AppCommand::ListModels => {
+            let _ = log_tx.send("📦 Fetching Ollama models...".to_string()).await;
+            let cfg = config.read().await;
+            match list_ollama_models(&cfg.ollama_url).await {
+                Ok(models) => {
+                    for m in models {
+                        let size_mb = m.size / (1024 * 1024);
+                        let _ = log_tx.send(format!("  {} ({} MB, updated {})", m.name, size_mb, m.modified_at)).await;
+                    }
+                }
+                Err(e) => {
+                    let _ = log_tx.send(format!("❌ Failed to list models: {e}")).await;
+                }
+            }
+        }
+        AppCommand::SelectModel(model_name) => {
+            let _ = log_tx.send(format!("🔧 Switching to model: {}", model_name)).await;
+            let mut cfg = config.write().await;
+            cfg.ollama_model = model_name.clone();
+            cfg.save(PathBuf::from("config.yaml").as_path()).await?;
+            let _ = log_tx.send(format!("✅ Model switched to {}.", model_name)).await;
+        }
+        AppCommand::ListDir(path) => {
+            let cfg = config.read().await;
+            let data_root = cfg.root_dir.join("data");
+            drop(cfg);
+            let target = if path.is_empty() {
+                data_root
+            } else {
+                sanitize_path(&data_root, &path)?
+            };
+            let _ = log_tx.send(format!("📁 Listing: {}", target.display())).await;
+            let entries = WalkDir::new(&target)
+                .min_depth(1)
+                .max_depth(1)
+                .into_iter()
+                .filter_map(|e| e.ok())
+                .map(|e| {
+                    let typ = if e.file_type().is_dir() { "📁" } else { "📄" };
+                    format!("{} {}", typ, e.file_name().to_string_lossy())
+                })
+                .collect::<Vec<_>>();
+            if entries.is_empty() {
+                let _ = log_tx.send("  (empty)".to_string()).await;
+            } else {
+                for entry in entries {
+                    let _ = log_tx.send(entry).await;
+                }
+            }
+        }
+        AppCommand::SearchFiles(query) => {
+            let _ = log_tx.send(format!("🔍 Searching for: {}", query)).await;
+            let cfg = config.read().await;
+            let data_root = cfg.root_dir.join("data");
+            drop(cfg);
+            let re = Regex::new(&regex::escape(&query)).unwrap();
+            let walker = WalkDir::new(&data_root)
+                .into_iter()
+                .filter_map(|e| e.ok())
+                .filter(|e| e.file_type().is_file());
+            let mut matches = Vec::new();
+            for entry in walker {
+                if let Ok(content) = std::fs::read_to_string(entry.path()) {
+                    if re.is_match(&content) {
+                        matches.push(entry.path().strip_prefix(&data_root).unwrap_or(entry.path()).display().to_string());
+                    }
+                }
+            }
+            if matches.is_empty() {
+                let _ = log_tx.send("  No matches found.".to_string()).await;
+            } else {
+                for m in matches {
+                    let _ = log_tx.send(m).await;
+                }
+            }
+        }
+        AppCommand::RunCommand(cmd_line) => {
+            let parts: Vec<&str> = cmd_line.split_whitespace().collect();
+            if parts.is_empty() {
+                let _ = log_tx.send("Usage: /run <command> [args...]".to_string()).await;
+                return Ok(());
+            }
+            let cmd = parts[0];
+            let args = &parts[1..];
+            let cfg = config.read().await;
+            let cwd = cfg.root_dir.join("data");
+            drop(cfg);
+            let _ = log_tx.send(format!("🖥️ Running: {} {}", cmd, args.join(" "))).await;
+            match run_safe_command(cmd, args, &cwd).await {
+                Ok(output) => {
+                    for line in output.lines() {
+                        let _ = log_tx.send(line.to_string()).await;
+                    }
+                }
+                Err(e) => {
+                    let _ = log_tx.send(format!("❌ Command failed: {e}")).await;
+                }
+            }
+        }
+        AppCommand::GitStatus => {
+            let cfg = config.read().await;
+            let cwd = cfg.root_dir.join("data");
+            drop(cfg);
+            match run_safe_command("git", &["status", "--short"], &cwd).await {
+                Ok(output) => {
+                    if output.is_empty() {
+                        let _ = log_tx.send("  Working tree clean".to_string()).await;
+                    } else {
+                        for line in output.lines() {
+                            let _ = log_tx.send(line.to_string()).await;
+                        }
+                    }
+                }
+                Err(e) => {
+                    let _ = log_tx.send(format!("❌ Git status failed: {e}")).await;
+                }
+            }
+        }
+        AppCommand::GitLog(n) => {
+            let cfg = config.read().await;
+            let cwd = cfg.root_dir.join("data");
+            drop(cfg);
+            match run_safe_command("git", &["log", "-n", &n.to_string(), "--oneline"], &cwd).await {
+                Ok(output) => {
+                    if output.is_empty() {
+                        let _ = log_tx.send("  No commits yet".to_string()).await;
+                    } else {
+                        for line in output.lines() {
+                            let _ = log_tx.send(line.to_string()).await;
+                        }
+                    }
+                }
+                Err(e) => {
+                    let _ = log_tx.send(format!("❌ Git log failed: {e}")).await;
+                }
+            }
+        }
+        AppCommand::GitCommit(msg) => {
+            let cfg = config.read().await;
+            let cwd = cfg.root_dir.join("data");
+            drop(cfg);
+            let _ = log_tx.send(format!("📦 Committing all changes: {}", msg)).await;
+            match run_safe_command("git", &["add", "-A"], &cwd).await {
+                Ok(_) => {
+                    match run_safe_command("git", &["commit", "-m", &msg], &cwd).await {
+                        Ok(output) => {
+                            let _ = log_tx.send(format!("✅ {}", output.trim())).await;
+                        }
+                        Err(e) => {
+                            let _ = log_tx.send(format!("❌ Commit failed: {e}")).await;
+                        }
+                    }
+                }
+                Err(e) => {
+                    let _ = log_tx.send(format!("❌ Add failed: {e}")).await;
+                }
+            }
+        }
+        AppCommand::Quit => {}
+    }
+    Ok(())
+}
+
+// ---------- AppState (TUI – no blocking) ----------
+struct AppState {
+    input: String,
+    logs: VecDeque<String>,
+    config: Arc<RwLock<Config>>,
+    bio_path: PathBuf,
+    model_name: String,
+    max_log_lines: usize,
+    cmd_tx: mpsc::Sender<AppCommand>,
+    log_rx: mpsc::Receiver<String>,
+}
+
+impl AppState {
+    fn new(
+        config: Arc<RwLock<Config>>,
+        cmd_tx: mpsc::Sender<AppCommand>,
+        log_rx: mpsc::Receiver<String>,
+        bio_path: PathBuf,
+        initial_model: String,
+    ) -> Self {
+        Self {
+            input: String::new(),
+            logs: VecDeque::new(),
+            config,
+            bio_path,
+            model_name: initial_model,
+            max_log_lines: 200,
+            cmd_tx,
+            log_rx,
+        }
+    }
+
+    fn push_log(&mut self, line: String) {
+        if self.logs.len() >= self.max_log_lines {
+            self.logs.pop_front();
+        }
+        self.logs.push_back(line);
+    }
+
+    fn visible_logs(&self, height: usize) -> Vec<String> {
+        let skip = if self.logs.len() > height {
+            self.logs.len() - height
+        } else {
+            0
+        };
+        self.logs.iter().skip(skip).cloned().collect()
+    }
+
+    fn drain_logs(&mut self) {
+        while let Ok(line) = self.log_rx.try_recv() {
+            self.push_log(line);
+        }
+    }
+
+    // Non‑blocking cache update – ignore any lock error
+    fn refresh_model_cache(&mut self) {
+        if let Ok(cfg) = self.config.try_read() {
+            self.model_name = cfg.ollama_model.clone();
+        }
+    }
+
+    fn handle_command(&mut self, cmd: &str) -> Option<AppCommand> {
+        let parts: Vec<&str> = cmd.trim().split_whitespace().collect();
+        if parts.is_empty() {
+            return None;
+        }
+        match parts[0] {
+            "/help" => {
+                let help_text = r#"Commands:
+  /help               – Show this help
+  /bio                – Display current bio.md
+  /consolidate        – Force memory consolidation
+  /write_file <path> <content> – Write content to a file in data/ folder
+  /read_file <path>   – Read a file from data/ folder
+  /model list         – List all Ollama models
+  /model select <name> – Switch to another model
+  /list_dir [path]    – List contents of data/ or subfolder
+  /search <query>     – Search for text in all files under data/
+  /run <command>      – Run a safe command (whitelisted: ls, cat, echo, git, pwd)
+  /git status         – Show git status of data/ folder
+  /git log [n]        – Show last n commits (default 10)
+  /git commit <msg>   – Commit all changes in data/ folder
+  /quit or /exit      – Exit RustyClaw"#;
+                for line in help_text.lines() {
+                    self.push_log(line.to_string());
+                }
+                None
+            }
+            "/bio" => {
+                match std::fs::read_to_string(&self.bio_path) {
+                    Ok(content) => {
+                        for line in content.lines() {
+                            self.push_log(line.to_string());
+                        }
+                    }
+                    Err(e) => self.push_log(format!("❌ Error reading bio.md: {e}")),
+                }
+                None
+            }
+            "/consolidate" => {
+                self.push_log("Consolidating memory...".into());
+                Some(AppCommand::ConsolidateMemory)
+            }
+            "/write_file" => {
+                if parts.len() < 3 {
+                    self.push_log("Usage: /write_file <path> <content>".into());
+                    return None;
+                }
+                let path = parts[1].to_string();
+                let content = parts[2..].join(" ");
+                Some(AppCommand::WriteFile { path, content })
+            }
+            "/read_file" => {
+                if parts.len() < 2 {
+                    self.push_log("Usage: /read_file <path>".into());
+                    return None;
+                }
+                let path = parts[1].to_string();
+                Some(AppCommand::ReadFile { path })
+            }
+            "/model" => {
+                if parts.len() < 2 {
+                    self.push_log("Usage: /model list | /model select <name>".into());
+                    return None;
+                }
+                match parts[1] {
+                    "list" => Some(AppCommand::ListModels),
+                    "select" => {
+                        if parts.len() < 3 {
+                            self.push_log("Usage: /model select <model_name>".into());
+                            None
+                        } else {
+                            Some(AppCommand::SelectModel(parts[2].to_string()))
+                        }
+                    }
+                    _ => {
+                        self.push_log("Unknown /model subcommand".into());
+                        None
+                    }
+                }
+            }
+            "/list_dir" => {
+                let path = if parts.len() > 1 { parts[1] } else { "" };
+                Some(AppCommand::ListDir(path.to_string()))
+            }
+            "/search" => {
+                if parts.len() < 2 {
+                    self.push_log("Usage: /search <query>".into());
+                    None
+                } else {
+                    let query = parts[1..].join(" ");
+                    Some(AppCommand::SearchFiles(query))
+                }
+            }
+            "/run" => {
+                if parts.len() < 2 {
+                    self.push_log("Usage: /run <command> [args...]".into());
+                    None
+                } else {
+                    let full_cmd = parts[1..].join(" ");
+                    Some(AppCommand::RunCommand(full_cmd))
+                }
+            }
+            "/git" => {
+                if parts.len() < 2 {
+                    self.push_log("Usage: /git status | /git log [n] | /git commit <msg>".into());
+                    return None;
+                }
+                match parts[1] {
+                    "status" => Some(AppCommand::GitStatus),
+                    "log" => {
+                        let n = if parts.len() > 2 {
+                            parts[2].parse::<usize>().unwrap_or(10)
+                        } else {
+                            10
+                        };
+                        Some(AppCommand::GitLog(n))
+                    }
+                    "commit" => {
+                        if parts.len() < 3 {
+                            self.push_log("Usage: /git commit <message>".into());
+                            None
+                        } else {
+                            let msg = parts[2..].join(" ");
+                            Some(AppCommand::GitCommit(msg))
+                        }
+                    }
+                    _ => {
+                        self.push_log("Unknown /git subcommand".into());
+                        None
+                    }
+                }
+            }
+            "/quit" | "/exit" => Some(AppCommand::Quit),
+            _ => Some(AppCommand::Chat(cmd.to_string())),
+        }
+    }
+}
+
+// ---------- Worker ----------
+async fn worker(
+    agent: Arc<Agent>,
+    config: Arc<RwLock<Config>>,
+    mut cmd_rx: mpsc::Receiver<AppCommand>,
+    log_tx: mpsc::Sender<String>,
+) {
+    while let Some(cmd) = cmd_rx.recv().await {
+        let result = run_command(cmd, agent.clone(), config.clone(), log_tx.clone()).await;
+        if let Err(e) = result {
+            let _ = log_tx.send(format!("❌ Command error: {e}")).await;
+        }
+    }
+}
+
+// ---------- REST API ----------
+fn build_api(agent: Arc<Agent>) -> impl warp::Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
+    let bio_get = warp::path!("api" / "bio")
+        .and(warp::get())
+        .and_then(move || {
+            let agent = agent.clone();
+            async move {
+                match agent.read_bio().await {
+                    Ok(content) => Ok::<_, warp::Rejection>(warp::reply::json(&serde_json::json!({"bio": content}))),
+                    Err(e) => Ok(warp::reply::json(&serde_json::json!({"error": e.to_string()}))),
+                }
+            }
+        });
+
+    let health = warp::path!("health")
+        .and(warp::get())
+        .map(|| warp::reply::json(&serde_json::json!({"status": "ok"})));
+
+    bio_get.or(health)
+}
+
+// ---------- TUI rendering (permanent logo) ----------
+fn ui(frame: &mut Frame, app: &AppState) {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .margin(1)
+        .constraints([
+            Constraint::Length(5),
+            Constraint::Length(3),
+            Constraint::Min(0),
+            Constraint::Length(3),
+        ])
+        .split(frame.size());
+
+    let logo_text = r#"    
+▄▖    ▗     ▜      
+▙▘▌▌▛▘▜▘▌▌▛▘▐ ▀▌▌▌▌
+▌▌▙▌▄▌▐▖▙▌▙▖▐▖█▌▚▚▘
+        ▄▌         
+ 🦞 RustyClaw v0.6.0"#;
+    let logo = Paragraph::new(logo_text)
+        .block(Block::default().borders(Borders::NONE))
+        .style(Style::default().fg(Color::Rgb(205, 127, 50)).add_modifier(Modifier::BOLD))
+        .alignment(Alignment::Center);
+    frame.render_widget(logo, chunks[0]);
+
+    let header = Paragraph::new(Line::from(vec![
+        Span::styled("📄 bio.md active  ", Style::default().fg(Color::Rgb(205, 127, 50)).add_modifier(Modifier::BOLD)),
+        Span::styled(format!("Model: {}", app.model_name), Style::default().fg(Color::Cyan)),
+    ]))
+    .block(Block::default().borders(Borders::ALL).border_style(Style::default().fg(Color::Rgb(205, 127, 50))))
+    .alignment(Alignment::Left);
+    frame.render_widget(header, chunks[1]);
+
+    let log_items: Vec<ListItem> = app
+        .visible_logs(chunks[2].height.saturating_sub(2) as usize)
+        .into_iter()
+        .map(|s| ListItem::new(Line::from(s)))
+        .collect();
+    let logs = List::new(log_items).block(
+        Block::default()
+            .borders(Borders::ALL)
+            .title("Logs  (ESC to quit · /help for commands)")
+            .border_style(Style::default().fg(Color::Rgb(205, 127, 50))),
+    );
+    frame.render_widget(logs, chunks[2]);
+
+    let input = Paragraph::new(app.input.as_str())
+        .block(
+            Block::default()
+                .borders(Borders::ALL)
+                .title("Input (Enter to send)")
+                .border_style(Style::default().fg(Color::Rgb(205, 127, 50))),
+        )
+        .style(Style::default().fg(Color::White));
+    frame.render_widget(input, chunks[3]);
+
+    frame.set_cursor(
+        chunks[3].x + app.input.len() as u16 + 1,
+        chunks[3].y + 1,
+    );
+}
+
+// ---------- Main ----------
+#[tokio::main]
+async fn main() -> Result<()> {
+    let ollama_ok = reqwest::get("http://localhost:11434/api/tags")
+        .await
+        .is_ok();
+    if !ollama_ok {
+        eprintln!("⚠️  Ollama not detected at http://localhost:11434");
+        eprintln!("   Start Ollama with: ollama serve");
+        eprintln!("   Pull a model: ollama pull qwen2.5:0.5b");
+    }
+
+    let git_ok = tokio::process::Command::new("git")
+        .arg("--version")
+        .output()
+        .await
+        .is_ok();
+    if !git_ok {
+        eprintln!("⚠️  Git not found in PATH. Git commands will fail.");
+    }
+
+    let config = Config::load(Path::new("config.yaml")).await.unwrap_or_default();
+    let config = Arc::new(RwLock::new(config));
+
+    let log_file = {
+        let cfg = config.read().await;
+        cfg.root_dir.join("data/logs/app.log")
+    };
+    let logger = JsonLogger::new(log_file);
+    logger.init_global()?;
+    info!("RustyClaw v0.6.0 starting up");
+
+    let agent = Arc::new(Agent::new(config.clone()).await?);
+    info!("Agent initialized, bio.md at {}", agent.bio_path().display());
+
+    let data_repo_path = {
+        let cfg = config.read().await;
+        cfg.root_dir.join("data")
+    };
+    if git_ok && !data_repo_path.join(".git").exists() {
+        let result = run_safe_command("git", &["init"], &data_repo_path).await;
+        if let Err(e) = result {
+            warn!("Git init failed: {}", e);
+        } else {
+            info!("Git repo initialized at {}", data_repo_path.display());
+        }
+    }
+
+    let (cmd_tx, cmd_rx) = mpsc::channel::<AppCommand>(32);
+    let (log_tx, log_rx) = mpsc::channel::<String>(256);
+
+    let worker_agent = agent.clone();
+    let worker_config = config.clone();
+    tokio::spawn(async move {
+        worker(worker_agent, worker_config, cmd_rx, log_tx).await;
+    });
+
+    let interval = {
+        let cfg = config.read().await;
+        Duration::from_secs(cfg.memory_sync_interval_secs)
+    };
+    let timer_cmd_tx = cmd_tx.clone();
+    tokio::spawn(async move {
+        let mut interval = time::interval(interval);
+        loop {
+            interval.tick().await;
+            let _ = timer_cmd_tx.send(AppCommand::ConsolidateMemory).await;
+        }
+    });
+
+    let api_agent = agent.clone();
+    let api_port = {
+        let cfg = config.read().await;
+        cfg.api_port
+    };
+    tokio::spawn(async move {
+        let api = build_api(api_agent);
+        info!("REST API listening on :{}", api_port);
+        warp::serve(api).run(([127, 0, 0, 1], api_port)).await;
+    });
+
+    crossterm::terminal::enable_raw_mode().unwrap();
+    let backend = ratatui::backend::CrosstermBackend::new(std::io::stdout());
+    let mut terminal = ratatui::Terminal::new(backend).unwrap();
+    crossterm::execute!(
+        std::io::stderr(),
+        crossterm::terminal::EnterAlternateScreen,
+        crossterm::event::EnableMouseCapture,
+    )
+    .ok();
+
+    let (bio_path, initial_model) = {
+        let cfg = config.read().await;
+        (cfg.bio_file.clone(), cfg.ollama_model.clone())
+    };
+    let mut app = AppState::new(config.clone(), cmd_tx.clone(), log_rx, bio_path, initial_model);
+    app.push_log("🦀 Welcome to RustyClaw v0.6.0!".into());
+    app.push_log("📄 bio.md loaded as persistent memory.".into());
+    if !ollama_ok {
+        app.push_log("⚠️  Ollama not running! Please start it: ollama serve".into());
+    } else {
+        app.push_log("✅ Ollama detected.".into());
+    }
+    if !git_ok {
+        app.push_log("⚠️  Git not found. Git commands will fail.".into());
+    } else {
+        app.push_log("✅ Git detected.".into());
+    }
+    app.push_log(format!("🌐 REST API: http://127.0.0.1:{}/api/bio", api_port));
+    app.push_log("📁 Data folder is a Git repo (auto‑commits after writes)".into());
+    app.push_log("💡 Try /help to see all commands.".into());
+
+    loop {
+        app.drain_logs();
+        app.refresh_model_cache();
+
+        terminal.draw(|f| ui(f, &app))?;
+
+        if event::poll(Duration::from_millis(100))? {
+            if let Event::Key(key) = event::read()? {
+                if key.kind == KeyEventKind::Press {
+                    match key.code {
+                        KeyCode::Esc => {
+                            let _ = cmd_tx.send(AppCommand::Quit).await;
+                            break;
+                        }
+                        KeyCode::Enter => {
+                            let cmd = app.input.trim().to_string();
+                            app.input.clear();
+                            if cmd.is_empty() {
+                                continue;
+                            }
+                            app.push_log(format!("> {}", cmd));
+                            if let Some(worker_cmd) = app.handle_command(&cmd) {
+                                match worker_cmd {
+                                    AppCommand::Quit => {
+                                        let _ = cmd_tx.send(AppCommand::Quit).await;
+                                        break;
+                                    }
+                                    other => {
+                                        let _ = cmd_tx.send(other).await;
+                                    }
+                                }
+                            }
+                        }
+                        KeyCode::Char(c) => app.input.push(c),
+                        KeyCode::Backspace => {
+                            app.input.pop();
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+
+    crossterm::terminal::disable_raw_mode().unwrap();
+    crossterm::execute!(
+        std::io::stderr(),
+        crossterm::terminal::LeaveAlternateScreen,
+        crossterm::event::DisableMouseCapture,
+    )
+    .ok();
+
+    info!("RustyClaw shut down cleanly");
+    Ok(())
+}

start.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+# start.sh – RustyClaw v0.6.0 launcher
+
+set -e
+
+RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'
+BLUE='\033[0;34m'; CYAN='\033[0;36m'; BOLD='\033[1m'; NC='\033[0m'
+
+echo -e "${BOLD}${CYAN}"
+cat << 'EOF'
+▄▖    ▗     ▜      
+▙▘▌▌▛▘▜▘▌▌▛▘▐ ▀▌▌▌▌
+▌▌▙▌▄▌▐▖▙▌▙▖▐▖█▌▚▚▘
+        ▄▌         
+EOF
+echo -e "${NC}"
+
+# Check Cargo
+if ! command -v cargo &>/dev/null; then
+    echo -e "${RED}❌ Cargo not found. Install Rust: https://rustup.rs/${NC}"
+    exit 1
+fi
+echo -e "${GREEN}✅ $(cargo --version)${NC}"
+
+# Ensure directories
+mkdir -p src data logs
+
+# Move main.rs if needed
+if [ -f "main.rs" ] && [ ! -f "src/main.rs" ]; then
+    echo -e "${YELLOW}⚠️  Moving main.rs → src/main.rs${NC}"
+    mv main.rs src/main.rs
+fi
+
+if [ ! -f "src/main.rs" ]; then
+    echo -e "${RED}❌ src/main.rs not found.${NC}"
+    exit 1
+fi
+
+# Ollama check
+if curl -sf http://localhost:11434/api/tags >/dev/null 2>&1; then
+    MODEL_COUNT=$(curl -s http://localhost:11434/api/tags | python3 -c "import sys,json; d=json.load(sys.stdin); print(len(d.get('models',[])))" 2>/dev/null || echo "?")
+    echo -e "${GREEN}✅ Ollama running — ${MODEL_COUNT} model(s) available${NC}"
+else
+    echo -e "${YELLOW}⚠️  Ollama not detected at localhost:11434${NC}"
+    echo -e "${YELLOW}   Start with: ollama serve${NC}"
+    echo -e "${YELLOW}   Pull model: ollama pull qwen2.5:0.5b${NC}"
+    echo ""
+    read -rp "   Continue anyway? (y/N) " reply; echo
+    [[ "$reply" =~ ^[Yy]$ ]] || exit 1
+fi
+
+# Build
+BINARY="./target/release/rustyclaw"
+FORCE_REBUILD="${1:-}"
+
+needs_build=false
+[ ! -f "$BINARY" ] && needs_build=true
+[ "src/main.rs" -nt "$BINARY" ] 2>/dev/null && needs_build=true
+[ "Cargo.toml"  -nt "$BINARY" ] 2>/dev/null && needs_build=true
+[ "$FORCE_REBUILD" = "--rebuild" ] && needs_build=true
+
+if $needs_build; then
+    echo -e "${BLUE}🔨 Building RustyClaw (release)…${NC}"
+    cargo build --release
+    echo -e "${GREEN}✅ Build complete${NC}"
+else
+    echo -e "${CYAN}⚡ Binary up-to-date (./start.sh --rebuild to force)${NC}"
+fi
+
+# Launch
+echo ""
+echo -e "${GREEN}⚙️  Launching RustyClaw…${NC}"
+echo -e "${CYAN}   ESC or /quit to exit  │  /help for commands${NC}"
+echo -e "${CYAN}   REST API: http://127.0.0.1:3030/health${NC}"
+echo -e "${CYAN}   Persona:  ~/.rustyclaw/bio.md${NC}"
+echo -e "${CYAN}   Files:    ~/.rustyclaw/data/ (Git repo)${NC}"
+echo ""
+exec "$BINARY"