npm - @atlashub/smartstack-cli - Versions diffs - 4.80.0 → 5.0.0 - Mend

@atlashub/smartstack-cli 4.80.0 → 5.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1008) hide show

package/templates/skills/application/SKILL.md DELETED Viewed

@@ -1,241 +0,0 @@
----
-name: application
-description: |
-  Creates SmartStack full-stack applications/modules.
-  Use this skill when:
-  - User asks to create an application or module
-  - User mentions "new module", "new application", "add a feature"
-  - User wants to extend navigation with new entries
-  Scope: Application → Module → Section → Resource (all levels)
----
-# Skill Application SmartStack
-**Reference:** [_shared.md](../_shared.md) for architecture, permissions, i18n
-## ENTRY POINT
-> **FIRST ACTION:** Load `steps/step-00-init.md`
-This skill uses progressive step loading. Each step calls MCP tools for generation.
-## STEP FILES
-| Step | File | MCP Tool Called | Condition |
-|------|------|-----------------|-----------|
-| 00 | `steps/step-00-init.md` | `validate_conventions` (MCP check) | Always |
-| 01 | `steps/step-01-navigation.md` | `scaffold_navigation` | Always |
-| 02 | `steps/step-02-permissions.md` | `generate_permissions` | Always |
-| 03 | `steps/step-03-roles.md` | `scaffold_role_permissions` | Always |
-| 03b | `steps/step-03b-provider.md` | (none - direct generation) | Client projects only |
-| 04 | `steps/step-04-backend.md` | `scaffold_extension` | Always |
-| 05 | `steps/step-05-frontend.md` | `scaffold_api_client`, `scaffold_routes` | Always |
-| 06 | `steps/step-06-migration.md` | `suggest_migration` | Always |
-| 07 | `steps/step-07-tests.md` | `scaffold_tests` | Always |
-| 08 | `steps/step-08-documentation.md` | `/documentation` skill | If userDocRequired |
-## MCP INTEGRATION
-> **CRITICAL:** This skill MUST use MCP tools for all generation.
-> Templates in this folder are for REFERENCE ONLY - never use them directly.
-| MCP Tool | Purpose |
-|----------|---------|
-| `mcp__smartstack__scaffold_navigation` | Navigation entity + translations |
-| `mcp__smartstack__generate_permissions` | Permissions.cs + HasData |
-| `mcp__smartstack__scaffold_role_permissions` | Role-permission mappings |
-| `mcp__smartstack__scaffold_extension` | Entity, Service, Controller, DTOs |
-| `mcp__smartstack__scaffold_api_client` | TypeScript API client |
-| `mcp__smartstack__scaffold_routes` | React Router configuration |
-| `mcp__smartstack__suggest_migration` | Migration name suggestion |
-| `mcp__smartstack__scaffold_tests` | Test suite generation (backend) |
-| `mcp__smartstack__scaffold_frontend_tests` | Test suite generation (frontend React) |
-| `mcp__smartstack__validate_conventions` | Post-generation convention check |
-| `mcp__smartstack__review_code` | Code quality audit |
-## WHEN THIS SKILL ACTIVATES
-| Trigger | Example |
-|---------|---------|
-| Explicit request | "Create a module to manage products" |
-| New feature | "We need to add order management" |
-| Navigation extension | "Add a CRM application" |
-| Keywords | "new module", "new application" |
-## FLOW ARCHITECTURE
-```
-WEB (React) → API (.NET) → Application → Infrastructure → Database
-```
-**FORBIDDEN:** WEB → Infrastructure (direct DB access), WEB → Domain
-## WORKFLOW
-### 1. Level Detection
-| Hint | → Level |
-|------|---------|
-| "application", "app" | Application |
-| "module", "feature" | Module |
-| "section", "tab" | Section |
-### 2. Parameter Extraction
-`$LEVEL`, `$CODE` (kebab-case), `$LABEL_EN`, `$ICON` (Lucide)
-### 3. Full-Stack Generation
-```
-1. DB SEED (Navigation + Translations 4 languages)
-2. PERMISSIONS (Permissions.cs + PermissionConfiguration.cs) ← 2 files!
-3. ROLES (RolePermission mappings)
-3b. CLIENT SEED PROVIDER (client projects only - IClientSeedDataProvider)
-4. API (Controller + DTOs via /controller create)
-   4b. VALIDATE (/validate - convention check on generated backend)
-5. SERVICES (Interface + Implementation)
-6. FRONTEND (Page + Components + Hooks)
-7. I18N (fr, en, it, de)
-8. ROUTES (nested routes mandatory)
-9. PREFERENCES (Hook pattern)
-10. MIGRATION (/efcore migration)
-11. TESTS - Backend (scaffold_tests - 7 categories including real integration)
-12. TESTS - Frontend (scaffold_frontend_tests - Vitest + Testing Library + MSW)
-13. REVIEW (/review-code - security + architecture + quality audit)
-14. DOCUMENTATION (in-app user doc via /documentation - if userDocRequired)
-```
-### 3b. Client Seed Provider (client projects only)
-Generates `IClientSeedDataProvider` implementation that wires navigation + permissions + roles
-into the SmartStack Core seeding pipeline. Only runs when `{seeding_strategy}` = "provider".
-Core projects skip this step entirely.
-### 4. Automatic Chaining
-- `/controller create` → API Controllers
-- `/efcore migration` → DB Migrations
-- `/ui-components` → EntityCard, DataTable
-## USER PREFERENCES
-| Preference | Storage |
-|------------|---------|
-| pageSize | `user.preferences.{module}.pageSize` |
-| sortColumn/Direction | `user.preferences.{module}.sort*` |
-| filters | `user.preferences.{module}.filters` |
-| visibleColumns | `user.preferences.{module}.visibleColumns` |
-| viewMode | `user.preferences.{module}.viewMode` |
-```typescript
-export function use{Module}Preferences() {
-  const { preferences, updatePreference } = useUserPreferences();
-  return {
-    pageSize: preferences.{module}?.pageSize ?? 10,
-    setPageSize: (size: number) => updatePreference('{module}.pageSize', size),
-    // ... others
-  };
-}
-```
-## ROUTING (React Router v7)
-```tsx
-// ✅ CORRECT - Nested routes
-<Route path="$APPLICATION">
-  <Route index element={<Navigate to="$DEFAULT_MODULE" replace />} />
-  <Route path="$MODULE1" element={<Module1Page />} />
-</Route>
-// ❌ FORBIDDEN - Flat routes (cause redirect to Home)
-<Route path="$APPLICATION" element={<Navigate ... />} />
-<Route path="$APPLICATION/$MODULE1" element={...} />
-```
-## INTEGRATIONS
-| Skill | When | Action |
-|-------|------|--------|
-| `/notification` | User alerts | INotificationService + SignalR |
-| `/workflow` | Automated emails | IWorkflowService.TriggerAsync |
-| `/ai-prompt` | AI assistance | IAiCompletionService |
-| `/feature-full` | Complete feature | Orchestration all skills |
-| `/validate` | After step-04 (backend) | MCP `validate_conventions` on generated code |
-| `/review-code` | After step-07 (tests) | Security (OWASP), architecture, SOLID, performance audit |
-| `/validate-feature` | After step-07 (tests) | Compile + test + API smoke test |
-| `/documentation` | In-app user doc | Documentation page via doc-data.ts + DocRenderer |
-### Notification Integration Pattern
-```csharp
-await _notificationService.SendNotificationAsync(
-    userId, NotificationType.{Entity}Created, title, message,
-    relatedEntityType: nameof({Entity}), relatedEntityId: entity.Id);
-```
-### Workflow Integration Pattern
-```csharp
-await _workflowService.TriggerAsync("{entity}.created", new Dictionary<string, object>
-{
-    ["entityId"] = entity.Id,
-    ["creatorEmail"] = _currentUser.Email
-});
-```
-## ABSOLUTE RULES
-| DO | DON'T |
-|----|-------|
-| 4 languages (FR, EN, IT, DE) | Import Infrastructure in frontend |
-| Permissions: 2 files | Direct SQL in frontend |
-| Nested routes | Flat routes (flat siblings) |
-| EntityCard for cards | Manual cards with divs |
-| DataTable for tables | Sequential GUIDs |
-### FORBIDDEN ACTIONS (BLOCKING)
-> **NEVER create temporary files, scripts, or helper files of any kind.**
-| FORBIDDEN | USE INSTEAD |
-|-----------|-------------|
-| Creating `.ps1` scripts | `Grep` tool to search `.cs` files |
-| Creating `.sh` / `.bat` scripts | `Glob` tool to find files by pattern |
-| Creating `temp-*` files | `Read` tool to inspect file contents |
-| Scanning DLLs / assemblies | Search source `.cs` files directly |
-| Running `dotnet` reflection commands | MCP `validate_conventions` tool |
-| Any file not part of the final deliverable | Ask the user if information is missing |
-**Type Discovery Rules:**
-- To find base classes: `Grep` for `class BaseEntity` or `class {Name}` in `*.cs` files
-- To find existing services: `Glob` for `**/I*Service.cs` in the Application layer
-- To find NuGet packages: `Read` the `.csproj` files directly
-- To find existing entities: `Glob` for `**/*.cs` in the Domain layer
-- If a type cannot be found after 2 search attempts: **ASK the user**, do NOT create scripts
-## ASSOCIATED FILES
-### Step Files (ACTIVE - Use These)
-- [steps/step-00-init.md](steps/step-00-init.md) - Initialize parameters
-- [steps/step-01-navigation.md](steps/step-01-navigation.md) - Generate navigation
-- [steps/step-02-permissions.md](steps/step-02-permissions.md) - Generate permissions
-- [steps/step-03-roles.md](steps/step-03-roles.md) - Assign roles
-- [steps/step-03b-provider.md](steps/step-03b-provider.md) - Client seed provider (client projects only)
-- [steps/step-04-backend.md](steps/step-04-backend.md) - Generate backend
-- [steps/step-05-frontend.md](steps/step-05-frontend.md) - Generate frontend
-- [steps/step-06-migration.md](steps/step-06-migration.md) - Create migration
-- [steps/step-07-tests.md](steps/step-07-tests.md) - Generate test suite
-- [steps/step-08-documentation.md](steps/step-08-documentation.md) - Generate in-app documentation
-### Templates (REFERENCE ONLY - Do Not Use Directly)
-> These templates are kept for documentation purposes.
-> All generation is done via MCP tools in step files.
-- [templates-backend.md](templates-backend.md) - Backend patterns reference
-- [templates-frontend.md](templates-frontend.md) - Frontend patterns reference
-- [templates-i18n.md](templates-i18n.md) - i18n structure reference
-- [templates-seed.md](templates-seed.md) - Seed data patterns reference
-<success_criteria>
-- Navigation entries created with correct hierarchy (Application/Module)
-- Permissions generated via MCP with 2-file pattern (constants + seed)
-- Roles assigned with appropriate permission sets
-- Backend layers follow SmartStack conventions (validated by MCP)
-- Frontend pages in correct path structure with i18n
-- EF Core migration created and applied successfully
-- Test suite generated and passing
-</success_criteria>

