refactor: replace OpenClaw auto-migration with detection notice

Remove silent auto-migration of OpenClaw config and replace with a
startup notice linking to the migration guide when ~/.openclaw is
detected.

Author: yiwang

src/cli/chat.rs

@@ -183,6 +183,10 @@ pub async fn run(args: ChatArgs, agent_id: &str) -> Result<()> {
     );
     println!("Type /help for commands, /quit to exit\n");
 
+    if let Some(notice) = crate::config::check_openclaw_detected() {
+        println!("{}\n", notice);
+    }
+
     // Store agent_id for command handling
     let agent_id = agent_id.to_string();
 

src/cli/daemon.rs

@@ -96,6 +96,10 @@ pub fn daemonize_and_run(agent_id: &str) -> Result<()> {
     println!("\nUse 'localgpt daemon status' to check status");
     println!("Use 'localgpt daemon stop' to stop\n");
 
+    if let Some(notice) = crate::config::check_openclaw_detected() {
+        println!("{}\n", notice);
+    }
+
     // Fork BEFORE starting Tokio
     // Use append mode to preserve previous logs within the same day
     let stdout = std::fs::OpenOptions::new()
@@ -296,6 +300,10 @@ async fn start_daemon(foreground: bool, agent_id: &str) -> Result<()> {
         agent_id
     );
 
+    if let Some(notice) = crate::config::check_openclaw_detected() {
+        println!("{}\n", notice);
+    }
+
     // Write PID file for foreground mode
     fs::write(&pid_file, std::process::id().to_string())?;
 

src/config/migrate.rs

@@ -1,174 +1,22 @@
-//! OpenClaw config migration support
+//! OpenClaw detection
 //!
-//! Provides best-effort migration from OpenClaw's JSON5 config format to LocalGPT's TOML format.
-
-use anyhow::Result;
-use serde::Deserialize;
-use std::fs;
-use std::path::PathBuf;
-use tracing::{debug, info, warn};
-
-use super::{AnthropicConfig, ClaudeCliConfig, Config, OpenAIConfig};
-
-/// OpenClaw config structure (partial - only fields we can migrate)
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct OpenClawConfig {
-    #[serde(default)]
-    agents: Option<OpenClawAgentsConfig>,
-
-    #[serde(default)]
-    models: Option<OpenClawModelsConfig>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct OpenClawAgentsConfig {
-    #[serde(default)]
-    defaults: Option<OpenClawAgentDefaults>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct OpenClawAgentDefaults {
-    #[serde(default)]
-    workspace: Option<String>,
-
-    #[serde(default)]
-    model: Option<String>,
-
-    #[serde(default)]
-    context_window: Option<usize>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct OpenClawModelsConfig {
-    #[serde(default)]
-    openai: Option<OpenClawOpenAIConfig>,
-
-    #[serde(default)]
-    anthropic: Option<OpenClawAnthropicConfig>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct OpenClawOpenAIConfig {
-    #[serde(default)]
-    api_key: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct OpenClawAnthropicConfig {
-    #[serde(default)]
-    api_key: Option<String>,
-}
-
-/// Path to OpenClaw's config file
-pub fn openclaw_config_path() -> Result<PathBuf> {
-    let base = directories::BaseDirs::new()
-        .ok_or_else(|| anyhow::anyhow!("Could not determine home directory"))?;
-
-    Ok(base.home_dir().join(".openclaw").join("config.json5"))
-}
-
-/// Try to load and migrate OpenClaw config
-pub fn try_migrate_openclaw_config() -> Option<Config> {
-    let path = match openclaw_config_path() {
-        Ok(p) => p,
-        Err(_) => return None,
-    };
-
-    if !path.exists() {
-        debug!("No OpenClaw config found at {:?}", path);
-        return None;
+//! Checks for an existing OpenClaw installation and returns a notice
+//! directing users to the migration guide.
+
+/// Check if an OpenClaw data directory exists at ~/.openclaw.
+///
+/// Returns a formatted notice string if detected, `None` otherwise.
+pub fn check_openclaw_detected() -> Option<String> {
+    let base = directories::BaseDirs::new()?;
+    let openclaw_dir = base.home_dir().join(".openclaw");
+
+    if openclaw_dir.exists() {
+        Some(
+            "Note: OpenClaw data detected at ~/.openclaw\n  \
+             Migration guide: https://localgpt.app/docs/openclaw-migration"
+                .to_string(),
+        )
+    } else {
+        None
     }
-
-    info!("Found OpenClaw config at {:?}, attempting migration", path);
-
-    let content = match fs::read_to_string(&path) {
-        Ok(c) => c,
-        Err(e) => {
-            warn!("Failed to read OpenClaw config: {}", e);
-            return None;
-        }
-    };
-
-    let openclaw_config: OpenClawConfig = match json5::from_str(&content) {
-        Ok(c) => c,
-        Err(e) => {
-            warn!("Failed to parse OpenClaw config: {}", e);
-            return None;
-        }
-    };
-
-    Some(convert_openclaw_config(openclaw_config))
-}
-
-/// Convert OpenClaw config to LocalGPT config
-fn convert_openclaw_config(oc: OpenClawConfig) -> Config {
-    let mut config = Config::default();
-
-    // Migrate agent defaults
-    if let Some(agents) = oc.agents
-        && let Some(defaults) = agents.defaults
-    {
-        if let Some(workspace) = defaults.workspace {
-            // Convert OpenClaw workspace path to LocalGPT XDG format
-            let workspace = workspace.replace("~/.openclaw/", "~/.local/share/localgpt/");
-            config.memory.workspace = workspace;
-        }
-
-        if let Some(model) = defaults.model {
-            config.agent.default_model = model;
-        }
-
-        if let Some(context_window) = defaults.context_window {
-            config.agent.context_window = context_window;
-        }
-    }
-
-    // Migrate model configs (API keys)
-    if let Some(models) = oc.models {
-        if let Some(openai) = models.openai
-            && let Some(api_key) = openai.api_key
-        {
-            config.providers.openai = Some(OpenAIConfig {
-                api_key,
-                base_url: "https://api.openai.com/v1".to_string(),
-            });
-        }
-
-        if let Some(anthropic) = models.anthropic
-            && let Some(api_key) = anthropic.api_key
-        {
-            config.providers.anthropic = Some(AnthropicConfig {
-                api_key,
-                base_url: "https://api.anthropic.com".to_string(),
-            });
-        }
-    }
-
-    // Always enable Claude CLI as default (OpenClaw uses it too)
-    if config.providers.claude_cli.is_none() {
-        config.providers.claude_cli = Some(ClaudeCliConfig {
-            command: "claude".to_string(),
-            model: "opus".to_string(),
-        });
-    }
-
-    info!("Migrated OpenClaw config successfully");
-    config
-}
-
-/// Check if OpenClaw workspace exists and can be reused
-pub fn has_openclaw_workspace() -> bool {
-    let base = match directories::BaseDirs::new() {
-        Some(b) => b,
-        None => return false,
-    };
-
-    let workspace = base.home_dir().join(".openclaw").join("workspace");
-    workspace.exists()
 }

src/config/mod.rs

@@ -1,7 +1,7 @@
 mod migrate;
 mod schema;
 
-pub use migrate::{has_openclaw_workspace, openclaw_config_path, try_migrate_openclaw_config};
+pub use migrate::check_openclaw_detected;
 pub use schema::*;
 
 use anyhow::Result;
@@ -537,13 +537,6 @@ impl Config {
         let path = paths.config_file();
 
         if !path.exists() {
-            // Try to migrate from OpenClaw config
-            if let Some(mut migrated) = try_migrate_openclaw_config() {
-                migrated.paths = paths;
-                // Save migrated config to disk
-                migrated.save()?;
-                return Ok(migrated);
-            }
             // Create default config file on first run
             let config = Config {
                 paths,