watashi-db 0.0.13 → 0.0.14

package/misc/20260316_xaml-testing-library-recipe.md

@@ -0,0 +1,817 @@
+# XAML Testing Library — Phase B: Binding 静的検証 実装レシピ
+
+## Context
+
+WPF アプリは「画面を開いて初めて Binding ミスに気づく」状態が多い。XAML の `{Binding Path}` が ViewModel のプロパティに正しく対応しているかを、**画面表示なし・コンパイル時に静的チェック**するツールを作る。
+
+**技術スタック**: C# / .NET 8+ / Roslyn (Microsoft.CodeAnalysis) / System.Xaml
+
+**ゴール**: CI で回せる XAML Binding 検証ツールの PoC
+
+---
+
+## プロジェクト構成
+
+```
+XamlTestLib/
+├── src/
+│   ├── XamlTestLib/                          # メインライブラリ
+│   │   ├── XamlTestLib.csproj
+│   │   ├── Parsing/
+│   │   │   ├── XamlBindingExtractor.cs       # XAML から Binding 式を抽出
+│   │   │   ├── BindingInfo.cs                # Binding のメタデータ
+│   │   │   └── DataContextResolver.cs        # View → ViewModel の対応解決
+│   │   ├── Analysis/
+│   │   │   ├── RoslynProjectLoader.cs        # .csproj を Roslyn で読み込み
+│   │   │   ├── ViewModelAnalyzer.cs          # ViewModel のプロパティ・型を解析
+│   │   │   └── BindingValidator.cs           # Binding パスの検証ロジック
+│   │   └── Reporting/
+│   │       ├── ValidationResult.cs           # 検証結果モデル
+│   │       └── ConsoleReporter.cs            # コンソール出力
+│   ├── XamlTestLib.Cli/                      # CLI ツール（dotnet tool）
+│   │   ├── XamlTestLib.Cli.csproj
+│   │   └── Program.cs
+│   └── XamlTestLib.MsBuild/                  # MSBuild タスク（将来）
+│       └── XamlTestLib.MsBuild.csproj
+├── tests/
+│   ├── XamlTestLib.Tests/                    # ユニットテスト
+│   │   ├── XamlTestLib.Tests.csproj
+│   │   ├── Parsing/
+│   │   │   └── XamlBindingExtractorTests.cs
+│   │   ├── Analysis/
+│   │   │   ├── ViewModelAnalyzerTests.cs
+│   │   │   └── BindingValidatorTests.cs
+│   │   └── TestData/                         # テスト用 XAML / ViewModel
+│   │       ├── SimpleView.xaml
+│   │       ├── SimpleViewModel.cs
+│   │       ├── NestedBindingView.xaml
+│   │       ├── ConverterView.xaml
+│   │       └── BrokenBindingView.xaml
+│   └── SampleWpfApp/                         # Dog-fooding 対象
+│       ├── SampleWpfApp.csproj
+│       ├── Views/
+│       │   └── MainWindow.xaml
+│       └── ViewModels/
+│           └── MainWindowViewModel.cs
+├── XamlTestLib.sln
+├── .gitignore
+├── CLAUDE.md
+└── README.md
+```
+
+---
+
+## Step 1: ソリューション初期構成
+
+```bash
+mkdir XamlTestLib && cd XamlTestLib
+dotnet new sln
+
+# メインライブラリ
+dotnet new classlib -n XamlTestLib -o src/XamlTestLib -f net8.0
+dotnet sln add src/XamlTestLib
+
+# CLI ツール
+dotnet new console -n XamlTestLib.Cli -o src/XamlTestLib.Cli -f net8.0
+dotnet sln add src/XamlTestLib.Cli
+
+# テストプロジェクト
+dotnet new xunit -n XamlTestLib.Tests -o tests/XamlTestLib.Tests -f net8.0
+dotnet sln add tests/XamlTestLib.Tests
+
+# サンプル WPF アプリ（dog-fooding 用）
+dotnet new wpf -n SampleWpfApp -o tests/SampleWpfApp -f net8.0-windows
+dotnet sln add tests/SampleWpfApp
+
+# プロジェクト参照
+dotnet add src/XamlTestLib.Cli reference src/XamlTestLib
+dotnet add tests/XamlTestLib.Tests reference src/XamlTestLib
+```
+
+### NuGet パッケージ（XamlTestLib.csproj）
+
+```xml
+<ItemGroup>
+  <!-- Roslyn: C# ソースの意味解析 -->
+  <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" />
+  <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.9.2" />
+  <PackageReference Include="Microsoft.Build.Locator" Version="1.7.8" />
+  <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" Version="4.9.2" />
+</ItemGroup>
+```
+
+> MSBuildLocator は Roslyn が .csproj をロードするために必要。
+> バージョンは最新を確認すること。
+
+---
+
+## Step 2: XAML パーサー — Binding 式の抽出
+
+### `BindingInfo.cs`
+
+```csharp
+namespace XamlTestLib.Parsing;
+
+/// <summary>Binding 式のメタデータ</summary>
+public record BindingInfo(
+    string Path,                    // Binding Path（例: "UserName", "Items.Count"）
+    string? Converter,              // Converter 名（例: "BoolToVisibility"）
+    string? ConverterParameter,
+    string? StringFormat,
+    string? ElementName,            // ElementName binding の場合
+    string? RelativeSource,         // RelativeSource の場合
+    string SourceXamlFile,          // 元 XAML ファイルパス
+    int LineNumber,                 // XAML 内の行番号
+    string ParentElementName,       // 親要素名（例: "TextBox"）
+    string TargetProperty           // 対象プロパティ（例: "Text"）
+);
+```
+
+### `XamlBindingExtractor.cs` — コア実装
+
+XAML を XML として読み、`{Binding ...}` を正規表現 + 簡易パーサーで抽出する。
+`System.Xaml.XamlReader` ではなく XML パーサーを使う理由:
+- XamlReader は型解決が必要（アセンブリ参照がないと失敗する）
+- 静的検証の目的では XML レベルで十分
+- エラー耐性が高い（壊れた XAML でも部分的に処理可能）
+
+```csharp
+namespace XamlTestLib.Parsing;
+
+using System.Text.RegularExpressions;
+using System.Xml.Linq;
+
+public class XamlBindingExtractor
+{
+    // {Binding Path=XXX, Converter={StaticResource YYY}} のパターン
+    // {Binding XXX} の省略形も対応
+    private static readonly Regex BindingRegex = new(
+        @"\{Binding\s+(?:Path=)?([^,\}]+)(?:,\s*([^}]*))?\}",
+        RegexOptions.Compiled);
+
+    public IReadOnlyList<BindingInfo> Extract(string xamlFilePath)
+    {
+        var results = new List<BindingInfo>();
+        var doc = XDocument.Load(xamlFilePath, LoadOptions.SetLineInfo);
+
+        foreach (var element in doc.Descendants())
+        {
+            foreach (var attr in element.Attributes())
+            {
+                var matches = BindingRegex.Matches(attr.Value);
+                foreach (Match match in matches)
+                {
+                    var path = match.Groups[1].Value.Trim();
+                    var options = match.Groups[2].Success ? match.Groups[2].Value : null;
+
+                    var info = new BindingInfo(
+                        Path: path,
+                        Converter: ExtractOption(options, "Converter"),
+                        ConverterParameter: ExtractOption(options, "ConverterParameter"),
+                        StringFormat: ExtractOption(options, "StringFormat"),
+                        ElementName: ExtractOption(options, "ElementName"),
+                        RelativeSource: ExtractOption(options, "RelativeSource"),
+                        SourceXamlFile: xamlFilePath,
+                        LineNumber: ((IXmlLineInfo)element).LineNumber,
+                        ParentElementName: element.Name.LocalName,
+                        TargetProperty: attr.Name.LocalName
+                    );
+                    results.Add(info);
+                }
+            }
+        }
+
+        return results;
+    }
+
+    private static string? ExtractOption(string? options, string key)
+    {
+        if (options == null) return null;
+        var regex = new Regex($@"{key}=([^,\}}]+)");
+        var match = regex.Match(options);
+        return match.Success ? match.Groups[1].Value.Trim() : null;
+    }
+}
+```
+
+### 考慮事項
+- `{Binding}` (パスなし = DataContext 自体) → Path="" で記録
+- `{x:Bind}` (UWP/WinUI) → 将来対応、今は `{Binding}` のみ
+- `MultiBinding` → 子の `<Binding>` 要素として出現するので要素走査で対応（Step 2 では後回し）
+- ネストした `{StaticResource}` 内の Binding → 正規表現を改良する必要あり
+
+---
+
+## Step 3: DataContext 解決 — View と ViewModel の対応付け
+
+### 対応付けの3戦略（優先順）
+
+1. **d:DataContext 属性**（デザイン時 DataContext）
+   ```xml
+   <Window d:DataContext="{d:DesignInstance vm:MainWindowViewModel}">
+   ```
+   → 最も信頼性が高い。これがあれば確定。
+
+2. **code-behind の DataContext 代入**
+   ```csharp
+   DataContext = new MainWindowViewModel();
+   ```
+   → Roslyn で code-behind を解析して型を特定。
+
+3. **命名規約**
+   - `MainWindow.xaml` → `MainWindowViewModel`
+   - `UserListView.xaml` → `UserListViewModel`
+   → フォールバック。設定でカスタマイズ可能にする。
+
+### `DataContextResolver.cs`
+
+```csharp
+namespace XamlTestLib.Parsing;
+
+using System.Xml.Linq;
+
+public class DataContextResolver
+{
+    private static readonly XNamespace DesignNs =
+        "http://schemas.microsoft.com/expression/blend/2008";
+
+    /// <summary>XAML から DataContext 型名を解決する</summary>
+    public string? ResolveFromXaml(string xamlFilePath)
+    {
+        var doc = XDocument.Load(xamlFilePath);
+        var root = doc.Root;
+        if (root == null) return null;
+
+        // 戦略1: d:DataContext
+        var designContext = root.Attribute(DesignNs + "DataContext");
+        if (designContext != null)
+        {
+            return ExtractDesignInstanceType(designContext.Value, root);
+        }
+
+        // 戦略3: 命名規約（フォールバック）
+        var fileName = Path.GetFileNameWithoutExtension(xamlFilePath);
+        return fileName + "ViewModel";
+    }
+
+    private string? ExtractDesignInstanceType(string value, XElement root)
+    {
+        // {d:DesignInstance vm:MainWindowViewModel} のパターン
+        var match = Regex.Match(value, @"DesignInstance\s+(?:Type=)?(\w+:)?(\w+)");
+        if (!match.Success) return null;
+
+        var prefix = match.Groups[1].Value.TrimEnd(':');
+        var typeName = match.Groups[2].Value;
+
+        if (!string.IsNullOrEmpty(prefix))
+        {
+            // xmlns:vm="clr-namespace:SampleApp.ViewModels" からフル名を解決
+            var ns = root.Attributes()
+                .FirstOrDefault(a => a.Name.LocalName == prefix)?
+                .Value;
+            if (ns != null)
+            {
+                var clrNs = ExtractClrNamespace(ns);
+                if (clrNs != null) return $"{clrNs}.{typeName}";
+            }
+        }
+
+        return typeName;
+    }
+
+    private static string? ExtractClrNamespace(string xmlns)
+    {
+        // "clr-namespace:SampleApp.ViewModels;assembly=SampleApp"
+        var match = Regex.Match(xmlns, @"clr-namespace:([^;]+)");
+        return match.Success ? match.Groups[1].Value : null;
+    }
+}
+```
+
+---
+
+## Step 4: Roslyn で ViewModel を解析
+
+### `RoslynProjectLoader.cs`
+
+```csharp
+namespace XamlTestLib.Analysis;
+
+using Microsoft.Build.Locator;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.MSBuild;
+
+public class RoslynProjectLoader : IDisposable
+{
+    private MSBuildWorkspace? _workspace;
+
+    static RoslynProjectLoader()
+    {
+        // MSBuild の場所を自動検出（初回のみ）
+        if (!MSBuildLocator.IsRegistered)
+            MSBuildLocator.RegisterDefaults();
+    }
+
+    public async Task<Compilation?> LoadProjectAsync(string csprojPath)
+    {
+        _workspace = MSBuildWorkspace.Create();
+        var project = await _workspace.OpenProjectAsync(csprojPath);
+        return await project.GetCompilationAsync();
+    }
+
+    public void Dispose() => _workspace?.Dispose();
+}
+```
+
+### `ViewModelAnalyzer.cs`
+
+```csharp
+namespace XamlTestLib.Analysis;
+
+using Microsoft.CodeAnalysis;
+
+public class ViewModelAnalyzer
+{
+    private readonly Compilation _compilation;
+
+    public ViewModelAnalyzer(Compilation compilation)
+    {
+        _compilation = compilation;
+    }
+
+    /// <summary>型名から INamedTypeSymbol を取得</summary>
+    public INamedTypeSymbol? FindType(string fullTypeName)
+    {
+        return _compilation.GetTypeByMetadataName(fullTypeName);
+    }
+
+    /// <summary>型名の部分一致検索（namespace 不明の場合）</summary>
+    public INamedTypeSymbol? FindTypeByName(string typeName)
+    {
+        return _compilation.GetSymbolsWithName(typeName, SymbolFilter.Type)
+            .OfType<INamedTypeSymbol>()
+            .FirstOrDefault();
+    }
+
+    /// <summary>Binding パスが ViewModel 上で有効かチェック</summary>
+    public PropertyCheckResult CheckBindingPath(INamedTypeSymbol viewModelType, string bindingPath)
+    {
+        // "Items.Count" → ["Items", "Count"]
+        var segments = bindingPath.Split('.');
+        var currentType = viewModelType;
+
+        foreach (var segment in segments)
+        {
+            // インデクサ [0] や添付プロパティ (Grid.Row) は今はスキップ
+            if (segment.Contains('[') || segment.Contains('('))
+            {
+                return new PropertyCheckResult(true, null, "Skipped: indexer or attached property");
+            }
+
+            var member = FindProperty(currentType, segment);
+            if (member == null)
+            {
+                return new PropertyCheckResult(
+                    false,
+                    currentType,
+                    $"Property '{segment}' not found on type '{currentType.Name}'"
+                );
+            }
+
+            // 次のセグメントのために型を進める
+            currentType = GetPropertyType(member);
+            if (currentType == null)
+            {
+                return new PropertyCheckResult(true, null, "Skipped: unresolvable type");
+            }
+        }
+
+        return new PropertyCheckResult(true, currentType, null);
+    }
+
+    private ISymbol? FindProperty(INamedTypeSymbol type, string name)
+    {
+        // 本人 + 基底クラスを走査
+        var current = type;
+        while (current != null)
+        {
+            var member = current.GetMembers(name)
+                .FirstOrDefault(m => m.Kind == SymbolKind.Property
+                                  || m.Kind == SymbolKind.Field);
+            if (member != null) return member;
+            current = current.BaseType;
+        }
+        return null;
+    }
+
+    private INamedTypeSymbol? GetPropertyType(ISymbol member)
+    {
+        var type = member switch
+        {
+            IPropertySymbol p => p.Type,
+            IFieldSymbol f => f.Type,
+            _ => null
+        };
+        return type as INamedTypeSymbol;
+    }
+}
+
+public record PropertyCheckResult(
+    bool IsValid,
+    INamedTypeSymbol? ResolvedType,
+    string? Message
+);
+```
+
+---
+
+## Step 5: Binding 検証の統合
+
+### `BindingValidator.cs`
+
+```csharp
+namespace XamlTestLib.Analysis;
+
+using XamlTestLib.Parsing;
+using XamlTestLib.Reporting;
+
+public class BindingValidator
+{
+    private readonly ViewModelAnalyzer _analyzer;
+    private readonly DataContextResolver _contextResolver;
+
+    public BindingValidator(ViewModelAnalyzer analyzer)
+    {
+        _analyzer = analyzer;
+        _contextResolver = new DataContextResolver();
+    }
+
+    public ValidationReport Validate(IEnumerable<string> xamlFiles)
+    {
+        var extractor = new XamlBindingExtractor();
+        var results = new List<ValidationResult>();
+
+        foreach (var xamlFile in xamlFiles)
+        {
+            // 1. Binding 式を抽出
+            var bindings = extractor.Extract(xamlFile);
+
+            // 2. DataContext（ViewModel 型）を解決
+            var viewModelName = _contextResolver.ResolveFromXaml(xamlFile);
+            if (viewModelName == null)
+            {
+                results.Add(new ValidationResult(
+                    xamlFile, 0, Severity.Warning,
+                    "DataContext を解決できませんでした。d:DataContext または命名規約を確認してください。"
+                ));
+                continue;
+            }
+
+            // 3. ViewModel 型を Roslyn で取得
+            var vmType = _analyzer.FindTypeByName(viewModelName)
+                      ?? _analyzer.FindType(viewModelName);
+            if (vmType == null)
+            {
+                results.Add(new ValidationResult(
+                    xamlFile, 0, Severity.Warning,
+                    $"ViewModel '{viewModelName}' がプロジェクト内に見つかりません。"
+                ));
+                continue;
+            }
+
+            // 4. 各 Binding パスを検証
+            foreach (var binding in bindings)
+            {
+                // ElementName / RelativeSource binding はスキップ
+                if (binding.ElementName != null || binding.RelativeSource != null)
+                    continue;
+
+                // 空パス（DataContext 自体への Binding）はスキップ
+                if (string.IsNullOrWhiteSpace(binding.Path))
+                    continue;
+
+                var check = _analyzer.CheckBindingPath(vmType, binding.Path);
+                if (!check.IsValid)
+                {
+                    results.Add(new ValidationResult(
+                        xamlFile,
+                        binding.LineNumber,
+                        Severity.Error,
+                        $"{binding.ParentElementName}.{binding.TargetProperty}: "
+                        + $"Binding Path=\"{binding.Path}\" — {check.Message}"
+                    ));
+                }
+            }
+        }
+
+        return new ValidationReport(results);
+    }
+}
+```
+
+### `ValidationResult.cs` / `ValidationReport.cs`
+
+```csharp
+namespace XamlTestLib.Reporting;
+
+public enum Severity { Info, Warning, Error }
+
+public record ValidationResult(
+    string FilePath,
+    int LineNumber,
+    Severity Severity,
+    string Message
+);
+
+public class ValidationReport
+{
+    public IReadOnlyList<ValidationResult> Results { get; }
+    public int ErrorCount => Results.Count(r => r.Severity == Severity.Error);
+    public int WarningCount => Results.Count(r => r.Severity == Severity.Warning);
+    public bool HasErrors => ErrorCount > 0;
+
+    public ValidationReport(IReadOnlyList<ValidationResult> results)
+    {
+        Results = results;
+    }
+}
+```
+
+---
+
+## Step 6: CLI ツール
+
+### `Program.cs`
+
+```csharp
+using XamlTestLib.Analysis;
+
+if (args.Length == 0)
+{
+    Console.Error.WriteLine("Usage: xaml-test <path-to.csproj>");
+    return 1;
+}
+
+var csprojPath = Path.GetFullPath(args[0]);
+if (!File.Exists(csprojPath))
+{
+    Console.Error.WriteLine($"File not found: {csprojPath}");
+    return 1;
+}
+
+Console.WriteLine($"Loading project: {csprojPath}");
+
+using var loader = new RoslynProjectLoader();
+var compilation = await loader.LoadProjectAsync(csprojPath);
+if (compilation == null)
+{
+    Console.Error.WriteLine("Failed to load project.");
+    return 1;
+}
+
+// XAML ファイルを収集
+var projectDir = Path.GetDirectoryName(csprojPath)!;
+var xamlFiles = Directory.GetFiles(projectDir, "*.xaml", SearchOption.AllDirectories)
+    .Where(f => !f.Contains("obj") && !f.Contains("bin"))
+    .ToList();
+
+Console.WriteLine($"Found {xamlFiles.Count} XAML files.");
+
+var analyzer = new ViewModelAnalyzer(compilation);
+var validator = new BindingValidator(analyzer);
+var report = validator.Validate(xamlFiles);
+
+// 結果出力
+foreach (var result in report.Results)
+{
+    var icon = result.Severity switch
+    {
+        Severity.Error => "ERROR",
+        Severity.Warning => "WARN ",
+        _ => "INFO "
+    };
+    Console.WriteLine($"  [{icon}] {Path.GetFileName(result.FilePath)}:{result.LineNumber}");
+    Console.WriteLine($"          {result.Message}");
+}
+
+Console.WriteLine();
+Console.WriteLine($"Errors: {report.ErrorCount}, Warnings: {report.WarningCount}");
+
+return report.HasErrors ? 1 : 0;
+```
+
+---
+
+## Step 7: テストデータとユニットテスト
+
+### `TestData/SimpleViewModel.cs`（テスト用ソース文字列）
+
+```csharp
+public class SimpleViewModel
+{
+    public string UserName { get; set; }
+    public int Age { get; set; }
+    public Address Address { get; set; }
+}
+
+public class Address
+{
+    public string City { get; set; }
+    public string ZipCode { get; set; }
+}
+```
+
+### `XamlBindingExtractorTests.cs`
+
+```csharp
+public class XamlBindingExtractorTests
+{
+    [Fact]
+    public void Extract_SimpleBinding_ReturnsPath()
+    {
+        var xaml = CreateTempXaml("""
+            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+                <TextBox Text="{Binding UserName}" />
+            </Window>
+            """);
+
+        var extractor = new XamlBindingExtractor();
+        var bindings = extractor.Extract(xaml);
+
+        Assert.Single(bindings);
+        Assert.Equal("UserName", bindings[0].Path);
+        Assert.Equal("TextBox", bindings[0].ParentElementName);
+        Assert.Equal("Text", bindings[0].TargetProperty);
+    }
+
+    [Fact]
+    public void Extract_NestedPath_ReturnsDottedPath()
+    {
+        var xaml = CreateTempXaml("""
+            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+                <TextBlock Text="{Binding Address.City}" />
+            </Window>
+            """);
+
+        var extractor = new XamlBindingExtractor();
+        var bindings = extractor.Extract(xaml);
+
+        Assert.Single(bindings);
+        Assert.Equal("Address.City", bindings[0].Path);
+    }
+
+    [Fact]
+    public void Extract_BrokenBinding_StillParsesValid()
+    {
+        var xaml = CreateTempXaml("""
+            <Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+                <TextBox Text="{Binding UserName}" />
+                <TextBox Text="{Binding NonExistent}" />
+            </Window>
+            """);
+
+        var extractor = new XamlBindingExtractor();
+        var bindings = extractor.Extract(xaml);
+
+        Assert.Equal(2, bindings.Count);
+    }
+
+    private static string CreateTempXaml(string content)
+    {
+        var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xaml");
+        File.WriteAllText(path, content);
+        return path;
+    }
+}
+```
+
+### `BindingValidatorTests.cs`（Roslyn インメモリ Compilation）
+
+```csharp
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+public class BindingValidatorTests
+{
+    [Fact]
+    public void Validate_ValidBinding_NoErrors()
+    {
+        // Roslyn でインメモリ Compilation を作成（.csproj 不要）
+        var compilation = CreateCompilation("""
+            public class MainWindowViewModel
+            {
+                public string UserName { get; set; }
+            }
+            """);
+
+        var analyzer = new ViewModelAnalyzer(compilation);
+        var vmType = analyzer.FindTypeByName("MainWindowViewModel");
+
+        var result = analyzer.CheckBindingPath(vmType!, "UserName");
+        Assert.True(result.IsValid);
+    }
+
+    [Fact]
+    public void Validate_InvalidBinding_ReturnsError()
+    {
+        var compilation = CreateCompilation("""
+            public class MainWindowViewModel
+            {
+                public string UserName { get; set; }
+            }
+            """);
+
+        var analyzer = new ViewModelAnalyzer(compilation);
+        var vmType = analyzer.FindTypeByName("MainWindowViewModel");
+
+        var result = analyzer.CheckBindingPath(vmType!, "NonExistent");
+        Assert.False(result.IsValid);
+        Assert.Contains("not found", result.Message);
+    }
+
+    [Fact]
+    public void Validate_NestedPath_ResolvesCorrectly()
+    {
+        var compilation = CreateCompilation("""
+            public class MainWindowViewModel
+            {
+                public Address Address { get; set; }
+            }
+            public class Address
+            {
+                public string City { get; set; }
+            }
+            """);
+
+        var analyzer = new ViewModelAnalyzer(compilation);
+        var vmType = analyzer.FindTypeByName("MainWindowViewModel");
+
+        Assert.True(analyzer.CheckBindingPath(vmType!, "Address.City").IsValid);
+        Assert.False(analyzer.CheckBindingPath(vmType!, "Address.Country").IsValid);
+    }
+
+    private static Compilation CreateCompilation(string source)
+    {
+        var tree = CSharpSyntaxTree.ParseText(source);
+        return CSharpCompilation.Create("TestAssembly")
+            .AddReferences(MetadataReference.CreateFromFile(
+                typeof(object).Assembly.Location))
+            .AddSyntaxTrees(tree);
+    }
+}
+```
+
+---
+
+## 実装順序（PoC 最短ルート）
+
+1. **ソリューション初期構成** — `dotnet new` でプロジェクト群を作成
+2. **BindingInfo + XamlBindingExtractor** — XAML → Binding 式抽出（XML ベース）
+3. **XamlBindingExtractorTests** — テストデータで動作確認
+4. **ViewModelAnalyzer** — Roslyn インメモリ Compilation でプロパティ検証
+5. **BindingValidatorTests** — インメモリ Compilation でユニットテスト通過
+6. **DataContextResolver** — d:DataContext + 命名規約で View → ViewModel 対応
+7. **BindingValidator** — 統合ロジック
+8. **CLI Program.cs** — 実プロジェクト（SampleWpfApp）で E2E 動作確認
+
+**PoC ゴール**: SampleWpfApp に意図的に壊れた Binding を入れて、CLI が検出できること。
+
+---
+
+## 将来の拡張（Phase B+）
+
+| 機能 | 概要 | 難易度 |
+|------|------|--------|
+| **DataTemplate 内の Binding** | ItemsControl 系の DataTemplate の DataType から型解決 | 中 |
+| **Converter 存在チェック** | StaticResource で参照される Converter がリソースに存在するか | 中 |
+| **Command 存在チェック** | `Command="{Binding SaveCommand}"` → ICommand プロパティの存在確認 | 低 |
+| **MSBuild タスク** | ビルド時に自動実行、Warning/Error として VS に表示 | 中 |
+| **Roslyn Analyzer** | IDE 内リアルタイム警告（赤波線） | 高 |
+| **x:Bind 対応** | WinUI / UWP 向け | 中 |
+| **CI 用 JSON 出力** | GitHub Actions 等で Annotation として表示 | 低 |
+
+---
+
+## CLAUDE.md（初期内容案）
+
+```markdown
+# XamlTestLib
+
+WPF XAML Binding の静的検証ツール。画面表示なしで Binding パスの正当性を検証する。
+
+## ビルド・テスト
+
+dotnet build
+dotnet test
+
+## アーキテクチャ
+
+1. Parsing: XAML を XML として読み、{Binding} 式を抽出
+2. Analysis: Roslyn で ViewModel の型情報を取得し、Binding パスを検証
+3. Reporting: 結果をコンソール / JSON で出力
+
+## 命名規約
+
+- View: `*Window.xaml`, `*View.xaml`, `*Page.xaml`
+- ViewModel: `*ViewModel` (View 名 + "ViewModel")
+```