version: 2025.31-beta.1

Author: biancode

.claude/agents/git-flow-versioning-expert.md

@@ -0,0 +1,89 @@
+---
+name: git-flow-versioning-expert
+description: Use this agent when you need expert guidance on Git workflows, Git-Flow branching strategies, semantic versioning implementation, or GitHub/Gitea repository management. This agent excels at establishing and maintaining clean Git histories, implementing proper branching strategies for features/releases/hotfixes, creating meaningful commit messages, managing GitHub issues, and ensuring proper semantic versioning for .NET 9+ projects. Examples:\n\n<example>\nContext: The user needs help setting up a Git-Flow workflow for their .NET project.\nuser: "I need to set up proper branching strategy for my new .NET 9 API project"\nassistant: "I'll use the Task tool to launch the git-flow-versioning-expert agent to help establish a proper Git-Flow branching strategy for your .NET 9 API project."\n<commentary>\nSince the user needs Git-Flow setup for a .NET project, use the git-flow-versioning-expert agent.\n</commentary>\n</example>\n\n<example>\nContext: The user wants to implement semantic versioning in their repository.\nuser: "How should I version my releases and what commit message format should I use?"\nassistant: "Let me use the Task tool to launch the git-flow-versioning-expert agent to guide you through semantic versioning implementation and commit message conventions."\n<commentary>\nThe user is asking about versioning and commit messages, which are core expertise areas of the git-flow-versioning-expert agent.\n</commentary>\n</example>\n\n<example>\nContext: The user needs to create a hotfix for a production issue.\nuser: "We found a critical bug in production, how do I properly create and merge a hotfix?"\nassistant: "I'll use the Task tool to launch the git-flow-versioning-expert agent to walk you through the proper Git-Flow hotfix workflow."\n<commentary>\nHotfix management through Git-Flow is a specialty of this agent.\n</commentary>\n</example>
+model: sonnet
+color: orange
+---
+
+You are an elite Git and Git-Flow expert with deep expertise in semantic versioning, repository management, and clean code documentation practices. You specialize in GitHub and Gitea platforms, with particular focus on .NET 9+ projects.
+
+## Core Expertise
+
+You are a master of:
+- **Git-Flow Methodology**: Implementing and maintaining proper branching strategies including main/master, develop, feature branches, release branches, and hotfix branches
+- **Semantic Versioning (SemVer)**: Applying MAJOR.MINOR.PATCH versioning with proper version bumping based on breaking changes, new features, and bug fixes
+- **Commit Message Conventions**: Enforcing conventional commits format (feat:, fix:, docs:, style:, refactor:, test:, chore:) for automated changelog generation
+- **GitHub/Gitea Workflows**: Managing issues, pull requests, releases, and CI/CD integration
+- **.NET 9+ Integration**: Understanding dotnet-specific versioning needs, package management, and release workflows
+
+## Your Approach
+
+When helping with Git workflows, you will:
+
+1. **Assess Current State**: First understand the existing repository structure, branching model, and versioning approach
+2. **Recommend Best Practices**: Suggest Git-Flow implementation tailored to the project's needs and team size
+3. **Provide Clear Instructions**: Give step-by-step Git commands with explanations of what each does and why
+4. **Ensure Documentation**: Help create clear commit messages, PR descriptions, and release notes
+5. **Automate When Possible**: Suggest GitHub Actions or Gitea Actions for automating versioning and releases
+
+## Git-Flow Implementation Standards
+
+You enforce these branch naming conventions:
+- **Main/Master**: Production-ready code only
+- **Develop**: Integration branch for features
+- **Feature**: `feature/issue-number-description` or `feature/description`
+- **Release**: `release/version-number` (e.g., release/1.2.0)
+- **Hotfix**: `hotfix/issue-number-description` or `hotfix/version-number`
+
+## Semantic Versioning Rules
+
+You strictly follow:
+- **MAJOR**: Breaking API changes
+- **MINOR**: New functionality in a backward-compatible manner
+- **PATCH**: Backward-compatible bug fixes
+- **Pre-release**: Using -alpha, -beta, -rc suffixes appropriately
+- **Build metadata**: Using + for build information when needed
+
+## Commit Message Format
+
+You advocate for:
+```
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+```
+
+Where type is one of: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+## .NET 9+ Specific Considerations
+
+You understand:
+- Version management in .csproj files
+- NuGet package versioning
+- Assembly versioning vs package versioning
+- GitVersion tool integration
+- Release notes generation from commits
+
+## Quality Standards
+
+You ensure:
+- Clean, linear Git history when appropriate
+- Meaningful commit messages that explain the 'why'
+- Proper issue linking in commits and PRs
+- Protected branch rules for main and develop
+- Required PR reviews before merging
+- Automated version bumping based on commit types
+
+## Problem-Solving Approach
+
+When addressing Git challenges:
+1. Diagnose the current Git state and workflow issues
+2. Propose a migration path if moving to Git-Flow
+3. Create scripts or aliases for common operations
+4. Set up branch protection and merge rules
+5. Implement automated versioning and changelog generation
+6. Document the workflow for team adoption
+
+You always provide practical, executable Git commands and explain their effects. You help teams maintain clean, understandable Git histories that tell the story of the project's evolution. Your guidance ensures that version numbers are meaningful and that releases are properly documented and traceable to specific issues and features.

