refactor: Begin Repository.cs restructuring with partial class and interface

- Create IRepositoryService interface to define repository contract
- Convert Repository class to partial class for future splitting
- Add comprehensive refactoring plan document
- Prepare foundation for extracting repository operations into separate files

This is the first step in breaking down the 2549-line Repository.cs file
into more manageable, focused partial class files following SOLID principles.

Author: biancode

REFACTORING_PLAN.md

@@ -0,0 +1,102 @@
+# Repository.cs Refactoring Plan
+
+## Current State
+- Repository.cs has 2549 lines of code
+- Successfully converted to partial class
+- Build is working
+
+## Refactoring Strategy
+
+### Phase 1: Preparation ✅ COMPLETED
+- [x] Create IRepositoryService interface
+- [x] Convert Repository.cs to partial class declaration
+- [x] Ensure build still works
+
+### Phase 2: Gradual Extraction (RECOMMENDED APPROACH)
+
+#### Step 1: Extract Refresh Operations
+Create `Repository.Refresh.cs` with:
+- RefreshAfterOperation()
+- RefreshAll()
+- RefreshBranches()
+- RefreshTags()
+- RefreshCommits()
+- RefreshWorkingCopyChanges()
+- RefreshStashes()
+- RefreshSubmodules()
+- RefreshWorktrees()
+
+**Note**: These methods have complex dependencies on internal fields and other methods. Need careful extraction.
+
+#### Step 2: Extract Git Operations
+Create `Repository.GitOperations.cs` with:
+- FetchAsync()
+- PullAsync()
+- PushAsync()
+- CheckoutBranchAsync()
+- CreateBranch()
+- DeleteBranch()
+- MergeMultipleBranches()
+
+#### Step 3: Extract Branch Management
+Create `Repository.Branches.cs` with:
+- Branch tree building methods
+- Branch filtering methods
+- GitFlow related methods
+- Branch context menu creation
+
+#### Step 4: Extract UI/Popup Management
+Create `Repository.UI.cs` with:
+- ShowPopup()
+- ShowAndStartPopupAsync()
+- CanCreatePopup()
+- All popup creation methods
+
+#### Step 5: Extract Search Operations
+Create `Repository.Search.cs` with:
+- StartSearchCommits()
+- CalcWorktreeFilesForSearching()
+- CalcMatchedFilesForSearching()
+- Search-related properties
+
+## Key Challenges Identified
+
+1. **Complex Dependencies**: Methods are tightly coupled with private fields and other methods
+2. **UI Thread Dispatching**: Many methods use Dispatcher.UIThread.Invoke
+3. **Async/Await Patterns**: Mix of synchronous and asynchronous operations
+4. **State Management**: Extensive use of private fields that need to be accessible across partial classes
+
+## Recommendations
+
+1. **Start Small**: Begin with methods that have fewer dependencies
+2. **Test Incrementally**: Build and test after each extraction
+3. **Keep Related Methods Together**: Group methods that work closely together
+4. **Document Dependencies**: Note which fields and methods each extracted group needs
+5. **Consider Service Pattern**: Eventually move to service-based architecture for better separation
+
+## Alternative Approach: Service-Based Architecture
+
+Instead of just splitting into partial classes, consider:
+
+1. **Create Service Interfaces**:
+   - IGitOperationService
+   - IRefreshService
+   - IBranchManagementService
+   - ISearchService
+
+2. **Implement Services**: Each service handles its specific domain
+
+3. **Use Dependency Injection**: Repository becomes a coordinator that delegates to services
+
+4. **Benefits**:
+   - Better testability
+   - Clear separation of concerns
+   - Easier to maintain and extend
+   - Follows SOLID principles
+
+## Next Steps
+
+1. Attempt careful extraction of refresh methods with proper dependency handling
+2. If extraction proves too complex, maintain current structure but document sections
+3. Consider gradual migration to service pattern over time
+4. Add unit tests for extracted components

src/ViewModels/IRepositoryService.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Avalonia.Collections;
+
+namespace SourceGit.ViewModels
+{
+    /// <summary>
+    /// Interface defining core repository services and operations
+    /// </summary>
+    public interface IRepositoryService
+    {
+        // Core Properties
+        string FullPath { get; }
+        string GitDir { get; }
+        bool IsBare { get; }
+        Models.RepositorySettings Settings { get; }
+        
+        // Branch Management
+        Models.Branch CurrentBranch { get; }
+        AvaloniaList<Models.Branch> Branches { get; }
+        AvaloniaList<BranchTreeNode> LocalBranchTrees { get; }
+        AvaloniaList<BranchTreeNode> RemoteBranchTrees { get; }
+        
+        // Remote Management
+        AvaloniaList<Models.Remote> Remotes { get; }
+        
+        // Tag Management
+        AvaloniaList<Models.Tag> Tags { get; }
+        AvaloniaList<Models.Tag> VisibleTags { get; }
+        
+        // Working Copy
+        WorkingCopy WorkingCopy { get; }
+        
+        // Stash Management
+        List<Models.Stash> Stashes { get; }
+        
+        // Submodule Management
+        List<Models.Submodule> Submodules { get; }
+        
+        // Core Operations
+        void Close();
+        void OpenInFileManager();
+        void OpenInTerminal();
+        
+        // Refresh Operations
+        Task RefreshBranches();
+        Task RefreshTags();
+        Task RefreshCommits();
+        Task RefreshWorkingCopy();
+        Task RefreshStashes();
+        Task RefreshRemotes();
+        Task RefreshSubmodules();
+        Task RefreshAfterOperation(Models.RefreshOptions options);
+        
+        // Git Operations
+        bool Fetch(Models.Remote remote, bool prune, bool noTags, Action<string> onProgress);
+        bool Pull(Models.Branch branch, Action<string> onProgress);
+        bool Push(Models.Branch branch, bool force, bool withTags, Action<string> onProgress);
+        bool Checkout(string target);
+        bool CreateBranch(string name, string basedOn);
+        bool DeleteBranch(Models.Branch branch, bool force);
+        bool CreateTag(string name, string basedOn, string message);
+        bool DeleteTag(Models.Tag tag);
+        
+        // Stash Operations
+        bool Stash(bool includeUntracked, string message);
+        bool ApplyStash(Models.Stash stash);
+        bool DropStash(Models.Stash stash);
+        
+        // Submodule Operations
+        bool AddSubmodule(string url, string path);
+        bool UpdateSubmodule(string path);
+        bool RemoveSubmodule(string path);
+        
+        // History Navigation
+        void NavigateToCommit(string sha);
+        void NavigateToBranch(Models.Branch branch);
+        void NavigateToTag(Models.Tag tag);
+        
+        // Search Operations
+        void SearchCommits(string query);
+        void ClearSearchFilter();
+        
+        // UI State Management
+        void SetWatcherEnabled(bool enabled);
+        void MarkBranchesDirty();
+        void MarkTagsDirty();
+        void MarkWorkingCopyDirty();
+    }
+}

src/ViewModels/Repository.cs

@@ -14,7 +14,7 @@
 
 namespace SourceGit.ViewModels
 {
-    public class Repository : ObservableObject, Models.IRepository
+    public partial class Repository : ObservableObject, Models.IRepository
     {
         public bool IsBare
         {