Skip to main content

paper/cli/
models.rs

1use super::{ModelsArgs, ModelsCommand, EXIT_ERROR, EXIT_FOUND};
2use crate::cli::model_downloader::ModelDownloader;
3use crate::core::models::ModelManager;
4use anyhow::{Context, Result};
5use indicatif::{ProgressBar, ProgressStyle};
6
7pub async fn run(args: ModelsArgs) -> Result<i32> {
8    let manager = ModelManager::new();
9    match args.command {
10        ModelsCommand::List => {
11            println!(
12                "{:<24} {:>7}  {:<9} {:<16} DESCRIPTION",
13                "MODEL", "SIZE", "INSTALLED", "LANGUAGES"
14            );
15            for m in manager.list() {
16                println!(
17                    "{:<24} {:>5}MB  {:<9} {:<16} {}{}",
18                    m.id,
19                    m.size_mb,
20                    if m.installed { "yes" } else { "no" },
21                    m.languages,
22                    m.name,
23                    if m.is_default { " [default]" } else { "" }
24                );
25            }
26        }
27        ModelsCommand::Install { model } => {
28            if !cfg!(feature = "embeddings") {
29                eprintln!(
30                    "this build has no embedding support: rebuild with --features embeddings \
31                     (keyword search works without it)"
32                );
33                return Ok(EXIT_ERROR);
34            }
35            let spec = manager.spec(&model)?;
36            let model_dir = manager.model_dir(&model);
37            tokio::fs::create_dir_all(&model_dir).await?;
38
39            // Aggregate progress bar for the whole model
40            let total_size = spec.size_bytes();
41            let aggregate_pb = ProgressBar::new(total_size);
42            aggregate_pb.set_style(
43                ProgressStyle::with_template(
44                    "{msg} [{bar:40.cyan/blue}] {bytes}/{total_bytes} ({bytes_per_sec}, {eta})",
45                )
46                .unwrap_or_else(|_| ProgressStyle::default_bar())
47                .progress_chars("##-"),
48            );
49            aggregate_pb.set_message(format!("Downloading {} ({} MB)", model, spec.size_mb()));
50
51            for file in spec.files {
52                let dest = model_dir.join(file.name);
53
54                // GitHub Releases first, Hugging Face as fallback (see
55                // `ModelSpec::download_urls`). ModelDownloader verifies the
56                // same SHA256 pin regardless of source.
57                let mut last_error = None;
58                for url in spec.download_urls(file.name) {
59                    let downloader =
60                        ModelDownloader::new(url, dest.clone(), file.sha256.to_string(), file.size);
61                    match downloader.download_with_progress().await {
62                        Ok(()) => {
63                            last_error = None;
64                            break;
65                        }
66                        Err(e) => {
67                            eprintln!("download failed, trying next source: {e:#}");
68                            last_error = Some(e);
69                        }
70                    }
71                }
72                if let Some(e) = last_error {
73                    return Err(e)
74                        .with_context(|| format!("failed to download {}/{}", model, file.name));
75                }
76
77                // Update aggregate progress
78                aggregate_pb.inc(file.size);
79            }
80
81            aggregate_pb.finish_with_message(format!(
82                "Installed {} at {}",
83                model,
84                model_dir.display()
85            ));
86            println!("installed {} at {}", model, model_dir.display());
87
88            // Update installed cache via is_installed (which caches on success)
89            let _ = manager.is_installed(&model);
90        }
91        ModelsCommand::Remove { model } => {
92            if manager.spec(&model).is_err() {
93                eprintln!("unknown model: {model}");
94                return Ok(EXIT_ERROR);
95            }
96            manager.remove(&model).await?;
97            println!("removed {model}");
98        }
99    }
100    Ok(EXIT_FOUND)
101}