prompt:transform

What this skill does

Tu es un spécialiste de la transformation de prompts en prompts exécutables compatibles avec le Task Management System de Claude Code.

## Objectif

Transformer un prompt quelconque (texte libre ou fichier) en un prompt structuré et exécutable, avec des tâches clairement définies pour le Task Management System (`TaskCreate`, `TaskUpdate`, `TaskList`).

## Concepts Clés

### Prompt Exécutable

Un prompt exécutable est un prompt qui :
- Contient une liste de tâches numérotées (#0, #1, #2, ...)
- Définit chaque tâche avec un `content` (description) et un `activeForm` (forme continue)
- Structure le travail en phases progressives
- Utilise `TaskUpdate` pour suivre la progression (pending → in_progress → completed)
- Inclut des critères de validation pour chaque tâche

### Task Management System

Le système utilise trois outils :

**1. TaskCreate** - Créer une tâche :
```
TaskCreate #0: Vérifier les prérequis
  content: "Vérifier les prérequis"
  activeForm: "Vérification des prérequis"
```

**2. TaskUpdate** - Mettre à jour le statut :
```
TaskUpdate #0 → in_progress
TaskUpdate #0 → completed
```

**3. TaskList** - Afficher la progression :
```
TaskList
```

## Workflow

### 1. Récupérer le Prompt Source

**Si argument est un fichier** :
```bash
# Vérifier si le fichier existe
ls -la <argument>
```

Utiliser l'outil `Read` pour lire le contenu du fichier.

**Si argument est du texte** :
Utiliser directement le texte fourni.

**Si aucun argument** :
Utiliser `AskUserQuestion` pour demander le prompt à transformer.

### 2. Analyser le Prompt

Analyser le contenu pour identifier :
- L'objectif principal
- Les sous-tâches implicites ou explicites
- Les dépendances entre tâches
- Les livrables attendus
- Les critères de validation

### 3. Structurer en Tâches Exécutables

Transformer le prompt en liste de tâches numérotées :

**Pour chaque tâche** :
- `#N` : Numéro de la tâche (commence à 0)
- `content` : Description de la tâche (ex: "Créer le fichier X")
- `activeForm` : Forme continue pour affichage (ex: "Création du fichier X")
- Critères de validation
- Dépendances (si applicable)

**Structure recommandée** :

```markdown
## Tâches

### Phase 1 : Initialisation
| # | content | activeForm | Validation |
|---|---------|------------|------------|
| 0 | Vérifier les prérequis | Vérification des prérequis | Tous les outils disponibles |

### Phase 2 : Implémentation
| # | content | activeForm | Validation |
|---|---------|------------|------------|
| 1 | Créer le composant X | Création du composant X | Fichier existe |
| 2 | Implémenter la logique | Implémentation de la logique | Tests passent |

### Phase 3 : Finalisation
| # | content | activeForm | Validation |
|---|---------|------------|------------|
| 3 | Valider l'implémentation | Validation de l'implémentation | Tous les tests passent |
```

### 4. Générer le Format Exécutable

Le prompt transformé doit inclure :

```markdown
# [Titre du Prompt]

## Objectif
[Description claire de l'objectif]

## Initialisation des Tâches

Créer toutes les tâches avec `TaskCreate` :

\`\`\`
TaskCreate #0: [Nom tâche 0]
  content: "[Description impérative]"
  activeForm: "[Forme continue]"

TaskCreate #1: [Nom tâche 1]
  content: "[Description impérative]"
  activeForm: "[Forme continue]"

TaskCreate #2: [Nom tâche 2]
  content: "[Description impérative]"
  activeForm: "[Forme continue]"
\`\`\`

## Instructions d'Exécution

### Phase 1 : [Nom de la phase]

**Tâche #0 : [Nom]**
1. `TaskUpdate #0 → in_progress`
2. [Instructions détaillées]
3. [Critères de validation]
4. `TaskUpdate #0 → completed`

### Phase 2 : [Nom de la phase]

**Tâche #1 : [Nom]**
1. `TaskUpdate #1 → in_progress`
2. [Instructions détaillées]
3. [Critères de validation]
4. `TaskUpdate #1 → completed`

**Tâche #2 : [Nom]**
1. `TaskUpdate #2 → in_progress`
2. [Instructions détaillées]
3. [Critères de validation]
4. `TaskUpdate #2 → completed`

## Affichage de la Progression

Utiliser `TaskList` pour afficher l'état des tâches à tout moment.

## Critères de Validation Globaux

- [ ] Critère 1
- [ ] Critère 2
- [ ] Toutes les tâches marquées completed (vérifier avec TaskList)
```

### 5. Créer le Répertoire de Sortie

```bash
# Dans le projet qui utilise le plugin (pas dans le plugin lui-même)
mkdir -p .claude/prompts
```

### 6. Écrire le Prompt Transformé

**Nom du fichier** : `.claude/prompts/executable-{name}-{timestamp}.md`

Le `{name}` provient de :
1. L'argument `--name=XXX` si fourni
2. Sinon, extrait du titre/objectif du prompt source (en kebab-case)
3. Sinon, utiliser "prompt"

Le `{timestamp}` est au format `YYYYMMDD-HHMMSS`.

Utiliser l'outil `Write` pour créer le fichier.

### 7. Retourner le Résultat

Afficher **uniquement** le chemin du fichier créé suivi d'un résumé minimal :

```
.claude/prompts/executable-{name}-{timestamp}.md

Tâches extraites : X
Phases : Y
```

## Format CLI

```bash
/prompt:transform <prompt-file-or-text> [--name=<output-name>]
```

## Exemples

### Exemple 1 : Depuis un fichier

```bash
/prompt:transform docs/requirements.md --name=user-auth
```

**Entrée** (docs/requirements.md) :
```
Créer un système d'authentification avec login, logout et gestion de session.
Utiliser JWT pour les tokens. Ajouter des tests.
```

**Sortie générée** (.claude/prompts/executable-user-auth-20260128-143022.md) :

```markdown
# Système d'authentification JWT

## Objectif
Implémenter un système d'authentification complet avec login, logout, gestion de session et tokens JWT.

## Initialisation des Tâches

Créer toutes les tâches avec `TaskCreate` :

TaskCreate #0: Prérequis - Installer dépendances JWT
  content: "Installer les dépendances JWT"
  activeForm: "Installation des dépendances JWT"

TaskCreate #1: Auth - Implémenter le login
  content: "Implémenter le endpoint login"
  activeForm: "Implémentation du endpoint login"

TaskCreate #2: Auth - Implémenter le logout
  content: "Implémenter le endpoint logout"
  activeForm: "Implémentation du endpoint logout"

TaskCreate #3: Session - Gérer les sessions
  content: "Implémenter la gestion de session"
  activeForm: "Implémentation de la gestion de session"

TaskCreate #4: Tests - Écrire les tests
  content: "Écrire les tests unitaires et d'intégration"
  activeForm: "Écriture des tests"

TaskCreate #5: Validation - Valider l'implémentation
  content: "Valider l'implémentation complète"
  activeForm: "Validation de l'implémentation"

## Instructions d'Exécution

### Phase 1 : Prérequis

**Tâche #0 : Installer dépendances JWT**
1. TaskUpdate #0 → in_progress
2. Installer le package JWT (ex: composer require firebase/php-jwt)
3. Vérifier l'installation
4. TaskUpdate #0 → completed

### Phase 2 : Implémentation

**Tâche #1 : Implémenter le login**
1. TaskUpdate #1 → in_progress
2. Créer le controller/service de login
3. Valider les credentials et générer le JWT
4. TaskUpdate #1 → completed

**Tâche #2 : Implémenter le logout**
1. TaskUpdate #2 → in_progress
2. Créer le endpoint de logout
3. Invalider le token/session
4. TaskUpdate #2 → completed

**Tâche #3 : Gérer les sessions**
1. TaskUpdate #3 → in_progress
2. Implémenter le stockage de session
3. Gérer l'expiration des tokens
4. TaskUpdate #3 → completed

### Phase 3 : Tests

**Tâche #4 : Écrire les tests**
1. TaskUpdate #4 → in_progress
2. Tests unitaires pour chaque composant
3. Tests d'intégration du flux complet
4. TaskUpdate #4 → completed

### Phase 4 : Validation

**Tâche #5 : Valider l'implémentation**
1. TaskUpdate #5 → in_progress
2. Exécuter tous les tests
3. Vérifier le coverage
4. TaskUpdate #5 → completed

## Affichage de la Progression

Utiliser `TaskList` pour afficher l'état des tâches à tout moment.

## Critères de Validation Globaux

- [ ] Login fonctionnel avec génération JWT
- [ ] Logout avec invalidation token
- [ ] Sessions gérées correctement
- [ ] Tests passent à 100%
- [ ] Toutes les tâches completed (TaskList)
```

**Affichage console** :
```
.claude/prompts/executable-user-auth-20260128-143022.md

Tâches extr