fix(agent): use clients release assets for updates

Author: AlexMikhalev

Cargo.toml

@@ -14,7 +14,7 @@ members = [
 ]
 
 [workspace.package]
-version = "1.21.4"
+version = "1.21.5"
 edition = "2024"
 authors = ["Terraphim Team <team@terraphim.ai>"]
 documentation = "https://terraphim.ai"

crates/terraphim_agent/src/main.rs

@@ -1832,7 +1832,9 @@ fn main() -> Result<()> {
     // Check for updates on startup (non-blocking, debug logging on failure)
     let rt = Runtime::new()?;
     rt.block_on(async {
-        let config = UpdaterConfig::new("terraphim-agent").with_version(env!("CARGO_PKG_VERSION"));
+        let config = UpdaterConfig::new("terraphim-agent")
+            .with_repo("terraphim", "terraphim-clients")
+            .with_version(env!("CARGO_PKG_VERSION"));
         let updater = TerraphimUpdater::new(config);
         if let Err(e) = updater.check_update().await {
             log::debug!("Update check failed: {}", e);
@@ -2130,7 +2132,9 @@ async fn run_offline_command(
     // CheckUpdate is stateless - handle before TuiService initialization
     if let Command::CheckUpdate = &command {
         println!("Checking for terraphim-agent updates...");
-        let config = UpdaterConfig::new("terraphim-agent").with_version(env!("CARGO_PKG_VERSION"));
+        let config = UpdaterConfig::new("terraphim-agent")
+            .with_repo("terraphim", "terraphim-clients")
+            .with_version(env!("CARGO_PKG_VERSION"));
         let updater = TerraphimUpdater::new(config);
         match updater.check_update().await {
             Ok(status) => {
@@ -2147,7 +2151,9 @@ async fn run_offline_command(
     // Update is stateless - handle before TuiService initialization
     if let Command::Update = &command {
         println!("Updating terraphim-agent...");
-        let config = UpdaterConfig::new("terraphim-agent").with_version(env!("CARGO_PKG_VERSION"));
+        let config = UpdaterConfig::new("terraphim-agent")
+            .with_repo("terraphim", "terraphim-clients")
+            .with_version(env!("CARGO_PKG_VERSION"));
         let updater = TerraphimUpdater::new(config);
         match updater.check_and_update().await {
             Ok(status) => {
@@ -3844,20 +3850,20 @@ fn evolution_path() -> std::path::PathBuf {
 
 fn load_evolution() -> terraphim_agent_evolution::AgentEvolutionSystem {
     let path = evolution_path();
-    if path.exists() {
-        if let Ok(data) = std::fs::read_to_string(&path) {
-            #[derive(serde::Deserialize)]
-            struct EvolutionState {
-                memory: terraphim_agent_evolution::MemoryState,
-                lessons: terraphim_agent_evolution::LessonsState,
-            }
-            if let Ok(state) = serde_json::from_str::<EvolutionState>(&data) {
-                let mut evolution =
-                    terraphim_agent_evolution::AgentEvolutionSystem::new("cli-agent".to_string());
-                evolution.memory.current_state = state.memory;
-                evolution.lessons.current_state = state.lessons;
-                return evolution;
-            }
+    if path.exists()
+        && let Ok(data) = std::fs::read_to_string(&path)
+    {
+        #[derive(serde::Deserialize)]
+        struct EvolutionState {
+            memory: terraphim_agent_evolution::MemoryState,
+            lessons: terraphim_agent_evolution::LessonsState,
+        }
+        if let Ok(state) = serde_json::from_str::<EvolutionState>(&data) {
+            let mut evolution =
+                terraphim_agent_evolution::AgentEvolutionSystem::new("cli-agent".to_string());
+            evolution.memory.current_state = state.memory;
+            evolution.lessons.current_state = state.lessons;
+            return evolution;
         }
     }
     terraphim_agent_evolution::AgentEvolutionSystem::new("cli-agent".to_string())
@@ -3942,14 +3948,23 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                     serde_json::json!({ "status": "ok", "action": "distill", "format": format })
                 );
             } else {
-                println!("Memory distill: routing to learn compile + export-kg (format: {})", format);
+                println!(
+                    "Memory distill: routing to learn compile + export-kg (format: {})",
+                    format
+                );
             }
             Ok(())
         }
-        MemorySub::Scope { role, project, check } => {
+        MemorySub::Scope {
+            role,
+            project,
+            check,
+        } => {
             let (role_clone, project_clone) = (role.clone(), project.clone());
             if check {
-                println!("Memory scope --check: verifying no permissioned items in public locations");
+                println!(
+                    "Memory scope --check: verifying no permissioned items in public locations"
+                );
                 let config_dir = dirs::config_dir()
                     .unwrap_or_else(|| std::path::PathBuf::from("."))
                     .join("terraphim");
@@ -3959,10 +3974,10 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                     for entry in std::fs::read_dir(&kg_dir)? {
                         let entry = entry?;
                         let path = entry.path();
-                        if path.is_dir() && path.file_name().map_or(false, |n| n != "projects") {
+                        if path.is_dir() && path.file_name().is_some_and(|n| n != "projects") {
                             println!("  found role KG: {}", path.display());
                         }
-                        if path.is_dir() && path.file_name().map_or(false, |n| n == "projects") {
+                        if path.is_dir() && path.file_name().is_some_and(|n| n == "projects") {
                             for p in std::fs::read_dir(&path)? {
                                 let p = p?;
                                 println!("  found project KG: {}", p.path().display());
@@ -4057,12 +4072,7 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
 
             let evolution = load_evolution();
             let items: Vec<&MemoryItem> = if all {
-                evolution
-                    .memory
-                    .current_state
-                    .short_term
-                    .iter()
-                    .collect()
+                evolution.memory.current_state.short_term.iter().collect()
             } else if let Some(ref id) = lesson_id {
                 evolution
                     .memory
@@ -4127,11 +4137,8 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                     );
                 }
 
-                let avg_composite = scores
-                    .iter()
-                    .map(|(_, s)| s.composite())
-                    .sum::<f64>()
-                    / scores.len() as f64;
+                let avg_composite =
+                    scores.iter().map(|(_, s)| s.composite()).sum::<f64>() / scores.len() as f64;
                 println!("\nAverage composite score: {:.2}", avg_composite);
             }
             Ok(())
@@ -4179,7 +4186,10 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
             }
             Ok(())
         }
-        MemorySub::Rubric { project, output: outfile } => {
+        MemorySub::Rubric {
+            project,
+            output: outfile,
+        } => {
             use terraphim_agent_evolution::MemoryItem;
 
             let evolution = load_evolution();
@@ -4196,32 +4206,27 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                 .map(|item| (*item, score_memory_item(item)))
                 .collect();
 
-            let avg_composite = scores
-                .iter()
-                .map(|(_, s)| s.composite())
-                .sum::<f64>()
-                / scores.len() as f64;
+            let avg_composite =
+                scores.iter().map(|(_, s)| s.composite()).sum::<f64>() / scores.len() as f64;
 
             let avg_dimensions = RubricScore {
                 faithfulness: scores.iter().map(|(_, s)| s.faithfulness).sum::<f64>()
                     / scores.len() as f64,
-                scope: scores.iter().map(|(_, s)| s.scope).sum::<f64>()
-                    / scores.len() as f64,
+                scope: scores.iter().map(|(_, s)| s.scope).sum::<f64>() / scores.len() as f64,
                 provenance: scores.iter().map(|(_, s)| s.provenance).sum::<f64>()
                     / scores.len() as f64,
                 actionability: scores.iter().map(|(_, s)| s.actionability).sum::<f64>()
                     / scores.len() as f64,
-                decay: scores.iter().map(|(_, s)| s.decay).sum::<f64>()
-                    / scores.len() as f64,
-                risk: scores.iter().map(|(_, s)| s.risk).sum::<f64>()
-                    / scores.len() as f64,
+                decay: scores.iter().map(|(_, s)| s.decay).sum::<f64>() / scores.len() as f64,
+                risk: scores.iter().map(|(_, s)| s.risk).sum::<f64>() / scores.len() as f64,
             };
 
             let mut offender_list: Vec<(&MemoryItem, f64)> = scores
                 .iter()
                 .map(|(item, s)| (*item, s.composite()))
                 .collect();
-            offender_list.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
+            offender_list
+                .sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal));
             let top_offenders: Vec<_> = offender_list.iter().take(3).collect();
 
             let retirement_recs: Vec<&MemoryItem> = scores
@@ -4238,15 +4243,10 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                 "**Generated:** {}\n",
                 chrono::Utc::now().to_rfc3339()
             ));
-            report.push_str(&format!(
-                "**Items analysed:** {}\n\n",
-                items.len()
-            ));
+            report.push_str(&format!("**Items analysed:** {}\n\n", items.len()));
 
             report.push_str("## Overall Scores\n\n");
-            report.push_str(&format!(
-                "| Dimension | Score | Status |\n|---|---|---|\n"
-            ));
+            report.push_str("| Dimension | Score | Status |\n|---|---|---|\n");
             for (name, value) in [
                 ("Faithfulness", avg_dimensions.faithfulness),
                 ("Scope", avg_dimensions.scope),
@@ -4306,8 +4306,6 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
             Ok(())
         }
         MemorySub::List { item_type, limit } => {
-            
-
             let evolution = load_evolution();
             let state = &evolution.memory.current_state;
 
@@ -4317,7 +4315,9 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                     .short_term
                     .iter()
                     .filter(|m| {
-                        format!("{:?}", m.item_type).to_lowercase().contains(&filter)
+                        format!("{:?}", m.item_type)
+                            .to_lowercase()
+                            .contains(&filter)
                     })
                     .take(limit)
                     .collect::<Vec<_>>()
@@ -4352,11 +4352,7 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                 } else {
                     println!("Memory items ({} total):", items.len());
                     for (i, m) in items.iter().enumerate() {
-                        let first_line = m
-                            .content
-                            .lines()
-                            .next()
-                            .unwrap_or(&m.content);
+                        let first_line = m.content.lines().next().unwrap_or(&m.content);
                         println!(
                             "  {}. [{:?}] {} -- {:?} importance (accessed {}x)",
                             i + 1,
@@ -4379,8 +4375,6 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
             Ok(())
         }
         MemorySub::Show { id, json } => {
-            
-
             let evolution = load_evolution();
 
             let memory_item = evolution
@@ -4400,11 +4394,7 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                 v.extend(ls.success_patterns.iter());
                 v
             };
-            let lesson = all_lessons
-                .iter()
-                .find(|l| l.id == id)
-                .cloned()
-                .cloned();
+            let lesson = all_lessons.iter().find(|l| l.id == id).cloned().cloned();
 
             if memory_item.is_none() && lesson.is_none() {
                 eprintln!("No memory item or lesson found with ID: {}", id);
@@ -4450,7 +4440,11 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                     println!("  impact: {:?}", l.impact);
                     println!("  confidence: {:.0}%", l.confidence * 100.0);
                     println!("  learned: {}", l.learned_at);
-                    println!("  applied: {} times (success rate: {:.0}%)", l.applied_count, l.success_rate * 100.0);
+                    println!(
+                        "  applied: {} times (success rate: {:.0}%)",
+                        l.applied_count,
+                        l.success_rate * 100.0
+                    );
                     println!("  validated: {}", if l.validated { "yes" } else { "no" });
                     if !l.tags.is_empty() {
                         println!("  tags: {}", l.tags.join(", "));
@@ -4467,9 +4461,10 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
             }
             Ok(())
         }
-        MemorySub::Export { format, output: outfile } => {
-            
-
+        MemorySub::Export {
+            format,
+            output: outfile,
+        } => {
             let evolution = load_evolution();
 
             let memory_items: Vec<serde_json::Value> = evolution
@@ -4535,15 +4530,12 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                 "markdown" => {
                     let mut md = String::new();
                     md.push_str("# Memory Export\n\n");
-                    md.push_str(&format!("**Agent:** cli-agent\n"));
+                    md.push_str("**Agent:** cli-agent\n");
                     md.push_str(&format!(
                         "**Exported:** {}\n\n",
                         chrono::Utc::now().to_rfc3339()
                     ));
-                    md.push_str(&format!(
-                        "## Memory Items ({})\n\n",
-                        memory_items.len()
-                    ));
+                    md.push_str(&format!("## Memory Items ({})\n\n", memory_items.len()));
                     for m in &memory_items {
                         md.push_str(&format!(
                             "- **{}** [{:?}]: {} (importance: {:?}, accessed: {}x)\n",
@@ -4594,12 +4586,11 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                 for entry in std::fs::read_dir(&artefact_base)? {
                     let entry = entry?;
                     let path = entry.path();
-                    if path.extension().map_or(false, |e| e == "json") {
-                        if let Ok(data) = std::fs::read_to_string(&path) {
-                            if let Ok(metrics) = serde_json::from_str::<RunMetrics>(&data) {
-                                runs.push(metrics);
-                            }
-                        }
+                    if path.extension().is_some_and(|e| e == "json")
+                        && let Ok(data) = std::fs::read_to_string(&path)
+                        && let Ok(metrics) = serde_json::from_str::<RunMetrics>(&data)
+                    {
+                        runs.push(metrics);
                     }
                 }
             }
@@ -4627,7 +4618,10 @@ async fn run_memory_command(sub: MemorySub, output: &CommandOutputConfig) -> Res
                     if artefact_base.exists() {
                         println!("  artefact directory: {}", artefact_base.display());
                     } else {
-                        println!("  no artefact directory found (expected at: {})", artefact_base.display());
+                        println!(
+                            "  no artefact directory found (expected at: {})",
+                            artefact_base.display()
+                        );
                     }
                 }
                 return Ok(());

crates/terraphim_agent/tests/update_functionality_tests.rs

@@ -157,6 +157,11 @@ async fn test_updater_configuration() {
     assert_eq!(config.bin_name, "terraphim-agent");
     assert_eq!(config.repo_owner, "terraphim");
     assert_eq!(config.repo_name, "terraphim-ai");
+
+    // terraphim-agent CLI release assets live in terraphim-clients.
+    let config = UpdaterConfig::new("terraphim-agent").with_repo("terraphim", "terraphim-clients");
+    assert_eq!(config.repo_owner, "terraphim");
+    assert_eq!(config.repo_name, "terraphim-clients");
     assert!(config.show_progress);
 
     // Test custom configuration