@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/application/steps/step-01-navigation.md

@@ -1,170 +0,0 @@
----
-name: step-01-navigation
-description: Generate navigation entity seeds using MCP scaffold_navigation (with fallback)
-prev_step: steps/step-00-init.md
-next_step: steps/step-02-permissions.md
----
-
-# Step 1: Navigation Generation
-
-## MANDATORY EXECUTION RULES
-
-- PREFER MCP `scaffold_navigation` tool as the primary method
-- If MCP is unavailable (`{mcp_available}` = false) or the call fails, use the FALLBACK PROCEDURE below
-- ALWAYS verify the output includes translations for 4 languages (fr, en, it, de)
-- ALWAYS WRITE generated code to the actual Configuration files (not just display)
-- Store navigation GUID for use in subsequent steps
-
-## YOUR TASK
-
-Generate navigation entity seeds:
-1. Navigation entity HasData() code in the appropriate Configuration.cs
-2. NavigationTranslation entries (4 languages) in NavigationTranslationConfiguration.cs
-
----
-
-## AVAILABLE STATE
-
-From step-00-init:
-
-| Variable | Description |
-|----------|-------------|
-| `{level}` | application, module, section, or resource |
-| `{code}` | kebab-case identifier |
-| `{full_path}` | Complete navigation path |
-| `{parent_path}` | Parent path (null for context) |
-| `{labels}` | Object with fr, en, it, de |
-| `{descriptions}` | Object with fr, en, it, de |
-| `{icon}` | Lucide icon name |
-| `{display_order}` | Numeric display order |
-| `{mcp_available}` | Boolean - MCP connectivity status |
-| `{project_type}` | "core" or "client" |
-| `{seeding_strategy}` | "hasdata" or "provider" |
-
----
-
-## EXECUTION SEQUENCE (MCP Primary)
-
-> **Branch:** If `{seeding_strategy}` = "provider", jump to **CLIENT PROJECT HANDLING** section below.
-> The MCP and FALLBACK sections apply only when `{seeding_strategy}` = "hasdata" (core projects).
-
-### 1. Call MCP scaffold_navigation
-
-```
-Tool: mcp__smartstack__scaffold_navigation
-Args:
-  level: "{level}"
-  code: "{code}"
-  parentPath: "{parent_path}"  # Omit if level is "application" (top-level)
-  labels:
-    fr: "{labels.fr}"
-    en: "{labels.en}"
-    it: "{labels.it}"
-    de: "{labels.de}"
-  descriptions:
-    fr: "{descriptions.fr}"
-    en: "{descriptions.en}"
-    it: "{descriptions.it}"
-    de: "{descriptions.de}"
-  icon: "{icon}"
-  displayOrder: {display_order}
-```
-
-### 2. Parse MCP Response
-
-The tool returns:
-- Navigation entity GUID (deterministic)
-- HasData() code for NavigationXxxConfiguration.cs
-- HasData() code for NavigationTranslationConfiguration.cs
-- SeedData class template (optional)
-
-### 3. Write Code to Files
-
-**CRITICAL:** WRITE the generated code to the actual Configuration files.
-
-1. Update `Navigation{Level}Configuration.cs` with the new HasData entry
-2. Update `NavigationTranslationConfiguration.cs` with the 4 translation entries
-
-### 4. Store Generated GUID
-
-```
-{navigation_guid} = [GUID from MCP response]
-```
-
----
-
-## MCP RESPONSE HANDLING
-
-### Success Case
-
-If MCP returns successfully:
-- Write HasData code to Configuration files
-- Store `{navigation_guid}` for next step
-- Proceed to step-02-permissions.md
-
-### Error Case
-
-If MCP call fails or `{mcp_available}` = false:
-- Log the error for reference
-- Proceed to FALLBACK PROCEDURE below
-- Do NOT stop the workflow
-
----
-
-## CLIENT PROJECT HANDLING
-
-> **Condition:** `{seeding_strategy}` = "provider"
-
-For client projects, navigation is NOT seeded via HasData() in Configuration files.
-It will be seeded at runtime via `IClientSeedDataProvider` generated at step 03b.
-
-### Actions for a client project:
-
-1. **Generate the navigation GUID** (deterministic, same method as core)
-2. **Create the SeedData file** (same pattern as existing)
-   - `Infrastructure/Persistence/Seeding/Data/{Domain}/{Module}NavigationSeedData.cs`
-   - Contains static GUIDs and `GetNavigationEntries()`
-3. **Create the translations file**
-   - `Infrastructure/Persistence/Seeding/Data/{Domain}/{Module}NavigationTranslationSeedData.cs`
-4. **DO NOT search for** `NavigationModuleConfiguration.cs` (does not exist in client projects)
-5. **DO NOT write** HasData() in Configuration files
-6. **Store** `{navigation_guid}` for subsequent steps
-
-The SeedData files will be consumed by the `IClientSeedDataProvider` generated at step 03b.
-
-**After creating SeedData files:** Store `{navigation_guid}` and proceed to step-02-permissions.md.
-
----
-
-## FALLBACK PROCEDURE (When MCP Unavailable)
-
-See [references/nav-fallback-procedure.md](../references/nav-fallback-procedure.md) for the complete 8-step fallback:
-- **F1:** Read existing Configuration/SeedData files to determine state
-- **F2:** Determine parent GUID by level
-- **F3:** Generate random GUID via Guid.NewGuid()
-- **F4:** Write navigation entity seed (SeedData class or inline HasData)
-- **F5:** Write 4 translation entries (continue existing index sequence)
-- **F6-F8:** Store result, validation checklist, summary
-
----
-
-## SUCCESS METRICS
-
-- Navigation entity GUID obtained (via MCP or fallback)
-- HasData code WRITTEN to Configuration files
-- Translation code WRITTEN (4 languages)
-- `{navigation_guid}` stored for step-02
-- Proceeded to step-02-permissions.md
-
-## FAILURE MODES
-
-- Missing parent path for non-application level (return to step-00)
-- Invalid level (return to step-00)
-- Parent entity not found in existing seeds (ask user for parent GUID)
-
----
-
-## NEXT STEP
-
-After navigation seeds are generated (via MCP or fallback) and written to files,
-proceed to `./step-02-permissions.md`

