Refactor services and improve file filtering logic

DavidVeksler · DavidVeksler · commit d5e50c2175b0 · 2025-12-07T20:25:54.000-07:00
Refactored multiple service classes to use primary constructors and field initializers for dependencies, simplifying code and improving readability. Enhanced file filtering logic in FileFilterService with pattern matching. Replaced custom file collection logic in CodeContextTools with a call to ProjectScanner's new GetAllFiles method. Updated FileUtilities to use Span for buffer operations and improved binary content detection. Various minor improvements to immutability and collection initialization throughout the codebase.
diff --git a/Configuration/FilterConfiguration.cs b/Configuration/FilterConfiguration.cs
@@ -1,3 +1,5 @@
+using System.Collections.Frozen;
+
 namespace CodeContext.Configuration;
 
 /// <summary>
@@ -13,7 +15,7 @@ public class FilterConfiguration
     /// <summary>
     /// File extensions to ignore during processing.
     /// </summary>
-    public HashSet<string> IgnoredExtensions { get; init; } = new(StringComparer.OrdinalIgnoreCase)
+    public FrozenSet<string> IgnoredExtensions { get; init; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
     {
         // Executable and library files
         ".exe", ".dll", ".pdb", ".bin", ".obj", ".lib", ".so", ".dylib", ".a", ".o",
@@ -107,12 +109,12 @@ public class FilterConfiguration
         ".bat", ".sh", ".cmd", ".ps1",
 
         ".sql"
-    };
+    }.ToFrozenSet(StringComparer.OrdinalIgnoreCase);
 
     /// <summary>
     /// Directory names to ignore during processing.
     /// </summary>
-    public HashSet<string> IgnoredDirectories { get; init; } = new(StringComparer.OrdinalIgnoreCase)
+    public FrozenSet<string> IgnoredDirectories { get; init; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
     {
         ".sonarqube",
 
@@ -243,18 +245,18 @@ public class FilterConfiguration
 
         // Pipenv
         ".venv"
-    };
+    }.ToFrozenSet(StringComparer.OrdinalIgnoreCase);
 
     /// <summary>
     /// File names to ignore during processing.
     /// </summary>
-    public HashSet<string> IgnoredFiles { get; init; } = new(StringComparer.OrdinalIgnoreCase)
+    public FrozenSet<string> IgnoredFiles { get; init; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
     {
         ".bzrignore", ".coveragerc", ".editorconfig", ".env", ".env.development",
         ".env.production", ".env.local", ".env.test", ".eslintrc", ".gitattributes",
         "thumbs.db", "desktop.ini", ".DS_Store", "npm-debug.log", "yarn-error.log",
         "package-lock.json", "yarn.lock", "composer.lock", ".gitignore"
-    };
+    }.ToFrozenSet(StringComparer.OrdinalIgnoreCase);
 
     /// <summary>
     /// Number of lines to check for generated code markers.
diff --git a/Mcp/CodeContextTools.cs b/Mcp/CodeContextTools.cs
@@ -13,14 +13,9 @@ namespace CodeContext.Mcp;
 /// Provides intelligent code context generation with token budget optimization.
 /// </summary>
 [McpServerToolType]
