Merge branch 'feature/gitreader-primitive' into devel

kekyo · kekyo · commit 226667af58ec · 2025-07-01T18:51:06.000+09:00
diff --git a/RelaxVersioner.Core.Tests/AnalyzerTests.cs b/RelaxVersioner.Core.Tests/AnalyzerTests.cs
@@ -8,7 +8,7 @@
 ////////////////////////////////////////////////////////////////////////////////////////
 
 using GitReader;
-using GitReader.Structures;
+using GitReader.Primitive;
 using NUnit.Framework;
 using System.IO;
 using System.Threading.Tasks;
@@ -30,7 +30,7 @@ public sealed class AnalyzerTests
     [TestCase("MultiRoot2", "0.10.22")]
     public async Task LookupVersionLabel(string repositoryName, string expectedString)
     {
-        using var repository = await Repository.Factory.OpenStructureAsync(
+        using var repository = await Repository.Factory.OpenPrimitiveAsync(
             Path.Combine(TestsSetUp.BasePath, repositoryName));
 
         var actual = await Analyzer.LookupVersionLabelAsync(repository, false, default);
diff --git a/RelaxVersioner.Core.Tests/Analyzer_WorkingDirectory.cs b/RelaxVersioner.Core.Tests/Analyzer_WorkingDirectory.cs
@@ -8,7 +8,7 @@
 ////////////////////////////////////////////////////////////////////////////////////////
 
 using GitReader;
-using GitReader.Structures;
+using GitReader.Primitive;
 using NUnit.Framework;
 using System;
 using System.IO;
@@ -42,54 +42,54 @@ public async Task LookupVersionLabelWithWorkingDirectoryChanges()
             
             // Test 1: Clean working directory - should return tagged version
             Hash root;
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
-                root = repository.Head!.Head;
+                root = (await repository.GetCurrentHeadReferenceAsync())!.Value;
 
                 var version = await Analyzer.LookupVersionLabelAsync(repository, true, default);
                 Assert.That(version.ToString(), Is.EqualTo("1.2.3"));
             }
             
             // Test 2: Modified file (unstaged) - should increment version
             File.WriteAllText(testFile, "modified content");
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, true, default);
                 Assert.That(version.ToString(), Is.EqualTo("1.2.4"));
             }
             
             // Test 3: Staged file - should increment version
             await TestUtilities.RunGitCommand(tempPath, "add test.txt");
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, true, default);
                 Assert.That(version.ToString(), Is.EqualTo("1.2.4"));
             }
             
             // Test 4: Commit staged file and test untracked file
             await TestUtilities.RunGitCommand(tempPath, "commit -m \"Test\"");
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, true, default);
                 Assert.That(version.ToString(), Is.EqualTo("1.2.4"));
             }
             var untrackedFile = Path.Combine(tempPath, "untracked.txt");
             File.WriteAllText(untrackedFile, "untracked content");
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, true, default);
                 Assert.That(version.ToString(), Is.EqualTo("1.2.5"));
             }
             
             // Test 5: Reset
             await TestUtilities.RunGitCommand(tempPath, $"reset --hard {root}");
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, true, default);
                 Assert.That(version.ToString(), Is.EqualTo("1.2.4"));
             }
             await TestUtilities.RunGitCommand(tempPath, $"clean -xfd");   // Remove `untracked.txt`
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, true, default);
                 Assert.That(version.ToString(), Is.EqualTo("1.2.3"));
@@ -127,7 +127,7 @@ public async Task LookupVersionLabelWithInitialRepository()
             await TestUtilities.RunGitCommand(tempPath, "config user.name \"Test User\"");
             
             // Test 1: Initial repository with no commits and no files - should return default version
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, false, default);
                 Assert.That(version.ToString(), Is.EqualTo("0.0.1"));
