feat(cli): add scaffolding, config transforms, and full pipeline wiring

Add ProjectScaffolder, GlobalUsingsGenerator, ShimGenerator for project
scaffold generation (.csproj, Program.cs, _Imports.razor, App.razor,
Routes.razor, launchSettings.json, GlobalUsings.cs, shims).

Add WebConfigTransformer to parse web.config and generate appsettings.json
with appSettings key/values, connectionStrings, and standard Blazor sections.

Add DatabaseProviderDetector with 3-pass provider detection: explicit
providerName, connection string pattern matching, EntityClient inner provider.

Add OutputWriter with dry-run support, UTF-8 no BOM, directory creation,
and file tracking for reports.

Enhance MigrationReport with JSON serialization, console summary output,
and report file writing for --report flag.

Wire full pipeline in MigrationPipeline.ExecuteAsync:
1. Scaffold project (if not --skip-scaffold)
2. Transform config (web.config -> appsettings.json)
3. For each source file: markup + code-behind transforms -> write output
4. Generate report

Update Program.cs DI to register all new services. Add backward-compatible
2-param constructor on MigrationPipeline for existing tests.

All ported from bwfc-migrate.ps1: New-ProjectScaffold, New-AppRazorScaffold,
Convert-WebConfigToAppSettings, Find-DatabaseProvider.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: csharpfritz

src/BlazorWebFormsComponents.Cli/Config/DatabaseProviderDetector.cs

@@ -0,0 +1,155 @@
+using System.Xml.Linq;
+
+namespace BlazorWebFormsComponents.Cli.Config;
+
+/// <summary>
+/// Detects EF database provider from Web.config connectionStrings.
+/// Ported from Find-DatabaseProvider in bwfc-migrate.ps1.
+/// </summary>
+public class DatabaseProviderDetector
+{
+    private static readonly Dictionary<string, (string PackageName, string ProviderMethod)> ProviderMap = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ["System.Data.SqlClient"] = ("Microsoft.EntityFrameworkCore.SqlServer", "UseSqlServer"),
+        ["System.Data.SQLite"] = ("Microsoft.EntityFrameworkCore.Sqlite", "UseSqlite"),
+        ["Npgsql"] = ("Npgsql.EntityFrameworkCore.PostgreSQL", "UseNpgsql"),
+        ["MySql.Data.MySqlClient"] = ("Pomelo.EntityFrameworkCore.MySql", "UseMySql")
+    };
+
+    public DatabaseProviderInfo Detect(string sourcePath)
+    {
+        var defaultResult = new DatabaseProviderInfo
+        {
+            PackageName = "Microsoft.EntityFrameworkCore.SqlServer",
+            ProviderMethod = "UseSqlServer",
+            DetectedFrom = "Default — no Web.config connectionStrings found",
+            ConnectionString = ""
+        };
+
+        if (string.IsNullOrEmpty(sourcePath))
+            return defaultResult;
+
+        // Look for Web.config in source path and parent directory
+        var candidates = new[]
+        {
+            Path.Combine(sourcePath, "Web.config"),
+            Path.Combine(Path.GetDirectoryName(sourcePath) ?? sourcePath, "Web.config")
+        };
+
+        string? webConfigPath = null;
+        foreach (var candidate in candidates)
+        {
+            if (File.Exists(candidate))
+            {
+                webConfigPath = candidate;
+                break;
+            }
+        }
+
+        if (webConfigPath == null)
+            return defaultResult;
+
+        XDocument doc;
+        try
+        {
+            doc = XDocument.Load(webConfigPath);
+        }
+        catch
+        {
+            return defaultResult;
+        }
+
+        var connStringsElement = doc.Root?.Element("connectionStrings");
+        if (connStringsElement == null)
+            return defaultResult;
+
+        var adds = connStringsElement.Elements("add").ToList();
+        if (adds.Count == 0)
+            return defaultResult;
+
+        // Pass 1: Non-EntityClient entries with explicit providerName
+        foreach (var entry in adds)
+        {
+            var providerName = entry.Attribute("providerName")?.Value;
+            if (string.IsNullOrEmpty(providerName) || providerName == "System.Data.EntityClient")
+                continue;
+
+            if (ProviderMap.TryGetValue(providerName, out var mapped))
+            {
+                return new DatabaseProviderInfo
+                {
+                    PackageName = mapped.PackageName,
+                    ProviderMethod = mapped.ProviderMethod,
+                    DetectedFrom = $"Web.config providerName={providerName}",
+                    ConnectionString = entry.Attribute("connectionString")?.Value ?? ""
+                };
+            }
+        }
+
+        // Pass 2: Entries without providerName — detect from connection string content
+        foreach (var entry in adds)
+        {
+            var connString = entry.Attribute("connectionString")?.Value;
+            if (string.IsNullOrEmpty(connString) || connString.StartsWith("metadata=", StringComparison.OrdinalIgnoreCase))
+                continue;
+            if (entry.Attribute("providerName") != null)
+                continue;
+
+            if (System.Text.RegularExpressions.Regex.IsMatch(connString, @"(?i)\(LocalDB\)|Server="))
+            {
+                return new DatabaseProviderInfo
+                {
+                    PackageName = "Microsoft.EntityFrameworkCore.SqlServer",
+                    ProviderMethod = "UseSqlServer",
+                    DetectedFrom = "Web.config connection string pattern (SQL Server)",
+                    ConnectionString = connString
+                };
+            }
+
+            if (System.Text.RegularExpressions.Regex.IsMatch(connString, @"(?i)Data Source=.*\.db"))
+            {
+                return new DatabaseProviderInfo
+                {
+                    PackageName = "Microsoft.EntityFrameworkCore.Sqlite",
+                    ProviderMethod = "UseSqlite",
+                    DetectedFrom = "Web.config connection string pattern (SQLite)",
+                    ConnectionString = connString
+                };
+            }
+        }
+
+        // Pass 3: EntityClient entries — extract inner provider (EF6 pattern)
+        foreach (var entry in adds)
+        {
+            if (entry.Attribute("providerName")?.Value != "System.Data.EntityClient")
+                continue;
+
+            var connString = entry.Attribute("connectionString")?.Value ?? "";
+            var match = System.Text.RegularExpressions.Regex.Match(connString, @"provider=([^;""]+)");
+            if (match.Success)
+            {
+                var innerProvider = match.Groups[1].Value.Trim();
+                if (ProviderMap.TryGetValue(innerProvider, out var mapped))
+                {
+                    return new DatabaseProviderInfo
+                    {
+                        PackageName = mapped.PackageName,
+                        ProviderMethod = mapped.ProviderMethod,
+                        DetectedFrom = $"Web.config EntityClient provider={innerProvider}",
+                        ConnectionString = ""
+                    };
+                }
+            }
+        }
+
+        return defaultResult;
+    }
+}
+
+public class DatabaseProviderInfo
+{
+    public required string PackageName { get; init; }
+    public required string ProviderMethod { get; init; }
+    public required string DetectedFrom { get; init; }
+    public required string ConnectionString { get; init; }
+}

