@polymorphism-tech/morph-spec 3.1.0 → 4.2.0

package/src/utils/process-handler.js

@@ -0,0 +1,97 @@
+/**
+ * Process Handler - Testable Exit Strategy
+ *
+ * Replaces direct process.exit() calls with a mockable handler.
+ * Makes the codebase testable by allowing exit behavior to be intercepted.
+ *
+ * @module process-handler
+ */
+
+import chalk from 'chalk';
+
+/**
+ * Process Handler Class
+ *
+ * Provides testable process exit functionality.
+ */
+export class ProcessHandler {
+  /**
+   * @param {Function} exitFn - Exit function (defaults to process.exit)
+   */
+  constructor(exitFn = process.exit.bind(process)) {
+    this.exitFn = exitFn;
+  }
+
+  /**
+   * Exit the process with optional message
+   *
+   * @param {number} code - Exit code (0 = success, non-zero = error)
+   * @param {string} [message] - Optional message to display
+   */
+  exit(code = 0, message = null) {
+    if (message) {
+      if (code === 0) {
+        console.log(message);
+      } else {
+        console.error(message);
+      }
+    }
+    this.exitFn(code);
+  }
+
+  /**
+   * Exit with error message (code 1)
+   *
+   * @param {string} message - Error message
+   * @param {number} [code=1] - Error code
+   */
+  exitWithError(message, code = 1) {
+    this.exit(code, chalk.red(message));
+  }
+
+  /**
+   * Exit with success message (code 0)
+   *
+   * @param {string} message - Success message
+   */
+  exitWithSuccess(message) {
+    this.exit(0, chalk.green(message));
+  }
+
+  /**
+   * Exit with warning message (code 0, but highlighted)
+   *
+   * @param {string} message - Warning message
+   */
+  exitWithWarning(message) {
+    this.exit(0, chalk.yellow(message));
+  }
+}
+
+// Default instance for general use
+export const processHandler = new ProcessHandler();
+
+/**
+ * Create a test handler for unit tests
+ *
+ * @returns {{handler: ProcessHandler, getExitCode: Function, getExited: Function}}
+ */
+export function createTestHandler() {
+  let exitCode = null;
+  let exited = false;
+
+  const handler = new ProcessHandler((code) => {
+    exitCode = code;
+    exited = true;
+  });
+
+  return {
+    handler,
+    getExitCode: () => exitCode,
+    getExited: () => exited,
+    reset: () => {
+      exitCode = null;
+      exited = false;
+    },
+  };
+}

package/src/writer/file-writer.js