@@ -136,15 +136,15 @@ public async Task LookupVersionLabelWithInitialRepository()
             // Test 2: Initial repository with untracked file - should still return default version
             var testFile = Path.Combine(tempPath, "test.txt");
             File.WriteAllText(testFile, "content");
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, false, default);
                 Assert.That(version.ToString(), Is.EqualTo("0.0.1"));
             }
             
             // Test 3: Initial repository with staged file (but no commits) - should still return default version
             await TestUtilities.RunGitCommand(tempPath, "add test.txt");
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, false, default);
                 Assert.That(version.ToString(), Is.EqualTo("0.0.1"));
@@ -153,7 +153,7 @@ public async Task LookupVersionLabelWithInitialRepository()
             // Test 4: Initial repository with unstaged changes after staging - should still return default version
             // First modify the staged file to create unstaged changes
             File.WriteAllText(testFile, "modified content");
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, false, default);
                 Assert.That(version.ToString(), Is.EqualTo("0.0.1"));
@@ -163,7 +163,7 @@ public async Task LookupVersionLabelWithInitialRepository()
             var testFile2 = Path.Combine(tempPath, "test2.txt");
             File.WriteAllText(testFile2, "second file content");
             await TestUtilities.RunGitCommand(tempPath, "add test2.txt");
