feat(pkg-mgr): implement pkg-show command

Add `pkg-show` to display installed packages and their versions,
removing its NOT_IMPL marker from help. Include internal commands
to load enabled package paths and completion scripts.

3 files changed, 219 insertions, 0 deletions

diff --git a/mingling_cli/src/pkg_mgr.rs b/mingling_cli/src/pkg_mgr.rs
index 2f947df..f244fa7 100644
--- a/mingling_cli/src/pkg_mgr.rs
+++ b/mingling_cli/src/pkg_mgr.rs
@@ -1,6 +1,8 @@
 pub mod cmd_install;
+pub mod cmd_internal_loadpkgs;
 pub mod cmd_pkg_disable;
 pub mod cmd_pkg_enable;
+pub mod cmd_pkg_show;
 pub mod cmd_uninstall;
 
 use std::path::PathBuf;
diff --git a/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs b/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs
new file mode 100644
index 0000000..b4928ce
--- /dev/null
+++ b/mingling_cli/src/pkg_mgr/cmd_internal_loadpkgs.rs
@@ -0,0 +1,104 @@
+use std::{
+    fs, io,
+    path::{Path, PathBuf},
+};
+
+use mingling::{
+    Routable,
+    macros::{buffer, command, pack, r_println, renderer, routeify},
+};
+
+use crate::{
+    Next,
+    pkg_mgr::{ErrorNoDataDirectory, ResPackagesDir},
+};
+
+// Version directory paths of every enabled package.
+pack!(ResultLoadPkgsPaths = Vec<PathBuf>);
+
+// Completion script paths of every enabled package.
+pack!(ResultLoadPkgsComps = Vec<PathBuf>);
+
+#[command(node = "__loadpkgs_path", routeify)]
+pub fn load_packages_paths(packages_dir: &ResPackagesDir) -> Next {
+    let packages_dir = &packages_dir.path;
+    if packages_dir.as_os_str().is_empty() {
+        return ErrorNoDataDirectory::default().to_chain();
+    }
+    let paths = enabled_version_dirs(packages_dir).map_err(|e| {
+        io::Error::new(
+            e.kind(),
+            format!("failed to read {}: {e}", packages_dir.display()),
+        )
+    })?;
+    ResultLoadPkgsPaths::new(paths).to_chain()
+}
+
+#[command(node = "__loadpkgs_comp_scripts", routeify)]
+pub fn load_packages_comp_scripts(packages_dir: &ResPackagesDir) -> Next {
+    let packages_dir = &packages_dir.path;
+    if packages_dir.as_os_str().is_empty() {
+        return ErrorNoDataDirectory::default().to_chain();
+    }
+    let scripts = comp_scripts(packages_dir).map_err(|e| {
+        io::Error::new(
+            e.kind(),
+            format!("failed to read {}: {e}", packages_dir.display()),
+        )
+    })?;
+    ResultLoadPkgsComps::new(scripts).to_chain()
+}
+
+#[renderer(buffer)]
+pub fn render_result_load_pkgs_paths(r: ResultLoadPkgsPaths) {
+    for path in r.inner {
+        r_println!("{}", path.display());
+    }
+}
+
+#[renderer(buffer)]
+pub fn render_result_load_pkgs_comps(r: ResultLoadPkgsComps) {
+    for path in r.inner {
+        r_println!("{}", path.display());
+    }
+}
+
+/// Version directories of every enabled package.
+///
+/// An enable file is a `name` file (no `@`) whose content is the enabled version.
+fn enabled_version_dirs(packages_dir: &Path) -> Result<Vec<PathBuf>, io::Error> {
+    let mut dirs = Vec::new();
+    for entry in fs::read_dir(packages_dir)? {
+        let entry = entry?;
+        if !entry.file_type().is_ok_and(|t| t.is_file()) {
+            continue;
+        }
+        let name = entry.file_name().to_string_lossy().into_owned();
+        if name.contains('@') {
+            continue;
+        }
+        let version = fs::read_to_string(entry.path())?;
+        dirs.push(packages_dir.join(format!("{name}@{}", version.trim())));
+    }
+    dirs.sort();
+    Ok(dirs)
+}
+
+/// Completion scripts inside every enabled version directory.
+fn comp_scripts(packages_dir: &Path) -> Result<Vec<PathBuf>, io::Error> {
+    let mut scripts = Vec::new();
+    for dir in enabled_version_dirs(packages_dir)? {
+        if !dir.is_dir() {
+            continue;
+        }
+        for entry in fs::read_dir(&dir)? {
+            let entry = entry?;
+            let name = entry.file_name().to_string_lossy().into_owned();
+            if name.contains("_comp") {
+                scripts.push(entry.path());
+            }
+        }
+    }
+    scripts.sort();
+    Ok(scripts)
+}
diff --git a/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs b/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs
new file mode 100644
index 0000000..68aef2b
--- /dev/null
+++ b/mingling_cli/src/pkg_mgr/cmd_pkg_show.rs
@@ -0,0 +1,113 @@
+use std::{collections::BTreeMap, fs, io};
+
+use colored::Colorize;
+use mingling::{
+    Grouped, Routable,
+    macros::{buffer, command, metadata, r_println, renderer, routeify},
+    metadata::Description,
+};
+
+use crate::{
+    Next,
+    pkg_mgr::{ErrorNoDataDirectory, ResPackagesDir},
+};
+
+#[derive(Debug, Default, Clone)]
+pub struct PkgShowEntry {
+    pub name: String,
+    /// Enabled version, from the content of the enable file.
+    pub enabled: Option<String>,
+    /// Installed versions, newest first.
+    pub versions: Vec<String>,
+}
+
+#[derive(Debug, Default, Grouped)]
+pub struct ResultPkgShow {
+    pub packages: Vec<PkgShowEntry>,
+}
+
+#[metadata(EntryPkgShow)]
+pub fn desc_pkg_show() -> Description {
+    "Show locally installed packages".into()
+}
+
+#[command(node = "pkg-show", routeify)]
+pub fn package_show(packages_dir: &ResPackagesDir) -> Next {
+    let packages_dir = &packages_dir.path;
+    if packages_dir.as_os_str().is_empty() {
+        return ErrorNoDataDirectory::default().to_chain();
+    }
+
+    let mut entries: BTreeMap<String, PkgShowEntry> = BTreeMap::new();
+    for entry in fs::read_dir(packages_dir).map_err(|e| {
+        io::Error::new(
+            e.kind(),
+            format!("failed to read {}: {e}", packages_dir.display()),
+        )
+    })? {
+        let entry = entry.map_err(|e| {
+            io::Error::new(e.kind(), format!("failed to read directory entry: {e}"))
+        })?;
+        let file_type = entry.file_type().map_err(|e| {
+            io::Error::new(e.kind(), format!("failed to inspect directory entry: {e}"))
+        })?;
+        let name = entry.file_name().to_string_lossy().into_owned();
+
+        if file_type.is_dir() {
+            // Installed version directory: `name@version`
+            if let Some((pkg, version)) = name.split_once('@') {
+                let pkg = pkg.to_string();
+                let entry = entries.entry(pkg.clone()).or_default();
+                entry.name = pkg;
+                entry.versions.push(version.to_string());
+            }
+        } else if file_type.is_file() {
+            // Enable file: `name`, content is the enabled version
+            let content = fs::read_to_string(entry.path()).map_err(|e| {
+                io::Error::new(
+                    e.kind(),
+                    format!("failed to read {}: {e}", entry.path().display()),
+                )
+            })?;
+            let entry = entries.entry(name.clone()).or_default();
+            entry.name = name;
+            entry.enabled = Some(content.trim().to_string());
+        }
+    }
+
+    for pkg in entries.values_mut() {
+        pkg.versions.sort_by(|a, b| compare_versions(b, a));
+    }
+
+    ResultPkgShow {
+        packages: entries.into_values().collect(),
+    }
+    .to_chain()
+}
+
+#[renderer(buffer)]
+pub fn render_result_pkg_show(r: ResultPkgShow) {
+    if r.packages.is_empty() {
+        r_println!("No packages installed");
+    }
+    for pkg in r.packages {
+        if let Some(enabled) = &pkg.enabled {
+            r_println!("{}", format!("{} ({})", pkg.name, enabled).bright_cyan());
+        } else {
+            r_println!("{}", pkg.name);
+        }
+        for version in pkg.versions {
+            r_println!("  {version}");
+        }
+    }
+}
+
+/// Newest first; unparsable versions sort last, compared lexicographically.
+fn compare_versions(a: &str, b: &str) -> std::cmp::Ordering {
+    match (semver::Version::parse(a), semver::Version::parse(b)) {
+        (Ok(x), Ok(y)) => x.cmp(&y),
+        (Ok(_), Err(_)) => std::cmp::Ordering::Greater,
+        (Err(_), Ok(_)) => std::cmp::Ordering::Less,
+        (Err(_), Err(_)) => a.cmp(b),
+    }
+}