feat: Phase 1a : MAUI alpha on .NET 10 (44 components + tests)

.github/workflows/ci.yml

@@ -16,15 +16,26 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: |
-          8.0.x
-          9.0.x
+        dotnet-version: 10.0.x
 
-    - name: Restore dependencies (src only)
-      run: dotnet restore src/
+    - name: Restore dependencies (src + tests)
+      run: |
+        dotnet restore src/ShellUI.Native.CLI/ShellUI.Native.CLI.csproj
+        dotnet restore tests/ShellUI.Native.Tests/ShellUI.Native.Tests.csproj
 
     - name: Build library projects
-      run: dotnet build src/ --no-restore --configuration Release
+      run: dotnet build src/ShellUI.Native.CLI/ShellUI.Native.CLI.csproj --no-restore --configuration Release
+
+    - name: Run tests
+      run: dotnet test tests/ShellUI.Native.Tests/ShellUI.Native.Tests.csproj --configuration Release --no-restore --logger "trx;LogFileName=test-results.trx" --collect:"XPlat Code Coverage"
+
+    - name: Upload test results
+      if: always()
+      uses: actions/upload-artifact@v4
+      with:
+        name: test-results
+        path: |
+          tests/**/TestResults/**
 
     - name: Pack CLI tool
       run: dotnet pack src/ShellUI.Native.CLI/ShellUI.Native.CLI.csproj --no-restore --configuration Release -o ./nupkg
@@ -45,8 +56,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: |
-          8.0.x
+        dotnet-version: 10.0.x
 
     - name: Install MAUI workload
       run: dotnet workload install maui
@@ -55,4 +65,4 @@ jobs:
       run: dotnet restore examples/MAUI.Demo/MAUI.Demo.csproj
 
     - name: Build MAUI Demo (Windows)
-      run: dotnet build examples/MAUI.Demo/MAUI.Demo.csproj --configuration Release --framework net8.0-windows10.0.19041.0
+      run: dotnet build examples/MAUI.Demo/MAUI.Demo.csproj --configuration Release --framework net10.0-windows10.0.19041.0

.github/workflows/pr-check.yml

@@ -15,7 +15,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 8.0.x
+        dotnet-version: 10.0.x
 
     - name: Check formatting
       run: dotnet format src/ --verify-no-changes --verbosity diagnostic

.github/workflows/release.yml

@@ -16,9 +16,7 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: |
-          8.0.x
-          9.0.x
+        dotnet-version: 10.0.x
 
     - name: Extract version from tag
       id: version

Directory.Build.props

@@ -23,15 +23,13 @@
     <Copyright>© $([System.DateTime]::Now.Year) ShellUI. All rights reserved.</Copyright>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
-    <PackageTags>maui;winui;wpf;ui;components;shadcn;native;cross-platform</PackageTags>
+    <PackageTags>maui;avalonia;winui;ui;components;shadcn;native;cross-platform</PackageTags>
     <RepositoryUrl>https://github.com/shellui-dev/shellui-native</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
   </PropertyGroup>
 
-  <!-- Common build settings -->
+  <!-- Common build settings (TargetFramework should be set per-project) -->
   <PropertyGroup>
-    <!-- Supports .NET 8.0 and later (including .NET 9, 10, etc.) -->
-    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <LangVersion>latest</LangVersion>

ShellUI.Native.slnx

@@ -0,0 +1,22 @@
+<Solution>
+  <Folder Name="/docs/">
+    <File Path="docs/ARCHITECTURE.md" />
+    <File Path="docs/BLAZOR_HYBRID.md" />
+    <File Path="docs/PLAN.md" />
+    <File Path="docs/README.md" />
+  </Folder>
+  <Folder Name="/examples/">
+    <File Path="examples/README.md" />
+    <Project Path="examples/MAUI.Demo/MAUI.Demo.csproj">
+      <Deploy />
+    </Project>
+  </Folder>
+  <Folder Name="/src/">
+    <Project Path="src/ShellUI.Native.CLI/ShellUI.Native.CLI.csproj" />
+    <Project Path="src/ShellUI.Native.Core/ShellUI.Native.Core.csproj" />
+    <Project Path="src/ShellUI.Native.Templates/ShellUI.Native.Templates.csproj" />
+  </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/ShellUI.Native.Tests/ShellUI.Native.Tests.csproj" />
+  </Folder>
+</Solution>

docs/ARCHITECTURE.md

@@ -2,13 +2,13 @@
 
 ## Overview
 
-ShellUI Native follows a modular architecture designed to support multiple native platforms while maintaining a consistent developer experience and design system.
+ShellUI Native follows a modular architecture designed to support multiple native platforms while maintaining a consistent developer experience and design system. It is the native counterpart to [ShellUI (Blazor)](https://shellui.dev/), inspired by [shadcn/ui](https://ui.shadcn.com/)'s copy-and-own approach.
 
 ## Key Difference from ShellUI Blazor: No Tailwind!
 
 **ShellUI Native does NOT use Tailwind CSS.** Native platforms use XAML styles, not CSS.
 
-| Aspect | ShellUI Blazor | ShellUI Native |
+| Aspect | [ShellUI Blazor](https://shellui.dev/) | ShellUI Native |
 |--------|---------------|----------------|
 | Styling | Tailwind CSS | XAML Styles/ResourceDictionary |
 | Rendering | HTML/CSS in browser | Native platform controls |
@@ -21,14 +21,18 @@ The design tokens (colors, spacing, typography) are **identical** to maintain vi
 
 ```
 shellui-native/
-├── Directory.Build.props          # Centralized versioning
-├── ShellUI.Native.sln
+├── Directory.Build.props          # Centralized versioning + package metadata
+├── global.json                    # Pins .NET 10 SDK
+├── ShellUI.Native.slnx            # XML-format solution (post .NET 9)
 ├── src/
 │   ├── ShellUI.Native.Core/       # Shared models and abstractions
-│   ├── ShellUI.Native.Templates/  # Component templates
+│   ├── ShellUI.Native.Templates/  # Component templates (MAUI today; per-platform planned)
 │   ├── ShellUI.Native.CLI/        # Command-line tool
-│   └── ShellUI.Native.MAUI/       # Reference implementation (optional)
-├── samples/
+│   ├── ShellUI.Native.MAUI/       # MAUI reference implementation (optional)
+│   └── ShellUI.Native.Avalonia/   # Avalonia reference implementation (planned, Phase 2)
+├── tests/
+│   └── ShellUI.Native.Tests/      # xUnit — registry invariants, template hygiene, ProjectDetector
+├── examples/
 │   └── MAUI.Demo/
 └── docs/
 ```
@@ -69,6 +73,13 @@ public class ButtonTemplate
 }
 ```
 
+**Gap today (Template System v2 target):** `Content` is a single MAUI-flavored string, and
+`ComponentRegistry.GetComponentContent` has no platform parameter — it can't yet return
+different code for Avalonia vs. MAUI. Adding Avalonia support requires evolving this to
+something like `ButtonTemplate.Content(NativePlatform)` or per-platform static properties
+(`ButtonTemplate.MauiContent` / `ButtonTemplate.AvaloniaContent`) selected by
+`config.TargetPlatform`. See [PLAN.md](./PLAN.md) and [DEVELOPMENT_PLAN.md](./DEVELOPMENT_PLAN.md).
+
 ### 2. Namespace Replacement
 
 When components are installed, the placeholder `YourProjectNamespace` is replaced with the actual project namespace detected from the .csproj file.
@@ -81,7 +92,8 @@ Components can declare dependencies on other components. The CLI automatically i
 
 The `shellui-native.json` file tracks:
 
-- Target platform (MAUI, WinUI, WPF)
+- Target platform (MAUI, Avalonia, WinUI, or WPF — see `NativePlatform` in
+  [ShellUINativeConfig.cs](../src/ShellUI.Native.Core/Models/ShellUINativeConfig.cs))
 - Components path
 - Installed components with versions
 - Theme settings
@@ -93,16 +105,29 @@ The CLI detects project types by examining the .csproj file:
 | Detection | Platform |
 |-----------|----------|
 | `UseMaui=true` or SDK contains "Maui" | MAUI |
+| `PackageReference` starting with "Avalonia", or an `App.axaml` file present | Avalonia |
 | `UseWinUI=true` | WinUI 3 |
-| `UseWPF=true` or SDK contains "Wpf" | WPF |
+| `UseWPF=true` or SDK contains "Wpf" | WPF (detection only — see [PLAN.md](./PLAN.md)) |
+
+Detection order matters: MAUI is checked first (via SDK/`UseMaui`), then Avalonia (via
+`PackageReference`/`App.axaml`, since Avalonia has no dedicated SDK), then WinUI/WPF. See
+[`ProjectDetector.cs`](../src/ShellUI.Native.CLI/Services/ProjectDetector.cs).
+
+**Current limitation:** detection recognizes Avalonia/WinUI/WPF projects, but
+[`ComponentRegistry`](../src/ShellUI.Native.Templates/ComponentRegistry.cs) only has MAUI
+templates today. `shellui-native add` prints a warning and installs MAUI code regardless of
+detected platform until per-platform templates exist (see "Component Templates" in Core
+Concepts above, and Template System v2 in [PLAN.md](./PLAN.md)).
 
 ## Theming System
 
-Unlike ShellUI Blazor which uses CSS variables, ShellUI Native uses platform-native theming:
+Unlike [ShellUI Blazor](https://shellui.dev/) which uses CSS variables, ShellUI Native uses platform-native theming:
 
 - **MAUI** - ResourceDictionary with Colors, Styles
+- **Avalonia** - `Styles`/`ResourceDictionary` with `DynamicResource`, plus Avalonia's built-in
+  Fluent/Simple theme variants for light/dark switching
 - **WinUI** - XAML Resources and ThemeResources
-- **WPF** - ResourceDictionary with DynamicResource
+- **WPF** - ResourceDictionary with DynamicResource (existing apps only, not an active target)
 
 Design tokens are mapped from the ShellUI CSS variables to native equivalents:
 
@@ -138,12 +163,40 @@ public partial class Button : ContentView
 }
 ```
 
+## Component Pattern (Avalonia, planned)
+
+Avalonia components will follow the `StyledProperty`/`TemplatedControl` pattern instead of
+MAUI's `BindableProperty`/`ContentView` — the same property-driven visual-state approach, just
+Avalonia's equivalent APIs:
+
+```csharp
+public partial class Button : TemplatedControl
+{
+    public static readonly StyledProperty<ButtonVariant> VariantProperty =
+        AvaloniaProperty.Register<Button, ButtonVariant>(nameof(Variant), ButtonVariant.Default);
+
+    public ButtonVariant Variant
+    {
+        get => GetValue(VariantProperty);
+        set => SetValue(VariantProperty, value);
+    }
+
+    static Button()
+    {
+        VariantProperty.Changed.AddClassHandler<Button>((button, _) => button.UpdateVisualState());
+    }
+}
+```
+
+Not implemented yet — this illustrates the target shape once Template System v2 lands and
+`ShellUI.Native.Avalonia` is scaffolded.
+
 ## Versioning Strategy
 
 All packages share a single version defined in `Directory.Build.props`:
 
 ```xml
-<ShellUINativeVersion>0.1.0</ShellUINativeVersion>
+<ShellUINativeVersion>0.0.1</ShellUINativeVersion>
 ```
 
 Component metadata reads this version at runtime, ensuring consistency across all installed components.

docs/BLAZOR_HYBRID.md

@@ -1,6 +1,6 @@
 # Blazor MAUI Hybrid Guide
 
-How to use ShellUI libraries in Blazor Hybrid applications.
+How to use [ShellUI](https://shellui.dev/) libraries in Blazor Hybrid applications.
 
 ## Understanding Hybrid Architecture
 
@@ -30,7 +30,7 @@ A Blazor Hybrid app has two distinct rendering contexts:
 
 ## Which Library to Use?
 
-### Use ShellUI (Blazor) When:
+### Use [ShellUI (Blazor)](https://shellui.dev/) When:
 - Building UI inside the `BlazorWebView`
 - Working with Razor components
 - Need Tailwind CSS styling
@@ -48,7 +48,7 @@ A Blazor Hybrid app has two distinct rendering contexts:
 If your app is primarily Blazor with minimal native UI:
 
 ```bash
-# Just install ShellUI Blazor
+# Just install ShellUI Blazor (https://github.com/shellui-dev/shellui)
 dotnet tool install -g ShellUI.CLI
 cd YourHybridApp
 shellui init --yes
@@ -132,7 +132,7 @@ YourHybridApp/
 
 ## Recommendations
 
-1. **Start with Blazor** - Most hybrid apps are Blazor-heavy. Start with ShellUI Blazor only.
+1. **Start with Blazor** - Most hybrid apps are Blazor-heavy. Start with [ShellUI Blazor](https://shellui.dev/) only.
 
 2. **Add Native as Needed** - Only add ShellUI Native when you need truly native controls.