@sonenta/mcp 0.29.0 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sonenta/mcp",
-  "version": "0.29.0",
+  "version": "0.31.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.29.0"
+version = "0.31.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.29.0"
+__version__ = "0.31.0"

package/python/verbumia_mcp/tools.py

@@ -89,16 +89,20 @@ from .client import VerbumiaApiError, VerbumiaClient
 # visible text. `surfaceKinds` in the variants matrix tags each as a11y.
 A11Y_SURFACES = ("aria_label", "alt_text", "screen_reader", "plain_language")
 
-# RS1 (task 1367): audit trail of code edits an agent made while resolving a
-# duplicate group — passed on set_source_duplicate_merge_plan / set_duplicate_status,
-# persisted + surfaced in resolved_duplicates[]. Supplying it overwrites; omitting
-# preserves the prior value.
+# RS1 (task 1367) + FM1 (task 1390): audit trail of code edits an agent made while
+# resolving a duplicate group — accepted on ALL FOUR resolution paths
+# (set_source_duplicate_merge_plan, set_duplicate_status, apply_new_key_cluster,
+# mark_cluster_applied), persisted + surfaced in resolved_duplicates[]. FM1 changed
+# the semantics to UNION-MERGE (accumulate + dedup by tuple), not overwrite.
 _FILES_MODIFIED_SCHEMA = {
     "type": "array",
     "description": (
         "Optional audit trail of the code edits you made (e.g. t() repoints) while "
-        "resolving this group: each {path (required), line?, key_name?}. Supplying it "
-        "overwrites the stored record; omit to preserve the prior value."
+        "resolving this group: each {path (required), line?, key_name?}. Accepted on "
+        "every resolution path and MERGED (union + dedup by the full {path,line,"
+        "key_name} tuple) into the record — so record your edits at whatever step you "
+        "make them and they accumulate; omit to preserve the existing list. Always "
+        "pass the STRUCTURED field, never just a note."
     ),
     "items": {
         "type": "object",
@@ -2225,13 +2229,26 @@ def register(server: Server, client: VerbumiaClient) -> tuple[Any, Any]:
                                     "items": {
                                         "type": "object",
                                         "properties": {
-                                            "canonical_key_uuid": {"type": "string"},
+                                            "canonical_key_uuid": {
+                                                "type": "string",
+                                                "description": "An EXISTING key kept as the canonical survivor. Mutually exclusive with new_key.",
+                                            },
+                                            "new_key": {
+                                                "type": "object",
+                                                "description": "Create a BRAND-NEW canonical key instead of keeping an existing one (NK1). Mutually exclusive with canonical_key_uuid. For a new_key cluster, redundant_key_uuids = ALL the group's keys (none survives). After authoring, call apply_new_key_cluster — the backend creates the key + copies translations + trashes the old keys.",
+                                                "properties": {
+                                                    "name": {"type": "string", "description": "New key name (must not collide with an active key)."},
+                                                    "namespace": {"type": "string", "description": "Namespace slug the new key lives in (must exist)."},
+                                                },
+                                                "required": ["name", "namespace"],
+                                            },
                                             "redundant_key_uuids": {
                                                 "type": "array",
                                                 "items": {"type": "string"},
+                                                "description": "Keys folded into the canonical. For a new_key cluster, this is ALL the group's keys.",
                                             },
                                         },
-                                        "required": ["canonical_key_uuid", "redundant_key_uuids"],
+                                        "required": ["redundant_key_uuids"],
                                     },
                                 },
                                 "survivor_outcome": {
@@ -2278,11 +2295,55 @@ def register(server: Server, client: VerbumiaClient) -> tuple[Any, Any]:
                             "type": "boolean",
                             "description": "True to mark applied (default), false to un-mark.",
                         },
+                        "files_modified": _FILES_MODIFIED_SCHEMA,
                     },
                     "required": ["source_value", "canonical_key_uuid"],
                     "additionalProperties": False,
                 },
             ),
+            Tool(
+                name="apply_new_key_cluster",
+                description=(
+                    "Consolidate a duplicate group onto a BRAND-NEW canonical key (NK1) — "
+                    "the BACKEND does the atomic data transaction so no translation is "
+                    "lost: it creates the new key (type/description/context inherited from "
+                    "the group's most-complete key), COPIES every language value from that "
+                    "most-complete key, and TRASHES all the old keys. Address it by "
+                    "source_value + new_key {name, namespace} (the namespace must exist and "
+                    "the name must be free). Returns {new_key_uuid, name, namespace, "
+                    "copied_from_key_uuid, copied_languages, trashed_key_uuids}. YOUR job "
+                    "after this is the CODE only: repoint every t() usage of the trashed "
+                    "keys onto new_key_uuid, and record those edits in `files_modified` "
+                    "(accepted right here, union-merged). You do NOT create_key or "
+                    "delete_keys_bulk yourself — the backend owns that. Author the "
+                    "new_key cluster in the merge plan first (on the dev's acceptance)."
+                ),
+                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.",
+                        },
+                        "new_key": {
+                            "type": "object",
+                            "description": "The new canonical key to create and consolidate the group onto.",
+                            "properties": {
+                                "name": {"type": "string", "description": "New key name (must not collide with an active key)."},
+                                "namespace": {"type": "string", "description": "Namespace slug the new key lives in (must exist)."},
+                            },
+                            "required": ["name", "namespace"],
+                        },
+                        "files_modified": _FILES_MODIFIED_SCHEMA,
+                    },
+                    "required": ["source_value", "new_key"],
+                    "additionalProperties": False,
+                },
+            ),
         ]
 
     @server.call_tool()
@@ -3033,11 +3094,28 @@ def register(server: Server, client: VerbumiaClient) -> tuple[Any, Any]:
                 }
                 if "applied" in args:
                     body["applied"] = bool(args["applied"])
+                if args.get("files_modified"):
+                    body["files_modified"] = args["files_modified"]
                 data = await client.put(
                     f"/v1/mcp/projects/{project_uuid}/source-duplicates/cluster-applied",
                     json=body,
                 )
                 return _text(data)
+            if name == "apply_new_key_cluster":
+                project_uuid = _project_uuid(args, client)
+                new_key = args.get("new_key")
+                if not args.get("source_value") or not isinstance(new_key, dict):
+                    return _err("source_value and new_key {name, namespace} are required")
+                if not new_key.get("name") or not new_key.get("namespace"):
+                    return _err("new_key requires name and namespace")
+                body = {"source_value": args["source_value"], "new_key": new_key}
+                if args.get("files_modified"):
+                    body["files_modified"] = args["files_modified"]
+                data = await client.post(
+                    f"/v1/mcp/projects/{project_uuid}/source-duplicates/apply-cluster",
+                    json=body,
+                )
+                return _text(data)
             return _err(f"unknown tool: {name}")
         except VerbumiaApiError as exc:
             return _err(f"API {exc.status}: {exc.body}")