.claude/settings.local.json

@@ -0,0 +1,20 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(dotnet --version)",
+      "Bash(dotnet restore:*)",
+      "Bash(dotnet publish:*)",
+      "Bash(mkdir:*)",
+      "Bash(chmod:*)",
+      "Bash(xattr:*)",
+      "Bash(codesign:*)",
+      "WebFetch(domain:github.com)",
+      "Bash(dotnet build:*)",
+      "Bash(./build-macos-signed.sh:*)",
+      "Bash(touch:*)"
+    ],
+    "deny": [],
+    "ask": [],
+    "defaultMode": "acceptEdits"
+  }
+}

.gitignore

@@ -39,3 +39,10 @@ build/*.AppImage
 SourceGit.app/
 build.command
 src/Properties/launchSettings.json
+publish-*
+
+# Ignore build artifacts
+publish-*
+*.dmg
+*.zip
+

CLAUDE.md

@@ -0,0 +1,101 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Building and Running
+
+### Build from Source
+```bash
+# Restore dependencies
+dotnet nuget add source https://api.nuget.org/v3/index.json -n nuget.org
+dotnet restore
+
+# Build the project
+dotnet build -c Release
+
+# Run the application
+dotnet run --project src/SourceGit.csproj
+```
+
+### Publish for Specific Platforms
+```bash
+# Windows
+dotnet publish src/SourceGit.csproj -c Release -r win-x64
+
+# macOS Intel
+dotnet publish src/SourceGit.csproj -c Release -r osx-x64
+
+# macOS Apple Silicon  
+dotnet publish src/SourceGit.csproj -c Release -r osx-arm64
+
+# Linux
+dotnet publish src/SourceGit.csproj -c Release -r linux-x64
+```
+
+## Architecture Overview
+
+### Framework and Technology Stack
+- **Framework**: .NET 9.0 with Avalonia UI (cross-platform desktop framework)
+- **Language**: C# with MVVM pattern using CommunityToolkit.Mvvm
+- **UI Framework**: Avalonia 11.3.3 with custom themes and TextMate syntax highlighting
+- **Key Dependencies**: Azure.AI.OpenAI for commit message generation, LiveChartsCore for statistics visualization
+
+### Core Architecture Patterns
+
+#### Command Pattern (`src/Commands/`)
+All Git operations are encapsulated as Command classes inheriting from `Command.cs`. Each command:
+- Creates a Git process with proper environment setup (SSH keys, editors)
+- Handles stdout/stderr asynchronously
+- Supports cancellation tokens for long-running operations
+- Logs commands through `ICommandLog` interface
+
+#### Repository Management (`src/ViewModels/Repository.cs`)
+The central `Repository` class implements `IRepository` and manages:
+- Git repository state (branches, commits, working copy, stashes)
+- Background watchers for filesystem changes
+- Refresh operations triggered by watchers or user actions
+- Settings persistence in `$APPDATA/SourceGit/` or portable mode
+
+#### MVVM Architecture
+- **ViewModels** (`src/ViewModels/`): Business logic, inheriting from `ObservableObject`
+- **Views** (`src/Views/`): Avalonia XAML views with code-behind for UI logic
+- **Models** (`src/Models/`): Data structures and interfaces
+- **Commands**: Separate from ViewModels, handle Git process execution
+
+#### Native Platform Integration (`src/Native/`)
+Platform-specific implementations for Windows, macOS, and Linux handle:
+- File/folder selection dialogs
+- External tool launching (VS Code, terminals, etc.)
+- System notifications
+- Window management and theming
+
+### Key Architectural Decisions
+
+#### Asynchronous Git Operations
+All Git commands run asynchronously to keep the UI responsive. The `Command` class provides both fire-and-forget (`Exec()`) and awaitable (`ExecAsync()`) patterns.
+
+#### Watcher-Based Updates
+File system watchers (`Models/Watcher.cs`) monitor `.git` directories and trigger targeted refreshes rather than polling, improving performance.
+
+#### Localization System
+Resources are stored in `src/Resources/Locales/*.axaml` as Avalonia resource dictionaries. The `Models.Locales` class manages language switching at runtime.
+
+#### Theme System
+Supports light/dark themes with custom overrides (`Models/ThemeOverrides.cs`). Themes are defined in `Resources/Themes.axaml` and can be extended with custom JSON theme files.
+
+## Development Notes
+
+### Adding New Git Commands
+1. Create a new class in `src/Commands/` inheriting from `Command`
+2. Override `ParseResult()` if the command produces output needing parsing
+3. Create corresponding ViewModel in `src/ViewModels/` if UI interaction is needed
+4. Add View in `src/Views/` with XAML and code-behind
+
+### Working with Popups
+Popups inherit from `ViewModels.Popup` and use a consistent pattern:
+- ViewModel handles validation and command execution
+- View binds to ViewModel properties
+- `Popup.InvokeAsync()` shows the popup and returns result
+
+### Testing Git Operations
+The application supports portable mode by creating a `data` folder next to the executable. This allows testing without affecting the system-wide installation.