@atlashub/smartstack-cli 1.13.2 → 1.14.0

package/templates/skills/gitflow/templates/config.json

@@ -0,0 +1,53 @@
+{
+  "version": "2.0.0",
+  "repository": {
+    "name": "",
+    "defaultBranch": "main",
+    "remoteUrl": ""
+  },
+  "git": {
+    "provider": "github",
+    "branches": {
+      "main": "main",
+      "develop": "develop"
+    },
+    "prefixes": {
+      "feature": "feature/",
+      "release": "release/",
+      "hotfix": "hotfix/"
+    }
+  },
+  "worktrees": {
+    "enabled": true,
+    "mode": "organized",
+    "structure": {
+      "features": "../features",
+      "releases": "../releases",
+      "hotfixes": "../hotfixes"
+    }
+  },
+  "versioning": {
+    "strategy": "semver",
+    "current": "0.1.0",
+    "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": "en"
+  }
+}

package/templates/skills/notification/SKILL.md

@@ -1,29 +1,29 @@
 ---
 name: notification
 description: |
-  Integre le systeme de notifications SmartStack dans le developpement.
-  Utiliser ce skill quand:
-  - L'utilisateur veut envoyer des notifications depuis une feature
-  - L'utilisateur mentionne "notifier", "alerte", "notification", "in-app"
-  - Creation d'un module qui necessite des notifications utilisateur
-  - Integration SignalR pour real-time
-  Types: In-App, Email (via Workflow), Push (futur)
+  Integrates SmartStack notification system into development.
+  Use this skill when:
+  - User wants to send notifications from a feature
+  - User mentions "notify", "alert", "notification", "in-app"
+  - Creating a module that requires user notifications
+  - SignalR integration for real-time
+  Types: In-App, Email (via Workflow), Push (future)
 ---
 
 # Skill Notification SmartStack
 
 > **Architecture:** In-App (DB + SignalR) + Email (via Workflows)
 
-**Référence:** [_shared.md](../_shared.md) pour services communs
+**Reference:** [_shared.md](../_shared.md) for common services
 
-## QUAND CE SKILL S'ACTIVE
+## WHEN THIS SKILL ACTIVATES
 
-| Declencheur | Exemple |
-|-------------|---------|
-| Demande explicite | "Notifie l'utilisateur quand un ticket est cree" |
-| Event-driven | "Quand le SLA expire, prevenir l'utilisateur" |
-| Real-time | "Afficher en temps reel les nouvelles notifications" |
-| Mots-cles | "notifier", "alerte", "SignalR", "real-time" |
+| Trigger | Example |
+|---------|---------|
+| Explicit request | "Notify the user when a ticket is created" |
+| Event-driven | "When SLA expires, alert the user" |
+| Real-time | "Display new notifications in real-time" |
+| Keywords | "notify", "alert", "SignalR", "real-time" |
 
 ## FLOW
 
@@ -35,7 +35,7 @@ DB (store) + SignalR Hub (real-time)
 Frontend: useSignalR() → NotificationBell
 ```
 
-## TYPES DE NOTIFICATION
+## NOTIFICATION TYPES
 
 | Type | Usage |
 |------|-------|
@@ -44,46 +44,46 @@ Frontend: useSignalR() → NotificationBell
 | `SystemAnnouncement` | Global |
 | `SlaWarning/ResponseBreached/ResolutionBreached` | SLA |
 
-### Ajouter un Nouveau Type
+### Add a New Type
 ```csharp
 // 1. Domain/Support/Enums/NotificationType.cs
 public enum NotificationType { ..., $NEW_TYPE = XX }
 
-// 2. Utilisation
+// 2. Usage
 await _notificationService.SendNotificationAsync(userId, NotificationType.$NEW_TYPE, title, message,
     relatedEntityType: "Entity", relatedEntityId: id, actionUrl: "/path");
 ```
 
 ## WORKFLOW INTEGRATION
 
-### 1. Identifier le Besoin
+### 1. Identify the Need
 | Question | Action |
 |----------|--------|
-| Real-time ? | → In-App + SignalR |
-| Email ? | → Workflow + EmailTemplate |
-| Entite liee ? | → relatedEntityType/Id |
-| Navigation ? | → actionUrl |
+| Real-time? | → In-App + SignalR |
+| Email? | → Workflow + EmailTemplate |
+| Related entity? | → relatedEntityType/Id |
+| Navigation? | → actionUrl |
 
-### 2. Envoi de Notification
+### 2. Send Notification
 ```csharp
 // Simple
 await _notificationService.SendNotificationAsync(userId, NotificationType.TicketCreated,
-    "Nouveau ticket", $"Ticket #{ticket.Number} cree", ct);
+    "New ticket", $"Ticket #{ticket.Number} created", ct);
 