package/templates/skills/application/references/application-roles-template.md DELETED Viewed

@@ -1,228 +0,0 @@
-# Application Roles Seed Data Template
-> Referenced from `core-seed-data.md` and `step-03-roles.md` — C# template for application-scoped roles in client projects.
----
-## Problem Statement
-When using `IClientSeedDataProvider` (client projects with `seeding_strategy = "provider"`), role-permission mappings reference roles by their `Code`:
-```csharp
-var role = roles.FirstOrDefault(r => r.Code == mapping.RoleCode);  // "admin", "manager", "contributor", "viewer"
-```
-**However**, the current templates do NOT create these application-scoped roles. They assume:
-- System roles (SuperAdmin, PlatformAdmin, TenantAdmin, StandardUser) exist in Core
-- Application-scoped roles (Admin, Manager, Contributor, Viewer) already exist with valid `Code` values
-**Result:** Role-permission mappings fail silently when `role == null`.
----
-## Solution: Application Roles Seed Data
-Create application-scoped roles with random GUIDs (`Guid.NewGuid()`) and valid `Code` values.
----
-## File Location
-**Path:** `Infrastructure/Persistence/Seeding/Data/ApplicationRolesSeedData.cs`
-This file should be created **ONCE per application** (not per module).
----
-## Template
-```csharp
-using SmartStack.Domain.Platform.Administration.Roles;
-namespace {BaseNamespace}.Infrastructure.Persistence.Seeding.Data;
-/// <summary>
-/// Application-scoped role seed data for {AppLabel}.
-/// Defines the 4 standard application roles: Admin, Manager, Contributor, Viewer.
-/// Consumed by IClientSeedDataProvider at application startup.
-/// </summary>
-public static class ApplicationRolesSeedData
-{
-    // Random GUIDs — idempotence is handled by Code-based lookups, not fixed IDs
-    public static readonly Guid ApplicationId = NavigationApplicationSeedData.ApplicationId;
-    public static readonly Guid AdminRoleId = Guid.NewGuid();
-    public static readonly Guid ManagerRoleId = Guid.NewGuid();
-    public static readonly Guid ContributorRoleId = Guid.NewGuid();
-    public static readonly Guid ViewerRoleId = Guid.NewGuid();
-    /// <summary>
-    /// Returns application-scoped role entries for seeding into core.auth_Roles.
-    /// </summary>
-    public static IEnumerable<ApplicationRoleSeedEntry> GetRoleEntries()
-    {
-        yield return new ApplicationRoleSeedEntry
-        {
-            Id = AdminRoleId,
-            Code = "admin",
-            Name = "{AppLabel} Admin",
-            Description = "Full administrative access to {AppLabel}",
-            ApplicationId = ApplicationId,
-            IsSystem = false,
-            IsActive = true,
-            DisplayOrder = 1
-        };
-        yield return new ApplicationRoleSeedEntry
-        {
-            Id = ManagerRoleId,
-            Code = "manager",
-            Name = "{AppLabel} Manager",
-            Description = "Management access to {AppLabel} (Create, Read, Update)",
-            ApplicationId = ApplicationId,
-            IsSystem = false,
-            IsActive = true,
-            DisplayOrder = 2
-        };
-        yield return new ApplicationRoleSeedEntry
-        {
-            Id = ContributorRoleId,
-            Code = "contributor",
-            Name = "{AppLabel} Contributor",
-            Description = "Contributor access to {AppLabel} (Create, Read)",
-            ApplicationId = ApplicationId,
-            IsSystem = false,
-            IsActive = true,
-            DisplayOrder = 3
-        };
-        yield return new ApplicationRoleSeedEntry
-        {
-            Id = ViewerRoleId,
-            Code = "viewer",
-            Name = "{AppLabel} Viewer",
-            Description = "Read-only access to {AppLabel}",
-            ApplicationId = ApplicationId,
-            IsSystem = false,
-            IsActive = true,
-            DisplayOrder = 4
-        };
-    }
-    // No deterministic GUID generation — all IDs are random via Guid.NewGuid()
-    // Roles are resolved by Code at runtime, not by fixed GUIDs
-}
-/// <summary>Seed entry DTO for application role.</summary>
-public class ApplicationRoleSeedEntry
-{
-    public Guid Id { get; init; }
-    public string Code { get; init; } = null!;
-    public string Name { get; init; } = null!;
-    public string Description { get; init; } = null!;
-    public Guid ApplicationId { get; init; }
-    public bool IsSystem { get; init; }
-    public bool IsActive { get; init; }
-    public int DisplayOrder { get; init; }
-}
-```
----
-## Placeholder Replacement
-| Placeholder | Description | Example |
-|-------------|-------------|---------|
-| `{BaseNamespace}` | Root namespace of the client project | `SmartStack.Modules.RessourcesHumaines` |
-| `{AppLabel}` | Human-readable application label (EN) | `Human Resources` |
-| `ApplicationId` | From `NavigationApplicationSeedData.ApplicationId` — resolved at runtime via Code lookup | Auto-resolved |
----
-## Integration into IClientSeedDataProvider
-Add a new method `SeedRolesAsync()` to the provider:
-```csharp
-public async Task SeedRolesAsync(ICoreDbContext context, CancellationToken ct)
-{
-    // Resolve application from DB by Code — NOT seed-time GUID
-    var app = await context.NavigationApplications
-        .FirstAsync(a => a.Code == "{app_code}", ct);
-    // Check idempotence — scoped by actual DB ApplicationId
-    var exists = await context.Roles
-        .AnyAsync(r => r.ApplicationId == app.Id, ct);
-    if (exists) return;
-    // Create application-scoped roles using factory method
-    foreach (var entry in ApplicationRolesSeedData.GetRoleEntries())
-    {
-        var role = Role.Create(
-            name: entry.Name,
-            shortName: entry.Code,
-            category: RoleCategory.Application,
-            description: entry.Description,
-            isSystem: entry.IsSystem,
-            applicationId: app.Id,
-            code: entry.Code);
-        context.Roles.Add(role);
-    }
-    await ((DbContext)context).SaveChangesAsync(ct);
-}
-```
----
-## Execution Order in Provider
-**CRITICAL:** Roles must be created BEFORE role-permission mappings.
-```
-1. SeedNavigationAsync()   → Creates application + modules + translations
-2. SeedRolesAsync()         → Creates application-scoped roles (NEW)
-3. SeedPermissionsAsync()   → Creates permissions
-4. SeedRolePermissionsAsync() → Maps roles to permissions (now succeeds because roles exist)
-```
----
-## Verification Checklist
-Before marking the task as completed, verify:
-- [ ] `ApplicationRolesSeedData.cs` created in `Infrastructure/Persistence/Seeding/Data/`
-- [ ] Random GUIDs used via `Guid.NewGuid()` (no deterministic/sequential/fixed values)
-- [ ] 4 roles defined: Admin, Manager, Contributor, Viewer
-- [ ] Each role has a valid `Code` value ("admin", "manager", "contributor", "viewer")
-- [ ] Each role has `ApplicationId` set to the application GUID
-- [ ] `SeedRolesAsync()` method added to `IClientSeedDataProvider`
-- [ ] `SeedRolesAsync()` is idempotent (checks existence before inserting)
-- [ ] `Role.Create()` factory method used (NEVER `new Role()`)
-- [ ] `SaveChangesAsync()` called after role creation
-- [ ] Execution order: Navigation → Roles → Permissions → RolePermissions
-- [ ] `dotnet build` passes after generation
----
-## Notes
-- **Application ID source:** Read from the navigation application created in `SeedNavigationAsync()` or from `{AppPascal}NavigationSeedData.cs`
-- **Role factory method:** Use `Role.Create(name, shortName, category, description, isSystem, applicationId: ..., code: ...)` from SmartStack.Domain
-- **Code uniqueness:** Role codes must be unique within the application scope
-- **System roles:** These are NOT system roles (IsSystem = false) - they are application-scoped roles
-- **Tenant isolation:** Application-scoped roles are automatically tenant-isolated via the Core authorization system
----
-## Migration Impact
-**For existing projects without application roles:**
-1. Generate `ApplicationRolesSeedData.cs` using this template
-2. Add `SeedRolesAsync()` method to the existing `IClientSeedDataProvider`
-3. Update the provider's execution to call `SeedRolesAsync()` BEFORE `SeedRolePermissionsAsync()`
-4. Run the application - roles will be created on next startup
-5. Role-permission mappings will now succeed

