@sonenta/mcp 0.26.0 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sonenta/mcp",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "MCP server for Sonenta translation management \u2014 wires Claude Desktop and other MCP clients into your project's keys, missing-key feed, and translation drafts.",
   "license": "MIT",
   "homepage": "https://sonenta.com",

package/python/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonenta-mcp"
-version = "0.26.0"
+version = "0.28.0"
 description = "Model Context Protocol server for Sonenta — list projects, missing keys, propose translations from Claude Desktop and other MCP clients."
 readme = "README.md"
 requires-python = ">=3.12,<3.14"

package/python/verbumia_mcp/__init__.py

@@ -1,3 +1,3 @@
 """Sonenta MCP server (MIT)."""
 
-__version__ = "0.26.0"
+__version__ = "0.28.0"

package/python/verbumia_mcp/tools.py

@@ -1881,6 +1881,76 @@ def register(server: Server, client: VerbumiaClient) -> tuple[Any, Any]:
                     "additionalProperties": False,
                 },
             ),
+            Tool(
+                name="list_a11y_review_queue",
+                description=(
+                    "Read the a11y REVIEW QUEUE — the per-(key, locale, surface) review "
+                    "items with their state. Each item: {key_uuid, key_name, "
+                    "namespace_slug, surface, surface_kind, locale, state (missing | draft "
+                    "| translated | reviewed | approved | rejected), value, is_bot, gap, "
+                    "base_value, screenshots[], drift, ignored, ignore_reason, "
+                    "reject_reason}; the envelope carries by_state / by_surface rollups. "
+                    "**Pass state='rejected' to drive the RECTIFICATION loop**: a reviewer "
+                    "rejected a suggestion and left a `reject_reason` — the retained "
+                    "`value` is the rejected text and `reject_reason` is the human's "
+                    "instruction. The agent regenerates a corrected value addressing the "
+                    "reason and re-proposes via set_a11y_variant (rejected is unprotected, "
+                    "so it returns to draft). Defaults to the production version. READ-ONLY."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "project_uuid": {
+                            "type": "string",
+                            "description": "Project UUID. Required when multiple projects are configured (SONENTA_PROJECTS); defaults to the single configured project otherwise.",
+                        },
+                        "version_id": {
+                            "type": "string",
+                            "description": "Optional version UUID; defaults to the production version.",
+                        },
+                        "state": {
+                            "type": "string",
+                            "enum": [
+                                "missing",
+                                "draft",
+                                "translated",
+                                "reviewed",
+                                "approved",
+                                "rejected",
+                            ],
+                            "description": "Filter to one review state. Use 'rejected' for the rectification loop (items carry reject_reason).",
+                        },
+                        "locale": {
+                            "type": "string",
+                            "description": "Filter to one locale code (e.g. 'fr'). Use 'source' for source-locale rows.",
+                        },
+                        "surface": {
+                            "type": "string",
+                            "enum": list(A11Y_SURFACES),
+                            "description": "Filter to one a11y surface.",
+                        },
+                        "namespace_uuid": {
+                            "type": "string",
+                            "description": "Restrict to one namespace by its UUID.",
+                        },
+                        "key_uuid": {
+                            "type": "string",
+                            "description": "Restrict to one key by its UUID.",
+                        },
+                        "include_ignored": {
+                            "type": "boolean",
+                            "description": "Include items suppressed by the remediation plan (ignored cells). Default false.",
+                        },
+                        "group_by_key": {
+                            "type": "boolean",
+                            "description": "Aggregate items by key (one entry per key with its surfaces/locales nested) instead of a flat list.",
+                        },
+                        "limit": {"type": "integer", "minimum": 1, "maximum": 500},
+                        "offset": {"type": "integer", "minimum": 0},
+                    },
+                    "additionalProperties": False,
+                },
+            ),
             Tool(
                 name="a11y_remediation_plan_get",
                 description=(
@@ -2093,6 +2163,101 @@ def register(server: Server, client: VerbumiaClient) -> tuple[Any, Any]:
                     "additionalProperties": False,
                 },
             ),
