titan-synapse 0.1.1

package/crates/synapse/src/cli/learn.rs

@@ -0,0 +1,53 @@
+use anyhow::Result;
+use colored::Colorize;
+use crate::config::SynapseConfig;
+use crate::learn::LearningEngine;
+
+pub async fn status(config: &SynapseConfig) -> Result<()> {
+    println!("{}", "Learning Engine Status".bold().cyan());
+    println!("{}", "═".repeat(50));
+
+    let engine = LearningEngine::new(&config.learning.sidecar_url, config.learning.enabled);
+
+    match engine.status().await {
+        Ok(status) => {
+            println!("  {} {}", "Pairs collected:".bold(), status.pairs_collected);
+            println!("  {} {}", "Training queue:".bold(), status.training_queue);
+            println!("  {} {}", "Adapters created:".bold(), status.adapters_created);
+            if let Some(last) = status.last_trained {
+                println!("  {} {}", "Last trained:".bold(), last);
+            }
+        }
+        Err(e) => {
+            println!("  {} Learning sidecar not reachable: {e}", "⚠".yellow());
+            println!("  Start it with: {}", "docker compose up synapse-learn".yellow());
+        }
+    }
+
+    Ok(())
+}
+
+pub async fn train_now(config: &SynapseConfig) -> Result<()> {
+    println!("{}", "Triggering training...".bold().cyan());
+
+    let engine = LearningEngine::new(&config.learning.sidecar_url, config.learning.enabled);
+
+    let request = crate::learn::engine::TrainRequest {
+        specialist: "general".into(),
+        base_model: config.base_model.clone(),
+    };
+
+    match engine.train_now(request).await {
+        Ok(result) => {
+            println!("  {} Training complete!", "✓".green());
+            println!("  Adapter: {}", result.adapter_path);
+            println!("  Loss: {:.4}", result.loss);
+            println!("  Pairs used: {}", result.pairs_used);
+        }
+        Err(e) => {
+            println!("  {} Training failed: {e}", "✗".red());
+        }
+    }
+
+    Ok(())
+}

package/crates/synapse/src/cli/mod.rs

@@ -0,0 +1,10 @@
+pub mod status;
+pub mod models;
+pub mod pull;
+pub mod export;
+pub mod import;
+pub mod learn;
+pub mod bench;
+pub mod eval;
+pub mod hub;
+pub mod train;

package/crates/synapse/src/cli/models.rs

@@ -0,0 +1,36 @@
+use anyhow::Result;
+use colored::Colorize;
+use crate::config::SynapseConfig;
+
+pub async fn run(config: &SynapseConfig) -> Result<()> {
+    println!("{}", "Available Models".bold().cyan());
+    println!("{}", "═".repeat(50));
+
+    // Scan models directory
+    if !config.models_dir.exists() {
+        println!("  No models found. Use {} to download one.", "synapse pull <model>".yellow());
+        return Ok(());
+    }
+
+    let mut found = false;
+    for entry in std::fs::read_dir(&config.models_dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_file() {
+            let name = path.file_name().unwrap_or_default().to_string_lossy();
+            let size_mb = std::fs::metadata(&path)?.len() / (1024 * 1024);
+            println!("  {} ({} MB)", name.green(), size_mb);
+            found = true;
+        }
+    }
+
+    if !found {
+        println!("  No models found. Use {} to download one.", "synapse pull <model>".yellow());
+        println!("\n  Available models:");
+        println!("    {} — Coordinator (0.5 GB)", "qwen3-0.6b".yellow());
+        println!("    {} — Specialist base (2.1 GB)", "qwen3-3b".yellow());
+        println!("    {} — Generalist (4.5 GB)", "qwen3-7b".yellow());
+    }
+
+    Ok(())
+}

package/crates/synapse/src/cli/pull.rs