src/BlazorWebFormsComponents.Cli/Config/WebConfigTransformer.cs

@@ -0,0 +1,146 @@
+using System.Text.Json;
+using System.Xml.Linq;
+using BlazorWebFormsComponents.Cli.Io;
+
+namespace BlazorWebFormsComponents.Cli.Config;
+
+/// <summary>
+/// Parses Web.config and generates appsettings.json.
+/// Ported from Convert-WebConfigToAppSettings in bwfc-migrate.ps1 (line ~892).
+/// </summary>
+public class WebConfigTransformer
+{
+    private static readonly HashSet<string> BuiltInConnectionNames = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "LocalSqlServer",
+        "LocalMySqlServer"
+    };
+
+    /// <summary>
+    /// Transforms Web.config appSettings and connectionStrings into appsettings.json content.
+    /// Returns null if no Web.config found or no settings to extract.
+    /// </summary>
+    public WebConfigResult? Transform(string sourcePath)
+    {
+        // Find Web.config (case-insensitive search)
+        var webConfigPath = FindWebConfig(sourcePath);
+        if (webConfigPath == null)
+            return null;
+
+        XDocument doc;
+        try
+        {
+            doc = XDocument.Load(webConfigPath);
+        }
+        catch (Exception ex)
+        {
+            return new WebConfigResult
+            {
+                JsonContent = null,
+                AppSettingsCount = 0,
+                ConnectionStringsCount = 0,
+                Error = $"Could not parse Web.config: {ex.Message}"
+            };
+        }
+
+        var appSettings = new Dictionary<string, string>();
+        var connectionStrings = new Dictionary<string, string>();
+
+        // Parse <appSettings>
+        var appSettingsNodes = doc.Descendants("appSettings").Elements("add");
+        foreach (var node in appSettingsNodes)
+        {
+            var key = node.Attribute("key")?.Value;
+            var value = node.Attribute("value")?.Value ?? "";
+            if (!string.IsNullOrEmpty(key))
+            {
+                appSettings[key] = value;
+            }
+        }
+
+        // Parse <connectionStrings>
+        var connStrNodes = doc.Descendants("connectionStrings").Elements("add");
+        foreach (var node in connStrNodes)
+        {
+            var name = node.Attribute("name")?.Value;
+            var connStr = node.Attribute("connectionString")?.Value;
+            if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(connStr))
+            {
+                if (!BuiltInConnectionNames.Contains(name))
+                {
+                    connectionStrings[name] = connStr;
+                }
+            }
+        }
+
+        if (appSettings.Count == 0 && connectionStrings.Count == 0)
+            return null;
+
+        // Build JSON structure
+        var jsonObj = new Dictionary<string, object>();
+
+        if (connectionStrings.Count > 0)
+        {
+            jsonObj["ConnectionStrings"] = connectionStrings;
+        }
+
+        foreach (var entry in appSettings)
+        {
+            jsonObj[entry.Key] = entry.Value;
+        }
+
+        // Add standard Blazor sections
+        if (!jsonObj.ContainsKey("Logging"))
+        {
+            jsonObj["Logging"] = new Dictionary<string, object>
+            {
+                ["LogLevel"] = new Dictionary<string, string>
+                {
+                    ["Default"] = "Information",
+                    ["Microsoft.AspNetCore"] = "Warning"
+                }
+            };
+        }
+
+        if (!jsonObj.ContainsKey("AllowedHosts"))
+        {
+            jsonObj["AllowedHosts"] = "*";
+        }
+
+        var options = new JsonSerializerOptions
+        {
+            WriteIndented = true
+        };
+        var jsonContent = JsonSerializer.Serialize(jsonObj, options);
+
+        return new WebConfigResult
+        {
+            JsonContent = jsonContent,
+            AppSettingsCount = appSettings.Count,
+            ConnectionStringsCount = connectionStrings.Count,
+            AppSettingsKeys = [.. appSettings.Keys],
+            ConnectionStringNames = [.. connectionStrings.Keys]
+        };
+    }
+
+    private static string? FindWebConfig(string sourcePath)
+    {
+        var path1 = Path.Combine(sourcePath, "Web.config");
+        if (File.Exists(path1)) return path1;
+
+        var path2 = Path.Combine(sourcePath, "web.config");
+        if (File.Exists(path2)) return path2;
+
+        return null;
+    }
+}
+
+public class WebConfigResult
+{
+    public string? JsonContent { get; init; }
+    public int AppSettingsCount { get; init; }
+    public int ConnectionStringsCount { get; init; }
+    public List<string> AppSettingsKeys { get; init; } = [];
+    public List<string> ConnectionStringNames { get; init; } = [];
+    public string? Error { get; init; }
+}

