wip(inspect): initial implementation for inspect function

Author: omarabid

src/cli/mod.rs

@@ -169,6 +169,27 @@ enum CodeownersSubcommand {
         #[arg(long, value_name = "FORMAT", default_value = "text", value_parser = parse_output_format)]
         format: OutputFormat,
 
+        /// Custom cache file location
+        #[arg(long, value_name = "FILE", default_value = ".codeowners.cache")]
+        cache_file: Option<PathBuf>,
+    },
+    #[clap(
+        name = "inspect",
+        about = "Inspect ownership and tags for a specific file"
+    )]
+    Inspect {
+        /// File path to inspect
+        #[arg(value_name = "FILE")]
+        file_path: PathBuf,
+
+        /// Directory path to analyze (default: current directory)
+        #[arg(short, long, default_value = ".")]
+        repo: Option<PathBuf>,
+
+        /// Output format: text|json|bincode
+        #[arg(long, value_name = "FORMAT", default_value = "text", value_parser = parse_output_format)]
+        format: OutputFormat,
+
         /// Custom cache file location
         #[arg(long, value_name = "FILE", default_value = ".codeowners.cache")]
         cache_file: Option<PathBuf>,
@@ -245,6 +266,14 @@ pub(crate) fn codeowners(subcommand: &CodeownersSubcommand) -> Result<()> {
             format,
             cache_file,
         } => commands::codeowners_list_tags(path.as_deref(), format, cache_file.as_deref()),
+        CodeownersSubcommand::Inspect {
+            file_path,
+            repo,
+            format,
+            cache_file,
+        } => {
+            commands::codeowners_inspect(file_path, repo.as_deref(), format, cache_file.as_deref())
+        }
     }
 }
 

src/core/commands.rs

@@ -498,3 +498,170 @@ pub fn codeowners_list_tags(
     );
     Ok(())
 }
+
+/// Inspect ownership and tags for a specific file
+pub fn codeowners_inspect(
+    file_path: &std::path::Path, repo: Option<&std::path::Path>, format: &OutputFormat,
+    cache_file: Option<&std::path::Path>,
+) -> Result<()> {
+    // Repository path
+    let repo = repo.unwrap_or_else(|| std::path::Path::new("."));
+
+    // Load the cache
+    let cache = sync_cache(repo, cache_file)?;
+
+    // Normalize the file path to be relative to the repo
+    let normalized_file_path = if file_path.is_absolute() {
+        file_path
+            .strip_prefix(repo)
+            .map_err(|_| {
+                Error::new(&format!(
+                    "File {} is not within repository {}",
+                    file_path.display(),
+                    repo.display()
+                ))
+            })?
+            .to_path_buf()
+    } else {
+        file_path.to_path_buf()
+    };
+
+    // Find the file in the cache
+    let file_entry = cache
+        .files
+        .iter()
+        .find(|file| file.path == normalized_file_path)
+        .ok_or_else(|| {
+            Error::new(&format!(
+                "File {} not found in cache",
+                normalized_file_path.display()
+            ))
+        })?;
+
+    // Find the CODEOWNERS entries that match this file
+    let matching_entries: Vec<&CodeownersEntry> = cache
+        .entries
+        .iter()
+        .filter(|entry| {
+            // Simple pattern matching - in a real implementation you'd want proper glob matching
+            let pattern = &entry.pattern;
+            let file_str = normalized_file_path.to_string_lossy();
+
+            if pattern.ends_with("*") {
+                let prefix = &pattern[..pattern.len() - 1];
+                file_str.starts_with(prefix)
+            } else if pattern.starts_with("*") {
+                let suffix = &pattern[1..];
+                file_str.ends_with(suffix)
+            } else if pattern.contains('*') {
+                // Basic wildcard matching - could be improved
+                let parts: Vec<&str> = pattern.split('*').collect();
+                if parts.len() == 2 {
+                    file_str.starts_with(parts[0]) && file_str.ends_with(parts[1])
+                } else {
+                    file_str == *pattern || file_str.starts_with(&format!("{}/", pattern))
+                }
+            } else {
+                file_str == *pattern || file_str.starts_with(&format!("{}/", pattern))
+            }
+        })
+        .collect();
+
+    // Create inspection result
+    let inspection_result = serde_json::json!({
+        "file_path": normalized_file_path.to_string_lossy(),
+        "owners": file_entry.owners,
+        "tags": file_entry.tags.iter().map(|t| &t.0).collect::<Vec<_>>(),
+        "matching_rules": matching_entries.iter().map(|entry| {
+            serde_json::json!({
+                "source_file": entry.source_file.to_string_lossy(),
+                "line_number": entry.line_number,
+                "pattern": entry.pattern,
+                "owners": entry.owners,
+                "tags": entry.tags.iter().map(|t| &t.0).collect::<Vec<_>>()
+            })
+        }).collect::<Vec<_>>()
+    });
+
+    // Output the inspection result in the requested format
+    match format {
+        OutputFormat::Text => {
+            println!(
+                "==============================================================================="
+            );
+            println!(" File: {}", normalized_file_path.display());
+            println!(
+                "==============================================================================="
+            );
+            println!("\nOwners:");
+            if file_entry.owners.is_empty() {
+                println!("  (no owners)");
+            } else {
+                for owner in &file_entry.owners {
+                    println!("  - {}", owner.identifier);
+                }
+            }
+
+            println!("\nTags:");
+            if file_entry.tags.is_empty() {
+                println!("  (no tags)");
+            } else {
+                for tag in &file_entry.tags {
+                    println!("  - {}", tag.0);
+                }
+            }
+
+            println!("\nMatching CODEOWNERS Rules:");
+            if matching_entries.is_empty() {
+                println!("  (no explicit rules)");
+            } else {
+                for entry in matching_entries {
+                    println!(
+                        "\n  From {}:{}",
+                        entry.source_file.display(),
+                        entry.line_number
+                    );
+                    println!("    Pattern: {}", entry.pattern);
+                    let owners_str = entry
+                        .owners
+                        .iter()
+                        .map(|o| o.identifier.as_str())
+                        .collect::<Vec<_>>()
+                        .join(", ");
+                    println!("    Owners:  {}", owners_str);
+                    if !entry.tags.is_empty() {
+                        println!(
+                            "    Tags:    {}",
+                            entry
+                                .tags
+                                .iter()
+                                .map(|t| t.0.as_str())
+                                .collect::<Vec<_>>()
+                                .join(", ")
+                        );
+                    }
+                }
+            }
+            println!();
+        }
+        OutputFormat::Json => {
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&inspection_result)
+                    .map_err(|e| Error::new(&format!("JSON serialization error: {}", e)))?
+            );
+        }
+        OutputFormat::Bincode => {
+            let encoded =
+                bincode::serde::encode_to_vec(&inspection_result, bincode::config::standard())
+                    .map_err(|e| Error::new(&format!("Serialization error: {}", e)))?;
+
+            // Write raw binary bytes to stdout
+            io::stdout()
+                .write_all(&encoded)
+                .map_err(|e| Error::new(&format!("IO error: {}", e)))?;
+        }
+    }
+
+    Ok(())
+}