use clap::{Parser, Subcommand};
use laded::builder::Builder;
use laded::catalog::Catalog;
use laded::downloader::Downloader;
use laded::error::Error;
use std::fs;
use std::io::{self, Write};
use std::path::PathBuf;
const DEFAULT_CHUNK_SIZE: u32 = 1048576;
#[derive(Parser)]
#[command(name = "laded")]
#[command(about = "CLI tool to inspect, pack, and fetch lading files")]
struct Cli {
#[command(subcommand)]
command: Commands,
}
#[derive(Subcommand)]
enum Commands {
Pack {
#[arg(long)]
input: PathBuf,
#[arg(long)]
output: Option<PathBuf>,
#[arg(long)]
title: Option<String>,
#[arg(long)]
family: Option<String>,
#[arg(long)]
quantization: Option<String>,
#[arg(long = "mirror")]
mirrors: Vec<String>,
},
List {
#[arg(long)]
catalog: String,
},
Info {
#[arg(long)]
catalog: String,
#[arg(long)]
name: String,
},
Get {
#[arg(long)]
source: String,
#[arg(long)]
name: Option<String>,
#[arg(long)]
output: Option<PathBuf>,
},
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let cli = Cli::parse();
match cli.command {
Commands::Pack {
input,
output,
title,
family,
quantization,
mirrors,
} => {
let mut builder = Builder::new();
if input.is_dir() {
let base_url = mirrors.first().cloned().unwrap_or_default();
let directory = Builder::add_directory_from_disk(&input, DEFAULT_CHUNK_SIZE, &base_url)?;
let package_title = title.unwrap_or_else(|| {
input
.file_name()
.and_then(|n| n.to_str())
.unwrap_or("package")
.to_string()
});
let package = laded::package::Package {
title: package_title,
description: None,
family,
model_size: None,
quantization,
adaptation: None,
parameters: None,
files: vec![],
directories: vec![directory],
};
builder.add_package(package);
} else {
builder.add_file_from_disk(
&input,
DEFAULT_CHUNK_SIZE,
title,
family,
None, quantization,
None, None, None, mirrors,
)?;
}
let xml_out = builder.build()?;
if let Some(out_path) = output {
fs::write(out_path, xml_out)?;
} else {
io::stdout().write_all(xml_out.as_bytes())?;
}
}
Commands::List { catalog } => {
let cat = load_catalog(&catalog).await?;
println!("Catalog Version: {}", cat.version);
for pkg in &cat.packages {
println!("Package: {}", pkg.title);
if let Some(ref f) = pkg.family {
println!(" Family: {}", f);
}
if let Some(ref q) = pkg.quantization {
println!(" Quantization: {}", q);
}
for file in pkg.all_files() {
println!(" File: {}", file.name);
for url in file.mirror_urls() {
println!(" - {}", url);
}
}
}
}
Commands::Info { catalog, name } => {
let cat = load_catalog(&catalog).await?;
let found_pkg = cat.packages.iter().find(|p| p.title == name);
if let Some(pkg) = found_pkg {
println!("Package Title: {}", pkg.title);
if let Some(ref desc) = pkg.description {
println!("Description: {}", desc);
}
if let Some(ref family) = pkg.family {
println!("Family: {}", family);
}
if let Some(ref quant) = pkg.quantization {
println!("Quantization: {}", quant);
}
println!("Total Size: {} bytes", pkg.total_size());
println!("Files:");
for file in pkg.all_files() {
println!(" - {} ({} bytes)", file.name, file.file_size);
}
} else if let Some(file) = cat.packages.iter().flat_map(|p| p.all_files()).find(|f| f.name == name) {
println!("Name: {}", file.name);
println!("File Size: {} bytes", file.file_size);
println!("Chunk Size: {}", file.chunk_size);
if let Some(ref title) = file.title {
println!("Title: {}", title);
}
if let Some(ref quant) = file.quantization {
println!("Quantization: {}", quant);
}
println!("Mirrors:");
for url in file.mirror_urls() {
println!(" - {}", url);
}
} else {
eprintln!("Package or file '{}' not found in catalog.", name);
std::process::exit(1);
}
}
Commands::Get {
source,
name,
output,
} => {
let cat = load_catalog(&source).await?;
let downloader = Downloader::new();
let dst_dir = output.unwrap_or_else(|| PathBuf::from("."));
if let Some(target_name) = name {
if let Some(pkg) = cat.packages.iter().find(|p| p.title == target_name) {
downloader
.download_package(pkg, &dst_dir, |_read, _total| {})
.await?;
} else if let Some(file) = cat.packages.iter().flat_map(|p| p.all_files()).find(|f| f.name == target_name) {
let dst_file = dst_dir.join(&file.name);
downloader
.download_file(&file, None, &dst_file, |_read, _total| {})
.await?;
} else {
return Err(format!("Entry '{}' not found in catalog", target_name).into());
}
} else if let Some(pkg) = cat.packages.first() {
downloader
.download_package(pkg, &dst_dir, |_read, _total| {})
.await?;
} else {
return Err("Catalog contains no packages or files".into());
}
eprintln!("Download completed successfully.");
}
}
Ok(())
}
async fn load_catalog(source: &str) -> Result<Catalog, Error> {
if source.starts_with("http://") || source.starts_with("https://") {
Catalog::fetch(source).await
} else {
let content = fs::read_to_string(PathBuf::from(source))
.map_err(|e| Error::XmlParse(e.to_string()))?;
Catalog::parse(&content)
}
}