Refactor GenerateCommand into focused modules and stabilize package-reference builds

.github/copilot-instructions.md

@@ -257,3 +257,6 @@ dotnet run --project src/Refitter --configuration Release --framework net9.0 --
 - Commit messages should be brief, clear and descriptive of the changes made
 - Avoid using multi-line commit messages; if necessary, use bullet points for clarity
 - Commit changes in small logical units to facilitate easier code review and debugging
+- **AI agents MUST commit after every logical unit of work** — do not accumulate all changes into a single end-of-task commit. Commit each independently-releasable unit (e.g. new file, new feature, refactor step) as soon as it is ready and building.
+- **NEVER add a co-author to commits.** Do not include `Co-authored-by:` trailers or any attribution to AI tools in commit messages. Commits are owned by the developer.
+- This commit policy is automatic and applies to all agentic work — do not wait for the user to request it.

src/Refitter.Core/RefitterSettingsLoader.cs

@@ -0,0 +1,68 @@
+namespace Refitter.Core;
+
+/// <summary>
+/// Loads <see cref="RefitGeneratorSettings"/> from the contents of a <c>.refitter</c> settings file.
+/// </summary>
+/// <remarks>
+/// This module deliberately operates on already-read JSON text plus the directory the settings
+/// file lives in, rather than reading the file itself. File reading stays with each consumer
+/// (the CLI reads from disk; the source generator reads via Roslyn's <c>AdditionalText</c>), which
+/// keeps filesystem APIs out of the analyzer assembly and preserves incremental-generation semantics.
+/// </remarks>
+public static class RefitterSettingsLoader
+{
+    /// <summary>
+    /// Deserializes the contents of a <c>.refitter</c> settings file and resolves any relative
+    /// OpenAPI specification paths against the directory the settings file lives in.
+    /// </summary>
+    /// <param name="json">The raw contents of the <c>.refitter</c> settings file.</param>
+    /// <param name="baseDirectory">
+    /// The directory the settings file lives in. Relative <see cref="RefitGeneratorSettings.OpenApiPath"/>
+    /// and <see cref="RefitGeneratorSettings.OpenApiPaths"/> entries are resolved against this directory.
+    /// </param>
+    /// <returns>The deserialized settings with relative specification paths resolved to absolute paths.</returns>
+    /// <exception cref="System.Text.Json.JsonException">Thrown when <paramref name="json"/> cannot be deserialized.</exception>
+    public static RefitGeneratorSettings Load(string json, string baseDirectory)
+    {
+        var settings = Serializer.Deserialize<RefitGeneratorSettings>(json);
+        ResolveRelativeSpecPaths(settings, baseDirectory);
+        return settings;
+    }
+
+    /// <summary>
+    /// Resolves any relative OpenAPI specification paths on <paramref name="settings"/> against
+    /// <paramref name="baseDirectory"/>. URLs and already-rooted paths are left untouched.
+    /// </summary>
+    /// <param name="settings">The settings whose specification paths should be resolved.</param>
+    /// <param name="baseDirectory">The directory to resolve relative paths against.</param>
+    public static void ResolveRelativeSpecPaths(RefitGeneratorSettings settings, string baseDirectory)
+    {
+        if (!string.IsNullOrWhiteSpace(settings.OpenApiPath) &&
+            !IsUrl(settings.OpenApiPath!) &&
+            !Path.IsPathRooted(settings.OpenApiPath))
+        {
+            settings.OpenApiPath = Path.GetFullPath(Path.Combine(baseDirectory, settings.OpenApiPath!));
+        }
+
+        if (settings.OpenApiPaths is { Length: > 0 })
+        {
+            for (var i = 0; i < settings.OpenApiPaths.Length; i++)
+            {
+                var path = settings.OpenApiPaths[i];
+                if (!IsUrl(path) && !Path.IsPathRooted(path))
+                {
+                    settings.OpenApiPaths[i] = Path.GetFullPath(Path.Combine(baseDirectory, path));
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Determines whether the specified path is an absolute HTTP or HTTPS URL.
+    /// </summary>
+    /// <param name="path">The path to inspect.</param>
+    /// <returns><see langword="true"/> when the path is an HTTP or HTTPS URL; otherwise <see langword="false"/>.</returns>
+    public static bool IsUrl(string path) =>
+        Uri.TryCreate(path, UriKind.Absolute, out var uriResult) &&
+        (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
+}

src/Refitter.SourceGenerator.Tests/SourceGeneratorPackageReferenceTests.cs

@@ -65,6 +65,8 @@ public void Packed_SourceGenerator_Package_Should_Only_Ship_Its_Own_Analyzer_Ass
 
     private static string PackSourceGeneratorPackage(string workspace, string version)
     {
+        using var buildLock = AcquireBuildLock();
+
         var repoRoot = GetRepositoryRoot();
         var projectFile = Path.Combine(repoRoot, "src", "Refitter.SourceGenerator", "Refitter.SourceGenerator.csproj");
         var packageOutputPath = Path.Combine(workspace, "packages");
@@ -125,6 +127,25 @@ private static void BuildSourceGeneratorProject(
         process.ExitCode.Should().Be(0, $"dotnet build should succeed before pack{Environment.NewLine}{output}{Environment.NewLine}{error}");
     }
 
+    private static FileStream AcquireBuildLock()
+    {
+        var lockFilePath = Path.Combine(Path.GetTempPath(), "refitter-source-generator-package-tests.lock");
+        var timeout = TimeSpan.FromMinutes(2);
+        var startedAt = DateTime.UtcNow;
+
+        while (true)
+        {
+            try
+            {
+                return new FileStream(lockFilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
+            }
+            catch (IOException) when (DateTime.UtcNow - startedAt < timeout)
+            {
+                Thread.Sleep(TimeSpan.FromMilliseconds(100));
+            }
+        }
+    }
+
     private static string CreateWorkspace()
     {
         var workspace = Path.Combine(AppContext.BaseDirectory, "SourceGeneratorPackageReferenceTests", Guid.NewGuid().ToString("N"));

src/Refitter.SourceGenerator/RefitterSourceGenerator.cs

@@ -159,31 +159,7 @@ internal static GeneratedCode GenerateCode(
     private static void ResolveRelativeSpecPaths(string settingsFilePath, RefitGeneratorSettings settings)
     {
         var settingsFileDirectory = Path.GetDirectoryName(Path.GetFullPath(settingsFilePath)) ?? string.Empty;
-
-        if (!string.IsNullOrWhiteSpace(settings.OpenApiPath) &&
-            !IsUrl(settings.OpenApiPath) &&
-            !Path.IsPathRooted(settings.OpenApiPath))
-        {
-            settings.OpenApiPath = Path.GetFullPath(Path.Combine(settingsFileDirectory, settings.OpenApiPath));
-        }
-
-        if (settings.OpenApiPaths is { Length: > 0 })
-        {
-            for (var i = 0; i < settings.OpenApiPaths.Length; i++)
-            {
-                var path = settings.OpenApiPaths[i];
-                if (!IsUrl(path) && !Path.IsPathRooted(path))
-                {
-                    settings.OpenApiPaths[i] = Path.GetFullPath(Path.Combine(settingsFileDirectory, path));
-                }
-            }
-        }
-    }
-
-    private static bool IsUrl(string path)
-    {
-        return Uri.TryCreate(path, UriKind.Absolute, out var uriResult) &&
-               (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
+        RefitterSettingsLoader.ResolveRelativeSpecPaths(settings, settingsFileDirectory);
     }
 
     internal static GeneratedDiagnostic CreateNoRefitterFilesFoundDiagnostic() =>

src/Refitter.Tests/FileWriterTests.cs

@@ -0,0 +1,92 @@
+using FluentAssertions;
+using TUnit.Core;
+
+namespace Refitter.Tests;
+
+public class FileWriterTests
+{
+    private static readonly string TestRoot =
+        Path.Combine(Path.GetTempPath(), "refitter-filewriter-tests");
+
+    [Test]
+    public async Task WriteAsync_Writes_Content_To_Existing_Directory()
+    {
+        var tempFile = Path.Combine(Path.GetTempPath(), $"refitter-fw-{Guid.NewGuid()}.cs");
+        const string content = "// generated code";
+
+        try
+        {
+            await FileWriter.WriteAsync(tempFile, content);
+
+            File.Exists(tempFile).Should().BeTrue();
+            (await File.ReadAllTextAsync(tempFile)).Should().Be(content);
+        }
+        finally
+        {
+            if (File.Exists(tempFile))
+                File.Delete(tempFile);
+        }
+    }
+
+    [Test]
+    public async Task WriteAsync_Creates_Missing_Directory()
+    {
+        var subDir = Path.Combine(TestRoot, Guid.NewGuid().ToString(), "nested");
+        var filePath = Path.Combine(subDir, "Output.cs");
+        const string content = "// code in new directory";
+
+        try
+        {
+            await FileWriter.WriteAsync(filePath, content);
+
+            File.Exists(filePath).Should().BeTrue();
+            (await File.ReadAllTextAsync(filePath)).Should().Be(content);
+        }
+        finally
+        {
+            if (Directory.Exists(subDir))
+                Directory.Delete(subDir, recursive: true);
+        }
+    }
+
+    [Test]
+    public async Task WriteAsync_PlannedFile_Writes_Content()
+    {
+        var tempFile = Path.Combine(Path.GetTempPath(), $"refitter-fw-planned-{Guid.NewGuid()}.cs");
+        const string content = "// planned content";
+
+        try
+        {
+            await FileWriter.WriteAsync(new PlannedFile(tempFile, content));
+
+            File.Exists(tempFile).Should().BeTrue();
+            (await File.ReadAllTextAsync(tempFile)).Should().Be(content);
+        }
+        finally
+        {
+            if (File.Exists(tempFile))
+                File.Delete(tempFile);
+        }
+    }
+
+    [Test]
+    public async Task WriteAsync_PlannedFile_Creates_Missing_Directory()
+    {
+        var subDir = Path.Combine(TestRoot, Guid.NewGuid().ToString(), "planned");
+        var filePath = Path.Combine(subDir, "Planned.cs");
+        const string content = "// planned in new dir";
+
+        try
+        {
+            await FileWriter.WriteAsync(new PlannedFile(filePath, content));
+
+            File.Exists(filePath).Should().BeTrue();
+            (await File.ReadAllTextAsync(filePath)).Should().Be(content);
+        }
+        finally
+        {
+            if (Directory.Exists(subDir))
+                Directory.Delete(subDir, recursive: true);
+        }
+    }
+}

src/Refitter.Tests/OpenApiStatisticsFormatterTests.cs

@@ -0,0 +1,84 @@
+using FluentAssertions;
+using TUnit.Core;
+
+namespace Refitter.Tests;
+
+public class OpenApiStatisticsFormatterTests
+{
+    [Test]
+    public void Parse_Returns_Empty_For_Empty_String()
+    {
+        OpenApiStatisticsFormatter.Parse(string.Empty).Should().BeEmpty();
+    }
+
+    [Test]
+    public void Parse_Returns_Empty_When_No_Lines_Start_With_Dash()
+    {
+        OpenApiStatisticsFormatter.Parse("Paths: 5\nOperations: 10").Should().BeEmpty();
+    }
+
+    [Test]
+    public void Parse_Returns_Label_Value_Pairs_From_Dash_Lines()
+    {
+        var statistics = $"- Paths: 5{Environment.NewLine}- Operations: 10{Environment.NewLine}- Schemas: 20";
+
+        var result = OpenApiStatisticsFormatter.Parse(statistics);
+
+        result.Should().HaveCount(3);
+        result[0].Should().Be(("Paths", "5"));
+        result[1].Should().Be(("Operations", "10"));
+        result[2].Should().Be(("Schemas", "20"));
+    }
+
+    [Test]
+    public void Parse_Skips_Lines_Not_Starting_With_Dash()
+    {
+        var statistics = $"Summary:{Environment.NewLine}- Paths: 5{Environment.NewLine}Footer";
+
+        var result = OpenApiStatisticsFormatter.Parse(statistics);
+
+        result.Should().HaveCount(1);
+        result[0].Should().Be(("Paths", "5"));
+    }
+
+    [Test]
+    public void Parse_Skips_Lines_Without_Colon_Separator()
+    {
+        var statistics = $"- ValidLine: 1{Environment.NewLine}- NoColon";
+
+        var result = OpenApiStatisticsFormatter.Parse(statistics);
+
+        result.Should().HaveCount(1);
+        result[0].Should().Be(("ValidLine", "1"));
+    }
+
+    [Test]
+    [Arguments("Paths", "📝")]
+    [Arguments("Operations", "⚡")]
+    [Arguments("Parameters", "📝")]
+    [Arguments("Request Bodies", "📤")]
+    [Arguments("Responses", "📥")]
+    [Arguments("Links", "🔗")]
+    [Arguments("Callbacks", "🔄")]
+    [Arguments("Schemas", "📋")]
+    [Arguments("Unknown Metric", "📊")]
+    public void GetIcon_Returns_Expected_Icon(string label, string expectedIcon)
+    {
+        OpenApiStatisticsFormatter.GetIcon(label).Should().Be(expectedIcon);
+    }
+
+    [Test]
+    [Arguments("Paths", "API endpoints defined")]
+    [Arguments("Operations", "HTTP operations available")]
+    [Arguments("Parameters", "Input parameters defined")]
+    [Arguments("Request Bodies", "Request body schemas")]
+    [Arguments("Responses", "Response schemas defined")]
+    [Arguments("Links", "Operation links")]
+    [Arguments("Callbacks", "Callback definitions")]
+    [Arguments("Schemas", "Data schemas defined")]
+    [Arguments("Unknown Metric", "API specification metric")]
+    public void GetDescription_Returns_Expected_Description(string label, string expectedDescription)
+    {
+        OpenApiStatisticsFormatter.GetDescription(label).Should().Be(expectedDescription);
+    }
+}