rigspark-cli 3.0.7

Which local LLMs can your computer run? Hardware-aware CLI with yes/slow/no verdicts and tok/s estimates, then verified installs via Ollama, llama.cpp, MLX or LM Studio.
Documentation
use clap::Parser;
use rigspark_core::{
    catalog::Catalog,
    coverage::{
        Coverage, INVENTORY_URL, MAX_INVENTORY_BYTES, evaluate, monitored, parse_inventory,
    },
    reports::strip_control,
};
use rigspark_runtime::secure_fs::Directory;
use serde::Serialize;
use std::{
    error::Error,
    fs, io,
    path::{Path, PathBuf},
    process::ExitCode,
};
use tokio_util::sync::CancellationToken;

#[derive(Parser)]
#[command(about = "Report monitored upstream Ollama repositories missing from the curated catalog")]
struct Args {
    #[arg(long, default_value = "crates/rigspark-core/data/models.json")]
    catalog_path: PathBuf,
    #[arg(long)]
    inventory_path: Option<PathBuf>,
    #[arg(long, default_value = "catalog-coverage.json")]
    out: PathBuf,
    #[arg(long)]
    json: bool,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct Report {
    source: &'static str,
    checked_at: String,
    inventory_count: usize,
    #[serde(flatten)]
    coverage: Coverage,
}

fn checked_path(path: &Path) -> io::Result<PathBuf> {
    let absolute = std::path::absolute(path)?;
    let parent = absolute
        .parent()
        .ok_or_else(|| io::Error::other("file parent required"))?
        .canonicalize()?;
    let name = absolute
        .file_name()
        .ok_or_else(|| io::Error::other("filename required"))?;
    let path = parent.join(name);
    match fs::symlink_metadata(&path) {
        Ok(metadata) if !metadata.is_file() || metadata.file_type().is_symlink() => Err(
            io::Error::other("coverage paths must be regular non-symlink files"),
        ),
        Ok(_) => Ok(path),
        Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(path),
        Err(error) => Err(error),
    }
}
fn read(path: &Path, maximum: u64) -> io::Result<String> {
    let directory = Directory::open(
        path.parent()
            .ok_or_else(|| io::Error::other("missing parent"))?,
    )?;
    let name = Path::new(
        path.file_name()
            .ok_or_else(|| io::Error::other("missing filename"))?,
    );
    String::from_utf8(directory.read(name, maximum, false)?)
        .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
}
fn write(path: &Path, text: &str) -> io::Result<()> {
    let directory = Directory::open(
        path.parent()
            .ok_or_else(|| io::Error::other("missing parent"))?,
    )?;
    let name = Path::new(
        path.file_name()
            .ok_or_else(|| io::Error::other("missing filename"))?,
    );
    let exists = path.try_exists()?;
    directory.write(name, text.as_bytes(), !exists, exists)
}

async fn run(args: Args) -> Result<(), Box<dyn Error>> {
    let catalog_path = checked_path(&args.catalog_path)?;
    let inventory_path = args
        .inventory_path
        .as_deref()
        .map(checked_path)
        .transpose()?;
    let out = checked_path(&args.out)?;
    let summary = std::env::var_os("GITHUB_STEP_SUMMARY")
        .filter(|value| !value.is_empty())
        .map(|value| checked_path(Path::new(&value)))
        .transpose()?;
    let mut paths = vec![&catalog_path, &out];
    paths.extend(inventory_path.iter());
    paths.extend(summary.iter());
    for (index, path) in paths.iter().enumerate() {
        if paths[index + 1..].contains(path) {
            return Err(
                io::Error::other("coverage input and output paths must be distinct").into(),
            );
        }
    }
    let catalog = Catalog::parse(&read(&catalog_path, 16 * 1024 * 1024)?)?;
    let cancel = CancellationToken::new();
    let upstream = if let Some(path) = inventory_path {
        parse_inventory(&read(&path, MAX_INVENTORY_BYTES as u64)?)?
    } else {
        tokio::select! {
            signal=tokio::signal::ctrl_c()=>{signal?;cancel.cancel();return Err(io::Error::new(io::ErrorKind::Interrupted,"coverage cancelled").into());},
            result=rigspark_runtime::coverage::fetch_inventory(&cancel)=>result?,
        }
    };
    let monitored = monitored(&catalog, &upstream)?;
    let coverage = evaluate(&catalog, &monitored)?;
    let human = format!(
        "Catalog coverage\n  upstream: {}\n  covered:  {}\n  missing:  {}",
        coverage.upstream_count,
        coverage.covered_count,
        coverage.missing.len()
    );
    let report = Report {
        source: INVENTORY_URL,
        checked_at: rigspark_runtime::native_chat::timestamp()?,
        inventory_count: upstream.len(),
        coverage,
    };
    let json = format!("{}\n", serde_json::to_string(&report)?);
    let summary_text = summary
        .as_ref()
        .map(|path| -> io::Result<String> {
            let previous = if path.try_exists()? {
                read(path, 1024 * 1024)?
            } else {
                String::new()
            };
            Ok(format!(
                "{previous}### Catalog coverage\n\n```\n{human}\n```\n"
            ))
        })
        .transpose()?;
    write(&out, &json)?;
    if let (Some(path), Some(text)) = (summary, summary_text) {
        write(&path, &text)?;
    }
    eprintln!("{human}");
    if args.json {
        print!("{json}");
    }
    Ok(())
}

#[tokio::main]
async fn main() -> ExitCode {
    match run(Args::parse()).await {
        Ok(()) => ExitCode::SUCCESS,
        Err(error) => {
            eprintln!(
                "catalog-coverage failed: {}",
                strip_control(&error.to_string())
            );
            ExitCode::FAILURE
        }
    }
}