@atlashub/smartstack-cli 3.39.0 → 3.40.0

package/templates/skills/feature-full/SKILL.md

@@ -1,111 +1,111 @@
----
-name: feature-full
-description: |
-  Creates a complete SmartStack feature with all integrations.
-  Use this skill when:
-  - User wants to create a complete feature from A to Z
-  - User mentions "oneshot", "complete feature", "full-stack"
-  - Creating a module with notifications, workflows and/or AI
-  - Need for complete user experience
-  Scope: Domain -> Application -> Infrastructure -> API -> Web + Notifications + Workflows + AI
-disable-model-invocation: true
----
-
-# Skill Feature Full SmartStack
-
-> **OneShot Development:** Orchestrates all skills for a complete feature.
-
-**Reference:** [_shared.md](../_shared.md) for architecture, permissions, i18n
-
-## When This Skill Activates
-
-| Trigger | Example |
-|---------|---------|
-| Complete feature | "Create a product management module" |
-| Full-stack | "Create the backend and frontend for..." |
-| Integration | "With notifications and automated emails" |
-
-## Complete Flow
-
-```
-DOMAIN -> APPLICATION -> INFRASTRUCTURE -> API -> WEB
-                      + NOTIFICATIONS + WORKFLOWS + AI
-```
-
-## Phase 1: Analysis
-
-```
-- Module/functionality?
-- Entities? CRUD operations? Business rules?
-- Notifications required? Automated emails? AI?
-- Display: Cards/Table/Kanban? Permissions?
-```
-
-## Phases 2-7: Implementation
-
-Start with [steps/step-00-init.md](steps/step-00-init.md) to analyze requirements and existing patterns, then proceed to [steps/step-01-implementation.md](steps/step-01-implementation.md) for detailed code templates covering:
-- Phase 2: Domain (Entity + Factory + Behaviors + Enum)
-- Phase 3: Application (Interface + DTOs + Permissions)
-- Phase 4: Infrastructure (EF Config + Service + DI)
-- Phase 5: API (Controller + Authorize + RequirePermission)
-- Phase 6: Frontend (API + Hook + Page + Routes)
-- Phase 7: Integrations (Notifications + Workflows + AI)
-
-## Complete Checklist
-
-### Backend
-```
-- Domain: Entity + Factory + Behaviors + Enum + IAuditableEntity
-- Application: Interface + DTOs + Permissions (2 files!)
-- Infrastructure: EF Config + Service + DI + DbSet + Migration
-- API: Controller + Authorize + RequirePermission + ProducesResponseType
-```
-
-### Frontend
-```
-- {module}Api.ts + use{Module}.ts (with SignalR) + {Module}Page.tsx + {Module}Form.tsx
-- i18n: fr, en, it, de
-- Nested routes in App.tsx
-```
-
-### Integrations
-```
-- Notifications: NotificationType + SendNotificationAsync + useSignalR
-- Workflows: Trigger + Workflow + TriggerAsync
-- AI: Prompt + OutputSchema + ExecutePromptAsync
-```
-
-### Validation
-```
-- dotnet build + npm run build + npm run lint OK
-```
-
-## Orchestrated Skills
-
-| Skill | Phase |
-|-------|-------|
-| `/application` | 2-6 |
-| `/controller` | 5 |
-| `/notification` | 7.1 |
-| `/workflow` | 7.2 |
-| `/ai-prompt` | 7.3 |
-| `/ui-components` | 6 |
-| `/efcore:migration` | 4 |
-
-## Absolute Rules
-
-| DO | DON'T |
-|----|-------|
-| Layered architecture | Direct frontend DB access |
-| Entity Factory Methods | Hardcoded permission strings |
-| Permissions 2 files | Flat routes |
-| SignalR hooks | Skip i18n 4 languages |
-| ProducesResponseType | Skip logging |
-
-<success_criteria>
-- All layers created: Domain, Infrastructure, Application, API, Frontend
-- Navigation, permissions, and roles seed data generated via MCP
-- EF Core migration created and applied
-- Tests pass (unit + integration)
-- i18n translations in 4 languages
-</success_criteria>
+---
+name: feature-full
+description: |
+  Creates a complete SmartStack feature with all integrations.
+  Use this skill when:
+  - User wants to create a complete feature from A to Z
+  - User mentions "oneshot", "complete feature", "full-stack"
+  - Creating a module with notifications, workflows and/or AI
+  - Need for complete user experience
+  Scope: Domain -> Application -> Infrastructure -> API -> Web + Notifications + Workflows + AI
+disable-model-invocation: true
+---
+
+# Skill Feature Full SmartStack
+
+> **OneShot Development:** Orchestrates all skills for a complete feature.
+
+**Reference:** [_shared.md](../_shared.md) for architecture, permissions, i18n
+
+## When This Skill Activates
+
+| Trigger | Example |
+|---------|---------|
+| Complete feature | "Create a product management module" |
+| Full-stack | "Create the backend and frontend for..." |
+| Integration | "With notifications and automated emails" |
+
+## Complete Flow
+
+```
+DOMAIN -> APPLICATION -> INFRASTRUCTURE -> API -> WEB
+                      + NOTIFICATIONS + WORKFLOWS + AI
+```
+
+## Phase 1: Analysis
+
+```
+- Module/functionality?
+- Entities? CRUD operations? Business rules?
+- Notifications required? Automated emails? AI?
+- Display: Cards/Table/Kanban? Permissions?
+```
+
+## Phases 2-7: Implementation
+
+Start with [steps/step-00-init.md](steps/step-00-init.md) to analyze requirements and existing patterns, then proceed to [steps/step-01-implementation.md](steps/step-01-implementation.md) for detailed code templates covering:
+- Phase 2: Domain (Entity + Factory + Behaviors + Enum)
+- Phase 3: Application (Interface + DTOs + Permissions)
+- Phase 4: Infrastructure (EF Config + Service + DI)
+- Phase 5: API (Controller + Authorize + RequirePermission)
+- Phase 6: Frontend (API + Hook + Page + Routes)
+- Phase 7: Integrations (Notifications + Workflows + AI)
+
+## Complete Checklist
+
+### Backend
+```
+- Domain: Entity + Factory + Behaviors + Enum + IAuditableEntity
+- Application: Interface + DTOs + Permissions (2 files!)
+- Infrastructure: EF Config + Service + DI + DbSet + Migration
+- API: Controller + Authorize + RequirePermission + ProducesResponseType
+```
+
+### Frontend
+```
+- {module}Api.ts + use{Module}.ts (with SignalR) + {Module}Page.tsx + {Module}Form.tsx
+- i18n: fr, en, it, de
+- Nested routes in App.tsx
+```
+
+### Integrations
+```
+- Notifications: NotificationType + SendNotificationAsync + useSignalR
+- Workflows: Trigger + Workflow + TriggerAsync
+- AI: Prompt + OutputSchema + ExecutePromptAsync
+```
+
+### Validation
+```
+- dotnet build + npm run build + npm run lint OK
+```
+
+## Orchestrated Skills
+
+| Skill | Phase |
+|-------|-------|
+| `/application` | 2-6 |
+| `/controller` | 5 |
+| `/notification` | 7.1 |
+| `/workflow` | 7.2 |
+| `/ai-prompt` | 7.3 |
+| `/ui-components` | 6 |
+| `/efcore migration` | 4 |
+
+## Absolute Rules
+
+| DO | DON'T |
+|----|-------|
+| Layered architecture | Direct frontend DB access |
+| Entity Factory Methods | Hardcoded permission strings |
+| Permissions 2 files | Flat routes |
+| SignalR hooks | Skip i18n 4 languages |
+| ProducesResponseType | Skip logging |
+
+<success_criteria>
+- All layers created: Domain, Infrastructure, Application, API, Frontend
+- Navigation, permissions, and roles seed data generated via MCP
+- EF Core migration created and applied
+- Tests pass (unit + integration)
+- i18n translations in 4 languages
+</success_criteria>

