Improve file and directory filtering and error handling

Added 'venv' to ignored directories and improved file filtering to skip symbolic links and junction points. Enhanced ProjectScanner to handle inaccessible files and directories gracefully, and implemented manual recursive file enumeration to better respect filter rules and avoid I/O errors.

Author: DavidVeksler

Configuration/FilterConfiguration.cs

@@ -116,6 +116,8 @@ public class FilterConfiguration
     {
         ".sonarqube",
 
+        "venv",
+
         // Version control systems
         ".git", ".svn", ".hg", ".bzr", ".cvs",
 

Services/ConfigLoader.cs

@@ -1,5 +1,6 @@
 using System.Text.Json;
 using CodeContext.Configuration;
+using CodeContext.Interfaces;
 
 namespace CodeContext.Services;
 

Services/FileFilterService.cs

@@ -24,6 +24,12 @@ public bool ShouldSkip(FileSystemInfo info, string rootPath)
         Guard.NotNull(info, nameof(info));
         Guard.NotNullOrEmpty(rootPath, nameof(rootPath));
 
+        // Skip symbolic links and junction points to avoid I/O errors
+        if (info.Attributes.HasFlag(FileAttributes.ReparsePoint))
+        {
+            return true;
+        }
+
         // Check if any parent directory is in the ignored list
         var relativePath = Path.GetRelativePath(rootPath, info.FullName);
         var pathParts = relativePath.Split(Path.DirectorySeparatorChar);

Services/ProjectScanner.cs

@@ -47,10 +47,37 @@ public string GetProjectStructure(string projectPath, int indent = 0)
         }
 
         var rootPath = _gitRepoRoot ?? projectPath;
-        var entries = Directory.EnumerateFileSystemEntries(projectPath)
-            .OrderBy(e => e)
-            .Where(e => !_fileChecker.ShouldSkip(new FileInfo(e), rootPath))
-            .ToList();
+
+        List<string> entries;
+        try
+        {
+            var enumerationOptions = new EnumerationOptions
+            {
+                IgnoreInaccessible = true,
+                RecurseSubdirectories = false
+            };
+
+            entries = Directory.EnumerateFileSystemEntries(projectPath, "*", enumerationOptions)
+                .OrderBy(e => e)
+                .Where(e =>
+                {
+                    try
+                    {
+                        return !_fileChecker.ShouldSkip(new FileInfo(e), rootPath);
+                    }
+                    catch
+                    {
+                        // Skip entries that can't be accessed
+                        return false;
+                    }
+                })
+                .ToList();
+        }
+        catch (Exception ex)
+        {
+            _console.WriteLine($"\n⚠️ Warning: Could not enumerate directory {projectPath}: {ex.Message}");
+            return string.Empty;
+        }
 
         var structure = new StringBuilder();
 
@@ -87,9 +114,10 @@ public string GetFileContents(string projectPath)
         _console.WriteLine("\n📄 Processing files...");
 
         var rootPath = _gitRepoRoot ?? projectPath;
-        var files = Directory.EnumerateFiles(projectPath, "*", SearchOption.AllDirectories)
-            .Where(f => !_fileChecker.ShouldSkip(new FileInfo(f), rootPath))
-            .ToList();
+        var files = new List<string>();
+
+        // Manually enumerate files recursively to respect filters
+        EnumerateFilesRecursively(projectPath, rootPath, files);
 
         var fileContents = new List<string>();
         for (int i = 0; i < files.Count; i++)
@@ -111,6 +139,59 @@ public string GetFileContents(string projectPath)
         return string.Join("\n\n", fileContents);
     }
 
+    /// <summary>
+    /// Recursively enumerates files while respecting filter rules.
+    /// </summary>
+    private void EnumerateFilesRecursively(string directory, string rootPath, List<string> files)
+    {
+        try
+        {
+            var enumerationOptions = new EnumerationOptions
+            {
+                IgnoreInaccessible = true,
+                RecurseSubdirectories = false
+            };
+
+            // Get files in current directory
+            foreach (var file in Directory.EnumerateFiles(directory, "*", enumerationOptions))
+            {
+                try
+                {
+                    var fileInfo = new FileInfo(file);
+                    if (!_fileChecker.ShouldSkip(fileInfo, rootPath))
+                    {
+                        files.Add(file);
+                    }
+                }
+                catch
+                {
+                    // Skip files that can't be accessed
+                }
+            }
+
+            // Recursively process subdirectories
+            foreach (var subDir in Directory.EnumerateDirectories(directory, "*", enumerationOptions))
+            {
+                try
+                {
+                    var dirInfo = new DirectoryInfo(subDir);
+                    if (!_fileChecker.ShouldSkip(dirInfo, rootPath))
+                    {
+                        EnumerateFilesRecursively(subDir, rootPath, files);
+                    }
+                }
+                catch
+                {
+                    // Skip directories that can't be accessed
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _console.WriteLine($"\n⚠️ Warning: Could not enumerate directory {directory}: {ex.Message}");
+        }
+    }
+
     /// <summary>
     /// Gets the root path of the git repository containing the scanned path.
     /// </summary>