rigspark-cli 3.0.2

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_runtime::{
    catalog_proposals::{
        NativeProposalTransport, ProposalTransport, RecordedProposals, collect_batch,
    },
    secure_fs::Directory,
};
use std::{
    error::Error,
    path::{Path, PathBuf},
    process::ExitCode,
};
use tokio_util::sync::CancellationToken;

#[derive(Parser)]
#[command(
    about = "Collect unverified catalog candidates from official registry metadata for review"
)]
struct Args {
    #[arg(long, default_value = "crates/rigspark-core/data/models.json")]
    catalog_path: PathBuf,
    #[arg(long, default_value = "catalog-proposals.json")]
    out: PathBuf,
    #[arg(long, default_value_t = 10, value_parser = clap::value_parser!(u8).range(1..=10))]
    limit: u8,
    #[arg(long, conflicts_with = "resume_from")]
    after: Option<String>,
    #[arg(long)]
    resume_from: Option<PathBuf>,
    #[arg(long)]
    source_only: bool,
    #[arg(long)]
    fixture: Option<PathBuf>,
    #[arg(long)]
    now: Option<String>,
}

fn path(raw: &Path) -> Result<PathBuf, Box<dyn Error>> {
    let absolute = std::path::absolute(raw)?;
    Ok(absolute
        .parent()
        .ok_or("parent required")?
        .canonicalize()?
        .join(absolute.file_name().ok_or("filename required")?))
}

fn read(raw: &Path) -> Result<String, Box<dyn Error>> {
    let path = path(raw)?;
    Ok(String::from_utf8(
        Directory::open(path.parent().ok_or("parent required")?)?.read(
            Path::new(path.file_name().ok_or("filename required")?),
            16 * 1024 * 1024,
            false,
        )?,
    )?)
}

async fn run(args: Args) -> Result<bool, Box<dyn Error>> {
    let output = path(&args.out)?;
    if output == path(&args.catalog_path)?
        || args
            .fixture
            .as_ref()
            .map(|fixture| path(fixture))
            .transpose()?
            .as_ref()
            == Some(&output)
        || args
            .resume_from
            .as_ref()
            .map(|input| path(input))
            .transpose()?
            .as_ref()
            == Some(&output)
    {
        return Err("output must not replace inputs".into());
    }
    let catalog = rigspark_core::catalog::Catalog::parse(&read(&args.catalog_path)?)?;
    #[derive(serde::Deserialize)]
    #[serde(rename_all = "camelCase")]
    struct Cursor {
        next_after: Option<String>,
    }
    let after = match args.resume_from {
        Some(input) => serde_json::from_str::<Cursor>(&read(&input)?)?.next_after,
        None => args.after,
    };
    let cancel = CancellationToken::new();
    let (inventory, transport): (_, Box<dyn ProposalTransport>) = match args.fixture {
        Some(fixture) => {
            let recorded: RecordedProposals =
                rigspark_core::catalog::parse_document(&read(&fixture)?)?;
            (recorded.inventory.clone(), Box::new(recorded))
        }
        None => {
            let transport = NativeProposalTransport::new(
                if args.source_only {
                    None
                } else {
                    std::env::var("OPENAI_API_KEY").ok()
                },
                if args.source_only {
                    None
                } else {
                    std::env::var("OPENAI_CATALOG_MODEL").ok()
                },
            )?;
            (
                rigspark_runtime::coverage::fetch_inventory(&cancel).await?,
                Box::new(transport),
            )
        }
    };
    let now = args
        .now
        .map(Ok)
        .unwrap_or_else(rigspark_runtime::native_chat::timestamp)?;
    let report = collect_batch(
        &catalog,
        &inventory,
        usize::from(args.limit),
        after.as_deref(),
        &now,
        args.source_only,
        transport.as_ref(),
    )
    .await?;
    let bytes = serde_json::to_vec_pretty(&report)?;
    if bytes.len() > 16 * 1024 * 1024 {
        return Err("proposal report exceeds limit".into());
    }
    let directory = Directory::open(output.parent().ok_or("parent required")?)?;
    let exists = output.try_exists()?;
    directory.write(
        Path::new(output.file_name().ok_or("filename required")?),
        &bytes,
        !exists,
        exists,
    )?;
    eprintln!(
        "catalog-propose: {} candidates; review required; inventory incomplete",
        report.proposals.len()
    );
    for proposal in &report.proposals {
        eprintln!(
            "{}: {}; {}; {}",
            proposal.repository,
            proposal.status,
            proposal.extraction_status,
            proposal.extraction_error.unwrap_or("no extraction error")
        );
    }
    Ok(!report.has_errors())
}

#[tokio::main]
async fn main() -> ExitCode {
    match run(Args::parse()).await {
        Ok(true) => ExitCode::SUCCESS,
        Ok(false) => ExitCode::from(2),
        Err(_) => {
            eprintln!(
                "catalog-propose: failed; check inputs, output path, and upstream availability (details redacted)"
            );
            ExitCode::FAILURE
        }
    }
}