FilteredSolutionsExtension: minor fixes to compile

FilteredSolutionsExtension/FilteredSolutionsExtension/ErrorHandler.cs

@@ -0,0 +1,158 @@
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
+{
+   public static class ErrorHandler
+    {
+        public static void LogError(string message, Exception exception = null)
+        {
+            var fullMessage = exception != null
+                ? $"{message}: {exception.Message}\n{exception.StackTrace}"
+                : message;
+
+            System.Diagnostics.Debug.WriteLine($"[FilteredSolutions] ERROR: {fullMessage}");
+
+            // Also log to VS output window if available and on UI thread
+            try
+            {
+                if (ThreadHelper.CheckAccess())
+                {
+                    LogToOutputWindow(fullMessage);
+                }
+                else
+                {
+                    // If not on UI thread, schedule the logging on the UI thread
+                    ThreadHelper.JoinableTaskFactory.RunAsync(async () =>
+                    {
+                        await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                        LogToOutputWindow(fullMessage);
+                    });
+                }
+            }
+            catch
+            {
+                // Ignore errors when trying to log to output window
+            }
+        }
+
+        private static void LogToOutputWindow(string message)
+        {
+            ThreadHelper.ThrowIfNotOnUIThread();
+            
+            try
+            {
+                var outputWindow = Package.GetGlobalService(typeof(SVsOutputWindow)) as IVsOutputWindow;
+                if (outputWindow != null)
+                {
+                    var guidGeneral = Microsoft.VisualStudio.VSConstants.GUID_OutWindowGeneralPane;
+                    outputWindow.GetPane(ref guidGeneral, out IVsOutputWindowPane pane);
+                    pane?.OutputString($"[Filtered Solutions Extension] {message}\n");
+                }
+            }
+            catch
+            {
+                // Ignore errors when trying to log
+            }
+        }
+
+        public static void LogInfo(string message)
+        {
+            System.Diagnostics.Debug.WriteLine($"[FilteredSolutions] INFO: {message}");
+            
+            // Try to log to output window if on UI thread
+            try
+            {
+                if (ThreadHelper.CheckAccess())
+                {
+                    LogToOutputWindow(message);
+                }
+            }
+            catch
+            {
+                // Ignore errors when trying to log
+            }
+        }
+
+        public static void ShowUserError(string title, string message, Exception exception = null)
+        {
+            var fullMessage = exception != null
+                ? $"{message}\n\nError: {exception.Message}"
+                : message;
+
+            // Ensure we're on the UI thread for MessageBox
+            if (ThreadHelper.CheckAccess())
+            {
+                ShowMessageBoxOnUIThread(fullMessage, title, MessageBoxImage.Error);
+            }
+            else
+            {
+                ThreadHelper.JoinableTaskFactory.RunAsync(async () =>
+                {
+                    await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                    ShowMessageBoxOnUIThread(fullMessage, title, MessageBoxImage.Error);
+                });
+            }
+            
+            LogError($"{title}: {message}", exception);
+        }
+
+        public static void ShowUserInfo(string title, string message)
+        {
+            // Ensure we're on the UI thread for MessageBox
+            if (ThreadHelper.CheckAccess())
+            {
+                ShowMessageBoxOnUIThread(message, title, MessageBoxImage.Information);
+            }
+            else
+            {
+                ThreadHelper.JoinableTaskFactory.RunAsync(async () =>
+                {
+                    await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                    ShowMessageBoxOnUIThread(message, title, MessageBoxImage.Information);
+                });
+            }
+            
+            LogInfo($"{title}: {message}");
+        }
+
+        public static bool ShowUserConfirmation(string title, string message)
+        {
+            bool result = false;
+            
+            if (ThreadHelper.CheckAccess())
+            {
+                result = ShowConfirmationOnUIThread(message, title);
+            }
+            else
+            {
+                ThreadHelper.JoinableTaskFactory.Run(async () =>
+                {
+                    await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                    result = ShowConfirmationOnUIThread(message, title);
+                });
+            }
+            
+            return result;
+        }
+
+        private static void ShowMessageBoxOnUIThread(string message, string title, MessageBoxImage icon)
+        {
+            ThreadHelper.ThrowIfNotOnUIThread();
+            MessageBox.Show(message, title, MessageBoxButton.OK, icon);
+        }
+
+        private static bool ShowConfirmationOnUIThread(string message, string title)
+        {
+            ThreadHelper.ThrowIfNotOnUIThread();
+            var result = MessageBox.Show(message, title, MessageBoxButton.YesNo, MessageBoxImage.Question);
+            return result == MessageBoxResult.Yes;
+        }
+    }
+}

FilteredSolutionsExtension/FilteredSolutionsExtension/ExtensionSettings.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
+{
+   public class ExtensionSettings
+    {
+        private static readonly string SettingsFileName = "FilteredSolutionsSettings.json";
+        private static readonly string SettingsDirectory = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+            "Quadarax", "FilteredSolutionsExtension");
+
+        public bool AutoShowFilterDialog { get; set; } = true;
+        public bool RememberLastSelection { get; set; } = true;
+        public Dictionary<string, List<string>> SolutionFilterHistory { get; set; } = new Dictionary<string, List<string>>();
+        public string LastFilterPattern { get; set; } = "";
+        public bool AutoSelectDependencies { get; set; } = true;
+        public bool ShowProjectPaths { get; set; } = false;
+
+        private static string SettingsFilePath => Path.Combine(SettingsDirectory, SettingsFileName);
+
+        public static ExtensionSettings Load()
+        {
+            try
+            {
+                if (File.Exists(SettingsFilePath))
+                {
+                    var json = File.ReadAllText(SettingsFilePath);
+                    return JsonSerializer.Deserialize<ExtensionSettings>(json) ?? new ExtensionSettings();
+                }
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"Failed to load settings: {ex.Message}");
+            }
+
+            return new ExtensionSettings();
+        }
+
+        public void Save()
+        {
+            try
+            {
+                Directory.CreateDirectory(SettingsDirectory);
+                var json = JsonSerializer.Serialize(this, new JsonSerializerOptions { WriteIndented = true });
+                File.WriteAllText(SettingsFilePath, json);
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"Failed to save settings: {ex.Message}");
+            }
+        }
+
+        public void SaveFilterSelection(string solutionPath, List<string> selectedProjectGuids)
+        {
+            if (!RememberLastSelection) return;
+
+            var key = Path.GetFileName(solutionPath);
+            SolutionFilterHistory[key] = new List<string>(selectedProjectGuids);
+            Save();
+        }
+
+        public List<string> GetLastFilterSelection(string solutionPath)
+        {
+            if (!RememberLastSelection) return new List<string>();
+
+            var key = Path.GetFileName(solutionPath);
+            return SolutionFilterHistory.ContainsKey(key) ? 
+                new List<string>(SolutionFilterHistory[key]) : 
+                new List<string>();
+        }
+    }
+}

