devflow-cli 1.0.0__tar.gz → 2.2.0__tar.gz

{devflow_cli-1.0.0 → devflow_cli-2.2.0}/.gitignore

@@ -10,3 +10,4 @@ venv/
 *.tmp
 *.swp
 .DS_Store
+.coverage

{devflow_cli-1.0.0 → devflow_cli-2.2.0}/.specify/memory/constitution.md

@@ -159,7 +159,7 @@ prévaut. Un conflit détecté DOIT être résolu avant progression.
 - La complexité ajoutée DOIT être justifiée explicitement ;
   la charge de la preuve incombe à celui qui ajoute la complexité.
 
-**Version**: 1.1.0 | **Ratified**: 2026-03-15 | **Last Amended**: 2026-03-15
+**Version**: 1.3.0 | **Ratified**: 2026-03-15 | **Last Amended**: 2026-03-20
 
 ### Amendment Log
 
@@ -167,3 +167,13 @@ prévaut. Un conflit détecté DOIT être résolu avant progression.
   `docs/features/{{ISSUE_ID}}/` vers `.specify/specs/{{NAME}}/`.
   Justification: alignement avec spec-kit, decouplage documentation/specs.
   Migration: fallback triple + commande `devflow migrate`.
+- **1.2.0** (2026-03-15): Principe III amendé — ajout exception mode
+  fast pour les review gates. Les gates restent obligatoires en mode
+  full. Justification: réduction overhead pour features simples
+  (bug fix, documentation, spike). Filet de sécurité: pre-commit review.
+- **1.3.0** (2026-03-20): Principe III amendé — retrait exception mode
+  fast pour les review gates. Les gates sont désormais obligatoires
+  quel que soit le mode. Justification: l'exception créait une
+  contradiction architecturale (reviews dans OPTIONAL_STEPS vs
+  contrainte "Ne jamais sauter une review"). Filet de sécurité
+  additionnel: pre-commit review toujours actif.

devflow_cli-2.2.0/.specify/specs/010-flexible-pipeline/checklists/requirements.md

@@ -0,0 +1,36 @@
+# Specification Quality Checklist: Pipeline flexible avec étapes optionnelles
+
+**Purpose**: Validate specification completeness and quality before proceeding to planning
+**Created**: 2026-03-15
+**Feature**: [spec.md](../spec.md)
+
+## Content Quality
+
+- [x] No implementation details (languages, frameworks, APIs)
+- [x] Focused on user value and business needs
+- [x] Written for non-technical stakeholders
+- [x] All mandatory sections completed
+
+## Requirement Completeness
+
+- [x] No [NEEDS CLARIFICATION] markers remain
+- [x] Requirements are testable and unambiguous
+- [x] Success criteria are measurable
+- [x] Success criteria are technology-agnostic (no implementation details)
+- [x] All acceptance scenarios are defined
+- [x] Edge cases are identified
+- [x] Scope is clearly bounded
+- [x] Dependencies and assumptions identified
+
+## Feature Readiness
+
+- [x] All functional requirements have clear acceptance criteria
+- [x] User scenarios cover primary flows
+- [x] Feature meets measurable outcomes defined in Success Criteria
+- [x] No implementation details leak into specification
+
+## Notes
+
+- All items pass. Spec is ready for `/speckit.plan`.
+- Constitution Principe IV (rétrocompatibilité) est le garde-fou principal : les state.json existants restent valides.
+- Les review gates (review-spec, review-tasks, review-impl) sont optionnelles en mode fast mais le pre-commit review reste actif.

devflow_cli-2.2.0/.specify/specs/010-flexible-pipeline/plan.md