package/templates/skills/application/steps/step-02-permissions.md

@@ -1,196 +0,0 @@
----
-name: step-02-permissions
-description: Generate RBAC permissions using MCP generate_permissions
-prev_step: steps/step-01-navigation.md
-next_step: steps/step-03-roles.md
----
-
-# Step 2: Permissions Generation
-
-## MANDATORY EXECUTION RULES
-
-- ALWAYS use MCP `generate_permissions` tool - NEVER use templates
-- ALWAYS generate BOTH Permissions.cs constants AND PermissionConfiguration.cs HasData
-- NEVER skip this step - permissions are MANDATORY for security
-- YOU ARE AN ORCHESTRATOR calling MCP, not a generator
-
-## YOUR TASK
-
-Call the SmartStack MCP `generate_permissions` tool to generate:
-1. Permissions.cs nested class with constants
-2. PermissionConfiguration.cs HasData() entries
-
----
-
-## AVAILABLE STATE
-
-From previous steps:
-
-| Variable | Description |
-|----------|-------------|
-| `{level}` | application, module, section, or resource |
-| `{full_path}` | Complete navigation path (navRoute) |
-| `{navigation_guid}` | GUID of the navigation entity |
-| `{labels}` | Object with fr, en, it, de |
-| `{project_type}` | "core" or "client" |
-| `{seeding_strategy}` | "hasdata" or "provider" |
-
----
-
-## EXECUTION SEQUENCE
-
-### 1. Determine NavRoute
-
-For permissions, the navRoute is the `{full_path}`:
-
-```
-navRoute = "{full_path}"
-Example: "sales.products"
-```
-
-### 2. Call MCP generate_permissions
-
-```
-Tool: mcp__smartstack__generate_permissions
-Args:
-  navRoute: "{full_path}"
-  includeStandardActions: true
-  includeWildcard: true
-```
-
-### 3. Parse MCP Response
-
-The tool returns:
-- Permissions.cs nested class structure
-- PermissionConfiguration.cs HasData() entries
-- Random GUIDs via Guid.NewGuid() for each permission
-
-### 4. Present Permissions.cs Output
-
-```markdown
-## Permissions.cs Constants
-
-Add to `Application/Common/Authorization/Permissions.cs`:
-
-[Show Permissions.cs nested class from MCP response]
-
-**Usage in Controller:**
-```csharp
-[RequirePermission(Permissions.{Application}.{Module}.Read)]
-public async Task<ActionResult> GetAll() { ... }
-```
-```
-
-### 5. Present PermissionConfiguration.cs Output
-
-```markdown
-## PermissionConfiguration.cs HasData
-
-Add to `Infrastructure/Persistence/Configurations/PermissionConfiguration.cs`:
-
-[Show HasData entries from MCP response]
-```
-
-### 6. Store Permission GUIDs
-
-Store the permission GUIDs for use in step-03-roles:
-
-```
-{permission_guids} = {
-  wildcard: "guid-for-wildcard",
-  read: "guid-for-read",
-  create: "guid-for-create",
-  update: "guid-for-update",
-  delete: "guid-for-delete"
-}
-```
-
----
-
-## CLIENT PROJECT HANDLING
-
-> **Condition:** `{seeding_strategy}` = "provider"
-
-### 1. Call MCP generate_permissions normally
-
-The tool always returns:
-- Permissions.cs constants (Application layer) - **ALWAYS generated** (identical for core and client)
-- PermissionConfiguration.cs HasData - **REDIRECT for client projects**
-
-### 2. Permissions.cs: IDENTICAL
-
-The `Permissions.cs` file in the Application layer is generated identically regardless of project type.
-Write it as usual.
-
-### 3. PermissionConfiguration.cs: REDIRECT
-
-**For core (`{seeding_strategy}` = "hasdata"):** Write HasData() in `PermissionConfiguration.cs` (existing pattern)
-
-**For client (`{seeding_strategy}` = "provider"):** DO NOT write in PermissionConfiguration.cs (does not exist in client projects).
-Instead, create:
-- `Infrastructure/Persistence/Seeding/Data/{Domain}/{Module}PermissionSeedData.cs`
-
-Content: static class with `Guid.NewGuid()` and method `GetPermissionEntries()`.
-These entries will be consumed by the `IClientSeedDataProvider` at step 03b.
-
-### 4. Store Permission GUIDs
-
-Identical to the existing pattern - store `{permission_guids}` for step-03.
-
----
-
-## TWO-FILE REQUIREMENT
-
-**CRITICAL:** SmartStack requires permissions in TWO files:
-
-| File | Layer | Content |
-|------|-------|---------|
-| `Permissions.cs` | Application | Compile-time constants |
-| `PermissionConfiguration.cs` | Infrastructure | EF Core HasData seeds |
-
-Both MUST be kept in sync. Missing one = runtime 403 errors.
-
-> **Client project exception:** For `{seeding_strategy}` = "provider", `PermissionConfiguration.cs` is replaced by
-> `{Module}PermissionSeedData.cs` + `IClientSeedDataProvider`. The `Permissions.cs` constants file is still required.
-
----
-
-## MCP RESPONSE HANDLING
-
-### Success Case
-
-If MCP returns successfully:
-- Display Permissions.cs code
-- Display PermissionConfiguration.cs HasData code
-- Store `{permission_guids}` for next step
-- Proceed to step-03-roles.md
-
-### Error Case
-
-If MCP call fails:
-- Display error message
-- Suggest checking navRoute format
-- Do NOT proceed automatically
-
----
-
-## SUCCESS METRICS
-
-- MCP generate_permissions called successfully
-- Permissions.cs code displayed
-- PermissionConfiguration.cs HasData displayed
-- Random GUIDs via Guid.NewGuid() (not placeholders, not deterministic)
-- Permission GUIDs stored for role assignment
-- Proceeded to step-03-roles.md
-
-## FAILURE MODES
-
-- MCP call failed (display error, stop)
-- Invalid navRoute format (must be application.module.section)
-- Missing navigation entity (return to step-01)
-
----
-
-## NEXT STEP
-
-After displaying permission code, proceed to `./step-03-roles.md`

