diff --git a/src/NetPackageAnalyzer/AnalyzeMerge/AnalyzeMerge.csproj b/src/NetPackageAnalyzer/AnalyzeMerge/AnalyzeMerge.csproj
index 9fb1eb51..d3d7355c 100644
--- a/src/NetPackageAnalyzer/AnalyzeMerge/AnalyzeMerge.csproj
+++ b/src/NetPackageAnalyzer/AnalyzeMerge/AnalyzeMerge.csproj
@@ -34,4 +34,10 @@
+
+
+
+
+
+
diff --git a/src/NetPackageAnalyzer/AnalyzeMerge/AnalyzeMergeData.cs b/src/NetPackageAnalyzer/AnalyzeMerge/AnalyzeMergeData.cs
index 5b0d398d..7d1bccaf 100644
--- a/src/NetPackageAnalyzer/AnalyzeMerge/AnalyzeMergeData.cs
+++ b/src/NetPackageAnalyzer/AnalyzeMerge/AnalyzeMergeData.cs
@@ -1,11 +1,15 @@
-namespace AnalyzeMerge;
+using System.IO.Abstractions;
+
+namespace AnalyzeMerge;
public class AnalyzeMergeData
{
private readonly string folder;
+ private readonly IFileSystem fileSystem;
private string folderRoot;
- public AnalyzeMergeData(string folder)
+ public AnalyzeMergeData(string folder, IFileSystem? fileSystem = null)
{
this.folder = folder;
+ this.fileSystem = fileSystem ?? new FileSystem();
folderRoot=folder;
}
@@ -79,13 +83,13 @@ public async Task GenerateNow()
data.Analyze();
var g = new TemplateGenerator();
var folderResults = Path.Combine(folderRoot, "changes");
- if(!Path.Exists(folderResults))
- Directory.CreateDirectory(folderResults);
+ if(!fileSystem.Directory.Exists(folderResults))
+ fileSystem.Directory.CreateDirectory(folderResults);
var file = Path.Combine(folderResults, $"Changes_{currentBranch1.FriendlyName}.html");
- await File.WriteAllTextAsync(file, await g.Generate_DisplayAllFiles (data));
+ await fileSystem.File.WriteAllTextAsync(file, await g.Generate_DisplayAllFiles (data));
file = Path.Combine(folderResults, $"Changes_{currentBranch1.FriendlyName}.md");
- await File.WriteAllTextAsync(file, await g.Generate_DisplayAllFilesMD(data));
+ await fileSystem.File.WriteAllTextAsync(file, await g.Generate_DisplayAllFilesMD(data));
//Console.WriteLine("=>"+name);
//Branch? currentBranch = null;
@@ -202,4 +206,4 @@ public async Task GenerateNow()
// .Single();
//}
-}
\ No newline at end of file
+}
diff --git a/src/NetPackageAnalyzer/AnalyzeMerge/ProcessOutput.cs b/src/NetPackageAnalyzer/AnalyzeMerge/ProcessOutput.cs
index 652cf095..f1422b18 100644
--- a/src/NetPackageAnalyzer/AnalyzeMerge/ProcessOutput.cs
+++ b/src/NetPackageAnalyzer/AnalyzeMerge/ProcessOutput.cs
@@ -1,6 +1,15 @@
-namespace AnalyzeMerge;
+using NPA.ProcessRunner;
+
+namespace AnalyzeMerge;
class ProcessOutput
{
+ private readonly IProcessRunner processRunner;
+
+ public ProcessOutput(IProcessRunner? processRunner = null)
+ {
+ this.processRunner = processRunner ?? new SystemProcessRunner();
+ }
+
public string ExecuteGit(string folder, GitData gitData)
{
var args = gitData switch
@@ -24,19 +33,9 @@ public string ExecuteGit(string folder, GitData gitData)
Arguments = args
};
- // Create and start the process
- Process process = new Process
- {
- StartInfo = startInfo
- };
- process.Start();
-
- // Read the output
- string output = process.StandardOutput.ReadToEnd();
- string errorOutput = process.StandardError.ReadToEnd();
-
- // Wait for the process to exit
- process.WaitForExit();
+ var result = processRunner.Run(startInfo);
+ string output = result.StandardOutput;
+ string errorOutput = result.StandardError;
if (errorOutput.Length > 0)
{
throw new ArgumentException(errorOutput);
diff --git a/src/NetPackageAnalyzer/NPA.BigResources/NPA.BigResources.csproj b/src/NetPackageAnalyzer/NPA.BigResources/NPA.BigResources.csproj
index 4de45fc5..1524c36b 100644
--- a/src/NetPackageAnalyzer/NPA.BigResources/NPA.BigResources.csproj
+++ b/src/NetPackageAnalyzer/NPA.BigResources/NPA.BigResources.csproj
@@ -19,4 +19,7 @@
true
$(BaseIntermediateOutputPath)\GX
+
+
+
diff --git a/src/NetPackageAnalyzer/NPA.BigResources/ZipFiles.cs b/src/NetPackageAnalyzer/NPA.BigResources/ZipFiles.cs
index 101d716e..131261ba 100644
--- a/src/NetPackageAnalyzer/NPA.BigResources/ZipFiles.cs
+++ b/src/NetPackageAnalyzer/NPA.BigResources/ZipFiles.cs
@@ -1,19 +1,22 @@
-using System.IO.Compression;
+using System.IO.Abstractions;
+using System.IO.Compression;
namespace NPA.BigResources;
public class ZipBigFiles
{
//TODO : should contain files for Windows, Linux, MacOS
- public static async Task SaveToFile(string folderPath, EmbeddedResource embeddedResource)
+ public static async Task SaveToFile(string folderPath, EmbeddedResource embeddedResource, IFileSystem? fileSystem = null)
{
- if(Directory.Exists(folderPath) && Directory.EnumerateFiles(folderPath).Any())
+ fileSystem ??= new FileSystem();
+
+ if(fileSystem.Directory.Exists(folderPath) && fileSystem.Directory.EnumerateFiles(folderPath).Any())
{
return;
}
- if(!Directory.Exists(folderPath))
+ if(!fileSystem.Directory.Exists(folderPath))
{
- Directory.CreateDirectory(folderPath);
+ fileSystem.Directory.CreateDirectory(folderPath);
}
using var stream = EmbeddedResources.GetStream(embeddedResource);
diff --git a/src/NetPackageAnalyzer/NPA.GitInfo/GitInfo.cs b/src/NetPackageAnalyzer/NPA.GitInfo/GitInfo.cs
index b2d0f011..1aa7582d 100644
--- a/src/NetPackageAnalyzer/NPA.GitInfo/GitInfo.cs
+++ b/src/NetPackageAnalyzer/NPA.GitInfo/GitInfo.cs
@@ -1,11 +1,15 @@
-using System.Diagnostics;
+using System.Diagnostics;
+using NPA.ProcessRunner;
namespace NPA.GitInfo;
public class GitInfo
{
- private GitInfo()
+ public IProcessRunner ProcessRunner { get; set; }
+
+ private GitInfo(IProcessRunner? processRunner)
{
+ ProcessRunner = processRunner ?? new SystemProcessRunner();
}
public string Repository { get; set; } = string.Empty;
public string Branch { get; set; } = string.Empty;
@@ -13,28 +17,29 @@ private GitInfo()
public string Commit { get; set; }= string.Empty;
static Dictionary gitInfo=[];
- public static GitInfo Construct(string folder)
+ public static GitInfo Construct(string folder, IProcessRunner? processRunner = null)
{
+ processRunner = processRunner ?? new SystemProcessRunner();
if(gitInfo.ContainsKey(folder))
{
return gitInfo[folder];
}
- var ret = new GitInfo();
- ret.Branch = ExecuteGit(folder, "branch --show-current");
- ret.Repository = ExecuteGit(folder, "config --get remote.origin.url");
+ var ret = new GitInfo(processRunner);
+ ret.Branch = ExecuteGit(folder, "branch --show-current", processRunner);
+ ret.Repository = ExecuteGit(folder, "config --get remote.origin.url", processRunner);
if(ret.Repository.EndsWith(".git"))
{
ret.Repository = ret.Repository.Substring(0, ret.Repository.Length - 4);
}
- ret.Commit = ExecuteGit(folder, "rev-parse HEAD");
+ ret.Commit = ExecuteGit(folder, "rev-parse HEAD", processRunner);
gitInfo.Add(folder, ret);
return ret;
}
- static string ExecuteGit(string folder, string args)
+ static string ExecuteGit(string folder, string args, IProcessRunner? processRunner)
{
-
+ processRunner ??= new SystemProcessRunner();
ProcessStartInfo startInfo = new ProcessStartInfo
{
@@ -49,19 +54,9 @@ static string ExecuteGit(string folder, string args)
Arguments = args
};
- // Create and start the process
- Process process = new Process
- {
- StartInfo = startInfo
- };
- process.Start();
-
- // Read the output
- string output = process.StandardOutput.ReadToEnd();
- string errorOutput = process.StandardError.ReadToEnd();
-
- // Wait for the process to exit
- process.WaitForExit();
+ var result = processRunner.Run(startInfo);
+ string output = result.StandardOutput;
+ string errorOutput = result.StandardError;
if (errorOutput.Length > 0)
{
throw new ArgumentException(errorOutput);
diff --git a/src/NetPackageAnalyzer/NPA.GitInfo/NPA.GitInfo.csproj b/src/NetPackageAnalyzer/NPA.GitInfo/NPA.GitInfo.csproj
index b9c4d649..9baf86e3 100644
--- a/src/NetPackageAnalyzer/NPA.GitInfo/NPA.GitInfo.csproj
+++ b/src/NetPackageAnalyzer/NPA.GitInfo/NPA.GitInfo.csproj
@@ -5,4 +5,7 @@
enable
enable
+
+
+
diff --git a/src/NetPackageAnalyzer/NPA.GitSummary.Tests/GitRepositorySummaryAnalyzerTests.cs b/src/NetPackageAnalyzer/NPA.GitSummary.Tests/GitRepositorySummaryAnalyzerTests.cs
new file mode 100644
index 00000000..e0070ad7
--- /dev/null
+++ b/src/NetPackageAnalyzer/NPA.GitSummary.Tests/GitRepositorySummaryAnalyzerTests.cs
@@ -0,0 +1,96 @@
+using NPA.ProcessRunner;
+
+namespace NPA.GitSummary.Tests;
+
+public class GitRepositorySummaryAnalyzerTests
+{
+
+
+
+ [Fact]
+ public void CreateChurnHotspotReport_GroupsAndOrdersFiles()
+ {
+ var report = GitRepositorySummaryAnalyzer.CreateChurnHotspotReport(
+ ["src/B.cs", "src/A.cs", "src/B.cs", "src/C.cs", "src/B.cs", "src/A.cs"],
+ topCount: 2,
+ since: "1 year ago");
+
+ Assert.Equal("1 year ago", report.Since);
+ Assert.Collection(
+ report.Files,
+ item =>
+ {
+ Assert.Equal("src/B.cs", item.FilePath);
+ Assert.Equal(3, item.Count);
+ },
+ item =>
+ {
+ Assert.Equal("src/A.cs", item.FilePath);
+ Assert.Equal(2, item.Count);
+ });
+ }
+
+ [Fact]
+ public void CreateBusFactorReport_ComputesTopContributorRatio()
+ {
+ var report = GitRepositorySummaryAnalyzer.CreateBusFactorReport(
+ ["Alice", "Bob", "Alice", "Alice"],
+ topCount: 10);
+
+ Assert.Equal(4, report.TotalCommits);
+ Assert.NotNull(report.TopContributor);
+ Assert.Equal("Alice", report.TopContributor!.Contributor);
+ Assert.Equal(3, report.TopContributor.CommitCount);
+ Assert.Equal(0.75, report.TopContributorRatio);
+ }
+
+ [Fact]
+ public void CreateCommitVelocityReport_GroupsCommitsByMonth()
+ {
+ var report = GitRepositorySummaryAnalyzer.CreateCommitVelocityReport(
+ [
+ "2026-04-03T08:30:00+00:00",
+ "2026-04-01T09:00:00+00:00",
+ "2026-03-28T10:00:00+00:00"
+ ]);
+
+ Assert.Collection(
+ report.Months,
+ item =>
+ {
+ Assert.Equal("2026-03", item.YearMonth);
+ Assert.Equal(1, item.CommitCount);
+ },
+ item =>
+ {
+ Assert.Equal("2026-04", item.YearMonth);
+ Assert.Equal(2, item.CommitCount);
+ });
+ }
+
+ [Fact]
+ public void CreateFirefightingReport_FiltersRelevantSubjects()
+ {
+ var report = GitRepositorySummaryAnalyzer.CreateFirefightingReport(
+ [
+ "2026-04-03T08:30:00+00:00\tabc123\tHotfix authentication flow",
+ "2026-04-02T08:30:00+00:00\tdef456\tAdd diagnostics report",
+ "2026-04-01T08:30:00+00:00\tghi789\tRollback failing deployment"
+ ],
+ since: "1 year ago");
+
+ Assert.Equal("1 year ago", report.Since);
+ Assert.Collection(
+ report.Commits,
+ item =>
+ {
+ Assert.Equal("abc123", item.Sha);
+ Assert.Equal("Hotfix authentication flow", item.Subject);
+ },
+ item =>
+ {
+ Assert.Equal("ghi789", item.Sha);
+ Assert.Equal("Rollback failing deployment", item.Subject);
+ });
+ }
+}
diff --git a/src/NetPackageAnalyzer/NPA.GitSummary.Tests/NPA.GitSummary.Tests.csproj b/src/NetPackageAnalyzer/NPA.GitSummary.Tests/NPA.GitSummary.Tests.csproj
new file mode 100644
index 00000000..bd6fe009
--- /dev/null
+++ b/src/NetPackageAnalyzer/NPA.GitSummary.Tests/NPA.GitSummary.Tests.csproj
@@ -0,0 +1,30 @@
+
+
+
+ net10.0
+ enable
+ enable
+ Exe
+ false
+ true
+
+
+
+
+
+
+ all
+ runtime; build; native; contentfiles; analyzers; buildtransitive
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/NetPackageAnalyzer/NPA.GitSummary/GitRepositorySummaryAnalyzer.cs b/src/NetPackageAnalyzer/NPA.GitSummary/GitRepositorySummaryAnalyzer.cs
new file mode 100644
index 00000000..e29e7181
--- /dev/null
+++ b/src/NetPackageAnalyzer/NPA.GitSummary/GitRepositorySummaryAnalyzer.cs
@@ -0,0 +1,258 @@
+using System.Diagnostics;
+using System.Globalization;
+using System.IO.Abstractions;
+using System.Text.RegularExpressions;
+using NPA.ProcessRunner;
+
+namespace NPA.GitSummary;
+
+public sealed partial class GitRepositorySummaryAnalyzer
+{
+ private readonly string gitExecutable;
+ private readonly IFileSystem fileSystem;
+ private readonly IProcessRunner processRunner;
+
+ public GitRepositorySummaryAnalyzer(string gitExecutable = "git", IProcessRunner? processRunner = null, IFileSystem? fileSystem = null)
+ {
+ ArgumentException.ThrowIfNullOrWhiteSpace(gitExecutable);
+ this.gitExecutable = gitExecutable;
+ this.processRunner = processRunner ?? new SystemProcessRunner();
+ this.fileSystem = fileSystem ?? new FileSystem();
+ }
+
+ public async Task AnalyzeAsync(
+ string repositoryPath,
+ GitRepositorySummaryOptions? options = null,
+ CancellationToken cancellationToken = default)
+ {
+ ArgumentException.ThrowIfNullOrWhiteSpace(repositoryPath);
+
+ if(fileSystem.File.Exists(repositoryPath))
+ {
+ repositoryPath = fileSystem.Path.GetDirectoryName(repositoryPath) ?? string.Empty;
+ }
+ if (!fileSystem.Directory.Exists(repositoryPath))
+ {
+ throw new DirectoryNotFoundException($"Repository path '{repositoryPath}' does not exist.");
+ }
+
+ options ??= new();
+
+ var churnTask = ExecuteGitLinesAsync(repositoryPath, BuildChurnArguments(options), cancellationToken);
+ var busFactorTask = ExecuteGitLinesAsync(repositoryPath, BuildBusFactorArguments(), cancellationToken);
+ var bugTask = ExecuteGitLinesAsync(repositoryPath, BuildBugArguments(options), cancellationToken);
+ var velocityTask = ExecuteGitLinesAsync(repositoryPath, BuildVelocityArguments(), cancellationToken);
+ var firefightingTask = ExecuteGitLinesAsync(repositoryPath, BuildFirefightingArguments(options), cancellationToken);
+
+ await Task.WhenAll(churnTask, busFactorTask, bugTask, velocityTask, firefightingTask);
+
+ return new GitRepositorySummaryReport(
+ CreateChurnHotspotReport(await churnTask, options.TopCount, options.ChurnSince),
+ CreateBusFactorReport(await busFactorTask, options.TopCount),
+ CreateBugHotspotReport(await bugTask, options.TopCount, options.BugSince),
+ CreateCommitVelocityReport(await velocityTask),
+ CreateFirefightingReport(await firefightingTask, options.FirefightingSince));
+ }
+
+ public static GitChurnHotspotReport CreateChurnHotspotReport(
+ IEnumerable fileLines,
+ int topCount = 20,
+ string since = "1 year ago")
+ => new(since, BuildFileFrequency(fileLines, topCount));
+
+ public static GitBusFactorReport CreateBusFactorReport(
+ IEnumerable contributorLines,
+ int topCount = 20)
+ => new(BuildContributorFrequency(contributorLines, topCount));
+
+ public static GitBugHotspotReport CreateBugHotspotReport(
+ IEnumerable fileLines,
+ int topCount = 20,
+ string? since = null)
+ => new(since, BuildFileFrequency(fileLines, topCount));
+
+ public static GitCommitVelocityReport CreateCommitVelocityReport(IEnumerable commitDateLines)
+ {
+ var months = commitDateLines
+ .Select(static line => line.Trim())
+ .Where(static line => !string.IsNullOrWhiteSpace(line))
+ .Select(static line =>
+ {
+ if (!DateTimeOffset.TryParse(line, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var commitDate))
+ {
+ throw new InvalidOperationException($"Unable to parse git commit date '{line}'.");
+ }
+
+ return commitDate;
+ })
+ .GroupBy(static date => new { date.Year, date.Month })
+ .OrderBy(static group => group.Key.Year)
+ .ThenBy(static group => group.Key.Month)
+ .Select(static group => new GitMonthlyCommitFrequency(group.Key.Year, group.Key.Month, group.Count()))
+ .ToArray();
+
+ return new GitCommitVelocityReport(months);
+ }
+
+ public static GitFirefightingReport CreateFirefightingReport(
+ IEnumerable commitLines,
+ string since = "1 year ago")
+ {
+ var commits = commitLines
+ .Select(ParseFirefightingCommit)
+ .Where(static commit => commit is not null)
+ .Select(static commit => commit!)
+ .ToArray();
+
+ return new GitFirefightingReport(since, commits);
+ }
+
+ private async Task> ExecuteGitLinesAsync(
+ string repositoryPath,
+ IReadOnlyList arguments,
+ CancellationToken cancellationToken)
+ {
+ var startInfo = new ProcessStartInfo
+ {
+ FileName = gitExecutable,
+ WorkingDirectory = repositoryPath,
+ RedirectStandardOutput = true,
+ RedirectStandardError = true,
+ UseShellExecute = false,
+ CreateNoWindow = true
+ };
+
+ foreach (var argument in arguments)
+ {
+ startInfo.ArgumentList.Add(argument);
+ }
+
+ var result = await processRunner.RunAsync(startInfo, cancellationToken);
+
+ if (result.ExitCode != 0)
+ {
+ var command = string.Join(" ", arguments);
+ throw new InvalidOperationException(
+ $"git {command} failed with exit code {result.ExitCode}:{Environment.NewLine}{result.StandardError}");
+ }
+
+ return result.StandardOutput
+ .Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries)
+ .Select(static line => line.Trim())
+ .Where(static line => !string.IsNullOrWhiteSpace(line))
+ .ToArray();
+ }
+
+ private static IReadOnlyList BuildChurnArguments(GitRepositorySummaryOptions options)
+ {
+ List arguments = ["log", "--format=format:", "--name-only"];
+ AppendSince(arguments, options.ChurnSince);
+ return arguments;
+ }
+
+ private static IReadOnlyList BuildBusFactorArguments()
+ => ["log", "--format=%aN", "--no-merges"];
+
+ private static IReadOnlyList BuildBugArguments(GitRepositorySummaryOptions options)
+ {
+ List arguments =
+ [
+ "log",
+ "--format=format:",
+ "--name-only",
+ "--regexp-ignore-case",
+ "--extended-regexp",
+ "--grep=fix|bug|broken"
+ ];
+
+ AppendSince(arguments, options.BugSince);
+ return arguments;
+ }
+
+ private static IReadOnlyList BuildVelocityArguments()
+ => ["log", "--format=%aI"];
+
+ private static IReadOnlyList BuildFirefightingArguments(GitRepositorySummaryOptions options)
+ {
+ List arguments =
+ [
+ "log",
+ "--format=%aI%x09%H%x09%s"
+ ];
+
+ AppendSince(arguments, options.FirefightingSince);
+ return arguments;
+ }
+
+ private static void AppendSince(List arguments, string? since)
+ {
+ if (string.IsNullOrWhiteSpace(since))
+ {
+ return;
+ }
+
+ arguments.Add($"--since={since}");
+ }
+
+ private static IReadOnlyList BuildFileFrequency(IEnumerable fileLines, int topCount)
+ {
+ var take = NormalizeTopCount(topCount);
+
+ return fileLines
+ .Select(static line => line.Trim())
+ .Where(static line => !string.IsNullOrWhiteSpace(line))
+ .GroupBy(static line => line, StringComparer.Ordinal)
+ .OrderByDescending(static group => group.Count())
+ .ThenBy(static group => group.Key, StringComparer.Ordinal)
+ .Take(take)
+ .Select(static group => new GitFileFrequency(group.Key, group.Count()))
+ .ToArray();
+ }
+
+ private static IReadOnlyList BuildContributorFrequency(IEnumerable contributorLines, int topCount)
+ {
+ var take = NormalizeTopCount(topCount);
+
+ return contributorLines
+ .Select(static line => line.Trim())
+ .Where(static line => !string.IsNullOrWhiteSpace(line))
+ .GroupBy(static line => line, StringComparer.Ordinal)
+ .OrderByDescending(static group => group.Count())
+ .ThenBy(static group => group.Key, StringComparer.Ordinal)
+ .Take(take)
+ .Select(static group => new GitContributorFrequency(group.Key, group.Count()))
+ .ToArray();
+ }
+
+ private static int NormalizeTopCount(int topCount)
+ => topCount <= 0 ? int.MaxValue : topCount;
+
+ private static GitFirefightingCommit? ParseFirefightingCommit(string line)
+ {
+ var parts = line.Split('\t', 3, StringSplitOptions.None);
+ if (parts.Length != 3)
+ {
+ throw new InvalidOperationException($"Unable to parse git firefighting output '{line}'.");
+ }
+
+ if (!DateTimeOffset.TryParse(parts[0], CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var commitDate))
+ {
+ throw new InvalidOperationException($"Unable to parse git firefighting date '{parts[0]}'.");
+ }
+
+ var sha = parts[1].Trim();
+ var subject = parts[2].Trim();
+
+ if (string.IsNullOrWhiteSpace(sha) || string.IsNullOrWhiteSpace(subject))
+ {
+ throw new InvalidOperationException($"Unable to parse git firefighting output '{line}'.");
+ }
+
+ return FirefightingPattern().IsMatch(subject)
+ ? new GitFirefightingCommit(commitDate, sha, subject)
+ : null;
+ }
+
+ [GeneratedRegex(@"\b(revert|hotfix|emergency|rollback)\b", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
+ private static partial Regex FirefightingPattern();
+}
diff --git a/src/NetPackageAnalyzer/NPA.GitSummary/GitRepositorySummaryReport.cs b/src/NetPackageAnalyzer/NPA.GitSummary/GitRepositorySummaryReport.cs
new file mode 100644
index 00000000..63acba0d
--- /dev/null
+++ b/src/NetPackageAnalyzer/NPA.GitSummary/GitRepositorySummaryReport.cs
@@ -0,0 +1,64 @@
+namespace NPA.GitSummary;
+
+public sealed record GitFileFrequency(string FilePath, int Count);
+
+public sealed record GitContributorFrequency(string Contributor, int CommitCount)
+{
+ public double ShareOfCommits(int totalCommits)
+ => totalCommits == 0 ? 0 : (double)CommitCount / totalCommits;
+}
+public sealed record GitYearCommitFrequency(int Year,int CommitCount)
+{
+}
+public sealed record GitMonthlyCommitFrequency(int Year, int Month, int CommitCount)
+{
+ public string YearMonth => $"{Year:D4}-{Month:D2}";
+}
+
+public sealed record GitFirefightingCommit(DateTimeOffset CommitDate, string Sha, string Subject);
+
+public sealed record GitChurnHotspotReport(string Since, IReadOnlyList Files);
+
+public sealed record GitBusFactorReport(IReadOnlyList Contributors)
+{
+ public int TotalCommits => Contributors.Sum(it => it.CommitCount);
+
+ public GitContributorFrequency? TopContributor => Contributors.FirstOrDefault();
+
+ public double? TopContributorRatio
+ => TopContributor is null || TotalCommits == 0
+ ? null
+ : TopContributor.ShareOfCommits(TotalCommits);
+}
+
+public sealed record GitBugHotspotReport(string? Since, IReadOnlyList Files);
+
+public sealed record GitCommitVelocityReport(IReadOnlyList Months)
+{
+ public bool HasMoreThanOneYear => Months.Select(it=>it.Year).Distinct().Count() > 1;
+
+ public IReadOnlyList Years=> Months
+ .GroupBy(it => it.Year)
+ .Select(g => new GitYearCommitFrequency(g.Key, g.Sum(it => it.CommitCount)))
+ .ToList();
+}
+
+public sealed record GitFirefightingReport(string Since, IReadOnlyList Commits);
+
+public sealed record GitRepositorySummaryReport(
+ GitChurnHotspotReport ChurnHotspots,
+ GitBusFactorReport BusFactor,
+ GitBugHotspotReport BugHotspots,
+ GitCommitVelocityReport CommitVelocity,
+ GitFirefightingReport Firefighting);
+
+public sealed record GitRepositorySummaryOptions
+{
+ public int TopCount { get; init; } = 100;
+
+ public string ChurnSince { get; init; } = "2 years ago";
+
+ public string? BugSince { get; init; } = "2 years ago";
+
+ public string FirefightingSince { get; init; } = "2 years ago";
+}
diff --git a/src/NetPackageAnalyzer/NPA.GitSummary/NPA.GitSummary.csproj b/src/NetPackageAnalyzer/NPA.GitSummary/NPA.GitSummary.csproj
new file mode 100644
index 00000000..c5fc6dac
--- /dev/null
+++ b/src/NetPackageAnalyzer/NPA.GitSummary/NPA.GitSummary.csproj
@@ -0,0 +1,16 @@
+
+
+
+ net10.0
+ enable
+ enable
+ true
+
+
+
+
+
+
+
+
+
diff --git a/src/NetPackageAnalyzer/NPA.HtmlData/ExtractImages.cs b/src/NetPackageAnalyzer/NPA.HtmlData/ExtractImages.cs
index cb565500..f0baa586 100644
--- a/src/NetPackageAnalyzer/NPA.HtmlData/ExtractImages.cs
+++ b/src/NetPackageAnalyzer/NPA.HtmlData/ExtractImages.cs
@@ -1,7 +1,10 @@
-namespace NPA.HtmlData;
+using System.IO.Abstractions;
+
+namespace NPA.HtmlData;
public class ExtractImages
{
+ private readonly IFileSystem fileSystem;
static ExtractImages()
{
@@ -12,9 +15,10 @@ static ExtractImages()
}
}
- public ExtractImages(string htmlPath)
+ public ExtractImages(string htmlPath, IFileSystem? fileSystem = null)
{
HtmlPath = htmlPath;
+ this.fileSystem = fileSystem ?? new FileSystem();
}
public string HtmlPath { get; private set; }
@@ -25,9 +29,9 @@ public async Task GetImagesAsync()
var dir = Path.GetDirectoryName(HtmlPath)!;
var nameFile= Path.GetFileNameWithoutExtension(HtmlPath);
var imagesDir = Path.Combine(dir, "images_"+ nameFile);
- if (!Directory.Exists(imagesDir))
+ if (!fileSystem.Directory.Exists(imagesDir))
{
- Directory.CreateDirectory(imagesDir);
+ fileSystem.Directory.CreateDirectory(imagesDir);
}
using var playwright = await Playwright.CreateAsync();
@@ -71,7 +75,7 @@ public async Task GetImagesAsync()
{
var buffer = await title.ScreenshotAsync();
- await File.WriteAllBytesAsync(Path.Combine(imagesDir, $"{newName}.png"), buffer);
+ await fileSystem.File.WriteAllBytesAsync(Path.Combine(imagesDir, $"{newName}.png"), buffer);
}
catch(Exception ex)
{
diff --git a/src/NetPackageAnalyzer/NPA.HtmlData/NPA.HtmlData.csproj b/src/NetPackageAnalyzer/NPA.HtmlData/NPA.HtmlData.csproj
index 1fbdf04a..0796061c 100644
--- a/src/NetPackageAnalyzer/NPA.HtmlData/NPA.HtmlData.csproj
+++ b/src/NetPackageAnalyzer/NPA.HtmlData/NPA.HtmlData.csproj
@@ -12,5 +12,6 @@
+
diff --git a/src/NetPackageAnalyzer/NPA.ProcessRunner/FakeProcessRunner.cs b/src/NetPackageAnalyzer/NPA.ProcessRunner/FakeProcessRunner.cs
new file mode 100644
index 00000000..ded76509
--- /dev/null
+++ b/src/NetPackageAnalyzer/NPA.ProcessRunner/FakeProcessRunner.cs
@@ -0,0 +1,77 @@
+using System.Diagnostics;
+using System.IO.Abstractions;
+
+namespace NPA.ProcessRunner;
+
+public sealed class FakeProcessRunner : IProcessRunner
+{
+ private readonly IFileSystem fileSystem;
+ private readonly Queue runResults = new();
+ Dictionary results = new();
+
+ public FakeProcessRunner(IFileSystem? fileSystem = null)
+ {
+ this.fileSystem = fileSystem ?? new FileSystem();
+ }
+
+ public void DeserializeFromFolder(string folder)
+ {
+ results.Clear();
+ foreach (var item in fileSystem.Directory.GetFiles(folder, "*.json"))
+ {
+ var content = fileSystem.File.ReadAllText(item);
+ var deserialized = ProcessExecutionResultToSerialize.Deserialize(content);
+ var pso = deserialized.pso ?? throw new InvalidOperationException("Deserialized object missing ProcessStartInfo");
+ if (results.ContainsKey(pso))
+ {
+ if (results[pso].result != deserialized.result)
+ {
+ if(pso.file.StartsWith("dotnet") && pso.arguments.StartsWith("build"))
+ {
+ // Allow different build results for the same ProcessStartInfo, since they can be non-deterministic
+ continue;
+ }
+ throw new InvalidOperationException("Conflicting results for the same ProcessStartInfo");
+ }
+ continue;
+ }
+ results[deserialized.pso ?? throw new InvalidOperationException("Deserialized object missing ProcessStartInfo")] = deserialized;
+ }
+ }
+ public Process? Start(ProcessStartInfo startInfo)
+ {
+ return null;
+ }
+
+ public ProcessExecutionResult Run(ProcessStartInfo psi)
+ {
+ var p = ProcessToSerialize.FromProcessStartInfo(psi);
+ if(results.TryGetValue(p, out var result))
+ {
+ return result.result ?? throw new InvalidOperationException("Deserialized object missing ProcessExecutionResult");
+ }
+ else
+ {
+ var existing = results
+ .Where(it=>Path.GetFileName(it.Key.file) == Path.GetFileName(p.file) && it.Key.arguments == p.arguments)
+ .ToArray();
+ if (existing.Length == 0)
+ {
+ throw new ArgumentException("Cannot find output for " + p);
+ }
+ else
+ {
+ if(existing.Length == 1)return existing[0].Value.result ?? throw new InvalidOperationException("Deserialized object missing ProcessExecutionResult");
+ throw new ArgumentException("Cannot find output for " + p);
+
+ }
+ }
+ }
+
+ public Task RunAsync(ProcessStartInfo startInfo, CancellationToken cancellationToken = default)
+ {
+ return Task.FromResult(Run(startInfo));
+ }
+
+
+}
diff --git a/src/NetPackageAnalyzer/NPA.ProcessRunner/IProcessRunner.cs b/src/NetPackageAnalyzer/NPA.ProcessRunner/IProcessRunner.cs
new file mode 100644
index 00000000..33845997
--- /dev/null
+++ b/src/NetPackageAnalyzer/NPA.ProcessRunner/IProcessRunner.cs
@@ -0,0 +1,10 @@
+using System.Diagnostics;
+
+namespace NPA.ProcessRunner;
+
+public interface IProcessRunner
+{
+ Process? Start(ProcessStartInfo startInfo);
+ ProcessExecutionResult Run(ProcessStartInfo startInfo);
+ Task RunAsync(ProcessStartInfo startInfo, CancellationToken cancellationToken = default);
+}
diff --git a/src/NetPackageAnalyzer/NPA.ProcessRunner/NPA.ProcessRunner.csproj b/src/NetPackageAnalyzer/NPA.ProcessRunner/NPA.ProcessRunner.csproj
new file mode 100644
index 00000000..ead68c30
--- /dev/null
+++ b/src/NetPackageAnalyzer/NPA.ProcessRunner/NPA.ProcessRunner.csproj
@@ -0,0 +1,13 @@
+
+
+
+ net8.0
+ enable
+ enable
+ true
+
+
+
+
+
+
diff --git a/src/NetPackageAnalyzer/NPA.ProcessRunner/ProcessExecutionResult.cs b/src/NetPackageAnalyzer/NPA.ProcessRunner/ProcessExecutionResult.cs
new file mode 100644
index 00000000..96dbccc5
--- /dev/null
+++ b/src/NetPackageAnalyzer/NPA.ProcessRunner/ProcessExecutionResult.cs
@@ -0,0 +1,50 @@
+using System.Diagnostics;
+using System.Text.Json;
+
+namespace NPA.ProcessRunner;
+
+public sealed record ProcessExecutionResult(int ExitCode, string StandardOutput, string StandardError);
+
+public sealed record ProcessToSerialize(string file,string arguments, string workingDirectory)
+{
+ public static ProcessToSerialize FromProcessStartInfo(ProcessStartInfo psi) {
+
+ var args = (psi.ArgumentList?.Count > 0) ? string.Join(' ', psi.ArgumentList) : psi.Arguments ?? string.Empty;
+
+ return new(psi.FileName,args,psi.WorkingDirectory);
+ }
+ public ProcessStartInfo ToProcessStartInfo()
+ {
+ return new ProcessStartInfo
+ {
+ FileName = file,
+ Arguments = arguments,
+ WorkingDirectory = workingDirectory
+ };
+ }
+}
+
+public sealed class ProcessExecutionResultToSerialize
+{
+ public ProcessExecutionResultToSerialize()
+ {
+
+ }
+ public ProcessExecutionResultToSerialize(ProcessStartInfo psi, ProcessExecutionResult result)
+ {
+ this.pso = ProcessToSerialize.FromProcessStartInfo(psi);
+ this.result = result;
+ }
+ public ProcessToSerialize? pso { get; set; }
+ public ProcessExecutionResult? result { get; set; }
+
+ public string Serialize()
+ {
+ return JsonSerializer.Serialize(this, new JsonSerializerOptions { WriteIndented = true });
+ }
+ public static ProcessExecutionResultToSerialize Deserialize(string json)
+ {
+ return JsonSerializer.Deserialize(json) ?? throw new InvalidOperationException("Deserialization failed.");
+ }
+
+};
\ No newline at end of file
diff --git a/src/NetPackageAnalyzer/NPA.ProcessRunner/SystemProcessRunner.cs b/src/NetPackageAnalyzer/NPA.ProcessRunner/SystemProcessRunner.cs
new file mode 100644
index 00000000..2dcaa1c9
--- /dev/null
+++ b/src/NetPackageAnalyzer/NPA.ProcessRunner/SystemProcessRunner.cs
@@ -0,0 +1,51 @@
+using System.Diagnostics;
+
+namespace NPA.ProcessRunner;
+
+
+public sealed class SystemProcessRunner : IProcessRunner
+{
+ public SystemProcessRunner()
+ {
+
+ //Console.WriteLine(nr);
+ }
+ //static int nr=250;
+ public Process? Start(ProcessStartInfo startInfo) => Process.Start(startInfo);
+
+ public ProcessExecutionResult Run(ProcessStartInfo startInfo) =>
+ RunAsync(startInfo).GetAwaiter().GetResult();
+
+ public async Task RunAsync(
+ ProcessStartInfo startInfo,
+ CancellationToken cancellationToken = default)
+ {
+ using var process = new Process
+ {
+ StartInfo = startInfo
+ };
+
+ process.Start();
+
+ var outputTask = startInfo.RedirectStandardOutput
+ ? process.StandardOutput.ReadToEndAsync(cancellationToken)
+ : Task.FromResult(string.Empty);
+ var errorTask = startInfo.RedirectStandardError
+ ? process.StandardError.ReadToEndAsync(cancellationToken)
+ : Task.FromResult(string.Empty);
+
+ await process.WaitForExitAsync(cancellationToken);
+ var output = await outputTask;
+ var error = await errorTask;
+ var ret= new ProcessExecutionResult(
+ process.ExitCode,
+ output,
+ error);
+ ProcessExecutionResultToSerialize p = new ProcessExecutionResultToSerialize(startInfo, ret);
+ //string foldedOutput = @"D:\eu\GitHub\PackageAnalyzer\src\NetPackageAnalyzer\NetPackageAnalyzerConsole.Tests\eshopJSON";
+ //var serialize= p.Serialize();
+ //nr=Interlocked.Increment(ref nr);
+ //await File.WriteAllTextAsync(Path.Combine(foldedOutput, $"output_{nr}.json"), serialize);
+ return ret;
+ }
+}
diff --git a/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/Commits.cs b/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/Commits.cs
index a018136f..015fa383 100644
--- a/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/Commits.cs
+++ b/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/Commits.cs
@@ -1,4 +1,5 @@
-
+using NPA.ProcessRunner;
+
namespace NetPackageAnalyzeHistory;
public class Commit
{
@@ -60,10 +61,12 @@ public Dictionary FilesWithMaxCommits(int? year, int take)
public class FolderHistoryCommits
{
private readonly string nameFolder;
+ private readonly IProcessRunner processRunner;
public CommitsData commit = new();
- public FolderHistoryCommits(string nameFolder)
+ public FolderHistoryCommits(string nameFolder, IProcessRunner? processRunner = null)
{
this.nameFolder = nameFolder;
+ this.processRunner = processRunner ?? new SystemProcessRunner();
}
public void Initialize()
{
@@ -77,15 +80,8 @@ public void Initialize()
WorkingDirectory = nameFolder
};
- // Create and start the process
- Process process = new Process { StartInfo = startInfo };
- process.Start();
-
- // Read the output from the command
- string output = process.StandardOutput.ReadToEnd();
-
- // Wait for the process to finish
- process.WaitForExit();
+ var result = processRunner.Run(startInfo);
+ string output = result.StandardOutput;
var lines = output.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
string format = "yyyy-MM-dd HH:mm:ss";
@@ -121,4 +117,4 @@ public void Initialize()
}
}
-}
\ No newline at end of file
+}
diff --git a/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/FileHistorySimple.cs b/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/FileHistorySimple.cs
index 37943146..b5bb1257 100644
--- a/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/FileHistorySimple.cs
+++ b/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/FileHistorySimple.cs
@@ -1,4 +1,6 @@
-namespace NetPackageAnalyzeHistory;
+using NPA.ProcessRunner;
+
+namespace NetPackageAnalyzeHistory;
public record History(int? nrCommits, DateTime? FirstCommit, DateTime? LastCommit)
{
@@ -73,12 +75,14 @@ public int MinYear()
public class FileFolderHistorySimple
{
public readonly string nameFile;
+ private readonly IProcessRunner processRunner;
public HistoryPerYear? AllHistoryFile { get;private set; }
public HistoryPerYear? AllHistoryFolder { get; private set; }
- public FileFolderHistorySimple(string nameFile)
+ public FileFolderHistorySimple(string nameFile, IProcessRunner? processRunner = null)
{
this.nameFile = nameFile;
+ this.processRunner = processRunner ?? new SystemProcessRunner();
}
private HistoryPerYear NrCommits(string folder,string what)
{
@@ -96,19 +100,9 @@ private HistoryPerYear NrCommits(string folder,string what)
Arguments= "log --date=iso-strict --pretty=\"%ad\" -- "+ what
};
- // Create and start the process
- Process process = new Process
- {
- StartInfo = startInfo
- };
- process.Start();
-
- // Read the output
- string output = process.StandardOutput.ReadToEnd();
- string errorOutput = process.StandardError.ReadToEnd();
-
- // Wait for the process to exit
- process.WaitForExit();
+ var result = processRunner.Run(startInfo);
+ string output = result.StandardOutput;
+ string errorOutput = result.StandardError;
if (errorOutput.Length > 0)
{
throw new ArgumentException(errorOutput);
diff --git a/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/NetPackageAnalyzeHistory.csproj b/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/NetPackageAnalyzeHistory.csproj
index 6222e563..f7ddc39a 100644
--- a/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/NetPackageAnalyzeHistory.csproj
+++ b/src/NetPackageAnalyzer/NetPackageAnalyzeHistory/NetPackageAnalyzeHistory.csproj
@@ -10,4 +10,7 @@
+
+
+
diff --git a/src/NetPackageAnalyzer/NetPackageAnalyzer.slnx b/src/NetPackageAnalyzer/NetPackageAnalyzer.slnx
index f79ef278..2a67b62a 100644
--- a/src/NetPackageAnalyzer/NetPackageAnalyzer.slnx
+++ b/src/NetPackageAnalyzer/NetPackageAnalyzer.slnx
@@ -3,6 +3,7 @@
+
@@ -13,7 +14,10 @@
+
+
+
diff --git a/src/NetPackageAnalyzer/NetPackageAnalyzerConsole.Tests/NetPackageAnalyzerConsole.Tests.csproj b/src/NetPackageAnalyzer/NetPackageAnalyzerConsole.Tests/NetPackageAnalyzerConsole.Tests.csproj
new file mode 100644
index 00000000..41a4de5e
--- /dev/null
+++ b/src/NetPackageAnalyzer/NetPackageAnalyzerConsole.Tests/NetPackageAnalyzerConsole.Tests.csproj
@@ -0,0 +1,35 @@
+
+
+
+ net10.0
+ enable
+ enable
+ false
+ true
+
+
+
+
+
+
+ all
+ runtime; build; native; contentfiles; analyzers; buildtransitive
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ PreserveNewest
+
+
+
+