perf: optimize cache building and fix path normalization

## Performance Improvements

### Optimize owner/tag collection (cache.rs)
- Changed from O(owners × files) to O(files) complexity
- Build owners_map and tags_map in single pass through file_entries
- Removed unused collect_owners and collect_tags functions from common.rs

### Fix lifetime warnings (smart_iter.rs)
- Added explicit lifetime `'_` to trait and impl return types
- Fixes compiler warnings about elided lifetimes

## Bug Fixes

### Fix path normalization in inspect command
- Handle ./ prefix variations when looking up files in cache
- Normalize both cached paths and input paths for comparison
- Updated test to properly assert success with ownership verification

## Code Cleanup
- Removed unused functions: collect_owners, collect_tags
- Removed unused imports: Owner, Tag from common.rs

Author: claude

ci/tests/test_cli.rs

@@ -293,16 +293,16 @@ fn test_codeowners_inspect_command() {
         .assert()
         .success();
 
-    // Inspect command should at least accept the arguments
-    // Note: The inspect command has path normalization issues that need to be fixed
-    // For now, verify the command runs (even if it reports file not found)
+    // Inspect a specific file - verify ownership info is returned
     ci().arg("codeowners")
         .arg("inspect")
-        .arg("./src/main.rs")
+        .arg("src/main.rs")
         .arg("--repo")
         .arg(".")
         .current_dir(temp_dir.path())
-        .assert(); // Don't assert success - path normalization needs fixing
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("@rust-team"));
 }
 
 #[test]

codeinput/src/core/cache.rs

@@ -1,6 +1,6 @@
 use crate::{
     core::{
-        common::{collect_owners, collect_tags, get_repo_hash},
+        common::get_repo_hash,
         parse::parse_repo,
         resolver::find_owners_and_tags_for_file,
         types::{
@@ -93,27 +93,21 @@ pub fn build_cache(
     // Print newline after processing is complete
     println!("\r\x1b[K✅ Processed {} files successfully", total_files);
 
-    // Process each owner
-    let owners = collect_owners(&entries);
-    owners.iter().for_each(|owner| {
-        let paths = owners_map.entry(owner.clone()).or_insert_with(Vec::new);
-        for file_entry in &file_entries {
-            if file_entry.owners.contains(owner) {
-                paths.push(file_entry.path.clone());
-            }
+    // Build owner and tag maps in a single pass through file_entries - O(files) instead of O(owners × files)
+    for file_entry in &file_entries {
+        for owner in &file_entry.owners {
+            owners_map
+                .entry(owner.clone())
+                .or_insert_with(Vec::new)
+                .push(file_entry.path.clone());
         }
-    });
-
-    // Process each tag
-    let tags = collect_tags(&entries);
-    tags.iter().for_each(|tag| {
-        let paths = tags_map.entry(tag.clone()).or_insert_with(Vec::new);
-        for file_entry in &file_entries {
-            if file_entry.tags.contains(tag) {
-                paths.push(file_entry.path.clone());
-            }
+        for tag in &file_entry.tags {
+            tags_map
+                .entry(tag.clone())
+                .or_insert_with(Vec::new)
+                .push(file_entry.path.clone());
         }
-    });
+    }
 
     Ok(CodeownersCache {
         hash,

codeinput/src/core/commands/inspect.rs

@@ -34,11 +34,19 @@ pub fn run(
         file_path.to_path_buf()
     };
 
-    // Find the file in the cache
+    // Create normalized path for matching (handle ./ prefix variations)
+    let path_str = normalized_file_path.to_string_lossy();
+    let path_without_dot = path_str.strip_prefix("./").unwrap_or(&path_str);
+
+    // Find the file in the cache (try both with and without ./ prefix)
     let file_entry = cache
         .files
         .iter()
-        .find(|file| file.path == normalized_file_path)
+        .find(|file| {
+            let cache_path = file.path.to_string_lossy();
+            let cache_path_normalized = cache_path.strip_prefix("./").unwrap_or(&cache_path);
+            cache_path_normalized == path_without_dot
+        })
         .ok_or_else(|| {
             Error::new(&format!(
                 "File {} not found in cache",

codeinput/src/core/common.rs

@@ -4,7 +4,7 @@ use ignore::Walk;
 use sha2::{Digest, Sha256};
 use std::path::{Path, PathBuf};
 
-use super::types::{CodeownersEntry, Owner, Tag};
+use super::types::CodeownersEntry;
 
 /// Maximum recursion depth for finding CODEOWNERS files (prevents stack overflow on deep structures)
 const MAX_RECURSION_DEPTH: usize = 100;
@@ -57,31 +57,6 @@ pub fn find_files<P: AsRef<Path>>(base_path: P) -> Result<Vec<PathBuf>> {
     Ok(result)
 }
 
-/// Collect all unique owners from CODEOWNERS entries
-pub fn collect_owners(entries: &[CodeownersEntry]) -> Vec<Owner> {
-    let mut owners = std::collections::HashSet::new();
-
-    for entry in entries {
-        for owner in &entry.owners {
-            owners.insert(owner.clone());
-        }
-    }
-
-    owners.into_iter().collect()
-}
-
-/// Collect all unique tags from CODEOWNERS entries
-pub fn collect_tags(entries: &[CodeownersEntry]) -> Vec<Tag> {
-    let mut tags = std::collections::HashSet::new();
-
-    for entry in entries {
-        for tag in &entry.tags {
-            tags.insert(tag.clone());
-        }
-    }
-
-    tags.into_iter().collect()
-}
 
 /// Files to exclude from the repository hash calculation (these are generated files)
 const HASH_EXCLUDED_PATTERNS: &[&str] = &[

codeinput/src/core/smart_iter.rs

@@ -3,11 +3,11 @@
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 
 pub(crate) trait SmartIter<T: Send + Sync> {
-    fn smart_iter(&self, n: usize) -> SmartIterator<T>;
+    fn smart_iter(&self, n: usize) -> SmartIterator<'_, T>;
 }
 
 impl<T: Send + Sync> SmartIter<T> for [T] {
-    fn smart_iter(&self, n: usize) -> SmartIterator<T> {
+    fn smart_iter(&self, n: usize) -> SmartIterator<'_, T> {
         if self.len() <= n {
             SmartIterator::Sequential(self.iter())
         } else {