src/BlazorWebFormsComponents.Cli/Io/OutputWriter.cs

@@ -0,0 +1,69 @@
+using System.Text;
+
+namespace BlazorWebFormsComponents.Cli.Io;
+
+/// <summary>
+/// Centralized output writer that respects --dry-run and tracks all written files.
+/// UTF-8 encoding without BOM, creates directories as needed.
+/// </summary>
+public class OutputWriter
+{
+    private static readonly Encoding Utf8NoBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);
+    private readonly List<string> _writtenFiles = [];
+
+    public bool DryRun { get; set; }
+    public bool Verbose { get; set; }
+
+    public IReadOnlyList<string> WrittenFiles => _writtenFiles;
+
+    /// <summary>
+    /// Write content to a file, respecting dry-run mode.
+    /// </summary>
+    public async Task WriteFileAsync(string path, string content, string description)
+    {
+        if (DryRun)
+        {
+            Console.WriteLine($"  [dry-run] Would write: {path}");
+            if (Verbose)
+                Console.WriteLine($"            ({description})");
+            return;
+        }
+
+        var directory = Path.GetDirectoryName(path);
+        if (!string.IsNullOrEmpty(directory))
+            Directory.CreateDirectory(directory);
+
+        await File.WriteAllTextAsync(path, content, Utf8NoBom);
+        _writtenFiles.Add(path);
+
+        if (Verbose)
+            Console.WriteLine($"  ✓ {path} ({description})");
+    }
+
+    /// <summary>
+    /// Copy a file to the output, respecting dry-run mode.
+    /// </summary>
+    public void CopyFile(string source, string destination, string description)
+    {
+        if (DryRun)
+        {
+            Console.WriteLine($"  [dry-run] Would copy: {source} → {destination}");
+            return;
+        }
+
+        var directory = Path.GetDirectoryName(destination);
+        if (!string.IsNullOrEmpty(directory))
+            Directory.CreateDirectory(directory);
+
+        File.Copy(source, destination, overwrite: true);
+        _writtenFiles.Add(destination);
+
+        if (Verbose)
+            Console.WriteLine($"  ✓ {destination} ({description})");
+    }
+
+    public void Reset()
+    {
+        _writtenFiles.Clear();
+    }
+}