@atlashub/smartstack-cli 1.13.2 → 1.14.1

package/templates/skills/gitflow/steps/step-sync.md

@@ -0,0 +1,200 @@
+---
+name: step-sync
+description: Sync with remote and rebase if behind
+next_step: null
+---
+
+# Step: SYNC - Synchronize with Remote
+
+## YOUR TASK:
+
+Fetch from remote, detect divergence, push local commits, and rebase if behind base branch.
+
+**ULTRA THINK about merge conflicts.**
+
+---
+
+## EXECUTION SEQUENCE:
+
+### 1. Fetch Remote State
+
+```bash
+git fetch origin --quiet
+CURRENT=$(git rev-parse --abbrev-ref HEAD)
+
+# Determine base branch
+case "$CURRENT" in
+  feature/*) BASE_BRANCH="develop" ;;
+  release/*) BASE_BRANCH="develop" ;;
+  hotfix/*)  BASE_BRANCH="main" ;;
+  *)         BASE_BRANCH="develop" ;;
+esac
+```
+
+### 2. Analyze Divergence
+
+```bash
+# Current branch vs remote
+AHEAD=$(git rev-list --count origin/$CURRENT..HEAD 2>/dev/null || echo "0")
+BEHIND=$(git rev-list --count HEAD..origin/$CURRENT 2>/dev/null || echo "0")
+
+# Current branch vs base branch
+BASE_AHEAD=$(git rev-list --count origin/$BASE_BRANCH..HEAD 2>/dev/null || echo "0")
+BASE_BEHIND=$(git rev-list --count HEAD..origin/$BASE_BRANCH 2>/dev/null || echo "0")
+```
+
+**State matrix:**
+
+| Ahead | Behind | State | Action |
+|-------|--------|-------|--------|
+| 0 | 0 | Synced | Nothing to do |
+| >0 | 0 | Ahead | Push |
+| 0 | >0 | Behind | Pull |
+| >0 | >0 | Diverged | Pull --rebase + Push |
+
+### 3. Display Status
+
+```
+Sync Status: {CURRENT}
+
+| Remote | Ahead | Behind | Status |
+|--------|-------|--------|--------|
+| origin/{CURRENT} | {AHEAD} | {BEHIND} | {state} |
+| origin/{BASE_BRANCH} | {BASE_AHEAD} | {BASE_BEHIND} | {state} |
+```
+
+### 4. Push Local Commits
+
+```bash
+[ "$AHEAD" -gt 0 ] && {
+  echo "Pushing $AHEAD commit(s) to origin/$CURRENT..."
+  git push origin $CURRENT
+}
+```
+
+### 5. Pull Remote Commits
+
+```bash
+[ "$BEHIND" -gt 0 ] && {
+  echo "Pulling $BEHIND commit(s) from origin/$CURRENT..."
+
+  # Check for uncommitted changes
+  DIRTY=$(git status --porcelain | wc -l)
+  [ "$DIRTY" -gt 0 ] && {
+    git stash push -m "sync-stash-$(date +%s)"
+    STASHED=true
+  }
+
+  git pull --rebase origin $CURRENT
+
+  [ "$STASHED" = true ] && git stash pop
+}
+```
+
+### 6. Rebase on Base Branch (if behind)
+
+```bash
+[ "$BASE_BEHIND" -gt 0 ] && {
+  echo "Branch is $BASE_BEHIND commits behind $BASE_BRANCH"
+
+  if [ "$auto_mode" = true ]; then
+    # Auto rebase
+    git rebase origin/$BASE_BRANCH
+  else
+    # Ask user
+    AskUserQuestion:
+      header: "Rebase"
+      question: "Rebase on $BASE_BRANCH? ($BASE_BEHIND commits behind)"
+      options:
+        - label: "Yes (Recommended)"
+          description: "Rebase to include latest changes"
+        - label: "No"
+          description: "Keep current base"
+  fi
+}
+```
+
+### 7. Handle Rebase Conflicts
+
+```bash
+# If rebase has conflicts
+if [ -d ".git/rebase-merge" ] || [ -d ".git/rebase-apply" ]; then
+  echo "⚠️ REBASE CONFLICT DETECTED"
+
+  CONFLICTS=$(git diff --name-only --diff-filter=U)
+  echo "Conflicting files:"
+  echo "$CONFLICTS"
+
+  # Check for migration conflicts
+  MIGRATION_CONFLICTS=$(echo "$CONFLICTS" | grep "Migrations/")
+  [ -n "$MIGRATION_CONFLICTS" ] && {
+    echo "⚠️ Migration conflicts detected!"
+    echo "Recommend: /efcore:rebase-snapshot"
+  }
+
+  # Options
+  AskUserQuestion:
+    header: "Conflict"
+    question: "How to handle conflicts?"
+    options:
+      - label: "Resolve manually"
+        description: "I'll fix conflicts and continue"
+      - label: "Abort rebase"
+        description: "Cancel and return to previous state"
+      - label: "Accept theirs (migrations)"
+        description: "Use base branch migrations, regenerate ours"
+fi
+```
+
+### 8. Force Push After Rebase
+
+```bash
+# After successful rebase
+if [ "$REBASED" = true ]; then
+  echo "Rebase complete. Force pushing..."
+  git push --force-with-lease origin $CURRENT
+fi
+```
+
+### 9. Summary
+
+```
+╔══════════════════════════════════════════════════════════════════╗
+║                    SYNC COMPLETE                                  ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Branch: {CURRENT}                                                ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Actions:                                                         ║
+║  {✅ Pushed {N} commits | ⬜ Nothing to push}                     ║
+║  {✅ Pulled {N} commits | ⬜ Nothing to pull}                     ║
+║  {✅ Rebased on {BASE_BRANCH} | ⬜ No rebase needed}              ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Status: In sync with remote                                      ║
+╠══════════════════════════════════════════════════════════════════╣
+║  NEXT: /gitflow pr                                                ║
+╚══════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## ERROR HANDLING:
+
+| Error | Solution |
+|-------|----------|
+| Push rejected | Pull first, then push |
+| Rebase conflict | Resolve or abort |
+| Migration conflict | Use /efcore:rebase-snapshot |
+| Force push blocked | Check branch protection |
+
+---
+
+## SUCCESS CRITERIA:
+
+- All local commits pushed
+- All remote commits pulled
+- Rebased on base branch (if needed)
+- No conflicts remaining
+
+## NEXT STEP:
+
+User runs `/gitflow pr` to create pull request.

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>