feat(0.36.0): outil MCP move_issue — déplacement de carte par le service d'agents

Le serveur MCP n'exposait en écriture que create_issue et
add_comment : un déplacement approuvé côté service d'agents
(kanbante.move_card, vague H3) aurait échoué faute d'outil.

- move_issue (owner, repo, number, column) réutilise le service
  de déplacement de l'interface (_do_move_card, extrait de
  POST /api/move sans changement de comportement) : board
  local, journal source « mcp », miroir d'étiquette kanban:*
  remplacée, autres étiquettes préservées.
- Colonne acceptée par clé, par étiquette de forge ou par
  libellé français affiché (définitions de l'espace).
- Garde doctrine : la cible done (« Terminé ») est refusée
  avant toute écriture — les agents s'arrêtent en Révision.
- Erreurs propres : colonne inconnue (liste des valides),
  dépôt/issue inconnu, pull request refusée.
- 296 tests verts (5 nouveaux + épingles de la liste d'outils
  mises à jour).

app/config.py

@@ -177,7 +177,7 @@ from urllib.parse import urlparse
 
 BASE_DIR = Path(__file__).resolve().parent.parent
 
-APP_VERSION = "0.35.0"
+APP_VERSION = "0.36.0"
 
 
 def _env_bool(name: str, default: bool) -> bool:

app/main.py

@@ -23,6 +23,7 @@ import logging
 import re
 import secrets
 import time
+import unicodedata
 from contextlib import asynccontextmanager
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
@@ -5402,38 +5403,34 @@ async def activity(request: Request):
 
 # ── Routes: API ────────────────────────────────────────────
 
-@app.post("/api/move")
-async def api_move(
-    request: Request,
-    repo_full_name: str = Form(...),
-    issue_number: int = Form(...),
-    to_column: str = Form(...),
-    from_column: str = Form(""),
-    to_order: str = Form(""),
-    from_order: str = Form(""),
-    csrf_token: str = Form(""),
-):
-    """Move an issue to a new column and persist the resulting order.
+async def _do_move_card(
+    repo_full_name: str,
+    issue_number: int,
+    to_column: str,
+    *,
+    from_column: str = "",
+    to_order: str = "",
+    from_order: str = "",
+    client,
+    conn_id: int,
+    ws_id: int,
+    source: str = "ui",
+) -> dict:
+    """Déplacement effectif d'une carte, une fois la portée résolue.
 
-    With KANBANTE_SYNC_GITEA enabled (default), moving to "done" closes
-    the issue in Gitea and moving out of "done" reopens it. A failed
-    write-back is reported in the response (gitea_sync="failed") instead
-    of failing the move itself.
+    Board local (placement + ordres), journal des événements,
+    write-back Gitea (fermeture en entrant dans « done »,
+    réouverture en en sortant — échecs rapportés, jamais
+    bloquants) et miroir de l'étiquette kanban:* de la colonne
+    (les autres étiquettes de l'issue sont préservées).
+
+    Partagé par POST /api/move (interface, source « ui ») et par
+    l'outil MCP move_issue (source « mcp ») — même patron que
+    _do_capture pour la création. L'outil MCP refuse la colonne
+    « done » en amont : y entrer ferme l'issue, et Terminé
+    appartient à Bruno dans son interface.
     """
-    if not _csrf_valid(request, csrf_token):
-        return _csrf_error()
-    parts = _split_full_name(repo_full_name)
-    if parts is None:
-        return JSONResponse(
-            {"ok": False, "error": "Invalid repo_full_name"}, status_code=400
-        )
-    owner, repo = parts
-    client, conn_id, ws_id = await _resolve_board_scope(request, owner, repo)
-    if to_column not in bcols.keys(ws_id):
-        return JSONResponse(
-            {"ok": False, "error": "Invalid column"}, status_code=400
-        )
-
+    owner, repo = _split_full_name(repo_full_name)
     move_issue(
         repo_full_name, issue_number, to_column,
         workspace_id=ws_id, connection_id=conn_id,
@@ -5459,7 +5456,7 @@ async def api_move(
     if from_column != to_column:
         log_event(
             repo_full_name, issue_number, "moved",
-            from_column or None, to_column,
+            from_column or None, to_column, source=source,
             workspace_id=ws_id, connection_id=conn_id,
         )
         # Émission Lot 2 (journal du service d'agents) : le titre
@@ -5473,7 +5470,7 @@ async def api_move(
                 titre_carte = ""
         _emettre_changement_colonne(
             repo_full_name, issue_number, from_column or None, to_column,
-            "ui", title=titre_carte,
+            source, title=titre_carte,
         )
 
     result: dict = {"ok": True, "gitea_sync": "skipped"}
@@ -5485,14 +5482,14 @@ async def api_move(
                 result["gitea_sync"] = "closed"
                 log_event(
                     repo_full_name, issue_number, "closed", to_column="done",
-                    workspace_id=ws_id, connection_id=conn_id,
+                    source=source, workspace_id=ws_id, connection_id=conn_id,
                 )
             elif from_column == "done":
                 await client.set_issue_state(owner, repo, issue_number, "open")
                 result["gitea_sync"] = "reopened"
                 log_event(
                     repo_full_name, issue_number, "reopened",
-                    from_column="done", to_column=to_column,
+                    from_column="done", to_column=to_column, source=source,
                     workspace_id=ws_id, connection_id=conn_id,
                 )
         except httpx.HTTPError as exc:
@@ -5538,6 +5535,46 @@ async def api_move(
     return result
 
 
+@app.post("/api/move")
+async def api_move(
+    request: Request,
+    repo_full_name: str = Form(...),
+    issue_number: int = Form(...),
+    to_column: str = Form(...),
+    from_column: str = Form(""),
+    to_order: str = Form(""),
+    from_order: str = Form(""),
+    csrf_token: str = Form(""),
+):
+    """Move an issue to a new column and persist the resulting order.
+
+    With KANBANTE_SYNC_GITEA enabled (default), moving to "done" closes
+    the issue in Gitea and moving out of "done" reopens it. A failed
+    write-back is reported in the response (gitea_sync="failed") instead
+    of failing the move itself.
+    """
+    if not _csrf_valid(request, csrf_token):
+        return _csrf_error()
+    parts = _split_full_name(repo_full_name)
+    if parts is None:
+        return JSONResponse(
+            {"ok": False, "error": "Invalid repo_full_name"}, status_code=400
+        )
+    owner, repo = parts
+    client, conn_id, ws_id = await _resolve_board_scope(request, owner, repo)
+    if to_column not in bcols.keys(ws_id):
+        return JSONResponse(
+            {"ok": False, "error": "Invalid column"}, status_code=400
+        )
+
+    return await _do_move_card(
+        repo_full_name, issue_number, to_column,
+        from_column=from_column, to_order=to_order,
+        from_order=from_order, client=client, conn_id=conn_id,
+        ws_id=ws_id, source="ui",
+    )
+
+
 @app.post("/api/issues")
 async def api_create_issue(
     request: Request,
@@ -6236,9 +6273,10 @@ async def api_toggle_issue_label(
 
 # ── MCP server (tools over JSON-RPC) ───────────────────────
 # Lectures depuis la 0.5.0 ; écritures minimales (create_issue,
-# add_comment) depuis la 0.26.0, gardées par la même authentification
-# que tout /mcp (session, Basic ou jeton d'API kbt_ — voir le
-# middleware : un jeton n'ouvre jamais l'interface web).
+# add_comment) depuis la 0.26.0, move_issue depuis la 0.36.0,
+# gardées par la même authentification que tout /mcp (session,
+# Basic ou jeton d'API kbt_ — voir le middleware : un jeton
+# n'ouvre jamais l'interface web).
 
 MCP_TOOLS = [
     {
@@ -6337,15 +6375,77 @@ MCP_TOOLS = [
             "required": ["owner", "repo", "number", "body"],
         },
     },
+    {
+        "name": "move_issue",
+        "description": "Move a card (issue) to another board column. "
+        "column accepts the column key (backlog, todo, in_progress, "
+        "qa, review), the forge label (kanban:review) or the French "
+        "display label (« À faire », « En cours », « Révision »…). "
+        "The kanban:* label on the issue is replaced; its other "
+        "labels are preserved. Moving to done (« Terminé ») is "
+        "REFUSED: that column belongs to the human owner — agents "
+        "stop at review. Write tool — same /mcp authentication as "
+        "the reads (kbt_ API token, session or Basic).",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "owner": {"type": "string"},
+                "repo": {"type": "string"},
+                "number": {"type": "integer"},
+                "column": {"type": "string"},
+            },
+            "required": ["owner", "repo", "number", "column"],
+        },
+    },
 ]
 
 
+def _plier_libelle_colonne(valeur: str) -> str:
+    """Plie un libellé de colonne pour comparaison tolérante :
+    minuscules, accents retirés, emoji et ponctuation éliminés,
+    séparateurs unifiés en espaces (« in_progress »,
+    « in-progress » et « In progress » se rejoignent)."""
+    texte = unicodedata.normalize("NFKD", valeur or "")
+    texte = "".join(c for c in texte if not unicodedata.combining(c))
+    return re.sub(r"[^a-z0-9]+", " ", texte.lower()).strip()
+
+
+def _normaliser_colonne_mcp(brut: str, ws_id: int) -> str:
+    """Résout la colonne visée par l'outil MCP move_issue.
+
+    Accepte la clé (« review »), l'étiquette de forge
+    (« kanban:review », alias d'espace compris) et le libellé
+    français affiché (« Révision », « À faire »…) — les noms
+    d'affichage viennent de la définition des colonnes de
+    l'espace, pas d'une table figée. Lève ValueError, avec la
+    liste des colonnes valides, si rien ne correspond.
+    """
+    candidats: dict[str, str] = {}
+    for colonne in bcols.get_columns(ws_id):
+        cle = colonne["key"]
+        candidats[_plier_libelle_colonne(cle)] = cle
+        candidats[_plier_libelle_colonne(colonne.get("name") or "")] = cle
+        if colonne.get("label"):
+            candidats[_plier_libelle_colonne(colonne["label"])] = cle
+    for etiquette, cle in bcols.label_lookup(ws_id).items():
+        candidats[_plier_libelle_colonne(etiquette)] = cle
+    candidats["to do"] = "todo"
+    visee = _plier_libelle_colonne(brut)
+    if visee in candidats:
+        return candidats[visee]
+    valides = ", ".join(bcols.keys(ws_id))
+    raise ValueError(
+        f"Colonne inconnue : « {brut} ». Colonnes valides : {valides}."
+    )
+
+
 async def _mcp_call_tool(name: str, args: dict) -> str:
     """Execute one MCP tool and return text content.
 
-    Reads hit the forge's read API; the two write tools
-    (create_issue, add_comment) reuse the existing creation /
-    comment services — never a reimplemented forge call.
+    Reads hit the forge's read API; the write tools reuse the
+    existing services (creation via _do_capture, comment via the
+    forge client, move via _do_move_card) — never a reimplemented
+    forge call.
     """
     if name == "list_projects":
         repos = await gitea.search_repos()
@@ -6466,6 +6566,65 @@ async def _mcp_call_tool(name: str, args: dict) -> str:
             },
             ensure_ascii=False,
         )
+    if name == "move_issue":
+        owner, repo = args["owner"], args["repo"]
+        number = int(args["number"])
+        full_name = f"{owner}/{repo}"
+        client, conn_id = await _client_for_repo(full_name)
+        ws_id = next(
+            (
+                ws["id"]
+                for ws in models.list_workspaces()
+                if conn_id in models.workspace_connection_ids(ws["id"])
+            ),
+            1,
+        )
+        target = _normaliser_colonne_mcp(str(args.get("column") or ""), ws_id)
+        if target == "done":
+            # Garde doctrine : Terminé appartient à Bruno dans son
+            # interface — refus avant toute écriture (entrer dans
+            # « done » fermerait l'issue côté forge).
+            raise ValueError(
+                "Colonne refusée : « Terminé » (done) appartient à "
+                "Bruno — les agents s'arrêtent en Révision (review)."
+            )
+        try:
+            issue = await client.get_issue(owner, repo, number)
+        except httpx.HTTPStatusError as exc:
+            if exc.response is not None and exc.response.status_code == 404:
+                raise ValueError(
+                    f"Dépôt ou issue inconnu : {full_name}#{number}"
+                ) from exc
+            raise
+        if issue.get("pull_request"):
+            raise ValueError(
+                f"{full_name}#{number} est une pull request, pas une carte."
+            )
+        placement: dict[int, str] = {}
+        for col_name, cards in get_board_state(full_name).items():
+            for card in cards:
+                placement[card["issue_number"]] = col_name
+        from_column = placement.get(number)
+        if from_column is None:
+            from_column = (
+                "done" if issue.get("state") == "closed" else "backlog"
+            )
+        result = await _do_move_card(
+            full_name, number, target,
+            from_column=from_column,
+            client=client, conn_id=conn_id, ws_id=ws_id, source="mcp",
+        )
+        return json.dumps(
+            {
+                "repo_full_name": full_name,
+                "number": number,
+                "title": issue.get("title", ""),
+                "from_column": from_column,
+                "column": target,
+                **result,
+            },
+            ensure_ascii=False,
+        )
     raise ValueError(f"Unknown tool: {name}")
 
 
@@ -6477,7 +6636,7 @@ async def mcp_info():
         "version": APP_VERSION,
         "transport": "streamable-http (JSON-RPC 2.0 over POST)",
         "read_only": False,
-        "write_tools": ["create_issue", "add_comment"],
+        "write_tools": ["create_issue", "add_comment", "move_issue"],
         "tools": [t["name"] for t in MCP_TOOLS],
     }
 
@@ -6486,8 +6645,9 @@ async def mcp_info():
 async def mcp_endpoint(request: Request):
     """Minimal MCP server: initialize / tools/list / tools/call / ping.
 
-    Reads since 0.5.0; since 0.26.0, two minimal write tools
-    (create_issue, add_comment) for the agent service, guarded by
+    Reads since 0.5.0; since 0.26.0, minimal write tools
+    (create_issue, add_comment — move_issue since 0.36.0) for the
+    agent service, guarded by
     the same /mcp authentication as the reads (session, Basic or
     kbt_ API token — a token never unlocks the web UI).
     """