gtx-cli 2.2.0-alpha.0 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,63 @@
 # gtx-cli
 
+## 2.3.0
+
+### Minor Changes
+
+- [#651](https://github.com/generaltranslation/gt/pull/651) [`3e5705b`](https://github.com/generaltranslation/gt/commit/3e5705bc96005441798619fec97574fa15a5a2bd) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Split up file upload into source/translation specific uploads; added project setup visibility
+
+### Patch Changes
+
+- Updated dependencies [[`3e5705b`](https://github.com/generaltranslation/gt/commit/3e5705bc96005441798619fec97574fa15a5a2bd)]:
+  - generaltranslation@7.6.0
+
+## 2.2.0
+
+### Minor Changes
+
+- [#638](https://github.com/generaltranslation/gt/pull/638) [`16bf30d`](https://github.com/generaltranslation/gt/commit/16bf30d70a0599ec863305f4f7a5a0852dd07e5d) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - feat: add locale aliasing
+
+### Patch Changes
+
+- Updated dependencies [[`16bf30d`](https://github.com/generaltranslation/gt/commit/16bf30d70a0599ec863305f4f7a5a0852dd07e5d)]:
+  - generaltranslation@7.5.0
+
+## 2.1.21
+
+### Patch Changes
+
+- [#645](https://github.com/generaltranslation/gt/pull/645) [`58cfaee`](https://github.com/generaltranslation/gt/commit/58cfaee5cc1dcd187f0b72b2761f96c19b4f313e) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Escaping HTML to avoid parsing issues from MDX consumers
+
+## 2.1.20
+
+### Patch Changes
+
+- [#643](https://github.com/generaltranslation/gt/pull/643) [`4f553c0`](https://github.com/generaltranslation/gt/commit/4f553c00c119f272edc5ccb3616f2d0effec8586) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Removing custom configuration on remarkStringify
+
+## 2.1.19
+
+### Patch Changes
+
+- [#641](https://github.com/generaltranslation/gt/pull/641) [`4c67f77`](https://github.com/generaltranslation/gt/commit/4c67f775ee892b47eebcc3178c00ad6547a84d84) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Encoding placeholders that break MDX parse
+
+## 2.1.18
+
+### Patch Changes
+
+- [#637](https://github.com/generaltranslation/gt/pull/637) [`9c40a3c`](https://github.com/generaltranslation/gt/commit/9c40a3c729bf690381959679078c11c9c29bcdf2) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Skipping over empty files when sending for translation
+
+## 2.1.17
+
+### Patch Changes
+
+- [#635](https://github.com/generaltranslation/gt/pull/635) [`10aa051`](https://github.com/generaltranslation/gt/commit/10aa051592cea43f772615da200c8615d4dd1a78) Thanks [@brian-lou](https://github.com/brian-lou)! - Create dictionary with uuid to reduce flakiness
+
+## 2.1.16
+
+### Patch Changes
+
+- [#630](https://github.com/generaltranslation/gt/pull/630) [`1f0dc1b`](https://github.com/generaltranslation/gt/commit/1f0dc1b17f22737263938998f5c516e0aa136b1a) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Adding localization of import paths to MDX files
+
 ## 2.1.15
 
 ### Patch Changes

package/dist/api/sendFiles.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { createSpinner, logMessage, logSuccess } from '../console/logging.js';
+import { createSpinner, logError, logMessage, logSuccess, } from '../console/logging.js';
 import { gt } from '../utils/gt.js';
 import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
 /**
@@ -9,6 +9,8 @@ import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
  * @returns The translated content or version ID
  */
 export async function sendFiles(files, options, settings) {
+    // Keep track of the most recent spinner so we can stop it on error
+    let currentSpinner = null;
     logMessage(chalk.cyan('Files to translate:') +
         '\n' +
         files
@@ -19,26 +21,95 @@ export async function sendFiles(files, options, settings) {
             return `- ${file.fileName}`;
         })
             .join('\n'));
-    const spinner = createSpinner('dots');
-    spinner.start(`Sending ${files.length} file${files.length !== 1 ? 's' : ''} to General Translation API...`);
     try {
-        // Send the files to the API
-        const responseData = await gt.enqueueFiles(files, {
-            publish: settings.publish,
+        // Step 1: Upload files (get references)
+        const uploadSpinner = createSpinner('dots');
+        currentSpinner = uploadSpinner;
+        uploadSpinner.start(`Uploading ${files.length} file${files.length !== 1 ? 's' : ''} to General Translation API...`);
+        const sourceLocale = settings.defaultLocale;
+        if (!sourceLocale) {
+            uploadSpinner.stop(chalk.red('Missing default source locale'));
+            throw new Error('sendFiles: settings.defaultLocale is required to upload source files');
+        }
+        // Convert FileToTranslate[] -> { source: FileUpload }[]
+        const uploads = files.map(({ content, fileName, fileFormat, dataFormat }) => ({
+            source: {
+                content,
+                fileName,
+                fileFormat,
+                dataFormat,
+                locale: sourceLocale,
+            },
+        }));
+        const upload = await gt.uploadSourceFiles(uploads, {
+            sourceLocale,
+            modelProvider: settings.modelProvider,
+        });
+        uploadSpinner.stop(chalk.green('Files uploaded successfully'));
+        // Check if setup is needed
+        const setupDecision = await Promise.resolve(gt.shouldSetupProject?.())
+            .then((v) => v)
+            .catch(() => ({ shouldSetupProject: false }));
+        const shouldSetupProject = Boolean(setupDecision?.shouldSetupProject);
+        // Step 2: Setup if needed and poll until complete
+        if (shouldSetupProject) {
+            // Calculate timeout once for setup fetching
+            // Accept number or numeric string, default to 600s
+            const timeoutVal = options?.timeout !== undefined ? Number(options.timeout) : 600;
+            const setupTimeoutMs = (Number.isFinite(timeoutVal) ? timeoutVal : 600) * 1000;
+            const { setupJobId } = await gt.setupProject(upload.uploadedFiles);
+            const setupSpinner = createSpinner('dots');
+            currentSpinner = setupSpinner;
+            setupSpinner.start('Setting up project...');
+            const start = Date.now();
+            const pollInterval = 2000;
+            let setupCompleted = false;
+            let setupFailedMessage = null;
+            while (true) {
+                const status = await gt.checkSetupStatus(setupJobId);
+                if (status.status === 'completed') {
+                    setupCompleted = true;
+                    break;
+                }
+                if (status.status === 'failed') {
+                    setupFailedMessage = status.error?.message || 'Unknown error';
+                    break;
+                }
+                if (Date.now() - start > setupTimeoutMs) {
+                    setupFailedMessage = 'Timed out while waiting for setup generation';
+                    break;
+                }
+                await new Promise((r) => setTimeout(r, pollInterval));
+            }
+            if (setupCompleted) {
+                setupSpinner.stop(chalk.green('Setup successfully completed'));
+            }
+            else {
+                setupSpinner.stop(chalk.yellow(`Setup ${setupFailedMessage ? 'failed' : 'timed out'} — proceeding without setup${setupFailedMessage ? ` (${setupFailedMessage})` : ''}`));
+            }
+        }
+        // Step 3: Enqueue translations by reference
+        const enqueueSpinner = createSpinner('dots');
+        currentSpinner = enqueueSpinner;
+        enqueueSpinner.start('Enqueuing translations...');
+        const enqueueResult = await gt.enqueueFiles(upload.uploadedFiles, {
             sourceLocale: settings.defaultLocale,
             targetLocales: settings.locales,
-            version: settings.version, // not set ATM
+            publish: settings.publish,
+            requireApproval: settings.stageTranslations,
             modelProvider: settings.modelProvider,
             force: options?.force,
         });
-        // Handle version ID response (for async processing)
-        const { data, message, locales, translations } = responseData;
-        spinner.stop(chalk.green('Files for translation uploaded successfully'));
+        const { data, message, locales, translations } = enqueueResult;
+        enqueueSpinner.stop(chalk.green('Files for translation uploaded successfully'));
         logSuccess(message);
         return { data, locales, translations };
     }
     catch (error) {
-        spinner.stop(chalk.red('Failed to send files for translation'));
+        if (currentSpinner) {
+            currentSpinner.stop(chalk.red('Failed to send files for translation'));
+        }
+        logError('Failed to send files for translation');
         throw error;
     }
 }

package/dist/api/uploadFiles.d.ts

@@ -24,4 +24,4 @@ export type UploadData = {
 export declare function uploadFiles(files: {
     source: FileUpload;
     translations: FileUpload[];
-}[], options: Settings): Promise<any>;
+}[], options: Settings): Promise<void>;

package/dist/api/uploadFiles.js

@@ -18,12 +18,20 @@ export async function uploadFiles(files, options) {
     const spinner = createSpinner('dots');
     spinner.start(`Uploading ${files.length} file${files.length !== 1 ? 's' : ''} to General Translation...`);
     try {
-        const result = gt.uploadFiles(files, {
+        // Upload sources
+        await gt.uploadSourceFiles(files, {
             ...options,
             sourceLocale: options.defaultLocale,
         });
+        // Upload translations (if any exist)
+        const withTranslations = files.filter((f) => f.translations.length > 0);
+        if (withTranslations.length > 0) {
+            await gt.uploadTranslations(withTranslations, {
+                ...options,
+                sourceLocale: options.defaultLocale, // optional, safe to include
+            });
+        }
         spinner.stop(chalk.green('Files uploaded successfully'));
-        return result;
     }
     catch {
         spinner.stop(chalk.red('An unexpected error occurred while uploading files'));

package/dist/cli/commands/translate.js

@@ -7,6 +7,7 @@ import flattenJsonFiles from '../../utils/flattenJsonFiles.js';
 import localizeStaticUrls from '../../utils/localizeStaticUrls.js';
 import processAnchorIds from '../../utils/processAnchorIds.js';
 import { noFilesError, noVersionIdError } from '../../console/index.js';
+import localizeStaticImports from '../../utils/localizeStaticImports.js';
 // Downloads translations that were completed
 export async function handleTranslate(options, settings, filesTranslationResponse) {
     if (filesTranslationResponse && settings.files) {
@@ -46,6 +47,10 @@ export async function postProcessTranslations(settings) {
         // Uses inline {#id} format by default, or div wrapping if experimentalAddHeaderAnchorIds is 'mintlify'
         await processAnchorIds(settings);
     }
+    // Localize static imports (import Snippet from /snippets/file.mdx -> import Snippet from /snippets/[locale]/file.mdx)
+    if (settings.options?.experimentalLocalizeStaticImports) {
+        await localizeStaticImports(settings);
+    }
     // Flatten json files into a single file
     if (settings.options?.experimentalFlattenJsonFiles) {
         await flattenJsonFiles(settings);

package/dist/formats/files/translate.js

@@ -35,30 +35,46 @@ export async function aggregateFiles(settings) {
         else {
             dataFormat = 'JSX';
         }
-        const jsonFiles = filePaths.json.map((filePath) => {
+        const jsonFiles = filePaths.json
+            .map((filePath) => {
             const content = readFile(filePath);
-            const parsedJson = parseJson(content, filePath, settings.options || {}, settings.defaultLocale);
             const relativePath = getRelative(filePath);
+            const parsedJson = parseJson(content, filePath, settings.options || {}, settings.defaultLocale);
             return {
                 content: parsedJson,
                 fileName: relativePath,
                 fileFormat: 'JSON',
                 dataFormat,
             };
+        })
+            .filter((file) => {
+            if (!file || typeof file.content !== 'string' || !file.content.trim()) {
+                logWarning(`Skipping ${file?.fileName ?? 'unknown'}: JSON file is empty`);
+                return false;
+            }
+            return true;
         });
         allFiles.push(...jsonFiles);
     }
     // Process YAML files
     if (filePaths.yaml) {
-        const yamlFiles = filePaths.yaml.map((filePath) => {
+        const yamlFiles = filePaths.yaml
+            .map((filePath) => {
             const content = readFile(filePath);
-            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, settings.options || {});
             const relativePath = getRelative(filePath);
+            const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, settings.options || {});
             return {
                 content: parsedYaml,
                 fileName: relativePath,
                 fileFormat,
             };
+        })
+            .filter((file) => {
+            if (!file || typeof file.content !== 'string' || !file.content.trim()) {
+                logWarning(`Skipping ${file?.fileName ?? 'unknown'}: YAML file is empty`);
+                return false;
+            }
+            return true;
         });
         allFiles.push(...yamlFiles);
     }
@@ -73,8 +89,7 @@ export async function aggregateFiles(settings) {
                 if (fileType === 'mdx') {
                     const validation = isValidMdx(content, filePath);
                     if (!validation.isValid) {
-                        const errorMsg = validation.error ? `: ${validation.error}` : '';
-                        logWarning(`Skipping ${relativePath}: MDX file is not AST parsable${errorMsg}`);
+                        logWarning(`Skipping ${relativePath}: MDX file is not AST parsable${validation.error ? `: ${validation.error}` : ''}`);
                         return null;
                     }
                 }
@@ -85,7 +100,15 @@ export async function aggregateFiles(settings) {
                     fileFormat: fileType.toUpperCase(),
                 };
             })
-                .filter((file) => file !== null);
+                .filter((file) => {
+                if (!file ||
+                    typeof file.content !== 'string' ||
+                    !file.content.trim()) {
+                    logWarning(`Skipping ${file?.fileName ?? 'unknown'}: File is empty after sanitization`);
+                    return false;
+                }
+                return true;
+            });
             allFiles.push(...files);
         }
     }

package/dist/formats/files/upload.js

@@ -100,9 +100,8 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
     const fileMapping = createFileMapping(filePaths, placeholderPaths, transformPaths, locales, options.defaultLocale);
     // construct object
     const uploadData = allFiles.map((file) => {
-        const encodedContent = Buffer.from(file.content).toString('base64');
         const sourceFile = {
-            content: encodedContent,
+            content: file.content,
             fileName: file.fileName,
             fileFormat: file.fileFormat,
             dataFormat: file.dataFormat,
@@ -113,9 +112,8 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
             const translatedFileName = fileMapping[locale][file.fileName];
             if (translatedFileName && existsSync(translatedFileName)) {
                 const translatedContent = readFileSync(translatedFileName, 'utf8');
-                const encodedTranslatedContent = Buffer.from(translatedContent).toString('base64');
                 translations.push({
-                    content: encodedTranslatedContent,
+                    content: translatedContent,
                     fileName: translatedFileName,
                     fileFormat: file.fileFormat,
                     dataFormat: file.dataFormat,

package/dist/react/parse/createDictionaryUpdates.js

@@ -7,6 +7,7 @@ import loadJSON from '../../fs/loadJSON.js';
 import { hashSource } from 'generaltranslation/id';
 import getEntryAndMetadata from '../utils/getEntryAndMetadata.js';
 import { logError } from '../../console/logging.js';
+import { randomUUID } from 'node:crypto';
 export async function createDictionaryUpdates(dictionaryPath, esbuildConfig) {
     let dictionary;
     // ---- HANDLE JSON STRING DICTIONARY ----- //
@@ -21,7 +22,7 @@ export async function createDictionaryUpdates(dictionaryPath, esbuildConfig) {
             write: false,
         });
         const bundledCode = result.outputFiles[0].text;
-        const tempFilePath = path.join(os.tmpdir(), 'bundled-dictionary.js');
+        const tempFilePath = path.join(os.tmpdir(), `bundled-dictionary-${randomUUID()}.js`);
         await fs.promises.writeFile(tempFilePath, bundledCode);
         // Load the module using dynamic import
         let dictionaryModule;

package/dist/utils/addExplicitAnchorIds.js

@@ -5,6 +5,7 @@ import remarkFrontmatter from 'remark-frontmatter';
 import remarkStringify from 'remark-stringify';
 import { visit } from 'unist-util-visit';
 import { logWarning } from '../console/logging.js';
+import { escapeHtmlInTextNodes } from './escapeHtml.js';
 /**
  * Generates a slug from heading text
  */
@@ -158,13 +159,13 @@ function applyInlineIds(translatedContent, idMappings) {
             // Add the ID to the heading
             const lastChild = heading.children[heading.children.length - 1];
             if (lastChild?.type === 'text') {
-                lastChild.value += ` {#${id}}`;
+                lastChild.value += ` \\{#${id}\\}`;
             }
             else {
                 // If last child is not text, add a new text node
                 heading.children.push({
                     type: 'text',
-                    value: ` {#${id}}`,
+                    value: ` \\{#${id}\\}`,
                 });
             }
         }
@@ -173,23 +174,19 @@ function applyInlineIds(translatedContent, idMappings) {
     // Convert the modified AST back to MDX string
     try {
         const stringifyProcessor = unified()
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx)
+            .use(escapeHtmlInTextNodes)
             .use(remarkStringify, {
-            bullet: '-',
-            emphasis: '_',
-            strong: '*',
-            rule: '-',
-            ruleRepetition: 3,
-            ruleSpaces: false,
             handlers: {
                 // Custom handler to prevent escaping of {#id} syntax
                 text(node) {
                     return node.value;
                 },
             },
-        })
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx);
-        let content = stringifyProcessor.stringify(processedAst);
+        });
+        const outTree = stringifyProcessor.runSync(processedAst);
+        let content = stringifyProcessor.stringify(outTree);
         // Handle newline formatting to match original input
         if (content.endsWith('\n') && !translatedContent.endsWith('\n')) {
             content = content.slice(0, -1);

package/dist/utils/escapeHtml.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from 'unified';
+import type { Root } from 'mdast';
+/**
+ * Escape HTML-sensitive characters (`&`, `<`, `>`, `"`, `'`) in text nodes,
+ * leaving code, math, MDX expressions, and front-matter untouched.
+ * Ensures literals render safely without altering already-escaped entities.
+ */
+export declare const escapeHtmlInTextNodes: Plugin<[], Root>;

package/dist/utils/escapeHtml.js

@@ -0,0 +1,32 @@
+import { findAndReplace } from 'mdast-util-find-and-replace';
+const IGNORE_PARENTS = [
+    'code',
+    'inlineCode',
+    'mdxFlowExpression',
+    'mdxTextExpression',
+    'mdxjsEsm',
+    'heading',
+    'yaml',
+    'toml',
+    'math',
+    'inlineMath',
+];
+// & that is NOT already an entity: &word;  {  ᨫ
+const AMP_NOT_ENTITY = /&(?![a-zA-Z][a-zA-Z0-9]*;|#\d+;|#x[0-9A-Fa-f]+;)/g;
+/**
+ * Escape HTML-sensitive characters (`&`, `<`, `>`, `"`, `'`) in text nodes,
+ * leaving code, math, MDX expressions, and front-matter untouched.
+ * Ensures literals render safely without altering already-escaped entities.
+ */
+export const escapeHtmlInTextNodes = function () {
+    return (tree) => {
+        findAndReplace(tree, [
+            // Order matters: & first (idempotency), then the rest
+            [AMP_NOT_ENTITY, '&amp;'],
+            [/</g, '&lt;'],
+            [/>/g, '&gt;'],
+            [/"/g, '&quot;'],
+            [/'/g, '&#39;'],
+        ], { ignore: IGNORE_PARENTS });
+    };
+};

package/dist/utils/localizeStaticImports.js

@@ -1,11 +1,11 @@
 import * as fs from 'fs';
+import * as path from 'path';
 import { createFileMapping } from '../formats/files/fileMapping.js';
 import micromatch from 'micromatch';
 import { unified } from 'unified';
 import remarkParse from 'remark-parse';
 import remarkMdx from 'remark-mdx';
 import remarkFrontmatter from 'remark-frontmatter';
-import remarkStringify from 'remark-stringify';
 import { visit } from 'unist-util-visit';
 const { isMatch } = micromatch;
 /**
@@ -44,11 +44,15 @@ export default async function localizeStaticImports(settings) {
         }
         if (defaultLocaleFiles.length > 0) {
             const defaultPromise = Promise.all(defaultLocaleFiles.map(async (filePath) => {
+                // Check if file exists before processing
+                if (!fs.existsSync(filePath)) {
+                    return;
+                }
                 // Get file content
                 const fileContent = await fs.promises.readFile(filePath, 'utf8');
                 // Localize the file using default locale
                 const localizedFile = localizeStaticImportsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
-                settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath.endsWith('.md'));
+                settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath);
                 // Write the localized file back to the same path
                 await fs.promises.writeFile(filePath, localizedFile);
             }));
@@ -61,10 +65,14 @@ export default async function localizeStaticImports(settings) {
         const targetFiles = Object.values(filesMap).filter((path) => path.endsWith('.md') || path.endsWith('.mdx'));
         // Replace the placeholder path with the target path
         await Promise.all(targetFiles.map(async (filePath) => {
+            // Check if file exists before processing
+            if (!fs.existsSync(filePath)) {
+                return;
+            }
             // Get file content
             const fileContent = await fs.promises.readFile(filePath, 'utf8');
             // Localize the file
-            const localizedFile = localizeStaticImportsForFile(fileContent, settings.defaultLocale, locale, settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath.endsWith('.md'));
+            const localizedFile = localizeStaticImportsForFile(fileContent, settings.defaultLocale, locale, settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath);
             // Write the localized file to the target path
             await fs.promises.writeFile(filePath, localizedFile);
         }));
@@ -175,23 +183,44 @@ function transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale
 /**
  * Main import path transformation function that delegates to specific scenarios
  */
-function transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale) {
+function transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, projectRoot = process.cwd() // fallback if not provided
+) {
+    let newPath;
     if (targetLocale === defaultLocale) {
-        return transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale);
+        newPath = transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale);
     }
     else if (hideDefaultLocale) {
-        return transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale);
+        newPath = transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale);
     }
     else {
-        return transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale);
+        newPath = transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale);
     }
+    if (!newPath)
+        return null;
+    if (currentFilePath) {
+        let resolvedPath;
+        if (newPath.startsWith('/')) {
+            // Interpret as project-root relative
+            resolvedPath = path.join(projectRoot, newPath.replace(/^\//, ''));
+        }
+        else {
+            // Relative to current file
+            const currentDir = path.dirname(currentFilePath);
+            resolvedPath = path.resolve(currentDir, newPath);
+        }
+        if (!fs.existsSync(resolvedPath)) {
+            return null;
+        }
+    }
+    return newPath;
 }
 /**
  * AST-based transformation for MDX files using remark-mdx
  */
-function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = []) {
+function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], currentFilePath) {
     const transformedImports = [];
-    if (!pattern.startsWith('/')) {
+    // Don't auto-prefix relative patterns that start with . or ..
+    if (!pattern.startsWith('/') && !pattern.startsWith('.')) {
         pattern = '/' + pattern;
     }
     const patternHead = pattern.split('[locale]')[0];
@@ -239,23 +268,23 @@ function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaul
             transformedImports: [],
         };
     }
-    // Visit only mdxjsEsm nodes (import/export statements)
+    let content = mdxContent;
+    // Visit only mdxjsEsm nodes (import/export statements) to collect replacements
     visit(processedAst, 'mdxjsEsm', (node) => {
         if (node.value && node.value.includes(patternHead.replace(/\/$/, ''))) {
-            // Find and transform import paths in the node value
+            // Find import lines that need transformation
             const lines = node.value.split('\n');
-            const transformedLines = lines.map((line) => {
+            lines.forEach((line) => {
                 // Only process import lines that match our pattern
                 if (!line.trim().startsWith('import ')) {
-                    return line;
+                    return;
                 }
                 // Check if this line should be processed
                 if (!shouldProcessImportPath(line, patternHead, targetLocale, defaultLocale)) {
-                    return line;
+                    return;
                 }
                 // Extract the path from the import statement
                 const quotes = ['"', "'", '`'];
-                let transformedLine = line;
                 for (const quote of quotes) {
                     // Try both with and without trailing slash
                     let startPattern = `${quote}${patternHead}`;
@@ -274,7 +303,7 @@ function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaul
                         continue;
                     const fullPath = line.slice(pathStart, pathEnd);
                     // Transform the import path
-                    const newPath = transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale);
+                    const newPath = transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath);
                     if (!newPath) {
                         continue; // No transformation needed
                     }
@@ -282,43 +311,15 @@ function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaul
                     if (isImportPathExcluded(fullPath, exclude, defaultLocale)) {
                         continue;
                     }
-                    // Apply the transformation
+                    // Apply the transformation to the original content
+                    // Simply replace the import path with the new path
+                    content = content.replace(`${quote}${fullPath}${quote}`, `${quote}${newPath}${quote}`);
                     transformedImports.push({ originalPath: fullPath, newPath });
-                    transformedLine =
-                        line.slice(0, pathStart) + newPath + line.slice(pathEnd);
                     break;
                 }
-                return transformedLine;
             });
-            node.value = transformedLines.join('\n');
         }
     });
-    // Convert the modified AST back to MDX string
-    let content;
-    try {
-        const stringifyProcessor = unified()
-            .use(remarkStringify)
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx);
-        content = stringifyProcessor.stringify(processedAst);
-    }
-    catch (error) {
-        console.warn(`Failed to stringify MDX content: ${error instanceof Error ? error.message : String(error)}`);
-        console.warn('Returning original content unchanged due to stringify error.');
-        return {
-            content: mdxContent,
-            hasChanges: false,
-            transformedImports: [],
-        };
-    }
-    // Handle newline formatting to match original input
-    if (content.endsWith('\n') && !mdxContent.endsWith('\n')) {
-        content = content.slice(0, -1);
-    }
-    // Preserve leading newlines from original content
-    if (mdxContent.startsWith('\n') && !content.startsWith('\n')) {
-        content = '\n' + content;
-    }
     return {
         content,
         hasChanges: transformedImports.length > 0,
@@ -329,12 +330,12 @@ function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaul
  * AST-based transformation for MDX files only
  */
 function localizeStaticImportsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = [], isMarkdown = false) {
+exclude = [], currentFilePath) {
     // Skip .md files entirely - they cannot have imports
-    if (isMarkdown) {
+    if (currentFilePath && currentFilePath.endsWith('.md')) {
         return file;
     }
     // For MDX files, use AST-based transformation
-    const result = transformMdxImports(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude);
+    const result = transformMdxImports(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, currentFilePath);
     return result.content;
 }

package/dist/utils/localizeStaticUrls.js

@@ -7,6 +7,7 @@ import remarkMdx from 'remark-mdx';
 import remarkFrontmatter from 'remark-frontmatter';
 import remarkStringify from 'remark-stringify';
 import { visit } from 'unist-util-visit';
+import { escapeHtmlInTextNodes } from './escapeHtml.js';
 const { isMatch } = micromatch;
 /**
  * Localizes static urls in content files.
@@ -49,6 +50,10 @@ export default async function localizeStaticUrls(settings, targetLocales) {
         }
         if (defaultLocaleFiles.length > 0) {
             const defaultPromise = Promise.all(defaultLocaleFiles.map(async (filePath) => {
+                // Check if file exists before processing
+                if (!fs.existsSync(filePath)) {
+                    return;
+                }
                 // Get file content
                 const fileContent = await fs.promises.readFile(filePath, 'utf8');
                 // Localize the file using default locale
@@ -366,17 +371,19 @@ function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLo
     let content;
     try {
         const stringifyProcessor = unified()
-            .use(remarkStringify, {
-            bullet: '-',
-            emphasis: '_',
-            strong: '*',
-            rule: '-',
-            ruleRepetition: 3,
-            ruleSpaces: false,
-        })
             .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx);
-        content = stringifyProcessor.stringify(processedAst);
+            .use(remarkMdx)
+            .use(escapeHtmlInTextNodes)
+            .use(remarkStringify, {
+            handlers: {
+                // Handler to prevent escaping (avoids '<' -> '\<')
+                text(node) {
+                    return node.value;
+                },
+            },
+        });
+        const outTree = stringifyProcessor.runSync(processedAst);
+        content = stringifyProcessor.stringify(outTree);
     }
     catch (error) {
         console.warn(`Failed to stringify MDX content: ${error instanceof Error ? error.message : String(error)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.2.0-alpha.0",
+  "version": "2.3.0",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -87,10 +87,11 @@
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.4",
-    "generaltranslation": "^7.5.0-alpha.0",
+    "generaltranslation": "^7.6.0",
     "json-pointer": "^0.6.2",
     "jsonpath-plus": "^10.3.0",
     "jsonpointer": "^5.0.1",
+    "mdast-util-find-and-replace": "^3.0.2",
     "micromatch": "^4.0.8",
     "open": "^10.1.1",
     "ora": "^8.2.0",