@@ -0,0 +1,139 @@
+# Implementation Plan: Pipeline flexible avec étapes optionnelles
+
+**Branch**: `010-flexible-pipeline` | **Date**: 2026-03-15 | **Spec**: [spec.md](./spec.md)
+**Input**: Feature specification from `/specs/010-flexible-pipeline/spec.md`
+
+## Summary
+
+Rendre le pipeline devflow flexible en distinguant étapes obligatoires (`spec`, `plan`, `tasks`, `implement`) et optionnelles (`clarify`, `review-spec`, `research`, `contracts`, `review-tasks`, `review-impl`, `docs`). Ajouter un mode `fast` (4 étapes) à `devflow feature --fast`. Amender la constitution Principe III pour autoriser le skip des review gates en mode fast.
+
+## Technical Context
+
+**Language/Version**: Python 3.11
+**Primary Dependencies**: typer, rich
+**Storage**: state.json (fichier local)
+**Testing**: pytest (115+ tests)
+**Target Platform**: macOS, Linux (CLI)
+**Project Type**: CLI toolkit
+**Constraints**: Rétrocompatibilité totale state.json (Principe IV)
+**Scale/Scope**: 4 fichiers Python modifiés + 2 fichiers doc modifiés + 1 amendement constitution
+
+## Constitution Check
+
+| Principe | Statut | Justification |
+|----------|--------|---------------|
+| I. Spec-Driven Development | PASS | spec.md validée et clarifiée |
+| II. Pipeline Séquentiel | PASS | l'ordre est préservé — seules certaines étapes sont sautées, pas réordonnées |
+| III. Gates de Review | AMENDEMENT REQUIS | Les review gates deviennent optionnelles en mode fast. Clarification acceptée : le pre-commit review reste comme filet de sécurité. L'amendement est une tâche explicite (FR-009). |
+| IV. Rétrocompatibilité | PASS | FR-008 : state.json sans `mode` = `full` par défaut |
+| V. Simplicité (YAGNI) | PASS | ajout minimal (`mode` + `skippedSteps` dans state.json, `--fast` dans feature) |
+| VI. Testabilité | PASS | tests existants protègent le mode full, nouveaux tests pour le mode fast |
+| VII. Intégration Linear | PASS | étapes sautées ne sont pas traversées, mapping inchangé |
+
+**Verdict** : PASS avec amendement constitution Principe III.
+
+## Project Structure
+
+### Source Code (fichiers à modifier)
+
+```text
+src/devflow_cli/
+├── __init__.py                  # FR-001 : OPTIONAL_STEPS constant
+├── core/
+│   └── state.py                 # FR-003, FR-005 : mode + skippedSteps dans FeatureState
+├── commands/
+│   └── feature.py               # FR-004 : option --fast
+└── (status.py lu par commande status — pas de modification directe si Rich formatting suffisant)
+
+commands/
+└── devflow.md                   # FR-002 : orchestrateur propose skip
+
+docs/
+└── pipeline.md                  # FR-007 : étapes optionnelles marquées
+
+.specify/memory/
+└── constitution.md              # FR-009 : amendement Principe III
+```
+
+## Design Decisions
+
+### DD-001 : Constante OPTIONAL_STEPS dans __init__.py
+
+**Décision** : ajouter `OPTIONAL_STEPS = {"clarify", "review-spec", "research", "contracts", "review-tasks", "review-impl", "docs"}` à côté de `STEPS`.
+
+**Rationale** : source de vérité unique pour distinguer obligatoire vs optionnel. Utilisé par l'orchestrateur, le status, et la documentation.
+
+### DD-002 : Champ `mode` dans state.json
+
+**Décision** : ajouter `mode: str = "full"` dans `FeatureState`. Valeurs possibles : `"full"` | `"fast"`.
+
+**Rationale** : le mode détermine quelles étapes sont requises. En `fast`, seules `spec`, `plan`, `tasks`, `implement` (+ `done` terminal) sont requises. En `full`, toutes les 13 étapes.
+
+### DD-003 : Champ `skippedSteps` dans state.json
+
+**Décision** : ajouter `skippedSteps: list[str] = []` dans `FeatureState`.
+
+**Rationale** : distinguer "pas encore fait" de "explicitement sauté". Permet à `devflow status` d'afficher la progression correctement.
+
+### DD-004 : `total_steps` dynamique
+
+**Décision** : `total_steps` dans `FeatureState` retourne `len(STEPS) - len(skippedSteps)` au lieu de `len(STEPS)` fixe.
+
+**Rationale** : la progression affichée doit refléter le nombre d'étapes réellement requises, pas le total théorique.
+
+### DD-005 : Mode fast = skip automatique dans l'orchestrateur
+
+**Décision** : quand `mode == "fast"`, l'orchestrateur (`/devflow`) saute automatiquement les étapes optionnelles sans demander. En mode `full`, il propose le skip avec confirmation.
+
+**Rationale** : le mode fast est opt-in explicite — pas besoin de re-confirmer chaque skip.
+
+### DD-006 : Amendement constitution minimaliste
+
+**Décision** : ajouter une exception au Principe III : "En mode fast (`state.json: mode = "fast"`), les review gates sont optionnelles. Le pre-commit review (`pre-commit-review` agent) reste actif comme filet de sécurité."
+
+**Rationale** : amendement mineur (MINOR version bump), pas de suppression de principe.
+
+## Changements par fichier
+
+### `__init__.py` (FR-001)
+
+Ajouter après `STEPS` :
+```python
+OPTIONAL_STEPS = {"clarify", "review-spec", "research", "contracts", "review-tasks", "review-impl", "docs"}
+FAST_STEPS = ["spec", "plan", "tasks", "implement", "done"]
+```
+
+### `state.py` (FR-003, FR-005)
+
+Ajouter à `FeatureState` :
+- `mode: str = "full"`
+- `skippedSteps: list[str] = field(default_factory=list)`
+- Modifier `total_steps` → `len(STEPS) - len(self.skippedSteps)`
+
+### `feature.py` (FR-004)
+
+Ajouter option `--fast` :
+- `fast: bool = typer.Option(False, "--fast", help="Mode minimal (4 étapes)")`
+- Si `fast=True`, passer `mode="fast"` à `create_state()`
+- Modifier `create_state()` pour accepter un paramètre `mode`
+
+### `commands/devflow.md` (FR-002)
+
+Mettre à jour l'orchestrateur pour :
+- Lire `mode` depuis state.json
+- En mode fast : sauter automatiquement les étapes dans `OPTIONAL_STEPS`
+- En mode full : proposer le skip des étapes optionnelles avec confirmation
+
+### `docs/pipeline.md` (FR-007)
+
+Ajouter une colonne "Obligatoire" au tableau des étapes et une section "Mode fast".
+
+### `.specify/memory/constitution.md` (FR-009)
+
+Amender Principe III : ajout exception mode fast. Bump version 1.1.0 → 1.2.0 (MINOR).
+
+## Complexity Tracking
+
+| Violation | Why Needed | Simpler Alternative Rejected Because |
+|-----------|------------|-------------------------------------|
+| Amendement constitution Principe III | Mode fast nécessite skip des review gates | Garder les gates obligatoires en fast = 7 étapes minimum, annule l'intérêt du mode fast |

