pkgforge · QaidVoid · Aug 1, 2026 · Jul 28, 2026 · Jul 28, 2026 · Jul 28, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/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",

diff --git a/crates/soar-cli/src/apply.rs b/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)),
                 ]);

diff --git a/crates/soar-cli/src/download.rs b/crates/soar-cli/src/download.rs
@@ -153,6 +153,7 @@ pub async fn handle_direct_downloads(
                             MetadataRepository::find_filtered(
                                 conn,
                                 query.name.as_deref(),
+                                None,
                                 query.pkg_id.as_deref(),
                                 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());
 

diff --git a/crates/soar-cli/src/health.rs b/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::{
@@ -61,10 +61,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 +93,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 +108,7 @@ pub async fn remove_broken_packages(ctx: &SoarContext) -> SoarResult<()> {
             report
                 .failed
                 .iter()
-                .map(|f| format!("{}#{}", f.pkg_name, f.pkg_id))
+                .map(|f| format!("{}", f.pkg_name))
                 .collect::<Vec<_>>()
                 .join(", ")
         );

diff --git a/crates/soar-cli/src/inspect.rs b/crates/soar-cli/src/inspect.rs
@@ -44,7 +44,7 @@ fn get_installed_path(
             conn,
             &package.repo_name,
             &package.pkg_name,
-            &package.pkg_id,
+            package.pkg_id.as_deref(),
             &package.version,
         )
     })?;
@@ -71,6 +71,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 +91,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),

diff --git a/crates/soar-cli/src/install.rs b/crates/soar-cli/src/install.rs
@@ -76,8 +76,7 @@ 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 specific_query = format!("{}:{}", pkg.pkg_name, pkg.repo_name);
                     let re_results =
                         install::resolve_packages(ctx, &[specific_query], &options).await?;
                     for r in re_results {
@@ -97,13 +96,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 +160,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,8 +199,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 specific_query = format!("{}:{}", pkg.pkg_name, pkg.repo_name);
                             let re_results =
                                 install::resolve_packages(ctx, &[specific_query], options).await?;
                             for r in re_results {
@@ -221,13 +219,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!(
@@ -249,6 +247,7 @@ async fn install_with_show(
                         None,
                         None,
                         None,
+                        None,
                         Some(SortDirection::Asc),
                     )
                 })?
@@ -268,6 +267,7 @@ async fn install_with_show(
                     None,
                     None,
                     None,
+                    None,
                     Some(SortDirection::Asc),
                 )?;
                 Ok(pkgs
@@ -317,7 +317,7 @@ async fn install_with_show(
                 )
             })?
             .into_iter()
-            .map(|p| (p.pkg_id, p.repo_name, p.version))
+            .map(|p| (p.pkg_id.unwrap_or_default(), p.repo_name, p.version))
             .collect();
 
         let pkg = select_package_interactively_with_installed(
@@ -337,7 +337,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,
@@ -352,9 +352,8 @@ async fn install_with_show(
         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,10 +401,9 @@ 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())
         );
@@ -424,7 +422,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 +436,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
         );
     }
 

diff --git a/crates/soar-cli/src/json2db.rs b/crates/soar-cli/src/json2db.rs
@@ -8,7 +8,7 @@ use soar_db::{
     connection::DbConnection, migration::DbType, repository::metadata::MetadataRepository,
 };
 use soar_registry::RemotePackage;
-use tracing::info;
+use tracing::{info, warn};
 
 /// Converts JSON metadata file to SQLite database.
 pub fn json_to_db(input_path: &str, output_path: &str, repo_name: Option<&str>) -> SoarResult<()> {
@@ -23,7 +23,7 @@ pub fn json_to_db(input_path: &str, output_path: &str, repo_name: Option<&str>)
     let json_content = fs::read_to_string(input_path)
         .with_context(|| format!("reading JSON metadata from {}", input_path))?;
 
-    let packages: Vec<RemotePackage> = serde_json::from_str(&json_content)
+    let packages: Vec<RemotePackage> = soar_registry::parse_index(json_content.as_bytes())
         .map_err(|e| SoarError::Custom(format!("parsing JSON from {}: {}", input_path, e)))?;
 
     info!(count = packages.len(), "Parsed JSON metadata");
@@ -49,11 +49,26 @@ pub fn json_to_db(input_path: &str, output_path: &str, repo_name: Option<&str>)
     let mut conn = DbConnection::open(output_path, DbType::Metadata)
         .map_err(|e| SoarError::Custom(format!("opening database: {}", e)))?;
 
-    MetadataRepository::import_packages(conn.conn(), &packages, repo_name)
+    // Packages with an unsafe pkg_name/pkg_id are skipped during import.
+    // Reporting success while writing nothing hides that entirely, which is
+    // how an empty pkg_id silently produced an empty database.
+    let imported = MetadataRepository::import_packages(conn.conn(), &packages, repo_name)
         .map_err(|e| SoarError::Custom(format!("importing packages: {}", e)))?;
 
+    let skipped = packages.len() - imported;
+    if imported == 0 {
+        return Err(SoarError::Custom(format!(
+            "imported 0 of {} packages; every entry was rejected, most likely \
+             an unsafe or empty pkg_name/pkg_id",
+            packages.len()
+        )));
+    }
+    if skipped > 0 {
+        warn!(skipped, "some packages were rejected during import");
+    }
+
     info!(
-        count = packages.len(),
+        count = imported,
         output = %output_path.display(),
         "Successfully converted JSON to SQLite database"
     );