-// Avec entite liee
+// With related entity
 await _notificationService.SendNotificationAsync(userId, NotificationType.TicketAssigned,
-    "Ticket assigne", message,
+    "Ticket assigned", message,
     relatedEntityType: "Ticket", relatedEntityId: ticket.Id,
     actionUrl: $"/support/tickets/{ticket.Id}", ct);
 
-// Multi-utilisateurs
+// Multi-user
 await _notificationService.SendNotificationsAsync(userIds, type, title, message, ct);
 
-// Par role
+// By role
 await _notificationService.SendNotificationToRoleAsync("Admin", type, title, message, ct);
 ```
 
-### 3. Preferences Utilisateur
+### 3. User Preferences
 ```csharp
 var (shouldEmail, shouldInApp, shouldPush) = await _notificationService.ShouldNotifyAsync(userId, type);
 if (shouldInApp) await _notificationService.SendNotificationAsync(...);
@@ -112,12 +112,12 @@ notificationsApi.delete(id) / deleteAll()
 
 ### NotificationBell Component
 ```tsx
-<NotificationBell />  // Gere useSignalR, badge unreadCount, dropdown
+<NotificationBell />  // Manages useSignalR, badge unreadCount, dropdown
 ```
 
-## PATTERNS AVANCES
+## ADVANCED PATTERNS
 
-### SLA Warning (Job Hangfire)
+### SLA Warning (Hangfire Job)
 ```csharp
 var tickets = await _context.Tickets
     .Where(t => t.SlaDeadline <= DateTime.UtcNow.AddMinutes(30) && !t.SlaWarningNotificationSent)
@@ -128,39 +128,39 @@ foreach (var ticket in tickets) {
 }
 ```
 
-### Notification Groupee
+### Grouped Notification
 ```csharp
 if (entities.Count == 1) await SendSingle(...);
-else await SendBatch($"{entities.Count} nouveaux elements", ...);
+else await SendBatch($"{entities.Count} new elements", ...);
 ```
 
 ## CHECKLIST
 
 ```
-□ Type notification identifie (existant ou nouveau enum)
-□ INotificationService injecte
-□ Envoi avec: userId, type, title, message, relatedEntityType?, relatedEntityId?, actionUrl?
-□ Frontend: useSignalR configure, toast/UI sur reception
-□ Si email: workflow configure
+□ Notification type identified (existing or new enum)
+□ INotificationService injected
+□ Send with: userId, type, title, message, relatedEntityType?, relatedEntityId?, actionUrl?
+□ Frontend: useSignalR configured, toast/UI on receipt
+□ If email: workflow configured
 ```
 
-## REGLES ABSOLUES
+## ABSOLUTE RULES
 
 | DO | DON'T |
 |----|-------|
-| INotificationService | Acces DB direct |
-| NotificationType enum | Types hardcodes |
-| relatedEntityType/Id + actionUrl | Notifications sans contexte |
-| Respecter preferences utilisateur | Spam notifications |
-| CancellationToken | Messages hardcodes (utiliser i18n) |
+| INotificationService | Direct DB access |
+| NotificationType enum | Hardcoded types |
+| relatedEntityType/Id + actionUrl | Notifications without context |
+| Respect user preferences | Spam notifications |
+| CancellationToken | Hardcoded messages (use i18n) |
 
-## FICHIERS CLES
+## KEY FILES
 
-| Fichier | Role |
-|---------|------|
-| `Domain/Support/Notification.cs` | Entite |
+| File | Role |
+|------|------|
+| `Domain/Support/Notification.cs` | Entity |
 | `Domain/Support/Enums/NotificationType.cs` | Types |
 | `Application/Common/Interfaces/INotificationService.cs` | Interface |
 | `Infrastructure/Services/SignalR/NotificationHubService.cs` | Real-time |
