feat!: consume the declarative index, drop the pkg_id requirement

Cargo.toml

@@ -27,7 +27,7 @@ blake3 = { version = "1.8.5", features = ["mmap"] }
 clap = { version = "4.6.1", features = ["cargo", "derive"] }
 clap_complete = "4.6.5"
 chrono = "0.4"
-compak = "0.1.2"
+compak = "0.2.0"
 diesel = { version = "2.3.10", features = [
   "64-column-tables",
   "returning_clauses_for_sqlite_3_35",

crates/soar-cli/src/apply.rs

@@ -87,11 +87,7 @@ fn display_diff(diff: &ApplyDiff, prune: bool) {
             let pkg = &target.package;
             builder.push_record([
                 format!("{}", Colored(Green, icon_or("+", "+"))),
-                format!(
-                    "{}#{}",
-                    Colored(Blue, &pkg.pkg_name),
-                    Colored(Cyan, &pkg.pkg_id)
-                ),
+                format!("{}", Colored(Blue, &pkg.pkg_name),),
                 format!("{}", Colored(Green, &pkg.version)),
                 format!("{}", Colored(Magenta, &pkg.repo_name)),
             ]);
@@ -105,11 +101,7 @@ fn display_diff(diff: &ApplyDiff, prune: bool) {
                 .map_or("?".to_string(), |e| e.version.clone());
             builder.push_record([
                 format!("{}", Colored(Yellow, icon_or("~", "~"))),
-                format!(
-                    "{}#{}",
-                    Colored(Blue, &pkg.pkg_name),
-                    Colored(Cyan, &pkg.pkg_id)
-                ),
+                format!("{}", Colored(Blue, &pkg.pkg_name),),
                 format!(
                     "{} -> {}",
                     Colored(Red, &old_version),
@@ -123,11 +115,7 @@ fn display_diff(diff: &ApplyDiff, prune: bool) {
             for pkg in &diff.to_remove {
                 builder.push_record([
                     format!("{}", Colored(Red, icon_or("-", "-"))),
-                    format!(
-                        "{}#{}",
-                        Colored(Blue, &pkg.pkg_name),
-                        Colored(Cyan, &pkg.pkg_id)
-                    ),
+                    format!("{}", Colored(Blue, &pkg.pkg_name),),
                     format!("{}", Colored(Yellow, &pkg.version)),
                     format!("{}", Colored(Magenta, &pkg.repo_name)),
                 ]);

crates/soar-cli/src/download.rs

@@ -154,6 +154,7 @@ pub async fn handle_direct_downloads(
                                 conn,
                                 query.name.as_deref(),
                                 query.pkg_id.as_deref(),
+                                query.family.as_deref(),
                                 None,
                                 None,
                                 None,
@@ -173,6 +174,7 @@ pub async fn handle_direct_downloads(
                             conn,
                             query.name.as_deref(),
                             query.pkg_id.as_deref(),
+                            query.family.as_deref(),
                             None,
                             None,
                             None,
@@ -210,10 +212,7 @@ pub async fn handle_direct_downloads(
 
                 let package = package.resolve(query.version.as_deref());
 
-                info!(
-                    "Downloading package: {}#{}",
-                    package.pkg_name, package.pkg_id
-                );
+                info!("Downloading package: {}", package.pkg_name);
                 if let Some(ref url) = package.ghcr_blob {
                     let mut dl = OciDownload::new(url.as_str()).overwrite(ctx.get_overwrite_mode());
 

crates/soar-cli/src/health.rs

@@ -1,4 +1,4 @@
-use nu_ansi_term::Color::{Blue, Cyan, Green, Red, Yellow};
+use nu_ansi_term::Color::{Blue, Green, Red, Yellow};
 use soar_core::SoarResult;
 use soar_operations::{health, SoarContext};
 use tabled::{
@@ -25,6 +25,21 @@ pub async fn display_health(ctx: &SoarContext) -> SoarResult<()> {
     };
     builder.push_record(["PATH".to_string(), path_status]);
 
+    // Only shown once something has installed a manual page, so a user with no
+    // such package is not told to configure something they do not need.
+    if let Some(man_dir) = &report.man_path {
+        let man_status = if report.man_path_configured {
+            format!("{} Configured", Colored(Green, icon_or(Icons::CHECK, "OK")))
+        } else {
+            format!(
+                "{} {} not searched by man",
+                Colored(Yellow, icon_or(Icons::WARNING, "!")),
+                Colored(Blue, man_dir.display())
+            )
+        };
+        builder.push_record(["MANPATH".to_string(), man_status]);
+    }
+
     let pkg_status = if report.broken_packages.is_empty() {
         format!("{} None", Colored(Green, icon_or(Icons::CHECK, "OK")))
     } else {
@@ -61,10 +76,9 @@ pub async fn display_health(ctx: &SoarContext) -> SoarResult<()> {
         info!("\nBroken packages:");
         for pkg in &report.broken_packages {
             info!(
-                "  {} {}#{}: {}",
+                "  {} {}: {}",
                 Icons::ARROW,
                 Colored(Blue, &pkg.pkg_name),
-                Colored(Cyan, &pkg.pkg_id),
                 Colored(Yellow, &pkg.installed_path)
             );
         }
@@ -94,16 +108,11 @@ pub async fn remove_broken_packages(ctx: &SoarContext) -> SoarResult<()> {
     }
 
     for removed in &report.removed {
-        info!("Removed {}#{}", removed.pkg_name, removed.pkg_id);
+        info!("Removed {}", removed.pkg_name);
     }
 
     for failed in &report.failed {
-        tracing::error!(
-            "Failed to remove {}#{}: {}",
-            failed.pkg_name,
-            failed.pkg_id,
-            failed.error
-        );
+        tracing::error!("Failed to remove {}: {}", failed.pkg_name, failed.error);
     }
 
     if !report.removed.is_empty() && report.failed.is_empty() {
@@ -114,7 +123,7 @@ pub async fn remove_broken_packages(ctx: &SoarContext) -> SoarResult<()> {
             report
                 .failed
                 .iter()
-                .map(|f| format!("{}#{}", f.pkg_name, f.pkg_id))
+                .map(|f| f.pkg_name.to_string())
                 .collect::<Vec<_>>()
                 .join(", ")
         );

crates/soar-cli/src/inspect.rs

@@ -44,7 +44,8 @@ fn get_installed_path(
             conn,
             &package.repo_name,
             &package.pkg_name,
-            &package.pkg_id,
+            package.pkg_id.as_deref(),
+            package.pkg_family.as_deref(),
             &package.version,
         )
     })?;
@@ -71,6 +72,7 @@ pub async fn inspect_log(package: &str, inspect_type: InspectType) -> SoarResult
                     conn,
                     query.name.as_deref(),
                     query.pkg_id.as_deref(),
+                    query.family.as_deref(),
                     None,
                     None,
                     Some(SortDirection::Asc),
@@ -90,6 +92,7 @@ pub async fn inspect_log(package: &str, inspect_type: InspectType) -> SoarResult
                 conn,
                 query.name.as_deref(),
                 query.pkg_id.as_deref(),
+                query.family.as_deref(),
                 None,
                 None,
                 Some(SortDirection::Asc),

crates/soar-cli/src/install.rs

@@ -75,16 +75,10 @@ pub async fn install_packages(
                 };
 
                 if let Some(pkg) = pkg {
-                    // Re-resolve with the specific selected package
-                    let specific_query =
-                        format!("{}#{}:{}", pkg.pkg_name, pkg.pkg_id, pkg.repo_name);
-                    let re_results =
-                        install::resolve_packages(ctx, &[specific_query], &options).await?;
-                    for r in re_results {
-                        if let ResolveResult::Resolved(targets) = r {
-                            install_targets.extend(targets);
-                        }
-                    }
+                    // Install the package that was chosen. Re-resolving it by
+                    // name would ask the same ambiguous question again and
+                    // answer it with nothing.
+                    install_targets.push(install::target_for(ctx, pkg, &options)?);
                 }
             }
             ResolveResult::NotFound(name) => {
@@ -97,13 +91,13 @@ pub async fn install_packages(
             }
             ResolveResult::AlreadyInstalled {
                 pkg_name,
-                pkg_id,
                 repo_name,
                 version,
+                ..
             } => {
                 warn!(
-                    "{}#{}:{} ({}) is already installed - skipping",
-                    pkg_name, pkg_id, repo_name, version,
+                    "{}:{} ({}) is already installed - skipping",
+                    pkg_name, repo_name, version,
                 );
                 if !force {
                     info!("Hint: Use --force to reinstall, or --show to see other variants");
@@ -161,13 +155,13 @@ async fn install_with_show(
                     ResolveResult::Resolved(targets) => install_targets.extend(targets),
                     ResolveResult::AlreadyInstalled {
                         pkg_name,
-                        pkg_id,
                         repo_name,
                         version,
+                        ..
                     } => {
                         warn!(
-                            "{}#{}:{} ({}) is already installed - skipping",
-                            pkg_name, pkg_id, repo_name, version,
+                            "{}:{} ({}) is already installed - skipping",
+                            pkg_name, repo_name, version,
                         );
                         if !force {
                             info!("Hint: Use --force to reinstall");
@@ -200,15 +194,7 @@ async fn install_with_show(
                         };
 
                         if let Some(pkg) = pkg {
-                            let specific_query =
-                                format!("{}#{}:{}", pkg.pkg_name, pkg.pkg_id, pkg.repo_name);
-                            let re_results =
-                                install::resolve_packages(ctx, &[specific_query], options).await?;
-                            for r in re_results {
-                                if let ResolveResult::Resolved(targets) = r {
-                                    install_targets.extend(targets);
-                                }
-                            }
+                            install_targets.push(install::target_for(ctx, pkg, options)?);
                         }
                     }
                     ResolveResult::NotFound(name) => {
@@ -221,13 +207,13 @@ async fn install_with_show(
                     }
                     ResolveResult::AlreadyInstalled {
                         pkg_name,
-                        pkg_id,
                         repo_name,
                         version,
+                        ..
                     } => {
                         warn!(
-                            "{}#{}:{} ({}) is already installed - skipping",
-                            pkg_name, pkg_id, repo_name, version,
+                            "{}:{} ({}) is already installed - skipping",
+                            pkg_name, repo_name, version,
                         );
                         if !force {
                             info!(
@@ -247,6 +233,7 @@ async fn install_with_show(
                         conn,
                         query.name.as_deref(),
                         None,
+                        query.family.as_deref(),
                         None,
                         None,
                         Some(SortDirection::Asc),
@@ -266,6 +253,7 @@ async fn install_with_show(
                     conn,
                     query.name.as_deref(),
                     None,
+                    query.family.as_deref(),
                     None,
                     None,
                     Some(SortDirection::Asc),
@@ -302,7 +290,7 @@ async fn install_with_show(
         }
 
         // Get installed packages to show [installed] marker
-        let installed_packages: Vec<(String, String, String)> = diesel_db
+        let installed_packages: Vec<(String, Option<String>, String)> = diesel_db
             .with_conn(|conn| {
                 CoreRepository::list_filtered(
                     conn,
@@ -317,7 +305,7 @@ async fn install_with_show(
                 )
             })?
             .into_iter()
-            .map(|p| (p.pkg_id, p.repo_name, p.version))
+            .map(|p| (p.pkg_name, p.pkg_family, p.repo_name))
             .collect();
 
         let pkg = select_package_interactively_with_installed(
@@ -337,7 +325,7 @@ async fn install_with_show(
                     conn,
                     Some(&pkg.repo_name),
                     Some(&pkg.pkg_name),
-                    Some(&pkg.pkg_id),
+                    pkg.pkg_id.as_deref(),
                     None,
                     None,
                     None,
@@ -346,15 +334,17 @@ async fn install_with_show(
                 )
             })?
             .into_iter()
-            .map(Into::into)
-            .next();
+            // The query cannot narrow by family, and an uninstalled row of the
+            // same name would otherwise stand in for the installed one.
+            .filter(|ip| ip.pkg_family.as_deref() == pkg.pkg_family.as_deref())
+            .find(|ip| ip.is_installed)
+            .map(Into::into);
 
         if let Some(ref existing) = existing_install {
             if existing.is_installed {
                 warn!(
-                    "{}#{}:{} ({}) is already installed - {}",
+                    "{}:{} ({}) is already installed - {}",
                     existing.pkg_name,
-                    existing.pkg_id,
                     existing.repo_name,
                     existing.version,
                     if force { "reinstalling" } else { "skipping" }
@@ -402,14 +392,39 @@ fn display_install_report(report: &InstallReport, no_notes: bool) {
 
     for info in &report.installed {
         info!(
-            "\n{} {}#{}:{} [{}]",
+            "\n{} {}:{} [{}]",
             icon_or(Icons::CHECK, "*"),
             Colored(Blue, &info.pkg_name),
-            Colored(Cyan, &info.pkg_id),
             Colored(Green, &info.repo_name),
             Colored(Magenta, info.install_dir.display())
         );
 
+        if !info.shared.is_empty() {
+            // Listing these would bury the binaries: gh alone ships over a
+            // hundred manual pages.
+            let mut man = 0;
+            let mut completions = 0;
+            for (_, link) in &info.shared {
+                let path = link.to_string_lossy();
+                if path.contains("/man/") {
+                    man += 1;
+                } else {
+                    completions += 1;
+                }
+            }
+            let mut parts = Vec::new();
+            if man > 0 {
+                parts.push(format!("{man} man page{}", if man == 1 { "" } else { "s" }));
+            }
+            if completions > 0 {
+                parts.push(format!(
+                    "{completions} completion{}",
+                    if completions == 1 { "" } else { "s" }
+                ));
+            }
+            info!("  {} Linked {}", icon_or("📖", "-"), parts.join(", "));
+        }
+
         if !info.symlinks.is_empty() {
             info!("  {} Binaries:", icon_or("📂", "-"));
             for (target, link) in &info.symlinks {
@@ -424,7 +439,9 @@ fn display_install_report(report: &InstallReport, no_notes: bool) {
         }
 
         if !no_notes {
-            if let Some(ref notes) = info.notes {
+            // Most packages have nothing to say, and an empty list would
+            // otherwise print a heading with no content under it.
+            if let Some(notes) = info.notes.as_ref().filter(|n| !n.is_empty()) {
                 info!(
                     "  {} Notes:\n    {}",
                     icon_or("📝", "-"),
@@ -436,8 +453,8 @@ fn display_install_report(report: &InstallReport, no_notes: bool) {
 
     for err_info in &report.failed {
         error!(
-            "Failed to install {}#{}: {}",
-            err_info.pkg_name, err_info.pkg_id, err_info.error
+            "Failed to install {}: {}",
+            err_info.pkg_name, err_info.error
         );
     }