feat: platform extension migrator + code mode rename (#6611)

crates/goose/src/config/base.rs

@@ -273,25 +273,34 @@ impl Config {
     }
 
     fn load(&self) -> Result<Mapping, ConfigError> {
-        if self.config_path.exists() {
-            self.load_values_with_recovery()
+        let mut values = if self.config_path.exists() {
+            self.load_values_with_recovery()?
         } else {
             // Config file doesn't exist, try to recover from backup first
             tracing::info!("Config file doesn't exist, attempting recovery from backup");
 
             if let Ok(backup_values) = self.try_restore_from_backup() {
                 tracing::info!("Successfully restored config from backup");
-                return Ok(backup_values);
+                backup_values
+            } else {
+                // No backup available, create a default config
+                tracing::info!("No backup found, creating default configuration");
+
+                // Try to load from init-config.yaml if it exists, otherwise use empty config
+                let default_config = self.load_init_config_if_exists().unwrap_or_default();
+
+                self.create_and_save_default_config(default_config)?
             }
+        };
 
-            // No backup available, create a default config
-            tracing::info!("No backup found, creating default configuration");
-
-            // Try to load from init-config.yaml if it exists, otherwise use empty config
-            let default_config = self.load_init_config_if_exists().unwrap_or_default();
-
-            self.create_and_save_default_config(default_config)
+        // Run migrations on the loaded config
+        if crate::config::migrations::run_migrations(&mut values) {
+            if let Err(e) = self.save_values(values.clone()) {
+                tracing::warn!("Failed to save migrated config: {}", e);
+            }
         }
+
+        Ok(values)
     }
 
     pub fn all_values(&self) -> Result<HashMap<String, Value>, ConfigError> {
@@ -1203,13 +1212,7 @@ mod tests {
         // Print the final values for debugging
         println!("Final values: {:?}", final_values);
 
-        assert_eq!(
-            final_values.len(),
-            3,
-            "Expected 3 values, got {}",
-            final_values.len()
-        );
-
+        // Check that our 3 keys are present (migrations may add additional keys like "extensions")
         for i in 0..3 {
             let key = format!("key{}", i);
             let value = format!("value{}", i);
@@ -1285,19 +1288,22 @@ mod tests {
         // Try to load values - should create a fresh default config
         let recovered_values = config.all_values()?;
 
-        // Should return empty config
-        assert_eq!(recovered_values.len(), 0);
+        // Note: migrations may add keys like "extensions", so we just verify
+        // that no user-defined keys exist (the config was reset)
+        assert!(
+            !recovered_values.contains_key("key1"),
+            "Should not have user keys after recovery"
+        );
 
         // Verify that a clean config file was written to disk
         let file_content = std::fs::read_to_string(config_file.path())?;
 
-        // Should be valid YAML (empty object)
+        // Should be valid YAML
         let parsed: serde_yaml::Value = serde_yaml::from_str(&file_content)?;
         assert!(parsed.is_mapping());
 
         // Should be able to load it again without issues
-        let reloaded_values = config.all_values()?;
-        assert_eq!(reloaded_values.len(), 0);
+        let _reloaded_values = config.all_values()?;
 
         Ok(())
     }
@@ -1316,8 +1322,12 @@ mod tests {
         // Try to load values - should create a fresh default config file
         let values = config.all_values()?;
 
-        // Should return empty config
-        assert_eq!(values.len(), 0);
+        // Note: migrations may add keys like "extensions", so we just verify
+        // that no user-defined keys exist (the config was freshly created)
+        assert!(
+            !values.contains_key("key1"),
+            "Should not have user keys in fresh config"
+        );
 
         // Verify that the config file was created
         assert!(config_path.exists());
@@ -1328,8 +1338,7 @@ mod tests {
         assert!(parsed.is_mapping());
 
         // Should be able to load it again without issues
-        let reloaded_values = config.all_values()?;
-        assert_eq!(reloaded_values.len(), 0);
+        let _reloaded_values = config.all_values()?;
 
         Ok(())
     }

crates/goose/src/config/extensions.rs

@@ -1,5 +1,4 @@
 use super::base::Config;
-use crate::agents::extension::PLATFORM_EXTENSIONS;
 use crate::agents::ExtensionConfig;
 use indexmap::IndexMap;
 use serde::{Deserialize, Serialize};
@@ -54,24 +53,6 @@ fn get_extensions_map() -> IndexMap<String, ExtensionEntry> {
         }
     }
 
-    // Always inject platform extensions (code_execution, todo, skills, etc.)
-    // These are internal agent extensions that should always be available
-    for (name, def) in PLATFORM_EXTENSIONS.iter() {
-        if !extensions_map.contains_key(*name) {
-            extensions_map.insert(
-                name.to_string(),
-                ExtensionEntry {
-                    config: ExtensionConfig::Platform {
-                        name: def.name.to_string(),
-                        description: def.description.to_string(),
-                        bundled: Some(true),
-                        available_tools: Vec::new(),
-                    },
-                    enabled: def.default_enabled,
-                },
-            );
-        }
-    }
     extensions_map
 }
 

crates/goose/src/config/migrations.rs

@@ -0,0 +1,141 @@
+use crate::agents::extension::PLATFORM_EXTENSIONS;
+use crate::agents::ExtensionConfig;
+use crate::config::extensions::ExtensionEntry;
+use serde_yaml::Mapping;
+
+const EXTENSIONS_CONFIG_KEY: &str = "extensions";
+
+pub fn run_migrations(config: &mut Mapping) -> bool {
+    let mut changed = false;
+    changed |= migrate_platform_extensions(config);
+    changed
+}
+
+fn migrate_platform_extensions(config: &mut Mapping) -> bool {
+    let extensions_key = serde_yaml::Value::String(EXTENSIONS_CONFIG_KEY.to_string());
+
+    let extensions_value = config
+        .get(&extensions_key)
+        .cloned()
+        .unwrap_or(serde_yaml::Value::Mapping(Mapping::new()));
+
+    let mut extensions_map: Mapping = match extensions_value {
+        serde_yaml::Value::Mapping(m) => m,
+        _ => Mapping::new(),
+    };
+
+    let mut needs_save = false;
+
+    for (name, def) in PLATFORM_EXTENSIONS.iter() {
+        let ext_key = serde_yaml::Value::String(name.to_string());
+        let existing = extensions_map.get(&ext_key);
+
+        let needs_migration = match existing {
+            None => true,
+            Some(value) => match serde_yaml::from_value::<ExtensionEntry>(value.clone()) {
+                Ok(entry) => {
+                    if let ExtensionConfig::Platform {
+                        description,
+                        display_name,
+                        ..
+                    } = &entry.config
+                    {
+                        description != def.description
+                            || display_name.as_deref() != Some(def.display_name)
+                    } else {
+                        true
+                    }
+                }
+                Err(_) => true,
+            },
+        };
+
+        if needs_migration {
+            let enabled = existing
+                .and_then(|v| serde_yaml::from_value::<ExtensionEntry>(v.clone()).ok())
+                .map(|e| e.enabled)
+                .unwrap_or(def.default_enabled);
+
+            let new_entry = ExtensionEntry {
+                config: ExtensionConfig::Platform {
+                    name: def.name.to_string(),
+                    description: def.description.to_string(),
+                    display_name: Some(def.display_name.to_string()),
+                    bundled: Some(true),
+                    available_tools: Vec::new(),
+                },
+                enabled,
+            };
+
+            if let Ok(value) = serde_yaml::to_value(&new_entry) {
+                extensions_map.insert(ext_key, value);
+                needs_save = true;
+            }
+        }
+    }
+
+    if needs_save {
+        config.insert(extensions_key, serde_yaml::Value::Mapping(extensions_map));
+    }
+
+    needs_save
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_migrate_platform_extensions_empty_config() {
+        let mut config = Mapping::new();
+        let changed = run_migrations(&mut config);
+
+        assert!(changed);
+        let extensions_key = serde_yaml::Value::String(EXTENSIONS_CONFIG_KEY.to_string());
+        assert!(config.contains_key(&extensions_key));
+    }
+
+    #[test]
+    fn test_migrate_platform_extensions_preserves_enabled_state() {
+        let mut config = Mapping::new();
+        let mut extensions = Mapping::new();
+        let todo_entry = ExtensionEntry {
+            config: ExtensionConfig::Platform {
+                name: "todo".to_string(),
+                description: "old description".to_string(),
+                display_name: Some("Old Name".to_string()),
+                bundled: Some(true),
+                available_tools: Vec::new(),
+            },
+            enabled: false,
+        };
+        extensions.insert(
+            serde_yaml::Value::String("todo".to_string()),
+            serde_yaml::to_value(&todo_entry).unwrap(),
+        );
+        config.insert(
+            serde_yaml::Value::String(EXTENSIONS_CONFIG_KEY.to_string()),
+            serde_yaml::Value::Mapping(extensions),
+        );
+
+        let changed = run_migrations(&mut config);
+        assert!(changed);
+
+        let extensions_key = serde_yaml::Value::String(EXTENSIONS_CONFIG_KEY.to_string());
+        let extensions = config.get(&extensions_key).unwrap().as_mapping().unwrap();
+        let todo_key = serde_yaml::Value::String("todo".to_string());
+        let todo_value = extensions.get(&todo_key).unwrap();
+        let todo_entry: ExtensionEntry = serde_yaml::from_value(todo_value.clone()).unwrap();
+
+        assert!(!todo_entry.enabled);
+    }
+
+    #[test]
+    fn test_migrate_platform_extensions_idempotent() {
+        let mut config = Mapping::new();
+        run_migrations(&mut config);
+
+        let changed = run_migrations(&mut config);
+        assert!(!changed);
+    }
+}

crates/goose/src/config/mod.rs

@@ -3,6 +3,7 @@ pub mod declarative_providers;
 mod experiments;
 pub mod extensions;
 pub mod goose_mode;
+mod migrations;
 pub mod paths;
 pub mod permission;
 pub mod search_path;