devflow-cli 3.0.1__py3-none-any.whl → 6.0.0__py3-none-any.whl

devflow_cli/__init__.py

@@ -1,6 +1,6 @@
 """devflow CLI — workflow de développement adaptatif."""
 
-VERSION = "3.0.1"
+VERSION = "6.0.0"
 
 SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
 
@@ -13,6 +13,7 @@ ACTIVITY_LINEAR_MAPPING = {
     "contracts": "Plan",
     "plan": "Plan",
     "tasks": "Tasks",
+    "preflight-evidence": "Plan",
     "implement": "In Progress",
     "verify": "Review",
     "review": "Review",
@@ -38,9 +39,10 @@ ARTIFACTS = [
     "contracts.md",
     "plan.md",
     "tasks.md",
+    "preflight-evidence.md",
     "worklog.md",
     "activity-contract.json",
-    "activity-result.json",
+    "implement-result.json",
     "verification.json",
 ]
 

devflow_cli/adapters/agents.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import subprocess
 import re
+import time
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from pathlib import Path
@@ -17,6 +18,12 @@ from jsonschema.validators import validator_for
 PermissionMode = Literal["auto", "acceptEdits", "manual"]
 SandboxMode = Literal["read-only", "workspace-write"]
 
+_SAFE_DIAGNOSTIC_MESSAGES = {
+    "final-output-empty": "--output-last-message est vide",
+    "final-output-absent": "--output-last-message est absent",
+    "agent-turn-failed": "le tour agent a echoue avant la reponse finale",
+}
+
 
 @dataclass(frozen=True)
 class AgentExecution:
@@ -24,6 +31,19 @@ class AgentExecution:
     stdout: str = ""
     stderr: str = ""
     timed_out: bool = False
+    duration_seconds: float = 0.0
+    final_output_status: str = "unknown"
+    final_output_bytes: int = 0
+    final_output_diagnostic: str = "not-evaluated"
+    session_id: str | None = None
+
+
+class StructuredOutputError(ValueError):
+    """Erreur de sortie agent dont le diagnostic peut etre expose sans contenu."""
+
+    def __init__(self, diagnostic: str, message: str) -> None:
+        super().__init__(message)
+        self.diagnostic = diagnostic
 
 
 class AgentAdapter(ABC):
@@ -66,6 +86,7 @@ class AgentAdapter(ABC):
                 timeout=timeout,
                 text=True,
                 capture_output=capture_output,
+                stdin=subprocess.DEVNULL,
                 shell=False,
             )
             return AgentExecution(
@@ -96,6 +117,7 @@ class AgentAdapter(ABC):
         command = self.build_structured_command(
             prompt, permission_mode, schema_file, output_file, sandbox_mode
         )
+        started = time.monotonic()
         try:
             result = subprocess.run(
                 command,
@@ -103,12 +125,18 @@ class AgentAdapter(ABC):
                 timeout=timeout,
                 text=True,
                 capture_output=True,
+                stdin=subprocess.DEVNULL,
                 shell=False,
             )
             execution = AgentExecution(
                 result.returncode,
                 result.stdout or "",
                 result.stderr or "",
+                duration_seconds=time.monotonic() - started,
+                final_output_status=_output_status(output_file),
+                final_output_bytes=_output_size(output_file),
+                final_output_diagnostic="process-failed" if result.returncode else "validating",
+                session_id=self.session_id(result.stdout or "", result.stderr or ""),
             )
             if execution.returncode != 0:
                 return execution
@@ -118,28 +146,73 @@ class AgentAdapter(ABC):
                 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)
+            except StructuredOutputError as exc:
+                diagnostic = exc.diagnostic
+            except json.JSONDecodeError:
+                diagnostic = "final-output-invalid-json"
+            except ValidationError:
+                diagnostic = "final-output-schema-rejected"
+            except SchemaError:
+                diagnostic = "output-schema-invalid"
+            except OSError:
+                diagnostic = "final-output-unreadable"
+            except ValueError:
+                diagnostic = "final-output-invalid"
+            else:
                 return AgentExecution(
-                    1,
+                    execution.returncode,
                     execution.stdout,
-                    f"Sortie structuree invalide ({self.name}) : {exc}",
+                    execution.stderr,
+                    execution.timed_out,
+                    execution.duration_seconds,
+                    _output_status(output_file),
+                    _output_size(output_file),
+                    "validated",
+                    execution.session_id,
                 )