@@ -0,0 +1,60 @@
+use anyhow::Result;
+use colored::Colorize;
+use crate::config::SynapseConfig;
+
+/// Known model mappings to HuggingFace repos
+const MODEL_REGISTRY: &[(&str, &str, &str)] = &[
+    ("qwen3-0.6b", "Qwen/Qwen3-0.6B-GGUF", "qwen3-0.6b-q4_k_m.gguf"),
+    ("qwen3-3b",   "Qwen/Qwen3-4B-GGUF",   "qwen3-4b-q4_k_m.gguf"),
+    ("qwen3-7b",   "Qwen/Qwen3-8B-GGUF",   "qwen3-8b-q4_k_m.gguf"),
+];
+
+pub async fn run(config: &SynapseConfig, model: &str) -> Result<()> {
+    let (name, repo, filename) = MODEL_REGISTRY.iter()
+        .find(|(n, _, _)| *n == model)
+        .ok_or_else(|| anyhow::anyhow!(
+            "Unknown model '{model}'. Available: {}",
+            MODEL_REGISTRY.iter().map(|(n, _, _)| *n).collect::<Vec<_>>().join(", ")
+        ))?;
+
+    let output_path = config.models_dir.join(filename);
+    if output_path.exists() {
+        println!("  {} {} already downloaded", "✓".green(), name);
+        return Ok(());
+    }
+
+    std::fs::create_dir_all(&config.models_dir)?;
+
+    println!("{} {} from {}", "Pulling".bold().cyan(), name, repo);
+    println!("  Downloading to {}", output_path.display());
+
+    // Use huggingface-cli if available, otherwise curl
+    let hf_cli = tokio::process::Command::new("huggingface-cli")
+        .args(["download", repo, filename, "--local-dir", &config.models_dir.to_string_lossy()])
+        .output()
+        .await;
+
+    match hf_cli {
+        Ok(out) if out.status.success() => {
+            println!("  {} Downloaded {}", "✓".green(), name);
+        }
+        _ => {
+            // Fallback to direct URL download
+            let url = format!("https://huggingface.co/{repo}/resolve/main/{filename}");
+            println!("  Using direct download: {url}");
+
+            let output = tokio::process::Command::new("curl")
+                .args(["-L", "-o", &output_path.to_string_lossy(), &url, "--progress-bar"])
+                .status()
+                .await?;
+
+            if output.success() {
+                println!("  {} Downloaded {}", "✓".green(), name);
+            } else {
+                anyhow::bail!("Failed to download model. Try manually:\n  huggingface-cli download {repo} {filename}");
+            }
+        }
+    }
+
+    Ok(())
+}

package/crates/synapse/src/cli/status.rs

@@ -0,0 +1,52 @@
+use anyhow::Result;
+use colored::Colorize;
+use crate::config::SynapseConfig;
+use crate::vram::VramManager;
+
+pub async fn run(config: &SynapseConfig) -> Result<()> {
+    println!("{}", "TITAN Synapse Status".bold().cyan());
+    println!("{}", "═".repeat(50));
+
+    // Version
+    println!("  {} {}", "Version:".bold(), env!("CARGO_PKG_VERSION"));
+    println!("  {} {}", "Data dir:".bold(), config.data_dir.display());
+
+    // GPU info
+    println!("\n{}", "GPU".bold().yellow());
+    match VramManager::gpu_info().await {
+        Ok(info) => {
+            println!("  {} {}", "Name:".bold(), info.name);
+            println!("  {} {} MB / {} MB ({:.1}% used)",
+                "VRAM:".bold(),
+                info.vram_used_mb, info.vram_total_mb,
+                (info.vram_used_mb as f32 / info.vram_total_mb.max(1) as f32) * 100.0
+            );
+            println!("  {} {:.1}%", "GPU Util:".bold(), info.utilization_percent);
+            if let Some(temp) = info.temperature_c {
+                println!("  {} {}°C", "Temp:".bold(), temp);
+            }
+        }
+        Err(e) => println!("  {} {e}", "Error:".red()),
+    }
+
+    // Models
+    println!("\n{}", "Configuration".bold().yellow());
+    println!("  {} {}", "Coordinator:".bold(), config.coordinator_model);
+    println!("  {} {}", "Base model:".bold(), config.base_model);
+    println!("  {} {}", "Specialists:".bold(), config.specialists.len());
+    for spec in &config.specialists {
+        println!("    {} [{}]",
+            format!("• {}", spec.name).green(),
+            spec.capabilities.join(", ")
+        );
+    }
+
+    // Learning
+    println!("\n{}", "Learning".bold().yellow());
+    println!("  {} {}", "Enabled:".bold(),
+        if config.learning.enabled { "yes".green() } else { "no".red() }
+    );
+    println!("  {} {}", "Sidecar:".bold(), config.learning.sidecar_url);
+
+    Ok(())
+}

