devflow-cli 8.0.0__py3-none-any.whl → 8.2.0__py3-none-any.whl

devflow_cli/__init__.py

@@ -1,6 +1,6 @@
 """devflow CLI — workflow de développement adaptatif."""
 
-VERSION = "8.0.0"
+VERSION = "8.2.0"
 
 SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
 

devflow_cli/adapters/agents.py

@@ -22,6 +22,24 @@ from devflow_cli.adapters.linear import environment_without_linear_key
 PermissionMode = Literal["auto", "acceptEdits", "manual"]
 SandboxMode = Literal["read-only", "workspace-write"]
 
+# L'agent a termine sans erreur (code 0) mais sa sortie structuree manque ou n'est
+# pas le JSON attendu. Claude porte le diagnostic dedie ; Codex et Cursor gardent
+# leurs valeurs detaillees, traitees comme la meme famille par la reprise guidee.
+STRUCTURED_OUTPUT_MISSING = "structured-output-missing"
+MISSING_STRUCTURED_OUTPUT_DIAGNOSTICS = frozenset({
+    STRUCTURED_OUTPUT_MISSING,
+    "final-output-empty",
+    "final-output-absent",
+    "final-output-invalid-json",
+})
+STRUCTURED_OUTPUT_MISSING_MESSAGE = (
+    "l'agent a termine sans erreur mais sa sortie structuree manque "
+    "ou n'est pas le JSON attendu"
+)
+# Impose le premier plan aux sous-agents de l'agent Claude d'une activite ; desactive
+# aussi ses commandes shell en arriere-plan.
+CLAUDE_FOREGROUND_ENV = "CLAUDE_CODE_DISABLE_BACKGROUND_TASKS"
+
 _SAFE_DIAGNOSTIC_MESSAGES = {
     "final-output-empty": "--output-last-message est vide",
     "final-output-absent": "--output-last-message est absent",
@@ -165,7 +183,7 @@ class AgentAdapter(ABC):
                 capture_output=True,
                 stdin=subprocess.DEVNULL,
                 shell=False,
-                env=environment_without_linear_key(),
+                env=self.structured_environment(),
             )
             execution = AgentExecution(
                 result.returncode,
@@ -223,7 +241,9 @@ class AgentAdapter(ABC):
                 "Sortie structuree invalide "
                 f"({self.name}) [{diagnostic}]"
                 + (
-                    f" : {_SAFE_DIAGNOSTIC_MESSAGES[diagnostic]}"
+                    f" : {self.missing_output_message(execution.stdout)}"
+                    if diagnostic == STRUCTURED_OUTPUT_MISSING
+                    else f" : {_SAFE_DIAGNOSTIC_MESSAGES[diagnostic]}"
                     if diagnostic in _SAFE_DIAGNOSTIC_MESSAGES
                     else ""
                 ),
@@ -251,6 +271,27 @@ class AgentAdapter(ABC):
         except FileNotFoundError:
             return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable", duration_seconds=time.monotonic() - started)
 
+    def structured_environment(self) -> dict[str, str]:
+        """Environnement de l'agent d'une activite : jamais la cle Linear."""
+        return environment_without_linear_key()
+
+    def subagent_counts(self, stdout: str) -> tuple[int | None, int | None]:
+        """Sous-agents lances et lances en arriere-plan ; None si l'agent ne le dit pas."""
+        return None, None
+
+    def missing_output_message(self, stdout: str) -> str:
+        """Cause d'une sortie structuree absente : message fixe et entiers seulement."""
+        try:
+            spawned, background = self.subagent_counts(stdout)
+        except Exception:  # noqa: BLE001 - format externe non contractuel
+            spawned, background = None, None
+        message = STRUCTURED_OUTPUT_MISSING_MESSAGE
+        if spawned is not None:
+            message += f" ; sous-agents lances : {spawned}"
+            if background is not None:
+                message += f", dont {background} en arriere-plan"
+        return message
+
     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)
@@ -326,8 +367,23 @@ class ClaudeCodeAdapter(AgentAdapter):
             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")
+            try:
+                return json.loads(_strip_json_fence(result))
+            except json.JSONDecodeError:
+                pass
+        raise StructuredOutputError(
+            STRUCTURED_OUTPUT_MISSING, "champ structured_output absent"
+        )
+
+    def structured_environment(self) -> dict[str, str]:
+        return {**environment_without_linear_key(), CLAUDE_FOREGROUND_ENV: "1"}
+
+    def subagent_counts(self, stdout: str) -> tuple[int | None, int | None]:
+        envelope = json.loads(stdout)
+        stats = envelope.get("subagent_stats") if isinstance(envelope, dict) else None
+        if not isinstance(stats, dict):
+            return None, None
+        return _count(stats.get("spawned")), _count(stats.get("started_in_background"))
 
     def usage(self, stdout: str, session_id: str | None) -> AgentUsage | None:
         """Lit l'enveloppe --output-format json : usage cumule de tous les tours."""
@@ -515,6 +571,14 @@ def get_agent_adapter(name: str) -> AgentAdapter:
     return adapter_type()
 
 
+def describe_missing_output(agent: str, stdout: str) -> str:
+    """Cause d'une sortie structuree absente, pour la reprise guidee."""
+    try:
+        return get_agent_adapter(agent).missing_output_message(stdout)
+    except ValueError:
+        return STRUCTURED_OUTPUT_MISSING_MESSAGE
+
+
 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())
@@ -610,6 +674,10 @@ def _int(value: object) -> int:
     return value if isinstance(value, int) and not isinstance(value, bool) else 0
 
 
+def _count(value: object) -> int | None:
+    return value if isinstance(value, int) and not isinstance(value, bool) else None
+
+
 def _codex_home() -> Path:
     return Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex")