@polymorphism-tech/morph-spec 1.0.0

package/content/.morph/standards/coding.md

@@ -0,0 +1,342 @@
+# Padrões de Código - MORPH Framework
+
+## 📝 Nomenclatura
+
+### Classes e Interfaces
+```csharp
+// Interfaces: sempre com prefixo I
+public interface IReportService { }
+public interface IReportRepository { }
+
+// Classes: PascalCase, sufixo indica tipo
+public class ReportService : IReportService { }
+public class ReportRepository : IReportRepository { }
+public class ReportController : ControllerBase { }
+public class ReportGeneratorJob { }  // Hangfire job
+public class ReportAnalyzerAgent { } // AI Agent
+```
+
+### Métodos
+```csharp
+// Async sempre com sufixo Async
+public async Task<Report> GetByIdAsync(int id) { }
+public async Task CreateAsync(Report report) { }
+
+// Métodos síncronos sem sufixo
+public Report GetById(int id) { }
+public void Validate(Report report) { }
+```
+
+### Variáveis e Parâmetros
+```csharp
+// camelCase para variáveis locais e parâmetros
+public async Task ProcessAsync(string reportId, CancellationToken cancellationToken)
+{
+    var report = await _repository.GetByIdAsync(reportId);
+    var analysisResult = await _analyzer.AnalyzeAsync(report);
+}
+
+// _camelCase para campos privados
+private readonly IReportRepository _repository;
+private readonly ILogger<ReportService> _logger;
+```
+
+---
+
+## 📁 Estrutura de Projeto
+
+```
+src/
+├── MyProject.Web/              # Blazor Server
+│   ├── Components/
+│   │   ├── Pages/              # Páginas (rotas)
+│   │   ├── Shared/             # Componentes compartilhados
+│   │   └── Layout/             # Layouts
+│   └── Program.cs
+│
+├── MyProject.Application/      # Casos de uso
+│   ├── Features/
+│   │   └── Reports/
+│   │       ├── Commands/
+│   │       ├── Queries/
+│   │       └── Services/
+│   └── Common/
+│
+├── MyProject.Domain/           # Entidades e regras
+│   ├── Entities/
+│   ├── ValueObjects/
+│   └── Enums/
+│
+├── MyProject.Infrastructure/   # Implementações
+│   ├── Data/
+│   │   ├── Configurations/
+│   │   ├── Migrations/
+│   │   └── AppDbContext.cs
+│   └── Services/
+│
+└── MyProject.Agents/           # MS Agent Framework
+    └── ReportAnalyzer/
+```
+
+---
+
+## 💉 Dependency Injection
+
+```csharp
+// Usar primary constructor (C# 12+)
+public class ReportService(
+    IReportRepository repository,
+    ILogger<ReportService> logger) : IReportService
+{
+    public async Task<Report> GetByIdAsync(int id)
+    {
+        logger.LogInformation("Getting report {ReportId}", id);
+        return await repository.GetByIdAsync(id);
+    }
+}
+```
+
+---
+
+## 🗄️ Entity Framework Core
+
+### Entidades
+```csharp
+public class ReportSchedule
+{
+    public int Id { get; private set; }
+    public string Name { get; private set; } = string.Empty;
+    public ReportType ReportType { get; private set; }
+    public string CronExpression { get; private set; } = string.Empty;
+    public List<string> Recipients { get; private set; } = [];
+    public bool IsActive { get; private set; }
+    public DateTime CreatedAt { get; private set; }
+
+    // Factory method para criação
+    public static ReportSchedule Create(string name, ReportType reportType,
+        string cronExpression, List<string> recipients)
+    {
+        return new ReportSchedule
+        {
+            Name = name,
+            ReportType = reportType,
+            CronExpression = cronExpression,
+            Recipients = recipients,
+            IsActive = true,
+            CreatedAt = DateTime.UtcNow
+        };
+    }
+
+    // Métodos de domínio
+    public void Activate() => IsActive = true;
+    public void Deactivate() => IsActive = false;
+}
+```
+
+### Configuração Fluent API
+```csharp
+public class ReportScheduleConfiguration : IEntityTypeConfiguration<ReportSchedule>
+{
+    public void Configure(EntityTypeBuilder<ReportSchedule> builder)
+    {
+        builder.ToTable("ReportSchedules");
+        builder.HasKey(x => x.Id);
+
+        builder.Property(x => x.Name)
+            .IsRequired()
+            .HasMaxLength(200);
+
+        // JSON column para lista
+        builder.Property(x => x.Recipients)
+            .HasConversion(
+                v => JsonSerializer.Serialize(v, (JsonSerializerOptions?)null),
+                v => JsonSerializer.Deserialize<List<string>>(v, (JsonSerializerOptions?)null) ?? [])
+            .HasColumnType("nvarchar(max)");
+    }
+}
+```
+
+---
+
+## 🔥 Componentes Blazor
+
+```razor
+@page "/reports/schedules"
+@attribute [Authorize(Policy = "CanManageReports")]
+@inject IReportScheduleService ReportService
+@inject ILogger<ReportScheduleList> Logger
+
+<PageTitle>Report Schedules</PageTitle>
+
+@if (_isLoading)
+{
+    <LoadingSpinner />
+}
+else if (_schedules is null || !_schedules.Any())
+{
+    <EmptyState Message="No schedules configured" />
+}
+else
+{
+    <div class="schedule-list">
+        @foreach (var schedule in _schedules)
+        {
+            <ScheduleCard Schedule="schedule" OnToggle="HandleToggleAsync" />
+        }
+    </div>
+}
+
+@code {
+    private List<ReportScheduleDto>? _schedules;
+    private bool _isLoading = true;
+
+    protected override async Task OnInitializedAsync()
+    {
+        try
+        {
+            _schedules = await ReportService.GetAllAsync();
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError(ex, "Failed to load schedules");
+        }
+        finally
+        {
+            _isLoading = false;
+        }
+    }
+}
+```
+
+### Padrões Obrigatórios
+- ✅ Loading state em toda página
+- ✅ Empty state quando lista vazia
+- ✅ Error handling com try/catch
+- ✅ `@inject` para DI (não construtor)
+- ✅ `@attribute [Authorize]` quando necessário
+
+---
+
+## 🤖 MS Agent Framework
+
+```csharp
+public class ReportAnalyzerAgent(
+    Kernel kernel,
+    ILogger<ReportAnalyzerAgent> logger) : IReportAnalyzerAgent
+{
+    public async Task<AnalysisResult> AnalyzeAsync(
+        ReportData reportData,
+        CancellationToken cancellationToken = default)
+    {
+        var prompt = $"""
+            Analyze the following report data:
+            {reportData.ToJson()}
+
+            Provide: summary, top 3 insights, recommendations.
+            Respond in JSON format.
+            """;
+
+        try
+        {
+            var response = await kernel.InvokePromptAsync(prompt, cancellationToken: cancellationToken);
+            return ParseResponse(response.ToString());
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Analysis failed");
+            throw new ReportAnalysisException("Failed to analyze", ex);
+        }
+    }
+}
+```
+
+---
+
+## ⏰ Hangfire Jobs
+
+```csharp
+public class ReportGeneratorJob(
+    IReportScheduleService scheduleService,
+    IReportAnalyzerAgent analyzer,
+    ILogger<ReportGeneratorJob> logger) : IReportGeneratorJob
+{
+    [AutomaticRetry(Attempts = 3, DelaysInSeconds = new[] { 60, 300, 900 })]
+    [Queue("reports")]
+    public async Task ExecuteAsync(int scheduleId, CancellationToken cancellationToken)
+    {
+        logger.LogInformation("Starting report generation for {ScheduleId}", scheduleId);
+
+        var schedule = await scheduleService.GetByIdAsync(scheduleId);
+        if (schedule is null || !schedule.IsActive)
+        {
+            logger.LogWarning("Schedule {ScheduleId} not found or inactive", scheduleId);
+            return;
+        }
+
+        // ... implementação
+    }
+}
+```
+
+---
+
+## 🧪 Testes
+
+### Nomenclatura
+```csharp
+// Classe: {ClasseTestada}Tests
+public class ReportServiceTests
+{
+    // Método: {Método}_{Cenário}_{ResultadoEsperado}
+    [Fact]
+    public async Task GetByIdAsync_WithValidId_ReturnsReport() { }
+
+    [Fact]
+    public async Task GetByIdAsync_WithInvalidId_ThrowsNotFoundException() { }
+}
+```
+
+### Estrutura AAA
+```csharp
+[Fact]
+public async Task CreateAsync_WithValidData_CreatesSchedule()
+{
+    // Arrange
+    var request = new CreateReportScheduleRequest("Daily Sales", ReportType.Sales);
+
+    // Act
+    var result = await _service.CreateAsync(request);
+
+    // Assert
+    Assert.NotNull(result);
+    Assert.Equal(request.Name, result.Name);
+}
+```
+
+---
+
+## 🚫 Anti-Patterns a Evitar
+
+```csharp
+// ❌ Service Locator
+var service = serviceProvider.GetService<IReportService>();
+
+// ✅ Constructor Injection
+public class MyClass(IReportService reportService) { }
+
+// ❌ Async void
+public async void ProcessReport() { }
+
+// ✅ Async Task
+public async Task ProcessReportAsync() { }
+
+// ❌ Catching generic Exception sem log
+catch (Exception) { }
+
+// ✅ Log and handle
+catch (Exception ex)
+{
+    _logger.LogError(ex, "Operation failed");
+    throw;
+}
+```

