devflow-cli 2.3.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

devflow_cli/__init__.py

@@ -1,6 +1,7 @@
 """devflow CLI — Spec-Driven Development workflow."""
 
-VERSION = "2.3.0"
+VERSION = "2.9.0"
+STATE_SCHEMA_VERSION = 3
 
 STEPS = [
     "constitution",  # Pré-requis projet (1/projet). Auto-complétée si .specify/memory/constitution.md existe.
@@ -20,6 +21,12 @@ STEPS = [
 
 OPTIONAL_STEPS = {"clarify", "research", "contracts", "docs"}
 
+# Le mode fast conserve les gates et les bornes du pipeline. Il compte donc
+# 9 etapes effectives, dont 4 etapes productives principales.
+FAST_PRODUCTIVE_STEPS = ("spec", "plan", "tasks", "implement")
+FAST_STEP_COUNT = len(STEPS) - len(OPTIONAL_STEPS)
+FULL_STEP_COUNT = len(STEPS)
+
 REVIEW_GATES = {"review-spec", "review-tasks", "review-impl"}
 
 STEP_ARTIFACTS = {
@@ -51,7 +58,21 @@ STEP_LINEAR_MAPPING = {
     "done": "Done",
 }
 
-SUPPORTED_AGENTS = ["claude-code", "cursor"]
+# Ordre de progression des statuts Linear (pour non-régression lors de la sync).
+# Un statut ne doit jamais régresser : si l'index courant >= index cible, on ne met pas à jour.
+STEP_LINEAR_ORDER = [
+    "Backlog",
+    "Spec",
+    "Research",
+    "Plan",
+    "Tasks",
+    "Review",
+    "In Progress",
+    "Doc",
+    "Done",
+]
+
+SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
 
 # Mapping speckit → devflow pour la migration
 SPECKIT_STEP_MAP = {
@@ -85,4 +106,8 @@ assert OPTIONAL_STEPS <= _steps_set, f"OPTIONAL_STEPS not subset of STEPS: {OPTI
 assert REVIEW_GATES <= _steps_set, f"REVIEW_GATES not subset of STEPS: {REVIEW_GATES - _steps_set}"
 assert set(STEP_ARTIFACTS.keys()) <= _steps_set, f"STEP_ARTIFACTS has unknown keys: {set(STEP_ARTIFACTS.keys()) - _steps_set}"
 assert set(STEP_LINEAR_MAPPING.keys()) <= _steps_set, f"STEP_LINEAR_MAPPING has unknown keys: {set(STEP_LINEAR_MAPPING.keys()) - _steps_set}"
+assert set(STEP_LINEAR_MAPPING.values()) <= set(STEP_LINEAR_ORDER), (
+    f"STEP_LINEAR_MAPPING values not in STEP_LINEAR_ORDER: "
+    f"{set(STEP_LINEAR_MAPPING.values()) - set(STEP_LINEAR_ORDER)}"
+)
 assert set(SPECKIT_STEP_MAP.values()) <= _steps_set, f"SPECKIT_STEP_MAP maps to unknown steps: {set(SPECKIT_STEP_MAP.values()) - _steps_set}"

devflow_cli/adapters/__init__.py

@@ -0,0 +1,19 @@
+"""Adaptateurs des services externes utilisés par devflow."""
+
+from devflow_cli.adapters.agents import (
+    AgentAdapter,
+    AgentExecution,
+    ClaudeCodeAdapter,
+    CodexAdapter,
+    CursorAdapter,
+    get_agent_adapter,
+)
+
+__all__ = [
+    "AgentAdapter",
+    "AgentExecution",
+    "ClaudeCodeAdapter",
+    "CodexAdapter",
+    "CursorAdapter",
+    "get_agent_adapter",
+]

devflow_cli/adapters/agents.py

@@ -0,0 +1,220 @@
+"""Adaptateurs d'exécution pour les agents IA en mode non interactif."""
+
+from __future__ import annotations
+
+import subprocess
+import re
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+
+PermissionMode = Literal["auto", "acceptEdits", "manual"]
+SandboxMode = Literal["read-only", "workspace-write"]
+
+
+@dataclass(frozen=True)
+class AgentExecution:
+    returncode: int
+    stdout: str = ""
+    stderr: str = ""
+    timed_out: bool = False
+
+
+class AgentAdapter(ABC):
+    """Contrat minimal d'un agent pilotable par le CLI."""
+
+    name: str
+    executable: str
+
+    @abstractmethod
+    def build_command(self, prompt: str, permission_mode: PermissionMode) -> list[str]:
+        """Construit une commande sans passer par un shell."""
+
+    def build_named_agent_command(self, agent_name: str, prompt: str) -> list[str]:
+        raise ValueError(f"L'adaptateur {self.name} ne supporte pas les agents nommés")
+
+    def build_structured_command(
+        self,
+        prompt: str,
+        permission_mode: PermissionMode,
+        schema_file: Path,
+        output_file: Path,
+        sandbox_mode: SandboxMode = "workspace-write",
+    ) -> list[str]:
+        raise ValueError(f"L'adaptateur {self.name} ne supporte pas les sorties structurees")
+
+    def execute(
+        self,
+        prompt: str,
+        cwd: Path,
+        timeout: int,
+        permission_mode: PermissionMode = "auto",
+        *,
+        capture_output: bool = False,
+    ) -> AgentExecution:
+        command = self.build_command(prompt, permission_mode)
+        try:
+            result = subprocess.run(
+                command,
+                cwd=cwd,
+                timeout=timeout,
+                text=True,
+                capture_output=capture_output,
+                shell=False,
+            )
+            return AgentExecution(
+                result.returncode,
+                result.stdout or "",
+                result.stderr or "",
+            )
+        except subprocess.TimeoutExpired as exc:
+            return AgentExecution(
+                124,
+                _text(exc.stdout),
+                _text(exc.stderr),
+                timed_out=True,
+            )
+        except FileNotFoundError:
+            return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable")
+
+    def execute_structured(
+        self,
+        prompt: str,
+        cwd: Path,
+        timeout: int,
+        schema_file: Path,
+        output_file: Path,
+        permission_mode: PermissionMode = "auto",
+        sandbox_mode: SandboxMode = "workspace-write",
+    ) -> AgentExecution:
+        command = self.build_structured_command(
+            prompt, permission_mode, schema_file, output_file, sandbox_mode
+        )
+        try:
+            result = subprocess.run(
+                command,
+                cwd=cwd,
+                timeout=timeout,
+                text=True,
+                capture_output=True,
+                shell=False,
+            )
+            return AgentExecution(
+                result.returncode,
+                result.stdout or "",
+                result.stderr or "",
+            )
+        except subprocess.TimeoutExpired as exc:
+            return AgentExecution(
+                124,
+                _text(exc.stdout),
+                _text(exc.stderr),
+                timed_out=True,
+            )
+        except FileNotFoundError:
+            return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable")
+
+
+class ClaudeCodeAdapter(AgentAdapter):
+    name = "claude-code"
+    executable = "claude"
+
+    def build_command(self, prompt: str, permission_mode: PermissionMode) -> list[str]:
+        return [
+            self.executable,
+            "--print",
+            "--permission-mode",
+            permission_mode,
+            prompt,
+        ]
+
+    def build_named_agent_command(self, agent_name: str, prompt: str) -> list[str]:
+        return [self.executable, "--print", "--agent", agent_name, prompt]
+
+
+class CodexAdapter(AgentAdapter):
+    name = "codex"
+    executable = "codex"
+
+    def build_command(self, prompt: str, permission_mode: PermissionMode) -> list[str]:
+        command = [self.executable, "exec"]
+        if permission_mode in {"auto", "acceptEdits"}:
+            command.append("--approve-for-me")
+        else:
+            command.extend(["--sandbox", "workspace-write"])
+        command.append(_portable_prompt(prompt))
+        return command
+
+    def build_structured_command(
+        self,
+        prompt: str,
+        permission_mode: PermissionMode,
+        schema_file: Path,
+        output_file: Path,
+        sandbox_mode: SandboxMode = "workspace-write",
+    ) -> list[str]:
+        command = [self.executable, "exec"]
+        if permission_mode in {"auto", "acceptEdits"} and sandbox_mode == "workspace-write":
+            command.append("--approve-for-me")
+        else:
+            command.extend(["--sandbox", sandbox_mode])
+        command.extend([
+            "--output-schema",
+            str(schema_file),
+            "--output-last-message",
+            str(output_file),
+        ])
+        command.append(prompt)
+        return command
+
+
+class CursorAdapter(AgentAdapter):
+    name = "cursor"
+    executable = "cursor-agent"
+
+    def build_command(self, prompt: str, permission_mode: PermissionMode) -> list[str]:
+        command = [self.executable, "--print", "--output-format", "text"]
+        if permission_mode in {"auto", "acceptEdits"}:
+            command.append("--force")
+        command.append(_portable_prompt(prompt))
+        return command
+
+
+_AGENT_ADAPTERS = {
+    "claude": ClaudeCodeAdapter,
+    "claude-code": ClaudeCodeAdapter,
+    "codex": CodexAdapter,
+    "cursor": CursorAdapter,
+    "cursor-agent": CursorAdapter,
+}
+
+
+def get_agent_adapter(name: str) -> AgentAdapter:
+    try:
+        adapter_type = _AGENT_ADAPTERS[name.casefold()]
+    except KeyError as exc:
+        supported = ", ".join(sorted({kind().name for kind in _AGENT_ADAPTERS.values()}))
+        raise ValueError(f"Agent inconnu '{name}'. Agents supportés: {supported}") from exc
+    return adapter_type()
+
+
+def _portable_prompt(prompt: str) -> str:
+    """Traduit une slash-command Claude en instruction portable pour les autres agents."""
+    match = re.fullmatch(r"/devflow\.([a-z0-9-]+)(?:\s+(.*))?", prompt.strip())
+    if not match:
+        return prompt
+    command_name, arguments = match.groups()
+    arguments = arguments or ""
+    return (
+        f"Exécute strictement le workflow décrit dans "
+        f"commands/devflow.{command_name}.md avec $ARGUMENTS = {arguments!r}. "
+        "Travaille dans le dépôt courant et respecte toutes les validations de ce fichier."
+    )
+
+
+def _text(value: str | bytes | None) -> str:
+    if value is None:
+        return ""
+    return value.decode(errors="replace") if isinstance(value, bytes) else value

devflow_cli/adapters/linear.py

@@ -0,0 +1,79 @@
+"""Politique de synchronisation Linear, indépendante du transport MCP/API."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal, Protocol
+
+from devflow_cli import STEP_LINEAR_MAPPING, STEP_LINEAR_ORDER
+
+
+LinearAction = Literal["update", "keep", "skip"]
+
+
+class LinearAdapter(Protocol):
+    """Transport minimal requis pour synchroniser le statut d'une issue."""
+
+    def get_status(self, issue_id: str) -> str | None: ...
+
+    def update_status(self, issue_id: str, status: str) -> None: ...
+
+
+@dataclass(frozen=True)
+class LinearDecision:
+    action: LinearAction
+    step: str
+    current_status: str | None
+    target_status: str | None
+    reason: str
+
+    @property
+    def should_update(self) -> bool:
+        return self.action == "update"
+
+    def to_dict(self) -> dict[str, str | bool | None]:
+        return {
+            "action": self.action,
+            "step": self.step,
+            "currentStatus": self.current_status,
+            "targetStatus": self.target_status,
+            "shouldUpdate": self.should_update,
+            "reason": self.reason,
+        }
+
+
+def decide_linear_transition(step: str, current_status: str | None) -> LinearDecision:
+    """Applique le mapping et la règle de non-régression canonique."""
+    target = STEP_LINEAR_MAPPING.get(step)
+    if target is None:
+        return LinearDecision("skip", step, current_status, None, "Étape sans statut Linear")
+    if current_status not in STEP_LINEAR_ORDER:
+        return LinearDecision(
+            "skip",
+            step,
+            current_status,
+            target,
+            "Statut Linear courant absent de l'ordre canonique",
+        )
+    current_index = STEP_LINEAR_ORDER.index(current_status)
+    target_index = STEP_LINEAR_ORDER.index(target)
+    if current_index >= target_index:
+        return LinearDecision(
+            "keep",
+            step,
+            current_status,
+            target,
+            "Statut courant identique ou plus avancé",
+        )
+    return LinearDecision("update", step, current_status, target, "Progression autorisée")
+
+
+def sync_linear_status(
+    adapter: LinearAdapter, issue_id: str, step: str
+) -> LinearDecision:
+    """Synchronise via un transport injecté lorsque la politique l'autorise."""
+    current_status = adapter.get_status(issue_id)
+    decision = decide_linear_transition(step, current_status)
+    if decision.should_update and decision.target_status is not None:
+        adapter.update_status(issue_id, decision.target_status)
+    return decision

devflow_cli/cli.py

@@ -18,6 +18,16 @@ from devflow_cli.commands.upgrade_cmd import upgrade
 from devflow_cli.commands.rollback import rollback
 from devflow_cli.commands.migrate_speckit import migrate_speckit
 from devflow_cli.commands import extension
+from devflow_cli.commands import hooks_cmd
+from devflow_cli.commands import linear
+from devflow_cli.commands import review
+from devflow_cli.commands import step
+from devflow_cli.commands import adaptive
+from devflow_cli.commands.run import run
+from devflow_cli.commands.docs_sync import docs_sync
+from devflow_cli.commands.traceability import traceability
+from devflow_cli.commands.verify import verify
+from devflow_cli.commands.assess import assess
 
 app = typer.Typer(
     name="devflow",
@@ -53,6 +63,16 @@ app.command()(upgrade)
 app.command()(rollback)
 app.command(name="migrate-speckit")(migrate_speckit)
 app.add_typer(extension.app, name="extension")
+app.add_typer(hooks_cmd.app, name="hooks")
+app.add_typer(linear.app, name="linear")
+app.add_typer(step.app, name="step")
+app.add_typer(review.app, name="review")
+app.add_typer(adaptive.app, name="adaptive")
+app.command()(run)
+app.command(name="docs-sync")(docs_sync)
+app.command()(traceability)
+app.command()(verify)
+app.command()(assess)
 
 
 if __name__ == "__main__":