@syntholoc/mcp 0.1.0

package/dist/chunk-N4PXYXAP.js

@@ -0,0 +1,850 @@
+// src/build-server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// 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).",
+        "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.",
+        "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:",
+        "1. Find the i18n source files (e.g. messages/en.json, locales/en/*.json) and infer the source locale.",
+        "2. `create_project`, then `seed_starter_locales` (or `add_locale`) for the target languages.",
+        "3. `import_source_strings` from the source file(s).",
+        "4. Write `.syntholoc/config.json` mapping source \u2192 translation file patterns and the project id.",
+        "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, PROJECTS_RESOURCE, PROJECT_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(
+    "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) }))
+  );
+}
+
+// src/tools/analytics.ts
+import { z as z2 } from "zod";
+import { COST_ANALYTICS, LOCALE_PROGRESS, PROJECT_ANALYTICS, 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_ANALYTICS, { 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 {
+  LIST_REPOSITORIES,
+  PULL_TRANSLATIONS,
+  PUSH_TRANSLATIONS,
+  SYNC_REPOSITORY
+} from "@syntholoc/sdk";
+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(
+    "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: "Pulls translation files from the connected repo and imports them per locale. `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,
+  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_GLOSSARY, 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, 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_JOBS, 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,
+  UPDATE_KEY,
+  UPSERT_KEYS
+} from "@syntholoc/sdk";
+var FORMATS = ["JSON", "YAML", "CSV", "PO", "XLIFF", "ANDROID_XML", "IOS_STRINGS"];
+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_KEYS, 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 a file (paste the raw content) and returns the diff summary. Use `dryRun` to preview. For a structured delta prefer upsert_keys.",
+      inputSchema: {
+        projectId: z6.string(),
+        content: z6.string(),
+        format: z6.enum(FORMATS),
+        dryRun: z6.boolean().default(false)
+      },
+      annotations: { idempotentHint: true, openWorldHint: true }
+    },
+    async ({ projectId, content, format, dryRun }) => jsonResult(
+      (await gql.request(IMPORT_SOURCE_STRINGS, { projectId, input: { content, format, dryRun } })).importSourceStrings
+    )
+  );
+}
+
+// src/tools/locales.ts
+import { z as z7 } from "zod";
+import { ADD_LOCALE, LIST_LOCALES, REMOVE_LOCALE, SEED_STARTER_LOCALES } from "@syntholoc/sdk";
+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_LOCALES, { projectId })).locales)
+  );
+  server.registerTool(
+    "add_locale",
+    {
+      title: "Add locale",
+      description: "Adds a target locale (BCP-47 code) to a project.",
+      inputSchema: {
+        projectId: z7.string(),
+        code: z7.string().describe('BCP-47 code, e.g. "de-DE"'),
+        name: z7.string().optional(),
+        formality: z7.string().optional(),
+        gender: z7.string().optional(),
+        variant: z7.string().optional()
+      },
+      annotations: { openWorldHint: true }
+    },
+    async ({ projectId, ...input }) => jsonResult((await gql.request(ADD_LOCALE, { projectId, input })).addLocale)
+  );
+  server.registerTool(
+    "seed_starter_locales",
+    {
+      title: "Seed starter locales",
+      description: "Adds a set of common starter locales to a project (omit codes for the defaults).",
+      inputSchema: { projectId: z7.string(), codes: z7.array(z7.string()).optional() },
+      annotations: { openWorldHint: true }
+    },
+    async ({ projectId, codes }) => 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, UPDATE_PROJECT } from "@syntholoc/sdk";
+function registerProjectTools(server, gql) {
+  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 z9 } from "zod";
+import { CONFIGURE_LLM_PROVIDER, LIST_LLM_PROVIDERS } from "@syntholoc/sdk";
+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.",
+      inputSchema: {
+        type: z9.enum(["OPENROUTER", "OPENAI", "ANTHROPIC"]),
+        label: z9.string(),
+        apiKey: z9.string(),
+        baseUrl: z9.string().optional(),
+        defaultModel: z9.string().optional()
+      },
+      annotations: { openWorldHint: true }
+    },
+    async (input) => jsonResult((await gql.request(CONFIGURE_LLM_PROVIDER, { input })).configureLlmProvider)
+  );
+}
+
+// src/tools/qa.ts
+import { z as z10 } from "zod";
+import { LIST_QA_ISSUES, 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. Returns tracking `jobIds`.",
+      inputSchema: { projectId: z10.string(), localeId: z10.string() },
+      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: z10.string(), translationId: z10.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: z10.string(),
+        localeId: z10.string(),
+        type: z10.string().optional(),
+        skip: z10.number().int().min(0).default(0),
+        take: z10.number().int().min(1).max(100).default(25)
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async (vars) => jsonResult(await gql.request(LIST_QA_ISSUES, vars))
+  );
+}
+
+// src/tools/styleguides.ts
+import { z as z11 } from "zod";
+import { CREATE_STYLE_GUIDE, GENERATE_STYLE_GUIDE, LIST_STYLE_GUIDES } 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: z11.string().optional() },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    async ({ projectId }) => jsonResult((await gql.request(LIST_STYLE_GUIDES, { 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: z11.string(), localeCode: z11.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: z11.string(),
+        projectId: z11.string().optional(),
+        localeCode: z11.string().optional(),
+        tone: z11.string().optional(),
+        promptFragment: z11.string().optional(),
+        rules: z11.array(z11.string()).optional()
+      },
+      annotations: { openWorldHint: true }
+    },
+    async (input) => jsonResult((await gql.request(CREATE_STYLE_GUIDE, { input })).createStyleGuide)
+  );
+}
+
+// src/tools/translations.ts
+import { z as z12 } 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"];
+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: z12.string(),
+        localeId: z12.string(),
+        scope: z12.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: z12.string(), keyId: z12.string(), localeId: z12.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: z12.string(),
+        keyId: z12.string(),
+        localeId: z12.string(),
+        text: z12.string(),
+        origin: z12.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: z12.string(),
+        localeId: z12.string(),
+        skip: z12.number().int().min(0).default(0),
+        take: z12.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: z12.string(), translationId: z12.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: z12.string(), translationId: z12.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.",
+      inputSchema: {
+        projectId: z12.string(),
+        localeId: z12.string(),
+        format: z12.enum(FORMATS2).default("JSON"),
+        onlyApproved: z12.boolean().optional()
+      },
+      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.",
+      inputSchema: {
+        projectId: z12.string(),
+        localeId: z12.string(),
+        content: z12.string(),
+        format: z12.enum(FORMATS2),
+        autoApprove: z12.boolean().default(false),
+        conflict: z12.enum(["OVERWRITE", "SKIP_EXISTING", "KEEP_APPROVED"]).default("OVERWRITE"),
+        dryRun: z12.boolean().default(false)
+      },
+      annotations: { idempotentHint: true, openWorldHint: true }
+    },
+    async ({ projectId, localeId, content, format, autoApprove, conflict, dryRun }) => jsonResult(
+      (await gql.request(IMPORT_TRANSLATIONS, {
+        projectId,
+        localeId,
+        input: { content, format, autoApprove, conflict, dryRun }
+      })).importTranslations
+    )
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server, gql) {
+  registerConfigTools(server, gql);
+  registerProjectTools(server, gql);
+  registerLocaleTools(server, gql);
+  registerKeyTools(server, gql);
+  registerTranslationTools(server, gql);
+  registerQaTools(server, gql);
+  registerGlossaryTools(server, gql);
+  registerStyleGuideTools(server, gql);
+  registerGitTools(server, gql);
+  registerProviderTools(server, gql);
+  registerJobTools(server, gql);
+  registerAnalyticsTools(server, gql);
+}
+
+// src/build-server.ts
+function buildMcpServer(gql) {
+  const server = new McpServer({ name: "syntholoc", version: "0.1.0" });
+  registerAllTools(server, gql);
+  registerResources(server, gql);
+  registerPrompts(server);
+  return server;
+}
+
+export {
+  buildMcpServer
+};
+//# sourceMappingURL=chunk-N4PXYXAP.js.map