-| `web/src/hooks/useSignalR.ts` | Hook frontend |
+| `web/src/hooks/useSignalR.ts` | Frontend hook |
 | `web/src/components/notifications/NotificationBell.tsx` | UI |

package/templates/skills/ralph-loop/SKILL.md

@@ -0,0 +1,228 @@
+---
+name: ralph-loop
+description: Iterative AI development loop with MCP validation, progress tracking, and completion promises.
+argument-hint: "[-m N] [-c TEXT] [-v] <task description>"
+---
+
+<objective>
+Execute the Ralph Weegund technique - an iterative development methodology where the same prompt is fed repeatedly until completion. Uses progressive step loading with MCP validation and progress persistence.
+</objective>
+
+<quick_start>
+**Basic usage:**
+
+```bash
+/ralph-loop implement user authentication
+```
+
+**With completion promise:**
+
+```bash
+/ralph-loop -c "COMPLETE" refactor the cache layer
+```
+
+**With max iterations:**
+
+```bash
+/ralph-loop -m 20 -c "TESTS PASS" add comprehensive tests
+```
+
+**Verbose mode:**
+
+```bash
+/ralph-loop -v -c "DONE" fix all linting errors
+```
+
+**Flags:**
+
+- `-m N` (max): Maximum iterations before auto-stop
+- `-c TEXT` (complete): Completion promise text
+- `-v` (verbose): Detailed logging
+
+See `<parameters>` for complete flag list.
+</quick_start>
+
+<parameters>
+
+<flags>
+**Flags:**
+| Short | Long | Description |
+|-------|------|-------------|
+| `-m N` | `--max-iterations N` | Maximum iterations (default: 50) |
+| `-c TEXT` | `--completion-promise TEXT` | Text that signals completion |
+| `-v` | `--verbose` | Enable detailed logging |
+| `-r` | `--resume` | Resume from previous state |
+</flags>
+
+<examples>
+```bash
+# Basic loop
+/ralph-loop implement feature X
+
+# With completion signal
+/ralph-loop -c "ALL TESTS PASS" fix failing tests
+
+# Limited iterations with completion
+/ralph-loop -m 10 -c "REFACTOR COMPLETE" clean up auth module
+
+# Resume previous loop
+/ralph-loop -r
+
+# Verbose mode
+/ralph-loop -v -m 25 -c "DONE" implement CRUD for products
+```
+</examples>
+
+<parsing_rules>
+**Argument parsing:**
+
+1. `-m N` or `--max-iterations N` -> `{max_iterations}` = N
+2. `-c TEXT` or `--completion-promise TEXT` -> `{completion_promise}` = TEXT
+3. `-v` or `--verbose` -> `{verbose_mode}` = true
+4. `-r` or `--resume` -> `{resume_mode}` = true
+5. Remainder -> `{task_description}`
+</parsing_rules>
+
+</parameters>
+
+<ralph_concept>
+**Core concept:**
+
+The same prompt is fed to Claude repeatedly. The "self-referential" aspect comes from Claude seeing its own previous work in files and git history.
+
+**Each iteration:**
+1. Claude receives the SAME prompt
+2. Works on the task, modifying files
+3. Checks completion criteria
+4. If not complete: saves progress, iteration count increments
+5. Claude sees previous work in the files
+6. Iteratively improves until completion promise is output
+
+**Completion signal:**
+```
+<promise>{completion_promise}</promise>
+```
+
+The loop only stops when this exact tag is output or max iterations reached.
+</ralph_concept>
+
+<workflow>
+**Standard flow:**
+1. Parse flags and task description
+2. Verify MCP servers are available (MANDATORY)
+3. Initialize .ralph/ structure and state files
+4. Load current task from prd.json (or create initial tasks)
+5. Execute ONE task per iteration
+6. Commit changes, update progress
+7. Check completion criteria
+8. If complete: generate final report
+</workflow>
+
+<state_variables>
+**Persist throughout all steps:**
+
+| Variable | Type | Description |
+|----------|------|-------------|
+| `{task_description}` | string | The prompt/task to execute |
+| `{max_iterations}` | number | Maximum iterations allowed |
+| `{completion_promise}` | string | Text that signals completion |
+| `{verbose_mode}` | boolean | Enable detailed logging |
+| `{resume_mode}` | boolean | Resume from previous state |
+| `{current_iteration}` | number | Current iteration count |
+| `{tasks_completed}` | number | Number of tasks completed |
+| `{tasks_total}` | number | Total tasks in prd.json |
+
+</state_variables>
+
+<mcp_requirements>
+**MANDATORY MCP Validation:**
+
+Before ANY work, verify MCP servers:
+
+1. **SmartStack MCP** - `mcp__smartstack__validate_conventions`
+2. **Context7 MCP** - `mcp__plugin_context7_context7__resolve-library-id`
+
+**If ANY MCP unavailable:**
+- DO NOT proceed
+- Log failure to `.ralph/logs/`
+- Output error message
+- Suggest: `smartstack check-mcp`
+
+**Throughout work, use:**
+- `mcp__smartstack__validate_conventions` - Before commits
+- `mcp__smartstack__check_migrations` - Before EF Core changes
+- `mcp__smartstack__scaffold_extension` - For code generation
+</mcp_requirements>
+
+<entry_point>
+
+**FIRST ACTION:** Load `steps/step-00-init.md`
+
+</entry_point>
+
+<step_files>
+**Progressive loading - only load current step:**
+
+| Step | File | Purpose |
+|------|------|---------|
+| 00 | `steps/step-00-init.md` | Parse args, verify MCP, initialize state |
+| 01 | `steps/step-01-task.md` | Load current task from prd.json |
+| 02 | `steps/step-02-execute.md` | Execute ONE task |
+| 03 | `steps/step-03-commit.md` | Commit, update prd.json/progress.txt |
+| 04 | `steps/step-04-check.md` | Check completion, decide next action |
+| 05 | `steps/step-05-report.md` | Generate final report |
+
+</step_files>
+
+<file_structure>
+**Ralph creates these files:**
+
+```
+.ralph/
+├── prd.json          # Task list with status
+├── progress.txt      # Persistent memory between iterations
+├── logs/
+│   └── {timestamp}.log
+└── reports/
+    └── {feature-name}.md
+```
+
+**prd.json structure:**
+```json
+{
+  "feature": "{task_description}",
+  "created": "2024-01-01T00:00:00Z",
+  "max_iterations": 50,
+  "completion_promise": "COMPLETE",
+  "tasks": [
+    { "id": 1, "description": "Task 1", "passes": false },
+    { "id": 2, "description": "Task 2", "passes": false }
+  ]
+}
+```
+</file_structure>
+
+<execution_rules>
+
+- **Load one step at a time** - Only load the current step file
+- **VERIFY MCP FIRST** - Never skip MCP validation
+- **ONE TASK PER ITERATION** - Don't batch tasks
+- **COMMIT AFTER EACH TASK** - Atomic progress
+- **UPDATE progress.txt** - Persist learnings
+- **NEVER fake completion** - Only output promise when truly done
+</execution_rules>
+
+<success_criteria>
+
+- All tasks in prd.json have `passes: true`
+- MCP validations pass
+- Git commits atomic per task
+- Completion promise output when genuinely complete
+- Final report generated in `.ralph/reports/`
+</success_criteria>
+
+<available_commands>
+**Related commands:**
+- `/ralph-loop:cancel-ralph` - Cancel active loop
+- `/ralph-loop:help` - Show documentation
+</available_commands>

