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

devflow_cli/__init__.py

@@ -1,18 +1,18 @@
 """devflow CLI — workflow de développement adaptatif."""
 
-VERSION = "7.1.1"
+VERSION = "8.0.0"
 
 SUPPORTED_AGENTS = ["claude-code", "codex", "cursor"]
 
 ACTIVITY_LINEAR_MAPPING = {
     "assess": "Backlog",
-    "prepare": "Plan",
-    "risk-assessment": "Research",
-    "spec": "Spec",
-    "contracts": "Plan",
-    "plan": "Plan",
-    "tasks": "Tasks",
-    "preflight-evidence": "Plan",
+    "risk-assessment": "Design",
+    "prepare": "Design",
+    "spec": "Design",
+    "contracts": "Design",
+    "plan": "Design",
+    "tasks": "Design",
+    "preflight-evidence": "Design",
     "implement": "In Progress",
     "verify": "Review",
     "review": "Review",
@@ -22,10 +22,7 @@ ACTIVITY_LINEAR_MAPPING = {
 
 LINEAR_STATUS_ORDER = [
     "Backlog",
-    "Spec",
-    "Research",
-    "Plan",
-    "Tasks",
+    "Design",
     "In Progress",
     "Review",
     "Done",

devflow_cli/adapters/agents.py

@@ -16,6 +16,8 @@ from typing import Literal
 from jsonschema.exceptions import SchemaError, ValidationError
 from jsonschema.validators import validator_for
 
+from devflow_cli.adapters.linear import environment_without_linear_key
+
 
 PermissionMode = Literal["auto", "acceptEdits", "manual"]
 SandboxMode = Literal["read-only", "workspace-write"]
@@ -123,6 +125,7 @@ class AgentAdapter(ABC):
                 capture_output=capture_output,
                 stdin=subprocess.DEVNULL,
                 shell=False,
+                env=environment_without_linear_key(),
             )
             return AgentExecution(
                 result.returncode,
@@ -162,6 +165,7 @@ class AgentAdapter(ABC):
                 capture_output=True,
                 stdin=subprocess.DEVNULL,
                 shell=False,
+                env=environment_without_linear_key(),
             )
             execution = AgentExecution(
                 result.returncode,

devflow_cli/adapters/linear.py

@@ -1,11 +1,32 @@
-"""Politique de synchronisation Linear, indépendante du transport MCP/API."""
+"""Politique de synchronisation Linear et transport GraphQL."""
 
 from __future__ import annotations
 
+import json
+import os
+import urllib.error
+import urllib.request
 from dataclasses import dataclass
-from typing import Literal, Protocol
+from typing import Literal, Protocol, TextIO
 
-from devflow_cli import ACTIVITY_LINEAR_MAPPING, LINEAR_STATUS_ORDER
+from devflow_cli import ACTIVITY_LINEAR_MAPPING, LINEAR_STATUS_ORDER, VERSION
+from devflow_cli.core.run_progress import emit_progress
+
+
+LINEAR_API_KEY_ENV = "LINEAR_API_KEY"
+LINEAR_API_URL = "https://api.linear.app/graphql"
+LINEAR_TIMEOUT_SECONDS = 5
+
+_ISSUE_QUERY = (
+    "query($id: String!) { issue(id: $id) { id state { name } "
+    "team { states { nodes { id name } } } } }"
+)
+_UPDATE_MUTATION = (
+    "mutation($id: String!, $stateId: String!) { "
+    "issueUpdate(id: $id, input: { stateId: $stateId }) { success } }"
+)
+
+_missing_key_warned = False
 
 
 LinearAction = Literal["update", "keep", "skip"]
@@ -81,3 +102,142 @@ def sync_linear_status(
     if decision.should_update and decision.target_status is not None:
         adapter.update_status(issue_id, decision.target_status)
     return decision
+
+
+def environment_without_linear_key() -> dict[str, str]:
+    """Environnement transmis aux processus lancés par la CLI, sans la clé Linear."""
+    return {key: value for key, value in os.environ.items() if key != LINEAR_API_KEY_ENV}
+
+
+class _NoRedirectHandler(urllib.request.HTTPRedirectHandler):
+    """Refuse de suivre une redirection : l'en-tête Authorization ne doit pas la suivre."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+class LinearSyncError(Exception):
+    """Échec de synchronisation ; le libellé ne contient aucune donnée externe."""
+
+    def __init__(self, label: str) -> None:
+        super().__init__(label)
+        self.label = label
+
+
+class LinearGraphQLAdapter:
+    """Transport par l'API GraphQL de Linear, en bibliothèque standard."""
+
+    def __init__(self, api_key: str, timeout: float = LINEAR_TIMEOUT_SECONDS) -> None:
+        self._api_key = api_key
+        self._timeout = timeout
+        self._issue_uuid: str | None = None
+        self._state_ids: dict[str, str] = {}
+
+    def get_status(self, issue_id: str) -> str | None:
+        data = self._request(_ISSUE_QUERY, {"id": issue_id})
+        issue = data.get("issue")
+        if issue is None:
+            raise LinearSyncError("issue inconnue de Linear")
+        try:
+            self._issue_uuid = str(issue["id"])
+            self._state_ids = {
+                str(node["name"]): str(node["id"])
+                for node in issue["team"]["states"]["nodes"]
+            }
+            return str(issue["state"]["name"])
+        except (KeyError, TypeError):
+            raise LinearSyncError("reponse Linear invalide") from None
+
+    def update_status(self, issue_id: str, status: str) -> None:
+        state_id = self._state_ids.get(status)
+        if self._issue_uuid is None or state_id is None:
+            raise LinearSyncError(f"statut '{status}' absent de l'equipe Linear")
+        data = self._request(
+            _UPDATE_MUTATION, {"id": self._issue_uuid, "stateId": state_id}
+        )
+        result = data.get("issueUpdate")
+        if not isinstance(result, dict) or result.get("success") is not True:
+            raise LinearSyncError("mise a jour refusee par Linear")
+
+    def _request(self, query: str, variables: dict[str, str]) -> dict:
+        request = urllib.request.Request(
+            LINEAR_API_URL,
+            data=json.dumps({"query": query, "variables": variables}).encode("utf-8"),
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": self._api_key,
+                "User-Agent": f"devflow-cli/{VERSION}",
+            },
+            method="POST",
+        )
+        opener = urllib.request.build_opener(_NoRedirectHandler())
+        try:
+            with opener.open(request, timeout=self._timeout) as response:
+                payload = json.loads(response.read().decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            raise LinearSyncError(f"erreur HTTP {exc.code}") from None
+        except TimeoutError:
+            raise LinearSyncError("delai depasse") from None
+        except urllib.error.URLError as exc:
+            if isinstance(exc.reason, TimeoutError):
+                raise LinearSyncError("delai depasse") from None
+            raise LinearSyncError("erreur reseau") from None
+        except OSError:
+            raise LinearSyncError("erreur reseau") from None
+        except ValueError:
+            raise LinearSyncError("reponse Linear invalide") from None
+        if not isinstance(payload, dict):
+            raise LinearSyncError("reponse Linear invalide")
+        if payload.get("errors"):
+            raise LinearSyncError("erreur GraphQL")
+        data = payload.get("data")
+        if not isinstance(data, dict):
+            raise LinearSyncError("reponse Linear invalide")
+        return data
+
+
+def sync_activity_status(
+    issue_id: str, activity: str, stream: TextIO
+) -> LinearDecision | None:
+    """Synchronise le statut au démarrage d'une activité, sans jamais bloquer."""
+    global _missing_key_warned
+    api_key = os.environ.get(LINEAR_API_KEY_ENV, "").strip()
+    if not api_key:
+        if not _missing_key_warned:
+            _missing_key_warned = True
+            emit_progress(
+                f"Linear : avertissement, {LINEAR_API_KEY_ENV} absente ; "
+                "statuts non synchronises",
+                stream,
+            )
+        return None
+    try:
+        decision = sync_linear_status(LinearGraphQLAdapter(api_key), issue_id, activity)
+    except LinearSyncError as exc:
+        label = exc.label
+    except Exception:
+        label = "erreur inattendue"
+    else:
+        emit_progress(_describe_decision(issue_id, decision), stream)
+        return decision
+    emit_progress(
+        f"Linear : avertissement, {issue_id} non synchronisee ({label})", stream
+    )
+    return None
+
+
+def _describe_decision(issue_id: str, decision: LinearDecision) -> str:
+    if decision.action == "update":
+        return (
+            f"Linear : {issue_id} {decision.current_status} -> "
+            f"{decision.target_status} (activite {decision.activity})"
+        )
+    if decision.action == "keep":
+        return (
+            f"Linear : {issue_id} reste en {decision.current_status} "
+            f"(activite {decision.activity}, {decision.reason})"
+        )
+    return (
+        f"Linear : {issue_id} ignoree, statut {decision.current_status or 'inconnu'} "
+        f"({decision.reason})"
+    )

devflow_cli/commands/adaptive.py

@@ -14,6 +14,7 @@ from typing import Literal, Optional
 import typer
 
 from devflow_cli import VERSION
+from devflow_cli.adapters.linear import sync_activity_status
 from devflow_cli.core.adaptive_workflow import (
     AdaptiveWorkflowState,
     complete_activity,
@@ -24,6 +25,10 @@ from devflow_cli.core.adaptive_workflow import (
     write_adaptive_state,
 )
 from devflow_cli.core.assessment import read_assessment
+from devflow_cli.core.activity_base import (
+    enter_current_activity,
+    files_since_activity_base,
+)
 from devflow_cli.core.activity_contracts import (
     build_activity_contract,
     NEED_STATEMENT,
@@ -50,7 +55,6 @@ from devflow_cli.core.worklog import refresh_worklog, safe_refresh_worklog
 from devflow_cli.core.telemetry import append_record, telemetry_enabled, usage_payload
 from devflow_cli.core.waivers import create_validation_waiver
 from devflow_cli.core.remediation import (
-    carried_changed_files,
     discard_attempt,
     is_reopened_activity,
     reopen_activity,
@@ -76,6 +80,9 @@ app = typer.Typer(help="Machine d'etat des parcours adaptatifs")
 
 LEGACY_SCHEMA_EXIT_CODE = 1
 
+# Refus avant tout agent : base inutilisable (branche changee, historique reecrit).
+BASE_REFUSALS = frozenset({"base-history-rewritten", "base-branch-changed"})
+
 RESULT_VALIDATED_ACTIVITIES = frozenset({
     "prepare",
     "risk-assessment",
@@ -166,7 +173,10 @@ def start(feature: str = typer.Argument(..., help="ID ou dossier de la feature")
             assessment = _assessment(feature_dir)
             validate_need_statement(feature_dir / NEED_STATEMENT)
             state = create_adaptive_workflow(assessment.to_dict())
-        except ValueError as exc:
+            enter_current_activity(
+                state, project_root_for_feature(feature_dir), feature_dir
+            )
+        except (OSError, ValueError) as exc:
             fail(f"Impossible de demarrer le workflow : {exc}")
             raise typer.Exit(int(ExitCode.INVALID_CONTRACT)) from exc
         write_adaptive_state(state_file, state)
@@ -220,12 +230,17 @@ def complete(
                 validate_preflight_evidence(feature_dir / "preflight-evidence.md")
             ensure_fresh_devflow_evidence(feature_dir, state, activity)
             complete_activity(state, activity)
-        except ValueError as exc:
+            enter_current_activity(
+                state, project_root_for_feature(feature_dir), feature_dir
+            )
+        except (OSError, ValueError) as exc:
             fail(str(exc))
             console.print(f"  Suite : devflow adaptive status {state.issueId}")
             raise typer.Exit(int(ExitCode.BLOCKED)) from exc
         write_adaptive_state(feature_dir / "workflow-state.json", state)
     safe_refresh_worklog(feature_dir)
+    if activity == "done":
+        sync_activity_status(state.issueId, "done", run_progress.progress_stream(False))
     if state.status == "completed":
         ok(f"Workflow {state.profile} termine.")
         _print_completion_summary(feature_dir, state)
@@ -281,11 +296,15 @@ def contract(
                 state,
                 assessment.to_dict(),
                 feature_path,
-                carried_changed_files(feature_dir, state.currentActivity),
                 reopened=is_reopened_activity(feature_dir, state.currentActivity),
                 preflight_evidence=(feature_dir / "preflight-evidence.md").is_file(),
+                files_since_base=(
+                    files_since_activity_base(feature_dir, state)
+                    if state.activityBase is not None
+                    else ()
+                ),
             )
-        except ValueError as exc:
+        except (OSError, ValueError) as exc:
             fail(f"Impossible de generer le contrat : {exc}")
             raise typer.Exit(int(ExitCode.INVALID_CONTRACT)) from exc
         output_file = feature_dir / "activity-contract.json"
@@ -388,6 +407,9 @@ def run_adaptive(
                     f"agent {agent}, delai {timeout} s",
                     stream,
                 )
+                sync_activity_status(
+                    current_state.issueId, activity_contract.activity, stream
+                )
                 with run_progress.heartbeat(
                     activity_contract.activity,
                     agent,
@@ -451,12 +473,14 @@ def run_adaptive(
             _print_execution_json(
                 current_state.issueId, outcome.activity, True, outcome.reason,
                 outcome.detail, outcome.nextActivity, ExitCode.OK,
+                warnings=outcome.warnings,
             )
         else:
             ok(
                 f"Activite '{outcome.activity}' validee. "
                 f"Prochaine : {outcome.nextActivity}"
             )
+            _print_warnings(outcome.warnings)
         return
     safe_refresh_worklog(feature_dir)
     exit_code = exit_code_for_run_reason(outcome.reason)
@@ -464,9 +488,14 @@ def run_adaptive(
         _print_execution_json(
             current_state.issueId, outcome.activity, False, outcome.reason,
             outcome.detail, outcome.nextActivity, exit_code,
+            warnings=outcome.warnings,
         )
+    elif outcome.reason in BASE_REFUSALS:
+        fail(outcome.detail)
+        console.print(f"  Suite : devflow adaptive status {current_state.issueId}")
     else:
         fail(outcome.detail or outcome.reason)
+        _print_warnings(outcome.warnings)
         console.print(
             f"  Activite '{outcome.activity}' non validee : {outcome.reason}"
         )
@@ -585,12 +614,17 @@ def reconcile_adaptive(
             f"Activite '{outcome.activity}' reconciliee. "
             f"Prochaine : {outcome.nextActivity}"
         )
+        _print_warnings(outcome.warnings)
         return
     safe_refresh_worklog(feature_dir)
-    fail(
-        f"Reconciliation de '{outcome.activity}' refusee : {outcome.reason}"
-        + (f" ({outcome.detail})" if outcome.detail else "")
-    )
+    if outcome.reason in BASE_REFUSALS:
+        fail(outcome.detail)
+    else:
+        fail(
+            f"Reconciliation de '{outcome.activity}' refusee : {outcome.reason}"
+            + (f" ({outcome.detail})" if outcome.detail else "")
+        )
+        _print_warnings(outcome.warnings)
     console.print(f"  Suite : devflow adaptive status {state.issueId}")
     if outcome.reason == "reconcile-refused":
         console.print(
@@ -765,6 +799,9 @@ def reopen(
             entry = reopen_activity(
                 feature_dir, state, activity, reason, author=author
             )
+            enter_current_activity(
+                state, project_root_for_feature(feature_dir), feature_dir
+            )
         except (OSError, ValueError) as exc:
             fail(str(exc))
             console.print(f"  Suite : devflow adaptive status {state.issueId}")
@@ -800,19 +837,24 @@ def discard_attempt_command(
     )
     if entry["discardedFiles"]:
         warn(
-            "Changements laisses dans le working tree, non reportes : "
-            + ", ".join(entry["discardedFiles"])
+            "Fichiers modifies depuis le debut de l'activite "
+            f"'{entry['activity']}', comptes dans le lot a la relance ; remise en "
+            "etat a la charge du superviseur : " + ", ".join(entry["discardedFiles"])
         )
+    if entry.get("observationError"):
+        warn(f"Fichiers depuis la base non calcules : {entry['observationError']}")
 
 
 def _execute_local_verification(
     feature_dir: Path, project_root: Path, issue_id: str, *,
     refresh: bool = False, json_output: bool = False,
 ) -> None:
+    stream = run_progress.progress_stream(json_output)
     run_progress.emit_progress(
-        "Activite 'verify' demarree : verification locale",
-        run_progress.progress_stream(json_output),
+        "Activite 'verify' demarree : verification locale", stream
     )
+    if not refresh:
+        sync_activity_status(issue_id, "verify", stream)
     outcome = run_automatic_verification(feature_dir, project_root, refresh=refresh)
     if json_output:
         _print_execution_json(
@@ -843,6 +885,7 @@ def _execute_local_verification(
 def _print_execution_json(
     issue_id: str, activity: str | None, passed: bool, reason: str,
     detail: str, next_activity: str | None, exit_code: ExitCode,
+    *, warnings: tuple[str, ...] = (),
 ) -> None:
     typer.echo(json.dumps({
         "schemaVersion": 1,
@@ -853,9 +896,16 @@ def _print_execution_json(
         "detail": detail,
         "nextActivity": next_activity,
         "exitCode": int(exit_code),
+        "warnings": list(warnings),
     }, ensure_ascii=False))
 
 
+def _print_warnings(warnings: tuple[str, ...]) -> None:
+    """Ecart de declaration : avertissement seul, sans effet sur le code de sortie."""
+    for message in warnings:
+        warn(message)
+
+
 def _utc_now() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
@@ -1147,13 +1197,6 @@ def _print_run_recovery(
         console.print("    Ne relancez pas automatiquement l'agent : reconciliez d'abord les changements partiels.")
         console.print(f"    devflow adaptive reconcile {issue_id}")
         return
-    if reason == "stale-attempt":
-        console.print("    git status --short  # inspecter les changements de la tentative")
-        console.print(
-            "    Restaurez les fichiers de la tentative, ou abandonnez-la explicitement :"
-        )
-        console.print(f"    devflow adaptive discard-attempt {issue_id} --reason MOTIF")
-        return
     if reason == "inputs-changed-during-activity":
         console.print(
             "    Les entrees du besoin ont change pendant l'execution. "

devflow_cli/commands/check.py

@@ -8,6 +8,7 @@ from pathlib import Path
 
 import typer
 from devflow_cli.adapters.agents import get_agent_adapter
+from devflow_cli.adapters.linear import environment_without_linear_key
 from devflow_cli.core.agent_failure import diagnose_agent_failure
 from devflow_cli.utils.console import console, ok, warn, fail
 from devflow_cli.utils.logging import get_logger
@@ -78,7 +79,12 @@ def check(
     # git
     git_path = _cmd_exists("git")
     if git_path:
-        result = subprocess.run(["git", "--version"], capture_output=True, text=True)
+        result = subprocess.run(
+            ["git", "--version"],
+            capture_output=True,
+            text=True,
+            env=environment_without_linear_key(),
+        )
         version = result.stdout.strip().replace("git version ", "")
         ok(f"git -- {git_path} (version {version})")
         ok_count += 1
@@ -90,7 +96,10 @@ def check(
         codex_path = _cmd_exists("codex")
         if codex_path:
             result = subprocess.run(
-                ["codex", "--version"], capture_output=True, text=True
+                ["codex", "--version"],
+                capture_output=True,
+                text=True,
+                env=environment_without_linear_key(),
             )
             version = (result.stdout or result.stderr).strip()
             if result.returncode == 0:

devflow_cli/commands/hooks_cmd.py

@@ -8,6 +8,7 @@ from pathlib import Path
 
 import typer
 
+from devflow_cli.adapters.linear import environment_without_linear_key
 from devflow_cli.core.git import is_git_repo
 from devflow_cli.core.hooks import (
     DEFAULT_HOOK_TIMEOUT,
@@ -28,6 +29,7 @@ def _configure_hooks_path(repo: Path) -> None:
         ["git", "-C", str(repo), "config", "core.hooksPath", HOOKS_DIR_NAME],
         check=True,
         capture_output=True,
+        env=environment_without_linear_key(),
     )
 
 
@@ -36,6 +38,7 @@ def _current_hooks_path(repo: Path) -> str | None:
         ["git", "-C", str(repo), "config", "--get", "core.hooksPath"],
         capture_output=True,
         text=True,
+        env=environment_without_linear_key(),
     )
     if result.returncode != 0:
         return None
@@ -46,6 +49,7 @@ def _unset_hooks_path(repo: Path) -> None:
     subprocess.run(
         ["git", "-C", str(repo), "config", "--unset", "core.hooksPath"],
         capture_output=True,
+        env=environment_without_linear_key(),
     )