i18n-tools-mcp 1.0.0

package/README.md

@@ -0,0 +1,141 @@
+# i18n-tools-mcp
+
+MCP server for querying and managing JSON translation files. Designed for AI agents (Claude Code, Cursor, etc.) to read and write i18n, i18next, react-i18next, and next-i18next translations directly through the Model Context Protocol.
+
+Supports flat (`{locale}.json`) and namespaced (`{locale}/{namespace}.json`) directory layouts with dot-notation keys.
+
+## Install
+
+Ask your AI agent:
+
+> Install the i18n-tools-mcp MCP server. The translations directory is at ./messages and the base locale is nl.
+
+Or add it manually to your MCP client config (e.g. `.claude/settings.json`):
+
+```json
+{
+  "mcpServers": {
+    "i18n-tools": {
+      "command": "npx",
+      "args": ["i18n-tools-mcp", "./messages", "nl"]
+    }
+  }
+}
+```
+
+Arguments:
+
+1. **Required**: Path to the directory containing your translation files
+2. **Optional**: Base locale code (default: `nl`) — used in tool descriptions to guide AI agents
+3. **Optional**: JSON indentation spaces (default: `4`)
+
+## Directory structures
+
+Both flat and namespaced layouts are auto-detected.
+
+**Flat** — one JSON file per locale:
+
+```
+messages/
+  en.json
+  nl.json
+```
+
+**Namespaced** — subdirectory per locale, one JSON file per namespace (i18next-style):
+
+```
+messages/
+  en/
+    common.json
+    auth.json
+  nl/
+    common.json
+    auth.json
+```
+
+In namespace mode, prefix keys with the namespace: `common:Users.name`. Read operations (`query`, `list`, `search`, `missing`) work across all namespaces when no prefix is given. Write operations (`set`, `add`) require a namespace prefix.
+
+## Tools
+
+### `query`
+
+Look up a translation key across all locale files. Returns the value for each locale that has the key.
+
+| Parameter | Type   | Required | Description                              |
+|-----------|--------|----------|------------------------------------------|
+| `key`     | string | yes      | Dot-notation key, e.g. `"Users.name"` or `"common:Users.name"` |
+
+### `set`
+
+Set a translation value for a single locale. Creates intermediate keys if needed.
+
+| Parameter | Type   | Required | Description                              |
+|-----------|--------|----------|------------------------------------------|
+| `locale`  | string | yes      | Locale code, e.g. `"nl"` or `"en"`      |
+| `key`     | string | yes      | Dot-notation key, e.g. `"Users.name"` or `"common:Users.name"` |
+| `value`   | string | yes      | The translation value                    |
+
+### `add`
+
+Add a translation key to multiple locales at once.
+
+| Parameter      | Type                     | Required | Description                                              |
+|----------------|--------------------------|----------|----------------------------------------------------------|
+| `key`          | string                   | yes      | Dot-notation key, e.g. `"Users.name"` or `"common:Users.name"` |
+| `translations` | `Record<string, string>` | yes      | Locale-to-value mapping, e.g. `{"nl": "Naam", "en": "Name"}` |
+
+### `delete`
+
+Delete a translation key from all locale files.
+
+| Parameter | Type   | Required | Description                              |
+|-----------|--------|----------|------------------------------------------|
+| `key`     | string | yes      | Dot-notation key, e.g. `"Users.name"` or `"common:Users.name"` |
+
+### `rename`
+
+Rename a translation key across all locale files. Preserves values.
+
+| Parameter | Type   | Required | Description                                    |
+|-----------|--------|----------|------------------------------------------------|
+| `oldKey`  | string | yes      | Current dot-notation key, e.g. `"Users.name"`  |
+| `newKey`  | string | yes      | New dot-notation key, e.g. `"Users.fullName"`  |
+
+### `move`
+
+Move a translation key to a different path across all locale files.
+
+| Parameter | Type   | Required | Description                                    |
+|-----------|--------|----------|------------------------------------------------|
+| `oldKey`  | string | yes      | Current dot-notation key, e.g. `"Users.name"`  |
+| `newKey`  | string | yes      | New dot-notation key, e.g. `"Profile.name"`    |
+
+### `list`
+
+List all translation keys. Optionally filter by a key prefix.
+
+| Parameter | Type   | Required | Description                                           |
+|-----------|--------|----------|-------------------------------------------------------|
+| `prefix`  | string | no       | Key prefix to filter by, e.g. `"Users"` or `"common:"` |
+
+### `search`
+
+Search translations by value (case-insensitive).
+
+| Parameter | Type   | Required | Description                              |
+|-----------|--------|----------|------------------------------------------|
+| `value`   | string | yes      | Text to search for in translation values |
+
+### `missing`
+
+Find translation keys that exist in some locales but are missing in others. Takes no parameters.
+
+## Development
+
+```bash
+pnpm install       # Install dependencies
+pnpm dev           # Watch mode
+pnpm test          # Run tests
+pnpm test:watch    # Watch mode tests
+pnpm build         # Compile TypeScript
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { query, set, add, remove, rename, missing, list, search, move, setIndent } from './translations.js';
+const baseDir = process.argv[2];
+if (!baseDir) {
+    console.error('Usage: i18n-tools-mcp <translations-directory> [base-locale] [indent]');
+    process.exit(1);
+}
+const baseLocale = process.argv[3] || 'nl';
+const indent = parseInt(process.argv[4] || '4', 10);
+setIndent(indent);
+const server = new McpServer({
+    name: 'i18n-tools',
+    version: '0.1.0',
+});
+server.registerTool('query', {
+    description: 'Look up a translation key across all locale files. Returns the value for each locale that has the key.',
+    inputSchema: {
+        key: z.string().describe('Dot-notation translation key, e.g. "Users.name"'),
+    },
+}, async ({ key }) => {
+    try {
+        const result = query(key, baseDir);
+        return { content: [{ type: 'text', text: result }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
+    }
+});
+server.registerTool('set', {
+    description: 'Set a translation value for a single locale. Creates intermediate keys if needed.',
+    inputSchema: {
+        locale: z.string().describe(`Locale code, e.g. "${baseLocale}" or "en"`),
+        key: z.string().describe('Dot-notation translation key, e.g. "Users.name"'),
+        value: z.string().describe('The translation value to set'),
+    },
+}, async ({ locale, key, value }) => {
+    try {
+        const result = set(locale, key, value, baseDir);
+        return { content: [{ type: 'text', text: result }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
+    }
+});
+server.registerTool('add', {
+    description: `Add a translation key to multiple locales at once. Always include at least the base locale "${baseLocale}". Other locales are optional and will be filled by the AI translation pipeline.`,
+    inputSchema: {
+        key: z.string().describe('Dot-notation translation key, e.g. "Users.name"'),
+        translations: z.record(z.string(), z.string()).describe(`Object mapping locale codes to translation values. Always include "${baseLocale}" as the base locale. Example: {"${baseLocale}": "Naam", "en": "Name"}`),
+    },
+}, async ({ key, translations }) => {
+    try {
+        const result = add(key, translations, baseDir);
+        return { content: [{ type: 'text', text: result }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
+    }
+});
+server.registerTool('delete', {
+    description: 'Delete a translation key from all locale files.',
+    inputSchema: {
+        key: z.string().describe('Dot-notation translation key, e.g. "Users.name"'),
+    },
+}, async ({ key }) => {
+    try {
+        const result = remove(key, baseDir);
+        return { content: [{ type: 'text', text: result }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
+    }
+});
+server.registerTool('rename', {
+    description: 'Rename a translation key across all locale files. Preserves values.',
+    inputSchema: {
+        oldKey: z.string().describe('Current dot-notation key, e.g. "Users.name"'),
+        newKey: z.string().describe('New dot-notation key, e.g. "Users.fullName"'),
+    },
+}, async ({ oldKey, newKey }) => {
+    try {
+        const result = rename(oldKey, newKey, baseDir);
+        return { content: [{ type: 'text', text: result }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
+    }
+});
+server.registerTool('missing', {
+    description: 'Find translation keys that exist in some locales but are missing in others.',
+    inputSchema: {},
+}, async () => {
+    try {
+        const result = missing(baseDir);
+        return { content: [{ type: 'text', text: result }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
+    }
+});
+server.registerTool('list', {
+    description: 'List all translation keys. Optionally filter by a key prefix. Results are paginated (100 keys per page).',
+    inputSchema: {
+        prefix: z.string().optional().describe('Key prefix to filter by, e.g. "Users" to list all keys under Users'),
+        page: z.number().optional().describe('Page number (default: 1)'),
+        pageSize: z.number().optional().describe('Number of keys per page (default: 100)'),
+    },
+}, async ({ prefix, page, pageSize }) => {
+    try {
+        const result = list(prefix, page ?? 1, pageSize ?? 100, baseDir);
+        return { content: [{ type: 'text', text: result }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
+    }
+});
+server.registerTool('search', {
+    description: 'Search translations by value. Finds all keys where the translation contains the search term (case-insensitive). Results are paginated (100 results per page).',
+    inputSchema: {
+        value: z.string().describe('Text to search for in translation values'),
+        page: z.number().optional().describe('Page number (default: 1)'),
+        pageSize: z.number().optional().describe('Number of results per page (default: 100)'),
+    },
+}, async ({ value, page, pageSize }) => {
+    try {
+        const result = search(value, page ?? 1, pageSize ?? 100, baseDir);
+        return { content: [{ type: 'text', text: result }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
+    }
+});
+server.registerTool('move', {
+    description: 'Move a translation key to a different path across all locale files. Same as rename.',
+    inputSchema: {
+        oldKey: z.string().describe('Current dot-notation key, e.g. "Users.name"'),
+        newKey: z.string().describe('New dot-notation key, e.g. "Profile.name"'),
+    },
+}, async ({ oldKey, newKey }) => {
+    try {
+        const result = move(oldKey, newKey, baseDir);
+        return { content: [{ type: 'text', text: result }] };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }], isError: true };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/translations.d.ts

@@ -0,0 +1,10 @@
+export declare function setIndent(spaces: number): void;
+export declare function query(key: string, dir?: string): string;
+export declare function set(locale: string, key: string, value: string, dir?: string): string;
+export declare function remove(key: string, dir?: string): string;
+export declare function add(key: string, translations: Record<string, string>, dir?: string): string;
+export declare function rename(oldKey: string, newKey: string, dir?: string): string;
+export declare function missing(dir?: string): string;
+export declare function list(prefix?: string, page?: number, pageSize?: number, dir?: string): string;
+export declare function search(value: string, page?: number, pageSize?: number, dir?: string): string;
+export declare function move(oldKey: string, newKey: string, dir?: string): string;

package/dist/translations.js

@@ -0,0 +1,343 @@
+import { readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join, basename, resolve } from 'node:path';
+const DEFAULT_DIR = 'messages';
+const NS_SEPARATOR = ':';
+let jsonIndent = 4;
+function sanitize(value) {
+    return value
+        .replace(/[\u201C\u201D\u201E\u201F\u2033\u2036]/g, '"')
+        .replace(/[\u2018\u2019\u201A\u201B\u2032\u2035]/g, "'");
+}
+function discoverLocaleFiles(dir) {
+    const resolvedDir = resolve(dir);
+    const entries = readdirSync(resolvedDir, { withFileTypes: true });
+    const subdirs = entries.filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+    if (subdirs.length > 0) {
+        const files = [];
+        for (const subdir of subdirs) {
+            const localePath = join(resolvedDir, subdir.name);
+            const jsonFiles = readdirSync(localePath).filter((f) => f.endsWith('.json')).sort();
+            for (const f of jsonFiles) {
+                files.push({
+                    locale: subdir.name,
+                    namespace: basename(f, '.json'),
+                    path: join(localePath, f),
+                });
+            }
+        }
+        return files;
+    }
+    const jsonFiles = entries
+        .filter((e) => e.isFile() && e.name.endsWith('.json'))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return jsonFiles.map((f) => ({
+        locale: basename(f.name, '.json'),
+        path: join(resolvedDir, f.name),
+    }));
+}
+function parseKey(key) {
+    const colonIndex = key.indexOf(NS_SEPARATOR);
+    if (colonIndex > 0) {
+        return { namespace: key.substring(0, colonIndex), dotKey: key.substring(colonIndex + 1) };
+    }
+    return { dotKey: key };
+}
+function isNamespaced(files) {
+    return files.some((f) => f.namespace !== undefined);
+}
+function fullKey(file, dotKey) {
+    if (file.namespace) {
+        return `${file.namespace}${NS_SEPARATOR}${dotKey}`;
+    }
+    return dotKey;
+}
+function readJson(filePath) {
+    const raw = readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+function writeJson(filePath, data) {
+    const json = JSON.stringify(data, null, jsonIndent) + '\n';
+    writeFileSync(filePath, json, 'utf8');
+}
+export function setIndent(spaces) {
+    jsonIndent = spaces;
+}
+function getNestedValue(obj, key) {
+    const parts = key.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current == null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function deleteNestedValue(obj, key) {
+    const parts = key.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (current[part] == null || typeof current[part] !== 'object') {
+            return false;
+        }
+        current = current[part];
+    }
+    const lastPart = parts[parts.length - 1];
+    if (!(lastPart in current)) {
+        return false;
+    }
+    delete current[lastPart];
+    return true;
+}
+function setNestedValue(obj, key, value) {
+    const parts = key.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (current[part] == null || typeof current[part] !== 'object') {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+}
+function collectKeys(obj, prefix = '') {
+    const keys = [];
+    for (const [k, v] of Object.entries(obj)) {
+        const fk = prefix ? `${prefix}.${k}` : k;
+        if (v != null && typeof v === 'object' && !Array.isArray(v)) {
+            keys.push(...collectKeys(v, fk));
+        }
+        else {
+            keys.push(fk);
+        }
+    }
+    return keys;
+}
+function filterFiles(files, namespace) {
+    if (!namespace) {
+        return files;
+    }
+    return files.filter((f) => f.namespace === namespace);
+}
+function findLocaleFile(files, locale, namespace) {
+    if (namespace) {
+        return files.find((f) => f.locale === locale && f.namespace === namespace);
+    }
+    return files.find((f) => f.locale === locale);
+}
+export function query(key, dir) {
+    const resolvedDir = dir || DEFAULT_DIR;
+    const localeFiles = discoverLocaleFiles(resolvedDir);
+    const { namespace, dotKey } = parseKey(key);
+    const filesToSearch = filterFiles(localeFiles, namespace);
+    const results = [];
+    for (const file of filesToSearch) {
+        const data = readJson(file.path);
+        const value = getNestedValue(data, dotKey);
+        if (value !== undefined) {
+            const label = !namespace && file.namespace
+                ? `${file.locale} (${file.namespace})`
+                : file.locale;
+            if (typeof value === 'object') {
+                results.push(`${label}: ${JSON.stringify(value)}`);
+            }
+            else {
+                results.push(`${label}: ${value}`);
+            }
+        }
+    }
+    if (results.length === 0) {
+        return `Key "${key}" not found in any locale.`;
+    }
+    return results.join('\n');
+}
+export function set(locale, key, value, dir) {
+    const resolvedDir = dir || DEFAULT_DIR;
+    const localeFiles = discoverLocaleFiles(resolvedDir);
+    const { namespace, dotKey } = parseKey(key);
+    if (isNamespaced(localeFiles) && !namespace) {
+        throw new Error(`Namespace required in namespace mode. Use "namespace:${key}" format.`);
+    }
+    const localeFile = findLocaleFile(localeFiles, locale, namespace);
+    if (!localeFile) {
+        const target = namespace ? `${locale}/${namespace}` : locale;
+        throw new Error(`Locale "${target}" not found in ${resolvedDir}`);
+    }
+    const data = readJson(localeFile.path);
+    setNestedValue(data, dotKey, sanitize(value));
+    writeJson(localeFile.path, data);
+    return `Set ${locale}.${key} = "${value}"`;
+}
+export function remove(key, dir) {
+    const resolvedDir = dir || DEFAULT_DIR;
+    const localeFiles = discoverLocaleFiles(resolvedDir);
+    const { namespace, dotKey } = parseKey(key);
+    const filesToSearch = filterFiles(localeFiles, namespace);
+    const deleted = [];
+    for (const file of filesToSearch) {
+        const data = readJson(file.path);
+        if (deleteNestedValue(data, dotKey)) {
+            writeJson(file.path, data);
+            const label = !namespace && file.namespace
+                ? `${file.locale} (${file.namespace})`
+                : file.locale;
+            deleted.push(label);
+        }
+    }
+    if (deleted.length === 0) {
+        return `Key "${key}" not found in any locale.`;
+    }
+    return `Deleted "${key}" from ${deleted.length} locale(s): ${deleted.join(', ')}`;
+}
+export function add(key, translations, dir) {
+    const resolvedDir = dir || DEFAULT_DIR;
+    const localeFiles = discoverLocaleFiles(resolvedDir);
+    const { namespace, dotKey } = parseKey(key);
+    if (isNamespaced(localeFiles) && !namespace) {
+        throw new Error(`Namespace required in namespace mode. Use "namespace:${key}" format.`);
+    }
+    const updated = [];
+    const warnings = [];
+    for (const [locale, value] of Object.entries(translations)) {
+        const localeFile = findLocaleFile(localeFiles, locale, namespace);
+        if (!localeFile) {
+            const target = namespace ? `${locale}/${namespace}` : locale;
+            warnings.push(`Warning: locale "${target}" not found in ${resolvedDir}, skipping`);
+            continue;
+        }
+        const data = readJson(localeFile.path);
+        setNestedValue(data, dotKey, sanitize(value));
+        writeJson(localeFile.path, data);
+        updated.push(locale);
+    }
+    if (updated.length === 0) {
+        throw new Error('No locales were updated');
+    }
+    const lines = [];
+    if (warnings.length > 0) {
+        lines.push(...warnings);
+    }
+    lines.push(`Added "${key}" to ${updated.length} locale(s): ${updated.join(', ')}`);
+    return lines.join('\n');
+}
+export function rename(oldKey, newKey, dir) {
+    const resolvedDir = dir || DEFAULT_DIR;
+    const localeFiles = discoverLocaleFiles(resolvedDir);
+    const { namespace: oldNs, dotKey: oldDotKey } = parseKey(oldKey);
+    const { dotKey: newDotKey } = parseKey(newKey);
+    const filesToSearch = filterFiles(localeFiles, oldNs);
+    const renamed = [];
+    for (const file of filesToSearch) {
+        const data = readJson(file.path);
+        const value = getNestedValue(data, oldDotKey);
+        if (value === undefined) {
+            continue;
+        }
+        deleteNestedValue(data, oldDotKey);
+        if (typeof value === 'object' && value !== null) {
+            const subKeys = collectKeys(value);
+            for (const subKey of subKeys) {
+                const subValue = getNestedValue(value, subKey);
+                setNestedValue(data, `${newDotKey}.${subKey}`, subValue);
+            }
+        }
+        else {
+            setNestedValue(data, newDotKey, value);
+        }
+        writeJson(file.path, data);
+        const label = !oldNs && file.namespace
+            ? `${file.locale} (${file.namespace})`
+            : file.locale;
+        renamed.push(label);
+    }
+    if (renamed.length === 0) {
+        return `Key "${oldKey}" not found in any locale.`;
+    }
+    return `Renamed "${oldKey}" to "${newKey}" in ${renamed.length} locale(s): ${renamed.join(', ')}`;
+}
+export function missing(dir) {
+    const resolvedDir = dir || DEFAULT_DIR;
+    const localeFiles = discoverLocaleFiles(resolvedDir);
+    const allKeys = new Set();
+    const localeKeys = new Map();
+    for (const file of localeFiles) {
+        const data = readJson(file.path);
+        const keys = collectKeys(data).map((k) => fullKey(file, k));
+        if (!localeKeys.has(file.locale)) {
+            localeKeys.set(file.locale, new Set());
+        }
+        const existing = localeKeys.get(file.locale);
+        keys.forEach((k) => {
+            allKeys.add(k);
+            existing.add(k);
+        });
+    }
+    const results = [];
+    for (const [locale, keys] of localeKeys) {
+        const missingKeys = [...allKeys].filter((k) => !keys.has(k)).sort();
+        if (missingKeys.length > 0) {
+            results.push(`${locale}: ${missingKeys.join(', ')}`);
+        }
+    }
+    if (results.length === 0) {
+        return 'All locales have all keys.';
+    }
+    return results.join('\n');
+}
+export function list(prefix, page = 1, pageSize = 100, dir) {
+    const resolvedDir = dir || DEFAULT_DIR;
+    const localeFiles = discoverLocaleFiles(resolvedDir);
+    const allKeys = new Set();
+    for (const file of localeFiles) {
+        const data = readJson(file.path);
+        collectKeys(data).forEach((k) => allKeys.add(fullKey(file, k)));
+    }
+    let keys = [...allKeys].sort();
+    if (prefix) {
+        keys = keys.filter((k) => k.startsWith(prefix));
+    }
+    if (keys.length === 0) {
+        return prefix ? `No keys found with prefix "${prefix}".` : 'No keys found.';
+    }
+    const totalPages = Math.ceil(keys.length / pageSize);
+    const start = (page - 1) * pageSize;
+    const pageKeys = keys.slice(start, start + pageSize);
+    if (pageKeys.length === 0) {
+        return `Page ${page} is out of range. Total pages: ${totalPages}`;
+    }
+    const header = `Page ${page}/${totalPages} (${keys.length} keys total)`;
+    return `${header}\n${pageKeys.join('\n')}`;
+}
+export function search(value, page = 1, pageSize = 100, dir) {
+    const resolvedDir = dir || DEFAULT_DIR;
+    const localeFiles = discoverLocaleFiles(resolvedDir);
+    const results = [];
+    const lowerValue = value.toLowerCase();
+    for (const file of localeFiles) {
+        const data = readJson(file.path);
+        const keys = collectKeys(data);
+        for (const key of keys) {
+            const v = getNestedValue(data, key);
+            if (typeof v === 'string' && v.toLowerCase().includes(lowerValue)) {
+                const fk = fullKey(file, key);
+                results.push(`${file.locale}.${fk} = "${v}"`);
+            }
+        }
+    }
+    if (results.length === 0) {
+        return `No translations found containing "${value}".`;
+    }
+    const totalPages = Math.ceil(results.length / pageSize);
+    const start = (page - 1) * pageSize;
+    const pageResults = results.slice(start, start + pageSize);
+    if (pageResults.length === 0) {
+        return `Page ${page} is out of range. Total pages: ${totalPages}`;
+    }
+    const header = `Page ${page}/${totalPages} (${results.length} results total)`;
+    return `${header}\n${pageResults.join('\n')}`;
+}
+export function move(oldKey, newKey, dir) {
+    return rename(oldKey, newKey, dir).replace('Renamed', 'Moved');
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "i18n-tools-mcp",
+    "version": "1.0.0",
+    "description": "MCP server for managing JSON translation files",
+    "type": "module",
+    "bin": {
+        "i18n-tools-mcp": "dist/index.js"
+    },
+    "files": [
+        "dist",
+        "!dist/**/*.test.*"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsc --watch",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "prepublishOnly": "pnpm build"
+    },
+    "keywords": [
+        "mcp",
+        "i18n",
+        "translations",
+        "internationalization",
+        "i18next",
+        "react-i18next",
+        "next-i18next",
+        "json",
+        "locale",
+        "model-context-protocol"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Trivle/i18n-tools-mcp"
+    },
+    "packageManager": "pnpm@10.30.3",
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.12.1",
+        "zod": "^4.3.6"
+    },
+    "devDependencies": {
+        "@types/node": "^22.0.0",
+        "typescript": "^5.7.0",
+        "vitest": "^4.0.18"
+    }
+}