@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/controller/steps/step-00-init.md

@@ -1,193 +0,0 @@
----
-name: step-00-init
-description: Initialize controller generation - parse arguments, validate inputs, setup state
-next_step: steps/step-01-analyze.md
----
-
-# Step 0: Initialization
-
-## MANDATORY EXECUTION RULES:
-
-- NEVER skip argument parsing
-- ALWAYS validate area is valid (Admin, Support, Business, User, Auth)
-- YOU ARE AN INITIALIZER, not a generator
-- FORBIDDEN to load step-01 until init is complete
-
-## YOUR TASK:
-
-Parse arguments, validate inputs, and initialize state variables for controller generation.
-
----
-
-<defaults>
-## Default Configuration
-
-```yaml
-auto_mode: false      # -a: Skip confirmations
-postman_mode: false   # -p: Generate Postman tests
-dto_mode: false       # -d: Generate DTOs
-interactive_mode: false # -i: Configure via menu
-```
-</defaults>
-
----
-
-## EXECUTION SEQUENCE:
-
-### 1. Parse Flags and Input
-
-**Step 1: Load defaults from config above**
-
-```
-{auto_mode}        = false
-{postman_mode}     = false
-{dto_mode}         = false
-{interactive_mode} = false
-```
-
-**Step 2: Parse user input and override defaults:**
-
-```
-Enable flags (lowercase - turn ON):
-  -a or --auto      -> {auto_mode} = true
-  -p or --postman   -> {postman_mode} = true
-  -d or --dtos      -> {dto_mode} = true
-  -i or --interactive -> {interactive_mode} = true
-
-Disable flags (UPPERCASE - turn OFF):
-  -A or --no-auto     -> {auto_mode} = false
-  -P or --no-postman  -> {postman_mode} = false
-  -D or --no-dtos     -> {dto_mode} = false
-
-Arguments (after flags removed):
-  First word  -> {area}
-  Second word -> {module}
-  Third word  -> {entity} (optional, default = singularize({module}))
-```
-
-### 2. Validate Area
-
-**Valid areas:**
-
-| Area | Route Resolution | Permission Path Prefix |
-|------|-----------------|----------------------|
-| `Admin` | NavRoute(`administration.{module}`) | `administration.` |
-| `Support` | NavRoute(`support.{module}`) | `support.` |
-| `Business` | NavRoute(`{application}.{module}`) | `{application}.` |
-| `User` | NavRoute(`myspace.{module}`) | `myspace.` |
-| `Auth` | `api/auth/` | (AllowAnonymous) |
-
-> **Note:** All areas except Auth use `[NavRoute]` for dynamic route resolution from the navigation database. There are no hardcoded API prefixes like `api/business/`.
-
-**If {area} missing or invalid:**
-
-```yaml
-AskUserQuestion:
-  header: "Area"
-  question: "Which area for the controller?"
-  options:
-    - label: "Admin"
-      description: "Administration controllers (NavRoute)"
-    - label: "Support"
-      description: "Support features (NavRoute)"
-    - label: "Business"
-      description: "Business application modules (NavRoute)"
-    - label: "User"
-      description: "User-facing features (NavRoute)"
-```
-
-### 3. Validate Module
-
-**If {module} missing:**
-
-```yaml
-AskUserQuestion:
-  header: "Module"
-  question: "What is the module name? (PascalCase, e.g., Tickets, Users)"
-  # Free text input
-```
-
-**Normalize:**
-- Convert to PascalCase
-- Example: "tickets" → "Tickets", "user-roles" → "UserRoles"
-
-### 4. Derive Entity Name
-
-**If {entity} not provided:**
-
-```
-{entity} = singularize({module})
-
-Examples:
-  Users → User
-  Tickets → Ticket
-  Categories → Category
-  SlaDefinitions → SlaDefinition
-```
-
-### 5. Compute Permission Path
-
-**Based on {area}:**
-
-```
-Admin    → {permission_path} = "administration.{module_lowercase}"
-Support  → {permission_path} = "support.{module_lowercase}"
-Business → {permission_path} = "{application_lowercase}.{module_lowercase}"
-User     → {permission_path} = "myspace.{module_lowercase}"
-Auth     → {permission_path} = null (AllowAnonymous)
-```
-
-### 6. Interactive Mode (if -i flag)
-
-If `{interactive_mode}` = true:
-
-```yaml
-questions:
-  - header: "Configure"
-    question: "Select options for controller generation:"
-    options:
-      - label: "Auto mode (-a)"
-        description: "Skip all confirmations"
-      - label: "Postman tests (-p)"
-        description: "Generate Postman test collection"
-      - label: "DTOs (-d)"
-        description: "Generate CreateDto, UpdateDto, ResponseDto"
-    multiSelect: true
-```
-
-### 7. Show Summary and Proceed
-
-**Always show COMPACT summary:**
-
-```
-Controller: {area}/{module}Controller
-
-| Variable | Value |
-|----------|-------|
-| {area} | Admin |
-| {module} | Users |
-| {entity} | User |
-| {permission_path} | administration.users |
-| {auto_mode} | true/false |
-| {postman_mode} | true/false |
-| {dto_mode} | true/false |
-
--> Analyzing codebase...
-```
-
-**Then proceed directly to step-01-analyze.md**
-
----
-
-## SUCCESS METRICS:
-
-- All arguments correctly parsed
-- Area validated against allowed values
-- Module/Entity derived correctly
-- Permission path computed
-- Output is COMPACT (one table)
-- Proceeded to step-01 immediately after summary
-
-## NEXT STEP:
-
-After showing initialization summary, always proceed directly to `./step-01-analyze.md`