-            using (var repository = await Repository.Factory.OpenStructureAsync(tempPath))
+            using (var repository = await Repository.Factory.OpenPrimitiveAsync(tempPath))
             {
                 var version = await Analyzer.LookupVersionLabelAsync(repository, false, default);
                 Assert.That(version.ToString(), Is.EqualTo("0.0.1"));
diff --git a/RelaxVersioner.Core/Analyzer.cs b/RelaxVersioner.Core/Analyzer.cs
@@ -12,26 +12,26 @@
 using System.Threading;
 using System.Threading.Tasks;
 using GitReader.IO;
-using GitReader.Structures;
+using GitReader.Primitive;
 
 namespace RelaxVersioner;
 
 internal static class Analyzer
 {
     private readonly struct ScheduledCommit
     {
-        public readonly Commit Commit;
-        public readonly Commit[] Parents;
+        public readonly PrimitiveCommit Commit;
+        public readonly PrimitiveCommit[] Parents;
 
         public ScheduledCommit(
-            Commit commit, Commit[] parents)
+            PrimitiveCommit commit, PrimitiveCommit[] parents)
         {
             this.Commit = commit;
             this.Parents = parents;
         }
 
         public void Deconstruct(
-            out Commit commit, out Commit[] parents)
+            out PrimitiveCommit commit, out PrimitiveCommit[] parents)
         {
             commit = this.Commit;
             parents = this.Parents;
@@ -70,7 +70,9 @@ private static Version IncrementLastVersionComponent(
     }
 
     private static async Task<Version> LookupVersionLabelRecursiveAsync(
-        Commit commit, Dictionary<Commit, Version> reached, CancellationToken ct)
+        PrimitiveRepository repository,
+        PrimitiveCommit commit,
+        Dictionary<PrimitiveCommit, Version> reached, CancellationToken ct)
     {
         var scheduledStack = new Stack<ScheduledCommit>();
         var version = Version.Default;
@@ -89,7 +91,7 @@ private static async Task<Version> LookupVersionLabelRecursiveAsync(
             }
 
             // Detected mostly larger version tag.
-            var candidates = commit.Tags.
+            var candidates = (await repository.GetRelatedTagsAsync(commit, ct)).
                 Select(tag => Version.TryParse(tag.Name, out var v) ? v : null!).
                 Where(v => v?.ComponentCount >= 2).     // "1.2" or more.
                 OrderByDescending(v => v).
@@ -101,7 +103,11 @@ private static async Task<Version> LookupVersionLabelRecursiveAsync(
                 break;
             }
 
-            var parents = await commit.GetParentCommitsAsync(ct);
+            var parents = (await LooseConcurrentScope.Default.WhenAll(
+                commit.Parents.Select(parentCommitHash => repository.GetCommitAsync(parentCommitHash, ct)))).
+                Where(parentCommitHash => parentCommitHash.HasValue).
+                Select(parentCommitHash => parentCommitHash!.Value).
+                ToArray();
             if (parents.Length == 0)
             {
                 reached.Add(commit, version);
@@ -124,7 +130,7 @@ private static async Task<Version> LookupVersionLabelRecursiveAsync(
             {
                 for (var index = 1; index < pcs.Length; index++)
                 {
-                    var v = await LookupVersionLabelRecursiveAsync(pcs[index], reached, ct);
+                    var v = await LookupVersionLabelRecursiveAsync(repository, pcs[index], reached, ct);
                     if (v.CompareTo(version) > 0)
                     {
                         version = v;
@@ -140,19 +146,20 @@ private static async Task<Version> LookupVersionLabelRecursiveAsync(
     }
 
     private static async Task<Version> RunLookupVersionLabelAsync(
-        Branch branch, CancellationToken ct)
+        PrimitiveRepository repository,
+        PrimitiveReference branch, CancellationToken ct)
     {
-        var headCommit = await branch.GetHeadCommitAsync(ct);
-        return await LookupVersionLabelRecursiveAsync(headCommit, new(), ct);
+        var headCommit = await repository.GetCommitAsync(branch, ct);
+        return await LookupVersionLabelRecursiveAsync(repository, headCommit!.Value, new(), ct);
     }
 
     public static async Task<Version> LookupVersionLabelAsync(
-        StructuredRepository repository,
+        PrimitiveRepository repository,
         bool checkWorkingDirectoryStatus,
         CancellationToken ct)
     {
         // Check if repository has any commits (to handle initial state)
-        if (repository.Head is not { } branch)
+        if (await repository.GetCurrentHeadReferenceAsync(ct) is not { } branch)
         {
             return Version.Default; // Return default version (0.0.1) if no HEAD
         }
@@ -161,14 +168,19 @@ public static async Task<Version> LookupVersionLabelAsync(
         {
             var (baseVersion, workingDirectoryStatus) = await LooseConcurrentScope.Default.Join(
                 // Get the base version from commit tags
-                RunLookupVersionLabelAsync(branch, ct),
+                RunLookupVersionLabelAsync(repository, branch, ct),
                 // Check working directory status
                 repository.GetWorkingDirectoryStatusAsync(ct));
 
             // If there are modified files, increment the version
             if (workingDirectoryStatus.StagedFiles.Count > 0 ||
-                workingDirectoryStatus.UnstagedFiles.Count > 0 ||
-                workingDirectoryStatus.UntrackedFiles.Count > 0)
+                workingDirectoryStatus.UnstagedFiles.Count > 0)
+            {
+                return IncrementLastVersionComponent(baseVersion);
+            }
+
+            var untrackedFiles = await repository.GetUntrackedFilesAsync(workingDirectoryStatus, ct);
+            if (untrackedFiles.Count > 0)
             {
                 return IncrementLastVersionComponent(baseVersion);
             }
@@ -177,7 +189,7 @@ public static async Task<Version> LookupVersionLabelAsync(
         }
         else
         {
-            return await RunLookupVersionLabelAsync(branch, ct);
+            return await RunLookupVersionLabelAsync(repository, branch, ct);
         }
     }
 }
diff --git a/RelaxVersioner.Core/Processor.cs b/RelaxVersioner.Core/Processor.cs
@@ -1,4 +1,4 @@
-﻿////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////
 //
 // RelaxVersioner - Git tag/branch based, full-automatic version generator.
 // Copyright (c) Kouji Matsui (@kozy_kekyo, @kekyo@mi.kekyo.net)
@@ -17,7 +17,8 @@
 using System.Xml.Linq;
 
 using GitReader;
-using GitReader.Structures;
+using GitReader.IO;
+using GitReader.Primitive;
 
 using RelaxVersioner.Writers;
 
@@ -66,13 +67,13 @@ private static async Task<Result> WriteVersionSourceFileAsync(
         Logger logger,
         WriteProviderBase writeProvider,
         ProcessorContext context,
-        StructuredRepository? repository,
-        Branch? targetBranch,
+        PrimitiveRepository repository,
+        PrimitiveReference? targetBranch,
         DateTimeOffset generated,
         CancellationToken ct)
     {
-        var commit = targetBranch != null ?
-            await targetBranch.GetHeadCommitAsync(ct) :
+        var commit = targetBranch is { } tb ?
+            await repository.GetCommitAsync(tb, ct) :
             null;
 
         var commitId = commit?.Hash.ToString() ??
@@ -86,14 +87,22 @@ static string FormatSignature(Signature? sig) => sig is { } s ?
         var committer = FormatSignature(commit?.Committer);
         var commitDate = commit?.Committer.Date ?? generated;
 
-        var branches = commit?.Branches.
-            Select(b => b.Name).
-            ToArray() ?? Array.Empty<string>();
+        var branches = commit is { } c1 ?
+            (await repository.GetBranchHeadReferencesAsync(ct)).
+                Where(b => b.Target.Equals(c1.Hash)).
+                Select(b => b.Name).
+                ToArray() :
+            [];
         var branchesString = string.Join(",", branches);
 
-        var tags = commit?.Tags.
+        var tags = commit is { } c2 ?
+            (await LooseConcurrentScope.Default.WhenAll(
+                (await repository.GetTagReferencesAsync(ct)).
+                Select(t => repository.GetTagAsync(t, ct)))).
+            Where(t => t.Hash.Equals(c2.Hash)).
             Select(b => b.Name).
-            ToArray() ?? Array.Empty<string>();
+            ToArray() :
+            [];
         var tagsString = string.Join(",", tags);
 
         var safeVersion = Utilities.GetSafeVersionFromDate(commitDate);
@@ -145,6 +154,21 @@ static string FormatSignature(Signature? sig) => sig is { } s ?
 
         writeProvider.Write(context, keyValues, generated);
 
+        string subject;
+        string body;
+
+        if (commit is { } c)
+        {
+            var index = c.Message.IndexOf("\n\n");
+            subject = ((index >= 0) ? c.Message.Substring(0, index) : c.Message).Trim('\n').Replace('\n', ' ');
+            body = (index >= 0) ? c.Message.Substring(index + 2) : string.Empty;
+        }
+        else
+        {
+            subject = null;
+            body = null;
+        }
+
         return new Result(
             versionLabel,
             shortVersion,
@@ -157,8 +181,8 @@ static string FormatSignature(Signature? sig) => sig is { } s ?
             commitDate,
             author,
             committer,
-            commit?.Subject,
-            commit?.Body);
+            subject,
+            body);
     }
 
     public async Task<Result> RunAsync(
@@ -175,7 +199,7 @@ public async Task<Result> RunAsync(
             writeProvider,
             context,
             repository,
-            repository?.Head,
+            await repository.GetCurrentHeadReferenceAsync(ct),
             DateTimeOffset.Now,
             ct);
     }
diff --git a/RelaxVersioner.Core/RelaxVersioner.Core.csproj b/RelaxVersioner.Core/RelaxVersioner.Core.csproj
@@ -12,12 +12,12 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GitReader" Version="1.14.0" />
+    <PackageReference Include="GitReader" Version="1.15.0" />
     <PackageReference Include="NamingFormatter" Version="2.4.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="All" />
     <PackageReference Condition="'$(RV_BOOTSTRAP)' != 'True'"
-                      Include="RelaxVersioner" Version="3.13.0" PrivateAssets="all" />
+                      Include="RelaxVersioner" Version="3.15.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/RelaxVersioner.Core/Utilities.cs b/RelaxVersioner.Core/Utilities.cs

Original file line number	Diff line number	Diff line change
`@@ -12,26 +12,26 @@`
`12`	`12`	`using System.Threading;`
`13`	`13`	`using System.Threading.Tasks;`
`14`	`14`	`using GitReader.IO;`
`15`		`-using GitReader.Structures;`
	`15`	`+using GitReader.Primitive;`
`16`	`16`
`17`	`17`	`namespace RelaxVersioner;`
`18`	`18`
`19`	`19`	`internal static class Analyzer`
`20`	`20`	`{`
`21`	`21`	`private readonly struct ScheduledCommit`
`22`	`22`	`{`
`23`		`- public readonly Commit Commit;`
`24`		`- public readonly Commit[] Parents;`
	`23`	`+ public readonly PrimitiveCommit Commit;`
	`24`	`+ public readonly PrimitiveCommit[] Parents;`
`25`	`25`
`26`	`26`	`public ScheduledCommit(`
`27`		`- Commit commit, Commit[] parents)`
	`27`	`+ PrimitiveCommit commit, PrimitiveCommit[] parents)`
`28`	`28`	`{`
`29`	`29`	`this.Commit = commit;`
`30`	`30`	`this.Parents = parents;`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public void Deconstruct(`
`34`		`- out Commit commit, out Commit[] parents)`
	`34`	`+ out PrimitiveCommit commit, out PrimitiveCommit[] parents)`
`35`	`35`	`{`
`36`	`36`	`commit = this.Commit;`
`37`	`37`	`parents = this.Parents;`
`@@ -70,7 +70,9 @@ private static Version IncrementLastVersionComponent(`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`private static async Task<Version> LookupVersionLabelRecursiveAsync(`
`73`		`- Commit commit, Dictionary<Commit, Version> reached, CancellationToken ct)`
	`73`	`+ PrimitiveRepository repository,`
	`74`	`+ PrimitiveCommit commit,`
	`75`	`+ Dictionary<PrimitiveCommit, Version> reached, CancellationToken ct)`
`74`	`76`	`{`
`75`	`77`	`var scheduledStack = new Stack<ScheduledCommit>();`
`76`	`78`	`var version = Version.Default;`
`@@ -89,7 +91,7 @@ private static async Task<Version> LookupVersionLabelRecursiveAsync(`
`89`	`91`	`}`
`90`	`92`
`91`	`93`	`// Detected mostly larger version tag.`
`92`		`- var candidates = commit.Tags.`
	`94`	`+ var candidates = (await repository.GetRelatedTagsAsync(commit, ct)).`
`93`	`95`	`Select(tag => Version.TryParse(tag.Name, out var v) ? v : null!).`
`94`	`96`	`Where(v => v?.ComponentCount >= 2). // "1.2" or more.`
`95`	`97`	`OrderByDescending(v => v).`
`@@ -101,7 +103,11 @@ private static async Task<Version> LookupVersionLabelRecursiveAsync(`
`101`	`103`	`break;`
`102`	`104`	`}`
`103`	`105`
`104`		`- var parents = await commit.GetParentCommitsAsync(ct);`
	`106`	`+ var parents = (await LooseConcurrentScope.Default.WhenAll(`
	`107`	`+ commit.Parents.Select(parentCommitHash => repository.GetCommitAsync(parentCommitHash, ct)))).`
	`108`	`+ Where(parentCommitHash => parentCommitHash.HasValue).`
	`109`	`+ Select(parentCommitHash => parentCommitHash!.Value).`
	`110`	`+ ToArray();`
`105`	`111`	`if (parents.Length == 0)`
`106`	`112`	`{`
`107`	`113`	`reached.Add(commit, version);`
`@@ -124,7 +130,7 @@ private static async Task<Version> LookupVersionLabelRecursiveAsync(`
`124`	`130`	`{`
`125`	`131`	`for (var index = 1; index < pcs.Length; index++)`
`126`	`132`	`{`
`127`		`- var v = await LookupVersionLabelRecursiveAsync(pcs[index], reached, ct);`
	`133`	`+ var v = await LookupVersionLabelRecursiveAsync(repository, pcs[index], reached, ct);`
`128`	`134`	`if (v.CompareTo(version) > 0)`
`129`	`135`	`{`
`130`	`136`	`version = v;`
`@@ -140,19 +146,20 @@ private static async Task<Version> LookupVersionLabelRecursiveAsync(`
`140`	`146`	`}`
`141`	`147`
`142`	`148`	`private static async Task<Version> RunLookupVersionLabelAsync(`
`143`		`- Branch branch, CancellationToken ct)`
	`149`	`+ PrimitiveRepository repository,`
	`150`	`+ PrimitiveReference branch, CancellationToken ct)`
`144`	`151`	`{`
`145`		`- var headCommit = await branch.GetHeadCommitAsync(ct);`
`146`		`- return await LookupVersionLabelRecursiveAsync(headCommit, new(), ct);`
	`152`	`+ var headCommit = await repository.GetCommitAsync(branch, ct);`
	`153`	`+ return await LookupVersionLabelRecursiveAsync(repository, headCommit!.Value, new(), ct);`
`147`	`154`	`}`
`148`	`155`
`149`	`156`	`public static async Task<Version> LookupVersionLabelAsync(`
`150`		`- StructuredRepository repository,`
	`157`	`+ PrimitiveRepository repository,`
`151`	`158`	`bool checkWorkingDirectoryStatus,`
`152`	`159`	`CancellationToken ct)`
`153`	`160`	`{`
`154`	`161`	`// Check if repository has any commits (to handle initial state)`
`155`		`- if (repository.Head is not { } branch)`
	`162`	`+ if (await repository.GetCurrentHeadReferenceAsync(ct) is not { } branch)`
`156`	`163`	`{`
`157`	`164`	`return Version.Default; // Return default version (0.0.1) if no HEAD`
`158`	`165`	`}`
`@@ -161,14 +168,19 @@ public static async Task<Version> LookupVersionLabelAsync(`
`161`	`168`	`{`
`162`	`169`	`var (baseVersion, workingDirectoryStatus) = await LooseConcurrentScope.Default.Join(`
`163`	`170`	`// Get the base version from commit tags`
`164`		`- RunLookupVersionLabelAsync(branch, ct),`
	`171`	`+ RunLookupVersionLabelAsync(repository, branch, ct),`
`165`	`172`	`// Check working directory status`
`166`	`173`	`repository.GetWorkingDirectoryStatusAsync(ct));`
`167`	`174`
`168`	`175`	`// If there are modified files, increment the version`
`169`	`176`	`if (workingDirectoryStatus.StagedFiles.Count > 0 \|\|`
`170`		`- workingDirectoryStatus.UnstagedFiles.Count > 0 \|\|`
`171`		`- workingDirectoryStatus.UntrackedFiles.Count > 0)`
	`177`	`+ workingDirectoryStatus.UnstagedFiles.Count > 0)`
	`178`	`+ {`
	`179`	`+ return IncrementLastVersionComponent(baseVersion);`
	`180`	`+ }`
	`181`	`+`
	`182`	`+ var untrackedFiles = await repository.GetUntrackedFilesAsync(workingDirectoryStatus, ct);`
	`183`	`+ if (untrackedFiles.Count > 0)`
`172`	`184`	`{`
`173`	`185`	`return IncrementLastVersionComponent(baseVersion);`
`174`	`186`	`}`
`@@ -177,7 +189,7 @@ public static async Task<Version> LookupVersionLabelAsync(`
`177`	`189`	`}`
`178`	`190`	`else`
`179`	`191`	`{`
`180`		`- return await RunLookupVersionLabelAsync(branch, ct);`
	`192`	`+ return await RunLookupVersionLabelAsync(repository, branch, ct);`
`181`	`193`	`}`
`182`	`194`	`}`
`183`	`195`	`}`