devflow_cli-2.2.0/.specify/specs/010-flexible-pipeline/quickstart.md

@@ -0,0 +1,38 @@
+# Quickstart: Pipeline flexible avec étapes optionnelles
+
+**Feature**: 010-flexible-pipeline
+**Date**: 2026-03-15
+
+## Ordre d'exécution
+
+1. **`__init__.py`** — ajouter `OPTIONAL_STEPS` et `FAST_STEPS` (fondation)
+2. **`state.py`** — ajouter `mode` + `skippedSteps` + `total_steps` dynamique
+3. **`feature.py`** — ajouter `--fast` option + passer mode à create_state
+4. **`commands/devflow.md`** — orchestrateur : skip auto en fast, proposition en full
+5. **`constitution.md`** — amendement Principe III
+6. **`docs/pipeline.md`** — marquer étapes optionnelles
+
+## Validation
+
+```bash
+# Tests existants passent toujours
+pytest tests/ -v
+
+# Test mode fast
+devflow feature TEST-FAST --fast
+# Vérifier state.json contient mode: "fast"
+
+# Test status en mode fast
+devflow status
+# Vérifier progression sur 4 étapes (pas 13)
+
+# Test rétrocompat
+# Prendre un state.json existant sans champ mode → doit fonctionner en mode full
+```
+
+## Points d'attention
+
+- `create_state()` doit accepter un paramètre `mode` optionnel sans casser les appels existants
+- `FeatureState.__dataclass_fields__` filtrage dans `read_state()` gère automatiquement les nouveaux champs (absent = default)
+- L'amendement constitution doit bumper la version (1.1.0 → 1.2.0 MINOR)
+- Les tests existants utilisent `create_state(path, issue_id)` sans `mode` — doivent continuer de fonctionner

devflow_cli-2.2.0/.specify/specs/010-flexible-pipeline/research.md

@@ -0,0 +1,26 @@
+# Research: Pipeline flexible avec étapes optionnelles
+
+**Feature**: 010-flexible-pipeline
+**Date**: 2026-03-15
+
+## Décisions
+
+### R-001 : Représentation du mode dans state.json
+
+**Décision** : champ `mode` avec valeurs `"full"` | `"fast"`, défaut `"full"`.
+
+**Rationale** : simple, extensible (on pourrait ajouter `"custom"` plus tard), rétrocompatible (state.json sans `mode` = `"full"`).
+
+**Alternatives** : liste des étapes requises dans state.json — trop verbeux, risque de désynchronisation avec `STEPS`.
+
+### R-002 : Skip explicite vs implicite
+
+**Décision** : en mode fast, le skip est automatique (implicite). En mode full, le skip est proposé par l'orchestrateur (explicite avec confirmation).
+
+**Rationale** : le mode fast est un choix délibéré au `devflow feature --fast` — pas besoin de re-confirmer. En mode full, le skip est une exception qui mérite attention.
+
+### R-003 : Impact sur `devflow status`
+
+**Décision** : `total_steps` dynamique basé sur `len(STEPS) - len(skippedSteps)`. Les étapes sautées sont affichées avec un marqueur visuel distinct (ex: `⊘` ou `[skipped]`).
+
+**Rationale** : la barre de progression doit refléter la réalité. Un 4/13 qui devrait être 4/4 est trompeur.

devflow_cli-2.2.0/.specify/specs/010-flexible-pipeline/spec.md

