feat: Implement ls command

Cargo.toml

@@ -12,12 +12,9 @@ license     = "MIT"
 repository  = "https://github.com/anonrig/pacquet"
 
 [workspace.dependencies]
-# Crates
-pacquet_cli          = { path = "crates/cli" }
 pacquet_registry     = { path = "crates/registry" }
 pacquet_tarball      = { path = "crates/tarball" }
 pacquet_package_json = { path = "crates/package_json" }
-pacquet_lockfile     = { path = "crates/lockfile" }
 pacquet_npmrc        = { path = "crates/npmrc" }
 pacquet_executor     = { path = "crates/executor" }
 pacquet_cafs         = { path = "crates/cafs" }

crates/cli/Cargo.toml

@@ -32,6 +32,7 @@ node-semver  = { workspace = true }
 serde        = { workspace = true }
 serde_json   = { workspace = true }
 tokio        = { workspace = true }
+termtree = "0.4.1"
 
 [dev-dependencies]
 insta    = { workspace = true }

crates/cli/src/commands/list.rs

@@ -0,0 +1,114 @@
+use std::path::{PathBuf, MAIN_SEPARATOR};
+
+use clap::Parser;
+use termtree::Tree;
+
+use pacquet_package_json::{DependencyGroup, PackageJson};
+
+use crate::package_manager::{PackageManager, PackageManagerError};
+
+#[derive(Parser, Debug)]
+pub struct ListArgs {
+    /// Perform the command on every package subdirectories
+    /// or on every workspace
+    #[arg(long = "recursive", short = 'r')]
+    pub recursive: bool,
+    /// Log the output as JSON
+    #[arg(long = "json")]
+    pub json: bool,
+    /// Show the extended information
+    #[arg(long = "long")]
+    pub long: bool,
+    /// Outputs the package directories into a parseable format
+    #[arg(long = "parseable")]
+    pub parseable: bool,
+    /// List the package in the global install directory instead of the
+    /// current project
+    #[arg(long = "global", short = 'g')]
+    pub global: bool,
+    /// Max display depth of the dependency tree
+    #[arg(long = "depth")]
+    pub depth: u32,
+    /// Display only dependencies within dependencies or optionalDependencies
+    #[arg(long = "prod", short = 'p')]
+    pub prod: bool,
+    /// Display only dependencies within devDependencies
+    #[arg(long = "dev", short = 'd')]
+    pub dev: bool,
+    /// Omit packages from optionalDependencies
+    #[arg(long = "no-optional")]
+    pub no_opts: bool,
+    /// Display only depndencies that are also projects within the workspace
+    #[arg(long = "only-projects")]
+    pub projects_only: bool,
+    /// Display the dependencies from a given subset of dependencies
+    #[arg(long = "filter", short = 'f')]
+    pub filter: String,
+}
+
+impl ListArgs {
+    pub fn get_scope(&self) -> DependencyGroup {
+        if self.dev {
+            DependencyGroup::Dev
+        } else {
+            DependencyGroup::Default
+        }
+    }
+
+    pub fn get_depth(&self) -> u32 {
+        let mut depth: u32 = 1;
+        self.depth.clone_into(&mut depth);
+
+        depth
+    }
+}
+
+impl PackageManager {
+    pub fn list(
+        &self,
+        package_json: &PackageJson,
+        dependency_group: DependencyGroup,
+        node_modules_path: &PathBuf,
+        depth: u32,
+    ) -> Result<Tree<&str>, PackageManagerError> {
+        match dependency_group {
+            DependencyGroup::Default => {
+                let mut root = Tree::new("");
+                let dependencies = package_json.get_dependencies(vec![DependencyGroup::Default]);
+
+                for (name, version) in dependencies {
+                    // let label = format!("{} - {}", name, version);
+                    // print!("{}", label);
+                    let mut tree = helper::create_tree(name, version);
+
+                    if depth > 1 {
+                        let path = format!("{}{}{}", &name, MAIN_SEPARATOR, "package.json");
+                        let pjson = PackageJson::from_path(&node_modules_path.join(path))?;
+                        let subtree = self.list(
+                            &pjson,
+                            DependencyGroup::Default,
+                            node_modules_path,
+                            depth - 1,
+                        )?;
+
+                        tree.push(subtree);
+                    }
+
+                    root.push(tree.clone());
+                }
+
+                Ok(root)
+            }
+            // DependencyGroup::Dev => Ok(root),
+            _ => Ok(Tree::new("".clone())),
+        }
+    }
+}
+
+mod helper {
+    use termtree::Tree;
+    pub fn create_tree<'a>(name: &'a str, version: &str) -> Tree<&'a str> {
+        let label = format!("{}@{}", name.clone().to_owned(), version.clone().to_owned());
+        Tree::new(label.to_owned().as_str())
+    }
+}

crates/cli/src/commands/mod.rs

@@ -1,12 +1,14 @@
 pub mod add;
 pub mod install;
+pub mod list;
 pub mod run;
 pub mod store;
 
 use std::{env, ffi::OsString, path::PathBuf};
 
 use crate::commands::{
-    add::AddCommandArgs, install::InstallCommandArgs, run::RunCommandArgs, store::StoreSubcommands,
+    add::AddCommandArgs, install::InstallCommandArgs, list::ListArgs, run::RunCommandArgs,
+    store::StoreSubcommands,
 };
 use clap::{Parser, Subcommand};
 
@@ -46,4 +48,6 @@ pub enum Subcommands {
     /// Managing the package store.
     #[clap(subcommand)]
     Store(StoreSubcommands),
+    /// List all dependencies installed based on package.json
+    List(ListArgs),
 }

crates/cli/src/lib.rs

@@ -25,6 +25,7 @@ pub async fn run_cli() -> Result<()> {
 
 async fn run_commands(cli: Cli) -> Result<()> {
     let package_json_path = cli.current_dir.join("package.json");
+    let node_modules_path = cli.current_dir.join("node_modules");
 
     match &cli.subcommand {
         Subcommands::Init => {
@@ -97,6 +98,12 @@ async fn run_commands(cli: Cli) -> Result<()> {
                 }
             }
         }
+        Subcommands::List(args) => {
+            let group = args.get_scope();
+            let depth = args.get_depth();
+            let manager = PackageManager::new(&package_json_path)?;
+            manager.list(&manager.package_json, group, &node_modules_path, depth)?;
+        }
     }
 
     Ok(())