package/templates/skills/application/references/backend-controller-hierarchy.md DELETED Viewed

@@ -1,68 +0,0 @@
-# Controller NavRoute and Folder Hierarchy
-> Referenced from `steps/step-04-backend.md` — Controller file organization and NavRoute conventions.
----
-## Controller File Location
-Controllers are organized by **application** (matching SmartStack.app pattern):
-```
-Api/Controllers/
-├── Administration/            ← administration.*
-│   ├── {Module}/              ← Module sub-folder (e.g., AI/, Communications/, Tenants/)
-│   │   └── {EntityName}Controller.cs
-│   └── {EntityName}Controller.cs  ← Direct controllers (no module sub-folder)
-├── Support/                   ← support.*
-│   └── {EntityName}Controller.cs
-├── {ApplicationPascal}/       ← Other applications (e.g., Sales/, HumanResources/)
-│   └── {EntityName}Controller.cs
-├── MySpace/                   ← myspace.*
-│   └── {EntityName}Controller.cs
-└── {SharedControllers}.cs     ← Root-level (Auth, Config, Navigation, etc.)
-```
-## Application-to-Folder Mapping
-| NavRoute Application | Controller Folder | Example |
-|-----------------|-------------------|---------|
-| `administration` | `Administration` | `Controllers/Administration/TenantsController.cs` |
-| `administration.{module}` | `Administration/{Module}` | `Controllers/Administration/AI/AiPromptsController.cs` |
-| `support` | `Support` | `Controllers/Support/TicketsController.cs` |
-| `{application}` | `{ApplicationPascal}` | `Controllers/Sales/ProductsController.cs` |
-| `myspace` | `MySpace` | `Controllers/MySpace/PreferencesController.cs` |
-## Controller Attributes
-The generated controller uses NavRoute attribute:
-```csharp
-[ApiController]
-[NavRoute("{full_path}")]
-[Microsoft.AspNetCore.Authorization.Authorize]
-[Produces("application/json")]
-[Tags("{EntityNamePlural}")]
-public class {EntityName}Controller : ControllerBase
-{
-    private readonly ISender _mediator;
-    public {EntityName}Controller(ISender mediator) => _mediator = mediator;
-    [HttpGet]
-    [RequirePermission(Permissions.{Application}.{Module}.View)]
-    [ProducesResponseType(typeof(List<{EntityName}ListDto>), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
-    [ProducesResponseType(StatusCodes.Status403Forbidden)]
-    public async Task<ActionResult<List<{EntityName}ListDto>>> GetAll(CancellationToken ct)
-        => Ok(await _mediator.Send(new Get{EntityNamePlural}Query(), ct));
-    // ... other CRUD methods
-}
-```
-This ensures:
-- API route is derived from navigation path
-- Permissions use the constants from Permissions.cs
-- Frontend can discover API path from NavRoute registry
-- Controller file is in the correct application folder

