@atlashub/smartstack-cli 3.8.0 → 3.9.0

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

@@ -7,7 +7,7 @@ description: |
   - 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
+  Scope: Domain -> Application -> Infrastructure -> API -> Web + Notifications + Workflows + AI
 disable-model-invocation: true
 ---
 
@@ -17,7 +17,7 @@ disable-model-invocation: true
 
 **Reference:** [_shared.md](../_shared.md) for architecture, permissions, i18n
 
-## WHEN THIS SKILL ACTIVATES
+## When This Skill Activates
 
 | Trigger | Example |
 |---------|---------|
@@ -25,173 +25,62 @@ disable-model-invocation: true
 | Full-stack | "Create the backend and frontend for..." |
 | Integration | "With notifications and automated emails" |
 
-## COMPLETE FLOW
+## Complete Flow
 
 ```
-DOMAIN → APPLICATION → INFRASTRUCTURE → API → WEB
+DOMAIN -> APPLICATION -> INFRASTRUCTURE -> API -> WEB
                       + NOTIFICATIONS + WORKFLOWS + AI
 ```
 
-## CREATION WORKFLOW
+## Phase 1: Analysis
 
-### PHASE 1: ANALYSIS
-
-```
-□ Module/functionality?
-□ Entities? CRUD operations? Business rules?
-□ Notifications required? Automated emails? AI?
-□ Display: Cards/Table/Kanban? Permissions?
-```
-
-### 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<PagedResult<{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 = "{context}.{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(PagedResult<{Entity}Dto>), 200)]
-    public async Task<ActionResult<PagedResult<{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);
-}
+- Module/functionality?
+- Entities? CRUD operations? Business rules?
+- Notifications required? Automated emails? AI?
+- Display: Cards/Table/Kanban? Permissions?
 ```
 
-### PHASE 6: FRONTEND
-
-```typescript
-// {module}Api.ts
-export const {module}Api = {
-  getAll: (page, pageSize, search?) => apiClient.get<PagedResult<{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>
-```
+## Phases 2-7: Implementation
 
-### PHASE 7: INTEGRATIONS
+See [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)
 
-#### 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);
-```
-
-## COMPLETE CHECKLIST
+## 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
+- 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
+- {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
+- Notifications: NotificationType + SendNotificationAsync + useSignalR
+- Workflows: Trigger + Workflow + TriggerAsync
+- AI: Prompt + OutputSchema + ExecutePromptAsync
 ```
 
 ### Validation
 ```
-□ dotnet build + npm run build + npm run lint OK
+- dotnet build + npm run build + npm run lint OK
 ```
 
-## ORCHESTRATED SKILLS
+## Orchestrated Skills
 
 | Skill | Phase |
 |-------|-------|
@@ -203,7 +92,7 @@ var result = await _aiCompletionService.ExecutePromptByCodeWithValidationAsync<{
 | `/ui-components` | 6 |
 | `/efcore:migration` | 4 |
 
-## ABSOLUTE RULES
+## Absolute Rules
 
 | DO | DON'T |
 |----|-------|
@@ -212,3 +101,11 @@ var result = await _aiCompletionService.ExecutePromptByCodeWithValidationAsync<{
 | 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-01-implementation.md

@@ -0,0 +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<PagedResult<{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 = "{context}.{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(PagedResult<{Entity}Dto>), 200)]
+    public async Task<ActionResult<PagedResult<{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<PagedResult<{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);
+```

package/templates/skills/gitflow/references/init-config-template.md

@@ -0,0 +1,135 @@
+# GitFlow Config Template (v2.1.0)
+
+## Configuration JSON
+
+Write `.claude/gitflow/config.json` in develop worktree.
+
+**IMPORTANT:** Store paths using `normalize_path_for_storage()` format (Windows-style: `D:/path/to/folder`). The `read_gitflow_config()` in `_shared.md` translates them to platform format at read time.
+
+```json
+{
+  "version": "2.1.0",
+  "platform": {
+    "detected": "{GF_PLATFORM}",
+    "shell": "{GF_SHELL}",
+    "detectedAt": "{ISO_DATE}"
+  },
+  "workspace": {
+    "path": "{WORKSPACE_DIR_STORAGE_FORMAT}",
+    "name": ""
+  },
+  "repository": {
+    "name": "{PROJECT_NAME}",
+    "rootFolder": "{ROOT_FOLDER_STORAGE_FORMAT}",
+    "nameVariants": {
+      "pascalCaseDot": "{PascalCase.Dot}",
+      "pascalCase": "{PascalCase}",
+      "kebabCase": "{kebab-case}",
+      "snakeCase": "{snake_case}",
+      "displayName": "{Display Name}"
+    },
+    "defaultBranch": "main",
+    "remoteUrl": "{REPO_URL}"
+  },
+  "git": {
+    "provider": "{GIT_PROVIDER}",
+    "branches": {
+      "main": "main",
+      "develop": "develop"
+    },
+    "prefixes": {
+      "feature": "feature/",
+      "release": "release/",
+      "hotfix": "hotfix/"
+    }
+  },
+  "worktrees": {
+    "enabled": true,
+    "mode": "{WORKTREE_MODE}",
+    "structure": {
+      "main": "{ROOT_FOLDER_STORAGE_FORMAT}/01-Main",
+      "develop": "{ROOT_FOLDER_STORAGE_FORMAT}/02-Develop",
+      "features": "{ROOT_FOLDER_STORAGE_FORMAT}/features",
+      "releases": "{ROOT_FOLDER_STORAGE_FORMAT}/releases",
+      "hotfixes": "{ROOT_FOLDER_STORAGE_FORMAT}/hotfixes"
+    }
+  },
+  "versioning": {
+    "strategy": "semver",
+    "current": "{VERSION}",
+    "tagPrefix": "v",
+    "sources": ["csproj", "package.json", "VERSION"]
+  },
+  "efcore": {
+    "enabled": true,
+    "validateOnCommit": true,
+    "blockDestructive": true,
+    "migrationNaming": "{context}_v{version}_{sequence}_{Description}"
+  },
+  "workflow": {
+    "push": { "afterCommit": "worktree" },
+    "pr": { "autoLabels": true, "requireReview": true }
+  },
+  "language": { "code": "{GF_LANG}" }
+}
+```
+
+## Path Storage Convention
+
+- `{ROOT_FOLDER_STORAGE_FORMAT}` = result of `normalize_path_for_storage("{ROOT_FOLDER}")`
+- On WSL: `/mnt/d/projects/MyApp` -> stored as `D:/projects/MyApp`
+- On Windows: `D:\projects\MyApp` -> stored as `D:/projects/MyApp`
+- On Linux/macOS: `/home/user/projects/MyApp` -> stored as-is
+
+## Post-Init Validation
+
+```bash
+PROJECT_BASE="{ROOT_FOLDER}"
+MAIN_DIR=$([ "$WORKTREE_MODE" = "organized" ] && echo "01-Main" || echo "main")
+DEVELOP_DIR=$([ "$WORKTREE_MODE" = "organized" ] && echo "02-Develop" || echo "develop")
+ERRORS=0
+
+# Verify bare repo
+[ -f "$PROJECT_BASE/.bare/HEAD" ] && echo "OK .bare/HEAD" || { echo "FAIL .bare/HEAD missing"; ERRORS=$((ERRORS+1)); }
+
+# Verify worktrees on correct branches
+MAIN_BRANCH=$(git -C "$PROJECT_BASE/$MAIN_DIR" branch --show-current 2>/dev/null)
+[ "$MAIN_BRANCH" = "main" ] && echo "OK $MAIN_DIR on main" || { echo "FAIL $MAIN_DIR on '$MAIN_BRANCH'"; ERRORS=$((ERRORS+1)); }
+
+DEVELOP_BRANCH=$(git -C "$PROJECT_BASE/$DEVELOP_DIR" branch --show-current 2>/dev/null)
+[ "$DEVELOP_BRANCH" = "develop" ] && echo "OK $DEVELOP_DIR on develop" || { echo "FAIL $DEVELOP_DIR on '$DEVELOP_BRANCH'"; ERRORS=$((ERRORS+1)); }
+
+# Verify directories
+for subdir in features releases hotfixes; do
+  [ -d "$PROJECT_BASE/$subdir" ] && echo "OK $subdir/" || { echo "FAIL $subdir/ missing"; ERRORS=$((ERRORS+1)); }
+done
+
+# Verify config directory
+[ -d "$PROJECT_BASE/$DEVELOP_DIR/.claude/gitflow" ] && echo "OK .claude/gitflow/" || { echo "FAIL .claude/gitflow/ missing"; ERRORS=$((ERRORS+1)); }
+
+echo ""
+[ "$ERRORS" -eq 0 ] && echo "VALIDATION: ALL CHECKS PASSED" || echo "VALIDATION: $ERRORS error(s) detected"
+```
+
+## Workspace Mode (`--workspace`)
+
+When called with `init --workspace`, batch-initialize all repos in a workspace.
+
+### Workspace Execution Sequence:
+
+1. **Ask workspace directory** (AskUserQuestion: parent folder or custom path)
+2. **Detect or ask for repos** (scan workspace for git repos or enter URLs)
+3. **Create `.smartstack-workspace.json`:**
+```json
+{
+  "version": "1.0.0",
+  "name": "{WORKSPACE_NAME}",
+  "createdAt": "{ISO_DATE}",
+  "updatedAt": "{ISO_DATE}",
+  "platform": { "detected": "{GF_PLATFORM}", "shell": "{GF_SHELL}" },
+  "repositories": [],
+  "defaults": { "provider": "{GIT_PROVIDER}", "worktreeMode": "organized", "language": "en" }
+}
+```
+4. **Loop: For each repo, run Steps 1-10b with workspace defaults pre-populated.**
+5. **Display global summary** with all repos initialized.

package/templates/skills/gitflow/references/init-name-normalization.md

@@ -0,0 +1,103 @@
+# Project Name Normalization (INTELLIGENT)
+
+**ALWAYS normalize, even if user chose the detected name.**
+
+## Step 1: Parse input into words
+
+Split the raw input on any separator: spaces, hyphens, underscores, dots, camelCase boundaries.
+
+| Raw input | Parsed words |
+|-----------|-------------|
+| `mon super projet` | `["mon", "super", "projet"]` |
+| `gestion-des-stocks` | `["gestion", "des", "stocks"]` |
+| `my_awesome_app` | `["my", "awesome", "app"]` |
+| `SmartStack.App` | `["Smart", "Stack", "App"]` |
+| `userManagement` | `["user", "Management"]` |
+
+## Step 2: Language detection and spell check
+
+For EACH word, you MUST:
+1. **Detect the language** (French, English, or technical/proper noun)
+2. **Check spelling** - flag obvious typos
+3. **Suggest corrections** if misspelled
+
+| Word | Language | Spelling | Suggestion |
+|------|----------|----------|------------|
+| `gestion` | FR | OK | - |
+| `gestoin` | FR | typo | -> `gestion` |
+| `managment` | EN | typo | -> `management` |
+| `SmartStack` | Proper noun | OK | - |
+| `auth` | EN (abbreviation) | OK | - |
+
+**If typos detected**, ask the user BEFORE generating variants:
+
+```yaml
+AskUserQuestion:
+  - header: "Spelling"
+    question: "Corrections detected. Accept?"
+    options:
+      - label: "Accept corrections (Recommended)"
+        description: "'gestoin' -> 'gestion', 'managment' -> 'management'"
+      - label: "Keep original"
+        description: "Use the name as typed"
+    multiSelect: false
+```
+
+## Step 3: Generate all name variants
+
+From the cleaned words, generate ALL variants:
+
+| Variant | Format | Best for |
+|---------|--------|----------|
+| PascalCase.Dot | `Gestion.Des.Stocks` | .NET namespace, C# project, folder name |
+| PascalCase | `GestionDesStocks` | Class name, assembly name |
+| kebab-case | `gestion-des-stocks` | Git repo, npm package, URL slug |
+| snake_case | `gestion_des_stocks` | Database, Python, file system |
+
+## Step 4: Ask user to choose the PRIMARY format
+
+```yaml
+AskUserQuestion:
+  - header: "Format"
+    question: "Which format for the project name?"
+    options:
+      - label: "PascalCase.Dot (Recommended)"
+        description: "{PascalCase.Dot variant} - .NET convention"
+      - label: "PascalCase"
+        description: "{PascalCase variant} - single word"
+      - label: "kebab-case"
+        description: "{kebab-case variant} - git/npm convention"
+      - label: "snake_case"
+        description: "{snake_case variant} - database/python convention"
+    multiSelect: false
+```
+
+## Step 5: Store all derived names
+
+Regardless of the chosen primary format, ALL variants are generated and stored:
+
+```json
+{
+  "PROJECT_NAME": "{chosen format}",
+  "PROJECT_VARIANTS": {
+    "pascalCaseDot": "Gestion.Des.Stocks",
+    "pascalCase": "GestionDesStocks",
+    "kebabCase": "gestion-des-stocks",
+    "snakeCase": "gestion_des_stocks",
+    "displayName": "Gestion Des Stocks",
+    "words": ["gestion", "des", "stocks"],
+    "language": "fr"
+  }
+}
+```
+
+## Real-world examples
+
+| User types | PascalCase.Dot | kebab-case | PascalCase |
+|-----------|---------------|------------|------------|
+| `smart stack app` | `SmartStack.App` | `smart-stack-app` | `SmartStackApp` |
+| `gestion-des-stocks` | `Gestion.Des.Stocks` | `gestion-des-stocks` | `GestionDesStocks` |
+| `Mon Projet V2` | `Mon.Projet.V2` | `mon-projet-v2` | `MonProjetV2` |
+| `user auth module` | `User.Auth.Module` | `user-auth-module` | `UserAuthModule` |
+| `PROJET TEST` | `Projet.Test` | `projet-test` | `ProjetTest` |
+| `e-commerce platform` | `ECommerce.Platform` | `e-commerce-platform` | `ECommercePlatform` |

package/templates/skills/gitflow/references/plan-template.md

@@ -0,0 +1,69 @@
+# Integration Plan Document Template
+
+> Referenced from `steps/step-plan.md` — Markdown template for generated plan documents.
+
+**Write to:** `.claude/gitflow/plans/{branch-name}_{date}.md`
+
+---
+
+```markdown
+# Integration Plan: {CURRENT} → {BASE_BRANCH}
+
+**Generated:** {timestamp}
+**Status:** PENDING
+
+## Summary
+
+| Field | Value |
+|-------|-------|
+| Source | {CURRENT} |
+| Target | {BASE_BRANCH} |
+| Commits | {COMMITS} |
+| Strategy | {MERGE_STRATEGY} |
+| Merge Back | {MERGE_BACK or "N/A"} |
+
+## Commits to Integrate
+
+{COMMIT_LIST}
+
+## EF Core Analysis
+
+| Check | Status |
+|-------|--------|
+| Branch migrations | {count} |
+| Base migrations | {count} |
+| Snapshot diverged | {yes/no} |
+| Conflict type | {none/migration/code/both} |
+
+## Pre-Integration Steps
+
+{if migration conflict}
+1. [ ] Run `/efcore:rebase-snapshot`
+2. [ ] Verify migration generates same schema
+3. [ ] Run `/gitflow sync`
+{endif}
+
+{if code conflict}
+1. [ ] Run `/gitflow sync` (includes rebase)
+2. [ ] Resolve conflicts manually
+3. [ ] Verify build passes
+{endif}
+
+## Integration Steps
+
+1. [ ] Create PR: `/gitflow pr`
+2. [ ] Review and approve
+3. [ ] Merge: `/gitflow merge`
+{if release or hotfix}
+4. [ ] Merge back to develop
+5. [ ] Create tag: v{VERSION}
+{endif}
+6. [ ] Cleanup: `/gitflow finish`
+
+## Post-Integration
+
+- [ ] Verify CI/CD passes
+- [ ] Verify migrations applied
+- [ ] Delete source branch
+- [ ] Remove worktree
+```