package/templates/skills/application/steps/step-03-roles.md

@@ -1,182 +0,0 @@
----
-name: step-03-roles
-description: Generate application roles and role-permission mappings using MCP scaffold_role_permissions (with fallback)
-prev_step: steps/step-02-permissions.md
-next_step: steps/step-03b-provider.md
----
-
-# Step 3: Application Roles & Role-Permission Mapping
-
-## MANDATORY EXECUTION RULES
-
-- For **client projects** (`seeding_strategy = "provider"`): Generate ApplicationRolesSeedData.cs and module role mappings
-- For **core projects** (`seeding_strategy = "hasdata"`): Use RolePermissionConfiguration.cs
-- PREFER MCP `scaffold_role_permissions` tool as the primary method
-- If MCP is unavailable or the call fails, use the FALLBACK PROCEDURE below
-- ALWAYS assign permissions to default roles
-- NEVER leave permissions without role assignments
-- ALWAYS WRITE generated code to the actual files
-
-## YOUR TASK
-
-For **client projects**:
-1. **ApplicationRolesSeedData.cs** (once per application) — defines the 4 application-scoped roles
-2. **{Module}RolePermissionSeedData.cs** (per module) — maps permissions to roles by Code
-
-For **core projects**:
-1. RolePermissionConfiguration.cs HasData() entries
-2. Default role assignments (SuperAdmin, PlatformAdmin, TenantAdmin, StandardUser)
-3. Application-scoped role assignments (Admin, Manager, Contributor, Viewer)
-
----
-
-## AVAILABLE STATE
-
-From previous steps:
-
-| Variable | Description |
-|----------|-------------|
-| `{full_path}` | Complete navigation path (navRoute) |
-| `{level}` | application, module, section, or resource |
-| `{permission_guids}` | GUIDs for generated permissions |
-| `{mcp_available}` | Boolean - MCP connectivity status |
-| `{project_type}` | "core" or "client" |
-| `{seeding_strategy}` | "hasdata" or "provider" |
-
----
-
-## EXECUTION SEQUENCE (MCP Primary)
-
-### 1. Determine Default Role Assignments
-
-See [references/roles-client-project-handling.md](../references/roles-client-project-handling.md) for:
-- Default role mapping table by application prefix
-- ApplicationRolesSeedData.cs requirements (once per application)
-- {Module}RolePermissionSeedData.cs requirements (per module)
-
-### 2. Call MCP scaffold_role_permissions
-
-```
-Tool: mcp__smartstack__scaffold_role_permissions
-Args:
-  navRoute: "{full_path}"
-  roles:
-    platformAdmin: ["read", "create", "update", "delete"]  # Adjust based on context
-    tenantAdmin: ["read", "create", "update"]              # Adjust based on context
-    standardUser: ["read"]                                  # Adjust based on context
-  includeWildcard: true
-```
-
-### 3. Parse MCP Response
-
-The tool returns:
-- RolePermissionConfiguration.cs HasData() entries
-- Permission ID variable references
-- Role ID variable references
-
-### 4. Write Code to Files
-
-**CRITICAL:** WRITE the generated code to the actual RolePermissionConfiguration.cs file.
-
-### 5. Present Summary
-
-```markdown
-## Role-Permission Mappings
-
-| Role | Permissions |
-|------|-------------|
-| SuperAdmin | `{full_path}.*` (via wildcard) |
-| PlatformAdmin | `{full_path}.read`, `.create`, `.update`, `.delete` |
-| TenantAdmin | `{full_path}.read`, `.create`, `.update` |
-| StandardUser | `{full_path}.read` |
-```
-
-### 6. Confirm with User (Optional)
-
-```yaml
-questions:
-  - header: "Role Access"
-    question: "Adjust role permissions for {full_path}?"
-    options:
-      - label: "Keep defaults (Recommended)"
-        description: "PlatformAdmin: CRUD, TenantAdmin: CRU, StandardUser: R"
-      - label: "All roles full access"
-        description: "All roles get full CRUD access"
-      - label: "Custom"
-        description: "I'll specify custom permissions"
-    multiSelect: false
-```
-
----
-
-## MCP RESPONSE HANDLING
-
-### Success Case
-
-If MCP returns successfully:
-- Write RolePermission HasData code to file
-- Show role-permission summary table
-- Proceed to step-04-backend.md
-
-### Error Case
-
-If MCP call fails or `{mcp_available}` = false:
-- Log the error for reference
-- Proceed to FALLBACK PROCEDURE below
-- Do NOT stop the workflow
-
----
-
-## CLIENT PROJECT HANDLING
-
-> **Condition:** `{seeding_strategy}` = "provider"
-
-See [references/roles-client-project-handling.md](../references/roles-client-project-handling.md) for:
-- ApplicationRolesSeedData.cs creation (once per application)
-- {Module}RolePermissionSeedData.cs creation (per module)
-- Role code naming and GUID generation rules
-- Detection of existing ApplicationRolesSeedData.cs
-
----
-
-## FALLBACK PROCEDURE (When MCP Unavailable)
-
-See [references/roles-fallback-procedure.md](../references/roles-fallback-procedure.md) for the complete 7-step fallback:
-- **F1:** Read existing RolePermissionConfiguration.cs to determine state
-- **F2:** Read role GUIDs (system-level and application-scoped)
-- **F3:** Determine default mappings based on application prefix
-- **F4:** Generate RolePermission HasData entries using permission GUIDs
-- **F5:** Write code to RolePermissionConfiguration.cs (CRITICAL: WRITE not display)
-- **F6:** Present summary
-- **F7:** Offer user adjustment option
-
----
-
-## SUCCESS METRICS
-
-**For client projects:**
-- ApplicationRolesSeedData.cs created (once per application)
-- {Module}RolePermissionSeedData.cs created with role-permission mappings
-- All 4 application roles defined with valid Code values
-- Proceeded to step-03b-provider.md
-
-**For core projects:**
-- Role-permission mappings generated (via MCP or fallback)
-- RolePermissionConfiguration.cs WRITTEN with new entries
-- All default roles have appropriate access
-- Proceeded to step-04-backend.md
-
-## FAILURE MODES
-
-- Permission GUIDs not available from step-02 (return to step-02)
-- Role GUIDs not found in project (ask user, use well-known defaults)
-- Invalid navRoute format (return to step-00)
-
----
-
-## NEXT STEP
-
-After role-permission mappings are generated (via MCP or fallback) and written to files,
-proceed to `./step-03b-provider.md`
-
-> **Note:** step-03b will automatically skip if `{seeding_strategy}` = "hasdata" and proceed directly to step-04-backend.