+            # --- Source Health: agent-authored merge plan + per-cluster applied
+            #     marking (task 1363; backend PR #183 + cluster-applied route) ---
+            Tool(
+                name="set_source_duplicate_merge_plan",
+                description=(
+                    "AUTHOR (or clear) the merge plan for one duplicate group, addressed "
+                    "by its shared source_value (Source Health duplicates). This is how "
+                    "the sonenta-source-health agent records the CONSOLIDATION it proposes "
+                    "and the dev accepted: which keys collapse onto which canonical, and "
+                    "what to do with whatever still shares the text. `merge_plan` = "
+                    "{clusters:[{canonical_key_uuid, redundant_key_uuids:[...]}], "
+                    "survivor_outcome:'allowed'|'differentiate'} — or null/omit to CLEAR "
+                    "the plan. Saving a plan sets the group's status to to_fix. After "
+                    "authoring, the agent repoints t() usages, trashes the redundant keys "
+                    "(delete_keys_bulk), marks each cluster applied (mark_cluster_applied), "
+                    "and finally set_duplicate_status(resolved). Author only a plan the "
+                    "dev accepted — never decide a merge silently."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "project_uuid": {
+                            "type": "string",
+                            "description": "Project UUID. Required when multiple projects are configured (SONENTA_PROJECTS); defaults to the single configured project otherwise.",
+                        },
+                        "source_value": {
+                            "type": "string",
+                            "description": "The shared source-language value identifying the duplicate group (from list_source_duplicates).",
+                        },
+                        "merge_plan": {
+                            "type": ["object", "null"],
+                            "description": "The consolidation plan, or null to clear it.",
+                            "properties": {
+                                "clusters": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "canonical_key_uuid": {"type": "string"},
+                                            "redundant_key_uuids": {
+                                                "type": "array",
+                                                "items": {"type": "string"},
+                                            },
+                                        },
+                                        "required": ["canonical_key_uuid", "redundant_key_uuids"],
+                                    },
+                                },
+                                "survivor_outcome": {
+                                    "type": "string",
+                                    "enum": ["allowed", "differentiate"],
+                                    "description": "What to do with survivors that still share the text: allowed (sanctioned duplicate) or differentiate (make distinct).",
+                                },
+                            },
+                        },
+                    },
+                    "required": ["source_value"],
+                    "additionalProperties": False,
+                },
+            ),
+            Tool(
+                name="mark_cluster_applied",
+                description=(
+                    "Mark ONE cluster of a duplicate group's merge plan as APPLIED — "
+                    "addressed by the group's source_value + the cluster's "
+                    "canonical_key_uuid. Call it after you have repointed the redundant "
+                    "keys' t() usages onto the canonical and trashed them "
+                    "(delete_keys_bulk), so the dashboard tracks per-cluster progress. "
+                    "Pass applied=false to UN-mark it. Once every cluster of the group is "
+                    "applied (and the survivor_outcome handled), set_duplicate_status("
+                    "resolved) closes the group."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "project_uuid": {
+                            "type": "string",
+                            "description": "Project UUID. Required when multiple projects are configured (SONENTA_PROJECTS); defaults to the single configured project otherwise.",
+                        },
+                        "source_value": {
+                            "type": "string",
+                            "description": "The shared source-language value identifying the duplicate group.",
+                        },
+                        "canonical_key_uuid": {
+                            "type": "string",
+                            "description": "The surviving canonical key of the cluster to mark applied.",
+                        },
+                        "applied": {
+                            "type": "boolean",
+                            "description": "True to mark applied (default), false to un-mark.",
+                        },
+                    },
+                    "required": ["source_value", "canonical_key_uuid"],
+                    "additionalProperties": False,
+                },
+            ),
         ]
 
     @server.call_tool()
@@ -2716,6 +2881,29 @@ def register(server: Server, client: VerbumiaClient) -> tuple[Any, Any]:
                     f"/v1/mcp/projects/{project_uuid}/{segment}", params=params
                 )
                 return _text(data)
+            if name == "list_a11y_review_queue":
+                project_uuid = _project_uuid(args, client)
+                params: dict[str, Any] = {}
+                for opt in (
+                    "version_id",
+                    "state",
+                    "locale",
+                    "surface",
+                    "namespace_uuid",
+                    "key_uuid",
+                    "limit",
+                    "offset",
+                ):
+                    if args.get(opt) is not None:
+                        params[opt] = args[opt]
+                if args.get("include_ignored"):
+                    params["include_ignored"] = "true"
+                if args.get("group_by_key"):
+                    params["group_by_key"] = "true"
+                data = await client.get(
+                    f"/v1/mcp/projects/{project_uuid}/a11y/review/queue", params=params
+                )
+                return _text(data)
             if name == "a11y_remediation_plan_get":
                 project_uuid = _project_uuid(args, client)
                 params: dict[str, Any] = {}
@@ -2792,6 +2980,35 @@ def register(server: Server, client: VerbumiaClient) -> tuple[Any, Any]:
                     json=body,
                 )
                 return _text(data)
+            if name == "set_source_duplicate_merge_plan":
+                project_uuid = _project_uuid(args, client)
+                if not args.get("source_value"):
+                    return _err("source_value is required")
+                body = {"source_value": args["source_value"]}
+                # merge_plan may be an object OR explicit null (to clear); send it
+                # whenever the key is present at all.
+                if "merge_plan" in args:
+                    body["merge_plan"] = args["merge_plan"]
+                data = await client.put(
+                    f"/v1/mcp/projects/{project_uuid}/source-duplicates/merge-plan",
+                    json=body,
+                )
+                return _text(data)
+            if name == "mark_cluster_applied":
+                project_uuid = _project_uuid(args, client)
+                if not args.get("source_value") or not args.get("canonical_key_uuid"):
+                    return _err("source_value and canonical_key_uuid are required")
+                body = {
+                    "source_value": args["source_value"],
+                    "canonical_key_uuid": args["canonical_key_uuid"],
+                }
+                if "applied" in args:
+                    body["applied"] = bool(args["applied"])
+                data = await client.put(
+                    f"/v1/mcp/projects/{project_uuid}/source-duplicates/cluster-applied",
+                    json=body,
+                )
+                return _text(data)
             return _err(f"unknown tool: {name}")
         except VerbumiaApiError as exc:
             return _err(f"API {exc.status}: {exc.body}")