#[cfg(feature = "speech")]
use bunsen::kits::speech::{
asr::{
parakeet::pretrained::default_parakeet_factory,
qwen3_asr::pretrained::default_qwen3_asr_factory,
voxtral::pretrained::default_voxtral_factory,
whisper::pretrained::default_whisper_factory,
},
diarization::sortformer::pretrained::default_sortformer_factory,
tts::{
qwen3_tts::pretrained::default_qwen3_tts_factory,
zonos3::pretrained::default_zonos3_factory,
},
vad::silero_vad::pretrained::default_silero_factory,
};
use bunsen::{
data::{
builds::{
BuildFactory,
ConstructInit,
},
catalog::{
BunsenCatalogStack,
CatalogName,
ResolvedBuild,
builtin_stack,
document::CatalogEntry,
presets::ResolvedPresetSet,
},
},
errors::{
BunsenResult,
sys_at,
},
kits::language::{
decision::laya::pretrained::default_laya_factory,
generation::{
gemma::pretrained::default_gemma_factory,
nanochat::pretrained::default_nanochat_factory,
qwen3::pretrained::default_qwen3_factory,
qwen3_5::pretrained::default_qwen3_5_factory,
},
},
};
use bunsen_app::cache::human_bytes;
#[cfg(feature = "speech")]
const KIND_NAMES: &[&str] = &["asr", "tts", "chat", "decide"];
#[cfg(not(feature = "speech"))]
const KIND_NAMES: &[&str] = &["chat", "decide"];
#[derive(clap::Args, Debug)]
pub struct SummaryCommand {
#[arg(long, default_value_t = 75)]
width: usize,
#[arg(long, value_parser = clap::builder::PossibleValuesParser::new(KIND_NAMES))]
kind: Option<String>,
}
impl SummaryCommand {
pub fn run(&self) -> BunsenResult<()> {
let mut kinds = kinds()?;
if let Some(only) = &self.kind {
kinds.retain(|k| k.name == only);
}
let text = summary(&kinds, &builtin_stack()?, self.width);
use std::io::Write;
std::io::stdout()
.write_all(text.as_bytes())
.map_err(sys_at("write to", "stdout"))
}
}
pub struct Kind {
pub name: &'static str,
pub title: &'static str,
pub families: Vec<Family>,
}
pub struct Family {
pub name: &'static str,
pub description: String,
pub builds: Vec<ResolvedBuild>,
}
impl Family {
fn of<H: ConstructInit>(
name: &'static str,
factory: BuildFactory<H>,
) -> Self {
Self {
name,
description: factory
.providers()
.first()
.map(|p| p.description().to_string())
.unwrap_or_default(),
builds: factory.list().into_iter().map(|(_, b)| b).collect(),
}
}
}
pub fn kinds() -> BunsenResult<Vec<Kind>> {
let mut kinds = Vec::new();
#[cfg(feature = "speech")]
kinds.push(Kind {
name: "asr",
title: "Automated Speech Recognition",
families: vec![
Family::of("parakeet", default_parakeet_factory()?),
Family::of("qwen3-asr", default_qwen3_asr_factory()?),
Family::of("voxtral", default_voxtral_factory()?),
Family::of("whisper", default_whisper_factory()?),
Family::of("sortformer", default_sortformer_factory()?),
Family::of("silero-vad", default_silero_factory()?),
],
});
#[cfg(feature = "speech")]
kinds.push(Kind {
name: "tts",
title: "Text to Speech",
families: vec![
Family::of("zonos3", default_zonos3_factory()?),
Family::of("qwen3-tts", default_qwen3_tts_factory()?),
],
});
kinds.extend([
Kind {
name: "chat",
title: "Chat and Text Generation",
families: vec![
Family::of("qwen3", default_qwen3_factory()?),
Family::of("qwen3.5", default_qwen3_5_factory()?),
Family::of("gemma", default_gemma_factory()?),
Family::of("nanochat", default_nanochat_factory()?),
],
},
Kind {
name: "decide",
title: "Typed Decisions",
families: vec![Family::of("laya", default_laya_factory()?)],
},
]);
Ok(kinds)
}
type Listed<'a> = (&'a Family, &'a ResolvedBuild);
struct Group<'a> {
name: String,
description: String,
builds: Vec<Listed<'a>>,
}
fn group_by<'a>(
builds: impl IntoIterator<Item = Listed<'a>>,
header: impl Fn(Listed<'a>) -> (String, String),
) -> Vec<Group<'a>> {
let mut groups: Vec<Group<'a>> = Vec::new();
for listed in builds {
let (name, description) = header(listed);
match groups.iter_mut().find(|g| g.name == name) {
Some(group) => group.builds.push(listed),
None => groups.push(Group {
name,
description,
builds: vec![listed],
}),
}
}
groups
}
fn entry_description(
stack: &BunsenCatalogStack,
name: &CatalogName,
) -> Option<String> {
match stack.declaration(name)?.body() {
CatalogEntry::Namespace(ns) => ns.description.clone(),
CatalogEntry::Contract(c) => Some(c.description.clone()),
_ => None,
}
}
fn contract_header(
stack: &BunsenCatalogStack,
(family, build): Listed<'_>,
) -> (String, String) {
let top = build
.contract
.as_ref()
.and_then(|c| c.segments().get(..2))
.and_then(|s| CatalogName::parse(&s.join("/")).ok());
match top {
Some(top) => (
top.leaf().to_string(),
entry_description(stack, &top).unwrap_or_default(),
),
None => (family.name.to_string(), family.description.clone()),
}
}
fn publisher_header(
stack: &BunsenCatalogStack,
(_, build): Listed<'_>,
) -> (String, String) {
let publisher = build.name.segments()[0].clone();
let description = CatalogName::parse(&publisher)
.ok()
.and_then(|name| entry_description(stack, &name))
.unwrap_or_default();
(publisher, description)
}
pub fn summary(
kinds: &[Kind],
stack: &BunsenCatalogStack,
width: usize,
) -> String {
let mut out = String::new();
for (i, kind) in kinds.iter().enumerate() {
if i > 0 {
out.push('\n');
}
out.push_str(&format!(
"# bunsen-tool {} ...\n# {}\n",
kind.name, kind.title
));
let listed = kind
.families
.iter()
.flat_map(|f| f.builds.iter().map(move |b| (f, b)));
for contract in group_by(listed, |l| contract_header(stack, l)) {
out.push('\n');
out.push_str(&format!("# contract: {}\n", contract.name));
for line in wrap(contract.description.trim(), width.saturating_sub(2)) {
out.push_str(&format!("# {line}\n"));
}
let publishers = group_by(contract.builds, |l| publisher_header(stack, l));
for (j, publisher) in publishers.iter().enumerate() {
if j > 0 {
out.push('\n');
}
out.push_str(&header(
"publisher",
&publisher.name,
&publisher.description,
));
for (_, build) in &publisher.builds {
out.push_str(&format!("\n* {}: [{}]\n", build.name, build_details(build)));
if !build.aliases.is_empty() {
let aliases: Vec<&str> = build.aliases.iter().map(|a| a.leaf()).collect();
out.push_str(&format!(" - {}\n", aliases.join(", ")));
}
for line in wrap(build.description.trim(), width.saturating_sub(2)) {
out.push_str(&format!(" {line}\n"));
}
}
}
}
}
out
}
fn header(
what: &str,
name: &str,
description: &str,
) -> String {
match description.trim() {
"" => format!("# {what}: {name}\n"),
description => format!("# {what}: {name} - {description}\n"),
}
}
fn build_details(build: &ResolvedBuild) -> String {
let resources = build.resource_set();
let mut parts = Vec::new();
let mut files: Vec<String> = resources.size().map(human_bytes).into_iter().collect();
files.extend(
resources
.dtypes()
.into_iter()
.map(|d| short_dtype(d).to_string()),
);
if !files.is_empty() {
parts.push(files.join(" "));
}
parts.extend(presets_details(&build.presets));
parts.join("; ")
}
fn presets_details(set: &ResolvedPresetSet) -> Vec<String> {
let mut parts: Vec<String> = set
.axes
.iter()
.map(|a| {
let members: Vec<String> = a
.offers
.iter()
.map(|m| {
if !a.is_fixed() && *m == a.default {
format!("*{m}")
} else {
m.clone()
}
})
.collect();
format!("{}: {}", a.axis.name.leaf(), members.join("|"))
})
.collect();
let other: Vec<String> = set
.presets
.iter()
.map(|p| &p.name)
.filter(|n| set.axis_of(n).is_none())
.map(|n| {
if set.default.contains(n) {
format!("+*{n}")
} else {
format!("+{n}")
}
})
.collect();
if !other.is_empty() {
parts.push(other.join(" "));
}
parts
}
fn short_dtype(dtype: &str) -> &str {
match dtype {
"float64" => "f64",
"float32" => "f32",
"float16" => "f16",
"bfloat16" => "bf16",
other => other,
}
}
fn wrap(
text: &str,
width: usize,
) -> Vec<String> {
let mut lines = Vec::new();
let mut line = String::new();
for word in text.split_whitespace() {
if !line.is_empty() && width > 0 && line.chars().count() + 1 + word.chars().count() > width
{
lines.push(std::mem::take(&mut line));
}
if !line.is_empty() {
line.push(' ');
}
line.push_str(word);
}
if !line.is_empty() {
lines.push(line);
}
lines
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_wrap() {
assert_eq!(wrap("a bb ccc dddd", 6), ["a bb", "ccc", "dddd"]);
assert_eq!(wrap("a bb ccc", 0), ["a bb ccc"]);
assert_eq!(wrap(" ", 10), Vec::<String>::new());
assert_eq!(wrap("toolongword x", 4), ["toolongword", "x"]);
}
#[cfg(feature = "speech")]
#[test]
fn test_summary() {
let kinds = kinds().unwrap();
let text = summary(&kinds, &builtin_stack().unwrap(), 75);
for kind in &kinds {
assert!(
text.contains(&format!(
"# bunsen-tool {} ...\n# {}\n",
kind.name, kind.title
)),
"{text}"
);
for family in &kind.families {
for build in &family.builds {
assert_eq!(
text.matches(&format!("\n* {}: [", build.name)).count(),
1,
"{}",
build.name
);
}
}
}
assert!(
text.contains(
"# contract: parakeet-asr\n\
# A Parakeet TDT speech recognizer: a Phonon-2 archive, or transformers'\n\
# safetensors and its tokenizer.\n\
# publisher: fermion - FermionResearch, Phonon's authors.\n\n\
* fermion/phonon-2: [163.5 MB]\n - phonon\n Phonon-2: "
),
"{text}"
);
assert_eq!(text.matches("# contract: qwen3-asr\n").count(), 1, "{text}");
assert!(text.contains("task: *transcribe|translate"), "{text}");
assert!(text.contains("]\n - sortformer-v2\n"), "{text}");
assert!(!text.contains("- \n"), "{text}");
for line in text.lines().filter(|l| {
l.starts_with(" ") || l.starts_with("# ") && !l.starts_with("# publisher:")
}) {
assert!(line.chars().count() <= 75, "{line}");
}
}
}