package/templates/skills/application/steps/step-03b-provider.md

@@ -1,134 +0,0 @@
----
-name: step-03b-provider
-description: Generate IClientSeedDataProvider implementation for client projects
-prev_step: steps/step-03-roles.md
-next_step: steps/step-04-backend.md
----
-
-# Step 3b: Client Seed Data Provider (Client Projects Only)
-
-## CONDITION D'EXECUTION
-
-> This step executes ONLY if `{seeding_strategy}` = "provider" (client project).
-> If `{seeding_strategy}` = "hasdata", skip directly to step-04-backend.md.
-
-## MANDATORY EXECUTION RULES
-
-- ONLY execute for client projects (`{seeding_strategy}` = "provider")
-- ALWAYS use factory methods (`NavigationModule.Create(...)`, etc.) - NEVER `new Entity()`
-- ALWAYS implement idempotence (check existence before inserting)
-- ALWAYS register the provider in DI
-- ALWAYS consume the SeedData classes created in steps 01-03
-
-## YOUR TASK
-
-Generate the `IClientSeedDataProvider` implementation that wires the SeedData files
-created in steps 01, 02, 03 into the SmartStack Core seeding pipeline.
-
----
-
-## AVAILABLE STATE
-
-From previous steps:
-
-| Variable | Description |
-|----------|-------------|
-| `{level}` | application, module, section, or resource |
-| `{code}` | kebab-case identifier |
-| `{full_path}` | Complete navigation path |
-| `{labels}` | Object with fr, en, it, de |
-| `{descriptions}` | Object with fr, en, it, de |
-| `{icon}` | Lucide icon name |
-| `{display_order}` | Numeric display order |
-| `{navigation_guid}` | GUID of the navigation entity |
-| `{permission_guids}` | GUIDs for generated permissions |
-| `{project_type}` | "client" (guaranteed at this step) |
-| `{seeding_strategy}` | "provider" (guaranteed at this step) |
-
----
-
-## FILES TO GENERATE
-
-See [references/provider-template.md](../references/provider-template.md) for the complete implementation:
-- **ApplicationRolesSeedData.cs** (once per application) — defines application-scoped roles (Admin, Manager, Contributor, Viewer)
-- **Provider class** (`{AppPascalName}SeedDataProvider.cs`) with 4 seed methods (Navigation, Roles, Permissions, RolePermissions)
-- **DI registration** pattern for `Infrastructure/DependencyInjection.cs`
-- **7 critical rules** (factory methods, idempotence, execution order, SaveChangesAsync order, deterministic GUIDs, FK by Code, Order property)
-
----
-
-## EXECUTION SEQUENCE
-
-### 1. Read SeedData files from steps 01-03
-
-Identify all SeedData files created in previous steps:
-
-```
-Glob: **/Persistence/Seeding/Data/{Domain}/*SeedData.cs
-Glob: **/Persistence/Seeding/Data/ApplicationRolesSeedData.cs
-```
-
-Expected files:
-- `ApplicationRolesSeedData.cs` (application-level, once per app)
-- `{Module}NavigationSeedData.cs` (from step 01)
-- `{Module}NavigationTranslationSeedData.cs` (from step 01)
-- `{Module}PermissionSeedData.cs` (from step 02)
-- `{Module}RolePermissionSeedData.cs` (from step 03)
-
-### 2. Generate Provider Class
-
-Using the SeedData files as data sources, generate the `{AppPascalName}SeedDataProvider.cs` following the pattern above.
-
-Adapt the template:
-- Replace `{AppPascalName}` with the PascalCase application name
-- Replace `{app_code}` with the kebab-case application code
-- Fill in the actual navigation, permission, and role-permission creation logic
-  using the helper methods from the SeedData classes
-- **CRITICAL:** Follow the 7 critical rules: factory methods, idempotence, execution order, SaveChangesAsync order, random GUIDs via Guid.NewGuid(), FK by Code, Order property
-
-### 3. Register in DI
-
-Find and update `Infrastructure/DependencyInjection.cs`:
-
-```
-Glob: **/Infrastructure/DependencyInjection.cs
-```
-
-Add the `IClientSeedDataProvider` registration.
-
-### 4. Verify
-
-Before proceeding to step-04, verify:
-- [ ] ApplicationRolesSeedData.cs created (once per application)
-- [ ] Provider generated with 4 methods (SeedNavigationAsync, SeedRolesAsync, SeedPermissionsAsync, SeedRolePermissionsAsync)
-- [ ] Execution order: Navigation → Roles → Permissions → RolePermissions
-- [ ] Registered in DI (`services.AddScoped<IClientSeedDataProvider, ...>()`)
-- [ ] Consumes SeedData classes from steps 01-03 + ApplicationRolesSeedData
-- [ ] Idempotent (check existence before insert)
-- [ ] Uses factory methods (no `new Entity()`)
-
----
-
-## SUCCESS METRICS
-
-- ApplicationRolesSeedData.cs created (application-level)
-- Provider class generated with all 4 seed methods (Navigation, Roles, Permissions, RolePermissions)
-- Correct execution order enforced
-- DI registration added
-- SeedData classes from steps 01-03 + ApplicationRolesSeedData properly consumed
-- All methods are idempotent
-- Factory methods used throughout
-- Proceeded to step-04-backend.md
-
-## FAILURE MODES
-
-- SeedData files not found from previous steps (return to step-01)
-- DependencyInjection.cs not found (ask user for DI registration location)
-- Missing IClientSeedDataProvider interface (verify SmartStack.Application reference)
-
----
-
-## NEXT STEP
-
-After generating the provider and registering it in DI,
-proceed to `./step-04-backend.md`