plankit-cli 1.3.0 → 1.4.0

package/src/commandBundles.js

@@ -4,6 +4,24 @@ import fs from 'node:fs';
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
+export const SUPPORTED_FRAMEWORKS = ['angular', 'vue', 'dotnet'];
+
+export const FRAMEWORK_ALIASES = {
+  ng: 'angular',
+  angular: 'angular',
+  vue: 'vue',
+  vuejs: 'vue',
+  dotnet: 'dotnet',
+  net: 'dotnet',
+  '.net': 'dotnet'
+};
+
+export const FRAMEWORK_DESCRIPTIONS = {
+  angular: 'Angular command suite',
+  vue: 'Vue modernization & architecture suite',
+  dotnet: '.NET clean architecture & API suite'
+};
+
 export const COMMAND_BUNDLES = {
   'opencode-angular': {
     label: 'Angular command suite',
@@ -28,13 +46,100 @@ export const COMMAND_BUNDLES = {
     src: path.join('angular-commands', 'cursor'),
     dest: ['.cursor', 'rules'],
     kind: 'folder'
+  },
+  'opencode-vue': {
+    label: 'Vue command suite',
+    src: path.join('vue-commands', 'opencode'),
+    dest: ['.opencode', 'commands'],
+    kind: 'folder'
+  },
+  'gemini-vue': {
+    label: 'Vue skill suite',
+    src: path.join('vue-skills', 'gemini'),
+    dest: ['.gemini', 'skills'],
+    kind: 'folder'
+  },
+  'codex-vue': {
+    label: 'Vue command suite',
+    src: path.join('vue-commands', 'codex'),
+    dest: ['.codex'],
+    kind: 'folder'
+  },
+  'cursor-vue': {
+    label: 'Vue command suite',
+    src: path.join('vue-commands', 'cursor'),
+    dest: ['.cursor', 'rules'],
+    kind: 'folder'
+  },
+  'opencode-dotnet': {
+    label: '.NET command suite',
+    src: path.join('dotnet-commands', 'opencode'),
+    dest: ['.opencode', 'commands'],
+    kind: 'folder'
+  },
+  'gemini-dotnet': {
+    label: '.NET skill suite',
+    src: path.join('dotnet-skills', 'gemini'),
+    dest: ['.gemini', 'skills'],
+    kind: 'folder'
+  },
+  'codex-dotnet': {
+    label: '.NET command suite',
+    src: path.join('dotnet-commands', 'codex'),
+    dest: ['.codex'],
+    kind: 'folder'
+  },
+  'cursor-dotnet': {
+    label: '.NET command suite',
+    src: path.join('dotnet-commands', 'cursor'),
+    dest: ['.cursor', 'rules'],
+    kind: 'folder'
   }
 };
 
+export function normalizeFramework(input) {
+  if (!input) return null;
+  const cleaned = String(input).trim().toLowerCase();
+  if (cleaned === 'none') return null;
+  if (cleaned === 'all') return [...SUPPORTED_FRAMEWORKS];
+  return FRAMEWORK_ALIASES[cleaned] || null;
+}
+
+export function parseFrameworksInput(input) {
+  if (!input) return [];
+  if (Array.isArray(input)) {
+    return input.flatMap((item) => parseFrameworksInput(item));
+  }
+  const parts = String(input)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+  const frameworks = new Set();
+  for (const part of parts) {
+    const normalized = normalizeFramework(part);
+    if (Array.isArray(normalized)) {
+      normalized.forEach((fw) => frameworks.add(fw));
+    } else if (normalized) {
+      frameworks.add(normalized);
+    } else if (part.toLowerCase() === 'none') {
+      // explicit none
+      continue;
+    } else {
+      throw new Error(`Unknown framework "${part}". Valid frameworks: ${SUPPORTED_FRAMEWORKS.join(', ')}, none, all.`);
+    }
+  }
+  return Array.from(frameworks);
+}
+
 export function bundleEntry(bundleName) {
   return COMMAND_BUNDLES[bundleName] || null;
 }
 
+export function bundleNameFor(agentId, framework) {
+  return `${agentId}-${framework}`;
+}
+
 export function bundleSourceExists(bundleName, cwd, config) {
   const entry = COMMAND_BUNDLES[bundleName];
   if (!entry) {

package/src/config.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { AGENT_ORDER, DEFAULT_AGENT, getAgent } from './agents.js';
+import { parseFrameworksInput } from './commandBundles.js';
 
 export const DEFAULT_CONFIG = {
   artifactsDir: 'artifacts',
@@ -8,6 +9,7 @@ export const DEFAULT_CONFIG = {
   agents: {
     default: DEFAULT_AGENT
   },
+  frameworks: [],
   defaultPhases: [
     {
       title: 'Foundation & Setup',
@@ -57,9 +59,13 @@ export function loadConfig(cwd = process.cwd()) {
   };
 }
 
-export function createDefaultConfigFile(cwd, options = {}) {
+export function createDefaultConfigFile(cwd, options = {}, frameworks = []) {
   const filePath = path.join(cwd, 'plankit.config.json');
-  const content = `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`;
+  const baseConfig = structuredClone(DEFAULT_CONFIG);
+  if (Array.isArray(frameworks) && frameworks.length > 0) {
+    baseConfig.frameworks = frameworks;
+  }
+  const content = `${JSON.stringify(baseConfig, null, 2)}\n`;
   return writeManagedFile(filePath, content, options);
 }
 
@@ -69,10 +75,22 @@ export function normalizeConfig(config) {
   normalized.artifactsDir = normalized.artifactsDir || DEFAULT_CONFIG.artifactsDir;
   normalized.overwrite = normalized.overwrite || DEFAULT_CONFIG.overwrite;
   normalized.agents = normalizeAgents(normalized.agents);
+  normalized.frameworks = normalizeFrameworksConfig(normalized.frameworks);
   normalized.verification = { ...DEFAULT_CONFIG.verification, ...(normalized.verification || {}) };
   return normalized;
 }
 
+export function normalizeFrameworksConfig(frameworks) {
+  if (!frameworks) return [];
+  if (Array.isArray(frameworks)) {
+    return parseFrameworksInput(frameworks);
+  }
+  if (typeof frameworks === 'string') {
+    return parseFrameworksInput(frameworks);
+  }
+  return [];
+}
+
 export function normalizeAgents(agents) {
   if (!agents || typeof agents !== 'object') {
     return { ...DEFAULT_CONFIG.agents };

package/templates/PLANKIT.md

@@ -35,6 +35,13 @@ Prepares the phase output artifact after validating that the phase spec and prio
 
 Runs configured verification commands and archives the completed feature.
 
+## Framework Suites
+
+PlanKit supports modular framework engineering command suites selectable during `plankit init` via prompt or `--framework <angular|vue|dotnet|none|all>`:
+- **Angular**: Deterministic Angular workflows (`component-from`, `feature`, `signalize`, `modernize`, etc.)
+- **Vue**: Legacy modernization and standardization workflows (`vue-health`, `vue-pattern-map`, `vue-standardize`, `vue-modernize-slice`, etc.)
+- **.NET**: Clean Architecture & Minimal API workflows (`dotnet-health`, `dotnet-architecture-audit`, `dotnet-feature`, `dotnet-modernize`, etc.)
+
 ## Customization
 
 Configure PlanKit with `plankit.config.json`. Override generated templates by setting `templatesDir` and matching the package template file names.

package/templates/dotnet-commands/codex/dotnet-architecture-audit.md

@@ -0,0 +1,25 @@
+# dotnet-architecture-audit
+> Audit layer dependencies (Clean Architecture / Vertical Slices / DDD) and circular dependencies.
+
+# /dotnet-architecture-audit
+
+Analyze architectural layer boundaries and project references across the .NET solution.
+
+## Workflow
+1. Parse project references between .csproj files.
+2. Verify Domain layer has zero external project dependencies.
+3. Verify Application layer depends only on Domain.
+4. Detect illegal Infrastructure/API leaks into core layers or circular dependencies.
+5. Generate dependency graph and compliance matrix.
+
+## Guardrail
+Read-only architectural analysis.
+
+## Options
+- --strict            fail on any layer boundary violation
+- --json              output dependency graph as JSON
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-clean-guardrails.md

@@ -0,0 +1,24 @@
+# dotnet-clean-guardrails
+> Generate NetArchTest architectural unit tests and EditorConfig rules to guard layer boundaries.
+
+# /dotnet-clean-guardrails
+
+Enforce clean architecture layer boundaries with automated architectural unit tests and EditorConfig.
+
+## Workflow
+1. Detect solution architecture layers (Domain, Application, Infrastructure, API).
+2. Generate NetArchTest tests asserting layer boundaries (e.g. Domain should not reference Infrastructure).
+3. Generate or update .editorconfig with C# formatting, naming rules, and diagnostic severities.
+4. Run architectural tests to verify current compliance.
+
+## Guardrail
+Do not break legacy builds; apply warnings first or scope enforcement gradually.
+
+## Options
+- --netarchtest       generate NetArchTest test project
+- --editorconfig      generate .editorconfig rules
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-ef-migration.md

@@ -0,0 +1,25 @@
+# dotnet-ef-migration
+> Safe Entity Framework Core migration workflow with entity audit, SQL review, and rollback.
+
+# /dotnet-ef-migration
+
+Plan, generate, and review safe Entity Framework Core database migrations.
+
+## Workflow
+1. Audit entity configurations (Fluent API vs DataAnnotations) in target DbContext.
+2. Check for missing indexes, foreign key cascading issues, and property lengths.
+3. Generate migration with a descriptive name (dotnet ef migrations add <Name>).
+4. Generate and inspect raw migration SQL script (dotnet ef migrations script).
+5. Check for destructive schema changes (table drops, column drops, data loss warnings).
+
+## Guardrail
+Never execute irreversible or destructive migrations without explicit user confirmation.
+
+## Options
+- --name <Name>       descriptive migration name
+- --preview-sql       inspect generated SQL before applying
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-endpoint-from-model.md

@@ -0,0 +1,26 @@
+# dotnet-endpoint-from-model
+> Generate ASP.NET Core Minimal API or Controller endpoints from an entity/model with validation.
+
+# /dotnet-endpoint-from-model
+
+Generate robust CRUD endpoints from a domain model or entity.
+
+## Workflow
+1. Inspect entity/model properties, keys, and navigation properties.
+2. Generate Request/Response DTOs to avoid overposting or leaking domain entities.
+3. Generate endpoint handlers using TypedResults (Ok, Created, NotFound, ValidationProblem).
+4. Configure authorization, route groups, and OpenAPI metadata (.WithName(), .Produces()).
+5. Verify endpoint route constraints.
+
+## Guardrail
+Never expose raw database entities directly to API responses. Always map through DTOs.
+
+## Options
+- --minimal           use ASP.NET Core Minimal APIs (default)
+- --controller        use Controller-based architecture
+- --dto <Type>        use existing DTO type
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-extract-service.md

@@ -0,0 +1,25 @@
+# dotnet-extract-service
+> Refactor fat services or bloated controllers into isolated CQRS handlers or domain services.
+
+# /dotnet-extract-service
+
+Decompose fat classes into single-responsibility handlers or domain services.
+
+## Workflow
+1. Identify oversized methods or multi-responsibility service classes.
+2. Extract target method into an independent Command/Query handler or domain service.
+3. Define required interfaces and register with Microsoft.Extensions.DependencyInjection.
+4. Update caller references and ensure backward compatibility.
+5. Create unit tests for extracted handler.
+
+## Guardrail
+Preserve existing behavior and contract signatures. Do not introduce breaking API changes.
+
+## Options
+- --class <Name>      source class to refactor
+- --method <Name>     specific method to extract
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-feature.md

@@ -0,0 +1,26 @@
+# dotnet-feature
+> Build an end-to-end vertical slice feature (Command/Query, MediatR, FluentValidation, Endpoint).
+
+# /dotnet-feature
+
+Generate a complete, self-contained feature slice following Vertical Slice Architecture.
+
+## Workflow
+1. Determine feature name, operation type (Command or Query), and target domain.
+2. Generate Request and Response DTO records with immutable properties.
+3. Generate FluentValidation validator with standard validation rules.
+4. Generate MediatR / Wolverine handler with DbContext or repository access.
+5. Expose via Minimal API endpoint or Controller with TypedResults.
+6. Scaffold unit tests and integration tests.
+
+## Guardrail
+Adhere to existing solution conventions (Vertical Slices vs Clean Architecture). Do not introduce unnecessary abstractions.
+
+## Options
+- --type <command|query> operation type
+- --model <Entity>       domain entity to base feature on
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-generate-tests.md

@@ -0,0 +1,25 @@
+# dotnet-generate-tests
+> Generate xUnit/NUnit tests with FluentAssertions and WebApplicationFactory integration tests.
+
+# /dotnet-generate-tests
+
+Generate comprehensive unit and integration tests for .NET handlers, services, and endpoints.
+
+## Workflow
+1. Inspect target class (Handler, Validator, Service, or Endpoint).
+2. Generate unit tests covering valid input, boundary conditions, and error cases.
+3. Use Moq or NSubstitute for dependencies and FluentAssertions for assertions.
+4. For endpoints, generate WebApplicationFactory integration tests verifying status codes and payloads.
+5. Run tests with dotnet test.
+
+## Guardrail
+Mock only external boundaries (I/O, database, third-party APIs); test real business domain logic.
+
+## Options
+- --framework <xunit|nunit> test framework (default: xunit)
+- --integration             generate WebApplicationFactory integration tests
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-health.md

@@ -0,0 +1,24 @@
+# dotnet-health
+> Audit .NET solution health: SDK versions, NuGet packages, vulnerabilities, and compiler warnings.
+
+# /dotnet-health
+
+Comprehensive health check for .NET solutions and projects.
+
+## Workflow
+1. Locate .sln and .csproj files, target frameworks (e.g. net8.0, net9.0), and SDK versions.
+2. Check for vulnerable and outdated NuGet packages (dotnet list package --vulnerable).
+3. Audit nullable reference types (<Nullable>enable</Nullable>) and compiler warning configurations.
+4. Output structured markdown diagnostic report with prioritized security and health recommendations.
+
+## Guardrail
+Read-only diagnostic audit. Never modify project files during health check.
+
+## Options
+- --json              output machine-readable JSON metrics
+- --project <path>    restrict audit to a specific project
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-migrate-minimal-api.md

@@ -0,0 +1,25 @@
+# dotnet-migrate-minimal-api
+> Migrate ASP.NET Core controllers to modern Minimal APIs with RouteGroups and typed results.
+
+# /dotnet-migrate-minimal-api
+
+Refactor traditional controllers to modern, high-performance Minimal API route groups.
+
+## Workflow
+1. Inspect controller routes, actions, authorization attributes, and filter pipeline.
+2. Create endpoint extension class (MapXxxEndpoints()) using MapGroup().
+3. Convert ActionResult<T> to TypedResults with explicit return types.
+4. Replace controller DI with endpoint parameter injection ([FromServices], [FromBody]).
+5. Verify route parity and run integration tests.
+
+## Guardrail
+Preserve exact route paths, query parameter names, and HTTP status code behaviors.
+
+## Options
+- --controller <Name> name of the controller to migrate
+- --dry-run           preview changes without modifying files
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/codex/dotnet-modernize.md

@@ -0,0 +1,25 @@
+# dotnet-modernize
+> Upgrade legacy C# code to modern C# 12+ / .NET 8+ patterns (primary constructors, pattern matching).
+
+# /dotnet-modernize
+
+Modernize legacy C# syntax using modern C# language features.
+
+## Workflow
+1. Convert block-scoped namespaces to file-scoped namespaces (namespace X;).
+2. Convert classes/records with boilerplate constructors to primary constructors where appropriate.
+3. Adopt collection expressions ([] instead of new List<T>(), Array.Empty<T>()).
+4. Use pattern matching (is not null, switch expressions, property patterns).
+5. Build solution and run test suite to verify zero semantic changes.
+
+## Guardrail
+Only apply safe, semantic-preserving modernizations. Never compromise readability for conciseness.
+
+## Options
+- --project <path>    target specific project
+- --dry-run           preview modernization diffs
+
+## Execution
+1. Run .NET solution discovery against the repository.
+2. Apply the workflow above with the provided target.
+3. Report files created/modified and patterns applied.

package/templates/dotnet-commands/cursor/dotnet-architecture-audit.md

@@ -0,0 +1,26 @@
+---
+description: Audit layer dependencies (Clean Architecture / Vertical Slices / DDD) and circular dependencies.
+globs: **/*.cs, **/*.csproj, **/*.sln
+---
+
+# dotnet-architecture-audit
+
+# /dotnet-architecture-audit
+
+Analyze architectural layer boundaries and project references across the .NET solution.
+
+## Workflow
+1. Parse project references between .csproj files.
+2. Verify Domain layer has zero external project dependencies.
+3. Verify Application layer depends only on Domain.
+4. Detect illegal Infrastructure/API leaks into core layers or circular dependencies.
+5. Generate dependency graph and compliance matrix.
+
+## Guardrail
+Read-only architectural analysis.
+
+## Options
+- --strict            fail on any layer boundary violation
+- --json              output dependency graph as JSON
+
+Follow this workflow whenever asked to build, modernize, or test .NET code in this repository.

package/templates/dotnet-commands/cursor/dotnet-clean-guardrails.md

@@ -0,0 +1,25 @@
+---
+description: Generate NetArchTest architectural unit tests and EditorConfig rules to guard layer boundaries.
+globs: **/*.cs, **/*.csproj, **/*.sln
+---
+
+# dotnet-clean-guardrails
+
+# /dotnet-clean-guardrails
+
+Enforce clean architecture layer boundaries with automated architectural unit tests and EditorConfig.
+
+## Workflow
+1. Detect solution architecture layers (Domain, Application, Infrastructure, API).
+2. Generate NetArchTest tests asserting layer boundaries (e.g. Domain should not reference Infrastructure).
+3. Generate or update .editorconfig with C# formatting, naming rules, and diagnostic severities.
+4. Run architectural tests to verify current compliance.
+
+## Guardrail
+Do not break legacy builds; apply warnings first or scope enforcement gradually.
+
+## Options
+- --netarchtest       generate NetArchTest test project
+- --editorconfig      generate .editorconfig rules
+
+Follow this workflow whenever asked to build, modernize, or test .NET code in this repository.

package/templates/dotnet-commands/cursor/dotnet-ef-migration.md

@@ -0,0 +1,26 @@
+---
+description: Safe Entity Framework Core migration workflow with entity audit, SQL review, and rollback.
+globs: **/*.cs, **/*.csproj, **/*.sln
+---
+
+# dotnet-ef-migration
+
+# /dotnet-ef-migration
+
+Plan, generate, and review safe Entity Framework Core database migrations.
+
+## Workflow
+1. Audit entity configurations (Fluent API vs DataAnnotations) in target DbContext.
+2. Check for missing indexes, foreign key cascading issues, and property lengths.
+3. Generate migration with a descriptive name (dotnet ef migrations add <Name>).
+4. Generate and inspect raw migration SQL script (dotnet ef migrations script).
+5. Check for destructive schema changes (table drops, column drops, data loss warnings).
+
+## Guardrail
+Never execute irreversible or destructive migrations without explicit user confirmation.
+
+## Options
+- --name <Name>       descriptive migration name
+- --preview-sql       inspect generated SQL before applying
+
+Follow this workflow whenever asked to build, modernize, or test .NET code in this repository.

package/templates/dotnet-commands/cursor/dotnet-endpoint-from-model.md

@@ -0,0 +1,27 @@
+---
+description: Generate ASP.NET Core Minimal API or Controller endpoints from an entity/model with validation.
+globs: **/*.cs, **/*.csproj, **/*.sln
+---
+
+# dotnet-endpoint-from-model
+
+# /dotnet-endpoint-from-model
+
+Generate robust CRUD endpoints from a domain model or entity.
+
+## Workflow
+1. Inspect entity/model properties, keys, and navigation properties.
+2. Generate Request/Response DTOs to avoid overposting or leaking domain entities.
+3. Generate endpoint handlers using TypedResults (Ok, Created, NotFound, ValidationProblem).
+4. Configure authorization, route groups, and OpenAPI metadata (.WithName(), .Produces()).
+5. Verify endpoint route constraints.
+
+## Guardrail
+Never expose raw database entities directly to API responses. Always map through DTOs.
+
+## Options
+- --minimal           use ASP.NET Core Minimal APIs (default)
+- --controller        use Controller-based architecture
+- --dto <Type>        use existing DTO type
+
+Follow this workflow whenever asked to build, modernize, or test .NET code in this repository.

package/templates/dotnet-commands/cursor/dotnet-extract-service.md

@@ -0,0 +1,26 @@
+---
+description: Refactor fat services or bloated controllers into isolated CQRS handlers or domain services.
+globs: **/*.cs, **/*.csproj, **/*.sln
+---
+
+# dotnet-extract-service
+
+# /dotnet-extract-service
+
+Decompose fat classes into single-responsibility handlers or domain services.
+
+## Workflow
+1. Identify oversized methods or multi-responsibility service classes.
+2. Extract target method into an independent Command/Query handler or domain service.
+3. Define required interfaces and register with Microsoft.Extensions.DependencyInjection.
+4. Update caller references and ensure backward compatibility.
+5. Create unit tests for extracted handler.
+
+## Guardrail
+Preserve existing behavior and contract signatures. Do not introduce breaking API changes.
+
+## Options
+- --class <Name>      source class to refactor
+- --method <Name>     specific method to extract
+
+Follow this workflow whenever asked to build, modernize, or test .NET code in this repository.

package/templates/dotnet-commands/cursor/dotnet-feature.md

@@ -0,0 +1,27 @@
+---
+description: Build an end-to-end vertical slice feature (Command/Query, MediatR, FluentValidation, Endpoint).
+globs: **/*.cs, **/*.csproj, **/*.sln
+---
+
+# dotnet-feature
+
+# /dotnet-feature
+
+Generate a complete, self-contained feature slice following Vertical Slice Architecture.
+
+## Workflow
+1. Determine feature name, operation type (Command or Query), and target domain.
+2. Generate Request and Response DTO records with immutable properties.
+3. Generate FluentValidation validator with standard validation rules.
+4. Generate MediatR / Wolverine handler with DbContext or repository access.
+5. Expose via Minimal API endpoint or Controller with TypedResults.
+6. Scaffold unit tests and integration tests.
+
+## Guardrail
+Adhere to existing solution conventions (Vertical Slices vs Clean Architecture). Do not introduce unnecessary abstractions.
+
+## Options
+- --type <command|query> operation type
+- --model <Entity>       domain entity to base feature on
+
+Follow this workflow whenever asked to build, modernize, or test .NET code in this repository.

package/templates/dotnet-commands/cursor/dotnet-generate-tests.md

@@ -0,0 +1,26 @@
+---
+description: Generate xUnit/NUnit tests with FluentAssertions and WebApplicationFactory integration tests.
+globs: **/*.cs, **/*.csproj, **/*.sln
+---
+
+# dotnet-generate-tests
+
+# /dotnet-generate-tests
+
+Generate comprehensive unit and integration tests for .NET handlers, services, and endpoints.
+
+## Workflow
+1. Inspect target class (Handler, Validator, Service, or Endpoint).
+2. Generate unit tests covering valid input, boundary conditions, and error cases.
+3. Use Moq or NSubstitute for dependencies and FluentAssertions for assertions.
+4. For endpoints, generate WebApplicationFactory integration tests verifying status codes and payloads.
+5. Run tests with dotnet test.
+
+## Guardrail
+Mock only external boundaries (I/O, database, third-party APIs); test real business domain logic.
+
+## Options
+- --framework <xunit|nunit> test framework (default: xunit)
+- --integration             generate WebApplicationFactory integration tests
+
+Follow this workflow whenever asked to build, modernize, or test .NET code in this repository.