imp(core): add list-files, list-owners, list-tags initial implementation

Author: omarabid

cli/src/lib.rs

@@ -136,6 +136,10 @@ enum CodeownersSubcommand {
         about = "Display aggregated owner statistics and associations"
     )]
     ListOwners {
+        /// Directory path to analyze (default: current directory)
+        #[arg(default_value = ".")]
+        path: Option<PathBuf>,
+
         /// Output format: text|json|bincode
         #[arg(long, value_name = "FORMAT", default_value = "text", value_parser = parse_output_format)]
         format: OutputFormat,
@@ -145,6 +149,10 @@ enum CodeownersSubcommand {
         about = "Audit and analyze tag usage across CODEOWNERS files"
     )]
     ListTags {
+        /// Directory path to analyze (default: current directory)
+        #[arg(default_value = ".")]
+        path: Option<PathBuf>,
+
         /// Output format: text|json|bincode
         #[arg(long, value_name = "FORMAT", default_value = "text", value_parser = parse_output_format)]
         format: OutputFormat,
@@ -207,8 +215,12 @@ pub(crate) fn codeowners(subcommand: &CodeownersSubcommand) -> Result<()> {
             *unowned,
             format,
         ),
-        CodeownersSubcommand::ListOwners { format } => commands::codeowners_list_owners(format),
-        CodeownersSubcommand::ListTags { format } => commands::codeowners_list_tags(format),
+        CodeownersSubcommand::ListOwners { path, format } => {
+            commands::codeowners_list_owners(path.as_deref(), format)
+        }
+        CodeownersSubcommand::ListTags { path, format } => {
+            commands::codeowners_list_tags(path.as_deref(), format)
+        }
     }
 }
 

core/src/commands.rs

@@ -46,6 +46,7 @@ pub fn codeowners_parse(
     dbg!(cache);
 
     println!("CODEOWNERS parsing completed successfully");
+
     Ok(())
 }
 
@@ -61,22 +62,273 @@ pub fn codeowners_list_files(
     info!("Unowned only: {}", unowned);
     info!("Output format: {}", format);
 
-    println!("Files listing completed");
+    // Determine the cache file path based on repository path
+    let repo_path = path.unwrap_or_else(|| std::path::Path::new("."));
+    //let config = utils::app_config::AppConfig::fetch()?;
+    // let cache_dir = config
+    //     .cache_dir
+    //     .unwrap_or_else(|| repo_path.join(".codeowners.cache"));
+    let cache_file = repo_path.join(".codeowners.cache");
+
+    if !cache_file.exists() {
+        return Err(utils::error::Error::new(&format!(
+            "Cache file not found at {}. Please run 'codeowners parse' first.",
+            cache_file.display()
+        )));
+    }
+
+    // Load the cache
+    let cache = load_cache(&cache_file)?;
+
+    // Filter files based on criteria
+    let filtered_files = cache
+        .files
+        .iter()
+        .filter(|file| {
+            // Check if we should include this file based on filters
+            let passes_owner_filter = match owners {
+                Some(owner_filter) => {
+                    let owner_patterns: Vec<&str> = owner_filter.split(',').collect();
+                    file.owners.iter().any(|owner| {
+                        owner_patterns
+                            .iter()
+                            .any(|pattern| owner.identifier.contains(pattern))
+                    })
+                }
+                None => true,
+            };
+
+            let passes_tag_filter = match tags {
+                Some(tag_filter) => {
+                    let tag_patterns: Vec<&str> = tag_filter.split(',').collect();
+                    file.tags
+                        .iter()
+                        .any(|tag| tag_patterns.iter().any(|pattern| tag.0.contains(pattern)))
+                }
+                None => true,
+            };
+
+            let passes_unowned_filter = if unowned {
+                file.owners.is_empty()
+            } else {
+                true
+            };
+
+            passes_owner_filter && passes_tag_filter && passes_unowned_filter
+        })
+        .collect::<Vec<_>>();
+
+    // Output the filtered files in the requested format
+    match format {
+        OutputFormat::Text => {
+            for file in filtered_files {
+                let owners_str = file
+                    .owners
+                    .iter()
+                    .map(|o| o.identifier.clone())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+
+                let tags_str = file
+                    .tags
+                    .iter()
+                    .map(|t| t.0.clone())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+
+                println!("File: {}", file.path.display());
+                println!(
+                    "  Owners: {}",
+                    if owners_str.is_empty() {
+                        "None"
+                    } else {
+                        &owners_str
+                    }
+                );
+                println!(
+                    "  Tags: {}",
+                    if tags_str.is_empty() {
+                        "None"
+                    } else {
+                        &tags_str
+                    }
+                );
+                println!();
+            }
+        }
+        OutputFormat::Json => {
+            println!("{}", serde_json::to_string_pretty(&filtered_files).unwrap());
+        }
+        OutputFormat::Bincode => {
+            eprintln!("Binary output to stdout not supported for file listing");
+            return Err(utils::error::Error::new(
+                "Binary output to stdout not supported",
+            ));
+        }
+    }
+
     Ok(())
 }
 
 /// Display aggregated owner statistics and associations
