rigspark-cli 3.1.3

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_cli::maintenance_file::File;
use rigspark_core::{
    catalog::Catalog, catalog_request::ModelRequest, generation::GenerationCatalog,
};
use rigspark_runtime::{
    admission::{AdmissionTransport, NativeAdmissionTransport, RecordedAdmissionTransport},
    catalog_request::{RequestDisposition, evaluate_request},
};
use serde_json::Value;
use std::{error::Error, io, path::PathBuf, process::ExitCode};
use tokio_util::sync::CancellationToken;

#[derive(Parser)]
#[command(
    about = "Route a GitHub model request to generation review or source-backed GGUF admission"
)]
struct Args {
    #[arg(long, default_value = "crates/rigspark-core/data/models.json")]
    catalog_path: PathBuf,
    #[arg(long, default_value = "docs/references/catalog-quality-evidence.json")]
    evidence_path: PathBuf,
    #[arg(long, default_value = "crates/rigspark-core/data/generation.json")]
    generation_path: PathBuf,
    #[arg(long)]
    event_path: PathBuf,
    #[arg(long)]
    fixture: Option<PathBuf>,
    #[arg(long)]
    now: Option<String>,
    #[arg(long)]
    dry_run: bool,
}

fn utf8(bytes: &[u8]) -> io::Result<&str> {
    std::str::from_utf8(bytes).map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
}

fn merge_observation(mut evidence: Value, observation: Value) -> io::Result<Value> {
    let id = observation["id"]
        .as_str()
        .ok_or_else(|| io::Error::other("request observation id missing"))?;
    let observations = evidence
        .get_mut("observations")
        .and_then(Value::as_array_mut)
        .ok_or_else(|| io::Error::other("evidence observations missing"))?;
    observations.retain(|item| item["id"].as_str() != Some(id));
    observations.push(observation);
    observations.sort_by(|left, right| left["id"].as_str().cmp(&right["id"].as_str()));
    Ok(evidence)
}

async fn run(args: Args) -> Result<Value, Box<dyn Error>> {
    let catalog_file = File::open(&args.catalog_path)?;
    let evidence_file = File::open(&args.evidence_path)?;
    let event_file = File::open(&args.event_path)?;
    let original_catalog = catalog_file.read()?;
    let original_evidence = evidence_file.read()?;
    let request = ModelRequest::from_event(utf8(&event_file.read()?)?)?;
    let catalog = Catalog::parse(utf8(&original_catalog)?)?;
    let generation = GenerationCatalog::parse(utf8(&File::open(&args.generation_path)?.read()?)?)?;
    let evidence: Value = serde_json::from_slice(&original_evidence)?;
    let transport: Box<dyn AdmissionTransport> = match args.fixture {
        Some(path) => Box::new(RecordedAdmissionTransport::parse(utf8(
            &File::open(&path)?.read()?,
        )?)?),
        None => Box::new(NativeAdmissionTransport::new()?),
    };
    let now = args
        .now
        .map(Ok)
        .unwrap_or_else(rigspark_runtime::native_chat::timestamp)?;
    let outcome = evaluate_request(
        &catalog,
        &generation,
        &request.repository,
        transport.as_ref(),
        &now,
        &CancellationToken::new(),
    )
    .await?;
    let mut report = serde_json::to_value(&outcome)?;
    report["issueNumber"] = Value::from(request.issue_number);
    report["issueUrl"] = Value::from(request.issue_url);

    if outcome.disposition == RequestDisposition::Eligible && !args.dry_run {
        let updated = outcome
            .catalog
            .ok_or_else(|| io::Error::other("eligible request produced no catalog"))?;
        let observation = outcome
            .observation
            .ok_or_else(|| io::Error::other("eligible request produced no evidence"))?;
        let merged_evidence = merge_observation(evidence, observation)?;
        if catalog_file.read()? != original_catalog || evidence_file.read()? != original_evidence {
            return Err(io::Error::other("catalog or evidence changed during request").into());
        }
        catalog_file.write_json(&updated, true)?;
        evidence_file.write_json(&merged_evidence, true)?;
    }
    Ok(report)
}

#[tokio::main]
async fn main() -> ExitCode {
    match run(Args::parse()).await {
        Ok(report) => match serde_json::to_string_pretty(&report) {
            Ok(report) => {
                println!("{report}");
                ExitCode::SUCCESS
            }
            Err(_) => {
                eprintln!("catalog-request: failed to serialize validated outcome");
                ExitCode::FAILURE
            }
        },
        Err(_) => {
            eprintln!(
                "catalog-request: failed; check the event, catalog, evidence, and upstream fixture"
            );
            ExitCode::FAILURE
        }
    }
}