-            return execution
+
+            status = _output_status(output_file)
+            size = _output_size(output_file)
+            output_file.unlink(missing_ok=True)
+            return AgentExecution(
+                1,
+                execution.stdout,
+                "Sortie structuree invalide "
+                f"({self.name}) [{diagnostic}]"
+                + (
+                    f" : {_SAFE_DIAGNOSTIC_MESSAGES[diagnostic]}"
+                    if diagnostic in _SAFE_DIAGNOSTIC_MESSAGES
+                    else ""
+                ),
+                duration_seconds=execution.duration_seconds,
+                final_output_status=status,
+                final_output_bytes=size,
+                final_output_diagnostic=diagnostic,
+                session_id=execution.session_id,
+            )
         except subprocess.TimeoutExpired as exc:
             return AgentExecution(
                 124,
                 _text(exc.stdout),
                 _text(exc.stderr),
                 timed_out=True,
+                duration_seconds=time.monotonic() - started,
+                final_output_status=_output_status(output_file),
+                final_output_bytes=_output_size(output_file),
             )
         except FileNotFoundError:
-            return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable")
+            return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable", duration_seconds=time.monotonic() - started)
+
+    def session_id(self, stdout: str, stderr: str) -> str | None:
+        """Extrait un identifiant opaque de session, sans conserver la sortie."""
+        return _session_id(stdout, stderr)
+
+    def recover_structured_payload(self, raw_output: str) -> object:
+        """Extrait la reponse structuree d'une trace brute conservee apres un echec."""
+        return self._structured_payload(raw_output, None)
 
-    def _structured_payload(self, stdout: str, output_file: Path) -> object:
-        if output_file.is_file():
+    def _structured_payload(self, stdout: str, output_file: Path | None) -> object:
+        if output_file is not None and output_file.is_file():
             return json.loads(output_file.read_text(encoding="utf-8"))
         return json.loads(stdout)
 
@@ -169,7 +242,7 @@ class ClaudeCodeAdapter(AgentAdapter):
         sandbox_mode: SandboxMode = "workspace-write",
     ) -> list[str]:
         del output_file
-        schema = schema_file.read_text(encoding="utf-8")
+        schema = _claude_compatible_schema(schema_file)
         effective_mode = "plan" if sandbox_mode == "read-only" else permission_mode
         return [
             self.executable,
@@ -183,16 +256,19 @@ class ClaudeCodeAdapter(AgentAdapter):
             prompt,
         ]
 
-    def _structured_payload(self, stdout: str, output_file: Path) -> object:
+    def _structured_payload(self, stdout: str, output_file: Path | None) -> 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"]
+        if "structured_output" in envelope:
+            return envelope["structured_output"]
+        result = envelope.get("result")
+        if isinstance(result, str) and result.strip():
+            return json.loads(_strip_json_fence(result))
+        raise ValueError("champ structured_output absent")
 
 
 class CodexAdapter(AgentAdapter):