package/crates/synapse/src/cli/train.rs

@@ -0,0 +1,99 @@
+use anyhow::Result;
+use colored::Colorize;
+use crate::config::SynapseConfig;
+use std::process::Command;
+
+/// Train our own Synapse model — not someone else's, OURS.
+///
+/// Pipeline:
+/// 1. Generate training data (swarm routing + honesty + public datasets + user prefs)
+/// 2. SFT (Supervised Fine-Tuning) with QLoRA on the base architecture
+/// 3. DPO (Direct Preference Optimization) using collected preference pairs
+/// 4. Export to GGUF for the Synapse inference engine
+///
+/// The base architecture (Qwen2.5-3B) is Apache 2.0 licensed.
+/// Once we fine-tune it, the result is OUR model: synapse-3b.
+pub async fn run(config: &SynapseConfig, stage: &str, base_model: &str, output: &str) -> Result<()> {
+    println!("{}", "╔══════════════════════════════════════════════════╗".bold().purple());
+    println!("{}", "║     TITAN SYNAPSE — Model Training Pipeline     ║".bold().purple());
+    println!("{}", "║     Building OUR model. Not theirs. OURS.       ║".bold().purple());
+    println!("{}", "╚══════════════════════════════════════════════════╝".bold().purple());
+    println!();
+
+    println!("  {} {}", "Stage:".bold(), stage.cyan());
+    println!("  {} {}", "Base Architecture:".bold(), base_model);
+    println!("  {} {}", "Output Model:".bold(), output.green().bold());
+    println!("  {} {}", "License:".bold(), "Apache 2.0 (our model, our weights)");
+    println!();
+
+    // Check if Python training script exists
+    let train_script = config.data_dir
+        .parent().unwrap_or(&config.data_dir)
+        .join("python/synapse_learn/train_base.py");
+
+    // Also check relative to current directory
+    let script_paths = [
+        std::path::PathBuf::from("python/synapse_learn/train_base.py"),
+        train_script.clone(),
+        config.data_dir.join("train_base.py"),
+    ];
+
+    let script = script_paths.iter().find(|p| p.exists());
+
+    if let Some(script_path) = script {
+        println!("  {} Found training script: {}", "✓".green(), script_path.display());
+        println!();
+
+        // Run the Python training pipeline
+        println!("  {} Starting training...", "⚡".yellow());
+        println!("  {}", "This will take a while. Go grab coffee. Or three.".dimmed());
+        println!();
+
+        let result = Command::new("python")
+            .args([
+                script_path.to_str().unwrap(),
+                "--stage", stage,
+                "--base-model", base_model,
+                "--output", output,
+            ])
+            .env("SYNAPSE_DATA_DIR", config.data_dir.to_str().unwrap())
+            .status();
+
+        match result {
+            Ok(status) if status.success() => {
+                println!();
+                println!("  {}", "═".repeat(50).purple());
+                println!("  {} {}", "✓".green().bold(), "Model training complete!".bold().green());
+                println!();
+                println!("  Your model: {}", format!("{}.gguf", output).cyan().bold());
+                println!("  Location: {}", config.models_dir.display());
+                println!();
+                println!("  {} Start using it:", "→".bold());
+                println!("    {} synapse up", "$".dimmed());
+                println!("    Then open {} in your browser", "http://localhost:6900".cyan());
+                println!();
+                println!("  {}", "This model is YOURS. Train it more. Make it smarter.".bold());
+                println!("  {}", "Every conversation it has makes it better.".dimmed());
+            }
+            Ok(status) => {
+                println!("  {} Training exited with code: {:?}", "⚠".yellow(), status.code());
+            }
+            Err(e) => {
+                println!("  {} Failed to run training: {e}", "✗".red());
+                println!();
+                println!("  {} Install Python dependencies:", "→".bold());
+                println!("    pip install torch transformers peft trl bitsandbytes datasets");
+            }
+        }
+    } else {
+        // No Python script found — print manual instructions
+        println!("  {} Training script not found at expected paths.", "⚠".yellow());
+        println!();
+        println!("  {} Manual training:", "→".bold());
+        println!("    cd python/synapse_learn");
+        println!("    pip install torch transformers peft trl bitsandbytes datasets");
+        println!("    python train_base.py --stage {} --base-model {} --output {}", stage, base_model, output);
+    }
+
+    Ok(())
+}

