devflow-cli 4.0.2__py3-none-any.whl → 6.1.0__py3-none-any.whl

devflow_cli/__init__.py

@@ -1,6 +1,6 @@
 """devflow CLI — workflow de développement adaptatif."""
 
-VERSION = "4.0.2"
+VERSION = "6.1.0"
 
 SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
 
@@ -42,7 +42,7 @@ ARTIFACTS = [
     "preflight-evidence.md",
     "worklog.md",
     "activity-contract.json",
-    "activity-result.json",
+    "implement-result.json",
     "verification.json",
 ]
 

devflow_cli/adapters/agents.py

@@ -3,11 +3,13 @@
 from __future__ import annotations
 
 import json
+import os
 import subprocess
 import re
 import time
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
+from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Literal
 
@@ -21,9 +23,42 @@ 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 QuotaWindow:
+    """Evolution d'une fenetre de quota observee pendant une session agent."""
+
+    windowMinutes: int | None
+    usedPercentStart: float
+    usedPercentEnd: float
+    # None si la fenetre a ete reinitialisee entre les deux releves.
+    deltaPoints: float | None
+
+
+@dataclass(frozen=True)
+class AgentUsage:
+    """Compteurs de consommation declares par l'agent, sans aucun contenu.
+
+    inputTokens exclut toujours les tokens lus depuis le cache.
+    """
+
+    inputTokens: int = 0
+    cacheReadTokens: int = 0
+    cacheWriteTokens: int = 0
+    outputTokens: int = 0
+    reasoningTokens: int = 0
+    models: tuple[str, ...] = ()
+    effort: str | None = None
+    turns: int | None = None
+    costUsd: float | None = None
+    subagents: int | None = None
+    firstContextTokens: int | None = None
+    quota: tuple[QuotaWindow, ...] = ()
+
+
 @dataclass(frozen=True)
 class AgentExecution:
     returncode: int
@@ -35,6 +70,7 @@ class AgentExecution:
     final_output_bytes: int = 0
     final_output_diagnostic: str = "not-evaluated"
     session_id: str | None = None
+    usage: AgentUsage | None = None
 
 
 class StructuredOutputError(ValueError):
@@ -85,6 +121,7 @@ class AgentAdapter(ABC):
                 timeout=timeout,
                 text=True,
                 capture_output=capture_output,
+                stdin=subprocess.DEVNULL,
                 shell=False,
             )
             return AgentExecution(
@@ -123,6 +160,7 @@ class AgentAdapter(ABC):
                 timeout=timeout,
                 text=True,
                 capture_output=True,
+                stdin=subprocess.DEVNULL,
                 shell=False,
             )
             execution = AgentExecution(
@@ -133,7 +171,10 @@ class AgentAdapter(ABC):
                 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=_session_id(result.stdout or "", result.stderr or ""),
+                session_id=self.session_id(result.stdout or "", result.stderr or ""),
+            )
+            execution = replace(
+                execution, usage=self.safe_usage(execution.stdout, execution.session_id)
             )
             if execution.returncode != 0:
                 return execution
@@ -166,6 +207,7 @@ class AgentAdapter(ABC):
                     _output_size(output_file),
                     "validated",
                     execution.session_id,
+                    execution.usage,
                 )
 
             status = _output_status(output_file)
@@ -186,22 +228,46 @@ class AgentAdapter(ABC):
                 final_output_bytes=size,
                 final_output_diagnostic=diagnostic,
                 session_id=execution.session_id,
+                usage=execution.usage,
             )
         except subprocess.TimeoutExpired as exc:
+            stdout, stderr = _text(exc.stdout), _text(exc.stderr)
+            session_id = self.session_id(stdout, stderr)
             return AgentExecution(
                 124,
-                _text(exc.stdout),
-                _text(exc.stderr),
+                stdout,
+                stderr,
                 timed_out=True,
                 duration_seconds=time.monotonic() - started,
                 final_output_status=_output_status(output_file),
                 final_output_bytes=_output_size(output_file),
+                session_id=session_id,
+                usage=self.safe_usage(stdout, session_id),
             )
         except FileNotFoundError:
             return AgentExecution(127, stderr=f"Executable '{self.executable}' introuvable", duration_seconds=time.monotonic() - started)
 