package/content/.morph/templates/agent.cs

@@ -0,0 +1,172 @@
+// ============================================================
+// MS AGENT FRAMEWORK TEMPLATE
+// Generated by MORPH Framework
+// ============================================================
+
+using Microsoft.Extensions.Logging;
+using Microsoft.SemanticKernel;
+using System.Text.Json;
+
+namespace MyProject.Agents.{Feature}Analyzer;
+
+/// <summary>
+/// AI Agent for analyzing {Feature} data.
+/// Uses Semantic Kernel with Azure OpenAI (gpt-4o-mini by default).
+/// </summary>
+public class {Feature}AnalyzerAgent(
+    Kernel kernel,
+    ILogger<{Feature}AnalyzerAgent> logger) : I{Feature}AnalyzerAgent
+{
+    private const int MaxRetries = 3;
+    private static readonly TimeSpan[] RetryDelays =
+    {
+        TimeSpan.FromSeconds(1),
+        TimeSpan.FromSeconds(2),
+        TimeSpan.FromSeconds(4)
+    };
+
+    /// <inheritdoc />
+    public async Task<{Feature}AnalysisResult> AnalyzeAsync(
+        {Feature}Data data,
+        CancellationToken cancellationToken = default)
+    {
+        logger.LogInformation("Starting {Feature} analysis for: {Content}",
+            data.Content.Length > 100 ? data.Content[..100] + "..." : data.Content);
+
+        var prompt = BuildPrompt(data);
+
+        for (int attempt = 0; attempt < MaxRetries; attempt++)
+        {
+            try
+            {
+                var response = await kernel.InvokePromptAsync(
+                    prompt,
+                    cancellationToken: cancellationToken);
+
+                var result = ParseResponse(response.ToString());
+
+                logger.LogInformation(
+                    "Analysis completed. Confidence: {Confidence:P0}",
+                    result.ConfidenceScore);
+
+                return result;
+            }
+            catch (Exception ex) when (attempt < MaxRetries - 1)
+            {
+                logger.LogWarning(ex,
+                    "Analysis attempt {Attempt} failed, retrying...",
+                    attempt + 1);
+
+                await Task.Delay(RetryDelays[attempt], cancellationToken);
+            }
+        }
+
+        throw new {Feature}ProcessingException("Analysis failed after all retries");
+    }
+
+    #region Private Methods
+
+    private static string BuildPrompt({Feature}Data data)
+    {
+        return $"""
+            You are an expert analyst for {Feature} data.
+
+            Analyze the following data and provide insights:
+
+            <data>
+            {data.Content}
+            </data>
+
+            Provide your analysis in the following JSON format:
+            {{
+                "summary": "Brief summary of the analysis (1-2 sentences)",
+                "insights": ["insight 1", "insight 2", "insight 3"],
+                "recommendations": ["recommendation 1", "recommendation 2"],
+                "confidenceScore": 0.85
+            }}
+
+            Guidelines:
+            - Be concise and actionable
+            - Confidence score should be between 0 and 1
+            - Provide at least 2 insights
+            - Provide at least 1 recommendation
+            - Focus on practical, business-relevant observations
+
+            Respond ONLY with the JSON object, no additional text.
+            """;
+    }
+
+    private {Feature}AnalysisResult ParseResponse(string response)
+    {
+        try
+        {
+            // Clean up response (remove markdown code blocks if present)
+            var json = response
+                .Replace("```json", "")
+                .Replace("```", "")
+                .Trim();
+
+            var parsed = JsonSerializer.Deserialize<AnalysisResponse>(json,
+                new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
+
+            if (parsed is null)
+            {
+                throw new {Feature}ProcessingException("Failed to parse analysis response");
+            }
+
+            return new {Feature}AnalysisResult(
+                parsed.Summary ?? "Analysis completed",
+                parsed.Insights ?? new List<string>(),
+                parsed.Recommendations ?? new List<string>(),
+                parsed.ConfidenceScore
+            );
+        }
+        catch (JsonException ex)
+        {
+            logger.LogError(ex, "Failed to parse AI response: {Response}", response);
+            throw new {Feature}ProcessingException("Failed to parse analysis response", ex);
+        }
+    }
+
+    private class AnalysisResponse
+    {
+        public string? Summary { get; set; }
+        public List<string>? Insights { get; set; }
+        public List<string>? Recommendations { get; set; }
+        public double ConfidenceScore { get; set; }
+    }
+
+    #endregion
+}
+
+// ============================================================
+// DEPENDENCY INJECTION SETUP
+// ============================================================
+//
+// In Program.cs or a DI extension:
+//
+// public static IServiceCollection AddAgents(
+//     this IServiceCollection services,
+//     IConfiguration configuration)
+// {
+//     // Configure Semantic Kernel with Azure OpenAI
+//     var builder = Kernel.CreateBuilder();
+//
+//     builder.AddAzureOpenAIChatCompletion(
+//         deploymentName: "gpt-4o-mini",
+//         endpoint: configuration["AzureOpenAI:Endpoint"]!,
+//         apiKey: configuration["AzureOpenAI:ApiKey"]!);
+//
+//     // Or with Managed Identity (preferred):
+//     // builder.AddAzureOpenAIChatCompletion(
+//     //     deploymentName: "gpt-4o-mini",
+//     //     endpoint: configuration["AzureOpenAI:Endpoint"]!,
+//     //     credentials: new DefaultAzureCredential());
+//
+//     services.AddSingleton(builder.Build());
+//     services.AddScoped<I{Feature}AnalyzerAgent, {Feature}AnalyzerAgent>();
+//
+//     return services;
+// }
+//
+// ============================================================