-pub fn codeowners_list_owners(format: &OutputFormat) -> Result<()> {
+pub fn codeowners_list_owners(path: Option<&std::path::Path>, format: &OutputFormat) -> Result<()> {
+    info!("Listing owners");
     info!("Output format: {}", format);
 
-    println!("Owners listing completed");
+    // Determine the cache file path based on repository path
+    let repo_path = path.unwrap_or_else(|| std::path::Path::new("."));
+    let cache_file = repo_path.join(".codeowners.cache");
+
+    if !cache_file.exists() {
+        return Err(utils::error::Error::new(&format!(
+            "Cache file not found at {}. Please run 'codeowners parse' first.",
+            cache_file.display()
+        )));
+    }
+
+    // Load the cache
+    let cache = load_cache(&cache_file)?;
+
+    // Process the owners from the cache
+    match format {
+        OutputFormat::Text => {
+            println!("CODEOWNERS Ownership Report");
+            println!("==========================\n");
+
+            if cache.owners_map.is_empty() {
+                println!("No owners found in the codebase.");
+            } else {
+                // Sort owners by number of files they own (descending)
+                let mut owners_with_counts: Vec<_> = cache.owners_map.iter().collect();
+                owners_with_counts.sort_by(|a, b| b.1.len().cmp(&a.1.len()));
+
+                for (owner, paths) in owners_with_counts {
+                    println!("Owner: {} ({})", owner.identifier, owner.owner_type);
+                    println!("Files owned: {}", paths.len());
+
+                    // List first 5 files (to avoid overwhelming output)
+                    if !paths.is_empty() {
+                        println!("Sample files:");
+                        for path in paths.iter().take(5) {
+                            println!("  - {}", path.display());
+                        }
+
+                        if paths.len() > 5 {
+                            println!("  ... and {} more", paths.len() - 5);
+                        }
+                    }
+
+                    println!(); // Empty line between owners
+                }
+            }
+        }
+        OutputFormat::Json => {
+            // Convert to a more friendly JSON structure
+            let owners_data: Vec<_> = cache.owners_map.iter()
+                .map(|(owner, paths)| {
+                    serde_json::json!({
+                        "identifier": owner.identifier,
+                        "type": format!("{:?}", owner.owner_type),
+                        "file_count": paths.len(),
+                        "files": paths.iter().map(|p| p.to_string_lossy().to_string()).collect::<Vec<_>>()
+                    })
+                })
+                .collect();
+
+            println!("{}", serde_json::to_string_pretty(&owners_data).unwrap());
+        }
+        OutputFormat::Bincode => {
+            eprintln!("Binary output to stdout not supported for owners listing");
+            return Err(utils::error::Error::new(
+                "Binary output to stdout not supported",
+            ));
+        }
+    }
+
+    println!(
+        "Owners listing completed - {} owners found",
+        cache.owners_map.len()
+    );
     Ok(())
 }
 
 /// Audit and analyze tag usage across CODEOWNERS files
-pub fn codeowners_list_tags(format: &OutputFormat) -> Result<()> {
+pub fn codeowners_list_tags(path: Option<&std::path::Path>, format: &OutputFormat) -> Result<()> {
+    info!("Listing tags");
     info!("Output format: {}", format);
 
-    println!("Tags listing completed");
+    // Determine the cache file path based on repository path
+    let repo_path = path.unwrap_or_else(|| std::path::Path::new("."));
+    let cache_file = repo_path.join(".codeowners.cache");
+
+    if !cache_file.exists() {
+        return Err(utils::error::Error::new(&format!(
+            "Cache file not found at {}. Please run 'codeowners parse' first.",
+            cache_file.display()
+        )));
+    }
+
+    // Load the cache
+    let cache = load_cache(&cache_file)?;
+
+    // Process the tags from the cache
+    match format {
+        OutputFormat::Text => {
+            println!("CODEOWNERS Tags Report");
+            println!("======================\n");
+
+            if cache.tags_map.is_empty() {
+                println!("No tags found in the codebase.");
+            } else {
+                // Sort tags by number of files they're associated with (descending)
+                let mut tags_with_counts: Vec<_> = cache.tags_map.iter().collect();
+                tags_with_counts.sort_by(|a, b| b.1.len().cmp(&a.1.len()));
+
+                for (tag, paths) in tags_with_counts {
+                    println!("Tag: {}", tag.0);
+                    println!("Files tagged: {}", paths.len());
+
+                    // List first 5 files (to avoid overwhelming output)
+                    if !paths.is_empty() {
+                        println!("Sample files:");
+                        for path in paths.iter().take(5) {
+                            println!("  - {}", path.display());
+                        }
+
+                        if paths.len() > 5 {
+                            println!("  ... and {} more", paths.len() - 5);
+                        }
+                    }
+
+                    println!(); // Empty line between tags
+                }
+            }
+        }
+        OutputFormat::Json => {
+            // Convert to a more friendly JSON structure
+            let tags_data: Vec<_> = cache.tags_map.iter()
+                .map(|(tag, paths)| {
+                    serde_json::json!({
+                        "name": tag.0,
+                        "file_count": paths.len(),
+                        "files": paths.iter().map(|p| p.to_string_lossy().to_string()).collect::<Vec<_>>()
+                    })
+                })
+                .collect();
+
+            println!("{}", serde_json::to_string_pretty(&tags_data).unwrap());
+        }
+        OutputFormat::Bincode => {
+            eprintln!("Binary output to stdout not supported for tags listing");
+            return Err(utils::error::Error::new(
+                "Binary output to stdout not supported",
+            ));
+        }
+    }
+
+    println!(
+        "Tags listing completed - {} tags found",
+        cache.tags_map.len()
+    );
     Ok(())
 }

core/src/types.rs

@@ -29,6 +29,18 @@ pub enum OwnerType {
     Unknown,
 }
 
+impl std::fmt::Display for OwnerType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            OwnerType::User => write!(f, "User"),
+            OwnerType::Team => write!(f, "Team"),
+            OwnerType::Email => write!(f, "Email"),
+            OwnerType::Unowned => write!(f, "Unowned"),
+            OwnerType::Unknown => write!(f, "Unknown"),
+        }
+    }
+}
+
 /// Tag representation
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Hash)]
 pub struct Tag(pub String);