@syntholoc/mcp 0.4.0 → 0.6.1

package/dist/chunk-P7LZNIW2.js

@@ -1,1473 +0,0 @@
-// src/build-server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-
-// src/filter.ts
-function wildcardToRegExp(pattern) {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
-}
-function matchesAnyPattern(name, patterns) {
-  return patterns.some((re) => re.test(name));
-}
-function applyToolFilter(server, opts) {
-  const patterns = (opts.toolFilter ?? []).filter(Boolean).map(wildcardToRegExp);
-  if (!opts.readOnly && patterns.length === 0) return server;
-  const original = server.registerTool.bind(server);
-  const filtered = (name, config, handler) => {
-    const readOnly = config.annotations?.readOnlyHint;
-    if (opts.readOnly && !readOnly) return void 0;
-    if (patterns.length > 0 && !matchesAnyPattern(name, patterns)) {
-      return void 0;
-    }
-    return original(name, config, handler);
-  };
-  server.registerTool = filtered;
-  return server;
-}
-function parseList(value) {
-  if (!value) return void 0;
-  const items = value.split(",").map((s) => s.trim()).filter(Boolean);
-  return items.length > 0 ? items : void 0;
-}
-
-// src/prompts.ts
-import { z } from "zod";
-function userMessage(text) {
-  return { messages: [{ role: "user", content: { type: "text", text } }] };
-}
-function registerPrompts(server) {
-  server.registerPrompt(
-    "localize_changed",
-    {
-      title: "Localize changed keys",
-      description: "Sync changed source strings from the local diff, translate them, and write back.",
-      argsSchema: { projectId: z.string().optional() }
-    },
-    ({ projectId }) => userMessage(
-      [
-        "Localize my recent source-string changes via Syntholoc:",
-        "1. Read `.syntholoc/config.json` for the source file(s) and project.",
-        projectId ? `   (Use project ${projectId} if config is missing.)` : "",
-        "2. From `git diff` on the source file(s), collect added/changed keys and `upsert_keys` (dryRun first to preview).",
-        "   - MULTI-FILE / namespaced project (a file per namespace, e.g. messages/en/home.json): import each",
-        "     changed file with `import_source_strings` passing `keyPrefix` = the namespace (the filename",
-        '     without extension, e.g. "home"). This keeps overlapping keys from different files distinct.',
-        "3. Call `get_config` for `maxBulkSize`. For EACH target locale check `locale_progress` \u2192 `untranslated`.",
-        "   - If untranslated >= maxBulkSize: `translate_locale` (scope UNTRANSLATED) and `wait_for_job`.",
-        "   - If below the threshold: tell me the counts and ASK whether to translate now or accumulate.",
-        "4. `export_locale` for each translated locale and write the result back into the mapped local files.",
-        "   - Namespaced project: call `export_locale` once per namespace with the same `keyPrefix` (the prefix",
-        "     is stripped on export) and write each result to its file, e.g. messages/{locale}/home.json.",
-        "5. Summarize keys added, locales translated, and the cost from the job usage."
-      ].filter(Boolean).join("\n")
-    )
-  );
-  server.registerPrompt(
-    "review_locale",
-    {
-      title: "Review a locale",
-      description: "Surface low-confidence and QA-flagged translations for a locale and help fix them.",
-      argsSchema: { projectId: z.string(), locale: z.string() }
-    },
-    ({ projectId, locale }) => userMessage(
-      [
-        `Review the "${locale}" locale in project ${projectId}:`,
-        "1. Resolve the locale id via `list_locales`.",
-        "2. `list_qa_issues` and `list_translations` (focus on low qaScore / non-approved).",
-        "3. For each problem, propose a fix; apply with `set_translation`, then `approve_translation`.",
-        "4. Summarize what changed and what still needs human attention."
-      ].join("\n")
-    )
-  );
-  server.registerPrompt(
-    "bootstrap_project",
-    {
-      title: "Bootstrap a project from this repo",
-      description: "Detect i18n files, create a Syntholoc project, seed locales, and write .syntholoc/config.json.",
-      argsSchema: {}
-    },
-    () => userMessage(
-      [
-        "Set up Syntholoc for this repository. PREFER the Git-sync path \u2014 it pulls every",
-        "source string (and any existing translations) in one server-side sync and keeps",
-        "the repo in sync going forward. Only fall back to manual imports if the user",
-        "declines Git or the code lives outside a supported host.",
-        "",
-        "1. Find the i18n source files and infer the source locale. Note the LAYOUT:",
-        "   - Single file per locale (e.g. messages/en.json) \u2192 one mapping, no namespace.",
-        "   - A directory per locale with many namespace files (e.g. messages/en/home.json, common.json) \u2192",
-        "     each file is a NAMESPACE. Syntholoc stores a flat key space, so each file is imported under a",
-        "     `keyPrefix` = its namespace to avoid collisions between files.",
-        "2. `create_project`, then `seed_starter_locales` (or `add_locale`) for the target languages. Use valid",
-        '   BCP-47 codes (e.g. "zh-CN", not "cn"); `add_locale` accepts `code` or `locale`. Region-ambiguous',
-        '   languages MUST be qualified \u2014 "pt" \u2192 "pt-BR" or "pt-PT", "zh" \u2192 "zh-CN" or "zh-TW". The tools reject',
-        '   ambiguous codes and return the candidates; if a source filename is just "pt", ask which region (or',
-        "   default to the likeliest) and record the file\u2192locale mapping in the config `translation` pattern.",
-        "   (Target locales must exist before a Git pull so their translation files import.)",
-        "3. RECOMMENDED \u2014 connect the repo and sync, instead of pushing strings one by one:",
-        "   a. `list_repositories`. If one is already connected, skip to (e).",
-        "   b. Write `.syntholoc/config.json` FIRST and commit it to the source branch \u2014 the server reads it",
-        "      from the repo as the SOURCE OF TRUTH for mappings on every sync/pull/write-back (Crowdin-style),",
-        "      so it must land in the branch before the first sync. Schema (https://syntholoc.com/schemas/config.json):",
-        "      the `projectId`, `sourceLocale`, and a Crowdin-style `files` array of `{ source, translation }`",
-        '      patterns, e.g. { "source": "messages/en/*.json", "translation": "messages/{locale}/%original_file_name%" }.',
-        "      - Placeholders: `{locale}` (or %locale% / %two_letters_code% / %original_file_name% / %original_path%).",
-        `      - If a locale's ON-DISK code differs from its BCP-47 code (e.g. "zh-CN" stored as "cn", "pt-BR" as "pt"),`,
-        '        add `languagesMapping`, e.g. { "two_letters_code": { "zh-CN": "cn", "pt-BR": "pt" } }.',
-        '      - Do NOT invent fields like `i18nDir`, `format: "nested-dirs"`, or `localeMapping` \u2014 they are not read.',
-        "      - CRITICAL: `.syntholoc/config.json` MUST be committed and tracked \u2014 it is the mapping source of",
-        "        truth the server reads from the branch. NEVER add `.syntholoc` (or the config file) to `.gitignore`.",
-        "        If `.gitignore` already ignores it (a common reflex, next to `.claude`), remove that line. After",
-        "        committing, VERIFY it is tracked (e.g. `git ls-files .syntholoc/config.json` returns the path, or",
-        "        `git check-ignore` reports nothing) \u2014 an ignored config means every sync/pull/write-back resolves",
-        "        zero files and silently opens no PR.",
-        "   c. Connect it with `connect_repository`. Ask the user which method they prefer:",
-        "      - GitHub App (no token, recommended): `get_github_app_install_url` \u2192 give the URL to the user",
-        "        to open and authorize (you cannot click it for them; you may offer to open it via the shell).",
-        "        Once they confirm, `list_github_installations` \u2192 `list_github_installation_repos` to pick the",
-        "        repo, then `connect_repository` with that `installationId`.",
-        "      - Token (any host): ask the user to paste a personal access token (repo read + PR scope), then",
-        "        `connect_repository` with `token`. Treat the token as a secret \u2014 do not echo it back.",
-        "   d. `files`/`paths` on `connect_repository` are an OPTIONAL fallback used only when the repo has no",
-        "      committed `.syntholoc/config.json`. If you committed the config in (b) you may pass the same `files`",
-        "      for redundancy, but the in-repo config wins. Same Crowdin placeholders as the config file.",
-        "   e. `sync_repository` \u2014 imports ALL source strings from the repo at once and opens the translation PR.",
-        "      Then `pull_translations` to import any translation files already in the repo (choose `conflict`",
-        "      KEEP_APPROVED to preserve in-app edits).",
-        "   f. `wait_for_job` on the returned job id, then report keys imported and the PR url.",
-        "4. FALLBACK \u2014 file-based import when the user does NOT want Git integration:",
-        "   - Single file \u2192 `import_source_strings` once.",
-        "   - Namespaced \u2192 `import_source_strings` once PER FILE with `keyPrefix` set to the namespace",
-        "     (filename without extension). Keys become e.g. `home.title`, `common.title`.",
-        "5. Offer to run the localize_changed flow next."
-      ].join("\n")
-    )
-  );
-}
-
-// src/resources.ts
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  CONFIG_RESOURCE,
-  LIST_GLOSSARY,
-  LIST_JOBS,
-  LIST_KEYS,
-  LIST_LOCALES,
-  LIST_QA_ISSUES,
-  LIST_STYLE_GUIDES,
-  MY_ORGANIZATIONS,
-  PROJECT_ANALYTICS,
-  TM_STATS,
-  PROJECT_RESOURCE,
-  PROJECTS_RESOURCE
-} from "@syntholoc/sdk";
-function json(uri, data) {
-  return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(data, null, 2) }] };
-}
-function registerResources(server, gql) {
-  server.registerResource(
-    "config",
-    "syntholoc://config",
-    {
-      title: "Syntholoc config",
-      description: "Server metadata incl. maxBulkSize (auto-translate batch threshold).",
-      mimeType: "application/json"
-    },
-    async (uri) => json(uri, (await gql.request(CONFIG_RESOURCE)).appInfo)
-  );
-  server.registerResource(
-    "organizations",
-    "syntholoc://organizations",
-    {
-      title: "Organizations",
-      description: "Organizations you belong to (id, name, slug, your role). Pin one for a request with the `syntholoc-org-id` header; otherwise the earliest org is used.",
-      mimeType: "application/json"
-    },
-    async (uri) => json(
-      uri,
-      (await gql.request(MY_ORGANIZATIONS)).myProjects.map((g) => ({ ...g.organization, viewerRole: g.viewerRole }))
-    )
-  );
-  server.registerResource(
-    "projects",
-    "syntholoc://projects",
-    {
-      title: "Projects",
-      description: "All localization projects in the active organization.",
-      mimeType: "application/json"
-    },
-    async (uri) => json(uri, (await gql.request(PROJECTS_RESOURCE)).projects)
-  );
-  server.registerResource(
-    "project",
-    new ResourceTemplate("syntholoc://project/{projectId}", { list: void 0 }),
-    {
-      title: "Project overview",
-      description: "A project with its locales and per-locale progress.",
-      mimeType: "application/json"
-    },
-    async (uri, { projectId }) => json(uri, await gql.request(PROJECT_RESOURCE, { id: String(projectId) }))
-  );
-  server.registerResource(
-    "project-keys",
-    new ResourceTemplate("syntholoc://project/{projectId}/keys", { list: void 0 }),
-    {
-      title: "Project source keys",
-      description: "Source keys in a project (first 100).",
-      mimeType: "application/json"
-    },
-    async (uri, { projectId }) => json(uri, (await gql.request(LIST_KEYS, { projectId: String(projectId), skip: 0, take: 100 })).keys)
-  );
-  server.registerResource(
-    "project-locales",
-    new ResourceTemplate("syntholoc://project/{projectId}/locales", { list: void 0 }),
-    {
-      title: "Project locales",
-      description: "Target locales configured for a project.",
-      mimeType: "application/json"
-    },
-    async (uri, { projectId }) => json(uri, (await gql.request(LIST_LOCALES, { projectId: String(projectId) })).locales)
-  );
-  server.registerResource(
-    "project-progress",
-    new ResourceTemplate("syntholoc://project/{projectId}/progress", { list: void 0 }),
-    {
-      title: "Project progress",
-      description: "Per-locale translation progress and open QA issues for a project.",
-      mimeType: "application/json"
-    },
-    async (uri, { projectId }) => json(uri, (await gql.request(PROJECT_ANALYTICS, { projectId: String(projectId) })).projectAnalytics)
-  );
-  server.registerResource(
-    "project-jobs",
-    new ResourceTemplate("syntholoc://project/{projectId}/jobs", { list: void 0 }),
-    {
-      title: "Project jobs",
-      description: "Recent background jobs (translate / QA / git sync) for a project.",
-      mimeType: "application/json"
-    },
-    async (uri, { projectId }) => json(uri, (await gql.request(LIST_JOBS, { projectId: String(projectId), skip: 0, take: 25 })).jobs)
-  );
-  server.registerResource(
-    "project-qa-issues",
-    new ResourceTemplate("syntholoc://project/{projectId}/locale/{localeId}/qa-issues", { list: void 0 }),
-    {
-      title: "Locale QA issues",
-      description: "Open QA issues for a locale, with issue-type facets.",
-      mimeType: "application/json"
-    },
-    async (uri, { projectId, localeId }) => json(
-      uri,
-      await gql.request(LIST_QA_ISSUES, {
-        projectId: String(projectId),
-        localeId: String(localeId),
-        skip: 0,
-        take: 25
-      })
-    )
-  );
-  server.registerResource(
-    "glossary",
-    "syntholoc://glossary",
-    {
-      title: "Glossary",
-      description: "Organization-wide glossary terms (first 100).",
-      mimeType: "application/json"
-    },
-    async (uri) => json(uri, (await gql.request(LIST_GLOSSARY, { skip: 0, take: 100 })).glossaryTerms)
-  );
-  server.registerResource(
-    "style-guides",
-    "syntholoc://style-guides",
-    {
-      title: "Style guides",
-      description: "Organization-wide style guides.",
-      mimeType: "application/json"
-    },
-    async (uri) => json(uri, (await gql.request(LIST_STYLE_GUIDES, {})).styleGuides)
-  );
-  server.registerResource(
-    "tm",
-    "syntholoc://tm",
-    {
-      title: "Translation memory",
-      description: "Organization-wide Translation Memory coverage: entry counts per target locale.",
-      mimeType: "application/json"
-    },
-    async (uri) => json(uri, (await gql.request(TM_STATS, {})).tmStats)
-  );
-}
-
-// src/tools/analytics.ts
-import { z as z2 } from "zod";
-import { COST_ANALYTICS, LOCALE_PROGRESS, PROJECT_ANALYTICS as PROJECT_ANALYTICS2, USAGE } from "@syntholoc/sdk";
-
-// src/util.ts
-function jsonResult(data) {
-  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-}
-
-// src/tools/analytics.ts
-function registerAnalyticsTools(server, gql) {
-  server.registerTool(
-    "project_analytics",
-    {
-      title: "Project analytics",
-      description: "Real-time quality + progress metrics for a project (per-locale progress, open issues).",
-      inputSchema: { projectId: z2.string() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ projectId }) => jsonResult((await gql.request(PROJECT_ANALYTICS2, { projectId })).projectAnalytics)
-  );
-  server.registerTool(
-    "cost_analytics",
-    {
-      title: "Cost analytics",
-      description: "LLM token/cost time-series and per-model breakdown over a window (default 30 days).",
-      inputSchema: {
-        projectId: z2.string().optional(),
-        days: z2.number().int().min(1).max(365).optional()
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(COST_ANALYTICS, vars)).costAnalytics)
-  );
-  server.registerTool(
-    "usage",
-    {
-      title: "Org usage & plan",
-      description: "Organization plan, hosted words and seat usage.",
-      inputSchema: {},
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async () => jsonResult((await gql.request(USAGE)).usage)
-  );
-  server.registerTool(
-    "locale_progress",
-    {
-      title: "Locale progress",
-      description: "Progress counts for one locale: total / untranslated / autoTranslated / humanApproved. The `untranslated` count drives the batch threshold (see get_config).",
-      inputSchema: { projectId: z2.string(), localeId: z2.string() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(LOCALE_PROGRESS, vars)).localeProgress)
-  );
-}
-
-// src/tools/config.ts
-import { APP_INFO } from "@syntholoc/sdk";
-function registerConfigTools(server, gql) {
-  server.registerTool(
-    "get_config",
-    {
-      title: "Get Syntholoc config",
-      description: "Server metadata incl. `maxBulkSize` \u2014 the max keys per LLM batch. Use it as the auto-translate threshold: translate proactively only when pending untranslated keys reach this number; otherwise ask the user (an explicit translate request always runs).",
-      inputSchema: {},
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async () => jsonResult((await gql.request(APP_INFO)).appInfo)
-  );
-}
-
-// src/tools/git.ts
-import { z as z3 } from "zod";
-import {
-  CONNECT_REPOSITORY,
-  DISCONNECT_REPOSITORY,
-  GITHUB_APP,
-  GITHUB_INSTALLATIONS,
-  GITHUB_INSTALLATION_REPOS,
-  LIST_REPOSITORIES,
-  PULL_TRANSLATIONS,
-  PUSH_TRANSLATIONS,
-  SYNC_REPOSITORY,
-  UPDATE_REPOSITORY
-} from "@syntholoc/sdk";
-var fileMapping = z3.object({
-  source: z3.string().describe('Source file path or glob, e.g. "messages/en.json" or "locales/en/*.json".'),
-  translation: z3.string().describe(
-    'Translation pattern with Crowdin placeholders, e.g. "messages/%two_letters_code%/%original_file_name%" or "locales/%locale%/%original_file_name%".'
-  ),
-  languagesMapping: z3.record(z3.string(), z3.record(z3.string(), z3.string())).optional().describe(
-    'Crowdin `languages_mapping`: per-placeholder, per-locale path overrides. Keyed by placeholder name without % (e.g. "two_letters_code", "locale"), then by locale code, to the on-disk replacement. E.g. { "two_letters_code": { "zh-CN": "cn" } } writes Chinese under "cn" instead of "zh".'
-  )
-});
-function registerGitTools(server, gql) {
-  server.registerTool(
-    "list_repositories",
-    {
-      title: "List repositories",
-      description: "Lists git repositories connected to a project.",
-      inputSchema: { projectId: z3.string() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ projectId }) => jsonResult((await gql.request(LIST_REPOSITORIES, { projectId })).repositories)
-  );
-  server.registerTool(
-    "get_github_app_install_url",
-    {
-      title: "GitHub App install URL",
-      description: "Returns whether the Syntholoc GitHub App is available and a signed install URL for this project. GitHub App connect flow, step 1: give this URL to the user to open in a browser and authorize Syntholoc on the repositories they want (this authorize click cannot be automated). After they finish, call `list_github_installations` to see the new installation. If `enabled` is false, the server has no GitHub App configured \u2014 fall back to the token (PAT) path via `connect_repository`.",
-      inputSchema: { projectId: z3.string() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ projectId }) => jsonResult((await gql.request(GITHUB_APP, { projectId })).githubApp)
-  );
-  server.registerTool(
-    "list_github_installations",
-    {
-      title: "List GitHub installations",
-      description: "Lists GitHub App installations available to the active organization. GitHub App connect flow, step 2: run this after the user authorized the App (see `get_github_app_install_url`) to get the `installationId` to pass to `list_github_installation_repos` and `connect_repository`.",
-      inputSchema: { projectId: z3.string() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ projectId }) => jsonResult((await gql.request(GITHUB_INSTALLATIONS, { projectId })).githubInstallations)
-  );
-  server.registerTool(
-    "list_github_installation_repos",
-    {
-      title: "List installation repositories",
-      description: "Lists the repositories Syntholoc can access through a GitHub App installation. GitHub App connect flow, step 3: pick the target repo (its `fullName` and `defaultBranch`) before calling `connect_repository` with the same `installationId`.",
-      inputSchema: {
-        projectId: z3.string(),
-        installationId: z3.number().int().describe("From `list_github_installations`.")
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ projectId, installationId }) => jsonResult((await gql.request(GITHUB_INSTALLATION_REPOS, { projectId, installationId })).githubInstallationRepos)
-  );
-  server.registerTool(
-    "connect_repository",
-    {
-      title: "Connect repository",
-      description: "Connects a git repository to the project so syncs can pull source strings and push translation PRs. Provide EITHER `installationId` (GitHub App mode \u2014 after the browser authorize flow: `get_github_app_install_url` \u2192 `list_github_installations` \u2192 `list_github_installation_repos`) OR `token` (PAT mode \u2014 a personal access token with repo read + pull-request scope; works for GitHub, GitLab and Bitbucket, no browser needed). Mappings come from the repo's `.syntholoc/config.json` when present (the source of truth); `files`/`paths` here are an optional fallback used only when that file is absent. After connecting, call `sync_repository` to import all source strings at once.",
-      inputSchema: {
-        projectId: z3.string(),
-        provider: z3.enum(["GITHUB", "GITLAB", "BITBUCKET"]).default("GITHUB"),
-        fullName: z3.string().describe('owner/repo, e.g. "acme/webapp".'),
-        branch: z3.string().optional().describe('Source branch (default "main").'),
-        files: z3.array(fileMapping).optional().describe(
-          "Crowdin-style source\u2192translation mappings. Fallback only \u2014 an in-repo `.syntholoc/config.json` wins."
-        ),
-        paths: z3.array(z3.string()).optional().describe(
-          "Simple mode: source file paths/globs to track (use instead of `files`). Fallback for in-repo config."
-        ),
-        installationId: z3.number().int().optional().describe("GitHub App installation id. Mutually exclusive with `token`."),
-        token: z3.string().optional().describe("Access token (PAT mode), stored encrypted. Mutually exclusive with `installationId`."),
-        translationBranch: z3.string().optional().describe("Branch translations are committed to (default l10n_<branch>)."),
-        prTargetBranch: z3.string().optional().describe("Branch translation PRs target (default = branch)."),
-        autoSyncEnabled: z3.boolean().optional().describe("Enable scheduled auto-sync.")
-      },
-      annotations: { openWorldHint: true }
-    },
-    async ({ projectId, ...input }) => jsonResult((await gql.request(CONNECT_REPOSITORY, { projectId, input })).connectRepository)
-  );
-  server.registerTool(
-    "update_repository",
-    {
-      title: "Update repository",
-      description: "Updates an already-connected repository in place \u2014 no disconnect/reconnect, stored credentials and webhooks are preserved. Use it for integration settings (source `branch`, translation/PR branches, `pushSources`, auto-sync), and for `files`/`paths` only as the DB fallback. IMPORTANT: to change file MAPPINGS, prefer editing the repo's `.syntholoc/config.json` and opening a PR \u2014 that file is the source of truth and, when present, overrides `files`/`paths` here (they are ignored). So do NOT use this tool to change mappings of a config-managed repo; edit the file, open a PR, and after it merges call `sync_repository`. Only the fields you pass are changed.",
-      inputSchema: {
-        projectId: z3.string(),
-        repositoryId: z3.string(),
-        branch: z3.string().optional().describe("Source branch."),
-        files: z3.array(fileMapping).optional().describe("Crowdin-style source\u2192translation mappings (replaces existing)."),
-        paths: z3.array(z3.string()).optional().describe("Simple mode: source file paths/globs to track (replaces existing; use instead of `files`)."),
-        translationBranch: z3.string().optional().describe("Branch translations are committed to."),
-        prTargetBranch: z3.string().optional().describe("Branch translation PRs target."),
-        pushSources: z3.boolean().optional().describe("Rewrite the source file(s) in the repo from in-app keys."),
-        autoSyncEnabled: z3.boolean().optional().describe("Enable scheduled auto-sync."),
-        syncIntervalHours: z3.number().int().optional().describe("Auto-sync interval in hours.")
-      },
-      annotations: { openWorldHint: true }
-    },
-    async ({ projectId, repositoryId, ...input }) => jsonResult((await gql.request(UPDATE_REPOSITORY, { projectId, id: repositoryId, input })).updateRepository)
-  );
-  server.registerTool(
-    "disconnect_repository",
-    {
-      title: "Disconnect repository",
-      description: "Removes the link to a connected repository and its stored credentials. The repository itself is not affected. Destructive \u2014 confirm with the user first.",
-      inputSchema: { projectId: z3.string(), repositoryId: z3.string() },
-      annotations: { destructiveHint: true, openWorldHint: true }
-    },
-    async ({ projectId, repositoryId }) => jsonResult((await gql.request(DISCONNECT_REPOSITORY, { projectId, id: repositoryId })).disconnectRepository)
-  );
-  server.registerTool(
-    "sync_repository",
-    {
-      title: "Sync repository",
-      description: "Queues an immediate sync of a connected repository (pull \u2192 translate \u2192 PR).",
-      inputSchema: { projectId: z3.string(), repositoryId: z3.string() },
-      annotations: { openWorldHint: true }
-    },
-    async ({ projectId, repositoryId }) => jsonResult((await gql.request(SYNC_REPOSITORY, { projectId, id: repositoryId })).syncRepository)
-  );
-  server.registerTool(
-    "push_translations",
-    {
-      title: "Push translations (PR)",
-      description: "Queues write-back of a locale: export approved translations and open a PR.",
-      inputSchema: { projectId: z3.string(), repositoryId: z3.string(), localeId: z3.string() },
-      annotations: { openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(PUSH_TRANSLATIONS, vars)).pushTranslations)
-  );
-  server.registerTool(
-    "pull_translations",
-    {
-      title: "Pull translations",
-      description: "Queues a pull of translation files from the connected repo, importing them per locale. Returns the tracking job ids \u2014 the import itself runs in the background. `autoApprove` lands them as APPROVED; `conflict` is OVERWRITE | SKIP_EXISTING | KEEP_APPROVED.",
-      inputSchema: {
-        projectId: z3.string(),
-        repositoryId: z3.string(),
-        autoApprove: z3.boolean().default(false),
-        conflict: z3.enum(["OVERWRITE", "SKIP_EXISTING", "KEEP_APPROVED"]).default("OVERWRITE")
-      },
-      annotations: { openWorldHint: true }
-    },
-    async ({ projectId, repositoryId, autoApprove, conflict }) => jsonResult(
-      (await gql.request(PULL_TRANSLATIONS, { projectId, repositoryId, input: { autoApprove, conflict } })).pullTranslations
-    )
-  );
-}
-
-// src/tools/glossary.ts
-import { z as z4 } from "zod";
-import {
-  CREATE_GLOSSARY_TERM,
-  DELETE_GLOSSARY_TERM,
-  LIST_GLOSSARY as LIST_GLOSSARY2,
-  SUGGEST_GLOSSARY_TERMS,
-  UPDATE_GLOSSARY_TERM
-} from "@syntholoc/sdk";
-function registerGlossaryTools(server, gql) {
-  server.registerTool(
-    "list_glossary",
-    {
-      title: "List glossary terms",
-      description: "Lists glossary terms (project-scoped if projectId given, else org-wide).",
-      inputSchema: {
-        projectId: z4.string().optional(),
-        skip: z4.number().int().min(0).default(0),
-        take: z4.number().int().min(1).max(100).default(25)
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(LIST_GLOSSARY2, vars)).glossaryTerms)
-  );
-  server.registerTool(
-    "upsert_glossary_term",
-    {
-      title: "Create or update glossary term",
-      description: 'Creates a glossary term, or updates it when `termId` is given. `translations` is a per-locale map, e.g. {"de-DE":"\u2026"}. `forbidden` lists disallowed renderings.',
-      inputSchema: {
-        termId: z4.string().optional().describe("Provide to update an existing term"),
-        projectId: z4.string().optional().describe("Project scope; omit for org-wide (create only)"),
-        term: z4.string().optional(),
-        description: z4.string().optional(),
-        partOfSpeech: z4.string().optional(),
-        doNotTranslate: z4.boolean().optional(),
-        forbidden: z4.array(z4.string()).optional(),
-        translations: z4.record(z4.string(), z4.string()).optional()
-      },
-      annotations: { idempotentHint: true, openWorldHint: true }
-    },
-    async ({ termId, projectId, ...rest }) => {
-      if (termId) {
-        const data2 = await gql.request(UPDATE_GLOSSARY_TERM, { id: termId, input: rest });
-        return jsonResult(data2.updateGlossaryTerm);
-      }
-      if (!rest.term) throw new Error("`term` is required when creating a glossary term");
-      const data = await gql.request(CREATE_GLOSSARY_TERM, {
-        input: { term: rest.term, ...rest, projectId }
-      });
-      return jsonResult(data.createGlossaryTerm);
-    }
-  );
-  server.registerTool(
-    "delete_glossary_term",
-    {
-      title: "Delete glossary term",
-      description: "Deletes a glossary term. Destructive \u2014 confirm first.",
-      inputSchema: { termId: z4.string() },
-      annotations: { destructiveHint: true, openWorldHint: true }
-    },
-    async ({ termId }) => jsonResult((await gql.request(DELETE_GLOSSARY_TERM, { id: termId })).deleteGlossaryTerm)
-  );
-  server.registerTool(
-    "suggest_glossary_terms",
-    {
-      title: "Suggest glossary terms",
-      description: "AI-suggested glossary terms extracted from the project source strings.",
-      inputSchema: { projectId: z4.string() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ projectId }) => jsonResult((await gql.request(SUGGEST_GLOSSARY_TERMS, { projectId })).suggestGlossaryTerms)
-  );
-}
-
-// src/tools/jobs.ts
-import { z as z5 } from "zod";
-import { GET_JOB, LIST_JOBS as LIST_JOBS2, waitForJob } from "@syntholoc/sdk";
-function registerJobTools(server, gql) {
-  server.registerTool(
-    "get_job",
-    {
-      title: "Get job",
-      description: "Status, progress, token usage and cost of a background job by id.",
-      inputSchema: { jobId: z5.string(), projectId: z5.string() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ jobId, projectId }) => jsonResult((await gql.request(GET_JOB, { id: jobId, projectId })).job)
-  );
-  server.registerTool(
-    "list_jobs",
-    {
-      title: "List jobs",
-      description: "Recent background jobs for a project (translate / QA / git sync).",
-      inputSchema: {
-        projectId: z5.string(),
-        skip: z5.number().int().min(0).default(0),
-        take: z5.number().int().min(1).max(100).default(25)
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(LIST_JOBS2, vars)).jobs)
-  );
-  server.registerTool(
-    "wait_for_job",
-    {
-      title: "Wait for job",
-      description: "Polls a job until it reaches a terminal state (COMPLETED/FAILED/CANCELLED) or the timeout elapses, then returns its final detail. Use after translate/QA to follow a run.",
-      inputSchema: {
-        jobId: z5.string(),
-        projectId: z5.string(),
-        timeoutSec: z5.number().int().min(1).max(900).default(180),
-        pollIntervalSec: z5.number().int().min(1).max(30).default(2)
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ jobId, projectId, timeoutSec, pollIntervalSec }) => {
-      const { job, timedOut } = await waitForJob(gql, projectId, jobId, { timeoutSec, pollIntervalSec });
-      return jsonResult({ ...job, timedOut });
-    }
-  );
-}
-
-// src/tools/keys.ts
-import { z as z6 } from "zod";
-import {
-  DELETE_KEY,
-  IMPORT_SOURCE_STRINGS,
-  LIST_KEYS as LIST_KEYS2,
-  UPDATE_KEY,
-  UPSERT_KEYS
-} from "@syntholoc/sdk";
-var FORMATS = ["JSON", "YAML", "CSV", "PO", "XLIFF", "ANDROID_XML", "IOS_STRINGS", "NJK"];
-function registerKeyTools(server, gql) {
-  server.registerTool(
-    "list_keys",
-    {
-      title: "List keys",
-      description: "Lists source keys. With `localeId` + `status` (untranslated | flagged | approved) the result `totalCount` is the pending count for that status \u2014 use it for the batch threshold.",
-      inputSchema: {
-        projectId: z6.string(),
-        localeId: z6.string().optional(),
-        status: z6.enum(["untranslated", "flagged", "approved"]).optional(),
-        search: z6.string().optional(),
-        skip: z6.number().int().min(0).default(0),
-        take: z6.number().int().min(1).max(200).default(25)
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(LIST_KEYS2, vars)).keys)
-  );
-  server.registerTool(
-    "upsert_keys",
-    {
-      title: "Upsert keys (bulk)",
-      description: "Bulk-upserts source keys by name (delta sync from local i18n files). Keys not listed are left untouched. Returns added/updated/unchanged counts; set `dryRun` to preview.",
-      inputSchema: {
-        projectId: z6.string(),
-        keys: z6.array(
-          z6.object({
-            key: z6.string(),
-            sourceText: z6.string(),
-            context: z6.string().optional(),
-            maxLength: z6.number().int().positive().optional()
-          })
-        ).min(1),
-        dryRun: z6.boolean().default(false)
-      },
-      annotations: { idempotentHint: true, openWorldHint: true }
-    },
-    async ({ projectId, keys, dryRun }) => jsonResult((await gql.request(UPSERT_KEYS, { projectId, input: keys, dryRun })).upsertKeys)
-  );
-  server.registerTool(
-    "update_key",
-    {
-      title: "Update key",
-      description: "Updates a single key (source text, context, max length).",
-      inputSchema: {
-        projectId: z6.string(),
-        keyId: z6.string(),
-        sourceText: z6.string().optional(),
-        context: z6.string().optional(),
-        maxLength: z6.number().int().positive().optional()
-      },
-      annotations: { idempotentHint: true, openWorldHint: true }
-    },
-    async ({ projectId, keyId, ...input }) => jsonResult((await gql.request(UPDATE_KEY, { projectId, id: keyId, input })).updateKey)
-  );
-  server.registerTool(
-    "delete_key",
-    {
-      title: "Delete key",
-      description: "Deletes a key and its translations. Destructive \u2014 confirm first.",
-      inputSchema: { projectId: z6.string(), keyId: z6.string() },
-      annotations: { destructiveHint: true, openWorldHint: true }
-    },
-    async ({ projectId, keyId }) => jsonResult((await gql.request(DELETE_KEY, { projectId, id: keyId })).deleteKey)
-  );
-  server.registerTool(
-    "import_source_strings",
-    {
-      title: "Import source strings",
-      description: 'Imports source strings from ONE file (paste the raw content) and returns the diff summary. For initial setup of a repo-hosted project, PREFER connecting the repo and running `sync_repository` \u2014 it imports every source file server-side in one pass; use this tool only for file-based projects with no Git integration, or for one-off single-file imports. For a multi-file / namespaced project (a file per namespace, e.g. messages/en/home.json), pass `keyPrefix` (the namespace, e.g. "home") so keys become `home.title` and files with overlapping top-level keys do not collide \u2014 call once per file. Use `dryRun` to preview.',
-      inputSchema: {
-        projectId: z6.string(),
-        content: z6.string(),
-        format: z6.enum(FORMATS),
-        keyPrefix: z6.string().optional().describe('Namespace prefix, e.g. "home" (per-file, multi-file projects).'),
-        sourceFile: z6.string().optional().describe(
-          'Real source file path, e.g. "messages/en/home.json" \u2014 stored for the file tree + reliable export.'
-        ),
-        dryRun: z6.boolean().default(false)
-      },
-      annotations: { idempotentHint: true, openWorldHint: true }
-    },
-    async ({ projectId, content, format, keyPrefix, sourceFile, dryRun }) => jsonResult(
-      (await gql.request(IMPORT_SOURCE_STRINGS, {
-        projectId,
-        input: { content, format, keyPrefix, sourceFile, dryRun }
-      })).importSourceStrings
-    )
-  );
-}
-
-// src/tools/locales.ts
-import { z as z7 } from "zod";
-import { ADD_LOCALE, LIST_LOCALES as LIST_LOCALES2, REMOVE_LOCALE, SEED_STARTER_LOCALES } from "@syntholoc/sdk";
-
-// ../../packages/shared/src/locales.ts
-var STARTER_LOCALES = [
-  { code: "ar", name: "Arabic", nativeName: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629", rtl: true },
-  { code: "az", name: "Azerbaijani", nativeName: "Az\u0259rbaycan" },
-  { code: "be", name: "Belarusian", nativeName: "\u0411\u0435\u043B\u0430\u0440\u0443\u0441\u043A\u0430\u044F" },
-  { code: "bn", name: "Bengali", nativeName: "\u09AC\u09BE\u0982\u09B2\u09BE" },
-  { code: "cs", name: "Czech", nativeName: "\u010Ce\u0161tina" },
-  { code: "de", name: "German", nativeName: "Deutsch" },
-  { code: "el", name: "Greek", nativeName: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC" },
-  { code: "en", name: "English", nativeName: "English" },
-  { code: "es", name: "Spanish", nativeName: "Espa\xF1ol" },
-  { code: "es-419", name: "Spanish (Latin America)", nativeName: "Espa\xF1ol (Latinoam\xE9rica)" },
-  { code: "fa", name: "Persian", nativeName: "\u0641\u0627\u0631\u0633\u06CC", rtl: true },
-  { code: "fr", name: "French", nativeName: "Fran\xE7ais" },
-  { code: "hi", name: "Hindi", nativeName: "\u0939\u093F\u0928\u094D\u0926\u0940" },
-  { code: "hy", name: "Armenian", nativeName: "\u0540\u0561\u0575\u0565\u0580\u0565\u0576" },
-  { code: "id", name: "Indonesian", nativeName: "Bahasa Indonesia" },
-  { code: "it", name: "Italian", nativeName: "Italiano" },
-  { code: "ja", name: "Japanese", nativeName: "\u65E5\u672C\u8A9E" },
-  { code: "ka", name: "Georgian", nativeName: "\u10E5\u10D0\u10E0\u10D7\u10E3\u10DA\u10D8" },
-  { code: "kk", name: "Kazakh", nativeName: "\u049A\u0430\u0437\u0430\u049B \u0442\u0456\u043B\u0456" },
-  { code: "ko", name: "Korean", nativeName: "\uD55C\uAD6D\uC5B4" },
-  { code: "lv", name: "Latvian", nativeName: "Latvie\u0161u" },
-  { code: "ms", name: "Malay", nativeName: "Bahasa Melayu" },
-  { code: "nl", name: "Dutch", nativeName: "Nederlands" },
-  { code: "pl", name: "Polish", nativeName: "Polski" },
-  { code: "pt-BR", name: "Portuguese (Brazil)", nativeName: "Portugu\xEAs (Brasil)" },
-  { code: "pt-PT", name: "Portuguese (Portugal)", nativeName: "Portugu\xEAs (Portugal)" },
-  { code: "ro", name: "Romanian", nativeName: "Rom\xE2n\u0103" },
-  { code: "ru", name: "Russian", nativeName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" },
-  { code: "sk", name: "Slovak", nativeName: "Sloven\u010Dina" },
-  { code: "sl", name: "Slovenian", nativeName: "Sloven\u0161\u010Dina" },
-  { code: "sw", name: "Swahili", nativeName: "Kiswahili" },
-  { code: "th", name: "Thai", nativeName: "\u0E44\u0E17\u0E22" },
-  { code: "tl", name: "Filipino", nativeName: "Filipino" },
-  { code: "tr", name: "Turkish", nativeName: "T\xFCrk\xE7e" },
-  { code: "uk", name: "Ukrainian", nativeName: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430" },
-  { code: "ur", name: "Urdu", nativeName: "\u0627\u0631\u062F\u0648", rtl: true },
-  { code: "uz", name: "Uzbek", nativeName: "O\u02BBzbek" },
-  { code: "vi", name: "Vietnamese", nativeName: "Ti\u1EBFng Vi\u1EC7t" },
-  { code: "zh-CN", name: "Chinese (Simplified)", nativeName: "\u7B80\u4F53\u4E2D\u6587" },
-  { code: "zh-TW", name: "Chinese (Traditional)", nativeName: "\u7E41\u9AD4\u4E2D\u6587" }
-];
-var STARTER_LOCALE_CODES = STARTER_LOCALES.map((l) => l.code);
-var STARTER_BY_CODE = new Map(STARTER_LOCALES.map((l) => [l.code, l]));
-function findStarterLocale(code) {
-  return STARTER_BY_CODE.get(code);
-}
-
-// ../../packages/shared/src/locale-resolve.ts
-var ALIASES = {
-  cn: "zh-CN",
-  "zh-hans": "zh-CN",
-  "zh-hant": "zh-TW",
-  jp: "ja",
-  kr: "ko",
-  ua: "uk",
-  cz: "cs",
-  gr: "el",
-  iw: "he",
-  // legacy Hebrew
-  in: "id"
-  // legacy Indonesian
-};
-var VARIANTS_BY_LANG = (() => {
-  const map = /* @__PURE__ */ new Map();
-  for (const { code } of STARTER_LOCALES) {
-    const lang = code.split("-")[0].toLowerCase();
-    (map.get(lang) ?? map.set(lang, []).get(lang)).push(code);
-  }
-  return map;
-})();
-function canonicalize(input) {
-  try {
-    return Intl.getCanonicalLocales(input)[0] ?? null;
-  } catch {
-    return null;
-  }
-}
-function isRealLanguage(code) {
-  try {
-    const name = new Intl.DisplayNames(["en"], { type: "language" }).of(code);
-    return !!name && name.toLowerCase() !== code.toLowerCase();
-  } catch {
-    return false;
-  }
-}
-function resolveLocaleCode(raw) {
-  const input = raw.trim();
-  if (!input) {
-    return { status: "unknown", input: raw, message: "Empty locale code." };
-  }
-  const alias = ALIASES[input.toLowerCase()];
-  if (alias) {
-    return { status: "normalized", code: alias, from: input, reason: `mapped "${input}" to catalog code "${alias}"` };
-  }
-  const canonical = canonicalize(input);
-  if (!canonical) {
-    return { status: "unknown", input, message: `"${input}" is not a valid BCP-47 locale code.` };
-  }
-  if (findStarterLocale(canonical)) {
-    return canonical === input ? { status: "ok", code: canonical } : { status: "normalized", code: canonical, from: input, reason: `casing normalized to "${canonical}"` };
-  }
-  const lang = canonical.split("-")[0].toLowerCase();
-  const hasRegionOrScript = canonical.includes("-");
-  const variants = VARIANTS_BY_LANG.get(lang) ?? [];
-  if (!hasRegionOrScript) {
-    if (variants.length > 1) {
-      return {
-        status: "ambiguous",
-        input,
-        candidates: variants,
-        message: `"${input}" is ambiguous \u2014 the catalog has ${variants.join(", ")}. Pick one.`
-      };
-    }
-    if (variants.length === 1) {
-      return {
-        status: "normalized",
-        code: variants[0],
-        from: input,
-        reason: `expanded "${input}" to "${variants[0]}"`
-      };
-    }
-    return isRealLanguage(canonical) ? { status: "ok", code: canonical } : { status: "unknown", input, message: `"${input}" is not a recognized language.` };
-  }
-  if (!isRealLanguage(canonical)) {
-    return { status: "unknown", input, message: `"${input}" is not a valid locale.` };
-  }
-  return canonical === input ? { status: "ok", code: canonical } : { status: "normalized", code: canonical, from: input, reason: `canonicalized to "${canonical}"` };
-}
-function resolveLocaleCodes(raw) {
-  const out = { codes: [], normalized: [], rejected: [] };
-  const seen = /* @__PURE__ */ new Set();
-  for (const code of raw) {
-    const res = resolveLocaleCode(code);
-    if (res.status === "ambiguous") {
-      out.rejected.push({ input: res.input, message: res.message, candidates: res.candidates });
-    } else if (res.status === "unknown") {
-      out.rejected.push({ input: res.input, message: res.message });
-    } else {
-      if (res.status === "normalized") out.normalized.push({ from: res.from, code: res.code, reason: res.reason });
-      if (!seen.has(res.code)) {
-        seen.add(res.code);
-        out.codes.push(res.code);
-      }
-    }
-  }
-  return out;
-}
-
-// ../../packages/shared/src/constants.ts
-var ORG_PLANS = ["FREE", "PRO", "ENTERPRISE"];
-function isPaidPlan(plan) {
-  switch (plan) {
-    case "PRO":
-    case "ENTERPRISE":
-      return true;
-    case "FREE":
-      return false;
-    default:
-      return false;
-  }
-}
-var PAID_PLANS = ORG_PLANS.filter(isPaidPlan);
-
-// src/tools/locales.ts
-function registerLocaleTools(server, gql) {
-  server.registerTool(
-    "list_locales",
-    {
-      title: "List locales",
-      description: "Lists the target locales configured for a project.",
-      inputSchema: { projectId: z7.string() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ projectId }) => jsonResult((await gql.request(LIST_LOCALES2, { projectId })).locales)
-  );
-  server.registerTool(
-    "add_locale",
-    {
-      title: "Add locale",
-      description: 'Adds ONE target locale to a project. To add several at once, prefer seed_starter_locales (one call for the whole list). Codes are validated: aliases/casing are normalized (e.g. "cn" \u2192 "zh-CN"), and ambiguous macro-languages (e.g. "pt", "zh") are rejected with the concrete variants to choose from (pt-BR / pt-PT, zh-CN / zh-TW).',
-      inputSchema: {
-        projectId: z7.string(),
-        // `code` and `locale` are aliases — accept either so the natural
-        // `locale: "de-DE"` form works as well as `code`.
-        code: z7.string().optional().describe('BCP-47 code, e.g. "de-DE" or "ru". Alias: `locale`.'),
-        locale: z7.string().optional().describe("Alias for `code`."),
-        name: z7.string().optional(),
-        formality: z7.string().optional(),
-        gender: z7.string().optional(),
-        variant: z7.string().optional()
-      },
-      annotations: { openWorldHint: true }
-    },
-    async ({ projectId, code, locale, name, formality, gender, variant }) => {
-      const resolvedCode = code ?? locale;
-      if (!resolvedCode) {
-        return jsonResult({
-          error: 'Missing locale code. Pass `code` (BCP-47, e.g. "de-DE" or "ru"). To add several locales at once, use seed_starter_locales with a `codes` array.'
-        });
-      }
-      const res = resolveLocaleCode(resolvedCode);
-      if (res.status === "ambiguous") {
-        return jsonResult({
-          error: res.message,
-          hint: `Retry add_locale with one of: ${res.candidates.join(", ")}.`,
-          candidates: res.candidates
-        });
-      }
-      if (res.status === "unknown") {
-        return jsonResult({ error: res.message, hint: 'Use a valid BCP-47 code, e.g. "de-DE" or "zh-CN".' });
-      }
-      const input = { code: res.code, name, formality, gender, variant };
-      const added = (await gql.request(ADD_LOCALE, { projectId, input })).addLocale;
-      return res.status === "normalized" ? jsonResult({ ...added, note: `Interpreted "${res.from}" as "${res.code}" (${res.reason}).` }) : jsonResult(added);
-    }
-  );
-  server.registerTool(
-    "seed_starter_locales",
-    {
-      title: "Seed starter locales",
-      description: 'Adds MULTIPLE target locales in one call \u2014 pass `codes` (BCP-47, e.g. ["ru","de-DE","fr"]), or omit for a common starter set. Prefer this over repeated add_locale calls. Codes are validated as a batch: if any are ambiguous (e.g. "pt", "zh") or invalid, NONE are added and the response lists what to fix; aliases like "cn" are normalized to "zh-CN".',
-      inputSchema: {
-        projectId: z7.string(),
-        codes: z7.array(z7.string()).optional().describe('BCP-47 codes to add, e.g. ["ru","de-DE","fr"].')
-      },
-      annotations: { openWorldHint: true }
-    },
-    async ({ projectId, codes }) => {
-      if (codes && codes.length > 0) {
-        const resolved = resolveLocaleCodes(codes);
-        if (resolved.rejected.length > 0) {
-          return jsonResult({
-            error: "Some locale codes are ambiguous or invalid; nothing was added.",
-            hint: "Fix the codes below and retry. For ambiguous ones, pick a listed candidate.",
-            rejected: resolved.rejected
-          });
-        }
-        const seeded = (await gql.request(SEED_STARTER_LOCALES, { projectId, codes: resolved.codes })).seedStarterLocales;
-        return resolved.normalized.length > 0 ? jsonResult({ locales: seeded, normalized: resolved.normalized }) : jsonResult(seeded);
-      }
-      return jsonResult((await gql.request(SEED_STARTER_LOCALES, { projectId, codes })).seedStarterLocales);
-    }
-  );
-  server.registerTool(
-    "remove_locale",
-    {
-      title: "Remove locale",
-      description: "Removes a target locale and its translations. Destructive \u2014 confirm first.",
-      inputSchema: { projectId: z7.string(), localeId: z7.string() },
-      annotations: { destructiveHint: true, openWorldHint: true }
-    },
-    async ({ projectId, localeId }) => jsonResult((await gql.request(REMOVE_LOCALE, { projectId, id: localeId })).removeLocale)
-  );
-}
-
-// src/tools/projects.ts
-import { z as z8 } from "zod";
-import {
-  CREATE_PROJECT,
-  GET_PROJECT,
-  LIST_PROJECTS,
-  MY_ORGANIZATIONS as MY_ORGANIZATIONS2,
-  UPDATE_PROJECT
-} from "@syntholoc/sdk";
-function registerProjectTools(server, gql) {
-  server.registerTool(
-    "list_organizations",
-    {
-      title: "List organizations",
-      description: "Organizations you belong to (id, name, slug, your role). To act in a specific org, set the `syntholoc-org-id` request header (hosted transport); otherwise the earliest org is used.",
-      inputSchema: {},
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async () => jsonResult(
-      (await gql.request(MY_ORGANIZATIONS2)).myProjects.map((g) => ({
-        ...g.organization,
-        viewerRole: g.viewerRole
-      }))
-    )
-  );
-  server.registerTool(
-    "list_projects",
-    {
-      title: "List projects",
-      description: "Lists localization projects in the active organization (paginated).",
-      inputSchema: {
-        skip: z8.number().int().min(0).default(0),
-        take: z8.number().int().min(1).max(100).default(25)
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ skip, take }) => jsonResult((await gql.request(LIST_PROJECTS, { skip, take })).projects)
-  );
-  server.registerTool(
-    "get_project",
-    {
-      title: "Get project",
-      description: "Project settings plus analytics, including per-locale progress with the `untranslated` count used to decide the batch threshold (see get_config).",
-      inputSchema: { projectId: z8.string() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ projectId }) => jsonResult(await gql.request(GET_PROJECT, { id: projectId }))
-  );
-  server.registerTool(
-    "create_project",
-    {
-      title: "Create project",
-      description: 'Creates a localization project. `sourceLocale` defaults to "en".',
-      inputSchema: {
-        name: z8.string(),
-        sourceLocale: z8.string().default("en"),
-        description: z8.string().optional(),
-        context: z8.string().optional(),
-        requireReview: z8.boolean().optional(),
-        qaCriticEnabled: z8.boolean().optional()
-      },
-      annotations: { openWorldHint: true }
-    },
-    async (input) => jsonResult((await gql.request(CREATE_PROJECT, { input })).createProject)
-  );
-  server.registerTool(
-    "update_project",
-    {
-      title: "Update project",
-      description: "Updates project settings (name, source locale, review/QA flags, context).",
-      inputSchema: {
-        projectId: z8.string(),
-        name: z8.string().optional(),
-        sourceLocale: z8.string().optional(),
-        description: z8.string().optional(),
-        context: z8.string().optional(),
-        requireReview: z8.boolean().optional(),
-        qaCriticEnabled: z8.boolean().optional(),
-        exportApprovedOnly: z8.boolean().optional(),
-        sortKeysAlphabetically: z8.boolean().optional(),
-        status: z8.string().optional()
-      },
-      annotations: { idempotentHint: true, openWorldHint: true }
-    },
-    async ({ projectId, ...input }) => jsonResult((await gql.request(UPDATE_PROJECT, { id: projectId, input })).updateProject)
-  );
-}
-
-// src/tools/providers.ts
-import { z as z10 } from "zod";
-import { CONFIGURE_LLM_PROVIDER, LIST_LLM_PROVIDERS } from "@syntholoc/sdk";
-
-// src/generated/input-schemas.ts
-import { z as z9 } from "zod";
-var isDefinedNonNullAny = (v) => v !== void 0 && v !== null;
-var definedNonNullAnySchema = z9.any().refine((v) => isDefinedNonNullAny(v));
-var CoverageCategorySchema = z9.enum(["DYNAMIC", "NOT_CAPTURED", "NOT_IN_CODE", "SCREENSHOT", "SERVER", "TEST", "UNKNOWN"]);
-var QaCriticScopeSchema = z9.enum(["ALL", "UNREVIEWED"]);
-var TranslateScopeSchema = z9.enum(["ALL", "DRAFT", "UNAPPROVED", "UNTRANSLATED"]);
-function ConfigureProviderInputSchema() {
-  return z9.object({
-    apiKey: z9.string(),
-    baseUrl: z9.string().nullish(),
-    defaultModel: z9.string().nullish(),
-    label: z9.string(),
-    type: z9.string()
-  });
-}
-
-// src/tools/providers.ts
-function registerProviderTools(server, gql) {
-  server.registerTool(
-    "list_llm_providers",
-    {
-      title: "List LLM providers",
-      description: "Configured LLM providers for the org (never exposes the API key).",
-      inputSchema: {},
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async () => jsonResult((await gql.request(LIST_LLM_PROVIDERS)).llmProviders)
-  );
-  server.registerTool(
-    "configure_llm_provider",
-    {
-      title: "Configure LLM provider",
-      description: "Adds a BYOK LLM provider (OPENROUTER | OPENAI | ANTHROPIC). The key is stored encrypted at rest.",
-      // Base field shapes (apiKey/label/baseUrl/defaultModel) are generated from
-      // the GraphQL ConfigureProviderInput; we curate `type` from the API's
-      // free-form String down to the concrete provider set.
-      inputSchema: {
-        ...ConfigureProviderInputSchema().shape,
-        type: z10.enum(["OPENROUTER", "OPENAI", "ANTHROPIC"])
-      },
-      annotations: { openWorldHint: true }
-    },
-    async (input) => jsonResult((await gql.request(CONFIGURE_LLM_PROVIDER, { input })).configureLlmProvider)
-  );
-}
-
-// src/tools/qa.ts
-import { z as z11 } from "zod";
-import { LIST_QA_ISSUES as LIST_QA_ISSUES2, RUN_LOCALE_QA, RUN_QA } from "@syntholoc/sdk";
-function registerQaTools(server, gql) {
-  server.registerTool(
-    "run_locale_qa",
-    {
-      title: "Run locale QA",
-      description: "Queues an LLM QA-critic pass over a locale's non-approved translations. `scope` UNREVIEWED (default) critiques only translations not yet reviewed at their current text; ALL re-critiques every one. Returns tracking `jobIds`.",
-      inputSchema: {
-        projectId: z11.string(),
-        localeId: z11.string(),
-        scope: z11.enum(["UNREVIEWED", "ALL"]).optional()
-      },
-      annotations: { openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(RUN_LOCALE_QA, vars)).runLocaleQa)
-  );
-  server.registerTool(
-    "run_qa",
-    {
-      title: "Run QA on a translation",
-      description: "Runs QA on one translation and returns its score and issues (synchronous).",
-      inputSchema: { projectId: z11.string(), translationId: z11.string() },
-      annotations: { openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(RUN_QA, vars)).runQa)
-  );
-  server.registerTool(
-    "list_qa_issues",
-    {
-      title: "List QA issues",
-      description: "Open QA issues for a locale, plus the issue-type facets (filter tabs).",
-      inputSchema: {
-        projectId: z11.string(),
-        localeId: z11.string(),
-        type: z11.string().optional(),
-        skip: z11.number().int().min(0).default(0),
-        take: z11.number().int().min(1).max(100).default(25)
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async (vars) => jsonResult(await gql.request(LIST_QA_ISSUES2, vars))
-  );
-}
-
-// src/tools/styleguides.ts
-import { z as z12 } from "zod";
-import { CREATE_STYLE_GUIDE, GENERATE_STYLE_GUIDE, LIST_STYLE_GUIDES as LIST_STYLE_GUIDES2 } from "@syntholoc/sdk";
-function registerStyleGuideTools(server, gql) {
-  server.registerTool(
-    "list_style_guides",
-    {
-      title: "List style guides",
-      description: "Lists style guides (project-scoped if projectId given, else org-wide).",
-      inputSchema: { projectId: z12.string().optional() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ projectId }) => jsonResult((await gql.request(LIST_STYLE_GUIDES2, { projectId })).styleGuides)
-  );
-  server.registerTool(
-    "generate_style_guide",
-    {
-      title: "Generate style guide (draft)",
-      description: "Drafts a tone/rules/prompt-fragment style guide from the project (optionally per locale). Returns a draft \u2014 persist it with create_style_guide.",
-      inputSchema: { projectId: z12.string(), localeCode: z12.string().optional() },
-      annotations: { openWorldHint: true }
-    },
-    async ({ projectId, localeCode }) => jsonResult((await gql.request(GENERATE_STYLE_GUIDE, { input: { projectId, localeCode } })).generateStyleGuide)
-  );
-  server.registerTool(
-    "create_style_guide",
-    {
-      title: "Create style guide",
-      description: "Persists a style guide (tone, rules JSON, prompt fragment), project- or locale-scoped.",
-      inputSchema: {
-        name: z12.string(),
-        projectId: z12.string().optional(),
-        localeCode: z12.string().optional(),
-        tone: z12.string().optional(),
-        promptFragment: z12.string().optional(),
-        rules: z12.array(z12.string()).optional()
-      },
-      annotations: { openWorldHint: true }
-    },
-    async (input) => jsonResult((await gql.request(CREATE_STYLE_GUIDE, { input })).createStyleGuide)
-  );
-}
-
-// src/tools/tm.ts
-import { z as z13 } from "zod";
-import { TM_ENTRIES, TM_SEARCH, TM_STATS as TM_STATS2 } from "@syntholoc/sdk";
-function registerTmTools(server, gql) {
-  server.registerTool(
-    "tm_search",
-    {
-      title: "Search translation memory",
-      description: "Concordance search \u2014 the nearest prior translations for a source string in a target locale, with cosine distance (0 = identical). Scope to a project with `projectId` (includes its group siblings); omit for the whole organization. Requires an embedding-capable provider.",
-      inputSchema: {
-        sourceText: z13.string(),
-        targetLocale: z13.string(),
-        projectId: z13.string().optional(),
-        limit: z13.number().int().min(1).max(20).default(5)
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ sourceText, targetLocale, projectId, limit }) => jsonResult((await gql.request(TM_SEARCH, { sourceText, targetLocale, projectId, limit })).tmSearch)
-  );
-  server.registerTool(
-    "tm_stats",
-    {
-      title: "Translation memory stats",
-      description: "Entry counts per target locale (org-wide, or for a project with `projectId`).",
-      inputSchema: { projectId: z13.string().optional() },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async ({ projectId }) => jsonResult((await gql.request(TM_STATS2, { projectId })).tmStats)
-  );
-  server.registerTool(
-    "list_tm",
-    {
-      title: "Browse translation memory",
-      description: "Lists stored TM entries (paginated, newest first), optionally filtered by project and locale.",
-      inputSchema: {
-        projectId: z13.string().optional(),
-        targetLocale: z13.string().optional(),
-        skip: z13.number().int().min(0).default(0),
-        take: z13.number().int().min(1).max(100).default(25)
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(TM_ENTRIES, vars)).tmEntries)
-  );
-}
-
-// src/tools/translations.ts
-import { z as z14 } from "zod";
-import {
-  APPROVE_TRANSLATION,
-  EXPORT_LOCALE,
-  IMPORT_TRANSLATIONS,
-  LIST_TRANSLATIONS,
-  REJECT_TRANSLATION,
-  SET_TRANSLATION,
-  TRANSLATE_KEY,
-  TRANSLATE_LOCALE
-} from "@syntholoc/sdk";
-var FORMATS2 = ["JSON", "YAML", "CSV", "PO", "XLIFF", "ANDROID_XML", "IOS_STRINGS", "NJK"];
-function registerTranslationTools(server, gql) {
-  server.registerTool(
-    "translate_locale",
-    {
-      title: "Translate locale",
-      description: "Queues AI translation of a locale (scope ALL | UNAPPROVED | UNTRANSLATED) and returns the tracking `jobIds`. Executes immediately and unconditionally \u2014 the batch threshold is a client-side policy for PROACTIVE syncs, not for this tool.",
-      inputSchema: {
-        projectId: z14.string(),
-        localeId: z14.string(),
-        scope: z14.enum(["ALL", "UNAPPROVED", "UNTRANSLATED"]).default("UNTRANSLATED")
-      },
-      annotations: { openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(TRANSLATE_LOCALE, vars)).translateLocale)
-  );
-  server.registerTool(
-    "translate_key",
-    {
-      title: "Translate key",
-      description: "Queues AI translation of a single key into a locale. Returns tracking `jobIds`.",
-      inputSchema: { projectId: z14.string(), keyId: z14.string(), localeId: z14.string() },
-      annotations: { openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(TRANSLATE_KEY, vars)).translateKey)
-  );
-  server.registerTool(
-    "set_translation",
-    {
-      title: "Set translation",
-      description: "Manually sets the translation text for a key in a locale.",
-      inputSchema: {
-        projectId: z14.string(),
-        keyId: z14.string(),
-        localeId: z14.string(),
-        text: z14.string(),
-        origin: z14.string().optional()
-      },
-      annotations: { idempotentHint: true, openWorldHint: true }
-    },
-    async ({ projectId, keyId, localeId, text, origin }) => jsonResult(
-      (await gql.request(SET_TRANSLATION, { projectId, input: { keyId, localeId, text, origin } })).setTranslation
-    )
-  );
-  server.registerTool(
-    "list_translations",
-    {
-      title: "List translations",
-      description: "Lists translations for a locale with status, origin, model and QA score.",
-      inputSchema: {
-        projectId: z14.string(),
-        localeId: z14.string(),
-        skip: z14.number().int().min(0).default(0),
-        take: z14.number().int().min(1).max(200).default(25)
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async (vars) => jsonResult((await gql.request(LIST_TRANSLATIONS, vars)).translations)
-  );
-  server.registerTool(
-    "approve_translation",
-    {
-      title: "Approve translation",
-      description: "Marks a translation APPROVED.",
-      inputSchema: { projectId: z14.string(), translationId: z14.string() },
-      annotations: { idempotentHint: true, openWorldHint: true }
-    },
-    async ({ projectId, translationId }) => jsonResult((await gql.request(APPROVE_TRANSLATION, { projectId, id: translationId })).approveTranslation)
-  );
-  server.registerTool(
-    "reject_translation",
-    {
-      title: "Reject translation",
-      description: "Marks a translation REJECTED (queued for re-translation).",
-      inputSchema: { projectId: z14.string(), translationId: z14.string() },
-      annotations: { idempotentHint: true, openWorldHint: true }
-    },
-    async ({ projectId, translationId }) => jsonResult((await gql.request(REJECT_TRANSLATION, { projectId, id: translationId })).rejectTranslation)
-  );
-  server.registerTool(
-    "export_locale",
-    {
-      title: "Export locale",
-      description: 'Exports a locale to a file string in the chosen format \u2014 the basis for writing translations back into local files. Set `onlyApproved` to exclude drafts. For a multi-file project prefer `sourceFile` (the real path, e.g. "messages/en/home.json") to export exactly that file with file-local key names \u2014 reliable. `keyPrefix` is the legacy name-prefix heuristic.',
-      inputSchema: {
-        projectId: z14.string(),
-        localeId: z14.string(),
-        format: z14.enum(FORMATS2).default("JSON"),
-        onlyApproved: z14.boolean().optional(),
-        sourceFile: z14.string().optional().describe('Real source file path to export, e.g. "messages/en/home.json" (reliable, preferred).'),
-        keyPrefix: z14.string().optional().describe('Legacy namespace prefix, e.g. "home".')
-      },
-      annotations: { readOnlyHint: true, openWorldHint: true }
-    },
-    async (vars) => jsonResult({ content: (await gql.request(EXPORT_LOCALE, vars)).exportLocale })
-  );
-  server.registerTool(
-    "import_translations",
-    {
-      title: "Import translations",
-      description: "Imports ready-made translations for a locale (paste file content). `autoApprove` lands them as APPROVED; `conflict` is OVERWRITE | SKIP_EXISTING | KEEP_APPROVED; `dryRun` previews. For a multi-file / namespaced project pass `keyPrefix` (the namespace) to match prefixed source keys.",
-      inputSchema: {
-        projectId: z14.string(),
-        localeId: z14.string(),
-        content: z14.string(),
-        format: z14.enum(FORMATS2),
-        keyPrefix: z14.string().optional().describe('Namespace prefix, e.g. "home" (per-file, multi-file projects).'),
-        autoApprove: z14.boolean().default(false),
-        conflict: z14.enum(["OVERWRITE", "SKIP_EXISTING", "KEEP_APPROVED"]).default("OVERWRITE"),
-        dryRun: z14.boolean().default(false)
-      },
-      annotations: { idempotentHint: true, openWorldHint: true }
-    },
-    async ({ projectId, localeId, content, format, keyPrefix, autoApprove, conflict, dryRun }) => jsonResult(
-      (await gql.request(IMPORT_TRANSLATIONS, {
-        projectId,
-        localeId,
-        input: { content, format, keyPrefix, autoApprove, conflict, dryRun }
-      })).importTranslations
-    )
-  );
-}
-
-// src/tools/index.ts
-var TOOL_SETS = {
-  config: registerConfigTools,
-  projects: registerProjectTools,
-  locales: registerLocaleTools,
-  keys: registerKeyTools,
-  translations: registerTranslationTools,
-  qa: registerQaTools,
-  glossary: registerGlossaryTools,
-  styleguides: registerStyleGuideTools,
-  tm: registerTmTools,
-  git: registerGitTools,
-  providers: registerProviderTools,
-  jobs: registerJobTools,
-  analytics: registerAnalyticsTools
-};
-var TOOL_SET_NAMES = Object.keys(TOOL_SETS);
-function selectSets(requested) {
-  if (!requested || requested.length === 0 || requested.includes("all")) return TOOL_SET_NAMES;
-  return TOOL_SET_NAMES.filter((name) => requested.includes(name));
-}
-function registerAllTools(server, gql, opts = {}) {
-  const target = applyToolFilter(server, opts);
-  for (const name of selectSets(opts.toolSets)) {
-    TOOL_SETS[name]?.(target, gql);
-  }
-}
-
-// package.json
-var version = "0.4.0";
-
-// src/build-server.ts
-function buildMcpServer(gql, opts = {}) {
-  const server = new McpServer({ name: "syntholoc", version });
-  registerAllTools(server, gql, opts);
-  registerResources(server, gql);
-  registerPrompts(server);
-  return server;
-}
-
-export {
-  parseList,
-  TOOL_SET_NAMES,
-  buildMcpServer
-};