@@ -0,0 +1,155 @@
+# Feature Specification: Pipeline flexible avec étapes optionnelles
+
+**Feature Branch**: `010-flexible-pipeline`
+**Created**: 2026-03-15
+**Status**: Draft
+**Project Type**: Brownfield
+**Input**: Réduire l'overhead du pipeline devflow en rendant certaines étapes optionnelles et en ajoutant un mode "fast" pour les features simples.
+
+## Clarifications
+
+### Session 2026-03-15
+
+- Q: Review gates en mode fast vs Constitution Principe III (NON-NÉGOCIABLE) ? → A: Review gates optionnelles en mode fast, obligatoires en mode full. Le mode fast est un trade-off assumé (vitesse vs rigueur). Le pre-commit review reste comme filet de sécurité. Nécessite un amendement mineur de la constitution (Principe III : ajout d'une exception pour le mode fast).
+- Q: Étapes `constitution` et `done` — obligatoires ou optionnelles ? → A: `constitution` est un pré-requis projet (hors pipeline feature), `done` est un état terminal automatique. Ni l'un ni l'autre ne sont dans les listes obligatoire/optionnel — ils sont hors scope du mode fast/full.
+
+## Comportement existant
+
+### État actuel
+
+Le pipeline devflow impose 13 étapes séquentielles obligatoires :
+`constitution → spec → clarify → review-spec → research → plan → contracts → tasks → review-tasks → implement → review-impl → docs → done`
+
+Le `state.json` enregistre `currentStep` et `completedSteps`. L'orchestrateur (`/devflow`) vérifie que chaque étape est complétée avant de passer à la suivante.
+
+**Tolérance implicite existante** : la commande `/devflow` (orchestrateur) reconnaît déjà que certaines étapes peuvent être absentes de `completedSteps` sans bloquer :
+- `clarify` absent quand `currentStep` >= `review-spec`
+- `research` absent quand `currentStep` >= `plan`
+- `contracts` absent quand `currentStep` >= `tasks`
+
+La constitution (Principe IV) impose que les `state.json` sans `clarify`, `research` ou `contracts` dans `completedSteps` restent valides.
+
+### Flux existants
+
+1. **Flux complet** : un développeur exécute les 13 commandes dans l'ordre. Chaque commande produit un artefact et fait avancer `currentStep`.
+2. **Flux avec skip implicite** : un développeur saute `clarify` ou `research` en passant directement à l'étape suivante. L'orchestrateur tolère mais ne guide pas explicitement.
+
+### Dépendances identifiées
+
+- **`__init__.py:STEPS`** : liste ordonnée des 13 étapes, utilisée par `state.py` et l'orchestrateur
+- **`state.py:FeatureState`** : structure du state.json, `total_steps` calculé depuis `STEPS`
+- **`commands/devflow.md`** : orchestrateur qui lit `currentStep` et décide la prochaine commande
+- **Constitution Principe IV** : rétrocompatibilité des state.json sans étapes optionnelles
+- **Constitution Principe II** : pipeline séquentiel obligatoire (doit être respecté même en mode fast)
+
+### Limitations connues
+
+- Aucune commande pour sauter explicitement une étape — le skip est implicite et non documenté
+- Pas de mode "fast" ou "minimal" pour les features simples (bug fix, documentation, spike)
+- L'utilisateur ne sait pas quelles étapes sont optionnelles vs obligatoires
+- Le `total_steps` dans `state.py` compte toujours 13 même si des étapes sont sautées — la progression affichée est trompeuse
+
+## Impact sur l'existant
+
+### Composants affectés
+
+- **`__init__.py`** : ajout de la notion d'étapes optionnelles (modifié)
+- **`state.py`** : adaptation de `total_steps` pour exclure les étapes sautées (modifié)
+- **`commands/devflow.md`** : orchestrateur mis à jour pour proposer le skip d'étapes optionnelles (modifié)
+- **Documentation** : `docs/pipeline.md` et `README.md` mis à jour pour refléter la flexibilité (modifié)
+
+### Risques de régression
+
+- **state.json existants** : aucun risque — les state.json sans étapes optionnelles restent valides (Principe IV)
+- **Pipeline séquentiel** : les étapes obligatoires (spec, plan, tasks, implement) ne peuvent pas être sautées — le risque est de permettre un skip trop permissif. Atténuation : les review gates restent obligatoires par défaut.
+- **Linear mapping** : les étapes sautées ne doivent pas casser la synchronisation Linear. Atténuation : sauter une étape ne change pas le mapping, elle n'est simplement pas traversée.
+
+### Stratégie de migration
+
+Rétrocompatible. Les state.json existants restent valides. Le mode "fast" est opt-in (pas de changement de comportement par défaut). Les features en cours ne sont pas affectées.
+
+## User Scenarios & Testing
+
+### User Story 1 — Sauter une étape optionnelle explicitement (Priority: P1)
+
+Un développeur travaille sur un bug fix simple. Après la spec, il veut passer directement au plan sans exécuter `clarify` ni `review-spec`. L'orchestrateur lui propose de sauter les étapes optionnelles.
+
+**Why this priority** : c'est le cas d'usage le plus fréquent — la majorité des features ne nécessitent pas toutes les 13 étapes.
+
+**Independent Test** : exécuter `/devflow` après `spec`, vérifier que les étapes optionnelles sont proposées comme skip-ables.
+
+**Acceptance Scenarios** :
+
+1. **Given** une feature dont `currentStep` est `clarify`, **When** le développeur exécute `/devflow`, **Then** l'orchestrateur propose de sauter `clarify` (optionnel) ou de l'exécuter.
+2. **Given** un développeur qui choisit de sauter `clarify`, **When** le skip est confirmé, **Then** `currentStep` avance à `review-spec` (ou la prochaine étape non-sautée) et `clarify` est marqué comme `skipped` dans le state.json.
+3. **Given** une feature avec des étapes sautées, **When** `devflow status` est exécuté, **Then** les étapes sautées sont affichées distinctement des étapes complétées.
+
+---
+
+### User Story 2 — Lancer une feature en mode fast (Priority: P1)
+
+Un développeur veut créer une feature avec un pipeline minimal (4 étapes : spec → plan → tasks → implement). Il ne veut pas être guidé à travers les 13 étapes.
+
+**Why this priority** : réduit l'overhead de 13 à 4 étapes pour les features simples, répondant directement à la critique "waterfall déguisé".
+
+**Independent Test** : créer une feature en mode fast et vérifier que seules 4 étapes sont requises.
+
+**Acceptance Scenarios** :
+
+1. **Given** un développeur qui exécute `devflow feature KS-456 --fast`, **When** la feature est créée, **Then** le state.json contient un champ indiquant le mode fast et seules les étapes `spec`, `plan`, `tasks`, `implement` sont requises.
+2. **Given** une feature en mode fast, **When** le développeur exécute `/devflow`, **Then** l'orchestrateur ne propose que les 4 étapes (pas clarify, research, contracts, review gates, docs).
+3. **Given** une feature en mode fast, **When** `devflow status` est exécuté, **Then** la progression est calculée sur 4 étapes (pas 13).
+
+---
+
+### User Story 3 — Voir clairement quelles étapes sont obligatoires vs optionnelles (Priority: P2)
+
+Un nouvel utilisateur de devflow consulte la documentation ou exécute `devflow status`. Il veut comprendre quelles étapes il doit absolument faire et lesquelles il peut sauter.
+
+**Why this priority** : sans cette visibilité, l'utilisateur ne sait pas qu'il peut sauter des étapes.
+
+**Independent Test** : exécuter `devflow status` et vérifier que les étapes optionnelles sont marquées distinctement.
+
+**Acceptance Scenarios** :
+
+1. **Given** un développeur qui consulte `docs/pipeline.md`, **When** il lit la documentation, **Then** chaque étape est marquée comme obligatoire ou optionnelle.
+2. **Given** un développeur qui exécute `devflow status KS-123`, **When** le statut s'affiche, **Then** les étapes optionnelles sont visuellement distinctes (couleur, icône ou label).
+
+---
+
+### Edge Cases
+
+- Que se passe-t-il si un développeur saute `review-spec` en mode full ? Les review gates sont obligatoires en mode full — le skip nécessite un avertissement explicite. En mode fast, les review gates sont automatiquement sautées.
+- Que se passe-t-il si un développeur en mode fast veut revenir au mode complet mid-feature ? Le mode doit pouvoir être changé à tout moment (le state.json enregistre le mode, pas les étapes futures).
+- Que se passe-t-il si un state.json existant n'a pas de champ `mode` ? Le mode par défaut est `full` (13 étapes) — rétrocompatibilité Principe IV.
+- Que se passe-t-il si toutes les review gates sont sautées en mode fast ? Le commit `/review` (pre-commit) reste actif comme filet de sécurité.
+
+## Requirements
+
+### Functional Requirements
+
+- **FR-001** : Le système DOIT distinguer les étapes obligatoires et optionnelles du pipeline. Étapes obligatoires : `spec`, `plan`, `tasks`, `implement`. Étapes optionnelles : `clarify`, `review-spec`, `research`, `contracts`, `review-tasks`, `review-impl`, `docs`. Note : `constitution` est un pré-requis projet (hors pipeline feature) et `done` est un état terminal automatique — ni l'un ni l'autre ne sont concernés par le mode fast/full.
+- **FR-002** : L'orchestrateur (`/devflow`) DOIT proposer de sauter les étapes optionnelles quand elles sont la prochaine étape courante.
+- **FR-003** : Le state.json DOIT enregistrer les étapes sautées (champ `skippedSteps` ou marqueur dans `completedSteps`).
+- **FR-004** : La commande `devflow feature` DOIT accepter une option `--fast` qui configure le mode minimal (4 étapes obligatoires uniquement).
+- **FR-005** : Le state.json DOIT supporter un champ `mode` (`full` | `fast`) avec valeur par défaut `full` pour les state.json existants.
+- **FR-006** : La commande `devflow status` DOIT afficher la progression en fonction du mode (4 ou 13 étapes) et distinguer visuellement les étapes sautées.
+- **FR-007** : La documentation (`docs/pipeline.md`) DOIT indiquer clairement quelles étapes sont optionnelles.
+- **FR-008** : Les state.json existants sans champ `mode` DOIVENT rester valides et fonctionner en mode `full` par défaut (Principe IV constitution).
+- **FR-009** : La constitution DOIT être amendée (Principe III) pour autoriser le skip des review gates en mode fast, avec mention explicite que le pre-commit review reste actif comme filet de sécurité.
+
+### Key Entities
+
+- **Mode de pipeline** : `full` (13 étapes, par défaut) ou `fast` (4 étapes : spec, plan, tasks, implement).
+- **Étape optionnelle** : étape qui peut être sautée sans bloquer la progression du pipeline.
+- **Étape sautée** : étape optionnelle qui a été explicitement ignorée par le développeur.
+
+## Success Criteria
+
+### Measurable Outcomes
+
+- **SC-001** : Un développeur peut compléter une feature en mode fast en 4 étapes au lieu de 13 — vérifié par test end-to-end.
+- **SC-002** : `devflow status` affiche la progression correcte selon le mode (4/4 en fast, X/13 en full) — vérifié par test.
+- **SC-003** : Les state.json existants (sans champ `mode`) continuent de fonctionner sans modification — vérifié par les 115+ tests existants.
+- **SC-004** : La documentation pipeline indique clairement les étapes optionnelles — vérifié par lecture.
+- **SC-005** : No regression — les 115+ tests existants passent sans modification.

devflow_cli-2.2.0/.specify/specs/010-flexible-pipeline/tasks.md

@@ -0,0 +1,126 @@
+# Tasks: Pipeline flexible avec étapes optionnelles
+
+**Input**: Design documents from `/specs/010-flexible-pipeline/`
+**Prerequisites**: plan.md (required), spec.md (required), research.md, quickstart.md
+
+**Tests**: Non demandés explicitement — tests de non-régression couverts par la suite existante (115+). Un test pour le mode fast est ajouté dans Polish.
+
+**Organization**: Les constantes (`__init__.py`) et le modèle (`state.py`) sont foundational. Les user stories dépendent de cette fondation.
+
+## Format: `[T-XXX] [P?] [PX] [USX] Description — Réf: FR-XXX`
+
+- **[P]**: Can run in parallel (different files, no dependencies)
+- **[PX]**: Priorité de la user story
+- **[USX]**: Which user story this task belongs to
+
+---
+
+## Phase 1: Setup
+
+**Purpose**: Aucun setup nécessaire.
+
+**Checkpoint**: N/A
+
+---
+
+## Phase 2: Foundational (constantes + modèle state.json)
+
+**Purpose**: Ajouter `OPTIONAL_STEPS`, `FAST_STEPS` dans `__init__.py` et `mode` + `skippedSteps` dans `FeatureState`. Ces changements sont prérequis pour toutes les user stories.
+
+**⚠️ CRITICAL**: `feature.py`, l'orchestrateur et `status` dépendent tous de ces constantes et du modèle.
+
+- [x] [T-001] Ajouter les constantes `OPTIONAL_STEPS` et `FAST_STEPS` dans src/devflow_cli/__init__.py — Réf: FR-001. Ajouter après `STEPS` : `OPTIONAL_STEPS = {"clarify", "review-spec", "research", "contracts", "review-tasks", "review-impl", "docs"}` (set pour lookup O(1)) et `FAST_STEPS = ["spec", "plan", "tasks", "implement", "done"]` (liste ordonnée). Vérifier que `set(FAST_STEPS) | OPTIONAL_STEPS | {"constitution"}` == `set(STEPS) | {"constitution"}` (cohérence).
+- [x] [T-002] Ajouter `mode` et `skippedSteps` dans `FeatureState` de src/devflow_cli/core/state.py — Réf: FR-003, FR-005. Ajouter deux champs au dataclass : `mode: str = "full"` et `skippedSteps: list[str] = field(default_factory=list)`. Modifier la property `total_steps` pour retourner `len(STEPS) - len(self.skippedSteps)` au lieu de `len(STEPS)`. Modifier `create_state()` pour accepter un paramètre optionnel `mode: str = "full"` et le passer au constructeur `FeatureState`. Vérifier que `read_state()` fonctionne avec des state.json existants sans ces champs (le filtrage `__dataclass_fields__` + valeurs par défaut gère ça automatiquement).
+
+**Checkpoint**: `pytest tests/test_state.py -v` passe. `python -c "from devflow_cli import OPTIONAL_STEPS, FAST_STEPS; print(OPTIONAL_STEPS)"` fonctionne.
+
+---
+
+## Phase 3: User Story 1 — Sauter une étape optionnelle explicitement (Priority: P1)
+
+**Goal**: L'orchestrateur `/devflow` propose de sauter les étapes optionnelles en mode full.
+
+**Independent Test**: Exécuter `/devflow` après spec, vérifier que clarify est proposé comme skip-able.
+
+- [x] [T-003] [P1] [US1] Mettre à jour l'orchestrateur dans commands/devflow.md pour proposer le skip des étapes optionnelles — Réf: FR-002. Dans la section de détermination de la prochaine commande, ajouter la logique : si `currentStep` est dans `OPTIONAL_STEPS` ET `mode == "full"`, proposer à l'utilisateur de sauter l'étape ou de l'exécuter. Si l'utilisateur choisit de sauter : ajouter l'étape à `skippedSteps` dans state.json, ajouter à `completedSteps`, avancer `currentStep` à la prochaine étape non-sautée, et afficher un message confirmant le skip. En mode `fast` : sauter automatiquement sans demander.
+
+**Checkpoint**: Relire `commands/devflow.md` et vérifier la logique de skip est documentée pour les deux modes.
+
+---
+
+## Phase 4: User Story 2 — Lancer une feature en mode fast (Priority: P1)
+
+**Goal**: `devflow feature KS-456 --fast` crée une feature en mode fast (4 étapes).
+
+**Independent Test**: `devflow feature TEST-FAST --fast` → state.json contient `mode: "fast"`.
+
+- [x] [T-004] [P1] [US2] Ajouter l'option `--fast` à la commande `feature()` dans src/devflow_cli/commands/feature.py — Réf: FR-004. Ajouter le paramètre `fast: bool = typer.Option(False, "--fast", help="Mode minimal (4 étapes : spec, plan, tasks, implement)")`. Passer `mode="fast" if fast else "full"` à `create_state()`. Afficher le mode dans le récapitulatif final (ex: `Mode    : fast (4 étapes)`).
+
+**Checkpoint**: `devflow feature TEST-FAST --fast` crée un state.json avec `"mode": "fast"`. `devflow feature TEST-FULL` crée un state.json avec `"mode": "full"`.
+
+---
+
+## Phase 5: User Story 3 — Visibilité obligatoire vs optionnel (Priority: P2)
+
+**Goal**: `devflow status` et `docs/pipeline.md` distinguent clairement les étapes obligatoires et optionnelles.
+
+**Independent Test**: `devflow status` affiche la progression sur 4 étapes en mode fast, 13 en mode full.
+
+- [x] [T-005] [P] [P2] [US3] Mettre à jour docs/pipeline.md pour marquer les étapes optionnelles — Réf: FR-007. Ajouter une colonne "Requis" au tableau de chaque étape : "Obligatoire" pour spec/plan/tasks/implement, "Optionnel" pour les autres. Ajouter une section "## Mode fast" en bas décrivant le pipeline minimal (4 étapes) et comment l'activer (`devflow feature --fast`).
+- [x] [T-006] [P] [P2] [US3] Amender la constitution Principe III dans .specify/memory/constitution.md — Réf: FR-009. Ajouter après le paragraphe des review gates : "**Exception mode fast** : en mode fast (`state.json: mode = "fast"`), les review gates sont optionnelles. Le pre-commit review (`pre-commit-review` agent) reste actif comme filet de sécurité." Bumper la version de 1.1.0 à 1.2.0. Ajouter une entrée dans l'Amendment Log.
+- [x] [T-010] [P2] [US3] Adapter l'affichage de `devflow status` pour distinguer les étapes sautées dans src/devflow_cli/commands/status.py — Réf: FR-006. Lire `skippedSteps` depuis le state.json. Pour chaque étape dans le récapitulatif, si elle est dans `skippedSteps`, afficher un marqueur visuel `[dim]⊘ skipped[/dim]` (Rich) au lieu de `[ ] pending`. La barre de progression doit utiliser `total_steps` (dynamique, déjà calculé par T-002) pour refléter le nombre d'étapes réellement requises. En mode fast, afficher `Mode : fast (4 étapes)` dans l'en-tête du statut.
+
+**Checkpoint**: `docs/pipeline.md` contient une section "Mode fast". `constitution.md` version 1.2.0 avec exception mode fast.
+
+---
+
+## Phase 6: Polish & Cross-Cutting Concerns
+
+**Purpose**: Tests de non-régression + test mode fast + CHANGELOG.
+
+- [x] [T-007] Ajouter un test pour le mode fast dans tests/test_state.py — Vérifier que `create_state(path, "TEST", mode="fast")` produit un state.json avec `mode: "fast"` et que `total_steps` retourne 13 (pas de skippedSteps encore). Vérifier que `create_state(path, "TEST")` sans mode produit `mode: "full"` (rétrocompat).
+- [x] [T-008] Exécuter la suite de tests complète — Réf: FR-008, SC-005. `pytest tests/ -v` → 115+ tests passent, 0 régression. Compter le total (doit être > 115).
+- [x] [T-009] Mettre à jour CHANGELOG.md — Ajouter entrée pour cette feature (pipeline flexible, mode fast, étapes optionnelles, amendement constitution).
+
+---
+
+## Dependencies & Execution Order
+
+### Phase Dependencies
+
+- **Foundational (Phase 2)** : T-001 et T-002 séquentiels (T-002 importe depuis T-001)
+- **US1 (Phase 3)** : T-003 dépend de T-001 + T-002 (utilise OPTIONAL_STEPS et mode)
+- **US2 (Phase 4)** : T-004 dépend de T-002 (create_state avec mode)
+- **US3 (Phase 5)** : T-005, T-006 indépendants — peuvent commencer dès Phase 2 terminée. T-010 dépend de T-002 (skippedSteps dans state.py)
+- **Polish (Phase 6)** : T-007, T-008, T-009 après toutes les phases
+
+### Parallel Opportunities
+
+- **Phase 5** : T-005 (docs), T-006 (constitution) et T-010 (status.py) sont parallèles (fichiers distincts)
+- **Phase 3+4** : T-003 (commande markdown) et T-004 (Python) sont parallèles si Phase 2 terminée
+
+---
+
+## Implementation Strategy
+
+### MVP First (User Story 2)
+
+1. T-001 + T-002 (fondation)
+2. T-004 (--fast dans feature.py)
+3. **STOP and VALIDATE** : `devflow feature TEST --fast` → state.json avec `mode: "fast"` ?
+
+### Incremental Delivery
+
+1. T-001 + T-002 → constantes + modèle
+2. T-003 + T-004 → orchestrateur skip + --fast (en parallèle)
+3. T-005 + T-006 → docs + constitution (en parallèle)
+4. T-007 + T-008 + T-009 → tests + validation + CHANGELOG
+
+---
+
+## Notes
+
+- `create_state()` doit garder sa signature compatible (paramètre `mode` optionnel avec défaut "full")
+- Le filtrage `__dataclass_fields__` dans `read_state()` gère automatiquement les state.json sans `mode`/`skippedSteps`
+- L'orchestrateur `devflow.md` est un fichier markdown (commande Claude Code) — pas de tests unitaires possibles, validation par relecture
+- L'amendement constitution est un MINOR bump (ajout d'exception, pas de suppression de principe)

