devflow-cli 2.8.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

devflow_cli/__init__.py

@@ -1,113 +1,47 @@
-"""devflow CLI — Spec-Driven Development workflow."""
+"""devflow CLI — workflow de développement adaptatif."""
 
-VERSION = "2.8.0"
-STATE_SCHEMA_VERSION = 3
+VERSION = "3.0.0"
 
-STEPS = [
-    "constitution",  # Pré-requis projet (1/projet). Auto-complétée si .specify/memory/constitution.md existe.
-    "spec",
-    "clarify",
-    "review-spec",
-    "research",
-    "plan",
-    "contracts",
-    "tasks",
-    "review-tasks",
-    "implement",
-    "review-impl",
-    "docs",
-    "done",
-]
-
-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"}
+SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
 
-STEP_ARTIFACTS = {
-    "spec": "spec.md",
-    "clarify": "clarify-log.md",
-    "review-spec": "review-log.md",
-    "research": "research.md",
-    "plan": "plan.md",
-    "contracts": "contracts",
-    "tasks": "tasks.md",
-    "review-tasks": "review-log.md",
-    "implement": None,
-    "review-impl": "review-log.md",
-    "docs": "docs.md",
-}
-
-STEP_LINEAR_MAPPING = {
+ACTIVITY_LINEAR_MAPPING = {
+    "assess": "Backlog",
+    "prepare": "Plan",
+    "risk-assessment": "Research",
     "spec": "Spec",
-    "clarify": "Spec",
-    "review-spec": "Review",
     "research": "Research",
-    "plan": "Plan",
     "contracts": "Plan",
+    "plan": "Plan",
     "tasks": "Tasks",
-    "review-tasks": "Review",
     "implement": "In Progress",
-    "review-impl": "Review",
-    "docs": "Doc",
+    "verify": "Review",
+    "review": "Review",
+    "rollback-check": "Review",
     "done": "Done",
 }
 
-# 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 = [
+LINEAR_STATUS_ORDER = [
     "Backlog",
     "Spec",
     "Research",
     "Plan",
     "Tasks",
-    "Review",
     "In Progress",
-    "Doc",
+    "Review",
     "Done",
 ]
 
-SUPPORTED_AGENTS = ["claude-code", "cursor"]
-
-# Mapping speckit → devflow pour la migration
-SPECKIT_STEP_MAP = {
-    "specify": "spec",
-    "clarify": "clarify",
-    "plan": "plan",
-    "tasks": "tasks",
-    "implement": "implement",
-}
-
-SPECKIT_IGNORED_STEPS = {"checklist", "analyze"}
-
 ARTIFACTS = [
+    "risk-assessment.md",
     "spec.md",
-    "clarify-log.md",
     "research.md",
+    "contracts.md",
     "plan.md",
-    "contracts/",
-    "data-model.md",
-    "quickstart.md",
     "tasks.md",
-    "docs.md",
-    "review-log.md",
-    "analysis.md",
-    "checklist.md",
+    "worklog.md",
+    "activity-contract.json",
+    "activity-result.json",
+    "verification.json",
 ]
 
-# --- Pipeline constants coherence checks ---
-_steps_set = set(STEPS)
-assert OPTIONAL_STEPS <= _steps_set, f"OPTIONAL_STEPS not subset of STEPS: {OPTIONAL_STEPS - _steps_set}"
-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}"
+assert set(ACTIVITY_LINEAR_MAPPING.values()) <= set(LINEAR_STATUS_ORDER)

devflow_cli/adapters/agents.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import subprocess
 import re
 from abc import ABC, abstractmethod
@@ -9,8 +10,12 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal
 
+from jsonschema.exceptions import SchemaError, ValidationError
+from jsonschema.validators import validator_for
+
 
 PermissionMode = Literal["auto", "acceptEdits", "manual"]
+SandboxMode = Literal["read-only", "workspace-write"]
 
 
 @dataclass(frozen=True)