package/templates/skills/feature-full/steps/step-00-init.md

@@ -1,57 +1,57 @@
-# Step 0: Initialization
-
-## YOUR TASK
-Gather requirements and analyze existing code patterns before implementing a complete full-stack feature.
-
-## EXECUTION SEQUENCE
-
-### 1. Identify Feature Scope
-- What is the main entity/aggregate? (e.g., Product, Invoice, Support Ticket)
-- What are the CRUD operations required? (Create, Read, Update, Delete, Archive)
-- What business rules apply? (validations, state transitions, constraints)
-- What user permissions are needed? (who can create/edit/delete/view)
-- What notifications/workflows are required? (emails, webhooks, automation)
-- Does AI play a role? (content generation, analysis, validation)
-
-### 2. Analyze Existing Code Patterns
-- Review `Domain/` for similar entity structures, factories, and behaviors
-- Check `Application/` for existing service interfaces and DTOs
-- Examine `Infrastructure/` for EF Core configurations and patterns
-- Look at `API/Controllers/` for authorization and RequirePermission attributes
-- Study `web/` for similar pages, forms, and i18n implementations
-- Identify reusable components and patterns to follow
-
-### 3. Define Data Model
-- Entity properties and types
-- Enums for status, types, and classifications
-- Relationships (OneToMany, ManyToMany, etc.)
-- Audit requirements (CreatedAt, CreatedBy, ModifiedAt, ModifiedBy)
-- Soft delete or permanent delete?
-
-### 4. Plan Implementation Phases
-- **Phase 2:** Domain entity, factory method, behaviors, enums, IAuditableEntity
-- **Phase 3:** Application service interface, DTOs, permissions (create + assign permissions files)
-- **Phase 4:** Infrastructure (EF Config, concrete service, DI registration, DbSet, migration)
-- **Phase 5:** API controller with Authorize, RequirePermission, ProducesResponseType
-- **Phase 6:** Frontend (API client, custom hook with SignalR, page, form, routing, i18n for 4 languages)
-- **Phase 7:** Integrations (notifications, workflows, AI if applicable)
-
-### 5. Validate Against Architecture Rules
-- Confirm layered architecture is followed (no frontend-to-DB shortcuts)
-- Verify entity factory methods are used (no direct constructors in services)
-- Check permissions split across 2 files (Create/List/Read/Update/Delete vs Assign)
-- Plan SignalR hooks for real-time updates
-- Define ProducesResponseType for all endpoints
-- Plan i18n for English, French, Italian, German
-
-## SUCCESS METRICS
-- Feature scope clearly defined and bounded
-- All required CRUD operations identified
-- Business rules documented
-- Permissions mapped to roles
-- Implementation plan with all 7 phases outlined
-- Existing code patterns understood and will be followed
-- Data model defined with relationships and audit requirements
-
-## NEXT STEP
-Proceed to `./step-01-implementation.md` to execute all phases (Domain, Application, Infrastructure, API, Frontend, Integrations) with code templates and orchestration of child skills.
+# Step 0: Initialization
+
+## YOUR TASK
+Gather requirements and analyze existing code patterns before implementing a complete full-stack feature.
+
+## EXECUTION SEQUENCE
+
+### 1. Identify Feature Scope
+- What is the main entity/aggregate? (e.g., Product, Invoice, Support Ticket)
+- What are the CRUD operations required? (Create, Read, Update, Delete, Archive)
+- What business rules apply? (validations, state transitions, constraints)
+- What user permissions are needed? (who can create/edit/delete/view)
+- What notifications/workflows are required? (emails, webhooks, automation)
+- Does AI play a role? (content generation, analysis, validation)
+
+### 2. Analyze Existing Code Patterns
+- Review `Domain/` for similar entity structures, factories, and behaviors
+- Check `Application/` for existing service interfaces and DTOs
+- Examine `Infrastructure/` for EF Core configurations and patterns
+- Look at `API/Controllers/` for authorization and RequirePermission attributes
+- Study `web/` for similar pages, forms, and i18n implementations
+- Identify reusable components and patterns to follow
+
+### 3. Define Data Model
+- Entity properties and types
+- Enums for status, types, and classifications
+- Relationships (OneToMany, ManyToMany, etc.)
+- Audit requirements (CreatedAt, CreatedBy, ModifiedAt, ModifiedBy)
+- Soft delete or permanent delete?
+
+### 4. Plan Implementation Phases
+- **Phase 2:** Domain entity, factory method, behaviors, enums, IAuditableEntity
+- **Phase 3:** Application service interface, DTOs, permissions (create + assign permissions files)
+- **Phase 4:** Infrastructure (EF Config, concrete service, DI registration, DbSet, migration)
+- **Phase 5:** API controller with Authorize, RequirePermission, ProducesResponseType
+- **Phase 6:** Frontend (API client, custom hook with SignalR, page, form, routing, i18n for 4 languages)
+- **Phase 7:** Integrations (notifications, workflows, AI if applicable)
+
+### 5. Validate Against Architecture Rules
+- Confirm layered architecture is followed (no frontend-to-DB shortcuts)
+- Verify entity factory methods are used (no direct constructors in services)
+- Check permissions split across 2 files (Create/List/Read/Update/Delete vs Assign)
+- Plan SignalR hooks for real-time updates
+- Define ProducesResponseType for all endpoints
+- Plan i18n for English, French, Italian, German
+
+## SUCCESS METRICS
+- Feature scope clearly defined and bounded
+- All required CRUD operations identified
+- Business rules documented
+- Permissions mapped to roles
+- Implementation plan with all 7 phases outlined
+- Existing code patterns understood and will be followed
+- Data model defined with relationships and audit requirements
+
+## NEXT STEP
+Proceed to `./step-01-implementation.md` to execute all phases (Domain, Application, Infrastructure, API, Frontend, Integrations) with code templates and orchestration of child skills.