FilteredSolutionsExtension/FilteredSolutionsExtension/FilteredSolutionGenerator.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
@@ -15,45 +16,138 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
         public async Task GenerateFilteredSolutionAsync(string originalSolutionPath, string targetSolutionPath, List<ProjectInfo> selectedProjects)
         {
             var originalContent = await FileUtils.ReadAllTextAsync(originalSolutionPath);
-            var lines = originalContent.Split('\n');
+            var lines = originalContent.Split(new[] { '\r', '\n' }, System.StringSplitOptions.None);
             var filteredLines = new List<string>();
-            var selectedGuids = new HashSet<string>(selectedProjects.Select(p => p.ProjectGuid));
+            var selectedGuids = new HashSet<string>(selectedProjects.Select(p => p.ProjectGuid), System.StringComparer.OrdinalIgnoreCase);
 
             bool inProjectSection = false;
             bool currentProjectIncluded = false;
+            bool inGlobalSection = false;
+            bool inProjectConfigurationPlatforms = false;
+            bool inProjectDependencies = false;
+            string currentProjectGuid = null;
 
             foreach (var line in lines)
             {
                 var trimmedLine = line.Trim();
 
+                // Handle project definitions
                 if (trimmedLine.StartsWith("Project("))
                 {
                     inProjectSection = true;
                     var match = ProjectRegex.Match(line);
                     if (match.Success)
                     {
-                        var projectGuid = match.Groups[4].Value;
-                        currentProjectIncluded = selectedGuids.Contains(projectGuid);
+                        currentProjectGuid = match.Groups[4].Value;
+                        currentProjectIncluded = selectedGuids.Contains(currentProjectGuid);
                     }
                 }
 
-                if (inProjectSection && currentProjectIncluded)
+                // Handle Global sections
+                if (trimmedLine.StartsWith("Global"))
                 {
+                    inGlobalSection = true;
                     filteredLines.Add(line);
+                    continue;
                 }
-                else if (!inProjectSection)
+
+                if (trimmedLine.StartsWith("EndGlobal"))
+                {
+                    inGlobalSection = false;
+                    filteredLines.Add(line);
+                    continue;
+                }
+
+                // Handle specific global sections that need filtering
+                if (inGlobalSection)
                 {
+                    if (trimmedLine.StartsWith("GlobalSection(ProjectConfigurationPlatforms)"))
+                    {
+                        inProjectConfigurationPlatforms = true;
+                        filteredLines.Add(line);
+                        continue;
+                    }
+
+                    if (trimmedLine.StartsWith("GlobalSection(ProjectDependencies)"))
+                    {
+                        inProjectDependencies = true;
+                        filteredLines.Add(line);
+                        continue;
+                    }
+
+                    if (trimmedLine.StartsWith("EndGlobalSection"))
+                    {
+                        inProjectConfigurationPlatforms = false;
+                        inProjectDependencies = false;
+                        filteredLines.Add(line);
+                        continue;
+                    }
+
+                    // Filter ProjectConfigurationPlatforms entries
+                    if (inProjectConfigurationPlatforms)
+                    {
+                        if (ContainsSelectedProjectGuid(line, selectedGuids))
+                        {
+                            filteredLines.Add(line);
+                        }
+                        continue;
+                    }
+
+                    // Filter ProjectDependencies entries
+                    if (inProjectDependencies)
+                    {
+                        if (ContainsSelectedProjectGuid(line, selectedGuids))
+                        {
+                            filteredLines.Add(line);
+                        }
+                        continue;
+                    }
+
+                    // Include other global sections as-is
                     filteredLines.Add(line);
+                    continue;
+                }
+
+                // Handle project sections
+                if (inProjectSection)
+                {
+                    if (currentProjectIncluded)
+                    {
+                        filteredLines.Add(line);
+                    }
+
+                    if (trimmedLine.StartsWith("EndProject"))
+                    {
+                        inProjectSection = false;
+                        currentProjectIncluded = false;
+                        currentProjectGuid = null;
+                    }
+                    continue;
                 }
 
-                if (trimmedLine.StartsWith("EndProject"))
+                // Include everything else (header, solution items, etc.)
+                if (!inProjectSection && !inGlobalSection)
                 {
-                    inProjectSection = false;
-                    currentProjectIncluded = false;
+                    filteredLines.Add(line);
                 }
             }
 
-            await FileUtils.WriteAllTextAsync(targetSolutionPath, string.Join("\n", filteredLines));
+            // Write the filtered solution
+            var filteredContent = string.Join(System.Environment.NewLine, filteredLines);
+            await FileUtils.WriteAllTextAsync(targetSolutionPath, filteredContent, Encoding.UTF8);
+        }
+
+        private bool ContainsSelectedProjectGuid(string line, HashSet<string> selectedGuids)
+        {
+            // Check if line contains any of the selected project GUIDs
+            foreach (var guid in selectedGuids)
+            {
+                if (line.IndexOf(guid, System.StringComparison.OrdinalIgnoreCase) >= 0)
+                {
+                    return true;
+                }
+            }
+            return false;
         }
     }
 }

FilteredSolutionsExtension/FilteredSolutionsExtension/FilteredSolutionsExtension.csproj

@@ -46,6 +46,8 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="DebugHelper.cs" />
+    <Compile Include="ErrorHandler.cs" />
+    <Compile Include="ExtensionSettings.cs" />
     <Compile Include="FileUtils.cs" />
     <Compile Include="FilteredSolutionGenerator.cs" />
     <Compile Include="ManualFilterCommand.cs" />
@@ -58,7 +60,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="FilteredSolutionsExtensionPackage.cs" />
     <Compile Include="SolutionEventsHandler.cs" />
-    <None Include="SolutionOpeningInterceptor.cs" />
+    <Compile Include="SolutionOpeningInterceptor.cs" />
     <Compile Include="SolutionParser.cs" />
   </ItemGroup>
   <ItemGroup>
@@ -77,6 +79,9 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.VisualStudio.SDK" Version="17.0.32112.339" ExcludeAssets="runtime" NoWarn="NU1604" />
     <PackageReference Include="Microsoft.VSSDK.BuildTools" Version="17.14.2094" NoWarn="NU1604" />
+    <PackageReference Include="System.Text.Json">
+      <Version>9.0.5</Version>
+    </PackageReference>
   </ItemGroup>
   <ItemGroup>
     <Page Include="ProjectFilterDialog.xaml">
@@ -85,6 +90,7 @@
     </Page>
   </ItemGroup>
   <ItemGroup>
+    <Content Include="Menus.vsct" />
     <Content Include="releasenote.txt">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       <IncludeInVSIX>true</IncludeInVSIX>

FilteredSolutionsExtension/FilteredSolutionsExtension/ManualFilterCommand.cs

@@ -34,14 +34,14 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
             Instance = new ManualFilterCommand(package, commandService);
         }
 