package/templates/skills/ralph-loop/steps/step-00-init.md

@@ -0,0 +1,201 @@
+---
+name: step-00-init
+description: Initialize Ralph loop - parse args, verify MCP, setup state
+next_step: steps/step-01-task.md
+---
+
+# Step 0: Initialization
+
+## MANDATORY EXECUTION RULES:
+
+- NEVER skip MCP verification
+- ALWAYS parse ALL flags before any other action
+- ONLY check for resume if -r flag is set
+- YOU ARE AN INITIALIZER, not an executor
+- FORBIDDEN to load step-01 until init is complete
+
+## YOUR TASK:
+
+Initialize the Ralph loop by parsing flags, verifying MCP availability, and setting up the execution environment.
+
+---
+
+<defaults>
+## Default Configuration
+
+```yaml
+max_iterations: 50
+completion_promise: null
+verbose_mode: false
+resume_mode: false
+current_iteration: 1
+```
+</defaults>
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Parse Flags and Input
+
+**Step 1: Load defaults from config above**
+
+```
+{max_iterations}     = 50
+{completion_promise} = null
+{verbose_mode}       = false
+{resume_mode}        = false
+{current_iteration}  = 1
+```
+
+**Step 2: Parse user input and override defaults:**
+
+```
+Flags:
+  -m N or --max-iterations N     -> {max_iterations} = N
+  -c TEXT or --completion-promise TEXT -> {completion_promise} = TEXT
+  -v or --verbose                -> {verbose_mode} = true
+  -r or --resume                 -> {resume_mode} = true
+
+Remainder -> {task_description}
+```
+
+### 2. Verify MCP Servers (MANDATORY)
+
+**CRITICAL: Do NOT proceed without MCP verification!**
+
+**Check SmartStack MCP:**
+```
+mcp__smartstack__validate_conventions:
+  checks: ["all"]
+  (just to verify connectivity)
+```
+
+**Check Context7 MCP:**
+```
+mcp__plugin_context7_context7__resolve-library-id:
+  libraryName: "test"
+  query: "connectivity check"
+  (just to verify connectivity)
+```
+
+**If ANY MCP fails:**
+```
+╔══════════════════════════════════════════════════════════════════╗
+║  ❌ MCP SERVER UNAVAILABLE                                        ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Server: {failed_server}                                          ║
+║  Status: Connection failed                                        ║
+╠══════════════════════════════════════════════════════════════════╣
+║  RALPH CANNOT PROCEED WITHOUT MCP                                 ║
+║                                                                    ║
+║  Troubleshooting:                                                  ║
+║  1. Run: smartstack check-mcp                                      ║
+║  2. Restart Claude Code                                            ║
+║  3. Check MCP server configuration                                 ║
+╚══════════════════════════════════════════════════════════════════╝
+
+STOP - Do not proceed.
+```
+
+### 3. Check Resume Mode
+
+**If {resume_mode} = true:**
+
+1. Check for existing `.ralph/prd.json`
+2. If found:
+   - Read prd.json to restore state
+   - Read progress.txt for context
+   - Set {current_iteration} from state
+   - Continue to step-01
+3. If not found:
+   - Error: "No active Ralph loop to resume"
+   - Ask user to start new loop
+
+### 4. Initialize .ralph/ Structure
+
+**Create directory structure:**
+
+```
+.ralph/
+├── prd.json          # Will be created in step-01
+├── progress.txt      # Will be created in step-01
+├── logs/
+└── reports/
+```
+
+**Commands:**
+```bash
+mkdir -p .ralph/logs
+mkdir -p .ralph/reports
+```
+
+### 5. Validate Completion Promise
+
+**If {completion_promise} is null:**
+
+```yaml
+AskUserQuestion:
+  header: "Promise"
+  question: "What text should signal completion?"
+  options:
+    - label: "COMPLETE"
+      description: "Standard completion signal"
+    - label: "ALL TESTS PASS"
+      description: "For test-focused tasks"
+    - label: "DONE"
+      description: "Simple completion"
+    - label: "Custom..."
+      description: "Specify custom text"
+```
+
+### 6. Log Initialization
+
+**If {verbose_mode} = true:**
+
+Write to `.ralph/logs/{timestamp}.log`:
+```
+[{timestamp}] RALPH LOOP INITIALIZED
+Task: {task_description}
+Max iterations: {max_iterations}
+Completion promise: {completion_promise}
+MCP Status: SmartStack ✅, Context7 ✅
+```
+
+### 7. Show Summary and Proceed
+
+**Always show COMPACT summary:**
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║  RALPH LOOP INITIALIZED                                           ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Task: {task_description}                                         ║
+║  Max iterations: {max_iterations}                                 ║
+║  Completion: <promise>{completion_promise}</promise>              ║
+║  MCP: ✅ Ready                                                    ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Files:                                                           ║
+║  - .ralph/prd.json (tasks)                                        ║
+║  - .ralph/progress.txt (memory)                                   ║
+╚══════════════════════════════════════════════════════════════════╝
+
+-> Loading tasks...
+```
+
+**Then proceed directly to step-01-task.md**
+
+---
+
+## SUCCESS METRICS:
+
+- All flags correctly parsed
+- MCP servers verified and available
+- .ralph/ directory structure created
+- Completion promise defined
+- Output is COMPACT
+- Proceeded to step-01 immediately after summary
+
+## NEXT STEP:
+
+After showing initialization summary, always proceed directly to `./step-01-task.md`