astrid 0.10.1

Command-line interface for Astrid secure agent runtime
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

//! CLI handlers for the `astrid config` subcommand.

use anyhow::Result;
use astrid_config::{Config, ResolvedConfig, ShowFormat};

/// Show the resolved configuration with source annotations.
pub(crate) fn show_config(format: &str, section: Option<&str>) -> Result<()> {
    let workspace_root = std::env::current_dir().ok();
    let resolved = Config::load_with_layout(
        workspace_root.as_deref(),
        crate::workspace_layout::current(),
    )?;

    let show_format = match format {
        "json" => ShowFormat::Json,
        _ => ShowFormat::Toml,
    };

    let output = resolved
        .show(show_format, section)
        .map_err(|e| anyhow::anyhow!("failed to format config: {e}"))?;

    println!("{output}");
    Ok(())
}

/// Validate the current configuration.
#[expect(clippy::unnecessary_wraps)]
pub(crate) fn validate_config() -> Result<()> {
    let workspace_root = std::env::current_dir().ok();

    match Config::load_with_layout(
        workspace_root.as_deref(),
        crate::workspace_layout::current(),
    ) {
        Ok(resolved) => {
            println!("Configuration is valid.");
            if !resolved.loaded_files.is_empty() {
                println!("\nLoaded files:");
                for path in &resolved.loaded_files {
                    println!("  - {path}");
                }
            }
            Ok(())
        },
        Err(e) => {
            eprintln!("Configuration error: {e}");
            std::process::exit(1);
        },
    }
}

/// Open the global runtime config file (`~/.astrid/etc/config.toml`)
/// in `$EDITOR` (falling back to `$VISUAL`, then `vi`). Creates the
/// file if missing so the editor opens on a real path.
pub(crate) fn edit_config() -> Result<()> {
    let home = astrid_core::dirs::AstridHome::resolve()
        .map_err(|e| anyhow::anyhow!("Failed to resolve Astrid home: {e}"))?;
    let path = home.config_path();
    if !path.exists() {
        if let Some(parent) = path.parent() {
            std::fs::create_dir_all(parent)?;
        }
        std::fs::write(&path, "# Astrid runtime configuration\n")?;
    }
    let editor = std::env::var("EDITOR")
        .ok()
        .or_else(|| std::env::var("VISUAL").ok())
        .unwrap_or_else(|| "vi".to_string());
    let status = std::process::Command::new(&editor)
        .arg(&path)
        .status()
        .map_err(|e| anyhow::anyhow!("Failed to launch '{editor}': {e}"))?;
    if !status.success() {
        anyhow::bail!("editor '{editor}' exited with non-zero status");
    }
    Ok(())
}

/// Show all config file paths that are checked.
#[expect(clippy::unnecessary_wraps)]
pub(crate) fn show_paths() -> Result<()> {
    let home = directories::BaseDirs::new().map(|d| d.home_dir().to_string_lossy().to_string());

    let workspace = std::env::current_dir()
        .ok()
        .map(|p| p.to_string_lossy().to_string());
    let astrid_home = std::env::var("ASTRID_HOME").ok();

    let paths = ResolvedConfig::config_paths_with_layout(
        home.as_deref(),
        astrid_home.as_deref(),
        workspace.as_deref(),
        crate::workspace_layout::current(),
    );

    println!("Configuration files checked (in precedence order):\n");
    for (i, path) in paths.iter().enumerate() {
        let exists = std::path::Path::new(path).exists();
        let status = if exists { "found" } else { "not found" };
        println!("  {}. {path}  [{status}]", i.saturating_add(1));
    }

    println!("\nEnvironment variable fallbacks:");
    println!("  ANTHROPIC_API_KEY  -> model.api_key");
    println!("  ANTHROPIC_MODEL    -> model.model");
    println!("  ASTRID_LOG_LEVEL -> logging.level");
    println!("  ASTRID_MODEL     -> model.model");
    println!("  ASTRID_WORKSPACE_MODE -> workspace.mode");

    Ok(())
}