@@ -222,6 +298,7 @@ class CodexAdapter(AgentAdapter):
         else:
             command.extend(["--sandbox", sandbox_mode])
         command.extend([
+            "--json",
             "--output-schema",
             str(schema_file),
             "--output-last-message",
@@ -230,22 +307,36 @@ class CodexAdapter(AgentAdapter):
         command.append(prompt)
         return command
 
-    def _structured_payload(self, stdout: str, output_file: Path) -> object:
-        """Lit la reponse finale Codex et distingue son absence d'un JSON invalide."""
-        if output_file.is_file():
+    def session_id(self, stdout: str, stderr: str) -> str | None:
+        """Prefere l'identifiant de fil annonce par le flux d'evenements."""
+        for event in json_line_events(stdout):
+            if event.get("type") == "thread.started" and isinstance(
+                event.get("thread_id"), str
+            ):
+                return event["thread_id"]
+        return _session_id(stdout, stderr)
+
+    def _structured_payload(self, stdout: str, output_file: Path | None) -> object:
+        """Lit la reponse finale Codex, sinon la recupere depuis le flux d'evenements."""
+        if output_file is not None and output_file.is_file():
             payload = output_file.read_text(encoding="utf-8")
             if payload.strip():
                 return json.loads(payload)
-            raise ValueError(
-                "Codex a termine sans reponse finale structuree "
-                "(--output-last-message est vide)"
+            diagnostic = "final-output-empty"
+            message = "Codex a termine sans reponse finale structuree"
+        else:
+            diagnostic = "final-output-absent"
+            message = "Codex n'a pas produit le fichier de reponse finale structuree"
+        events = json_line_events(stdout)
+        if any(event.get("type") == "turn.failed" for event in events):
+            raise StructuredOutputError(
+                "agent-turn-failed",
+                "Codex a interrompu son tour avant la reponse finale",
             )
-        if stdout.strip():
-            return json.loads(stdout)
-        raise ValueError(
-            "Codex n'a pas produit de reponse finale structuree "
-            "ni de sortie standard exploitable"
-        )
+        final_message = _codex_final_message(events)
+        if final_message is not None:
+            return json.loads(_strip_json_fence(final_message))
+        raise StructuredOutputError(diagnostic, message)
 
 
 class CursorAdapter(AgentAdapter):
@@ -281,7 +372,7 @@ class CursorAdapter(AgentAdapter):
         command.append(structured_prompt)
         return command
 
-    def _structured_payload(self, stdout: str, output_file: Path) -> object:
+    def _structured_payload(self, stdout: str, output_file: Path | None) -> object:
         del output_file
         envelope = json.loads(stdout)
         if not isinstance(envelope, dict):
@@ -326,12 +417,70 @@ def _portable_prompt(prompt: str) -> str:
     )
 
 
+def _claude_compatible_schema(schema_file: Path) -> str:
+    """Adapte l'en-tete Draft 2020-12 au format accepte par Claude Code."""
+    raw_schema = schema_file.read_text(encoding="utf-8")
+    schema = json.loads(raw_schema)
+    if not isinstance(schema, dict):
+        raise ValueError("schema JSON Claude invalide")
+    if schema.get("$schema") != "https://json-schema.org/draft/2020-12/schema":
+        return raw_schema
+    schema["$schema"] = "http://json-schema.org/draft-07/schema#"
+    return json.dumps(schema, ensure_ascii=False)
+
+
 def _text(value: str | bytes | None) -> str:
     if value is None:
         return ""
     return value.decode(errors="replace") if isinstance(value, bytes) else value
 
 
+def _output_status(path: Path) -> str:
+    if not path.is_file():
+        return "absent"
+    return "empty" if _output_size(path) == 0 else "present"
+
+
+def _output_size(path: Path) -> int:
+    try:
+        return path.stat().st_size
+    except OSError:
+        return 0
+
+
+def _session_id(stdout: str, stderr: str) -> str | None:
+    # Only retain an opaque identifier, never the surrounding agent output.
+    match = re.search(r'(?i)(?:session[_ -]?id|session)\s*[=:]\s*["\']?([a-z0-9-]{8,})', stdout + "\n" + stderr)
+    return match.group(1) if match else None
+
+
+def json_line_events(stdout: str) -> list[dict]:
+    """Decode un flux JSONL d'agent en ignorant les lignes non JSON ou non objet."""
+    events: list[dict] = []
+    for line in stdout.splitlines():
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(event, dict):
+            events.append(event)
+    return events
+
+
+def _codex_final_message(events: list[dict]) -> str | None:
+    """Retourne le dernier message d'agent complet du flux d'evenements."""
+    for event in reversed(events):
+        item = event.get("item")
+        if event.get("type") != "item.completed" or not isinstance(item, dict):
+            continue
+        if item.get("type") == "agent_message" and isinstance(item.get("text"), str):
+            return item["text"]
+    return None
+
+
 def _strip_json_fence(value: str) -> str:
     text = value.strip()
     match = re.fullmatch(r"```(?:json)?\s*([\s\S]*?)\s*```", text, re.IGNORECASE)

devflow_cli/cli.py

@@ -13,7 +13,6 @@ from devflow_cli.commands.feature import feature
 from devflow_cli.commands.context import context
 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 import extension
 from devflow_cli.commands import hooks_cmd
@@ -53,7 +52,6 @@ app.command()(feature)
 app.command()(context)
 app.command(name="export")(export)
 app.command()(stale)
-app.command()(migrate)
 app.command()(upgrade)
 app.add_typer(extension.app, name="extension")
 app.add_typer(hooks_cmd.app, name="hooks")