devflow_cli-2.2.0/.specify/specs/011-cursor-support/checklists/requirements.md

@@ -0,0 +1,36 @@
+# Specification Quality Checklist: Support Cursor
+
+**Purpose**: Validate specification completeness and quality before proceeding to planning
+**Created**: 2026-03-15
+**Feature**: [spec.md](../spec.md)
+
+## Content Quality
+
+- [x] No implementation details (languages, frameworks, APIs)
+- [x] Focused on user value and business needs
+- [x] Written for non-technical stakeholders
+- [x] All mandatory sections completed
+
+## Requirement Completeness
+
+- [x] No [NEEDS CLARIFICATION] markers remain
+- [x] Requirements are testable and unambiguous
+- [x] Success criteria are measurable
+- [x] Success criteria are technology-agnostic (no implementation details)
+- [x] All acceptance scenarios are defined
+- [x] Edge cases are identified
+- [x] Scope is clearly bounded
+- [x] Dependencies and assumptions identified
+
+## Feature Readiness
+
+- [x] All functional requirements have clear acceptance criteria
+- [x] User scenarios cover primary flows
+- [x] Feature meets measurable outcomes defined in Success Criteria
+- [x] No implementation details leak into specification
+
+## Notes
+
+- All items pass. Spec is ready for `/speckit.plan`.
+- Le support Cursor est minimal viable — pas de commandes slash natives Cursor, mais des rules .mdc avec le workflow complet.
+- devflow context cursor et devflow export cursor fonctionnent déjà — cette feature comble le gap de devflow init --ai cursor.