@@ -0,0 +1,86 @@
+/**
+ * @fileoverview FileWriter - Saves generated configs to filesystem
+ * @module morph-spec/writer/file-writer
+ */
+
+import { writeFile, mkdir, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import chalk from 'chalk';
+
+/**
+ * @typedef {import('../types/index.js').GeneratedConfigs} GeneratedConfigs
+ */
+
+/**
+ * FileWriter - Saves configuration files to .morph/ directory
+ * @class
+ */
+export class FileWriter {
+  /**
+   * Save generated configs to filesystem
+   * @param {string} cwd - Current working directory
+   * @param {GeneratedConfigs} configs - Configs to save
+   * @returns {Promise<void>}
+   */
+  async save(cwd, configs) {
+    const morphDir = join(cwd, '.morph');
+    const configDir = join(morphDir, 'config');
+
+    // Ensure directories exist
+    await this.ensureDirectoryExists(morphDir);
+    await this.ensureDirectoryExists(configDir);
+
+    // Write files
+    const projectMdPath = join(morphDir, 'project.md');
+    const configJsonPath = join(configDir, 'config.json');
+
+    await Promise.all([
+      this.writeProjectMd(projectMdPath, configs.projectMd),
+      this.writeConfigJson(configJsonPath, configs.configJson)
+    ]);
+
+    // Display success message
+    console.log(chalk.bold.green('\n✅ Configuration files saved:\n'));
+    console.log(chalk.cyan(`  📄 ${projectMdPath}`));
+    console.log(chalk.cyan(`  ⚙️  ${configJsonPath}`));
+    console.log();
+  }
+
+  /**
+   * Write project.md file
+   * @param {string} filepath - File path
+   * @param {string} content - File content
+   * @returns {Promise<void>}
+   */
+  async writeProjectMd(filepath, content) {
+    await writeFile(filepath, content, 'utf-8');
+  }
+
+  /**
+   * Write config.json file (with pretty formatting)
+   * @param {string} filepath - File path
+   * @param {string} content - File content (JSON string)
+   * @returns {Promise<void>}
+   */
+  async writeConfigJson(filepath, content) {
+    // Parse and re-stringify with pretty formatting
+    const parsed = JSON.parse(content);
+    const formatted = JSON.stringify(parsed, null, 2);
+
+    await writeFile(filepath, formatted, 'utf-8');
+  }
+
+  /**
+   * Ensure directory exists (create if not)
+   * @param {string} dirPath - Directory path
+   * @returns {Promise<void>}
+   */
+  async ensureDirectoryExists(dirPath) {
+    try {
+      await access(dirPath);
+    } catch (error) {
+      // Directory doesn't exist, create it
+      await mkdir(dirPath, { recursive: true });
+    }
+  }
+}

package/stacks/blazor-azure/.claude/skills/level-2-domains/ai-agents/ai-system-architect.md

@@ -4,9 +4,9 @@ Expert in agentic system architecture, multi-agent orchestration, and RAG pipeli
 
 > **Layer:** 2 | **Load:** on-keyword | **Keywords:** orchestration, multi-agent, rag, vector search, embedding, agentic, memory, reasoning
 
-> **Ref:** `agent-framework-workflows.md` — Workflow patterns with AgentWorkflowBuilder
-> **Ref:** `agent-framework-production.md` — Middleware, A2A, MCP, caching
-> **Ref:** `vector-search-rag.md` — Vector Search + RAG with EF Core 10
+> **Ref:** `framework/standards/ai-agents/workflows.md` — Workflow patterns with AgentWorkflowBuilder
+> **Ref:** `framework/standards/ai-agents/production.md` — Middleware, A2A, MCP, caching
+> **Ref:** `framework/standards/backend/database/vector-search-rag.md` — Vector Search + RAG with EF Core 10
 
 ## Responsibilities
 

package/stacks/blazor-azure/.claude/skills/level-2-domains/backend/api-designer.md

@@ -0,0 +1,59 @@
+# API Designer
+
+**Tier:** 3 (Specialist)
+**Always Active:** No
+**Keywords:** api, endpoint, controller, rest, http, route, dto, request, response
+**Reports to:** dotnet-senior
+
+---
+
+## Role
+
+REST API design specialist for .NET Minimal API and controllers, focusing on clean endpoint design and DTO contracts.
+
+---
+
+## Standards Applied
+
+```
+framework/standards/core/coding.md
+framework/standards/backend/dotnet/core.md
+framework/standards/backend/dotnet/async.md
+framework/standards/backend/api/rest.md
+framework/standards/backend/api/validation.md
+```
+
+---
+
+## Responsibilities
+
+- Design REST API endpoints following conventions
+- Create request/response DTOs
+- Implement API controllers or Minimal API endpoints
+- Apply proper HTTP status codes (200, 201, 400, 404, etc.)
+- Implement input validation with FluentValidation
+- Design API versioning strategy
+- Create error response formats
+
+---
+
+## When to Use
+
+- Creating new API endpoints
+- Designing DTO contracts
+- API refactoring
+- Implementing validation logic
+- Designing error responses
+
+---
+
+## Collaborates With
+
+- **dotnet-senior** - Service layer consumed by endpoints
+- **ef-modeler** - Entity → DTO mapping
+- **blazor-builder** - Frontend consuming API
+- **testing-specialist** - API integration tests
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*

package/stacks/blazor-azure/.claude/skills/level-2-domains/backend/dotnet-senior.md

@@ -1,286 +1,76 @@
 # .NET Senior Engineer
 
-> **Layer:** 1 | **Load:** always | **Scope:** All .NET projects (Core Agent)
-
-Senior .NET engineer specialist. Writes production-quality C# following all framework standards. Includes **Ultrathink Mode** for complex architectural decisions.
-
-> **Ref:** `framework/standards/coding.md` — ALL code output MUST follow these conventions.
-> **Ref:** `framework/standards/architecture.md` — ALL code MUST respect layer boundaries.
-> **Ref:** `.claude/skills/checklists/code-review.md` — Self-check before delivering code.
+**Tier:** 2 (Domain Leader)
+**Always Active:** Yes
+**Reports to:** standards-architect
+**Coordinates:** ef-modeler, api-designer, event-architect, hangfire-orchestrator, ms-agent-expert, ddd-expert, nosql-cache-expert
 
 ---
 
-## Two Modes
-
-### Standard Mode (default)
-
-Active for all C# code writing. Every file produced follows the coding standards and architecture patterns.
-
-**Trigger:** Any implementation task (always active as Core Agent).
-
-### Ultrathink Mode
-
-Extended deep-reasoning mode for complex decisions. Think step by step through trade-offs before recommending.
+## Role
 
-**Trigger keywords:** `ultrathink`, `deep-think`, `think deeply`, `analyze deeply`, `complex decision`
-
-**Use for:**
-- Technology/library selection (MudBlazor vs Fluent UI, Hangfire vs Azure Functions)
-- Architecture pattern decisions (CQRS vs simple, Repository vs direct DbContext)
-- Performance optimization strategy
-- Migration planning (.NET version upgrades, library migrations)
-- Multi-system integration design
-- Database schema design for complex domains
+Senior .NET engineer and Backend Squad Leader. Writes production-quality C# code and coordinates backend domain specialists for all .NET implementation tasks.
 
 ---
 
-## Code Writing Rules
-
-**MANDATORY for ALL C# code output.** No exceptions.
-
-### Naming (ref: coding.md)
-
-| Element | Convention | Example |
-|---------|-----------|---------|
-| Classes | PascalCase + `sealed` | `public sealed class OrderService` |
-| Interfaces | `I` + PascalCase | `public interface IOrderService` |
-| Methods | PascalCase + `Async` | `public async Task<Result<Order>> GetByIdAsync(...)` |
-| Constants | PascalCase | `private const int MaxRetryCount = 3;` |
-| Private fields | `_camelCase` | `private readonly ILogger<OrderService> _logger;` |
-| Parameters | camelCase | `(int orderId, CancellationToken ct = default)` |
+## Standards Applied
 
-### Structure
-
-```csharp
-// 1. File-scoped namespace
-namespace MyApp.Application.Services;
-
-// 2. Primary constructor for DI (preferred) or traditional constructor
-public sealed class OrderService(
-    IOrderRepository repository,
-    IPaymentGateway paymentGateway,
-    ILogger<OrderService> logger) : IOrderService
-{
-    // 3. Constants first (PascalCase)
-    private const int MaxRetryCount = 3;
-    private const string DefaultCurrency = "BRL";
-
-    // 4. Public methods (business operations)
-    public async Task<Result<OrderResponse>> CreateAsync(
-        CreateOrderRequest request,
-        CancellationToken ct = default)
-    {
-        // 5. Entry logging with correlation
-        logger.LogInformation("Creating order for customer {CustomerId}", request.CustomerId);
-
-        // 6. Validation (early return with Result)
-        if (request.Items.Count == 0)
-            return Result.Failure<OrderResponse>("Order must have at least one item");
-
-        // 7. Domain logic
-        var order = Order.Create(request.CustomerId, request.Items);
-
-        // 8. Persistence
-        await repository.AddAsync(order, ct);
-        await repository.SaveChangesAsync(ct);
-
-        // 9. Exit logging
-        logger.LogInformation("Order {OrderId} created successfully", order.Id);
-
-        // 10. Return mapped response
-        return Result.Success(order.ToResponse());
-    }
-}
 ```
-
-### Mandatory Patterns
-
-| Pattern | Rule | Example |
-|---------|------|---------|
-| **CancellationToken** | Last parameter on ALL async methods | `CancellationToken ct = default` |
-| **Result pattern** | Business errors return Result, NOT exceptions | `Result.Failure<T>("message")` |
-| **Structured logging** | Entry + exit + error on every service method | `logger.LogInformation("...", correlationId)` |
-| **sealed** | All classes sealed unless designed for inheritance | `public sealed class OrderService` |
-| **Nullable types** | Always enabled, `?` only when truly optional | `string? middleName` (optional) vs `string name` (required) |
-| **Primary constructors** | For DI injection (C# 12+) | `class OrderService(IRepo repo)` |
-| **Expression body** | Single-line members | `public int Count => _items.Count;` |
-| **Pattern matching** | `is null` / `is not null` | `if (order is null) return ...` |
-| **Collection expressions** | Prefer `[..]` syntax | `List<int> ids = [1, 2, 3];` |
-
-### Entity Pattern
-
-```csharp
-namespace MyApp.Domain.Entities;
-
-public sealed class Order
-{
-    // Private constructor — force factory method
-    private Order() { }
-
-    public Guid Id { get; private set; }
-    public int CustomerId { get; private set; }
-    public OrderStatus Status { get; private set; }
-    public decimal Total { get; private set; }
-    public DateTime CreatedAt { get; private set; }
-
-    // Factory method with validation
-    public static Order Create(int customerId, List<OrderItem> items)
-    {
-        if (items.Count == 0)
-            throw new DomainException("Order must have at least one item");
-
-        return new Order
-        {
-            Id = Guid.NewGuid(),
-            CustomerId = customerId,
-            Status = OrderStatus.Created,
-            Total = items.Sum(i => i.Price * i.Quantity),
-            CreatedAt = DateTime.UtcNow
-        };
-    }
-
-    // Behavior methods (not anemic)
-    public void MarkAsPaid()
-    {
-        if (Status >= OrderStatus.Completed || Status == OrderStatus.Failed)
-            throw new DomainException($"Cannot mark order {Id} as paid in status {Status}");
-        Status = OrderStatus.PendingPayment;
-    }
-}
-```
-
-### DTO Pattern
-
-```csharp
-namespace MyApp.Application.DTOs;
-
-// Request: record with required properties
-public sealed record CreateOrderRequest(
-    int CustomerId,
-    List<OrderItemRequest> Items);
-
-// Response: record with computed properties
-public sealed record OrderResponse(
-    Guid Id,
-    int CustomerId,
-    string StatusDisplay,
-    decimal Total,
-    DateTime CreatedAt);
-
-// Enum: PascalCase members, error states at 100+
-public enum OrderStatus
-{
-    Created = 0,
-    PendingPayment = 1,
-    Processing = 2,
-    Shipped = 3,
-    Completed = 4,
-    // Error states (high values for comparison operators)
-    Failed = 100,
-    Cancelled = 101,
-    Refunded = 102
-}
+framework/standards/core/coding.md
+framework/standards/core/architecture.md
+framework/standards/core/testing.md
+framework/standards/backend/dotnet/core.md
+framework/standards/backend/dotnet/async.md
+framework/standards/backend/dotnet/di.md
+framework/standards/backend/database/ef-core.md
+framework/standards/backend/api/rest.md
 ```
 
 ---
 
-## Post-Implementation Pipeline
+## Responsibilities
 
-After writing code, self-check before delivering:
-
-```
-1. NAMING CHECK     → Does every identifier follow coding.md?
-2. ARCHITECTURE     → Are files in the correct layer? No forbidden references?
-3. ASYNC            → CancellationToken on all async? No .Result/.Wait()?
-4. LOGGING          → Entry/exit/error logging? Message templates (not $"")?
-5. ERROR HANDLING   → Result pattern for business? No empty catch?
-6. SEALED           → All classes sealed?
-7. NULLABLE         → <Nullable>enable</Nullable>? ? only where optional?
-```
-
-Then trigger **Code Analyzer** for deeper review (automatic at checkpoints and FASE 5).
+- Lead backend implementation (services, controllers, business logic)
+- Coordinate backend squad (ef-modeler, api-designer, etc.)
+- Ensure code follows all .NET standards
+- Design service layer architecture
+- Implement async patterns with CancellationToken
+- Apply dependency injection correctly
+- Write unit and integration tests
 
 ---
 
-## Ultrathink Decision Template
-
-When in Ultrathink Mode, produce structured analysis:
+## When to Use
 
-```markdown
-## Decision: {Title}
-
-### Context
-{Why this decision is needed now. What triggered it. Current state.}
-
-### Constraints
-- {Constraint 1: budget, timeline, team skill, existing tech}
-- {Constraint 2}
-
-### Options Analysis
-
-| Criterion | Option A: {Name} | Option B: {Name} | Option C: {Name} |
-|-----------|------------------|------------------|------------------|
-| **Performance** | {assessment} | {assessment} | {assessment} |
-| **Complexity** | {Low/Medium/High} | {Low/Medium/High} | {Low/Medium/High} |
-| **Maintainability** | {assessment} | {assessment} | {assessment} |
-| **Cost** | {assessment} | {assessment} | {assessment} |
-| **Risk** | {assessment} | {assessment} | {assessment} |
-| **Team familiarity** | {assessment} | {assessment} | {assessment} |
-
-### Option A: {Name}
-**Pros:** {list}
-**Cons:** {list}
-**Best when:** {scenario}
-
-### Option B: {Name}
-**Pros:** {list}
-**Cons:** {list}
-**Best when:** {scenario}
-
-### Recommendation
-**{Option X}** because {justification tied to constraints and criteria}.
-
-### Implementation Impact
-- **Files affected:** {count and key files}
-- **Migrations:** {yes/no, what changes}
-- **Breaking changes:** {yes/no, what breaks}
-- **Estimated effort:** {T-shirt size with rationale}
-- **Rollback plan:** {how to revert if needed}
-```
+- Any .NET/C# code implementation
+- Backend service layer development
+- API controller implementation
+- Business logic implementation
+- Complex architectural decisions (Ultrathink mode)
 
 ---
 
-## .NET 10 / C# 14 Quick Patterns
+## Ultrathink Mode
+
+**Trigger:** Keywords like "ultrathink", "deep-think", "analyze deeply", "complex decision"
 
-| Pattern | When | Example |
-|---------|------|---------|
-| Primary constructors | DI injection | `class Service(IRepo repo)` |
-| Collection expressions | Initialize collections | `List<int> ids = [1, 2, 3]` |
-| File-scoped namespaces | Always | `namespace MyApp.Services;` |
-| Raw string literals | Multi-line strings, SQL | `"""SELECT * FROM ..."""` |
-| Records | Immutable DTOs | `record OrderResponse(Guid Id, ...)` |
-| Pattern matching | Type checks, null checks | `if (x is Order { Status: > 0 } order)` |
-| `required` modifier | Non-nullable init props | `public required string Name { get; init; }` |
-| `sealed` classes | Default for all classes | `public sealed class OrderService` |
-| Extension methods | Add behavior to existing types | `public static class OrderExtensions` |
-| Global usings | Reduce repetitive imports | `global using MyApp.Domain.Entities;` |
+**Use for:**
+- Technology/library selection
+- Architecture pattern decisions (CQRS vs simple)
+- Performance optimization strategy
+- Migration planning
+- Multi-system integration design
 
 ---
 
-## Anti-Patterns to NEVER Produce
+## Collaborates With
 
-| Anti-Pattern | Why | Instead |
-|--------------|-----|---------|
-| `async void` | Exceptions lost, can't await | `async Task` (always) |
-| `.Result` / `.Wait()` | Deadlock in Blazor Server | `await` |
-| `new DbContext()` in service | Wrong lifetime, no DI | Constructor injection |
-| `catch (Exception) { }` | Swallowed exception | Log + rethrow or Result |
-| Public fields | Encapsulation broken | Properties with `{ get; private set; }` |
-| `string.Format` in logs | Defeats structured logging | Message templates |
-| `== null` | Not idiomatic C# | `is null` |
-| Unsealed classes | Unintended inheritance | `sealed` keyword |
-| Service Locator | Hidden dependencies | Constructor injection |
-| God class (500+ lines) | Unmaintainable | Split by responsibility |
+- **ef-modeler** - Database/EF Core layer
+- **api-designer** - REST API contracts and endpoints
+- **azure-architect** - Infrastructure provisioning
+- **blazor-builder** - Backend API consumed by frontend
+- **hangfire-orchestrator** - Background job coordination
+- **testing-specialist** - Test coverage and quality
 
 ---