1340 lines
44 KiB
C#
Executable File
1340 lines
44 KiB
C#
Executable File
using MarketAlly.AIPlugin;
|
|
using Microsoft.CodeAnalysis;
|
|
using Microsoft.CodeAnalysis.CSharp;
|
|
using Microsoft.CodeAnalysis.CSharp.Syntax;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace MarketAlly.AIPlugin.Refactoring.Plugins
|
|
{
|
|
[AIPlugin("ReadmeGenerator", "Generates comprehensive README.md files for projects and solutions with intelligent content analysis")]
|
|
public class ReadmeGeneratorPlugin : IAIPlugin
|
|
{
|
|
[AIParameter("Path to project directory or solution file", required: true)]
|
|
public string ProjectPath { get; set; }
|
|
|
|
[AIParameter("Type of project: auto, library, application, tool, maui", required: false)]
|
|
public string ProjectType { get; set; } = "auto";
|
|
|
|
[AIParameter("Include API documentation section", required: false)]
|
|
public bool IncludeApiDocs { get; set; } = true;
|
|
|
|
[AIParameter("Include architecture diagrams", required: false)]
|
|
public bool IncludeArchitecture { get; set; } = true;
|
|
|
|
[AIParameter("Include setup and installation instructions", required: false)]
|
|
public bool IncludeSetup { get; set; } = true;
|
|
|
|
[AIParameter("Include usage examples", required: false)]
|
|
public bool IncludeExamples { get; set; } = true;
|
|
|
|
[AIParameter("Apply changes and create README.md file", required: false)]
|
|
public bool ApplyChanges { get; set; } = false;
|
|
|
|
[AIParameter("Maximum file size in characters for analysis (default: 50000)", required: false)]
|
|
public int MaxFileSize { get; set; } = 50000;
|
|
|
|
[AIParameter("Use intelligent AI-powered description generation", required: false)]
|
|
public bool UseIntelligentDescription { get; set; } = false;
|
|
|
|
[AIParameter("Intelligent description override (if provided, skips AI generation)", required: false)]
|
|
public string IntelligentDescription { get; set; } = "";
|
|
|
|
public IReadOnlyDictionary<string, Type> SupportedParameters => new Dictionary<string, Type>
|
|
{
|
|
["projectPath"] = typeof(string),
|
|
["projectpath"] = typeof(string),
|
|
["projectType"] = typeof(string),
|
|
["projecttype"] = typeof(string),
|
|
["includeApiDocs"] = typeof(bool),
|
|
["includeapidocs"] = typeof(bool),
|
|
["includeArchitecture"] = typeof(bool),
|
|
["includearchitecture"] = typeof(bool),
|
|
["includeSetup"] = typeof(bool),
|
|
["includesetup"] = typeof(bool),
|
|
["includeExamples"] = typeof(bool),
|
|
["includeexamples"] = typeof(bool),
|
|
["applyChanges"] = typeof(bool),
|
|
["applychanges"] = typeof(bool),
|
|
["maxFileSize"] = typeof(int),
|
|
["maxfilesize"] = typeof(int),
|
|
["maxFilesToAnalyze"] = typeof(int),
|
|
["maxfilestoanalyze"] = typeof(int),
|
|
["useIntelligentDescription"] = typeof(bool),
|
|
["useintelligentdescription"] = typeof(bool),
|
|
["intelligentDescription"] = typeof(string),
|
|
["intelligentdescription"] = typeof(string)
|
|
};
|
|
|
|
public async Task<AIPluginResult> ExecuteAsync(IReadOnlyDictionary<string, object> parameters)
|
|
{
|
|
try
|
|
{
|
|
// Extract parameters
|
|
string projectPath = GetParameterValue(parameters, "projectPath", "projectpath")?.ToString();
|
|
string projectType = GetParameterValue(parameters, "projectType", "projecttype")?.ToString()?.ToLower() ?? "auto";
|
|
bool includeApiDocs = GetBoolParameter(parameters, "includeApiDocs", "includeapidocs", true);
|
|
bool includeArchitecture = GetBoolParameter(parameters, "includeArchitecture", "includearchitecture", true);
|
|
bool includeSetup = GetBoolParameter(parameters, "includeSetup", "includesetup", true);
|
|
bool includeExamples = GetBoolParameter(parameters, "includeExamples", "includeexamples", true);
|
|
bool applyChanges = GetBoolParameter(parameters, "applyChanges", "applychanges", false);
|
|
int maxFileSize = GetIntParameter(parameters, "maxFileSize", "maxfilesize", 50000);
|
|
int maxFilesToAnalyze = GetIntParameter(parameters, "maxFilesToAnalyze", "maxfilestoanalyze", 20);
|
|
bool useIntelligentDescription = GetBoolParameter(parameters, "useIntelligentDescription", "useintelligentdescription", false);
|
|
string intelligentDescription = GetParameterValue(parameters, "intelligentDescription", "intelligentdescription")?.ToString() ?? "";
|
|
|
|
if (!Directory.Exists(projectPath) && !File.Exists(projectPath))
|
|
{
|
|
return new AIPluginResult(new DirectoryNotFoundException($"Path not found: {projectPath}"), "Invalid project path");
|
|
}
|
|
|
|
// Phase 1: Analyze project structure and extract metadata
|
|
var analysisResult = await AnalyzeProjectStructure(projectPath, projectType, maxFileSize, maxFilesToAnalyze);
|
|
|
|
if (!analysisResult.Success)
|
|
{
|
|
return new AIPluginResult(new Exception(analysisResult.Error), analysisResult.Error);
|
|
}
|
|
|
|
// Phase 2: Generate README content using structured analysis
|
|
var readmeContent = await GenerateReadmeContent(
|
|
analysisResult,
|
|
includeApiDocs,
|
|
includeArchitecture,
|
|
includeSetup,
|
|
includeExamples,
|
|
useIntelligentDescription ? intelligentDescription : null
|
|
);
|
|
|
|
// Apply changes if requested
|
|
if (applyChanges)
|
|
{
|
|
var readmePath = Path.Combine(
|
|
Directory.Exists(projectPath) ? projectPath : Path.GetDirectoryName(projectPath),
|
|
"README.md"
|
|
);
|
|
|
|
// Create backup if file exists
|
|
if (File.Exists(readmePath))
|
|
{
|
|
var backupPath = $"{readmePath}.{DateTime.Now:yyyyMMdd_HHmmss}.bak";
|
|
File.Copy(readmePath, backupPath);
|
|
}
|
|
|
|
await File.WriteAllTextAsync(readmePath, readmeContent);
|
|
|
|
return new AIPluginResult(new
|
|
{
|
|
Message = "README.md generated successfully",
|
|
ProjectPath = projectPath,
|
|
ReadmePath = readmePath,
|
|
ProjectType = analysisResult.DetectedProjectType,
|
|
FilesAnalyzed = analysisResult.FilesAnalyzed,
|
|
ContentLength = readmeContent.Length,
|
|
Sections = analysisResult.IncludedSections,
|
|
ChangesApplied = true,
|
|
Timestamp = DateTime.UtcNow
|
|
});
|
|
}
|
|
else
|
|
{
|
|
return new AIPluginResult(new
|
|
{
|
|
Message = "README.md content generated (preview mode)",
|
|
ProjectPath = projectPath,
|
|
ProjectType = analysisResult.DetectedProjectType,
|
|
FilesAnalyzed = analysisResult.FilesAnalyzed,
|
|
ContentLength = readmeContent.Length,
|
|
Sections = analysisResult.IncludedSections,
|
|
PreviewContent = readmeContent,
|
|
ChangesApplied = false,
|
|
Timestamp = DateTime.UtcNow
|
|
});
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new AIPluginResult(ex, $"README generation failed: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
private async Task<ProjectAnalysisResult> AnalyzeProjectStructure(string projectPath, string projectType, int maxFileSize, int maxFilesToAnalyze)
|
|
{
|
|
var result = new ProjectAnalysisResult();
|
|
|
|
try
|
|
{
|
|
// Determine if it's a solution or single project
|
|
if (File.Exists(projectPath) && projectPath.EndsWith(".sln"))
|
|
{
|
|
result = await AnalyzeSolution(projectPath, maxFileSize, maxFilesToAnalyze);
|
|
}
|
|
else if (Directory.Exists(projectPath))
|
|
{
|
|
result = await AnalyzeDirectory(projectPath, projectType, maxFileSize, maxFilesToAnalyze);
|
|
}
|
|
else if (File.Exists(projectPath) && projectPath.EndsWith(".csproj"))
|
|
{
|
|
result = await AnalyzeProject(projectPath, projectType, maxFileSize, maxFilesToAnalyze);
|
|
}
|
|
|
|
result.Success = true;
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.Success = false;
|
|
result.Error = ex.Message;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
private async Task<ProjectAnalysisResult> AnalyzeSolution(string solutionPath, int maxFileSize, int maxFilesToAnalyze)
|
|
{
|
|
var result = new ProjectAnalysisResult
|
|
{
|
|
ProjectName = Path.GetFileNameWithoutExtension(solutionPath),
|
|
ProjectPath = Path.GetDirectoryName(solutionPath),
|
|
IsSolution = true
|
|
};
|
|
|
|
// Parse solution file
|
|
var solutionContent = await File.ReadAllTextAsync(solutionPath);
|
|
var projectMatches = Regex.Matches(solutionContent, @"Project\(""[^""]+\""\)\s*=\s*""([^""]+)"",\s*""([^""]+)""");
|
|
|
|
foreach (Match match in projectMatches)
|
|
{
|
|
var projectName = match.Groups[1].Value;
|
|
var projectRelativePath = match.Groups[2].Value;
|
|
var projectFullPath = Path.Combine(Path.GetDirectoryName(solutionPath), projectRelativePath);
|
|
|
|
if (File.Exists(projectFullPath) && projectFullPath.EndsWith(".csproj"))
|
|
{
|
|
var projectAnalysis = await AnalyzeProject(projectFullPath, "auto", maxFileSize, maxFilesToAnalyze / 2);
|
|
result.SubProjects.Add(projectAnalysis);
|
|
}
|
|
}
|
|
|
|
// Aggregate analysis
|
|
result.DetectedProjectType = DetermineOverallProjectType(result.SubProjects);
|
|
result.KeyFiles = result.SubProjects.SelectMany(p => p.KeyFiles).Take(maxFilesToAnalyze).ToList();
|
|
result.PublicApis = result.SubProjects.SelectMany(p => p.PublicApis).ToList();
|
|
result.Dependencies = result.SubProjects.SelectMany(p => p.Dependencies).Distinct().ToList();
|
|
result.FilesAnalyzed = result.SubProjects.Sum(p => p.FilesAnalyzed);
|
|
|
|
return result;
|
|
}
|
|
|
|
private async Task<ProjectAnalysisResult> AnalyzeDirectory(string directoryPath, string projectType, int maxFileSize, int maxFilesToAnalyze)
|
|
{
|
|
var result = new ProjectAnalysisResult
|
|
{
|
|
ProjectPath = directoryPath,
|
|
ProjectName = Path.GetFileName(directoryPath)
|
|
};
|
|
|
|
// Look for project files
|
|
var projectFiles = Directory.GetFiles(directoryPath, "*.csproj", SearchOption.TopDirectoryOnly);
|
|
|
|
if (projectFiles.Any())
|
|
{
|
|
return await AnalyzeProject(projectFiles.First(), projectType, maxFileSize, maxFilesToAnalyze);
|
|
}
|
|
|
|
// Analyze as general directory
|
|
result.DetectedProjectType = "application";
|
|
await AnalyzeCodeFiles(directoryPath, result, maxFileSize, maxFilesToAnalyze);
|
|
|
|
return result;
|
|
}
|
|
|
|
private async Task<ProjectAnalysisResult> AnalyzeProject(string projectPath, string projectType, int maxFileSize, int maxFilesToAnalyze)
|
|
{
|
|
var result = new ProjectAnalysisResult
|
|
{
|
|
ProjectPath = Path.GetDirectoryName(projectPath),
|
|
ProjectName = Path.GetFileNameWithoutExtension(projectPath)
|
|
};
|
|
|
|
// Parse project file
|
|
var projectContent = await File.ReadAllTextAsync(projectPath);
|
|
result.TargetFramework = ExtractTargetFramework(projectContent);
|
|
result.Dependencies = ExtractPackageReferences(projectContent);
|
|
|
|
// Detect project type
|
|
result.DetectedProjectType = projectType == "auto"
|
|
? DetectProjectType(projectContent, result.ProjectName)
|
|
: projectType;
|
|
|
|
// Analyze code files
|
|
await AnalyzeCodeFiles(result.ProjectPath, result, maxFileSize, maxFilesToAnalyze);
|
|
|
|
return result;
|
|
}
|
|
|
|
private async Task AnalyzeCodeFiles(string directoryPath, ProjectAnalysisResult result, int maxFileSize, int maxFilesToAnalyze)
|
|
{
|
|
var csharpFiles = Directory.GetFiles(directoryPath, "*.cs", SearchOption.AllDirectories)
|
|
.Where(f => !ShouldExcludeFile(f))
|
|
.Take(maxFilesToAnalyze)
|
|
.ToList();
|
|
|
|
var prioritizedFiles = PrioritizeFiles(csharpFiles, result.DetectedProjectType);
|
|
|
|
foreach (var file in prioritizedFiles)
|
|
{
|
|
try
|
|
{
|
|
var fileInfo = new FileInfo(file);
|
|
if (fileInfo.Length > maxFileSize) continue;
|
|
|
|
var content = await File.ReadAllTextAsync(file);
|
|
var syntaxTree = CSharpSyntaxTree.ParseText(content);
|
|
var root = syntaxTree.GetRoot();
|
|
|
|
// Extract key information
|
|
var fileAnalysis = AnalyzeCodeFile(file, root, content);
|
|
|
|
result.KeyFiles.Add(fileAnalysis);
|
|
result.PublicApis.AddRange(ExtractPublicApi(root));
|
|
result.FilesAnalyzed++;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// Skip problematic files
|
|
}
|
|
}
|
|
|
|
// Detect additional features
|
|
result.HasTests = csharpFiles.Any(f => f.Contains("Test", StringComparison.OrdinalIgnoreCase));
|
|
result.HasDocumentation = Directory.GetFiles(directoryPath, "*.md", SearchOption.AllDirectories).Any();
|
|
}
|
|
|
|
private List<string> PrioritizeFiles(List<string> files, string projectType)
|
|
{
|
|
var prioritized = new List<string>();
|
|
|
|
// High priority patterns based on project type
|
|
var highPriorityPatterns = projectType switch
|
|
{
|
|
"library" => new[] { "Plugin", "Service", "Manager", "Factory", "Builder", "Repository", "Interface" },
|
|
"application" => new[] { "Program", "Main", "Startup", "Controller", "Service", "App" },
|
|
"maui" => new[] { "App", "MainPage", "AppShell", "MauiProgram", "Platform" },
|
|
"tool" => new[] { "Program", "Main", "Command", "Tool", "Cli" },
|
|
_ => new[] { "Program", "Main", "Service", "Controller", "Manager" }
|
|
};
|
|
|
|
// Add high priority files first
|
|
foreach (var pattern in highPriorityPatterns)
|
|
{
|
|
prioritized.AddRange(files.Where(f => Path.GetFileName(f).Contains(pattern, StringComparison.OrdinalIgnoreCase)));
|
|
}
|
|
|
|
// Add remaining files
|
|
prioritized.AddRange(files.Except(prioritized));
|
|
|
|
return prioritized.Distinct().ToList();
|
|
}
|
|
|
|
private CodeFileAnalysis AnalyzeCodeFile(string filePath, SyntaxNode root, string content)
|
|
{
|
|
var analysis = new CodeFileAnalysis
|
|
{
|
|
FilePath = filePath,
|
|
FileName = Path.GetFileName(filePath),
|
|
LineCount = content.Split('\n').Length
|
|
};
|
|
|
|
// Extract classes and interfaces
|
|
var classes = root.DescendantNodes().OfType<ClassDeclarationSyntax>();
|
|
var interfaces = root.DescendantNodes().OfType<InterfaceDeclarationSyntax>();
|
|
|
|
analysis.Classes = classes.Select(c => c.Identifier.ValueText).ToList();
|
|
analysis.Interfaces = interfaces.Select(i => i.Identifier.ValueText).ToList();
|
|
|
|
// Extract key patterns
|
|
analysis.HasAttributes = root.DescendantNodes().OfType<AttributeSyntax>().Any();
|
|
analysis.HasAsyncMethods = root.DescendantNodes().OfType<MethodDeclarationSyntax>()
|
|
.Any(m => m.Modifiers.Any(mod => mod.IsKind(SyntaxKind.AsyncKeyword)));
|
|
|
|
// Extract namespace
|
|
var namespaceDecl = root.DescendantNodes().OfType<NamespaceDeclarationSyntax>().FirstOrDefault();
|
|
analysis.Namespace = namespaceDecl?.Name.ToString();
|
|
|
|
return analysis;
|
|
}
|
|
|
|
private List<ApiMethod> ExtractPublicApi(SyntaxNode root)
|
|
{
|
|
var apis = new List<ApiMethod>();
|
|
|
|
var publicMethods = root.DescendantNodes().OfType<MethodDeclarationSyntax>()
|
|
.Where(m => m.Modifiers.Any(mod => mod.IsKind(SyntaxKind.PublicKeyword)))
|
|
.Where(m => !IsConstructor(m) && !IsPropertyAccessor(m)); // Filter out constructors and property accessors
|
|
|
|
foreach (var method in publicMethods)
|
|
{
|
|
var className = GetContainingClassName(method);
|
|
var methodName = method.Identifier.ValueText;
|
|
|
|
// Skip duplicate ExecuteAsync methods - only include one per class
|
|
if (methodName == "ExecuteAsync" && apis.Any(a => a.Name == "ExecuteAsync" && a.ClassName == className))
|
|
continue;
|
|
|
|
apis.Add(new ApiMethod
|
|
{
|
|
Name = methodName,
|
|
ClassName = className,
|
|
ReturnType = method.ReturnType.ToString(),
|
|
Parameters = method.ParameterList.Parameters.Select(p =>
|
|
$"{p.Type} {p.Identifier.ValueText}").ToList(),
|
|
IsAsync = method.Modifiers.Any(m => m.IsKind(SyntaxKind.AsyncKeyword)),
|
|
Summary = ExtractDocumentationSummary(method),
|
|
IsPluginMethod = methodName == "ExecuteAsync" && className.Contains("Plugin")
|
|
});
|
|
}
|
|
|
|
// Group and prioritize meaningful methods
|
|
return apis.GroupBy(a => $"{a.ClassName}.{a.Name}")
|
|
.Select(g => g.First()) // Remove exact duplicates
|
|
.Where(a => !IsBoilerplateMethod(a))
|
|
.OrderBy(a => a.IsPluginMethod ? 0 : 1) // Plugin methods first
|
|
.ThenBy(a => a.ClassName)
|
|
.ThenBy(a => a.Name)
|
|
.ToList();
|
|
}
|
|
|
|
private bool IsConstructor(MethodDeclarationSyntax method)
|
|
{
|
|
return method.Identifier.ValueText == method.Parent?.ChildTokens()
|
|
.FirstOrDefault(t => t.IsKind(SyntaxKind.IdentifierToken)).ValueText;
|
|
}
|
|
|
|
private bool IsPropertyAccessor(MethodDeclarationSyntax method)
|
|
{
|
|
return method.Parent is AccessorDeclarationSyntax;
|
|
}
|
|
|
|
private string GetContainingClassName(MethodDeclarationSyntax method)
|
|
{
|
|
var classDecl = method.FirstAncestorOrSelf<ClassDeclarationSyntax>();
|
|
return classDecl?.Identifier.ValueText ?? "Unknown";
|
|
}
|
|
|
|
private bool IsBoilerplateMethod(ApiMethod method)
|
|
{
|
|
var boilerplateMethods = new[] { "ToString", "GetHashCode", "Equals", "GetType" };
|
|
return boilerplateMethods.Contains(method.Name);
|
|
}
|
|
|
|
private string ExtractDocumentationSummary(SyntaxNode node)
|
|
{
|
|
var docComment = node.GetLeadingTrivia()
|
|
.FirstOrDefault(t => t.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia));
|
|
|
|
if (docComment.IsKind(SyntaxKind.None)) return null;
|
|
|
|
var commentText = docComment.ToString();
|
|
var summaryMatch = Regex.Match(commentText, @"<summary>\s*(.*?)\s*</summary>", RegexOptions.Singleline);
|
|
|
|
return summaryMatch.Success
|
|
? summaryMatch.Groups[1].Value.Trim().Replace("///", "").Trim()
|
|
: null;
|
|
}
|
|
|
|
private string DetectProjectType(string projectContent, string projectName)
|
|
{
|
|
if (projectContent.Contains("<UseMaui>true</UseMaui>"))
|
|
return "maui";
|
|
|
|
if (projectContent.Contains("<OutputType>Exe</OutputType>") ||
|
|
projectName.ToLower().Contains("console") ||
|
|
projectName.ToLower().Contains("tool") ||
|
|
projectName.ToLower().Contains("cli"))
|
|
return "tool";
|
|
|
|
if (projectContent.Contains("Microsoft.AspNetCore") ||
|
|
projectContent.Contains("Microsoft.Extensions.Hosting"))
|
|
return "application";
|
|
|
|
if (projectContent.Contains("<OutputType>Library</OutputType>") ||
|
|
projectName.ToLower().Contains("library") ||
|
|
projectName.ToLower().Contains("plugin"))
|
|
return "library";
|
|
|
|
return "application";
|
|
}
|
|
|
|
private string DetermineOverallProjectType(List<ProjectAnalysisResult> projects)
|
|
{
|
|
if (projects.Any(p => p.DetectedProjectType == "maui"))
|
|
return "maui";
|
|
|
|
var types = projects.Select(p => p.DetectedProjectType).ToList();
|
|
return types.GroupBy(t => t).OrderByDescending(g => g.Count()).First().Key;
|
|
}
|
|
|
|
private string ExtractTargetFramework(string projectContent)
|
|
{
|
|
var match = Regex.Match(projectContent, @"<TargetFramework[s]?>(.*?)</TargetFramework[s]?>");
|
|
return match.Success ? match.Groups[1].Value : "Unknown";
|
|
}
|
|
|
|
private List<string> ExtractMauiPlatforms(string targetFramework)
|
|
{
|
|
var platforms = new List<string>();
|
|
|
|
if (string.IsNullOrEmpty(targetFramework) || targetFramework == "Unknown")
|
|
return platforms;
|
|
|
|
// Split multiple target frameworks
|
|
var frameworks = targetFramework.Split(';', ',')
|
|
.Select(f => f.Trim())
|
|
.Where(f => !string.IsNullOrEmpty(f));
|
|
|
|
foreach (var framework in frameworks)
|
|
{
|
|
var platform = framework.ToLower() switch
|
|
{
|
|
var f when f.Contains("android") => "Android",
|
|
var f when f.Contains("ios") => "iOS",
|
|
var f when f.Contains("windows") => "Windows",
|
|
var f when f.Contains("maccatalyst") => "macOS (Mac Catalyst)",
|
|
var f when f.Contains("tizen") => "Tizen",
|
|
_ => null
|
|
};
|
|
|
|
if (platform != null && !platforms.Contains(platform))
|
|
{
|
|
platforms.Add(platform);
|
|
}
|
|
}
|
|
|
|
return platforms;
|
|
}
|
|
|
|
private List<string> ExtractPackageReferences(string projectContent)
|
|
{
|
|
var matches = Regex.Matches(projectContent, @"<PackageReference Include=""([^""]+)""");
|
|
return matches.Cast<Match>().Select(m => m.Groups[1].Value).ToList();
|
|
}
|
|
|
|
private bool ShouldExcludeFile(string filePath)
|
|
{
|
|
var fileName = Path.GetFileName(filePath);
|
|
var excludePatterns = new[]
|
|
{
|
|
".Designer.cs", ".generated.cs", ".g.cs", "AssemblyInfo.cs",
|
|
"GlobalAssemblyInfo.cs", "TemporaryGeneratedFile", ".AssemblyAttributes.cs"
|
|
};
|
|
|
|
return excludePatterns.Any(pattern => fileName.Contains(pattern, StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
private async Task<string> GenerateReadmeContent(
|
|
ProjectAnalysisResult analysis,
|
|
bool includeApiDocs,
|
|
bool includeArchitecture,
|
|
bool includeSetup,
|
|
bool includeExamples,
|
|
string intelligentDescription = null)
|
|
{
|
|
var template = GetTemplate(analysis.DetectedProjectType);
|
|
var content = new StringBuilder();
|
|
|
|
// Handle MAUI platforms section
|
|
var platformsSection = "";
|
|
if (analysis.DetectedProjectType == "maui")
|
|
{
|
|
var platforms = ExtractMauiPlatforms(analysis.TargetFramework);
|
|
if (platforms.Any())
|
|
{
|
|
platformsSection = "## Supported Platforms\n\n" +
|
|
string.Join("\n", platforms.Select(p => $"- {p}")) + "\n\n";
|
|
}
|
|
}
|
|
|
|
// Replace template variables
|
|
var processedTemplate = template
|
|
.Replace("{{PROJECT_NAME}}", analysis.ProjectName)
|
|
.Replace("{{PROJECT_TYPE}}", FormatProjectType(analysis.DetectedProjectType))
|
|
.Replace("{{TARGET_FRAMEWORK}}", analysis.TargetFramework)
|
|
.Replace("{{DESCRIPTION}}", intelligentDescription ?? GenerateDescription(analysis))
|
|
.Replace("{{PLATFORMS_SECTION}}", platformsSection);
|
|
|
|
content.AppendLine(processedTemplate);
|
|
|
|
// Add sections based on parameters
|
|
if (includeSetup)
|
|
{
|
|
content.AppendLine(GenerateSetupSection(analysis));
|
|
}
|
|
|
|
if (includeExamples)
|
|
{
|
|
content.AppendLine(GenerateExamplesSection(analysis));
|
|
}
|
|
|
|
// Only show API docs for libraries and plugins - not for applications/tools/MAUI apps
|
|
if (includeApiDocs && analysis.PublicApis.Any() && ShouldIncludeApiDocs(analysis.DetectedProjectType))
|
|
{
|
|
content.AppendLine(GenerateApiDocumentation(analysis));
|
|
}
|
|
|
|
if (includeArchitecture)
|
|
{
|
|
content.AppendLine(GenerateArchitectureSection(analysis));
|
|
}
|
|
|
|
// Add additional sections
|
|
content.AppendLine(GenerateDependenciesSection(analysis));
|
|
content.AppendLine(GenerateContributingSection(analysis));
|
|
|
|
return content.ToString();
|
|
}
|
|
|
|
private string GetTemplate(string projectType)
|
|
{
|
|
return projectType switch
|
|
{
|
|
"library" => GetLibraryTemplate(),
|
|
"maui" => GetMauiTemplate(),
|
|
"tool" => GetToolTemplate(),
|
|
_ => GetApplicationTemplate()
|
|
};
|
|
}
|
|
|
|
private string GetLibraryTemplate()
|
|
{
|
|
return @"# {{PROJECT_NAME}}
|
|
|
|
A {{PROJECT_TYPE}} for .NET {{TARGET_FRAMEWORK}}.
|
|
|
|
## Overview
|
|
|
|
{{DESCRIPTION}}
|
|
|
|
## Features
|
|
|
|
- Modern .NET {{TARGET_FRAMEWORK}} implementation
|
|
- Comprehensive API surface
|
|
- Well-documented public interfaces
|
|
- Unit tested and production ready
|
|
|
|
";
|
|
}
|
|
|
|
private string GetMauiTemplate()
|
|
{
|
|
return @"# {{PROJECT_NAME}}
|
|
|
|
A cross-platform application built with .NET MAUI.
|
|
|
|
## Overview
|
|
|
|
{{DESCRIPTION}}
|
|
|
|
{{PLATFORMS_SECTION}}
|
|
|
|
## Features
|
|
|
|
- Cross-platform native UI
|
|
- Shared business logic
|
|
- Modern .NET implementation
|
|
|
|
";
|
|
}
|
|
|
|
private string GetToolTemplate()
|
|
{
|
|
return @"# {{PROJECT_NAME}}
|
|
|
|
A command-line tool built with .NET {{TARGET_FRAMEWORK}}.
|
|
|
|
## Overview
|
|
|
|
{{DESCRIPTION}}
|
|
|
|
## Features
|
|
|
|
- Cross-platform CLI tool
|
|
- Modern .NET {{TARGET_FRAMEWORK}} implementation
|
|
- Comprehensive command set
|
|
- Built-in help and documentation
|
|
|
|
";
|
|
}
|
|
|
|
private string GetApplicationTemplate()
|
|
{
|
|
return @"# {{PROJECT_NAME}}
|
|
|
|
A .NET {{TARGET_FRAMEWORK}} application.
|
|
|
|
## Overview
|
|
|
|
{{DESCRIPTION}}
|
|
|
|
## Features
|
|
|
|
- Modern .NET {{TARGET_FRAMEWORK}} implementation
|
|
- Scalable architecture
|
|
- Comprehensive functionality
|
|
- Production ready
|
|
|
|
";
|
|
}
|
|
|
|
private string GenerateDescription(ProjectAnalysisResult analysis)
|
|
{
|
|
var features = new List<string>();
|
|
|
|
if (analysis.PublicApis.Any())
|
|
features.Add($"Provides {analysis.PublicApis.Count} public API methods");
|
|
|
|
if (analysis.Dependencies.Any())
|
|
features.Add($"Integrates with {analysis.Dependencies.Count} external packages");
|
|
|
|
if (analysis.HasTests)
|
|
features.Add("includes comprehensive test coverage");
|
|
|
|
if (analysis.IsSolution)
|
|
features.Add($"multi-project solution with {analysis.SubProjects.Count} projects");
|
|
|
|
var description = $"This {analysis.DetectedProjectType} ";
|
|
|
|
if (features.Any())
|
|
{
|
|
description += string.Join(", ", features) + ".";
|
|
}
|
|
else
|
|
{
|
|
description += "provides essential functionality for your .NET applications.";
|
|
}
|
|
|
|
return description;
|
|
}
|
|
|
|
private string GenerateSetupSection(ProjectAnalysisResult analysis)
|
|
{
|
|
var setup = new StringBuilder();
|
|
setup.AppendLine("## Installation");
|
|
setup.AppendLine();
|
|
|
|
if (analysis.DetectedProjectType == "library")
|
|
{
|
|
setup.AppendLine("### Package Manager");
|
|
setup.AppendLine("```");
|
|
setup.AppendLine($"Install-Package {analysis.ProjectName}");
|
|
setup.AppendLine("```");
|
|
setup.AppendLine();
|
|
setup.AppendLine("### .NET CLI");
|
|
setup.AppendLine("```bash");
|
|
setup.AppendLine($"dotnet add package {analysis.ProjectName}");
|
|
setup.AppendLine("```");
|
|
}
|
|
else if (analysis.DetectedProjectType == "tool")
|
|
{
|
|
setup.AppendLine("### Install as Global Tool");
|
|
setup.AppendLine("```bash");
|
|
setup.AppendLine($"dotnet tool install -g {analysis.ProjectName}");
|
|
setup.AppendLine("```");
|
|
setup.AppendLine();
|
|
setup.AppendLine("### Local Installation");
|
|
setup.AppendLine("```bash");
|
|
setup.AppendLine("git clone <repository-url>");
|
|
setup.AppendLine($"cd {analysis.ProjectName}");
|
|
setup.AppendLine("dotnet build");
|
|
setup.AppendLine("dotnet run");
|
|
setup.AppendLine("```");
|
|
}
|
|
else if (analysis.DetectedProjectType == "maui")
|
|
{
|
|
setup.AppendLine("### Prerequisites");
|
|
var platforms = ExtractMauiPlatforms(analysis.TargetFramework);
|
|
var netVersion = ExtractNetVersion(analysis.TargetFramework);
|
|
setup.AppendLine($"- .NET {netVersion} SDK");
|
|
setup.AppendLine("- .NET MAUI workload");
|
|
|
|
if (platforms.Contains("Android"))
|
|
setup.AppendLine("- Android SDK (for Android development)");
|
|
if (platforms.Contains("iOS"))
|
|
setup.AppendLine("- Xcode (for iOS development)");
|
|
if (platforms.Contains("Windows"))
|
|
setup.AppendLine("- Windows App SDK (for Windows development)");
|
|
|
|
setup.AppendLine();
|
|
setup.AppendLine("### Build and Run");
|
|
setup.AppendLine("```bash");
|
|
setup.AppendLine("git clone <repository-url>");
|
|
setup.AppendLine($"cd {analysis.ProjectName}");
|
|
setup.AppendLine("dotnet restore");
|
|
setup.AppendLine("dotnet build");
|
|
|
|
if (platforms.Count == 1)
|
|
{
|
|
var platform = platforms.First().ToLower().Replace(" (mac catalyst)", "");
|
|
setup.AppendLine($"dotnet run --framework net{netVersion}-{platform}");
|
|
}
|
|
else
|
|
{
|
|
setup.AppendLine("# Run on specific platform:");
|
|
foreach (var platform in platforms.Take(3)) // Show top 3 platforms
|
|
{
|
|
var platformCode = platform.ToLower() switch
|
|
{
|
|
"android" => "android",
|
|
"ios" => "ios",
|
|
"windows" => "windows10.0.19041.0",
|
|
"macos (mac catalyst)" => "maccatalyst",
|
|
"tizen" => "tizen",
|
|
_ => platform.ToLower()
|
|
};
|
|
setup.AppendLine($"# dotnet run --framework net{netVersion}-{platformCode}");
|
|
}
|
|
}
|
|
setup.AppendLine("```");
|
|
}
|
|
else
|
|
{
|
|
setup.AppendLine("### Prerequisites");
|
|
var netVersion = ExtractNetVersion(analysis.TargetFramework);
|
|
setup.AppendLine($"- .NET {netVersion} SDK");
|
|
setup.AppendLine();
|
|
setup.AppendLine("### Build and Run");
|
|
setup.AppendLine("```bash");
|
|
setup.AppendLine("git clone <repository-url>");
|
|
setup.AppendLine($"cd {analysis.ProjectName}");
|
|
setup.AppendLine("dotnet restore");
|
|
setup.AppendLine("dotnet build");
|
|
setup.AppendLine("dotnet run");
|
|
setup.AppendLine("```");
|
|
}
|
|
|
|
return setup.ToString();
|
|
}
|
|
|
|
private bool ShouldIncludeApiDocs(string projectType)
|
|
{
|
|
return projectType switch
|
|
{
|
|
"library" => true, // Libraries have public APIs for consumers
|
|
"application" => false, // Applications are for end users, not developers
|
|
"tool" => false, // CLI tools focus on usage, not internal APIs
|
|
"maui" => false, // MAUI apps are end-user applications
|
|
_ => false // Default to false for unknown types
|
|
};
|
|
}
|
|
|
|
private string ExtractNetVersion(string targetFramework)
|
|
{
|
|
if (string.IsNullOrEmpty(targetFramework)) return "8.0";
|
|
|
|
// Extract version from frameworks like "net9.0-android;net9.0-ios"
|
|
var match = Regex.Match(targetFramework, @"net(\d+\.\d+)");
|
|
return match.Success ? match.Groups[1].Value : "8.0";
|
|
}
|
|
|
|
private string GenerateExamplesSection(ProjectAnalysisResult analysis)
|
|
{
|
|
var examples = new StringBuilder();
|
|
examples.AppendLine("## Usage Examples");
|
|
examples.AppendLine();
|
|
|
|
if (analysis.DetectedProjectType == "library" && analysis.PublicApis.Any())
|
|
{
|
|
// Check if this is a plugin-based architecture
|
|
var pluginClasses = analysis.KeyFiles
|
|
.SelectMany(f => f.Classes)
|
|
.Where(c => c.Contains("Plugin"))
|
|
.Take(5)
|
|
.ToList();
|
|
|
|
if (pluginClasses.Any())
|
|
{
|
|
examples.AppendLine("### Plugin Registration and Usage");
|
|
examples.AppendLine();
|
|
examples.AppendLine("```csharp");
|
|
examples.AppendLine("using " + (analysis.KeyFiles.FirstOrDefault()?.Namespace ?? analysis.ProjectName) + ";");
|
|
examples.AppendLine();
|
|
examples.AppendLine("// Register plugins");
|
|
examples.AppendLine("var registry = new AIPluginRegistry();");
|
|
|
|
foreach (var pluginClass in pluginClasses)
|
|
{
|
|
examples.AppendLine($"registry.RegisterPlugin(new {pluginClass}());");
|
|
}
|
|
|
|
examples.AppendLine();
|
|
examples.AppendLine("// Execute plugin functionality");
|
|
var firstPlugin = pluginClasses.FirstOrDefault()?.Replace("Plugin", "");
|
|
if (!string.IsNullOrEmpty(firstPlugin))
|
|
{
|
|
examples.AppendLine($"var result = await registry.CallFunctionAsync(\"{firstPlugin}\", new Dictionary<string, object>");
|
|
examples.AppendLine("{");
|
|
|
|
// Use actual parameters from the plugin if available
|
|
var pluginApi = analysis.PublicApis.FirstOrDefault(a => a.ClassName == pluginClasses.First());
|
|
if (pluginApi != null && pluginApi.Parameters.Any())
|
|
{
|
|
var sampleParam = pluginApi.Parameters.First().Split(' ').Last(); // Get parameter name
|
|
var paramType = pluginApi.Parameters.First().Split(' ').First(); // Get parameter type
|
|
|
|
var sampleValue = paramType.ToLower() switch
|
|
{
|
|
"string" => "\"example.cs\"",
|
|
"bool" => "true",
|
|
"int" => "42",
|
|
_ => "\"value\""
|
|
};
|
|
examples.AppendLine($" [\"{sampleParam}\"] = {sampleValue}");
|
|
}
|
|
else
|
|
{
|
|
examples.AppendLine(" // Parameters specific to the plugin");
|
|
}
|
|
|
|
examples.AppendLine("});");
|
|
}
|
|
examples.AppendLine("```");
|
|
|
|
// Add batch processing example if multiple plugins
|
|
if (pluginClasses.Count > 1)
|
|
{
|
|
examples.AppendLine();
|
|
examples.AppendLine("### Batch Processing");
|
|
examples.AppendLine();
|
|
examples.AppendLine("```csharp");
|
|
examples.AppendLine("// Process with multiple plugins");
|
|
var pluginNames = pluginClasses.Select(p => p.Replace("Plugin", "")).Take(3);
|
|
examples.AppendLine($"var operations = new[] {{ \"{string.Join("\", \"", pluginNames)}\" }};");
|
|
examples.AppendLine("foreach (var operation in operations)");
|
|
examples.AppendLine("{");
|
|
examples.AppendLine(" var result = await registry.CallFunctionAsync(operation, parameters);");
|
|
examples.AppendLine(" // Process result");
|
|
examples.AppendLine("}");
|
|
examples.AppendLine("```");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// For non-plugin libraries, only show examples if we have actual meaningful APIs
|
|
var meaningfulApis = analysis.PublicApis
|
|
.Where(a => !IsBoilerplateMethod(a))
|
|
.Where(a => !string.IsNullOrEmpty(a.ClassName))
|
|
.GroupBy(a => a.ClassName)
|
|
.Take(2)
|
|
.ToList();
|
|
|
|
if (meaningfulApis.Any())
|
|
{
|
|
examples.AppendLine("### Basic Usage");
|
|
examples.AppendLine();
|
|
examples.AppendLine("```csharp");
|
|
examples.AppendLine("using " + (analysis.KeyFiles.FirstOrDefault()?.Namespace ?? analysis.ProjectName) + ";");
|
|
examples.AppendLine();
|
|
|
|
foreach (var classGroup in meaningfulApis)
|
|
{
|
|
var className = classGroup.Key;
|
|
var firstMethod = classGroup.First();
|
|
|
|
examples.AppendLine($"// Using {className}");
|
|
examples.AppendLine($"var {className.ToLower()} = new {className}();");
|
|
|
|
if (firstMethod.IsAsync)
|
|
{
|
|
examples.AppendLine($"var result = await {className.ToLower()}.{firstMethod.Name}({GenerateExampleParams(firstMethod.Parameters)});");
|
|
}
|
|
else
|
|
{
|
|
examples.AppendLine($"var result = {className.ToLower()}.{firstMethod.Name}({GenerateExampleParams(firstMethod.Parameters)});");
|
|
}
|
|
examples.AppendLine();
|
|
}
|
|
examples.AppendLine("```");
|
|
}
|
|
// If no meaningful APIs found, don't show a usage section at all
|
|
}
|
|
}
|
|
else if (analysis.DetectedProjectType == "tool")
|
|
{
|
|
examples.AppendLine("### Command Line Usage");
|
|
examples.AppendLine();
|
|
examples.AppendLine("```bash");
|
|
examples.AppendLine($"# Install the tool");
|
|
examples.AppendLine($"dotnet tool install -g {analysis.ProjectName}");
|
|
examples.AppendLine();
|
|
examples.AppendLine($"# Basic usage");
|
|
examples.AppendLine($"{analysis.ProjectName.ToLower()} --help");
|
|
examples.AppendLine();
|
|
examples.AppendLine($"# Process files");
|
|
examples.AppendLine($"{analysis.ProjectName.ToLower()} process --input file.txt --output result.txt");
|
|
examples.AppendLine("```");
|
|
}
|
|
// For other project types with no clear APIs, don't show usage examples at all
|
|
|
|
return examples.ToString();
|
|
}
|
|
|
|
private string GenerateExampleParams(List<string> parameters)
|
|
{
|
|
if (!parameters.Any()) return "";
|
|
|
|
return string.Join(", ", parameters.Select(param =>
|
|
{
|
|
var parts = param.Split(' ');
|
|
var type = parts[0].ToLower();
|
|
return type switch
|
|
{
|
|
"string" => "\"example\"",
|
|
"int" => "42",
|
|
"bool" => "true",
|
|
"double" or "decimal" => "3.14",
|
|
_ => "null"
|
|
};
|
|
}));
|
|
}
|
|
|
|
private string GenerateApiDocumentation(ProjectAnalysisResult analysis)
|
|
{
|
|
var api = new StringBuilder();
|
|
api.AppendLine("## API Reference");
|
|
api.AppendLine();
|
|
|
|
if (!analysis.PublicApis.Any())
|
|
{
|
|
api.AppendLine("*API documentation will be generated when public methods are detected.*");
|
|
return api.ToString();
|
|
}
|
|
|
|
// Group APIs by class, but with better organization
|
|
var groupedApis = analysis.PublicApis
|
|
.GroupBy(a => a.ClassName ?? "General")
|
|
.Where(g => g.Any(m => !string.IsNullOrEmpty(m.Name)))
|
|
.Take(8) // Limit to top 8 classes
|
|
.ToList();
|
|
|
|
foreach (var group in groupedApis)
|
|
{
|
|
var className = group.Key;
|
|
var methods = group.Where(m => !string.IsNullOrEmpty(m.Name)).Take(6).ToList(); // Limit methods per class
|
|
|
|
if (!methods.Any()) continue;
|
|
|
|
api.AppendLine($"### {className}");
|
|
api.AppendLine();
|
|
|
|
foreach (var method in methods)
|
|
{
|
|
// Create meaningful descriptions for plugin methods
|
|
var description = GenerateMethodDescription(method, className);
|
|
|
|
if (!string.IsNullOrEmpty(description))
|
|
{
|
|
api.AppendLine($"#### {method.Name}");
|
|
api.AppendLine();
|
|
api.AppendLine(description);
|
|
api.AppendLine();
|
|
}
|
|
|
|
api.AppendLine("```csharp");
|
|
var signature = $"{method.ReturnType} {method.Name}(";
|
|
if (method.Parameters.Any())
|
|
{
|
|
signature += string.Join(", ", method.Parameters);
|
|
}
|
|
signature += ")";
|
|
api.AppendLine(signature);
|
|
api.AppendLine("```");
|
|
api.AppendLine();
|
|
}
|
|
}
|
|
|
|
return api.ToString();
|
|
}
|
|
|
|
private string GenerateMethodDescription(ApiMethod method, string className)
|
|
{
|
|
// Use existing summary if available
|
|
if (!string.IsNullOrEmpty(method.Summary))
|
|
{
|
|
return method.Summary;
|
|
}
|
|
|
|
// Generate intelligent descriptions based on patterns
|
|
if (method.IsPluginMethod && className.Contains("Plugin"))
|
|
{
|
|
return GeneratePluginDescription(className, method.Name);
|
|
}
|
|
|
|
// Generate description based on method name patterns
|
|
return GenerateMethodDescriptionFromName(method.Name, className);
|
|
}
|
|
|
|
private string GeneratePluginDescription(string className, string methodName)
|
|
{
|
|
if (methodName == "ExecuteAsync" && className.Contains("Plugin"))
|
|
{
|
|
return className.Replace("Plugin", "") switch
|
|
{
|
|
"CodeAnalysis" => "Analyzes code structure, complexity metrics, and identifies refactoring opportunities.",
|
|
"EnhancedDocumentationGenerator" => "Generates comprehensive XML documentation with AI-powered intelligent descriptions.",
|
|
"CodeFormatter" => "Formats code according to specified style guidelines and conventions.",
|
|
"NamingConvention" => "Analyzes and suggests improvements for variable, method, and class naming.",
|
|
"BatchRefactor" => "Orchestrates multiple refactoring operations across entire projects or solutions.",
|
|
"ReadmeGenerator" => "Generates comprehensive README documentation by analyzing project structure and code.",
|
|
_ => $"Executes {className.Replace("Plugin", "").ToLower()} operations on the specified code or project."
|
|
};
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
private string GenerateMethodDescriptionFromName(string methodName, string className)
|
|
{
|
|
// Generate descriptions based on common method name patterns
|
|
if (methodName.StartsWith("Generate")) return $"Generates content or artifacts based on the provided parameters.";
|
|
if (methodName.StartsWith("Analyze")) return $"Performs analysis on the specified input and returns detailed results.";
|
|
if (methodName.StartsWith("Process")) return $"Processes the input data and applies transformations or operations.";
|
|
if (methodName.StartsWith("Create")) return $"Creates new instances or artifacts based on the specified configuration.";
|
|
if (methodName.StartsWith("Execute")) return $"Executes the primary operation of the {className} component.";
|
|
if (methodName.StartsWith("Validate")) return $"Validates input parameters and returns validation results.";
|
|
if (methodName.StartsWith("Get")) return $"Retrieves information or data from the {className} component.";
|
|
if (methodName.StartsWith("Set")) return $"Sets or updates configuration values in the {className} component.";
|
|
|
|
return ""; // Don't generate description for unclear methods
|
|
}
|
|
|
|
private string GenerateArchitectureSection(ProjectAnalysisResult analysis)
|
|
{
|
|
var arch = new StringBuilder();
|
|
arch.AppendLine("## Architecture");
|
|
arch.AppendLine();
|
|
|
|
if (analysis.IsSolution)
|
|
{
|
|
arch.AppendLine("### Solution Structure");
|
|
arch.AppendLine();
|
|
foreach (var project in analysis.SubProjects)
|
|
{
|
|
arch.AppendLine($"- **{project.ProjectName}**: {project.DetectedProjectType}");
|
|
}
|
|
arch.AppendLine();
|
|
}
|
|
|
|
arch.AppendLine("### Key Components");
|
|
arch.AppendLine();
|
|
|
|
var componentTypes = analysis.KeyFiles
|
|
.SelectMany(f => f.Classes.Concat(f.Interfaces))
|
|
.GroupBy(GetComponentType)
|
|
.ToList();
|
|
|
|
foreach (var group in componentTypes)
|
|
{
|
|
arch.AppendLine($"- **{group.Key}**: {group.Count()} components");
|
|
}
|
|
|
|
if (analysis.DetectedProjectType == "maui")
|
|
{
|
|
arch.AppendLine();
|
|
arch.AppendLine("### MAUI Architecture");
|
|
arch.AppendLine();
|
|
arch.AppendLine("```");
|
|
arch.AppendLine("┌─────────────────┐");
|
|
arch.AppendLine("│ Shared UI │");
|
|
arch.AppendLine("├─────────────────┤");
|
|
arch.AppendLine("│ Business Logic │");
|
|
arch.AppendLine("├─────────────────┤");
|
|
arch.AppendLine("│ Platform APIs │");
|
|
arch.AppendLine("└─────────────────┘");
|
|
arch.AppendLine("```");
|
|
}
|
|
|
|
return arch.ToString();
|
|
}
|
|
|
|
private string GetComponentType(string className)
|
|
{
|
|
var lower = className.ToLower();
|
|
|
|
if (lower.Contains("service")) return "Services";
|
|
if (lower.Contains("controller")) return "Controllers";
|
|
if (lower.Contains("repository")) return "Repositories";
|
|
if (lower.Contains("manager")) return "Managers";
|
|
if (lower.Contains("factory")) return "Factories";
|
|
if (lower.Contains("builder")) return "Builders";
|
|
if (lower.Contains("plugin")) return "Plugins";
|
|
if (lower.Contains("handler")) return "Handlers";
|
|
if (lower.Contains("provider")) return "Providers";
|
|
if (lower.Contains("helper")) return "Helpers";
|
|
if (lower.Contains("util")) return "Utilities";
|
|
if (lower.StartsWith("i") && char.IsUpper(className[1])) return "Interfaces";
|
|
|
|
return "Core Classes";
|
|
}
|
|
|
|
private string GenerateDependenciesSection(ProjectAnalysisResult analysis)
|
|
{
|
|
if (!analysis.Dependencies.Any()) return "";
|
|
|
|
var deps = new StringBuilder();
|
|
deps.AppendLine("## Dependencies");
|
|
deps.AppendLine();
|
|
|
|
var majorDeps = analysis.Dependencies
|
|
.Where(d => !d.StartsWith("System.") && !d.StartsWith("Microsoft.Extensions."))
|
|
.Take(10)
|
|
.ToList();
|
|
|
|
if (majorDeps.Any())
|
|
{
|
|
deps.AppendLine("### Major Dependencies");
|
|
deps.AppendLine();
|
|
foreach (var dep in majorDeps)
|
|
{
|
|
deps.AppendLine($"- {dep}");
|
|
}
|
|
deps.AppendLine();
|
|
}
|
|
|
|
deps.AppendLine($"### Target Framework");
|
|
|
|
if (analysis.DetectedProjectType == "maui")
|
|
{
|
|
var netVersion = ExtractNetVersion(analysis.TargetFramework);
|
|
var platforms = ExtractMauiPlatforms(analysis.TargetFramework);
|
|
|
|
deps.AppendLine($"- .NET {netVersion}");
|
|
if (platforms.Any())
|
|
{
|
|
deps.AppendLine($"- Platforms: {string.Join(", ", platforms)}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var netVersion = ExtractNetVersion(analysis.TargetFramework);
|
|
deps.AppendLine($"- .NET {netVersion}");
|
|
}
|
|
|
|
deps.AppendLine();
|
|
|
|
return deps.ToString();
|
|
}
|
|
|
|
private string GenerateContributingSection(ProjectAnalysisResult analysis)
|
|
{
|
|
var contrib = new StringBuilder();
|
|
contrib.AppendLine("## Contributing");
|
|
contrib.AppendLine();
|
|
contrib.AppendLine("1. Fork the repository");
|
|
contrib.AppendLine("2. Create a feature branch");
|
|
contrib.AppendLine("3. Make your changes");
|
|
contrib.AppendLine("4. Add tests if applicable");
|
|
contrib.AppendLine("5. Submit a pull request");
|
|
contrib.AppendLine();
|
|
|
|
if (analysis.HasTests)
|
|
{
|
|
contrib.AppendLine("### Running Tests");
|
|
contrib.AppendLine();
|
|
contrib.AppendLine("```bash");
|
|
contrib.AppendLine("dotnet test");
|
|
contrib.AppendLine("```");
|
|
contrib.AppendLine();
|
|
}
|
|
|
|
contrib.AppendLine("## License");
|
|
contrib.AppendLine();
|
|
contrib.AppendLine("This project is licensed under the MIT License - see the LICENSE file for details.");
|
|
contrib.AppendLine();
|
|
|
|
return contrib.ToString();
|
|
}
|
|
|
|
private string FormatProjectType(string projectType)
|
|
{
|
|
return projectType switch
|
|
{
|
|
"library" => ".NET Library",
|
|
"application" => ".NET Application",
|
|
"tool" => "Command-Line Tool",
|
|
"maui" => ".NET MAUI Application",
|
|
_ => ".NET Project"
|
|
};
|
|
}
|
|
|
|
// Helper methods for parameter extraction
|
|
private object GetParameterValue(IReadOnlyDictionary<string, object> parameters, params string[] keys)
|
|
{
|
|
foreach (var key in keys)
|
|
{
|
|
if (parameters.TryGetValue(key, out var value))
|
|
return value;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private bool GetBoolParameter(IReadOnlyDictionary<string, object> parameters, string key1, string key2, bool defaultValue = false)
|
|
{
|
|
var value = GetParameterValue(parameters, key1, key2);
|
|
return value != null ? Convert.ToBoolean(value) : defaultValue;
|
|
}
|
|
|
|
private int GetIntParameter(IReadOnlyDictionary<string, object> parameters, string key1, string key2, int defaultValue = 0)
|
|
{
|
|
var value = GetParameterValue(parameters, key1, key2);
|
|
return value != null ? Convert.ToInt32(value) : defaultValue;
|
|
}
|
|
}
|
|
|
|
// Supporting classes for README generation
|
|
public class ProjectAnalysisResult
|
|
{
|
|
public bool Success { get; set; }
|
|
public string Error { get; set; }
|
|
public string ProjectName { get; set; }
|
|
public string ProjectPath { get; set; }
|
|
public string DetectedProjectType { get; set; }
|
|
public string TargetFramework { get; set; }
|
|
public bool IsSolution { get; set; }
|
|
public bool HasTests { get; set; }
|
|
public bool HasDocumentation { get; set; }
|
|
public int FilesAnalyzed { get; set; }
|
|
public List<string> Dependencies { get; set; } = new List<string>();
|
|
public List<CodeFileAnalysis> KeyFiles { get; set; } = new List<CodeFileAnalysis>();
|
|
public List<ApiMethod> PublicApis { get; set; } = new List<ApiMethod>();
|
|
public List<ProjectAnalysisResult> SubProjects { get; set; } = new List<ProjectAnalysisResult>();
|
|
public List<string> IncludedSections { get; set; } = new List<string>();
|
|
}
|
|
|
|
public class CodeFileAnalysis
|
|
{
|
|
public string FilePath { get; set; }
|
|
public string FileName { get; set; }
|
|
public string Namespace { get; set; }
|
|
public int LineCount { get; set; }
|
|
public List<string> Classes { get; set; } = new List<string>();
|
|
public List<string> Interfaces { get; set; } = new List<string>();
|
|
public bool HasAttributes { get; set; }
|
|
public bool HasAsyncMethods { get; set; }
|
|
}
|
|
|
|
public class ApiMethod
|
|
{
|
|
public string Name { get; set; }
|
|
public string ClassName { get; set; }
|
|
public string ReturnType { get; set; }
|
|
public List<string> Parameters { get; set; } = new List<string>();
|
|
public bool IsAsync { get; set; }
|
|
public string Summary { get; set; }
|
|
public bool IsPluginMethod { get; set; }
|
|
}
|
|
} |