sparrow-cli 0.8.2

A local-first Rust agent cockpit — route, run, replay, rewind
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

// src/commands/import_cmd.rs — sparrow import command handler

use sparrow::onboarding::migration::Migration;

pub fn handle_full_import(source: sparrow::cli::ImportSource) -> anyhow::Result<()> {
    let cwd = || std::env::current_dir().unwrap_or_default();

    let imports: Vec<(
        &'static str,
        sparrow::onboarding::migration::MigrationResult,
    )> = match source {
        sparrow::cli::ImportSource::ClaudeCode { path } => {
            let src = path.unwrap_or_else(cwd);
            vec![("claude-code", Migration::import_claude_code(&src)?)]
        }
        sparrow::cli::ImportSource::Codex { path } => {
            let src = path.unwrap_or_else(cwd);
            vec![("codex", Migration::import_codex(&src)?)]
        }
        sparrow::cli::ImportSource::OpenCode { path } => {
            let src = path.unwrap_or_else(cwd);
            vec![("opencode", Migration::import_opencode(&src)?)]
        }
        sparrow::cli::ImportSource::Openclaw { path } => {
            let src =
                path.unwrap_or_else(|| dirs::home_dir().unwrap_or_default().join(".openclaw"));
            vec![("openclaw", Migration::import_openclaw(&src)?)]
        }
        sparrow::cli::ImportSource::Auto => {
            let found = Migration::detect_installed();
            if found.is_empty() {
                println!(
                    "No supported tools detected. Supported: claude-code, codex, opencode, openclaw, hermes"
                );
                return Ok(());
            }
            println!("Detected: {}", found.join(", "));
            let cwd = cwd();
            let home = dirs::home_dir().unwrap_or_default();
            let mut all = Vec::new();
            for tool in &found {
                let imported = match tool.as_str() {
                    "claude-code" => {
                        Migration::import_claude_code(&cwd).map(|r| ("claude-code", r))
                    }
                    "codex" => Migration::import_codex(&cwd).map(|r| ("codex", r)),
                    "opencode" => Migration::import_opencode(&cwd).map(|r| ("opencode", r)),
                    "openclaw" => {
                        Migration::import_openclaw(&home.join(".openclaw")).map(|r| ("openclaw", r))
                    }
                    "hermes" => {
                        Migration::import_hermes(&home.join(".hermes")).map(|r| ("hermes", r))
                    }
                    other => {
                        println!("  (skipping {}: not supported for auto-import)", other);
                        continue;
                    }
                };
                match imported {
                    Ok(pair) => all.push(pair),
                    Err(e) => eprintln!("  ⚠ import from {} failed: {}", tool, e),
                }
            }
            all
        }
    };

    for (tool_name, result) in &imports {
        println!("═══ Import from {} ═══", tool_name);
        for line in &result.summary {
            println!("  {}", line);
        }
        if result.agents > 0 || result.commands > 0 || result.config_entries > 0 {
            println!(
                "\nDone: {} agents, {} commands, {} config entries imported.",
                result.agents, result.commands, result.config_entries
            );
        }
    }
    Ok(())
}