modelsdev 0.11.4

A fast TUI and CLI for browsing AI models, benchmarks, and coding agents
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use std::path::{Path, PathBuf};

use anyhow::{bail, Context, Result};

use crate::config::Config;

pub fn run(dir: Option<PathBuf>, remove: bool, status: bool, config: &Config) -> Result<()> {
    let binary = std::env::current_exe().context("could not determine binary path")?;

    let target_dir = match dir {
        Some(d) => {
            if !d.is_dir() {
                bail!("directory does not exist: {}", d.display());
            }
            d
        }
        None => binary
            .parent()
            .context("could not determine binary directory")?
            .to_path_buf(),
    };

    if status {
        show_status(&binary, &target_dir, config)
    } else if remove {
        remove_links(&binary, &target_dir, config)
    } else {
        create_links(&binary, &target_dir, config)
    }
}

fn show_status(binary: &Path, target_dir: &Path, config: &Config) -> Result<()> {
    println!("Binary: {}", binary.display());
    println!("Directory: {}\n", target_dir.display());

    for (alias, _kind) in config.alias_names() {
        let link_path = target_dir.join(alias);

        match std::fs::read_link(&link_path) {
            Ok(target) => {
                if target == binary {
                    println!("  {alias} -> linked (ok)");
                } else {
                    println!(
                        "  {alias} -> linked to {} (different binary)",
                        target.display()
                    );
                }
            }
            Err(_) => {
                if link_path.exists() {
                    println!("  {alias} -> exists (not a symlink)");
                } else {
                    println!("  {alias} -> not found");
                }
            }
        }
    }

    Ok(())
}

fn create_links(binary: &Path, target_dir: &Path, config: &Config) -> Result<()> {
    let mut created = 0;

    for (alias, _kind) in config.alias_names() {
        let link_path = target_dir.join(alias);

        if link_path.exists() || link_path.symlink_metadata().is_ok() {
            // Check if it already points to our binary
            if let Ok(target) = std::fs::read_link(&link_path) {
                if target == binary {
                    println!("  {alias} -> already linked");
                    continue;
                }
                println!(
                    "  {alias} -> skipped (symlink exists, points to {})",
                    target.display()
                );
            } else {
                println!("  {alias} -> skipped (file already exists)");
            }
            continue;
        }

        #[cfg(unix)]
        {
            std::os::unix::fs::symlink(binary, &link_path)
                .with_context(|| format!("failed to create symlink: {}", link_path.display()))?;
        }

        #[cfg(not(unix))]
        {
            bail!("symlink creation is only supported on Unix systems");
        }

        println!("  {alias} -> {}", link_path.display());
        created += 1;
    }

    if created > 0 {
        println!("\nCreated {created} symlink(s) in {}", target_dir.display());
    } else {
        println!("\nNo new symlinks created.");
    }
    println!("Ensure {} is in your PATH.", target_dir.display());

    Ok(())
}

fn remove_links(binary: &Path, target_dir: &Path, config: &Config) -> Result<()> {
    let mut removed = 0;

    for (alias, _kind) in config.alias_names() {
        let link_path = target_dir.join(alias);

        match std::fs::read_link(&link_path) {
            Ok(target) => {
                if target != binary {
                    println!(
                        "  {alias} -> skipped (points to {}, not our binary)",
                        target.display()
                    );
                    continue;
                }
                std::fs::remove_file(&link_path).with_context(|| {
                    format!("failed to remove symlink: {}", link_path.display())
                })?;
                println!("  {alias} -> removed");
                removed += 1;
            }
            Err(_) => {
                if link_path.exists() {
                    println!("  {alias} -> skipped (not a symlink)");
                } else {
                    println!("  {alias} -> not found");
                }
            }
        }
    }

    println!("\nRemoved {removed} symlink(s).");
    Ok(())
}