package/templates/skills/controller/steps/step-01-analyze.md

@@ -1,152 +0,0 @@
----
-name: step-01-analyze
-description: Analyze existing codebase - find Entity, DbContext, patterns
-next_step: steps/step-02-plan.md
----
-
-# Step 1: Analyze Codebase
-
-## YOUR TASK:
-
-Gather all context needed to generate the controller. Find the Entity, check DbContext, analyze existing patterns.
-
-**ULTRA THINK before searching.**
-
----
-
-## EXECUTION SEQUENCE:
-
-### 1. Find Entity Domain
-
-**Search for entity file:**
-
-1. Read `.smartstack/config.json` → use `paths.domain` if available
-2. Otherwise, use wildcard on project name:
-```
-Glob: "src/*Domain*/**/{entity}.cs"
-Glob: "src/*Domain*/**/{entity}s.cs"
-```
-3. Fallback (if no match):
-```
-Glob: "src/**/{entity}.cs" with ignore "**/obj/**,**/bin/**,**/Tests/**"
-```
-
-**Extract from Entity:**
-- Properties (for DTO generation)
-- Factory method signature `Create(...)`
-- Update method signature `Update(...)`
-- Relationships (navigation properties)
-- Base class (BaseEntity, AuditableEntity, TenantEntity)
-
-**If Entity NOT found:**
-```
-STOP - Entity {entity} not found in Domain layer.
-Create entity first using /application skill to add the entity to Domain
-```
-
-### 2. Check DbContext
-
-**Verify DbSet exists:**
-
-```
-Grep: "DbSet<{entity}>" in IApplicationDbContext.cs
-```
-
-**If DbSet NOT found:**
-```
-WARNING: DbSet<{entity}> not in DbContext.
-Will need to add: DbSet<{entity}> {module} { get; }
-```
-
-### 3. Analyze Existing Permissions
-
-**Check current permissions:**
-
-```
-Read: src/SmartStack.Application/Common/Authorization/Permissions.cs
-```
-
-**Look for:**
-- Existing permission class for this module
-- Permission naming pattern used
-- Nested class structure
-
-### 4. Find Similar Controllers
-
-**Find reference controllers in same area:**
-
-```
-Glob: "src/SmartStack.Api/Controllers/{area}/*.cs"
-```
-
-**Extract patterns from existing controllers:**
-- Constructor injection pattern
-- Base class used
-- Common attributes
-- Response type patterns
-- Error handling patterns
-
-### 5. Check for Existing Controller
-
-**Verify controller doesn't exist:**
-
-```
-Glob: "src/SmartStack.Api/Controllers/{area}/{module}Controller.cs"
-```
-
-**If EXISTS:**
-```
-WARNING: Controller already exists!
-Options:
-1. Overwrite (will backup existing)
-2. Abort generation
-```
-
-### 6. Compile Analysis Report
-
-**Store in state:**
-
-```
-{entity_found}       = true/false
-{entity_path}        = "src/SmartStack.Domain/..."
-{entity_properties}  = [list of properties]
-{entity_base_class}  = "TenantEntity" | "AuditableEntity" | "BaseEntity"
-{dbset_exists}       = true/false
-{permissions_exist}  = true/false
-{similar_controller} = "path/to/similar.cs" (for reference)
-{controller_exists}  = true/false
-```
-
----
-
-## OUTPUT FORMAT:
-
-```
-Analysis Complete:
-
-| Check | Status | Details |
-|-------|--------|---------|
-| Entity | ✅/❌ | {entity_path} |
-| DbSet | ✅/❌ | DbSet<{entity}> |
-| Permissions | ✅/❌ | {permission_path}.* |
-| Reference | ✅ | {similar_controller} |
-| Existing | ⚠️/✅ | Controller exists/new |
-
-Entity Properties:
-- Id (Guid)
-- Name (string)
-- ... (extracted from entity)
-
--> Planning controller structure...
-```
-
----
-
-## BLOCKING CONDITIONS:
-
-- **Entity not found** → STOP, suggest creating entity first
-- **Controller exists + auto_mode=false** → ASK user to confirm overwrite
-
-## NEXT STEP:
-
-After analysis complete, proceed to `./step-02-plan.md`

package/templates/skills/controller/steps/step-02-plan.md

@@ -1,176 +0,0 @@
----
-name: step-02-plan
-description: Plan controller structure - endpoints, DTOs, permissions
-next_step: steps/step-03-generate.md
----
-
-# Step 2: Plan Controller Structure
-
-## YOUR TASK:
-
-Design the complete controller structure based on analysis. Define endpoints, DTOs, and permissions.
-
-**ULTRA THINK about REST conventions and SmartStack patterns.**
-
----
-
-## EXECUTION SEQUENCE:
-
-### 1. Determine Controller Type
-
-**Based on {area} and analysis:**
-
-| Indicator | → Controller Type |
-|-----------|-------------------|
-| Area = Auth | `auth` (login, logout, tokens) |
-| Entity has all CRUD methods | `crud` (full CRUD) |
-| Entity missing Create/Update | `readonly` (GET only) |
-| User specifies custom | `custom` (specific endpoints) |
-
-**If not auto_mode, confirm:**
-
-```yaml
-AskUserQuestion:
-  header: "Type"
-  question: "What type of controller?"
-  options:
-    - label: "CRUD Complet (Recommended)"
-      description: "GET list, GET by ID, POST, PUT, PATCH, DELETE"
-    - label: "Read-Only"
-      description: "GET list, GET by ID only"
-    - label: "Custom"
-      description: "I'll specify the endpoints"
-```
-
-### 2. Plan Endpoints
-
-**For CRUD controller:**
-
-| Method | Route | Action | Permission |
-|--------|-------|--------|------------|
-| GET | `/{module}` | GetAll | `{permission_path}.read` |
-| GET | `/{module}/{id}` | GetById | `{permission_path}.read` |
-| POST | `/{module}` | Create | `{permission_path}.create` |
-| PUT | `/{module}/{id}` | Update | `{permission_path}.update` |
-| PATCH | `/{module}/{id}/status` | UpdateStatus | `{permission_path}.update` |
-| DELETE | `/{module}/{id}` | Delete | `{permission_path}.delete` |
-
-**For Auth controller:**
-
-| Method | Route | Action | Permission |
-|--------|-------|--------|------------|
-| POST | `/auth/login` | Login | AllowAnonymous |
-| POST | `/auth/logout` | Logout | Authorize |
-| POST | `/auth/refresh` | RefreshToken | AllowAnonymous |
-| POST | `/auth/change-password` | ChangePassword | Authorize |
-
-### 3. Plan DTOs (if dto_mode)
-
-**CreateDto:**
-```
-{entity}CreateDto:
-  - Required properties from Entity.Create()
-  - Validation attributes
-  - No Id, CreatedAt, etc.
-```
-
-**UpdateDto:**
-```
-{entity}UpdateDto:
-  - Updatable properties from Entity.Update()
-  - Validation attributes
-  - No Id, audit fields
-```
-
-**ResponseDto:**
-```
-{entity}ResponseDto:
-  - All public properties
-  - Formatted dates
-  - Nested DTOs for relationships
-```
-
-### 4. Plan Permissions
-
-**Permission structure:**
-
-```csharp
-public static class {module}
-{
-    public const string View = "{permission_path}.read";
-    public const string Create = "{permission_path}.create";
-    public const string Update = "{permission_path}.update";
-    public const string Delete = "{permission_path}.delete";
-}
-```
-
-**Permission seeds:**
-
-```csharp
-new Permission { Code = "{permission_path}.read", Name = "View {module}", ... }
-new Permission { Code = "{permission_path}.create", Name = "Create {module}", ... }
-new Permission { Code = "{permission_path}.update", Name = "Update {module}", ... }
-new Permission { Code = "{permission_path}.delete", Name = "Delete {module}", ... }
-```
-
-### 5. Plan Services to Inject
-
-**Required services:**
-
-| Service | Required | Reason |
-|---------|----------|--------|
-| `IApplicationDbContext` | Always | DB access |
-| `ICurrentUserService` | Always | User context |
-| `ILogger<T>` | Always | Logging |
-| `IPermissionService` | If roles/perms | Cache invalidation |
-| `IPasswordService` | If auth | Password hashing |
-| `IJwtService` | If auth | Token generation |
-
-### 6. Confirmation (if not auto_mode)
-
-**Show plan for approval:**
-
-```
-Controller Plan: {area}/{module}Controller
-
-Endpoints:
-  GET    /api/{area}/{module}           → GetAll
-  GET    /api/{area}/{module}/{id}      → GetById
-  POST   /api/{area}/{module}           → Create
-  PUT    /api/{area}/{module}/{id}      → Update
-  DELETE /api/{area}/{module}/{id}      → Delete
-
-DTOs: {dto_mode ? "CreateDto, UpdateDto, ResponseDto" : "None (inline)"}
-
-Permissions:
-  {permission_path}.read
-  {permission_path}.create
-  {permission_path}.update
-  {permission_path}.delete
-
-Proceed with generation?
-```
-
----
-
-## OUTPUT FORMAT:
-
-```
-Plan Complete:
-
-| Aspect | Details |
-|--------|---------|
-| Type | {controller_type} |
-| Endpoints | {endpoint_count} |
-| DTOs | {dto_count} |
-| Permissions | 4 (CRUD) |
-| Services | {service_count} |
-
--> Generating controller...
-```
-
----
-
-## NEXT STEP:
-
-After plan confirmed (or auto_mode), proceed to `./step-03-generate.md`