package/templates/skills/application/references/backend-entity-seeding.md DELETED Viewed

@@ -1,73 +0,0 @@
-# Entity Seeding Pattern
-> Reference: See `templates-seed.md` section "TEMPLATE: ENTITY SEED DATA (SeedData Provider)"
-## SeedData File
-**`Infrastructure/Persistence/Seeding/Data/{Domain}/{EntityName}SeedData.cs`**
-Follow SmartStack.app pattern:
-- Static class with `internal static IEnumerable<{EntityName}SeedItem> GetAll{EntityName}s()`
-- ALWAYS use `Guid.NewGuid()` — avoids conflicts between projects/tenants/environments
-- Idempotence is handled by `AnyAsync()` checks (by Code/Name), NOT by fixed IDs
-- Include 3-5 sample entities with varied, realistic data
-- For multi-tenant: organize by tenant using `GetTenant1{EntityName}s()` helpers
-```csharp
-public static class {EntityName}SeedData
-{
-    public static readonly Guid Sample1Id = Guid.NewGuid();
-    public static readonly Guid Sample2Id = Guid.NewGuid();
-    public static readonly Guid Sample3Id = Guid.NewGuid();
-    internal static IEnumerable<{EntityName}SeedItem> GetAll{EntityName}s()
-    {
-        return new[]
-        {
-            new {EntityName}SeedItem { Id = Sample1Id, /* ... */ },
-            new {EntityName}SeedItem { Id = Sample2Id, /* ... */ },
-            new {EntityName}SeedItem { Id = Sample3Id, /* ... */ }
-        };
-    }
-}
-internal class {EntityName}SeedItem
-{
-    public Guid Id { get; init; }
-    // ... all required entity properties
-}
-```
-## DevDataSeeder Update
-Add to `Infrastructure/Persistence/Seeding/DevDataSeeder.cs`:
-- `using` for the new SeedData namespace
-- `await Seed{EntityName}sAsync(cancellationToken);` in `SeedAsync()` method
-```csharp
-private async Task Seed{EntityName}sAsync(CancellationToken cancellationToken)
-{
-    _logger.LogInformation("Seeding demo {EntityName}s...");
-    var existingCount = await _context.{EntityName}s.CountAsync(cancellationToken);
-    if (existingCount > 0)
-    {
-        _logger.LogWarning("{EntityName}s already seeded ({Count} exist), skipping.", existingCount);
-        return;
-    }
-    var createdCount = 0;
-    foreach (var seedItem in {EntityName}SeedData.GetAll{EntityName}s())
-    {
-        var entity = {EntityName}.Create(/* map seedItem properties */);
-        // Factory method generates a random GUID — no need to override
-        _context.{EntityName}s.Add(entity);
-        createdCount++;
-    }
-    if (createdCount > 0)
-        await _context.SaveChangesAsync(cancellationToken);
-    _logger.LogInformation("Created {Count} demo {EntityName}s.", createdCount);
-}
-```