-public class CodeContextTools
+public class CodeContextTools(IConsoleWriter console)
 {
-    private readonly IConsoleWriter _console;
-
-    public CodeContextTools(IConsoleWriter console)
-    {
-        _console = console;
-    }
+    private readonly IConsoleWriter _console = console;
 
     /// <summary>
     /// Gets optimized code context for a specific task within a token budget.
@@ -281,64 +276,5 @@ public string GetFileContent(
     /// </summary>
     private static List<(string path, string content)> GetAllProjectFiles(
         ProjectScanner scanner,
-        string projectPath)
-    {
-        var files = new List<(string path, string content)>();
-        var context = GitHelper.FindRepositoryRoot(projectPath) ?? projectPath;
-
-        CollectFiles(scanner, projectPath, context, files);
-
-        return files;
-    }
-
-    private static void CollectFiles(
-        ProjectScanner scanner,
-        string currentPath,
-        string rootPath,
-        List<(string path, string content)> files)
-    {
-        try
-        {
-            var fileCheckerField = scanner.GetType()
-                .GetField("_fileChecker", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
-            var fileChecker = fileCheckerField?.GetValue(scanner) as IFileChecker;
-
-            var entries = Directory.EnumerateFileSystemEntries(currentPath)
-                .Where(e => fileChecker == null || !fileChecker.ShouldSkip(new FileInfo(e), rootPath))
-                .ToList();
-
-            foreach (var entry in entries)
-            {
-                if (Directory.Exists(entry))
-                {
-                    CollectFiles(scanner, entry, rootPath, files);
-                }
-                else if (File.Exists(entry))
-                {
-                    try
-                    {
-                        var content = File.ReadAllText(entry);
-                        var relativePath = Path.GetRelativePath(rootPath, entry);
-                        files.Add((relativePath, content));
-                    }
-                    catch (UnauthorizedAccessException)
-                    {
-                        // Skip files with permission issues
-                    }
-                    catch (IOException)
-                    {
-                        // Skip files that are locked or in use
-                    }
-                }
-            }
-        }
-        catch (UnauthorizedAccessException)
-        {
-            // Skip directories with permission issues
-        }
-        catch (DirectoryNotFoundException)
-        {
-            // Skip if directory was deleted during scan
-        }
-    }
+        string projectPath) => scanner.GetAllFiles(projectPath);
 }
diff --git a/Services/ConfigLoader.cs b/Services/ConfigLoader.cs
@@ -7,15 +7,10 @@ namespace CodeContext.Services;
 /// <summary>
 /// Functional configuration loader with separated I/O and parsing logic.
 /// </summary>
-public class ConfigLoader
+public class ConfigLoader(IConsoleWriter console)
 {
     private const string ConfigFileName = "config.json";
-    private readonly IConsoleWriter _console;
-
-    public ConfigLoader(IConsoleWriter console)
-    {
-        _console = console;
-    }
+    private readonly IConsoleWriter _console = console;
 
     /// <summary>
     /// Loads configuration from config.json if it exists, otherwise returns default configuration.
diff --git a/Services/ContentBuilder.cs b/Services/ContentBuilder.cs
@@ -7,14 +7,9 @@ namespace CodeContext.Services;
 /// Builds project context content using functional composition.
 /// Separates content generation from assembly.
 /// </summary>
-public class ContentBuilder
+public class ContentBuilder(ProjectScanner scanner)
 {
-    private readonly ProjectScanner _scanner;
-
-    public ContentBuilder(ProjectScanner scanner)
-    {
-        _scanner = scanner;
-    }
+    private readonly ProjectScanner _scanner = scanner;
 
     /// <summary>
     /// Builds the complete content output including structure and file contents.
diff --git a/Services/FileFilterService.cs b/Services/FileFilterService.cs
@@ -33,38 +33,30 @@ public bool ShouldSkip(FileSystemInfo info, string rootPath)
         Guard.NotNull(info, nameof(info));
         Guard.NotNullOrEmpty(rootPath, nameof(rootPath));
 
-        // Compose filter predicates - each is a pure function or has well-defined side effects
-        return IsReparsePoint(info)
-            || ContainsIgnoredDirectory(info, rootPath)
-            || (IsFile(info) && ShouldSkipFile(info, rootPath));
+        // Use pattern matching for more expressive filtering
+        return info switch
+        {
+            { Attributes: var attr } when attr.HasFlag(FileAttributes.ReparsePoint) => true,
+            _ when ContainsIgnoredDirectory(info, rootPath) => true,
+            FileInfo file => ShouldSkipFile(file, rootPath),
+            _ => false
+        };
     }
 
-    private static bool IsReparsePoint(FileSystemInfo info) =>
-        info.Attributes.HasFlag(FileAttributes.ReparsePoint);
-
-    private static bool IsFile(FileSystemInfo info) =>
-        !info.Attributes.HasFlag(FileAttributes.Directory);
-
     private bool ContainsIgnoredDirectory(FileSystemInfo info, string rootPath)
     {
         var relativePath = Path.GetRelativePath(rootPath, info.FullName);
         var pathParts = relativePath.Split(Path.DirectorySeparatorChar);
         return pathParts.Any(_config.IgnoredDirectories.Contains);
     }
 
-    private bool ShouldSkipFile(FileSystemInfo info, string rootPath) =>
-        IsIgnoredFileName(info.Name)
-        || ShouldSkipByExtension(info.Name)
-        || IsFileTooLarge(info)
-        || ShouldSkipByGitIgnore(info.FullName, rootPath)
-        || IsBinaryFile(info.FullName)
-        || IsGeneratedCode(info.FullName);
-
-    private bool IsIgnoredFileName(string fileName) =>
-        _config.IgnoredFiles.Contains(fileName);
-
-    private bool IsFileTooLarge(FileSystemInfo info) =>
-        info is FileInfo fileInfo && fileInfo.Length > _config.MaxFileSizeBytes;
+    private bool ShouldSkipFile(FileInfo file, string rootPath) =>
+        _config.IgnoredFiles.Contains(file.Name)
+        || ShouldSkipByExtension(file.Name)
+        || file.Length > _config.MaxFileSizeBytes
+        || ShouldSkipByGitIgnore(file.FullName, rootPath)
+        || IsBinaryFile(file.FullName)
+        || IsGeneratedCode(file.FullName);
 
     private bool IsBinaryFile(string filePath) =>
         FileUtilities.IsBinaryFile(filePath, _config.BinaryCheckChunkSize, _config.BinaryThreshold);
diff --git a/Services/FileRelevanceScorer.cs b/Services/FileRelevanceScorer.cs
@@ -7,7 +7,7 @@ namespace CodeContext.Services;
 /// Scores files based on relevance to a query or task description.
 /// Uses keyword matching, path analysis, and file characteristics.
 /// </summary>
-public class FileRelevanceScorer
+public class FileRelevanceScorer(string projectPath)
 {
     // Scoring weights for different factors
     private const double FileNameWeight = 0.30;
@@ -28,12 +28,7 @@ public class FileRelevanceScorer
     private const double IndexFileBoost = 0.15;
     private const double TestFileBoost = 0.1;
 
-    private readonly string _projectPath;
-
-    public FileRelevanceScorer(string projectPath)
-    {
-        _projectPath = Guard.NotNullOrEmpty(projectPath, nameof(projectPath));
-    }
+    private readonly string _projectPath = Guard.NotNullOrEmpty(projectPath, nameof(projectPath));
 
     /// <summary>
     /// Represents a scored file with relevance information.
@@ -55,7 +50,7 @@ Dictionary<string, double> ScoreBreakdown
     /// <returns>Scored file with relevance score between 0 and 1.</returns>
     public ScoredFile ScoreFile(string filePath, string content, string query)
     {
-        var breakdown = new Dictionary<string, double>();
+        Dictionary<string, double> breakdown = [];
         var keywords = ExtractKeywords(query);
 
         // 1. File name relevance (30% weight)
@@ -92,10 +87,10 @@ public ScoredFile ScoreFile(string filePath, string content, string query)
     private static List<string> ExtractKeywords(string query)
     {
         if (string.IsNullOrWhiteSpace(query))
-            return new List<string>();
+            return [];
 
         // Remove common words and split into keywords
-        var commonWords = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        HashSet<string> commonWords = new(StringComparer.OrdinalIgnoreCase)
         {
             "the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for",
             "of", "with", "by", "from", "as", "is", "was", "are", "were", "be",
diff --git a/Services/OutputFormatter.cs b/Services/OutputFormatter.cs
@@ -6,14 +6,9 @@ namespace CodeContext.Services;
 /// <summary>
 /// Functional output formatter with separated I/O and formatting logic.
 /// </summary>
-public class OutputFormatter
+public class OutputFormatter(IConsoleWriter console)
 {
-    private readonly IConsoleWriter _console;
-
-    public OutputFormatter(IConsoleWriter console)
-    {
-        _console = console;
-    }
+    private readonly IConsoleWriter _console = console;
 
     /// <summary>
     /// Writes content to the specified output location (I/O operation).
diff --git a/Services/PathResolver.cs b/Services/PathResolver.cs
@@ -7,14 +7,9 @@ namespace CodeContext.Services;
 /// Resolves and validates input and output paths with user interaction.
 /// Separates pure path operations from I/O side effects.
 /// </summary>
-public class PathResolver
+public class PathResolver(IConsoleWriter console)
 {
-    private readonly IConsoleWriter _console;
-
-    public PathResolver(IConsoleWriter console)
-    {
-        _console = console;
-    }
+    private readonly IConsoleWriter _console = console;
 
     /// <summary>
     /// Gets and validates the input directory path (I/O operation).
diff --git a/Services/ProjectScanner.cs b/Services/ProjectScanner.cs
@@ -8,16 +8,10 @@ namespace CodeContext.Services;
 /// Functional service for scanning and analyzing project directories.
 /// Uses immutable data structures and separates I/O from pure logic.
 /// </summary>
-public class ProjectScanner
+public class ProjectScanner(IFileChecker fileChecker, IConsoleWriter console)
 {
-    private readonly IFileChecker _fileChecker;
-    private readonly IConsoleWriter _console;
-
-    public ProjectScanner(IFileChecker fileChecker, IConsoleWriter console)
-    {
-        _fileChecker = Guard.NotNull(fileChecker, nameof(fileChecker));
-        _console = Guard.NotNull(console, nameof(console));
-    }
+    private readonly IFileChecker _fileChecker = Guard.NotNull(fileChecker, nameof(fileChecker));
+    private readonly IConsoleWriter _console = Guard.NotNull(console, nameof(console));
 
     /// <summary>
     /// Gets user input with a prompt (pure I/O operation).
@@ -292,4 +286,67 @@ private void WriteProgress(int current, int total)
         var percent = (int)((current / (double)total) * 100);
         _console.Write($"\r⏳ Progress: {percent}% ({current}/{total})");
     }
+
+    /// <summary>
+    /// Gets all files in the project directory tree with their contents.
+    /// </summary>
+    /// <param name="projectPath">The directory path to scan.</param>
+    /// <returns>List of tuples containing (relative path, content) for each file.</returns>
+    public List<(string path, string content)> GetAllFiles(string projectPath)
+    {
+        Guard.DirectoryExists(projectPath, nameof(projectPath));
+
+        var context = ScanContext.Create(projectPath);
+        var files = new List<(string path, string content)>();
+
+        CollectAllFiles(projectPath, context.GitRepoRoot, files);
+
+        return files;
+    }
+
+    /// <summary>
+    /// Recursively collects all files with their contents.
+    /// </summary>
+    private void CollectAllFiles(string currentPath, string rootPath, List<(string path, string content)> files)
+    {
+        try
+        {
+            var entries = Directory.EnumerateFileSystemEntries(currentPath)
+                .Where(e => ShouldIncludeEntry(e, rootPath))
+                .ToList();
+
+            foreach (var entry in entries)
+            {
+                if (Directory.Exists(entry))
+                {
+                    CollectAllFiles(entry, rootPath, files);
+                }
+                else if (File.Exists(entry))
+                {
+                    try
+                    {
+                        var content = File.ReadAllText(entry);
+                        var relativePath = Path.GetRelativePath(rootPath, entry);
+                        files.Add((relativePath, content));
+                    }
+                    catch (UnauthorizedAccessException)
+                    {
+                        // Skip files with permission issues
+                    }
+                    catch (IOException)
+                    {
+                        // Skip files that are locked or in use
+                    }
+                }
+            }
+        }
+        catch (UnauthorizedAccessException)
+        {
+            // Skip directories with permission issues
+        }
+        catch (DirectoryNotFoundException)
+        {
+            // Skip if directory was deleted during scan
+        }
+    }
 }
diff --git a/Services/TokenBudgetOptimizer.cs b/Services/TokenBudgetOptimizer.cs
diff --git a/Utils/FileUtilities.cs b/Utils/FileUtilities.cs
