devflow-cli 9.0.0__py3-none-any.whl → 10.0.0__py3-none-any.whl

devflow_cli/__init__.py

@@ -1,8 +1,6 @@
 """devflow CLI — workflow de développement adaptatif."""
 
-VERSION = "9.0.0"
-
-SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
+VERSION = "10.0.0"
 
 ACTIVITY_LINEAR_MAPPING = {
     "assess": "Backlog",

devflow_cli/adapters/__init__.py

@@ -4,8 +4,6 @@ from devflow_cli.adapters.agents import (
     AgentAdapter,
     AgentExecution,
     ClaudeCodeAdapter,
-    CodexAdapter,
-    CursorAdapter,
     get_agent_adapter,
 )
 
@@ -13,7 +11,5 @@ __all__ = [
     "AgentAdapter",
     "AgentExecution",
     "ClaudeCodeAdapter",
-    "CodexAdapter",
-    "CursorAdapter",
     "get_agent_adapter",
 ]

devflow_cli/adapters/agents.py

@@ -3,13 +3,11 @@
 from __future__ import annotations
 
 import json
-import os
 import subprocess
 import re
 import time
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, replace
-from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Literal
 
@@ -23,8 +21,9 @@ 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.
+# pas le JSON attendu. Claude porte le diagnostic dedie ; les autres valeurs restent
+# lisibles dans un agent-execution.json ecrit par une version anterieure, et sont
+# traitees comme la meme famille par la reprise guidee.
 STRUCTURED_OUTPUT_MISSING = "structured-output-missing"
 MISSING_STRUCTURED_OUTPUT_DIAGNOSTICS = frozenset({
     STRUCTURED_OUTPUT_MISSING,
@@ -40,13 +39,6 @@ STRUCTURED_OUTPUT_MISSING_MESSAGE = (
 # 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",
-    "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."""
@@ -111,9 +103,6 @@ class AgentAdapter(ABC):
     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,
@@ -243,8 +232,6 @@ class AgentAdapter(ABC):
                 + (
                     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 ""
                 ),
                 duration_seconds=execution.duration_seconds,
@@ -330,9 +317,6 @@ class ClaudeCodeAdapter(AgentAdapter):
             prompt,
         ]
 
-    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,
@@ -413,153 +397,13 @@ class ClaudeCodeAdapter(AgentAdapter):
         )
 
 
-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([
-            "--json",
-            "--output-schema",
-            str(schema_file),
-            "--output-last-message",
-            str(output_file),
-        ])
-        command.append(prompt)
-        return command
-
-    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(
-                "agent-turn-failed",
-                "Codex a interrompu son tour avant la reponse finale",
-            )
-        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):
-    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
-
-    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 | None) -> 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,
     "claude-code": ClaudeCodeAdapter,
-    "codex": CodexAdapter,
-    "cursor": CursorAdapter,
-    "cursor-agent": CursorAdapter,
 }
+# Nom ecrit dans les enregistrements (fiche de tentative, agent-execution.json, telemetrie).
+AGENT_NAME = "claude"
+SUPPORTED_AGENT_NAMES = frozenset(_AGENT_ADAPTERS)
 
 
 def get_agent_adapter(name: str) -> AgentAdapter:
@@ -579,20 +423,6 @@ def describe_missing_output(agent: str, stdout: str) -> str:
         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())
-    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 _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")
@@ -646,17 +476,6 @@ def json_line_events(stdout: str) -> list[dict]:
     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)
@@ -676,88 +495,3 @@ def _int(value: object) -> int:
 
 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")
-
-
-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/adapters/linear.py

@@ -52,16 +52,6 @@ class LinearDecision:
     def should_update(self) -> bool:
         return self.action == "update"
 
-    def to_dict(self) -> dict[str, str | bool | None]:
-        return {
-            "action": self.action,
-            "activity": self.activity,
-            "currentStatus": self.current_status,
-            "targetStatus": self.target_status,
-            "shouldUpdate": self.should_update,
-            "reason": self.reason,
-        }
-
 
 def decide_linear_transition(activity: str, current_status: str | None) -> LinearDecision:
     """Applique le mapping et la règle de non-régression canonique."""

devflow_cli/cli.py

@@ -13,20 +13,11 @@ from devflow_cli.commands.init_cmd import init
 from devflow_cli.commands.check import check
 from devflow_cli.commands.status import status
 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.upgrade_cmd import upgrade
-from devflow_cli.commands import extension
-from devflow_cli.commands import hooks_cmd
-from devflow_cli.commands import linear
 from devflow_cli.commands import adaptive
 from devflow_cli.commands import feedback
 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
 
 class DevflowGroup(TyperGroup):
     """Affiche un refus actionnable, sans trace, pour un fichier de feature 6.x."""
@@ -66,20 +57,11 @@ app.command()(init)
 app.command()(check)
 app.command()(status)
 app.command()(feature)
-app.command()(context)
-app.command(name="export")(export)
-app.command()(stale)
 app.command()(upgrade)
-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(adaptive.app, name="adaptive")
 app.add_typer(feedback.app, name="feedback")
 app.command(name="docs-sync")(docs_sync)
-app.command()(traceability)
-app.command()(verify)
 app.command()(assess)
-app.command()(usage)
 
 
 if __name__ == "__main__":