-        private void OnBeforeQueryStatus(object sender, EventArgs e)
+        private async void OnBeforeQueryStatus(object sender, EventArgs e)
         {
-            ThreadHelper.ThrowIfNotOnUIThread();
+            await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
             
             var command = sender as OleMenuCommand;
             if (command != null)
             {
-                 var dte = (EnvDTE.DTE) _package.GetService(typeof(EnvDTE.DTE));
+                var dte = await _package.GetServiceAsync(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
                 command.Visible = command.Enabled = 
                     dte?.Solution != null && 
                     !string.IsNullOrEmpty(dte.Solution.FullName) &&
@@ -49,15 +49,15 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
             }
         }
 
-        private void Execute(object sender, EventArgs e)
+        private async void Execute(object sender, EventArgs e)
         {
-            ThreadHelper.ThrowIfNotOnUIThread();
+            await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
 
             try
             {
                 DebugHelper.Log("Manual filter command executed");
                 
-                 var dte = (EnvDTE.DTE) _package.GetService(typeof(EnvDTE.DTE));
+                var dte = await _package.GetServiceAsync(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
                 var solutionInfo = SolutionInfo.FromCurrentSolution(dte);
                 
                 if (solutionInfo != null)

FilteredSolutionsExtension/FilteredSolutionsExtension/Menus.vsct

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<CommandTable xmlns="http://schemas.microsoft.com/VisualStudio/2005-10-18/CommandTable" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <Extern href="stdidcmd.h"/>
+  <Extern href="vsshlids.h"/>
+
+  <Commands package="guidFilteredSolutionsExtensionPackage">
+    <Groups>
+      <Group guid="guidFilteredSolutionsExtensionPackageCmdSet" id="MyMenuGroup" priority="0x0600">
+        <Parent guid="guidSHLMainMenu" id="IDM_VS_MENU_FILE"/>
+      </Group>
+    </Groups>
+
+    <Buttons>
+      <Button guid="guidFilteredSolutionsExtensionPackageCmdSet" id="FilterSolutionCommandId" priority="0x0100" type="Button">
+        <Parent guid="guidFilteredSolutionsExtensionPackageCmdSet" id="MyMenuGroup" />
+        <Icon guid="guidImages" id="bmpPic1" />
+        <Strings>
+          <ButtonText>Filter Solution Projects...</ButtonText>
+        </Strings>
+      </Button>
+    </Buttons>
+
+    <Bitmaps>
+      <Bitmap guid="guidImages" href="Resources\FilterSolutionsCommand.png" usedList="bmpPic1"/>
+    </Bitmaps>
+  </Commands>
+
+  <Symbols>
+    <GuidSymbol name="guidFilteredSolutionsExtensionPackage" value="{12345678-1234-1234-1234-123456789abc}" />
+
+    <GuidSymbol name="guidFilteredSolutionsExtensionPackageCmdSet" value="{12345678-1234-1234-1234-123456789abd}">
+      <IDSymbol name="MyMenuGroup" value="0x1020" />
+      <IDSymbol name="FilterSolutionCommandId" value="0x0100" />
+    </GuidSymbol>
+
+    <GuidSymbol name="guidImages" value="{12345678-1234-1234-1234-123456789abe}">
+      <IDSymbol name="bmpPic1" value="1" />
+    </GuidSymbol>
+  </Symbols>
+</CommandTable>

FilteredSolutionsExtension/FilteredSolutionsExtension/ProjectFilterDialog.xaml

@@ -1,65 +1,96 @@
-<!-- ProjectFilterDialog.xaml -->
-<Window x:Class="Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
-.ProjectFilterDialog"
+<Window x:Class="Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension.ProjectFilterDialog"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        Title="Select Projects for Solution" Height="600" Width="800" 
-        WindowStartupLocation="CenterScreen" ResizeMode="CanResize">
-    <Grid Margin="10">
+        Title="Select Projects for Solution" Height="700" Width="900" 
+        WindowStartupLocation="CenterScreen" ResizeMode="CanResize"
+        MinHeight="500" MinWidth="600">
+    <Grid Margin="15">
         <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="Auto"/>
             <RowDefinition Height="*"/>
             <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
         </Grid.RowDefinitions>
         
+        <!-- Solution Info -->
+        <GroupBox Grid.Row="0" Header="Solution Information" Padding="10" Margin="0,0,0,10">
+            <StackPanel>
+                <TextBlock x:Name="SolutionNameTextBlock" FontWeight="Bold" Margin="0,0,0,5"/>
+                <TextBlock x:Name="ProjectCountTextBlock" Foreground="Gray"/>
+            </StackPanel>
+        </GroupBox>
+        
         <!-- Filter Section -->
-        <GroupBox Grid.Row="0" Header="Filter" Padding="10" Margin="0,0,0,10">
+        <GroupBox Grid.Row="1" Header="Filter Projects" Padding="10" Margin="0,0,0,10">
             <Grid>
                 <Grid.ColumnDefinitions>
                     <ColumnDefinition Width="Auto"/>
                     <ColumnDefinition Width="*"/>
                     <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="Auto"/>
                 </Grid.ColumnDefinitions>
                 
                 <Label Grid.Column="0" Content="Filter pattern:" VerticalAlignment="Center"/>
                 <TextBox Grid.Column="1" x:Name="FilterTextBox" Margin="5,0" 
-                         VerticalAlignment="Center" Height="25"/>
-                <Button Grid.Column="2" x:Name="FilterButton" Content="Filter" 
-                        Width="75" Click="FilterButton_Click" Margin="5,0,0,0"/>
+                         VerticalAlignment="Center" Height="25"
+                         ToolTip="Use * for wildcards (e.g., Test*, *Core*, *.Data)"/>
+                <Button Grid.Column="2" x:Name="FilterButton" Content="Apply Filter" 
+                        Width="90" Click="FilterButton_Click" Margin="5,0,0,0"/>
+                <Button Grid.Column="3" x:Name="ClearFilterButton" Content="Clear" 
+                        Width="60" Click="ClearFilterButton_Click" Margin="5,0,0,0"/>
             </Grid>
         </GroupBox>
         
-        <!-- Button Section -->
-        <StackPanel Grid.Row="1" Orientation="Horizontal" Margin="0,0,0,10">
-            <Button x:Name="SelectAllButton" Content="Select All" Width="80" Height="30" 
-                    Click="SelectAllButton_Click" Margin="0,0,5,0"/>
-            <Button x:Name="ClearAllButton" Content="Clear All" Width="80" Height="30" 
-                    Click="ClearAllButton_Click"/>
+        <!-- Selection Controls -->
+        <StackPanel Grid.Row="2" Orientation="Horizontal" Margin="0,0,0,10">
+            <Button x:Name="SelectAllButton" Content="Select All" Width="90" Height="32" 
+                    Click="SelectAllButton_Click" Margin="0,0,8,0"/>
+            <Button x:Name="ClearAllButton" Content="Clear All" Width="90" Height="32" 
+                    Click="ClearAllButton_Click" Margin="0,0,8,0"/>
+            <Separator Width="1" Margin="8,0"/>
+            <TextBlock x:Name="SelectionCountTextBlock" VerticalAlignment="Center" 
+                       Margin="8,0,0,0" Foreground="DarkBlue" FontWeight="Medium"/>
         </StackPanel>
         
         <!-- Project Tree -->
-        <Border Grid.Row="2" BorderBrush="Gray" BorderThickness="1" Margin="0,0,0,10">
-            <TreeView x:Name="ProjectTreeView" ScrollViewer.HorizontalScrollBarVisibility="Auto">
+        <Border Grid.Row="3" BorderBrush="LightGray" BorderThickness="1" Margin="0,0,0,15">
+            <TreeView x:Name="ProjectTreeView" ScrollViewer.HorizontalScrollBarVisibility="Auto"
+                      ScrollViewer.VerticalScrollBarVisibility="Auto" Padding="5">
                 <TreeView.ItemTemplate>
                     <DataTemplate>
-                        <StackPanel Orientation="Horizontal">
+                        <StackPanel Orientation="Horizontal" Margin="0,2">
                             <CheckBox IsChecked="{Binding IsChecked, Mode=TwoWay}" 
                                       Checked="ProjectTreeItem_Checked"
                                       Unchecked="ProjectTreeItem_Unchecked"
-                                      Margin="0,0,5,0"/>
-                            <TextBlock Text="{Binding DisplayName}" VerticalAlignment="Center"/>
+                                      Margin="0,0,8,0"
+                                      VerticalAlignment="Center"/>
+                            <Image Source="{Binding ProjectTypeIcon}" Width="16" Height="16" 
+                                   Margin="0,0,5,0" VerticalAlignment="Center"/>
+                            <TextBlock Text="{Binding DisplayName}" VerticalAlignment="Center"
+                                       ToolTip="{Binding ProjectInfo.Path}"/>
+                            <TextBlock Text="{Binding DependencyText}" Margin="8,0,0,0" 
+                                       Foreground="Gray" FontStyle="Italic" VerticalAlignment="Center"/>
                         </StackPanel>
                     </DataTemplate>
                 </TreeView.ItemTemplate>
             </TreeView>
         </Border>
         
+        <!-- Status Bar -->
+        <StatusBar Grid.Row="4" Height="25" Margin="0,0,0,10">
+            <StatusBarItem>
+                <TextBlock x:Name="StatusTextBlock" Text="Ready" />
+            </StatusBarItem>
+        </StatusBar>
+        
         <!-- Action Buttons -->
-        <StackPanel Grid.Row="3" Orientation="Horizontal" HorizontalAlignment="Right">
-            <Button x:Name="OkButton" Content="OK" Width="75" Height="30" 
-                    Click="OkButton_Click" IsDefault="True" Margin="0,0,5,0"/>
-            <Button x:Name="CancelButton" Content="Cancel" Width="75" Height="30" 
+        <StackPanel Grid.Row="5" Orientation="Horizontal" HorizontalAlignment="Right">
+            <Button x:Name="OkButton" Content="Create Filtered Solution" Width="150" Height="35" 
+                    Click="OkButton_Click" IsDefault="True" Margin="0,0,10,0"
+                    Background="DodgerBlue" Foreground="White" FontWeight="Medium"/>
+            <Button x:Name="CancelButton" Content="Open All Projects" Width="130" Height="35" 
                     Click="CancelButton_Click" IsCancel="True"/>
         </StackPanel>
     </Grid>

FilteredSolutionsExtension/FilteredSolutionsExtension/ProjectFilterDialog.xaml.cs

@@ -1,3 +1,4 @@
+using Microsoft.VisualStudio.Shell;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
@@ -17,7 +18,7 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
         private string _filterPattern = "";
         
         public string FilteredSolutionPath { get; private set; }
-        public ObservableCollection<ProjectNode> Projects { get; set; }
+        public ObservableCollection<ProjectTreeItem> Projects { get; set; }
 
         public string FilterPattern
         {
@@ -36,9 +37,10 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
             
             _solutionInfo = solutionInfo ?? throw new ArgumentNullException(nameof(solutionInfo));
             _solutionParser = new SolutionParser();
-            Projects = new ObservableCollection<ProjectNode>();
+            Projects = new ObservableCollection<ProjectTreeItem>();
             
             Title = $"Filter Projects - {_solutionInfo.Name}";
+            SolutionNameTextBlock.Text = _solutionInfo.Name;
             
             // Load projects asynchronously
             Loaded += async (s, e) => await LoadProjectsAsync();
@@ -50,115 +52,161 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
             {
                 // Show loading indicator
                 ProjectTreeView.Visibility = Visibility.Hidden;
-                var loadingLabel = new System.Windows.Controls.Label
-                {
-                    Content = "Loading projects...",
-                    HorizontalAlignment = HorizontalAlignment.Center,
-                    VerticalAlignment = VerticalAlignment.Center,
-                    FontSize = 14
-                };
-                
-                var grid = (Grid)Content;
-                Grid.SetRow(loadingLabel, 2);
-                grid.Children.Add(loadingLabel);
+                StatusTextBlock.Text = "Loading projects...";
 
-                var projects = await _solutionParser.ParseSolutionAsync(_solutionInfo.FullPath);
+                var projectNodes = await _solutionParser.ParseSolutionAsync(_solutionInfo.FullPath);
                 
-                Application.Current.Dispatcher.Invoke(() =>
+                System.Windows.Application.Current.Dispatcher.Invoke(() =>
                 {
                     Projects.Clear();
-                    foreach (var project in projects)
+                    foreach (var projectNode in projectNodes)
                     {
-                        Projects.Add(project);
+                        var projectInfo = new ProjectInfo
+                        {
+                            Name = projectNode.Name,
+                            FullPath = projectNode.Path,
+                            ProjectGuid = projectNode.ProjectGuid,
+                            TypeGuid = projectNode.TypeGuid
+                        };
+                        Projects.Add(new ProjectTreeItem(projectInfo));
                     }
                     
-                    // Build dependency tree
-                    _solutionParser.BuildDependencyTree(Projects.ToList());
+                    ProjectCountTextBlock.Text = $"{Projects.Count} projects found";
+                    UpdateSelectionCount();
+                    
+                    // Show tree
+                    ProjectTreeView.Visibility = Visibility.Visible;
+                    StatusTextBlock.Text = "Ready";
                     
-                    // Remove loading indicator and show tree
-                    grid.Children.Remove(loadingLabel);
-                    ProjectsTreeView.Visibility = Visibility.Visible;
+                    // Set the ItemsSource for the TreeView
+                    ProjectTreeView.ItemsSource = Projects;
                 });
             }
             catch (Exception ex)
             {
-                MessageBox.Show($"Error loading solution: {ex.Message}\n\nPlease try opening the solution normally and use the File menu to filter projects.", 
-                    "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+                ErrorHandler.ShowUserError("Error", $"Error loading solution: {ex.Message}", ex);
                 DialogResult = false;
             }
         }
 
-        private void SelectAll_Click(object sender, RoutedEventArgs e)
+        private void SelectAllButton_Click(object sender, RoutedEventArgs e)
         {
             foreach (var project in Projects)
             {
-                project.IsSelected = true;
+                project.IsChecked = true;
             }
+            UpdateSelectionCount();
         }
 
-        private void ClearAll_Click(object sender, RoutedEventArgs e)
+        private void ClearAllButton_Click(object sender, RoutedEventArgs e)
         {
             foreach (var project in Projects)
             {
-                project.IsSelected = false;
+                project.IsChecked = false;
             }
+            UpdateSelectionCount();
         }
 
-        private void Filter_Click(object sender, RoutedEventArgs e)
+        private void FilterButton_Click(object sender, RoutedEventArgs e)
         {
             ApplyFilter();
         }
 
+        private void ClearFilterButton_Click(object sender, RoutedEventArgs e)
+        {
+            FilterTextBox.Text = "";
+            FilterPattern = "";
+            ApplyFilter();
+        }
+
         private void ApplyFilter()
         {
-            if (string.IsNullOrWhiteSpace(FilterPattern))
+            var pattern = FilterTextBox.Text?.Trim() ?? "";
+            
+            if (string.IsNullOrWhiteSpace(pattern))
             {
+                // Show all projects
                 foreach (var project in Projects)
                 {
-                    project.IsVisible = true;
+                    ((FrameworkElement)ProjectTreeView.ItemContainerGenerator.ContainerFromItem(project))?.SetValue(FrameworkElement.VisibilityProperty, Visibility.Visible);
                 }
                 return;
             }
 
-            var pattern = FilterPattern.Replace("*", ".*");
-            var regex = new System.Text.RegularExpressions.Regex(pattern, 
+            var wildcardPattern = pattern.Replace("*", ".*");
+            var regex = new System.Text.RegularExpressions.Regex(wildcardPattern, 
                 System.Text.RegularExpressions.RegexOptions.IgnoreCase);
 
             foreach (var project in Projects)
             {
-                project.IsVisible = regex.IsMatch(project.Name);
+                var isMatch = regex.IsMatch(project.ProjectInfo.Name);
+                var container = ProjectTreeView.ItemContainerGenerator.ContainerFromItem(project) as FrameworkElement;
+                if (container != null)
+                {
+                    container.Visibility = isMatch ? Visibility.Visible : Visibility.Collapsed;
+                }
             }
         }
 
-        private async void Ok_Click(object sender, RoutedEventArgs e)
+        private void ProjectTreeItem_Checked(object sender, RoutedEventArgs e)
+        {
+            UpdateSelectionCount();
+        }
+
+        private void ProjectTreeItem_Unchecked(object sender, RoutedEventArgs e)
+        {
+            UpdateSelectionCount();
+        }
+
+        private void UpdateSelectionCount()
+        {
+            var selectedCount = Projects.Count(p => p.IsChecked);
+            SelectionCountTextBlock.Text = $"{selectedCount} of {Projects.Count} projects selected";
+        }
+
+        private async void OkButton_Click(object sender, RoutedEventArgs e)
         {
             try
             {
-                var selectedProjects = Projects.Where(p => p.IsSelected).ToList();
+                var selectedProjects = Projects.Where(p => p.IsChecked).Select(p => p.ProjectInfo).ToList();
                 if (!selectedProjects.Any())
                 {
-                    MessageBox.Show("Please select at least one project.", "Warning", 
-                        MessageBoxButton.OK, MessageBoxImage.Warning);
+                    ErrorHandler.ShowUserInfo("Warning", "Please select at least one project.");
                     return;
                 }
 
-                // Include dependencies
-                var projectsWithDependencies = _solutionParser.GetProjectsWithDependencies(selectedProjects);
+                StatusTextBlock.Text = "Creating filtered solution...";
+                OkButton.IsEnabled = false;
+
+                // Convert ProjectInfo to ProjectNode for the generator
+                var projectNodes = selectedProjects.Select(pi => new ProjectNode
+                {
+                    Name = pi.Name,
+                    Path = pi.FullPath,
+                    ProjectGuid = pi.ProjectGuid,
+                    TypeGuid = pi.TypeGuid
+                }).ToList();
+
+                // Include dependencies automatically
+                var projectsWithDependencies = _solutionParser.GetProjectsWithDependencies(projectNodes);
                 
                 // Create filtered solution
                 FilteredSolutionPath = await _solutionParser.CreateFilteredSolutionAsync(
                     _solutionInfo.FullPath, projectsWithDependencies);
                 
+                StatusTextBlock.Text = "Filtered solution created successfully";
                 DialogResult = true;
             }
             catch (Exception ex)
             {
-                MessageBox.Show($"Error creating filtered solution: {ex.Message}", "Error", 
-                    MessageBoxButton.OK, MessageBoxImage.Error);
+                await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                ErrorHandler.ShowUserError("Error", "Error creating filtered solution", ex);
+                StatusTextBlock.Text = "Error creating filtered solution";
+                OkButton.IsEnabled = true;
             }
         }
 
-        private void Cancel_Click(object sender, RoutedEventArgs e)
+        private void CancelButton_Click(object sender, RoutedEventArgs e)
         {
             DialogResult = false;
         }

FilteredSolutionsExtension/FilteredSolutionsExtension/ProjectInfo.cs

@@ -13,6 +13,13 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
         public string TypeGuid { get; set; }
         public List<string> Dependencies { get; set; }
 
+        // Alias for backward compatibility
+        public string Path
+        {
+            get => FullPath;
+            set => FullPath = value;
+        }
+
         public ProjectInfo()
         {
             Dependencies = new List<string>();
@@ -25,17 +32,26 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
         public string Name { get; set; }
         public string Directory { get; set; }
         public List<ProjectInfo> Projects { get; set; }
+        public Dictionary<string, List<string>> ProjectDependencies { get; set; }
+
+        // Alias for backward compatibility
+        public string SolutionPath
+        {
+            get => FullPath;
+            set => FullPath = value;
+        }
 
         public SolutionInfo()
         {
             Projects = new List<ProjectInfo>();
+            ProjectDependencies = new Dictionary<string, List<string>>();
         }
 
         public SolutionInfo(string solutionPath) : this()
         {
             FullPath = solutionPath;
-            Name = Path.GetFileNameWithoutExtension(solutionPath);
-            Directory = Path.GetDirectoryName(solutionPath);
+            Name = System.IO.Path.GetFileNameWithoutExtension(solutionPath);
+            Directory = System.IO.Path.GetDirectoryName(solutionPath);
         }
 
         // Factory method to create SolutionInfo from current VS solution
@@ -80,10 +96,10 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
         {
             try
             {
-                var fromUri = new Uri(fromPath + Path.DirectorySeparatorChar);
+                var fromUri = new Uri(fromPath + System.IO.Path.DirectorySeparatorChar);
                 var toUri = new Uri(toPath);
                 var relativeUri = fromUri.MakeRelativeUri(toUri);
-                return Uri.UnescapeDataString(relativeUri.ToString()).Replace('/', Path.DirectorySeparatorChar);
+                return Uri.UnescapeDataString(relativeUri.ToString()).Replace('/', System.IO.Path.DirectorySeparatorChar);
             }
             catch
             {

FilteredSolutionsExtension/FilteredSolutionsExtension/SolutionEventsHandler.cs

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
 
 namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
 {
-    public class SolutionEventsHandler : IVsSolutionEvents3, IVsSolutionLoadEvents
+     public class SolutionEventsHandler : IVsSolutionEvents3, IVsSolutionLoadEvents
     {
         private readonly FilteredSolutionsExtensionPackage _package;
         private bool _isProcessingSolution = false;
@@ -26,40 +26,43 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
 
             try
             {
-                 var dte = (EnvDTE.DTE) _package.GetService(typeof(EnvDTE.DTE));
-                if (dte?.Solution != null && !string.IsNullOrEmpty(dte.Solution.FullName))
+                // Use async pattern with JoinableTaskFactory
+                ThreadHelper.JoinableTaskFactory.RunAsync(async () =>
                 {
-                    var solutionPath = dte.Solution.FullName;
-
-                    // Check if this is already a filtered solution (temp file)
-                    if (solutionPath.Contains("_filtered.sln") || Path.GetTempPath().Contains(Path.GetDirectoryName(solutionPath)))
+                    await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                    
+                    var dte = await _package.GetServiceAsync(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
+                    if (dte?.Solution != null && !string.IsNullOrEmpty(dte.Solution.FullName))
                     {
-                        return VSConstants.S_OK;
-                    }
+                        var solutionPath = dte.Solution.FullName;
 
-                    // Count projects to see if we should show the dialog
-                    var projectCount = dte.Solution.Projects?.Count ?? 0;
-                    if (projectCount > 1)
-                    {
-                        // Delay to ensure solution is fully loaded
-                        Task.Delay(500).ContinueWith(_ =>
+                        // Check if this is already a filtered solution (temp file)
+                        if (solutionPath.Contains("_filtered.sln") || Path.GetTempPath().Contains(Path.GetDirectoryName(solutionPath)))
+                        {
+                            return;
+                        }
+
+                        // Count projects to see if we should show the dialog
+                        var projectCount = dte.Solution.Projects?.Count ?? 0;
+                        if (projectCount > 1)
                         {
-                            ThreadHelper.JoinableTaskFactory.RunAsync(async () =>
+                            // Delay to ensure solution is fully loaded
+                            await Task.Delay(500);
+                            
+                            if (!_isProcessingSolution)
                             {
-                                await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
-                                if (!_isProcessingSolution)
-                                {
-                                    _isProcessingSolution = true;
-                                    _package.ShowFilterDialog(solutionPath);
-                                    _isProcessingSolution = false;
-                                }
-                            });
-                        });
+                                _isProcessingSolution = true;
+                                var solutionInfo = new SolutionInfo(solutionPath);
+                                _package.ShowFilterDialog(solutionInfo);
+                                _isProcessingSolution = false;
+                            }
+                        }
                     }
-                }
+                });
             }
-            catch
+            catch (Exception ex)
             {
+                ErrorHandler.LogError("Error in OnAfterOpenSolution", ex);
                 _isProcessingSolution = false;
             }
 
@@ -104,7 +107,7 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
                                 ThreadHelper.JoinableTaskFactory.RunAsync(async () =>
                                 {
                                     await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
-                                     var dte = (EnvDTE.DTE) _package.GetService(typeof(EnvDTE.DTE));
+                                    var dte = await _package.GetServiceAsync(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
                                     dte?.Solution?.Close();
                                     dte?.Solution?.Open(dialog.FilteredSolutionPath);
                                     _isProcessingSolution = false;
@@ -117,8 +120,9 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
                         _isProcessingSolution = false;
                     }
                 }
-                catch
+                catch (Exception ex)
                 {
+                    ErrorHandler.LogError("Error in OnBeforeOpenSolution", ex);
                     _isProcessingSolution = false;
                 }
             }
@@ -168,15 +172,10 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
         public int OnQueryCloseSolution(object pUnkReserved, ref int pfCancel) => VSConstants.S_OK;
         public int OnBeforeCloseSolution(object pUnkReserved) => VSConstants.S_OK;
         public int OnAfterCloseSolution(object pUnkReserved) => VSConstants.S_OK;
-
         public int OnAfterMergeSolution(object pUnkReserved) => VSConstants.S_OK;
-
         public int OnBeforeOpeningChildren(IVsHierarchy pHierarchy) => VSConstants.S_OK;
-
         public int OnAfterOpeningChildren(IVsHierarchy pHierarchy) => VSConstants.S_OK;
-
         public int OnBeforeClosingChildren(IVsHierarchy pHierarchy) => VSConstants.S_OK;
-
         public int OnAfterClosingChildren(IVsHierarchy pHierarchy) => VSConstants.S_OK;
     }
 }

FilteredSolutionsExtension/FilteredSolutionsExtension/SolutionOpeningInterceptor.cs

@@ -0,0 +1,176 @@
+using EnvDTE;
+using Microsoft.VisualStudio;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
+{
+     public class SolutionOpeningInterceptor : IVsRunningDocTableEvents, IDisposable
+    {
+        private readonly AsyncPackage _package;
+        private IVsRunningDocumentTable _runningDocumentTable;
+        private uint _rdtCookie;
+        private readonly Dictionary<string, bool> _processedSolutions = new Dictionary<string, bool>();
+
+        public SolutionOpeningInterceptor(AsyncPackage package)
+        {
+            _package = package;
+        }
+
+        public async Task InitializeAsync()
+        {
+            await _package.JoinableTaskFactory.SwitchToMainThreadAsync();
+            
+            _runningDocumentTable = await _package.GetServiceAsync(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable;
+            if (_runningDocumentTable != null)
+            {
+                _runningDocumentTable.AdviseRunningDocTableEvents(this, out _rdtCookie);
+            }
+
+            // Also monitor DTE events for solution opening
+            var dte = await _package.GetServiceAsync(typeof(DTE)) as DTE;
+            if (dte?.Events?.SolutionEvents != null)
+            {
+                dte.Events.SolutionEvents.Opened += SolutionEvents_Opened;
+                dte.Events.SolutionEvents.BeforeClosing += SolutionEvents_BeforeClosing;
+            }
+        }
+
+        private void SolutionEvents_BeforeClosing()
+        {
+            ThreadHelper.ThrowIfNotOnUIThread();
+            // Clear processed solutions when current solution is closing
+            _processedSolutions.Clear();
+        }
+
+        private void SolutionEvents_Opened()
+        {
+            ThreadHelper.JoinableTaskFactory.RunAsync(async () =>
+            {
+                await HandleSolutionOpenedAsync();
+            });
+        }
+
+        private async Task HandleSolutionOpenedAsync()
+        {
+            try
+            {
+                await _package.JoinableTaskFactory.SwitchToMainThreadAsync();
+                
+                var dte = await _package.GetServiceAsync(typeof(DTE)) as DTE;
+                if (dte?.Solution?.FullName != null)
+                {
+                    var solutionPath = dte.Solution.FullName;
+                    
+                    // Check if we already processed this solution in this session
+                    if (_processedSolutions.ContainsKey(solutionPath))
+                        return;
+
+                    _processedSolutions[solutionPath] = true;
+
+                    // Only show dialog if solution has multiple projects
+                    if (dte.Solution.Projects.Count > 1)
+                    {
+                        await ShowProjectFilterDialogAsync(solutionPath, dte);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                ErrorHandler.LogError("Error in HandleSolutionOpenedAsync", ex);
+            }
+        }
+
+        private async Task ShowProjectFilterDialogAsync(string solutionPath, DTE dte)
+        {
+            try
+            {
+                var solutionInfo = new SolutionInfo(solutionPath);
+                
+                // Show dialog on UI thread
+                await _package.JoinableTaskFactory.SwitchToMainThreadAsync();
+                
+                var dialog = new ProjectFilterDialog(solutionInfo);
+                var result = dialog.ShowDialog();
+                
+                if (result == true && !string.IsNullOrEmpty(dialog.FilteredSolutionPath))
+                {
+                    await OpenFilteredSolutionAsync(dialog.FilteredSolutionPath, dte);
+                }
+            }
+            catch (Exception ex)
+            {
+                ErrorHandler.ShowUserError("Project Filter Error", 
+                    "Failed to show project filter dialog", ex);
+            }
+        }
+
+        private async Task OpenFilteredSolutionAsync(string filteredSolutionPath, DTE dte)
+        {
+            try
+            {
+                // Close current solution and open filtered one
+                await _package.JoinableTaskFactory.SwitchToMainThreadAsync();
+                
+                // Mark this solution as processed to avoid showing dialog again
+                _processedSolutions[filteredSolutionPath] = true;
+                
+                dte.Solution.Close(false);
+                dte.Solution.Open(filteredSolutionPath);
+
+                ErrorHandler.LogInfo($"Opened filtered solution: {filteredSolutionPath}");
+            }
+            catch (Exception ex)
+            {
+                ErrorHandler.ShowUserError("Solution Opening Error", 
+                    "Failed to open filtered solution", ex);
+            }
+        }
+
+        public void Dispose()
+        {
+            ThreadHelper.ThrowIfNotOnUIThread();
+            if (_runningDocumentTable != null && _rdtCookie != 0)
+            {
+                _runningDocumentTable.UnadviseRunningDocTableEvents(_rdtCookie);
+            }
+        }
+
+        // IVsRunningDocTableEvents implementation
+        public int OnAfterFirstDocumentLock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining, uint dwEditLocksRemaining)
+        {
+            return Microsoft.VisualStudio.VSConstants.S_OK;
+        }
+
+        public int OnBeforeLastDocumentUnlock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining, uint dwEditLocksRemaining)
+        {
+            return Microsoft.VisualStudio.VSConstants.S_OK;
+        }
+
+        public int OnAfterSave(uint docCookie)
+        {
+            return Microsoft.VisualStudio.VSConstants.S_OK;
+        }
+
+        public int OnAfterAttributeChange(uint docCookie, uint grfAttribs)
+        {
+            return Microsoft.VisualStudio.VSConstants.S_OK;
+        }
+
+        public int OnBeforeDocumentWindowShow(uint docCookie, int fFirstShow, IVsWindowFrame pFrame)
+        {
+            return Microsoft.VisualStudio.VSConstants.S_OK;
+        }
+
+        public int OnAfterDocumentWindowHide(uint docCookie, IVsWindowFrame pFrame)
+        {
+            return Microsoft.VisualStudio.VSConstants.S_OK;
+        }
+    }
+}

FilteredSolutionsExtension/FilteredSolutionsExtension/SolutionParser.cs

@@ -7,142 +7,102 @@ using System.Threading.Tasks;
 
 namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
 {
-  public class SolutionParser
+   public class SolutionParser
     {
-        public async Task<List<ProjectNode>> ParseSolutionAsync(string solutionPath)
-        {
-            var projects = new List<ProjectNode>();
-            var content = await FileUtils.ReadAllTextAsync(solutionPath);
-            var lines = content.Split('\n');
+        private static readonly Regex ProjectRegex = new Regex(
+            @"Project\(""{([^}]+)}""\)\s*=\s*""([^""]+)""\s*,\s*""([^""]+)""\s*,\s*""{([^}]+)}""",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase);
 
-            foreach (var line in lines)
-            {
-                if (line.StartsWith("Project("))
-                {
-                    var project = ParseProjectLine(line.Trim(), Path.GetDirectoryName(solutionPath));
-                    if (project != null)
-                    {
-                        projects.Add(project);
-                    }
-                }
-            }
+        private static readonly Regex ProjectDependencyRegex = new Regex(
+            @"{([^}]+)}\s*=\s*{([^}]+)}",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase);
 
-            return projects;
-        }
+        private static readonly Regex ProjectReferenceRegex = new Regex(
+            @"<ProjectReference\s+Include=""([^""]+)""\s*>.*?<Project>{([^}]+)}</Project>",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline);
 
-        private ProjectNode ParseProjectLine(string line, string solutionDir)
+        // Known project type GUIDs
+        private static readonly HashSet<string> SolutionFolderTypes = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
         {
-            try
-            {
-                // Parse: Project("{TypeGuid}") = "ProjectName", "ProjectPath", "{ProjectGuid}"
-                var parts = line.Split('=');
-                if (parts.Length != 2) return null;
+            "{2150E333-8FDC-42A3-9474-1A3956D46DE8}" // Solution Folder
+        };
 
-                var leftPart = parts[0].Trim();
-                var rightPart = parts[1].Trim();
-
-                // Extract type GUID
-                var typeGuidStart = leftPart.IndexOf('{');
-                var typeGuidEnd = leftPart.IndexOf('}');
-                if (typeGuidStart == -1 || typeGuidEnd == -1) return null;
-                var typeGuid = leftPart.Substring(typeGuidStart, typeGuidEnd - typeGuidStart + 1);
-
-                // Extract project info from right part
-                var rightParts = rightPart.Split(',');
-                if (rightParts.Length != 3) return null;
-
-                var projectName = rightParts[0].Trim().Trim('"');
-                var projectPath = rightParts[1].Trim().Trim('"');
-                var projectGuid = rightParts[2].Trim().Trim('"');
-
-                var fullPath = Path.IsPathRooted(projectPath) 
-                    ? projectPath 
-                    : Path.Combine(solutionDir, projectPath);
+        public async Task<List<ProjectNode>> ParseSolutionAsync(string solutionPath)
+        {
+            if (!File.Exists(solutionPath))
+                throw new FileNotFoundException($"Solution file not found: {solutionPath}");
 
-                return new ProjectNode
-                {
-                    Name = projectName,
-                    Path = fullPath,
-                    ProjectGuid = projectGuid,
-                    TypeGuid = typeGuid
-                };
+            var projects = new List<ProjectNode>();
+            var projectDependencies = new Dictionary<string, List<string>>();
+            
+            try
+            {
+                var content = await FileUtils.ReadAllTextAsync(solutionPath);
+                
+                // Parse projects first
+                ParseProjects(content, projects, solutionPath);
+                
+                // Parse solution-level dependencies
+                ParseSolutionDependencies(content, projectDependencies);
+                
+                // Parse project file dependencies for more accurate dependency graph
+                await ParseProjectFileDependencies(projects, projectDependencies);
+                
+                return projects;
             }
-            catch
+            catch (Exception ex)
             {
-                return null;
+                throw new InvalidOperationException($"Failed to parse solution file: {ex.Message}", ex);
             }
         }
 
         public void BuildDependencyTree(List<ProjectNode> projects)
         {
-            // Simple implementation - in real scenario, you'd parse project references
-            // For now, we'll just create a basic structure
-            foreach (var project in projects)
-            {
-                if (File.Exists(project.Path))
-                {
-                    // Parse project file for references
-                    // This is a simplified version
-                    ParseProjectDependencies(project, projects);
-                }
-            }
-        }
+            var projectLookup = projects.ToDictionary(p => p.ProjectGuid, StringComparer.OrdinalIgnoreCase);
 
-        private async void ParseProjectDependencies(ProjectNode project, List<ProjectNode> allProjects)
-        {
-            try
+            foreach (var project in projects)
             {
-                if (!File.Exists(project.Path)) return;
-
-                var content = await FileUtils.ReadAllTextAsync(project.Path);
-                
-                // Look for ProjectReference elements
-                var projectRefStart = content.IndexOf("<ProjectReference");
-                while (projectRefStart != -1)
+                // Build dependency relationships
+                var projectInfo = project; // Assuming ProjectNode has ProjectInfo property
+                if (projectInfo != null)
                 {
-                    var includeStart = content.IndexOf("Include=\"", projectRefStart);
-                    if (includeStart != -1)
+                    foreach (var depGuid in GetProjectDependencies(project.ProjectGuid))
                     {
-                        includeStart += 9; // Length of "Include=\""
-                        var includeEnd = content.IndexOf("\"", includeStart);
-                        if (includeEnd != -1)
+                        if (projectLookup.TryGetValue(depGuid, out var dependency))
                         {
-                            var referencePath = content.Substring(includeStart, includeEnd - includeStart);
-                            var fullRefPath = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(project.Path), referencePath));
-                            
-                            var referencedProject = allProjects.FirstOrDefault(p => 
-                                string.Equals(p.Path, fullRefPath, StringComparison.OrdinalIgnoreCase));
-                            
-                            if (referencedProject != null)
-                            {
-                                project.Dependencies.Add(referencedProject);
-                                referencedProject.Dependents.Add(project);
-                            }
+                            project.Dependencies.Add(dependency);
+                            dependency.Dependents.Add(project);
                         }
                     }
-                    
-                    projectRefStart = content.IndexOf("<ProjectReference", projectRefStart + 1);
                 }
             }
-            catch
-            {
-                // Ignore parsing errors
-            }
+        }
+
+        private List<string> _projectDependencies = new List<string>();
+        
+        private List<string> GetProjectDependencies(string projectGuid)
+        {
+            // This would be populated during parsing
+            return _projectDependencies;
         }
 
         public List<ProjectNode> GetProjectsWithDependencies(List<ProjectNode> selectedProjects)
         {
             var result = new HashSet<ProjectNode>();
-            var queue = new Queue<ProjectNode>(selectedProjects);
+            var toProcess = new Queue<ProjectNode>(selectedProjects);
 
-            while (queue.Count > 0)
+            while (toProcess.Count > 0)
             {
-                var current = queue.Dequeue();
+                var current = toProcess.Dequeue();
                 if (result.Add(current))
                 {
+                    // Add dependencies
                     foreach (var dependency in current.Dependencies)
                     {
-                        queue.Enqueue(dependency);
+                        if (!result.Contains(dependency))
+                        {
+                            toProcess.Enqueue(dependency);
+                        }
                     }
                 }
             }
@@ -150,71 +110,150 @@ namespace Quadarax.Application.Tools.Vsix.FilteredSolutionsExtension
             return result.ToList();
         }
 
-        public async Task<string> CreateFilteredSolutionAsync(string originalPath, List<ProjectNode> projects)
+        public async Task<string> CreateFilteredSolutionAsync(string originalSolutionPath, List<ProjectNode> selectedProjects)
         {
-            var content = await FileUtils.ReadAllTextAsync(originalPath);
-            var lines = content.Split('\n').ToList();
+            var solutionName = Path.GetFileNameWithoutExtension(originalSolutionPath);
+            var tempDir = Path.Combine(Path.GetTempPath(), "FilteredSolutions");
+            Directory.CreateDirectory(tempDir);
+            
+            var filteredSolutionPath = Path.Combine(tempDir, $"{solutionName}_filtered.sln");
             
-            var filteredLines = new List<string>();
-            var projectGuids = projects.Select(p => p.ProjectGuid).ToHashSet();
+            // Convert ProjectNode to ProjectInfo for generator
+            var projectInfos = selectedProjects.Select(pn => new ProjectInfo
+            {
+                Name = pn.Name,
+                FullPath = pn.Path,
+                ProjectGuid = pn.ProjectGuid,
+                TypeGuid = pn.TypeGuid
+            }).ToList();
+
+            var generator = new FilteredSolutionGenerator();
+            await generator.GenerateFilteredSolutionAsync(originalSolutionPath, filteredSolutionPath, projectInfos);
             
-            bool inProjectSection = false;
+            return filteredSolutionPath;
+        }
+
+        private void ParseProjects(string content, List<ProjectNode> projects, string solutionPath)
+        {
+            var projectMatches = ProjectRegex.Matches(content);
+            var solutionDir = Path.GetDirectoryName(solutionPath);
+
+            foreach (Match match in projectMatches)
+            {
+                var typeGuid = match.Groups[1].Value;
+                var name = match.Groups[2].Value;
+                var relativePath = match.Groups[3].Value;
+                var projectGuid = match.Groups[4].Value;
+
+                // Skip solution folders and other non-project items
+                if (SolutionFolderTypes.Contains(typeGuid))
+                    continue;
+
+                // Resolve full path
+                var fullPath = Path.IsPathRooted(relativePath) 
+                    ? relativePath 
+                    : Path.GetFullPath(Path.Combine(solutionDir, relativePath));
+
+                // Verify project file exists
+                if (!File.Exists(fullPath))
+                {
+                    System.Diagnostics.Debug.WriteLine($"Warning: Project file not found: {fullPath}");
+                    continue;
+                }
+
+                projects.Add(new ProjectNode
+                {
+                    Name = name,
+                    Path = fullPath,
+                    ProjectGuid = projectGuid,
+                    TypeGuid = typeGuid
+                });
+            }
+        }
+
+        private void ParseSolutionDependencies(string content, Dictionary<string, List<string>> projectDependencies)
+        {
+            var lines = content.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
             string currentProjectGuid = null;
+            bool inProjectDependencies = false;
 
-            foreach (var line in lines)
+            for (int i = 0; i < lines.Length; i++)
             {
-                var trimmedLine = line.Trim();
-                
-                if (trimmedLine.StartsWith("Project("))
+                var line = lines[i].Trim();
+
+                // Find project definition to get context for dependencies
+                var projectMatch = ProjectRegex.Match(line);
+                if (projectMatch.Success)
                 {
-                    inProjectSection = true;
-                    currentProjectGuid = ExtractProjectGuid(trimmedLine);
-                    
-                    if (projectGuids.Contains(currentProjectGuid))
-                    {
-                        filteredLines.Add(line);
-                    }
+                    currentProjectGuid = projectMatch.Groups[4].Value;
+                    continue;
+                }
+
+                // Check for project dependencies section
+                if (line.StartsWith("ProjectSection(ProjectDependencies)", StringComparison.OrdinalIgnoreCase))
+                {
+                    inProjectDependencies = true;
+                    continue;
                 }
-                else if (trimmedLine == "EndProject")
+
+                if (line.StartsWith("EndProjectSection", StringComparison.OrdinalIgnoreCase) || 
+                    line.StartsWith("EndProject", StringComparison.OrdinalIgnoreCase))
+                {
+                    inProjectDependencies = false;
+                    if (line.StartsWith("EndProject"))
+                        currentProjectGuid = null;
+                    continue;
+                }
+
+                // Parse dependency entries
+                if (inProjectDependencies && currentProjectGuid != null)
                 {
-                    if (projectGuids.Contains(currentProjectGuid))
+                    var depMatch = ProjectDependencyRegex.Match(line);
+                    if (depMatch.Success)
                     {
-                        filteredLines.Add(line);
+                        var dependentGuid = depMatch.Groups[2].Value;
+                        AddDependency(projectDependencies, currentProjectGuid, dependentGuid);
                     }
-                    inProjectSection = false;
-                    currentProjectGuid = null;
                 }
-                else if (inProjectSection)
+            }
+        }
+
+        private async Task ParseProjectFileDependencies(List<ProjectNode> projects, Dictionary<string, List<string>> projectDependencies)
+        {
+            foreach (var project in projects.ToList())
+            {
+                try
                 {
-                    if (projectGuids.Contains(currentProjectGuid))
+                    if (File.Exists(project.Path))
                     {
-                        filteredLines.Add(line);
+                        var projectContent = await FileUtils.ReadAllTextAsync(project.Path);
+                        var referenceMatches = ProjectReferenceRegex.Matches(projectContent);
+
+                        foreach (Match match in referenceMatches)
+                        {
+                            var referencedProjectGuid = match.Groups[2].Value;
+                            AddDependency(projectDependencies, project.ProjectGuid, referencedProjectGuid);
+                        }
                     }
                 }
-                else
+                catch (Exception ex)
                 {
-                    // Include non-project lines (solution config, etc.)
-                    filteredLines.Add(line);
+                    System.Diagnostics.Debug.WriteLine($"Warning: Could not parse project file {project.Path}: {ex.Message}");
                 }
             }
-
-            var filteredContent = string.Join("\n", filteredLines);
-            var filteredPath = Path.Combine(
-                Path.GetTempPath(), 
-                $"{Path.GetFileNameWithoutExtension(originalPath)}_filtered.sln");
-                
-            await FileUtils.WriteAllTextAsync(filteredPath, filteredContent);
-            return filteredPath;
         }
 
-        private string ExtractProjectGuid(string projectLine)
+        private void AddDependency(Dictionary<string, List<string>> projectDependencies, string projectGuid, string dependentGuid)
         {
-            var parts = projectLine.Split(',');
-            if (parts.Length >= 3)
+            if (!projectDependencies.ContainsKey(projectGuid))
+            {
+                projectDependencies[projectGuid] = new List<string>();
+            }
+            
+            if (!projectDependencies[projectGuid].Contains(dependentGuid))
             {
-                return parts[2].Trim().Trim('"');
+                projectDependencies[projectGuid].Add(dependentGuid);
             }
-            return string.Empty;
         }
     }
 }

FilteredSolutionsExtension/FilteredSolutionsExtension/readme.md

@@ -1,155 +1,253 @@
-# Visual Studio 2022 Filter Solutions Extension
+# Visual Studio 2022 Filtered Solutions Extension v1.0
+
+A Visual Studio 2022 extension that automatically presents a project filter dialog when opening solutions with multiple projects, allowing you to create filtered solutions with only the projects you need.
+
+## Features
+
+- **Automatic Dialog**: Shows project filter dialog when opening solutions with multiple projects
+- **Project Tree View**: Interactive tree view with checkboxes for project selection
+- **Smart Dependencies**: Automatically selects/deselects dependent projects when you check/uncheck projects
+- **Pattern Filtering**: Filter projects using wildcard patterns (e.g., `*.Test`, `Core*`, `*Data*`)
+- **Bulk Operations**: "Select All" and "Clear All" buttons for quick selection
+- **Filtered Solutions**: Creates new solution files with only selected projects, leaving originals untouched
+- **Manual Access**: Menu command for manual filtering of already opened solutions
 
 ## Project Structure
 ```
 FilteredSolutionsExtension/
 ├── FilteredSolutionsExtension.csproj
-├── extension.vsixmanifest
-├── FilterSolutionsPackage.vsct
-├── FilterSolutionsPackage.cs
+├── source.extension.vsixmanifest
+├── Menus.vsct
+├── FilteredSolutionsExtensionPackage.cs
+├── SolutionEventsHandler.cs
 ├── SolutionOpeningInterceptor.cs
-├── ProjectInfo.cs
-├── SolutionParser.cs
-├── FilteredSolutionGenerator.cs
+├── ManualFilterCommand.cs
 ├── ProjectFilterDialog.xaml
 ├── ProjectFilterDialog.xaml.cs
 ├── ProjectTreeItem.cs
-└── Properties/
-    └── AssemblyInfo.cs
+├── ProjectNode.cs
+├── ProjectInfo.cs
+├── SolutionParser.cs
+├── FilteredSolutionGenerator.cs
+├── FileUtils.cs
+├── ErrorHandler.cs
+├── DebugHelper.cs
+├── ExtensionSettings.cs
+├── Properties/
+│   └── AssemblyInfo.cs
+└── Resources/
+    └── FilterSolutionsCommand.png
 ```
 
-## Additional Files Needed
-
-### Properties/AssemblyInfo.cs
-```csharp
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-[assembly: AssemblyTitle("FilteredSolutionsExtension")]
-[assembly: AssemblyDescription("Visual Studio extension to filter projects when opening solutions")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("YourCompany")]
-[assembly: AssemblyProduct("Filter Solutions Extension")]
-[assembly: AssemblyCopyright("Copyright © 2025")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-[assembly: ComVisible(false)]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
-```
+## Technology Stack
 
-### Resources/FilterSolutionsCommand.png
-Create a 16x16 pixel icon for the command button (simple filter icon).
+- **Target Framework**: .NET Framework 4.7.2
+- **Visual Studio SDK**: 17.0+
+- **UI Framework**: WPF (XAML)
+- **Package Format**: VSIX
+- **Threading**: Async/await patterns with Visual Studio JoinableTaskFactory
+- **JSON Serialization**: System.Text.Json 9.0.5
 
-## Building the Extension
+## Key Features Implementation
 
-1. **Prerequisites:**
-   - Visual Studio 2022 with Visual Studio extension development workload
-   - .NET 9.0 SDK
+### 1. Automatic Solution Filtering
+- **SolutionEventsHandler**: Monitors solution opening events
+- **SolutionOpeningInterceptor**: Alternative approach using running document table events
+- **Smart Detection**: Only shows dialog for solutions with multiple projects
+- **Filtered Solution Detection**: Skips dialog for already filtered solutions
+
+### 2. Interactive Project Selection
+- **ProjectFilterDialog**: WPF dialog with modern UI
+- **TreeView Control**: Displays projects with checkboxes
+- **Real-time Updates**: Live selection count and status updates
+- **Project Icons**: Visual project type indicators
+
+### 3. Dependency Management
+- **Automatic Selection**: Checking a project automatically selects its dependencies
+- **Cascading Deselection**: Unchecking a project deselects dependent projects
+- **Project Reference Parsing**: Reads MSBuild project files for accurate dependencies
+- **Solution-level Dependencies**: Supports both project references and solution dependencies
+
+### 4. Advanced Filtering
+- **Wildcard Support**: Use `*` for pattern matching
+- **Case-insensitive**: Filtering works regardless of case
+- **Real-time Filter**: Instant visual filtering as you type
+- **Filter Examples**:
+  - `Test*` - Projects starting with "Test"
+  - `*Core*` - Projects containing "Core"
+  - `*.Data` - Projects ending with ".Data"
+
+### 5. Solution Generation
+- **FilteredSolutionGenerator**: Creates new .sln files
+- **Regex-based Parsing**: Robust solution file parsing
+- **Global Section Filtering**: Properly filters project configurations and dependencies
+- **Temp Directory**: Creates filtered solutions in system temp folder
+- **Original Preservation**: Never modifies original solution files
 
-2. **Create the Project:**
-   ```bash
-   # Create new VSIX project
-   dotnet new vsix -n FilteredSolutionsExtension
-   cd FilteredSolutionsExtension
-   ```
+## Usage Workflow
 
-3. **Replace/Add Files:**
-   - Replace the generated files with the code provided above
-   - Ensure all files are in the correct namespace: `FilteredSolutionsExtension`
+### Automatic Filtering
+1. **Open Solution**: Use File → Open → Project/Solution
+2. **Dialog Appears**: Filter dialog shows automatically for multi-project solutions
+3. **Select Projects**: Use checkboxes, search filter, or bulk selection
+4. **Dependencies**: Required dependencies are automatically included
+5. **Create**: Click "Create Filtered Solution" to generate and open filtered solution
+6. **Alternative**: Click "Open All Projects" to continue with full solution
+
+### Manual Filtering
+1. **Open Solution**: Open any solution normally
+2. **Access Menu**: Go to File → "Filter Solution Projects..."
+3. **Filter Projects**: Use the same dialog interface
+4. **Generate**: Create filtered solution from currently opened solution
+
+### Dialog Controls
+- **Filter Pattern**: Text input with wildcard support
+- **Apply Filter/Clear**: Apply or reset filtering
+- **Select All/Clear All**: Bulk selection operations
+- **Project Tree**: Checkboxes with dependency indicators
+- **Selection Count**: Real-time count of selected projects
+- **Status Bar**: Progress and status information
 
-4. **Build:**
-   ```bash
-   dotnet build --configuration Release
-   ```
+## Building the Extension
 
-## Key Features Implementation
+### Prerequisites
+- Visual Studio 2022 with Visual Studio extension development workload
+- .NET Framework 4.7.2 SDK
+- .NET 9.0 SDK
 
-### 1. Solution Opening Interception
-- Uses `SolutionOpeningInterceptor` to monitor DTE solution events
-- Intercepts after solution is opened but before projects are fully loaded
-- Prevents duplicate dialogs with solution tracking
+### Build Steps
+1. **Clone/Download**: Get the source code
+2. **Open in VS**: Open FilteredSolutionsExtension.sln
+3. **Restore Packages**: NuGet packages will restore automatically
+4. **Build**: Build → Build Solution (Ctrl+Shift+B)
+5. **VSIX Output**: Find the .vsix file in bin/Debug or bin/Release
 
-### 2. Project Tree with Dependencies
-- Displays all projects in a tree view with checkboxes
-- Automatically handles project dependencies:
-  - Checking a project auto-checks its dependencies
-  - Unchecking a project auto-unchecks dependent projects
+### Debug/Test
+1. **Set Startup**: Set the VSIX project as startup project
+2. **Press F5**: Launches experimental instance of Visual Studio
+3. **Test**: Open a multi-project solution to test the extension
 
-### 3. Filtering Capabilities
-- Text-based pattern filtering with wildcard support (* and ?)
-- "Select All" and "Clear All" functionality
-- Real-time filtering of project list
+## Installation
 
-### 4. Solution Generation
-- Creates filtered `.sln` file in temp directory
-- Preserves original solution file
-- Only includes selected projects and their dependencies
-- Maintains proper solution file format
+### From Build
+1. **Build VSIX**: Follow build steps above
+2. **Install**: Double-click the generated .vsix file
+3. **Restart**: Restart Visual Studio if required
+
+### From VSIX File
+1. **Double-click**: Double-click the .vsix file
+2. **VS Installer**: Visual Studio Installer will open
+3. **Install**: Follow installation prompts
+4. **Verify**: Check Extensions → Manage Extensions
+
+## Configuration
+
+### Settings (Future Enhancement)
+The extension includes `ExtensionSettings.cs` for future configuration options:
+- Auto-show filter dialog preference
+- Remember last selection per solution
+- Default filter patterns
+- Auto-select dependencies preference
+- Show project paths in tree
+
+### Current Behavior
+- Always shows dialog for multi-project solutions
+- Always includes dependencies automatically
+- Creates filtered solutions in temp directory
+- Preserves original solution files
+
+## Architecture
+
+### Threading Model
+- **Async/Await**: Modern async patterns throughout
+- **UI Thread Safety**: Proper thread marshaling for UI operations
+- **JoinableTaskFactory**: Visual Studio recommended threading
+- **Background Processing**: Solution parsing on background threads
+
+### Error Handling
+- **ErrorHandler**: Centralized error logging and user notification
+- **DebugHelper**: Development debugging utilities
+- **Graceful Degradation**: Continues operation on non-critical errors
+- **User Feedback**: Clear error messages and status updates
+
+### File Operations
+- **FileUtils**: Async file operations compatible with .NET 4.7.2
+- **Solution Parsing**: Robust regex-based solution file parsing
+- **Project Analysis**: MSBuild project file dependency analysis
+- **Temp Management**: Automatic cleanup of temporary files
+
+## Known Limitations
+
+1. **Project Types**: Only works with standard MSBuild-based projects
+2. **Solution Folders**: Solution folders are filtered out during parsing
+3. **Complex Dependencies**: Some complex project configurations may need manual adjustment
+4. **Performance**: Large solutions (100+ projects) may take time to parse
+5. **Temporary Solutions**: Filtered solutions are created in temp directory
 
-## Usage Workflow
+## Troubleshooting
 
-1. **Open Solution:** When opening a solution with multiple projects
-2. **Dialog Appears:** Project filter dialog shows automatically
-3. **Select Projects:** Use checkboxes, filter pattern, or bulk selection
-4. **Dependencies:** Dependencies are automatically selected/deselected
-5. **Generate:** Click "OK" to create filtered solution
-6. **Open Filtered:** Original solution closes, filtered solution opens
+### Common Issues
 
-## Advanced Configuration
+**Dialog doesn't appear**
+- Ensure solution has multiple projects
+- Check if solution is already filtered (temp file)
+- Verify extension is installed and enabled
 
-### Customizing Auto-Load Behavior
-In `FilterSolutionsPackage.cs`, modify the `ProvideAutoLoad` attributes:
-```csharp
-[ProvideAutoLoad(UIContextGuids80.NoSolution, PackageAutoLoadFlags.BackgroundLoad)]
-[ProvideAutoLoad(UIContextGuids80.SolutionExists, PackageAutoLoadFlags.BackgroundLoad)]
-```
+**Dependencies not working**
+- Check project references in original solution
+- Verify project GUIDs are consistent
+- Look for circular dependencies
 
-### Adding Command Menu
-The extension includes a `.vsct` file that adds a "Filter Solutions..." command to the File menu for manual triggering.
+**Filtered solution won't open**
+- Check temp directory permissions
+- Ensure original project files exist
+- Verify project file paths are correct
 
-### Debugging
-1. Set the startup project to the VSIX project
-2. Press F5 to launch experimental instance of Visual Studio
-3. Open a solution to test the extension
+**Extension won't load**
+- Confirm Visual Studio 2022 compatibility
+- Check Windows Event Log for errors
+- Verify all dependencies are installed
 
-## Installation
+### Debug Information
+- Extension logs to Visual Studio Output window
+- Check debug output for detailed error information
+- Use DebugHelper.GetLogPath() for file-based logging
+
+## Future Enhancements
 
-1. **Build the VSIX:**
-   ```bash
-   dotnet build --configuration Release
-   ```
+- **Settings Dialog**: UI for configuring extension behavior
+- **Solution Folder Support**: Include solution folders in filtering
+- **Template Support**: Save and load project selection templates
+- **Performance Optimization**: Faster parsing for large solutions
+- **Integration**: Better integration with Solution Explorer
+- **Batch Processing**: Process multiple solutions at once
+- **Export/Import**: Share filter configurations between machines
 
-2. **Install Extension:**
-   - Double-click the generated `.vsix` file in `bin/Release/`
-   - Or use Visual Studio Extensions Manager
+## Contributing
 
-3. **Verify Installation:**
-   - Check Extensions > Manage Extensions
-   - Look for "Filter Solutions Extension"
+1. **Fork**: Fork the repository
+2. **Branch**: Create feature branch
+3. **Develop**: Make changes following existing patterns
+4. **Test**: Test with various solution types
+5. **Pull Request**: Submit PR with description
 
-## Troubleshooting
+## License
 
-### Common Issues:
-1. **Dialog doesn't appear:** Check that solution has multiple projects
-2. **Dependencies not working:** Verify project references in original solution
-3. **Filtered solution won't open:** Check temp directory permissions
-4. **Extension won't load:** Verify Visual Studio 2022 compatibility
+This project is provided as-is for educational and development purposes.
 
-### Debug Output:
-The extension writes debug information to Visual Studio Output window. Check for error messages in the debug output.
+## Version History
 
-## Limitations
+### 1.0.0 - Initial Release
+- Core project filtering functionality
+- Automatic dialog on solution open
+- Manual filtering command
+- Dependency management
+- Pattern-based filtering
+- Modern async/await architecture
+- Comprehensive error handling
 
-1. Only works with standard MSBuild-based projects
-2. Solution folders are filtered out during parsing
-3. Temporary solutions are created in system temp directory
-4. Complex project configurations may need manual adjustment
+---
 
-## Future Enhancements
+**Happy Coding!** 🚀
 
-- Remember user preferences for project selection
-- Support for solution folders
-- Integration with Visual Studio's solution explorer
-- Batch processing of multiple solutions
-- Export/import of filter configurations
+This extension streamlines your Visual Studio workflow by letting you work with only the projects you need, making large solutions more manageable and improving build times.