-    def _structured_payload(self, stdout: str, output_file: Path) -> object:
-        if output_file.is_file():
+    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 usage(self, stdout: str, session_id: str | None) -> AgentUsage | None:
+        """Extrait les compteurs de consommation ; None si l'agent n'en fournit pas."""
+        return None
+
+    def safe_usage(self, stdout: str, session_id: str | None) -> AgentUsage | None:
+        """La mesure de consommation ne doit jamais faire echouer une activite."""
+        try:
+            return self.usage(stdout, session_id)
+        except Exception:  # noqa: BLE001 - format externe non contractuel
+            return None
+
+    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 | 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)
 
@@ -245,16 +311,46 @@ 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")
+
+    def usage(self, stdout: str, session_id: str | None) -> AgentUsage | None:
+        """Lit l'enveloppe --output-format json : usage cumule de tous les tours."""
+        envelope = json.loads(stdout)
+        if not isinstance(envelope, dict) or not isinstance(envelope.get("usage"), dict):
+            return None
+        usage = envelope["usage"]
+        details = usage.get("output_tokens_details")
+        subagents = envelope.get("subagent_stats")
+        model_usage = envelope.get("modelUsage")
+        cost = envelope.get("total_cost_usd")
+        turns = envelope.get("num_turns")
+        return AgentUsage(
+            inputTokens=_int(usage.get("input_tokens")),
+            cacheReadTokens=_int(usage.get("cache_read_input_tokens")),
+            cacheWriteTokens=_int(usage.get("cache_creation_input_tokens")),
+            outputTokens=_int(usage.get("output_tokens")),
+            reasoningTokens=_int(details.get("thinking_tokens")) if isinstance(details, dict) else 0,
+            models=tuple(model_usage) if isinstance(model_usage, dict) else (),
+            turns=turns if isinstance(turns, int) else None,
+            costUsd=float(cost) if isinstance(cost, (int, float)) else None,
+            subagents=(
+                subagents.get("spawned")
+                if isinstance(subagents, dict) and isinstance(subagents.get("spawned"), int)
+                else None
+            ),
+        )
 
 
 class CodexAdapter(AgentAdapter):
@@ -284,6 +380,7 @@ class CodexAdapter(AgentAdapter):
         else:
             command.extend(["--sandbox", sandbox_mode])
         command.extend([
+            "--json",
             "--output-schema",
             str(schema_file),
             "--output-last-message",
@@ -292,20 +389,62 @@ 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)
+            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(
-                "final-output-empty",
-                "Codex a termine sans reponse finale structuree",
+                "agent-turn-failed",
+                "Codex a interrompu son tour avant la reponse finale",
             )
-        raise StructuredOutputError(
-            "final-output-absent",
-            "Codex n'a pas produit le fichier de reponse finale structuree",
+        final_message = _codex_final_message(events)
+        if final_message is not None:
+            return json.loads(_strip_json_fence(final_message))
+        raise StructuredOutputError(diagnostic, message)
+
+    def usage(self, stdout: str, session_id: str | None) -> AgentUsage | None:
+        """Combine le flux --json et, au mieux, le journal de session Codex.
+
+        Le flux ne donne que les tokens ; le modele, l'effort, le nombre de
+        requetes et les quotas ne figurent que dans le journal de session, dont
+        le format est interne a Codex.
+        """
+        totals = [
+            event["usage"]
+            for event in json_line_events(stdout)
+            if event.get("type") == "turn.completed" and isinstance(event.get("usage"), dict)
+        ]
+        session = _codex_session_facts(session_id)
+        if not totals and session is None:
+            return None
+        raw_input = sum(_int(item.get("input_tokens")) for item in totals)
+        cached = sum(_int(item.get("cached_input_tokens")) for item in totals)
+        usage = AgentUsage(
+            inputTokens=max(raw_input - cached, 0),
+            cacheReadTokens=cached,
+            cacheWriteTokens=sum(_int(item.get("cache_write_input_tokens")) for item in totals),
+            outputTokens=sum(_int(item.get("output_tokens")) for item in totals),
+            reasoningTokens=sum(_int(item.get("reasoning_output_tokens")) for item in totals),
         )
+        return replace(usage, **session) if session else usage
 
 
 class CursorAdapter(AgentAdapter):
@@ -341,7 +480,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):
@@ -423,6 +562,33 @@ def _session_id(stdout: str, stderr: str) -> str | None:
     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)