package/templates/skills/controller/steps/step-03-generate.md

@@ -1,189 +0,0 @@
----
-name: step-03-generate
-description: Generate controller using MCP scaffold_extension with NavRoute
-next_step: steps/step-04-perms.md
----
-
-# Step 3: Generate Controller
-
-## MANDATORY EXECUTION RULES
-
-- ALWAYS use MCP `scaffold_extension` tool - NEVER use templates
-- ALWAYS generate Controller + DTOs as a unit
-- ALWAYS include NavRoute attribute for frontend/backend sync
-- YOU ARE AN ORCHESTRATOR calling MCP, not a generator
-- MCP is the SOURCE OF TRUTH for code generation
-
-## YOUR TASK
-
-Call the SmartStack MCP `scaffold_extension` tool (TWO calls):
-1. Generate DTOs (Response, Create, Update)
-2. Generate API Controller with NavRoute attribute
-
----
-
-## AVAILABLE STATE
-
-From previous steps:
-
-| Variable | Description |
-|----------|-------------|
-| `{area}` | Controller folder (Admin, Business, Support, User) |
-| `{module}` | kebab-case module identifier |
-| `{entity}` | Entity name (PascalCase) |
-| `{permission_path}` | Complete navigation path (navRoute) |
-| `{controller_type}` | crud, readonly, custom, auth |
-
----
-
-## EXECUTION SEQUENCE
-
-### 1. Derive Entity Name
-
-Convert `{module}` to PascalCase for entity name:
-
-```
-module: "products"        → entityName: "Product"
-module: "order-items"     → entityName: "OrderItem"
-module: "user-profiles"   → entityName: "UserProfile"
-```
-
-### 2. Determine Table Prefix
-
-Based on navigation context extracted from `{permission_path}`:
-
-| Application | Table Prefix | Controller Folder |
-|-------------|--------------|-------------------|
-| administration | `auth_` or `cfg_` | `Administration` |
-| support | `support_` | `Support` |
-| {application} | `ref_` or domain-specific | `{ApplicationPascal}` |
-| myspace | `usr_` | `MySpace` |
-
-### 3. Call MCP scaffold_extension (TWO CALLS)
-
-See `references/mcp-scaffold-workflow.md` for complete MCP workflow, error handling, and post-generation checks.
-
-**Call 1: Generate DTOs**
-```javascript
-mcp__smartstack__scaffold_extension({
-  type: "dto",
-  name: "{entityName}",
-  options: {
-    navRoute: "{permission_path}",
-    schema: "core",
-    dryRun: false
-  }
-});
-```
-
-**Call 2: Generate Controller**
-```javascript
-mcp__smartstack__scaffold_extension({
-  type: "controller",
-  name: "{entityName}",
-  options: {
-    navRoute: "{permission_path}",  // MANDATORY for NavRoute attribute
-    navRouteSuffix: null,
-    dryRun: false
-  }
-});
-```
-
-### 4. Parse MCP Responses
-
-**From first call (DTOs):**
-- `Application/{Application}/{Module}/DTOs/{entityName}ResponseDto.cs`
-- `Application/{Application}/{Module}/DTOs/Create{entityName}Dto.cs`
-- `Application/{Application}/{Module}/DTOs/Update{entityName}Dto.cs`
-
-**From second call (Controller):**
-- `Api/Controllers/{area}/{entityName}Controller.cs` with **[NavRoute]** attribute
-
-### 5. Present Output to User
-
-```markdown
-## Controller Generated via MCP
-
-### API Layer
-- `Controllers/{area}/{entityName}Controller.cs`
-  - **NavRoute: `{permission_path}`** ✅
-  - Endpoints: GET /api/{module}, POST, PUT, DELETE
-
-### Application Layer (DTOs)
-- `{entityName}ResponseDto.cs`
-- `Create{entityName}Dto.cs`
-- `Update{entityName}Dto.cs`
-
-### ✅ NavRoute Integration
-- [NavRoute("{permission_path}")] attribute present
-- Frontend/backend sync enabled
-- Permission-based navigation ready
-
-Next: step-04-perms.md
-```
-
----
-
-## MCP RESPONSE HANDLING
-
-### Success Case
-
-**After Call 1 (DTOs):**
-- Display all generated DTO files
-- Verify DTOs match entity properties
-- Continue to Call 2
-
-**After Call 2 (Controller):**
-- Display controller file with NavRoute
-- Show frontend/backend sync enabled
-- Proceed to step-04-perms.md
-
-### Error Case
-
-**If Call 1 (DTOs) fails:**
-- Display error message
-- Suggest checking entity name format (must be PascalCase)
-- Verify entity properties are defined
-- Do NOT proceed to Call 2
-
-**If Call 2 (Controller) fails:**
-- Display error message
-- Note that DTOs were generated successfully
-- Suggest checking navRoute format
-- Do NOT proceed to step-04-perms.md
-
----
-
-## NAVROUTE VALIDATION
-
-Verify NavRoute is present (from `references/mcp-scaffold-workflow.md`):
-
-```javascript
-if (!controllerContent.includes('[NavRoute(')) {
-  console.error(`NavRoute attribute NOT FOUND`);
-  console.error(`Expected: [NavRoute("${permission_path}")]`);
-  STOP;
-}
-```
-
-Without NavRoute:
-- ❌ Frontend routes hardcoded
-- ❌ No automatic permission sync
-- ❌ Manual navigation required
-
----
-
-## SUCCESS METRICS
-
-- MCP scaffold_extension called twice (DTOs, then Controller)
-- DTOs generated (ResponseDto, CreateDto, UpdateDto)
-- Controller generated with **[NavRoute]** attribute
-- NavRoute matches permission_path
-- Controller references DTOs correctly
-- Proceeded to step-04-perms.md
-
----
-
-## NEXT STEP:
-
-After controller generation complete, proceed to `./step-04-perms.md`