package/crates/synapse/src/config.rs

@@ -0,0 +1,220 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SynapseConfig {
+    /// Server port
+    #[serde(default = "default_port")]
+    pub port: u16,
+
+    /// Data directory (~/.synapse)
+    #[serde(default = "default_data_dir")]
+    pub data_dir: PathBuf,
+
+    /// Models directory
+    #[serde(default = "default_models_dir")]
+    pub models_dir: PathBuf,
+
+    /// Adapters directory
+    #[serde(default = "default_adapters_dir")]
+    pub adapters_dir: PathBuf,
+
+    /// Coordinator model name
+    #[serde(default = "default_coordinator")]
+    pub coordinator_model: String,
+
+    /// Default specialist base model
+    #[serde(default = "default_base_model")]
+    pub base_model: String,
+
+    /// Max VRAM budget in MB (0 = auto-detect)
+    #[serde(default)]
+    pub max_vram_mb: u64,
+
+    /// Cloud fallback configuration
+    #[serde(default)]
+    pub cloud: CloudConfig,
+
+    /// Learning engine configuration
+    #[serde(default)]
+    pub learning: LearningConfig,
+
+    /// Specialist definitions
+    #[serde(default)]
+    pub specialists: Vec<SpecialistConfig>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct CloudConfig {
+    /// Cloud API base URL (OpenAI-compatible)
+    pub api_base: Option<String>,
+    /// API key
+    pub api_key: Option<String>,
+    /// Model to use for cloud fallback
+    pub model: Option<String>,
+    /// Enable cloud fallback
+    #[serde(default)]
+    pub enabled: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LearningConfig {
+    /// Enable continuous learning
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+    /// Min preference pairs before training
+    #[serde(default = "default_min_pairs")]
+    pub min_pairs_before_training: u32,
+    /// Learning sidecar URL
+    #[serde(default = "default_learn_url")]
+    pub sidecar_url: String,
+    /// Self-evaluation threshold (1-5, below this = negative example)
+    #[serde(default = "default_eval_threshold")]
+    pub eval_threshold: f32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SpecialistConfig {
+    /// Specialist name
+    pub name: String,
+    /// Capabilities this specialist handles
+    pub capabilities: Vec<String>,
+    /// Base model (overrides global)
+    pub base_model: Option<String>,
+    /// LoRA adapter path
+    pub adapter: Option<String>,
+    /// System prompt
+    pub system_prompt: Option<String>,
+    /// Priority (higher = preferred)
+    #[serde(default = "default_priority")]
+    pub priority: u32,
+}
+
+fn default_port() -> u16 { 6900 }
+fn default_data_dir() -> PathBuf {
+    dirs::home_dir().unwrap_or_default().join(".synapse")
+}
+fn default_models_dir() -> PathBuf {
+    default_data_dir().join("models")
+}
+fn default_adapters_dir() -> PathBuf {
+    default_data_dir().join("adapters")
+}
+fn default_coordinator() -> String { "qwen3-0.6b".into() }
+fn default_base_model() -> String { "qwen3-3b".into() }
+fn default_true() -> bool { true }
+fn default_min_pairs() -> u32 { 10 }
+fn default_learn_url() -> String { "http://localhost:8090".into() }
+fn default_eval_threshold() -> f32 { 3.0 }
+fn default_priority() -> u32 { 50 }
+
+impl Default for LearningConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            min_pairs_before_training: 10,
+            sidecar_url: default_learn_url(),
+            eval_threshold: 3.0,
+        }
+    }
+}
+
+impl SynapseConfig {
+    pub fn load(path: Option<&str>) -> Result<Self> {
+        let config_path = match path {
+            Some(p) => PathBuf::from(p),
+            None => default_data_dir().join("config.yaml"),
+        };
+
+        if config_path.exists() {
+            let content = std::fs::read_to_string(&config_path)?;
+            let config: SynapseConfig = serde_yaml::from_str(&content)?;
+            Ok(config)
+        } else {
+            let config = SynapseConfig::default();
+            // Ensure data directories exist
+            std::fs::create_dir_all(&config.data_dir)?;
+            std::fs::create_dir_all(&config.models_dir)?;
+            std::fs::create_dir_all(&config.adapters_dir)?;
+            // Write default config
+            let yaml = serde_yaml::to_string(&config)?;
+            std::fs::write(&config_path, yaml)?;
+            tracing::info!("Created default config at {}", config_path.display());
+            Ok(config)
+        }
+    }
+}
+
+impl Default for SynapseConfig {
+    fn default() -> Self {
+        Self {
+            port: default_port(),
+            data_dir: default_data_dir(),
+            models_dir: default_models_dir(),
+            adapters_dir: default_adapters_dir(),
+            coordinator_model: default_coordinator(),
+            base_model: default_base_model(),
+            max_vram_mb: 0,
+            cloud: CloudConfig::default(),
+            learning: LearningConfig::default(),
+            specialists: vec![
+                SpecialistConfig {
+                    name: "general".into(),
+                    capabilities: vec!["general".into(), "chat".into()],
+                    base_model: None,
+                    adapter: None,
+                    system_prompt: Some("You are a helpful AI assistant.".into()),
+                    priority: 50,
+                },
+                SpecialistConfig {
+                    name: "python_expert".into(),
+                    capabilities: vec!["python".into(), "debugging".into(), "testing".into()],
+                    base_model: None,
+                    adapter: None,
+                    system_prompt: Some("You are an expert Python developer.".into()),
+                    priority: 60,
+                },
+                SpecialistConfig {
+                    name: "sql_expert".into(),
+                    capabilities: vec!["sql".into(), "database".into(), "query".into()],
+                    base_model: None,
+                    adapter: None,
+                    system_prompt: Some("You are an expert database engineer.".into()),
+                    priority: 60,
+                },
+            ],
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_default_config() {
+        let config = SynapseConfig::default();
+        assert_eq!(config.port, 6900);
+        assert_eq!(config.coordinator_model, "qwen3-0.6b");
+        assert_eq!(config.specialists.len(), 3);
+    }
+
+    #[test]
+    fn test_config_serialization() {
+        let config = SynapseConfig::default();
+        let yaml = serde_yaml::to_string(&config).unwrap();
+        let parsed: SynapseConfig = serde_yaml::from_str(&yaml).unwrap();
+        assert_eq!(parsed.port, config.port);
+    }
+
+    #[test]
+    fn test_load_missing_config() {
+        // Should create default when file doesn't exist
+        let tmp = tempfile::tempdir().unwrap();
+        let path = tmp.path().join("nonexistent.yaml");
+        // This would try to create dirs, so just test default
+        let config = SynapseConfig::default();
+        assert_eq!(config.base_model, "qwen3-3b");
+    }
+}