reviewflow 3.0.0

package/templates/fr/review-with-agents/SKILL.md

@@ -0,0 +1,225 @@
+---
+name: review-with-agents
+description: Code review avancée avec plusieurs agents séquentiels. À personnaliser pour votre projet.
+---
+
+# Code Review Avancée
+
+<!-- CUSTOMIZE: Définissez votre persona de reviewer -->
+**Tu es** : Un reviewer expert avec une connaissance approfondie de l'architecture logicielle.
+
+**Ton approche** :
+- Analyse multi-agents séquentielle (évite les problèmes mémoire)
+- Chaque agent se concentre sur un aspect
+- Scores et verdicts par agent
+- Rapport final complet
+
+## Points de Personnalisation
+
+<!-- CUSTOMIZE: Définissez vos agents -->
+Ce template utilise ces agents :
+1. **Architecture** - Structure du code et dépendances
+2. **Testing** - Couverture et qualité des tests
+3. **Code Quality** - Style, nommage, bonnes pratiques
+
+---
+
+## ⚡ Architecture Séquentielle (Anti Memory-Leak)
+
+**CRITIQUE** : Les agents sont exécutés UN PAR UN pour éviter les pics mémoire.
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    ORCHESTRATEUR SÉQUENTIEL                     │
+│                                                                 │
+│  [1] Architecture  →  [2] Testing  →  [3] Code Quality  → ...  │
+│                                                                 │
+│  Chaque agent :                                                 │
+│  1. Émet [PROGRESS:agent:started]                               │
+│  2. Analyse le code                                             │
+│  3. Émet [PROGRESS:agent:completed]                             │
+│  4. ATTEND avant de lancer le suivant                           │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Workflow
+
+### Phase 1 : Initialisation
+
+```
+[PHASE:initializing]
+[PROGRESS:context:started]
+```
+
+1. Récupérer les informations de la MR/PR
+2. Lister les fichiers modifiés
+3. Lire la configuration du projet (CLAUDE.md, etc.)
+
+```
+[PROGRESS:context:completed]
+```
+
+---
+
+### Phase 2 : Exécution Séquentielle des Agents
+
+```
+[PHASE:agents-running]
+```
+
+**Exécuter les agents UN PAR UN dans l'ordre :**
+
+---
+
+#### Agent 1 : Architecture
+
+```
+[PROGRESS:architecture:started]
+```
+
+<!-- CUSTOMIZE: Ajoutez vos règles d'architecture -->
+Vérifier :
+- Direction des dépendances (pointent vers l'intérieur)
+- Séparation des couches (UI, métier, données)
+- Pas de dépendances circulaires
+- Abstractions correctes
+
+**Score** : X/10 avec justification
+
+```
+[PROGRESS:architecture:completed]
+```
+
+---
+
+#### Agent 2 : Testing
+
+```
+[PROGRESS:testing:started]
+```
+
+<!-- CUSTOMIZE: Ajoutez vos règles de testing -->
+Vérifier :
+- Nouveau code testé
+- Tests significatifs (pas juste de la couverture)
+- Nommage correct des tests
+- Pas de tests flaky
+
+**Score** : X/10 avec justification
+
+```
+[PROGRESS:testing:completed]
+```
+
+---
+
+#### Agent 3 : Code Quality
+
+```
+[PROGRESS:code-quality:started]
+```
+
+<!-- CUSTOMIZE: Ajoutez vos règles de qualité -->
+Vérifier :
+- Conventions de nommage
+- Duplication de code
+- Qualité des commentaires
+- Organisation des imports
+
+**Score** : X/10 avec justification
+
+```
+[PROGRESS:code-quality:completed]
+```
+
+---
+
+### Phase 3 : Synthèse
+
+```
+[PHASE:synthesizing]
+[PROGRESS:synthesis:started]
+```
+
+Combiner les résultats en rapport final :
+
+```markdown
+# Code Review - MR/PR #[NUMÉRO]
+
+## Synthèse Exécutive
+
+| Agent | Score | Verdict |
+|-------|-------|---------|
+| Architecture | X/10 | [Verdict court] |
+| Testing | X/10 | [Verdict court] |
+| Code Quality | X/10 | [Verdict court] |
+
+**Score Global : X/10**
+
+---
+
+## Corrections Bloquantes
+
+### 1. [Titre]
+📍 `fichier.ts:42`
+
+**Agent** : [Quel agent a trouvé ça]
+**Problème** : [Description]
+**Correction** : [Solution]
+
+---
+
+## Corrections Importantes
+
+[Même format]
+
+---
+
+## Points Positifs
+
+| Aspect | Note |
+|--------|------|
+| [Pattern] | [Observation factuelle] |
+
+---
+
+## Checklist Avant Merge
+
+- [ ] [Bloquant 1]
+- [ ] [Bloquant 2]
+- [ ] Lancer les tests
+```
+
+```
+[PROGRESS:synthesis:completed]
+```
+
+---
+
+### Phase 4 : Publication
+
+```
+[PHASE:publishing]
+```
+
+Poster le rapport :
+
+```
+[POST_COMMENT:## Code Review - MR/PR #[NUMÉRO]\n\n[Contenu complet]]
+```
+
+```
+[PHASE:completed]
+```
+
+---
+
+## Sortie
+
+À la fin, émettre le marqueur de stats (OBLIGATOIRE) :
+
+```
+[REVIEW_STATS:blocking=X:warnings=X:suggestions=X:score=X]
+```

package/templates/skills/review-bootstrap/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: review-bootstrap
+description: Bootstrap skill that injects critical automation instructions for review context communication. Must be loaded BEFORE any review skill.
+---
+
+# Review Bootstrap - Context Communication Protocol
+
+## CRITICAL INSTRUCTIONS - MANDATORY EXECUTION
+
+**THIS IS NOT OPTIONAL. YOU MUST FOLLOW THESE INSTRUCTIONS NO MATTER WHAT.**
+
+### Step 1: Locate and Read the Context File
+
+At the START of your review, you MUST:
+
+1. Find the context file in `.claude/reviews/logs/` directory
+2. The file is named `{platform}-{project}-{mrNumber}.json`
+3. READ this file to get:
+   - `threads`: List of existing threads with their IDs
+   - `agentInstructions`: Instructions you MUST follow
+
+### Step 2: Understand the Thread Structure
+
+Each thread in the `threads` array has:
+```json
+{
+  "id": "abc123def...",      // EXACT ID to use for actions
+  "file": "path/to/file.ts",
+  "line": 42,
+  "status": "open",          // "open" or "resolved"
+  "body": "Original comment"
+}
+```
+
+### Step 3: After Your Analysis - UPDATE THE FILE
+
+**CRITICAL - DO NOT SKIP THIS STEP**
+
+After completing your review analysis, you MUST update the context file:
+
+1. For EACH thread you determine is **FIXED/CORRECTED**:
+   - Add a `THREAD_RESOLVE` action to the `actions` array
+   - Use the **EXACT** `id` from the thread
+
+2. Use the **Write** tool to update the file
+
+### Action Format
+
+```json
+{
+  "actions": [
+    {
+      "type": "THREAD_RESOLVE",
+      "threadId": "abc123def..."
+    },
+    {
+      "type": "THREAD_REPLY",
+      "threadId": "xyz789ghi...",
+      "message": "Verified: the fix correctly addresses the issue."
+    },
+    {
+      "type": "POST_INLINE_COMMENT",
+      "filePath": "src/path/to/file.ts",
+      "line": 42,
+      "body": "Comment on this line of the diff"
+    },
+    {
+      "type": "POST_COMMENT",
+      "body": "Global comment on the MR/PR"
+    }
+  ]
+}
+```
+
+### Example Workflow
+
+```
+1. Read context file
+2. See thread with id="5fb4be584ab5db9bd845aef7c9fd0ab696f9ef49", status="open"
+3. Analyze the code - determine the issue is FIXED
+4. Update context file actions array:
+   {
+     "actions": [
+       { "type": "THREAD_RESOLVE", "threadId": "5fb4be584ab5db9bd845aef7c9fd0ab696f9ef49" }
+     ]
+   }
+5. Write the updated JSON to the same file path
+```
+
+### MANDATORY RULES
+
+| Rule | Description |
+|------|-------------|
+| **MUST READ** | Read the context file at the start |
+| **MUST PRESERVE** | Keep ALL existing JSON content |
+| **MUST UPDATE** | Add resolved threads to `actions` array |
+| **MUST WRITE** | Use Write tool to save changes |
+| **MUST USE EXACT IDs** | Copy thread IDs exactly as they appear |
+
+### DO NOT
+
+- Do NOT use stdout markers like `[THREAD_RESOLVE:...]` - they are deprecated
+- Do NOT call `glab api` or `gh api` directly for thread resolution
+- Do NOT skip updating the context file
+- Do NOT modify thread IDs
+
+---
+
+## Integration with Review Skills
+
+This skill provides the communication protocol. Your project's review skill (e.g., `/review-followup`) handles the actual review logic.
+
+The flow is:
+```
+review-bootstrap (this) → Provides context communication rules
+review-followup (project) → Provides review logic and criteria
+```
+
+Both skills work together. Follow BOTH sets of instructions.

package/templates/skills/review-with-mcp.md

@@ -0,0 +1,133 @@
+# Review Skill Template with MCP Progress Tracking
+
+This template shows how to build a review skill that reports progress via MCP tools.
+
+## How It Works
+
+The MCP server automatically receives the job context via environment variables set by the review system:
+- `MCP_JOB_ID` - The unique job identifier (e.g., `gitlab:owner/repo:123`)
+- `MCP_LOCAL_PATH` - Path to the local repository
+- `MCP_MERGE_REQUEST_ID` - The MR/PR identifier
+- `MCP_JOB_TYPE` - Either `review` or `followup`
+
+**Your skill just needs to use the jobId in all MCP tool calls.** The system handles the rest.
+
+## MCP Tools Available
+
+When the MCP server is configured, you have access to these tools:
+
+| Tool | Purpose | Required Args |
+|------|---------|---------------|
+| `get_workflow` | Get workflow state and agent list | jobId |
+| `start_agent` | Signal agent start | jobId, agentName |
+| `complete_agent` | Signal agent completion | jobId, agentName, status |
+| `set_phase` | Update review phase | jobId, phase |
+| `get_threads` | Get MR/PR discussion threads | jobId |
+| `add_action` | Queue an action (resolve, comment) | jobId, type, ... |
+
+## Workflow Pattern
+
+```
+1. Call get_workflow(jobId) to get the list of agents
+2. Call set_phase(jobId, "agents-running")
+3. For each agent in order:
+   a. Call start_agent(jobId, agentName)
+   b. Execute your analysis
+   c. Call complete_agent(jobId, agentName, "success" or "failed")
+4. Call set_phase(jobId, "synthesizing")
+5. Compile your report
+6. Call get_threads(jobId) to see existing discussions
+7. Call add_action() for each thread to resolve or comment
+8. Call set_phase(jobId, "completed")
+```
+
+## Example Skill Implementation
+
+```markdown
+# My Review Skill
+
+## Activation
+Triggered by: `/my-review <MR_NUMBER>`
+
+## Workflow
+
+### Step 1: Initialize
+First, get the workflow to know which agents to run:
+- Call `get_workflow` with the jobId
+- Note the list of agents and their order
+
+### Step 2: Run Agents Sequentially
+For EACH agent in the workflow:
+
+1. Call `start_agent(jobId, agentName)` BEFORE starting
+2. Perform your analysis for that agent
+3. Call `complete_agent(jobId, agentName, "success")` when done
+   - Use "failed" with error message if analysis fails
+
+### Step 3: Handle Threads
+After all agents complete:
+1. Call `get_threads(jobId)` to see open discussions
+2. For each thread that should be resolved:
+   - Call `add_action(jobId, "THREAD_RESOLVE", threadId)`
+3. To add a review comment:
+   - Call `add_action(jobId, "POST_COMMENT", body="Your comment")`
+
+### Step 4: Finalize
+Call `set_phase(jobId, "completed")` when done.
+```
+
+## Phases
+
+| Phase | When to use |
+|-------|-------------|
+| `initializing` | Before starting agents |
+| `agents-running` | During agent execution |
+| `synthesizing` | Compiling final report |
+| `publishing` | Posting to GitLab/GitHub |
+| `completed` | All done |
+
+## Action Types
+
+### THREAD_RESOLVE
+Marks a discussion thread as resolved.
+```json
+{
+  "type": "THREAD_RESOLVE",
+  "threadId": "abc123",
+  "message": "Optional resolution message"
+}
+```
+
+### THREAD_REPLY
+Replies to a discussion thread.
+```json
+{
+  "type": "THREAD_REPLY",
+  "threadId": "abc123",
+  "message": "Your reply message"
+}
+```
+
+### POST_COMMENT
+Posts a general comment on the MR/PR.
+```json
+{
+  "type": "POST_COMMENT",
+  "body": "Your review comment"
+}
+```
+
+## Error Handling
+
+If an agent fails:
+1. Call `complete_agent(jobId, agentName, "failed", "Error description")`
+2. Continue with the next agent (don't stop the whole review)
+3. Include failed agents in your final report
+
+## Best Practices
+
+1. **Always call start_agent before analysis** - The dashboard shows real-time progress
+2. **Complete agents even on failure** - Use status="failed" with error message
+3. **Process agents sequentially** - Parallel execution can cause memory issues
+4. **Use get_threads to check context** - Understand existing discussions before acting
+5. **Batch actions at the end** - Add all actions, they execute after review completes