@@ -434,3 +600,92 @@ def _validate_structured_payload(payload: object, schema_file: Path) -> None:
     validator_type = validator_for(schema)
     validator_type.check_schema(schema)
     validator_type(schema).validate(payload)
+
+
+def _int(value: object) -> int:
+    return value if isinstance(value, int) and not isinstance(value, bool) else 0
+
+
+def _codex_home() -> Path:
+    return Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex")
+
+
+def _codex_session_file(session_id: str | None) -> Path | None:
+    """Retrouve le journal d'une session Codex recente a partir de son identifiant."""
+    if not session_id or not re.fullmatch(r"[A-Za-z0-9-]{8,}", session_id):
+        return None
+    sessions = _codex_home() / "sessions"
+    today = datetime.now()
+    for offset in range(3):
+        day = today - timedelta(days=offset)
+        directory = sessions / f"{day:%Y}" / f"{day:%m}" / f"{day:%d}"
+        matches = sorted(directory.glob(f"rollout-*{session_id}.jsonl"))
+        if matches:
+            return matches[-1]
+    return None
+
+
+def _codex_session_facts(session_id: str | None) -> dict | None:
+    """Extrait modele, effort, requetes et quotas du journal de session Codex."""
+    path = _codex_session_file(session_id)
+    if path is None:
+        return None
+    models: list[str] = []
+    effort: str | None = None
+    totals: set[int] = set()
+    first_context: int | None = None
+    limits: list[dict] = []
+    with path.open(encoding="utf-8", errors="replace") as handle:
+        for event in json_line_events(handle.read()):
+            payload = event.get("payload")
+            if not isinstance(payload, dict):
+                continue
+            if event.get("type") == "turn_context":
+                model = payload.get("model")
+                if isinstance(model, str) and model not in models:
+                    models.append(model)
+                if isinstance(payload.get("effort"), str):
+                    effort = payload["effort"]
+            elif event.get("type") == "event_msg" and payload.get("type") == "token_count":
+                info = payload.get("info")
+                if isinstance(info, dict) and isinstance(info.get("total_token_usage"), dict):
+                    marker = _int(info["total_token_usage"].get("total_tokens"))
+                    if marker not in totals:
+                        totals.add(marker)
+                        last = info.get("last_token_usage")
+                        if first_context is None and isinstance(last, dict):
+                            first_context = _int(last.get("input_tokens")) or None
+                if isinstance(payload.get("rate_limits"), dict):
+                    limits.append(payload["rate_limits"])
+    return {
+        "models": tuple(models),
+        "effort": effort,
+        "turns": len(totals) or None,
+        "firstContextTokens": first_context,
+        "quota": _quota_windows(limits),
+    }
+
+
+def _quota_windows(limits: list[dict]) -> tuple[QuotaWindow, ...]:
+    """Compare le premier et le dernier releve de chaque fenetre de quota."""
+    windows: list[QuotaWindow] = []
+    if not limits:
+        return ()
+    for key in ("primary", "secondary"):
+        first, last = limits[0].get(key), limits[-1].get(key)
+        if not isinstance(first, dict) or not isinstance(last, dict):
+            continue
+        start, end = first.get("used_percent"), last.get("used_percent")
+        if not isinstance(start, (int, float)) or not isinstance(end, (int, float)):
+            continue
+        minutes = last.get("window_minutes")
+        same_window = first.get("resets_at") == last.get("resets_at")
+        windows.append(
+            QuotaWindow(
+                windowMinutes=minutes if isinstance(minutes, int) else None,
+                usedPercentStart=float(start),
+                usedPercentEnd=float(end),
+                deltaPoints=float(end) - float(start) if same_window else None,
+            )
+        )
+    return tuple(windows)

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
@@ -23,6 +22,7 @@ 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
+from devflow_cli.commands.usage import usage
 
 app = typer.Typer(
     name="devflow",
@@ -53,7 +53,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")
@@ -63,6 +62,7 @@ app.command(name="docs-sync")(docs_sync)
 app.command()(traceability)
 app.command()(verify)
 app.command()(assess)
+app.command()(usage)
 
 
 if __name__ == "__main__":