plankit-cli 1.3.1 → 1.5.0

package/src/dashboard/dashboard.js

@@ -0,0 +1,272 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { listDirectories, safeJoin } from '../config.js';
+import { runAnalysis, formatReport } from '../analyzer/engine.js';
+
+export function loadDashboardData(cwd, config) {
+  const artifactsDir = safeJoin(cwd, config.artifactsDir || 'artifacts');
+  const currentDir = path.join(artifactsDir, 'current');
+  const archivedDir = path.join(artifactsDir, 'archived');
+
+  const activeNames = listDirectories(currentDir);
+  const archivedNames = listDirectories(archivedDir);
+
+  const activeFeatures = activeNames.map((name) => {
+    const featureDir = path.join(currentDir, name);
+    const phasesDir = path.join(featureDir, 'phases');
+    const outputsDir = path.join(featureDir, 'outputs');
+
+    const phaseFiles = fs.existsSync(phasesDir)
+      ? fs.readdirSync(phasesDir).filter((f) => f.startsWith('phase-') && f.endsWith('.md')).sort()
+      : [];
+    const outputFiles = fs.existsSync(outputsDir)
+      ? fs.readdirSync(outputsDir).filter((f) => f.startsWith('phase-') && f.endsWith('.md')).sort()
+      : [];
+
+    let state = null;
+    const stateFile = path.join(featureDir, 'plankit.json');
+    if (fs.existsSync(stateFile)) {
+      try {
+        state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+      } catch {
+        state = null;
+      }
+    }
+
+    const phases = phaseFiles.map((pf, idx) => {
+      const num = idx + 1;
+      const expectedOutput = `phase-${num}-output.md`;
+      const hasOutput = outputFiles.includes(expectedOutput);
+      return {
+        number: num,
+        specFile: pf,
+        hasOutput,
+        status: hasOutput ? 'DONE' : (num === outputFiles.length + 1 ? 'IN_PROGRESS' : 'PENDING')
+      };
+    });
+
+    const completedCount = phases.filter((p) => p.hasOutput).length;
+    const totalCount = phases.length || 1;
+    const progressPercent = Math.round((completedCount / totalCount) * 100);
+
+    return {
+      name,
+      phases,
+      phaseCount: phases.length,
+      completedCount,
+      progressPercent,
+      state
+    };
+  });
+
+  return {
+    activeFeatures,
+    archivedCount: archivedNames.length,
+    archivedNames
+  };
+}
+
+export function renderStaticDashboard(data, io) {
+  io.stdout('================================================================');
+  io.stdout('               PlanKit Feature Management Matrix               ');
+  io.stdout('================================================================');
+  io.stdout(`Active Features: ${data.activeFeatures.length} | Archived Features: ${data.archivedCount}`);
+  io.stdout('');
+
+  if (data.activeFeatures.length === 0) {
+    io.stdout('  No active features found in artifacts/current/.');
+    io.stdout('  Run "plankit plan <feature-name>" to start a feature.');
+    io.stdout('================================================================');
+    return;
+  }
+
+  io.stdout(padRight('Feature Name', 25) + padRight('Phases', 12) + padRight('Progress', 20) + 'Status');
+  io.stdout('-'.repeat(64));
+
+  data.activeFeatures.forEach((feat) => {
+    const progressText = `${progressBar(feat.progressPercent, 10)} ${feat.progressPercent}%`;
+    const statusText = feat.completedCount === feat.phaseCount ? 'READY_FOR_REVIEW' : `PHASE_${feat.completedCount + 1}`;
+    io.stdout(padRight(feat.name, 25) + padRight(`${feat.completedCount}/${feat.phaseCount}`, 12) + padRight(progressText, 20) + statusText);
+
+    feat.phases.forEach((p) => {
+      const check = p.hasOutput ? '[x]' : '[ ]';
+      io.stdout(`    ${check} Phase ${p.number}: ${p.specFile} (${p.status})`);
+    });
+    io.stdout('');
+  });
+
+  io.stdout('================================================================');
+}
+
+export async function runInteractiveDashboard(cwd, io, config, handlers = {}) {
+  const isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const data = loadDashboardData(cwd, config);
+
+  if (!isTTY) {
+    renderStaticDashboard(data, io);
+    return;
+  }
+
+  let selectedIndex = 0;
+  let statusMessage = 'Use [↑/↓] or [j/k] to navigate. Press [q] to exit.';
+
+  function refresh() {
+    const freshData = loadDashboardData(cwd, config);
+    console.clear();
+    console.log('\x1b[1m================================================================\x1b[0m');
+    console.log('\x1b[1m\x1b[36m             PlanKit Interactive Feature Dashboard             \x1b[0m');
+    console.log('\x1b[1m================================================================\x1b[0m');
+    console.log(`Active Features: \x1b[32m${freshData.activeFeatures.length}\x1b[0m | Archived Features: \x1b[33m${freshData.archivedCount}\x1b[0m`);
+    console.log('');
+
+    if (freshData.activeFeatures.length === 0) {
+      console.log('  No active features in artifacts/current/.');
+      console.log('  Press [p] to plan a new feature, or [q] to exit.');
+      console.log('\x1b[1m================================================================\x1b[0m');
+      console.log(`Status: ${statusMessage}`);
+      return;
+    }
+
+    if (selectedIndex >= freshData.activeFeatures.length) {
+      selectedIndex = freshData.activeFeatures.length - 1;
+    }
+
+    freshData.activeFeatures.forEach((feat, index) => {
+      const isSelected = index === selectedIndex;
+      const pointer = isSelected ? '\x1b[36m▶ \x1b[0m' : '  ';
+      const nameFmt = isSelected ? `\x1b[1m\x1b[36m${padRight(feat.name, 22)}\x1b[0m` : padRight(feat.name, 22);
+      const progress = `${progressBar(feat.progressPercent, 10)} ${feat.progressPercent}%`;
+      console.log(`${pointer}${nameFmt} ${padRight(progress, 18)} (${feat.completedCount}/${feat.phaseCount} phases)`);
+    });
+
+    console.log('');
+    const selectedFeature = freshData.activeFeatures[selectedIndex];
+    if (selectedFeature) {
+      console.log(`\x1b[1mPhase Breakdown for "${selectedFeature.name}":\x1b[0m`);
+      selectedFeature.phases.forEach((p) => {
+        const badge = p.hasOutput ? '\x1b[32m[COMPLETED]\x1b[0m' : '\x1b[33m[PENDING]\x1b[0m';
+        console.log(`  Phase ${p.number}: ${padRight(p.specFile, 32)} ${badge}`);
+      });
+    }
+
+    console.log('');
+    console.log('\x1b[1m----------------------------------------------------------------\x1b[0m');
+    console.log('\x1b[2mActions: [i] Implement Next Phase | [c] Clarify | [r] Review | [s] Scan | [q] Quit\x1b[0m');
+    console.log(`\x1b[33m${statusMessage}\x1b[0m`);
+  }
+
+  return new Promise((resolve) => {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.setRawMode) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    refresh();
+
+    const onKeypress = async (str, key) => {
+      if ((key && key.ctrl && key.name === 'c') || (key && key.name === 'q')) {
+        cleanup();
+        console.clear();
+        io.stdout('Exited PlanKit Dashboard.');
+        resolve();
+        return;
+      }
+
+      const freshData = loadDashboardData(cwd, config);
+      const currentFeature = freshData.activeFeatures[selectedIndex];
+
+      if (key && (key.name === 'up' || key.name === 'k')) {
+        if (selectedIndex > 0) selectedIndex -= 1;
+        statusMessage = `Selected ${freshData.activeFeatures[selectedIndex]?.name || ''}`;
+        refresh();
+      } else if (key && (key.name === 'down' || key.name === 'j')) {
+        if (selectedIndex < freshData.activeFeatures.length - 1) selectedIndex += 1;
+        statusMessage = `Selected ${freshData.activeFeatures[selectedIndex]?.name || ''}`;
+        refresh();
+      } else if (str === 's') {
+        cleanup();
+        console.clear();
+        io.stdout('Running PlanKit Static Analysis...\n');
+        const report = await runAnalysis(cwd, { artifactsDir: config.artifactsDir });
+        io.stdout(formatReport(report, true));
+        io.stdout('\nPress any key to return to dashboard...');
+        process.stdin.once('data', () => {
+          readline.emitKeypressEvents(process.stdin);
+          if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+          process.stdin.resume();
+          process.stdin.on('keypress', onKeypress);
+          statusMessage = 'Completed static analysis scan.';
+          refresh();
+        });
+      } else if (str === 'i' && currentFeature && handlers.implement) {
+        const nextPhase = currentFeature.completedCount + 1;
+        if (nextPhase > currentFeature.phaseCount) {
+          statusMessage = `Feature "${currentFeature.name}" has completed all phases! Press [r] to review.`;
+          refresh();
+        } else {
+          cleanup();
+          console.clear();
+          io.stdout(`Preparing Phase ${nextPhase} for "${currentFeature.name}"...\n`);
+          try {
+            await handlers.implement(currentFeature.name, nextPhase);
+            statusMessage = `Phase ${nextPhase} prepared successfully for "${currentFeature.name}".`;
+          } catch (err) {
+            statusMessage = `Error: ${err.message}`;
+          }
+          resume();
+        }
+      } else if (str === 'c' && currentFeature && handlers.clarify) {
+        cleanup();
+        console.clear();
+        try {
+          await handlers.clarify(currentFeature.name);
+          statusMessage = `Clarifications prepared for "${currentFeature.name}".`;
+        } catch (err) {
+          statusMessage = `Error: ${err.message}`;
+        }
+        resume();
+      } else if (str === 'r' && currentFeature && handlers.review) {
+        cleanup();
+        console.clear();
+        try {
+          await handlers.review(currentFeature.name);
+          statusMessage = `Feature "${currentFeature.name}" reviewed and archived.`;
+        } catch (err) {
+          statusMessage = `Review error: ${err.message}`;
+        }
+        resume();
+      }
+    };
+
+    function cleanup() {
+      process.stdin.removeListener('keypress', onKeypress);
+      if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+      }
+    }
+
+    function resume() {
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(true);
+      }
+      process.stdin.resume();
+      process.stdin.on('keypress', onKeypress);
+      refresh();
+    }
+
+    process.stdin.on('keypress', onKeypress);
+  });
+}
+
+function progressBar(percent, length = 10) {
+  const filled = Math.round((percent / 100) * length);
+  const empty = length - filled;
+  return `[${'='.repeat(filled)}${'-'.repeat(empty)}]`;
+}
+
+function padRight(str, len) {
+  return String(str).padEnd(len, ' ');
+}

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.