diff --git a/src/main.rs b/src/main.rs
index c830b21..53738a8 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -64,6 +64,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let cli = Cli::parse();
     let managers = detect_available_managers();
     
+    if managers.is_empty() {
+        eprintln!("Warning: No package managers detected");
+    }
+    
     match cli.command {
         Commands::Tree { depth, package, source } => {
             handle_tree_command(&managers, depth, package, source)?;
@@ -80,7 +84,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         Commands::Find { name, package, size } => {
             handle_find_command(&managers, name, package, size)?;
         }
-        Commands::Scan { force, paths   , format, detailed, sizes, include_expected } => {
+        Commands::Scan { force, paths, format, detailed, sizes, include_expected } => {
             handle_scan_command(&managers, paths, format, force, detailed, sizes, include_expected)?;
         }
     }
@@ -92,23 +96,54 @@ fn handle_tree_command(
     managers: &[Box<dyn PackageManager>], 
     _depth: Option<usize>, 
     package_filter: Option<String>,
-    _source_filter: Option<String>
+    source_filter: Option<String>
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if let Some(dnf) = managers.iter().find(|m| m.name() == "dnf") {
-        if let Some(package_name) = package_filter {
-            // Show tree for specific package
-            cli::tree::print_package_tree(dnf.as_ref(), &package_name)?;
-        } else {
-            // Show tree for first few packages as demo
-            println!("Package file trees (first 5 packages):");
-            let packages = dnf.get_installed_packages()?;
-            for package in packages.iter().take(5) {
-                cli::tree::print_package_tree(dnf.as_ref(), &package.name)?;
-                println!(); // Empty line between packages
+    let target_managers: Vec<&Box<dyn PackageManager>> = if let Some(source_name) = source_filter {
+        // Filter to specific manager
+        managers.iter().filter(|m| m.name().to_lowercase() == source_name.to_lowercase()).collect()
+    } else {
+        // Use all managers
+        managers.iter().collect()
+    };
+
+    if target_managers.is_empty() {
+        println!("No suitable package managers found");
+        return Ok(());
+    }
+
+    if let Some(package_name) = package_filter {
+        // Show tree for specific package across all managers
+        let mut found = false;
+        for manager in &target_managers {
+            match manager.get_package_info(&package_name) {
+                Ok(Some(_)) => {
+                    println!("Package '{}' from {}:", package_name, manager.name());
+                    cli::tree::print_package_tree(manager.as_ref(), &package_name)?;
+                    found = true;
+                    println!();
+                }
+                Ok(None) => continue,
+                Err(e) => eprintln!("Error checking {} in {}: {}", package_name, manager.name(), e),
             }
         }
+        if !found {
+            println!("Package '{}' not found in any package manager", package_name);
+        }
     } else {
-        println!("No DNF package manager found");
+        // Show tree for first few packages from each manager as demo
+        for manager in &target_managers {
+            match manager.get_installed_packages() {
+                Ok(packages) => {
+                    println!("{} package file trees (first 3 packages):", manager.name());
+                    for package in packages.iter().take(3) {
+                        println!("  Package: {}", package.name);
+                        cli::tree::print_package_tree(manager.as_ref(), &package.name)?;
+                        println!();
+                    }
+                }
+                Err(e) => eprintln!("Error getting packages from {}: {}", manager.name(), e),
+            }
+        }
     }
     Ok(())
 }
@@ -117,10 +152,13 @@ fn handle_package_command(
     managers: &[Box<dyn PackageManager>], 
     name: &str
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if let Some(dnf) = managers.iter().find(|m| m.name() == "dnf") {
-        match dnf.get_package_info(name) {
+    let mut found = false;
+    
+    // Search all managers for the package
+    for manager in managers {
+        match manager.get_package_info(name) {
             Ok(Some(info)) => {
-                println!("Package: {}", info.name);
+                println!("Package: {} (from {})", info.name, manager.name());
                 println!("Version: {}", info.version);
                 println!("Source: {}", info.source.name());
                 println!("Install time: {}", info.install_time);
@@ -128,18 +166,25 @@ fn handle_package_command(
                 
                 // Show file tree for this package
                 println!("\nFiles:");
-                cli::tree::print_package_tree(dnf.as_ref(), name)?;
+                cli::tree::print_package_tree(manager.as_ref(), name)?;
+                found = true;
+                println!();
             }
-            Ok(None) => println!("Package '{}' not found", name),
-            Err(e) => println!("Error: {}", e),
+            Ok(None) => continue,
+            Err(e) => eprintln!("Error checking {} in {}: {}", name, manager.name(), e),
         }
     }
+    
+    if !found {
+        println!("Package '{}' not found in any package manager", name);
+    }
+    
     Ok(())
 }
 
 fn handle_packages_command(
     managers: &[Box<dyn PackageManager>], 
-    source_filter: Option<String>  // Removed the underscore!
+    source_filter: Option<String>
 ) -> Result<(), Box<dyn std::error::Error>> {
     if let Some(source_name) = source_filter {
         // Filter by specific source
@@ -187,13 +232,32 @@ fn handle_file_command(
     managers: &[Box<dyn PackageManager>], 
     path: &str
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if let Some(dnf) = managers.iter().find(|m| m.name() == "dnf") {
-        match dnf.get_file_owner(std::path::Path::new(path)) {
-            Ok(Some(owner)) => println!("{} is owned by package: {}", path, owner),
-            Ok(None) => println!("{} is not owned by any package", path),
-            Err(e) => println!("Error checking {}: {}", path, e),
+    let path_obj = std::path::Path::new(path);
+    let mut owners = Vec::new();
+    
+    // Check all managers for file ownership
+    for manager in managers {
+        match manager.get_file_owner(path_obj) {
+            Ok(Some(owner)) => {
+                owners.push((manager.name(), owner));
+            }
+            Ok(None) => continue,
+            Err(e) => eprintln!("Warning: Error checking {} in {}: {}", path, manager.name(), e),
         }
     }
+    
+    if owners.is_empty() {
+        println!("{} is not owned by any package", path);
+    } else if owners.len() == 1 {
+        let (manager, owner) = &owners[0];
+        println!("{} is owned by package: {} ({})", path, owner, manager);
+    } else {
+        println!("{} is owned by multiple packages:", path);
+        for (manager, owner) in owners {
+            println!("  {} ({} package manager)", owner, manager);
+        }
+    }
+    
     Ok(())
 }
 
@@ -204,17 +268,28 @@ fn handle_find_command(
     _size: Option<String>
 ) -> Result<(), Box<dyn std::error::Error>> {
     if let Some(package_name) = package {
-        if let Some(dnf) = managers.iter().find(|m| m.name() == "dnf") {
-            match dnf.get_package_files(&package_name) {
+        let mut found = false;
+        
+        // Search all managers for the package
+        for manager in managers {
+            match manager.get_package_files(&package_name) {
                 Ok(files) => {
-                    println!("Files in package '{}':", package_name);
-                    for file in files {
-                        println!("  {}", file.display());
+                    if !files.is_empty() {
+                        println!("Files in package '{}' from {}:", package_name, manager.name());
+                        for file in files {
+                            println!("  {}", file.display());
+                        }
+                        found = true;
+                        println!();
                     }
                 }
-                Err(e) => println!("Error: {}", e),
+                Err(e) => eprintln!("Error checking {} in {}: {}", package_name, manager.name(), e),
             }
         }
+        
+        if !found {
+            println!("Package '{}' not found in any package manager", package_name);
+        }
     } else {
         println!("Find command needs more specific criteria");
     }