@@ -34,6 +39,16 @@ class AgentAdapter(ABC):
     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,
@@ -68,6 +83,66 @@ class AgentAdapter(ABC):
         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,
+            )
+            execution = AgentExecution(
+                result.returncode,
+                result.stdout or "",
+                result.stderr or "",
+            )
+            if execution.returncode != 0:
+                return execution
+            try:
+                payload = self._structured_payload(execution.stdout, output_file)
+                _validate_structured_payload(payload, schema_file)
+                output_file.write_text(
+                    json.dumps(payload, ensure_ascii=False), encoding="utf-8"
+                )
+            except (
+                OSError, ValueError, json.JSONDecodeError, SchemaError, ValidationError
+            ) as exc:
+                output_file.unlink(missing_ok=True)
+                return AgentExecution(
+                    1,
+                    execution.stdout,
+                    f"Sortie structuree invalide ({self.name}) : {exc}",
+                )
+            return execution
+        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 _structured_payload(self, stdout: str, output_file: Path) -> object:
+        if output_file.is_file():
+            return json.loads(output_file.read_text(encoding="utf-8"))
+        return json.loads(stdout)
+
 
 class ClaudeCodeAdapter(AgentAdapter):
     name = "claude-code"
@@ -85,18 +160,76 @@ class ClaudeCodeAdapter(AgentAdapter):
     def build_named_agent_command(self, agent_name: str, prompt: str) -> list[str]:
         return [self.executable, "--print", "--agent", agent_name, prompt]
 
+    def build_structured_command(
+        self,
+        prompt: str,
+        permission_mode: PermissionMode,
+        schema_file: Path,
+        output_file: Path,
+        sandbox_mode: SandboxMode = "workspace-write",
+    ) -> list[str]:
+        del output_file
+        schema = schema_file.read_text(encoding="utf-8")
+        effective_mode = "plan" if sandbox_mode == "read-only" else permission_mode
+        return [
+            self.executable,
+            "--print",
+            "--permission-mode",
+            effective_mode,
+            "--output-format",
+            "json",
+            "--json-schema",
+            schema,
+            prompt,
+        ]
+
+    def _structured_payload(self, stdout: str, output_file: Path) -> object:
+        del output_file
+        envelope = json.loads(stdout)
+        if not isinstance(envelope, dict):
+            raise ValueError("enveloppe JSON Claude absente")
+        if envelope.get("subtype") not in {None, "success"}:
+            raise ValueError(f"execution Claude terminee avec {envelope.get('subtype')}")
+        if "structured_output" not in envelope:
+            raise ValueError("champ structured_output absent")
+        return envelope["structured_output"]
+
 
 class CodexAdapter(AgentAdapter):
     name = "codex"
     executable = "codex"
 
     def build_command(self, prompt: str, permission_mode: PermissionMode) -> list[str]:
-        command = [self.executable, "exec", "--sandbox", "workspace-write"]
+        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"
@@ -109,6 +242,40 @@ class CursorAdapter(AgentAdapter):
         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]:
+        del output_file
+        schema = schema_file.read_text(encoding="utf-8")
+        structured_prompt = (
+            f"{prompt}\n\n"
+            "Retourne comme reponse finale uniquement un objet JSON valide "
+            "respectant exactement ce JSON Schema, sans bloc Markdown :\n"
+            f"{schema}"
+        )
+        command = [self.executable, "--print", "--output-format", "json"]
+        if permission_mode in {"auto", "acceptEdits"} and sandbox_mode == "workspace-write":
+            command.append("--force")
+        command.append(structured_prompt)
+        return command
+
+    def _structured_payload(self, stdout: str, output_file: Path) -> object:
+        del output_file
+        envelope = json.loads(stdout)
+        if not isinstance(envelope, dict):
+            raise ValueError("enveloppe JSON Cursor absente")
+        if envelope.get("is_error") is True or envelope.get("subtype") not in {None, "success"}:
+            raise ValueError("execution Cursor terminee en erreur")
+        result = envelope.get("result")
+        if not isinstance(result, str):
+            raise ValueError("champ result Cursor absent")
+        return json.loads(_strip_json_fence(result))
+
 
 _AGENT_ADAPTERS = {
     "claude": ClaudeCodeAdapter,
@@ -146,3 +313,16 @@ def _text(value: str | bytes | None) -> str:
     if value is None:
         return ""
     return value.decode(errors="replace") if isinstance(value, bytes) else value
+
+
+def _strip_json_fence(value: str) -> str:
+    text = value.strip()
+    match = re.fullmatch(r"```(?:json)?\s*([\s\S]*?)\s*```", text, re.IGNORECASE)
+    return match.group(1).strip() if match else text
+
+
+def _validate_structured_payload(payload: object, schema_file: Path) -> None:
+    schema = json.loads(schema_file.read_text(encoding="utf-8"))
+    validator_type = validator_for(schema)
+    validator_type.check_schema(schema)
+    validator_type(schema).validate(payload)

devflow_cli/adapters/linear.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Literal, Protocol
 
-from devflow_cli import STEP_LINEAR_MAPPING, STEP_LINEAR_ORDER
+from devflow_cli import ACTIVITY_LINEAR_MAPPING, LINEAR_STATUS_ORDER
 
 
 LinearAction = Literal["update", "keep", "skip"]
@@ -22,7 +22,7 @@ class LinearAdapter(Protocol):
 @dataclass(frozen=True)
 class LinearDecision:
     action: LinearAction
-    step: str
+    activity: str
     current_status: str | None
     target_status: str | None
     reason: str
@@ -34,7 +34,7 @@ class LinearDecision:
     def to_dict(self) -> dict[str, str | bool | None]:
         return {
             "action": self.action,
-            "step": self.step,
+            "activity": self.activity,
             "currentStatus": self.current_status,
             "targetStatus": self.target_status,
             "shouldUpdate": self.should_update,
@@ -42,38 +42,42 @@ class LinearDecision:
         }
 
 
-def decide_linear_transition(step: str, current_status: str | None) -> LinearDecision:
+def decide_linear_transition(activity: str, current_status: str | None) -> LinearDecision:
     """Applique le mapping et la règle de non-régression canonique."""
-    target = STEP_LINEAR_MAPPING.get(step)
+    target = ACTIVITY_LINEAR_MAPPING.get(activity)
     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", activity, current_status, None, "Activité sans statut Linear"
+        )
+    if current_status not in LINEAR_STATUS_ORDER:
         return LinearDecision(
             "skip",
-            step,
+            activity,
             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)
+    current_index = LINEAR_STATUS_ORDER.index(current_status)
+    target_index = LINEAR_STATUS_ORDER.index(target)
     if current_index >= target_index:
         return LinearDecision(
             "keep",
-            step,
+            activity,
             current_status,
             target,
             "Statut courant identique ou plus avancé",
         )
-    return LinearDecision("update", step, current_status, target, "Progression autorisée")
+    return LinearDecision(
+        "update", activity, current_status, target, "Progression autorisée"
+    )
 
 
 def sync_linear_status(
-    adapter: LinearAdapter, issue_id: str, step: str
+    adapter: LinearAdapter, issue_id: str, activity: 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)
+    decision = decide_linear_transition(activity, 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

@@ -15,17 +15,14 @@ from devflow_cli.commands.export_cmd import export
 from devflow_cli.commands.stale import stale
 from devflow_cli.commands.migrate_cmd import migrate
 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.run import run
+from devflow_cli.commands import adaptive
 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",
@@ -58,17 +55,14 @@ app.command(name="export")(export)
 app.command()(stale)
 app.command()(migrate)
 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.command()(run)
+app.add_typer(adaptive.app, name="adaptive")
 app.command(name="docs-sync")(docs_sync)
 app.command()(traceability)
 app.command()(verify)
+app.command()(assess)
 
 
 if __name__ == "__main__":