kayro-cli 0.1.0

Create, build, and run Kayro desktop apps for humans and agents
Documentation
use std::{
    collections::{BTreeMap, BTreeSet},
    env,
    ffi::OsString,
    path::{Path, PathBuf},
    process::{Command, Stdio},
};

use serde::Deserialize;

use crate::{args::CargoOptions, project::Project};

#[derive(Clone, Debug)]
pub struct NativePackage {
    pub version: String,
    pub description: Option<String>,
    pub authors: Vec<String>,
}

/// Estimate the number of packages Cargo will compile. Cargo's stable JSON
/// stream reports completed artifacts but not a total, so we derive the total
/// from its stable, versioned metadata graph and degrade to indeterminate
/// progress if metadata is unavailable.
pub fn estimate(project: &Project, options: &CargoOptions, target: Option<&str>) -> Option<usize> {
    let mut command = metadata_command(project, options);
    command
        .arg("--filter-platform")
        .arg(target.unwrap_or("host-tuple"));

    let output = command.output().ok()?;
    if !output.status.success() {
        return None;
    }
    let metadata = serde_json::from_slice::<Metadata>(&output.stdout).ok()?;
    reachable_package_count(&metadata, &project.native_manifest)
}

pub fn native_package(project: &Project, options: &CargoOptions) -> Option<NativePackage> {
    let output = metadata_command(project, options)
        .arg("--no-deps")
        .output()
        .ok()?;
    if !output.status.success() {
        return None;
    }
    let metadata = serde_json::from_slice::<Metadata>(&output.stdout).ok()?;
    let package = metadata
        .packages
        .iter()
        .find(|package| same_path(&package.manifest_path, &project.native_manifest))?;
    (!package.version.trim().is_empty()).then(|| NativePackage {
        version: package.version.clone(),
        description: package.description.clone(),
        authors: package.authors.clone(),
    })
}

fn metadata_command(project: &Project, options: &CargoOptions) -> Command {
    let cargo = env::var_os("CARGO").unwrap_or_else(|| OsString::from("cargo"));
    let mut command = Command::new(cargo);
    command
        .arg("metadata")
        .arg("--format-version")
        .arg("1")
        .arg("--manifest-path")
        .arg(&project.native_manifest)
        .current_dir(&project.root)
        .stdin(Stdio::null())
        .stderr(Stdio::null());

    if !options.unlocked {
        command.arg("--locked");
    }
    if options.offline {
        command.arg("--offline");
    }
    if options.no_default_features {
        command.arg("--no-default-features");
    }
    if !options.features.is_empty() {
        command.arg("--features").arg(options.features.join(","));
    }
    if options
        .cargo_arg
        .iter()
        .any(|argument| argument == "--all-features")
    {
        command.arg("--all-features");
    }
    command
}

fn reachable_package_count(metadata: &Metadata, manifest: &Path) -> Option<usize> {
    let root = metadata
        .packages
        .iter()
        .find(|package| same_path(&package.manifest_path, manifest))?
        .id
        .clone();
    let nodes = metadata
        .resolve
        .as_ref()?
        .nodes
        .iter()
        .map(|node| (node.id.as_str(), node.dependencies.as_slice()))
        .collect::<BTreeMap<_, _>>();

    let mut seen = BTreeSet::new();
    let mut pending = vec![root];
    while let Some(package) = pending.pop() {
        if !seen.insert(package.clone()) {
            continue;
        }
        if let Some(dependencies) = nodes.get(package.as_str()) {
            pending.extend(dependencies.iter().cloned());
        }
    }
    (!seen.is_empty()).then_some(seen.len())
}

fn same_path(left: &Path, right: &Path) -> bool {
    if left == right {
        return true;
    }
    match (left.canonicalize(), right.canonicalize()) {
        (Ok(left), Ok(right)) => left == right,
        _ => false,
    }
}

#[derive(Deserialize)]
struct Metadata {
    packages: Vec<MetadataPackage>,
    resolve: Option<MetadataResolve>,
}

#[derive(Deserialize)]
struct MetadataPackage {
    id: String,
    manifest_path: PathBuf,
    #[serde(default)]
    version: String,
    #[serde(default)]
    description: Option<String>,
    #[serde(default)]
    authors: Vec<String>,
}

#[derive(Deserialize)]
struct MetadataResolve {
    nodes: Vec<MetadataNode>,
}

#[derive(Deserialize)]
struct MetadataNode {
    id: String,
    dependencies: Vec<String>,
}

#[cfg(test)]
mod tests {
    use serde_json::json;

    use super::*;

    #[test]
    fn counts_only_packages_reachable_from_the_native_manifest() {
        let metadata = serde_json::from_value::<Metadata>(json!({
            "packages": [
                { "id": "app", "manifest_path": "/tmp/app/Cargo.toml" },
                { "id": "a", "manifest_path": "/tmp/a/Cargo.toml" },
                { "id": "b", "manifest_path": "/tmp/b/Cargo.toml" },
                { "id": "unused", "manifest_path": "/tmp/unused/Cargo.toml" }
            ],
            "resolve": {
                "nodes": [
                    { "id": "app", "dependencies": ["a"] },
                    { "id": "a", "dependencies": ["b"] },
                    { "id": "b", "dependencies": [] },
                    { "id": "unused", "dependencies": [] }
                ]
            }
        }))
        .unwrap();

        assert_eq!(
            reachable_package_count(&metadata, Path::new("/tmp/app/Cargo.toml")),
            Some(3)
        );
    }
}