package/templates/skills/application/references/backend-seeding-and-dto-output.md DELETED Viewed

@@ -1,83 +0,0 @@
-# Backend Generation: Entity Seeding & Output Formatting
-> Referenced from `steps/step-04-backend.md` — Optional seeding and MCP response handling.
----
-## Entity Seeding (Optional)
-Ask the user if they want to seed initial data for the entity:
-```yaml
-questions:
-  - header: "Seed Data"
-    question: "Would you like to generate initial seed data for {EntityName}?"
-    options:
-      - label: "Yes - Generate SeedData provider"
-        description: "Creates {EntityName}SeedData.cs + registers in DevDataSeeder (same pattern as core)"
-      - label: "No - Skip seeding"
-        description: "Entity starts empty (can add seed data later)"
-    multiSelect: false
-```
-**If user selects YES:**
-See [references/backend-entity-seeding.md](../references/backend-entity-seeding.md) for the full seeding pattern:
-1. **SeedData file** (`{EntityName}SeedData.cs`) — static class with `Guid.NewGuid()`, 3-5 samples
-2. **DevDataSeeder update** — add `Seed{EntityName}sAsync()` method with idempotent check
-**If user selects NO:**
-Skip this section and proceed to storing entity info.
-```markdown
-> Skipping entity seed data. You can generate it later using the SeedData provider pattern
-> documented in templates-seed.md.
-```
----
-## Presenting Output to User
-Display generated backend code organized by layer:
-### Domain Layer
-- `Domain/{Application}/{Module}/{EntityName}.cs`
-### Infrastructure Layer
-- `Persistence/Configurations/{Application}/{Module}/{EntityName}Configuration.cs`
-- `Services/{Application}/{Module}/{EntityName}Service.cs`
-### Application Layer
-- `Common/Interfaces/I{EntityName}Service.cs`
-- `{Application}/{Module}/DTOs/{EntityName}ResponseDto.cs`
-- `{Application}/{Module}/DTOs/Create{EntityName}Dto.cs`
-- `{Application}/{Module}/DTOs/Update{EntityName}Dto.cs`
-### API Layer
-- `Controllers/{controller_folder}/{Application}/{EntityName}Controller.cs`
-  - NavRoute: `{full_path}`
-  - Endpoints:
-    - GET /api/{code} - List all
-    - GET /api/{code}/{id} - Get by ID
-    - POST /api/{code} - Create
-    - PUT /api/{code}/{id} - Update
-    - DELETE /api/{code}/{id} - Delete
-### Next Steps
-1. Add DbSet to ICoreDbContext: `public DbSet<{EntityName}> {EntityName}s => Set<{EntityName}>();`
-2. Register service in DI: `services.AddScoped<I{EntityName}Service, {EntityName}Service>();`
-3. Run: `dotnet ef migrations add core_vX.X.X_XXX_Add{EntityName}`
----
-## Entity Info Storage
-Store for use in frontend generation:
-```
-{entity_name} = "{EntityName}"
-{entity_code} = "{code}"
-{api_route} = "/api/{code}"
-{has_seed_data} = true/false  // Whether SeedData provider was generated
-```