package/templates/skills/feature-full/steps/step-01-implementation.md

@@ -1,120 +1,120 @@
-# Feature Full - Implementation Phases
-
-## Phase 2: Domain
-
-```csharp
-// {Entity}.cs - Factory Method + Behaviors
-public class {Entity} : BaseEntity, IAuditableEntity
-{
-    public string Name { get; private set; }
-    public {Entity}Status Status { get; private set; }
-    private {Entity}() { }
-    public static {Entity} Create(string name, Guid createdById) =>
-        new { Id = Guid.NewGuid(), Name = name, Status = {Entity}Status.Active, ... };
-    public void Update(string name) => Name = name ?? throw new DomainException("Name required");
-}
-
-// {Entity}Status.cs
-public enum {Entity}Status { Active = 0, Inactive = 1, Archived = 2 }
-```
-
-## Phase 3: Application
-
-```csharp
-// I{Entity}Service.cs
-Task<PaginatedResult<{Entity}Dto>> GetAllAsync(...);
-Task<{Entity}Dto> CreateAsync(Create{Entity}Request request, CancellationToken ct);
-
-// DTOs
-public record {Entity}Dto(Guid Id, string Name, string Status, DateTime CreatedAt);
-public record Create{Entity}Request(string Name, string? Description);
-
-// Permissions.cs + PermissionConfiguration.cs (2 files!)
-public const string View = "{area}.{module}.read";
-```
-
-## Phase 4: Infrastructure
-
-```csharp
-// {Entity}Configuration.cs
-builder.ToTable("{Entity}s", "{schema}");
-builder.Property(x => x.Name).HasMaxLength(200).IsRequired();
-
-// {Entity}Service.cs with Notifications
-public async Task<{Entity}Dto> CreateAsync(...) {
-    var entity = {Entity}.Create(request.Name, _currentUser.Id);
-    _context.{Entity}s.Add(entity);
-    await _context.SaveChangesAsync(ct);
-    await _notificationService.SendNotificationAsync(_currentUser.Id,
-        NotificationType.{Entity}Created, "Created", $"{entity.Name} created",
-        relatedEntityType: nameof({Entity}), relatedEntityId: entity.Id, ct);
-    return MapToDto(entity);
-}
-
-// DependencyInjection.cs
-services.AddScoped<I{Entity}Service, {Entity}Service>();
-```
-
-## Phase 5: API
-
-```csharp
-[ApiController][Route("api/{area}/{module}")][Authorize]
-public class {Entity}Controller : ControllerBase
-{
-    [HttpGet][RequirePermission(Permissions.{Area}.{Module}.View)]
-    [ProducesResponseType(typeof(PaginatedResult<{Entity}Dto>), 200)]
-    public async Task<ActionResult<PaginatedResult<{Entity}Dto>>> GetAll(...);
-
-    [HttpPost][RequirePermission(Permissions.{Area}.{Module}.Create)]
-    [ProducesResponseType(typeof({Entity}Dto), 201)]
-    public async Task<ActionResult<{Entity}Dto>> Create([FromBody] request, CancellationToken ct);
-}
-```
-
-## Phase 6: Frontend
-
-```typescript
-// {module}Api.ts
-export const {module}Api = {
-  getAll: (page, pageSize, search?) => apiClient.get<PaginatedResult<{Entity}Dto>>('/{area}/{module}', { params }),
-  create: (data) => apiClient.post<{Entity}Dto>('/{area}/{module}', data),
-};
-
-// use{Module}.ts with SignalR
-export function use{Module}() {
-  const queryClient = useQueryClient();
-  useSignalR({ onNotification: (n) => {
-    if (n.relatedEntityType === '{Entity}') queryClient.invalidateQueries(['{module}']);
-  }});
-  const createMutation = useMutation({ mutationFn: {module}Api.create, onSuccess: () => ... });
-  return { create: createMutation.mutate, ... };
-}
-
-// {Module}Page.tsx with EntityCard
-<EntityCard title={item.name} actions={[{ label: 'View', onClick: () => navigate(...) }]} />
-
-// Routes (nested mandatory)
-<Route path="{area}"><Route path="{module}"><Route index element={<{Module}Page />} /></Route></Route>
-```
-
-## Phase 7: Integrations
-
-### Notifications
-```csharp
-await _notificationService.SendNotificationAsync(userId, NotificationType.{Entity}Created,
-    title, message, relatedEntityType: nameof({Entity}), relatedEntityId: entity.Id, actionUrl);
-```
-
-### Workflow Email
-```csharp
-// 1. WorkflowTriggerConfiguration.cs: new { Code = "{entity}.created", ... }
-// 2. WorkflowConfiguration.cs: new { TriggerId = ..., ... }
-// 3. Service:
-await _workflowService.TriggerAsync("{entity}.created", new Dictionary<string, object>{...});
-```
-
-### AI
-```csharp
-var result = await _aiCompletionService.ExecutePromptByCodeWithValidationAsync<{Entity}AnalysisResult>(
-    "{entity}-analyzer", new Dictionary<string, object>{ ["name"] = entity.Name }, ct);
-```
+# Feature Full - Implementation Phases
+
+## Phase 2: Domain
+
+```csharp
+// {Entity}.cs - Factory Method + Behaviors
+public class {Entity} : BaseEntity, IAuditableEntity
+{
+    public string Name { get; private set; }
+    public {Entity}Status Status { get; private set; }
+    private {Entity}() { }
+    public static {Entity} Create(string name, Guid createdById) =>
+        new { Id = Guid.NewGuid(), Name = name, Status = {Entity}Status.Active, ... };
+    public void Update(string name) => Name = name ?? throw new DomainException("Name required");
+}
+
+// {Entity}Status.cs
+public enum {Entity}Status { Active = 0, Inactive = 1, Archived = 2 }
+```
+
+## Phase 3: Application
+
+```csharp
+// I{Entity}Service.cs
+Task<PaginatedResult<{Entity}Dto>> GetAllAsync(...);
+Task<{Entity}Dto> CreateAsync(Create{Entity}Request request, CancellationToken ct);
+
+// DTOs
+public record {Entity}Dto(Guid Id, string Name, string Status, DateTime CreatedAt);
+public record Create{Entity}Request(string Name, string? Description);
+
+// Permissions.cs + PermissionConfiguration.cs (2 files!)
+public const string View = "{area}.{module}.read";
+```
+
+## Phase 4: Infrastructure
+
+```csharp
+// {Entity}Configuration.cs
+builder.ToTable("{Entity}s", "{schema}");
+builder.Property(x => x.Name).HasMaxLength(200).IsRequired();
+
+// {Entity}Service.cs with Notifications
+public async Task<{Entity}Dto> CreateAsync(...) {
+    var entity = {Entity}.Create(request.Name, _currentUser.Id);
+    _context.{Entity}s.Add(entity);
+    await _context.SaveChangesAsync(ct);
+    await _notificationService.SendNotificationAsync(_currentUser.Id,
+        NotificationType.{Entity}Created, "Created", $"{entity.Name} created",
+        relatedEntityType: nameof({Entity}), relatedEntityId: entity.Id, ct);
+    return MapToDto(entity);
+}
+
+// DependencyInjection.cs
+services.AddScoped<I{Entity}Service, {Entity}Service>();
+```
+
+## Phase 5: API
+
+```csharp
+[ApiController][Route("api/{area}/{module}")][Authorize]
+public class {Entity}Controller : ControllerBase
+{
+    [HttpGet][RequirePermission(Permissions.{Area}.{Module}.View)]
+    [ProducesResponseType(typeof(PaginatedResult<{Entity}Dto>), 200)]
+    public async Task<ActionResult<PaginatedResult<{Entity}Dto>>> GetAll(...);
+
+    [HttpPost][RequirePermission(Permissions.{Area}.{Module}.Create)]
+    [ProducesResponseType(typeof({Entity}Dto), 201)]
+    public async Task<ActionResult<{Entity}Dto>> Create([FromBody] request, CancellationToken ct);
+}
+```
+
+## Phase 6: Frontend
+
+```typescript
+// {module}Api.ts
+export const {module}Api = {
+  getAll: (page, pageSize, search?) => apiClient.get<PaginatedResult<{Entity}Dto>>('/{area}/{module}', { params }),
+  create: (data) => apiClient.post<{Entity}Dto>('/{area}/{module}', data),
+};
+
+// use{Module}.ts with SignalR
+export function use{Module}() {
+  const queryClient = useQueryClient();
+  useSignalR({ onNotification: (n) => {
+    if (n.relatedEntityType === '{Entity}') queryClient.invalidateQueries(['{module}']);
+  }});
+  const createMutation = useMutation({ mutationFn: {module}Api.create, onSuccess: () => ... });
+  return { create: createMutation.mutate, ... };
+}
+
+// {Module}Page.tsx with EntityCard
+<EntityCard title={item.name} actions={[{ label: 'View', onClick: () => navigate(...) }]} />
+
+// Routes (nested mandatory)
+<Route path="{area}"><Route path="{module}"><Route index element={<{Module}Page />} /></Route></Route>
+```
+
+## Phase 7: Integrations
+
+### Notifications
+```csharp
+await _notificationService.SendNotificationAsync(userId, NotificationType.{Entity}Created,
+    title, message, relatedEntityType: nameof({Entity}), relatedEntityId: entity.Id, actionUrl);
+```
+
+### Workflow Email
+```csharp
+// 1. WorkflowTriggerConfiguration.cs: new { Code = "{entity}.created", ... }
+// 2. WorkflowConfiguration.cs: new { TriggerId = ..., ... }
+// 3. Service:
+await _workflowService.TriggerAsync("{entity}.created", new Dictionary<string, object>{...});
+```
+
+### AI
+```csharp
+var result = await _aiCompletionService.ExecutePromptByCodeWithValidationAsync<{Entity}AnalysisResult>(
+    "{entity}-analyzer", new Dictionary<string, object>{ ["name"] = entity.Name }, ct);
+```