gtx-cli 2.1.0 → 2.1.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gtx-cli
 
+## 2.1.2
+
+### Patch Changes
+
+- [#562](https://github.com/generaltranslation/gt/pull/562) [`8461c5e`](https://github.com/generaltranslation/gt/commit/8461c5ee2ca25cf50d4e366cb4d1e765107851fd) Thanks [@SamEggert](https://github.com/SamEggert)! - localStaticImports gracefully handles invalid MDX
+
+## 2.1.1
+
+### Patch Changes
+
+- [#554](https://github.com/generaltranslation/gt/pull/554) [`77fb048`](https://github.com/generaltranslation/gt/commit/77fb048ab2e4432739df1c4fbabe165712e84fb3) Thanks [@SamEggert](https://github.com/SamEggert)! - use MDX AST for static imports/urls
+
 ## 2.1.0
 
 ### Minor Changes

package/dist/utils/localizeStaticImports.js

@@ -1,7 +1,12 @@
 import * as fs from 'fs';
 import { createFileMapping } from '../formats/files/fileMapping.js';
-import { logError } from '../console/logging.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;
 /**
  * Localizes static imports in content files.
@@ -25,7 +30,33 @@ export default async function localizeStaticImports(settings) {
     const { resolvedPaths: sourceFiles } = settings.files;
     const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, settings.defaultLocale);
     // Process all file types at once with a single call
-    await Promise.all(Object.entries(fileMapping).map(async ([locale, filesMap]) => {
+    const processPromises = [];
+    // First, process default locale files (from source files)
+    // This is needed because they might not be in the fileMapping if they're not being translated
+    if (!fileMapping[settings.defaultLocale]) {
+        const defaultLocaleFiles = [];
+        // Collect all .md and .mdx files from sourceFiles
+        if (sourceFiles.md) {
+            defaultLocaleFiles.push(...sourceFiles.md);
+        }
+        if (sourceFiles.mdx) {
+            defaultLocaleFiles.push(...sourceFiles.mdx);
+        }
+        if (defaultLocaleFiles.length > 0) {
+            const defaultPromise = Promise.all(defaultLocaleFiles.map(async (filePath) => {
+                // 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'));
+                // Write the localized file back to the same path
+                await fs.promises.writeFile(filePath, localizedFile);
+            }));
+            processPromises.push(defaultPromise);
+        }
+    }
+    // Then process all other locales from fileMapping
+    const mappingPromises = Object.entries(fileMapping).map(async ([locale, filesMap]) => {
         // Get all files that are md or mdx
         const targetFiles = Object.values(filesMap).filter((path) => path.endsWith('.md') || path.endsWith('.mdx'));
         // Replace the placeholder path with the target path
@@ -33,83 +64,277 @@ export default async function localizeStaticImports(settings) {
             // 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);
+            const localizedFile = localizeStaticImportsForFile(fileContent, settings.defaultLocale, locale, settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath.endsWith('.md'));
             // Write the localized file to the target path
             await fs.promises.writeFile(filePath, localizedFile);
         }));
-    }));
+    });
+    processPromises.push(...mappingPromises);
+    await Promise.all(processPromises);
 }
-// Naive find and replace, in the future, construct an AST
-function localizeStaticImportsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = []) {
-    if (!pattern.startsWith('/')) {
-        pattern = '/' + pattern;
-    }
-    // 1. Search for all instances of:
-    const patternHead = pattern.split('[locale]')[0];
-    // Escape special regex characters and remove trailing slash if present
-    const escapedPatternHead = patternHead
-        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-        .replace(/\/$/, '');
-    let regex;
-    if (hideDefaultLocale) {
-        // Match complete import statements: `import { Foo } from '/docs/foo.md'`
-        regex = new RegExp(`import\\s+(.*?)\\s+from\\s+(["'])${escapedPatternHead}(?:/([^"']*?))?\\2`, 'g');
+/**
+ * Determines if an import path should be processed based on pattern matching
+ */
+function shouldProcessImportPath(importPath, patternHead, targetLocale, defaultLocale) {
+    const patternWithoutSlash = patternHead.replace(/\/$/, '');
+    if (targetLocale === defaultLocale) {
+        // For default locale processing, check if path contains the pattern
+        return importPath.includes(patternWithoutSlash);
     }
     else {
-        // Match complete import statements with default locale: `import { Foo } from '/docs/${defaultLocale}/foo.md'`
-        regex = new RegExp(`import\\s+(.*?)\\s+from\\s+(["'])${escapedPatternHead}/${defaultLocale}(?:/([^"']*?))?\\2`, 'g');
+        // For non-default locales, check if path starts with pattern
+        return importPath.includes(patternWithoutSlash);
     }
-    const matches = file.match(regex);
-    if (!matches) {
-        return file;
+}
+/**
+ * Checks if an import path should be excluded based on exclusion patterns
+ */
+function isImportPathExcluded(importPath, exclude, defaultLocale) {
+    const excludePatterns = exclude.map((p) => p.replace(/\[locale\]/g, defaultLocale));
+    return excludePatterns.some((pattern) => isMatch(importPath, pattern));
+}
+/**
+ * Transforms import path for default locale processing
+ */
+function transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale) {
+    if (hideDefaultLocale) {
+        // Remove locale from imports that have it: '/snippets/en/file.mdx' -> '/snippets/file.mdx'
+        if (fullPath.includes(`/${defaultLocale}/`)) {
+            return fullPath.replace(`/${defaultLocale}/`, '/');
+        }
+        else if (fullPath.endsWith(`/${defaultLocale}`)) {
+            return fullPath.replace(`/${defaultLocale}`, '');
+        }
+        return null; // Path doesn't have default locale
     }
-    exclude = exclude.map((pattern) => pattern.replace(/\[locale\]/g, defaultLocale));
-    // 2. Replace the default locale with the target locale in all matched instances
-    const localizedFile = file.replace(regex, (match, bindings, quoteType, pathContent) => {
-        // Check if this path should be excluded from localization
-        if (exclude.length > 0) {
-            let matchPath = '';
-            // let matchPath = patternHead;
-            if (pathContent) {
-                matchPath = hideDefaultLocale
-                    ? `${patternHead}${pathContent}`
-                    : `${patternHead}${defaultLocale}/${pathContent}`;
+    else {
+        // Add locale to imports that don't have it: '/snippets/file.mdx' -> '/snippets/en/file.mdx'
+        if (fullPath.includes(`/${defaultLocale}/`) ||
+            fullPath.endsWith(`/${defaultLocale}`)) {
+            return null; // Already has default locale
+        }
+        if (fullPath.startsWith(patternHead)) {
+            const pathAfterHead = fullPath.slice(patternHead.length);
+            if (pathAfterHead) {
+                return `${patternHead}${defaultLocale}/${pathAfterHead}`;
             }
             else {
-                matchPath = hideDefaultLocale
-                    ? `${patternHead}`
-                    : `${patternHead}${defaultLocale}`;
+                return `${patternHead.replace(/\/$/, '')}/${defaultLocale}`;
             }
-            if (exclude.some((pattern) => isMatch(matchPath, pattern))) {
-                return match; // Don't localize excluded paths
-            }
-        }
-        // get the quote type
-        quoteType = match.match(/["']/)?.[0] || '"';
-        if (!quoteType) {
-            logError(`Failed to localize static imports: Import pattern must include quotes in ${pattern}`);
-            return match;
         }
-        if (hideDefaultLocale) {
-            // For hideDefaultLocale, check if path already has target locale
-            if (pathContent) {
-                if (pathContent.startsWith(`${targetLocale}/`) ||
-                    pathContent === targetLocale) {
-                    return match; // Already localized
-                }
-            }
-            // Add target locale to the path
-            if (!pathContent || pathContent === '') {
-                return `import ${bindings} from ${quoteType}${patternHead}${targetLocale}${quoteType}`;
-            }
-            return `import ${bindings} from ${quoteType}${patternHead}${targetLocale}/${pathContent}${quoteType}`;
+        return null; // Path doesn't match pattern
+    }
+}
+/**
+ * Transforms import path for non-default locale processing with hideDefaultLocale=true
+ */
+function transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale) {
+    // Check if already localized
+    if (fullPath.startsWith(`${patternHead}${targetLocale}/`) ||
+        fullPath === `${patternHead}${targetLocale}`) {
+        return null;
+    }
+    // Replace default locale with target locale
+    const expectedPathWithDefaultLocale = `${patternHead}${defaultLocale}`;
+    if (fullPath.startsWith(`${expectedPathWithDefaultLocale}/`) ||
+        fullPath === expectedPathWithDefaultLocale) {
+        return fullPath.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
+    }
+    // Handle exact pattern match
+    if (fullPath === patternHead.replace(/\/$/, '')) {
+        return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+    }
+    // Add target locale to path without any locale
+    const pathAfterHead = fullPath.slice(patternHead.length);
+    return pathAfterHead
+        ? `${patternHead}${targetLocale}/${pathAfterHead}`
+        : `${patternHead}${targetLocale}`;
+}
+/**
+ * Transforms import path for non-default locale processing with hideDefaultLocale=false
+ */
+function transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale) {
+    const expectedPathWithLocale = `${patternHead}${defaultLocale}`;
+    if (fullPath.startsWith(`${expectedPathWithLocale}/`) ||
+        fullPath === expectedPathWithLocale) {
+        // Replace existing default locale with target locale
+        return fullPath.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
+    }
+    else if (fullPath.startsWith(patternHead)) {
+        // Add target locale to path that doesn't have any locale
+        const pathAfterHead = fullPath.slice(patternHead.length);
+        if (pathAfterHead) {
+            return `${patternHead}${targetLocale}/${pathAfterHead}`;
         }
         else {
-            // For non-hideDefaultLocale, replace defaultLocale with targetLocale
-            // pathContent contains everything after the default locale (no leading slash if present)
-            return `import ${bindings} from ${quoteType}${patternHead}${targetLocale}${pathContent ? '/' + pathContent : ''}${quoteType}`;
+            return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+        }
+    }
+    return null; // Path doesn't match pattern
+}
+/**
+ * Main import path transformation function that delegates to specific scenarios
+ */
+function transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale) {
+    if (targetLocale === defaultLocale) {
+        return transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale);
+    }
+    else if (hideDefaultLocale) {
+        return transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale);
+    }
+    else {
+        return transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale);
+    }
+}
+/**
+ * AST-based transformation for MDX files using remark-mdx
+ */
+function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = []) {
+    const transformedImports = [];
+    if (!pattern.startsWith('/')) {
+        pattern = '/' + pattern;
+    }
+    const patternHead = pattern.split('[locale]')[0];
+    // Quick check: if the file doesn't contain the pattern, skip expensive AST parsing
+    // For default locale processing, we also need to check if content might need adjustment
+    if (targetLocale === defaultLocale) {
+        // For default locale files, we always need to check as we're looking for either:
+        // - paths without locale (when hideDefaultLocale=false)
+        // - paths with default locale (when hideDefaultLocale=true)
+        const patternWithoutSlash = patternHead.replace(/\/$/, '');
+        if (!mdxContent.includes(patternWithoutSlash)) {
+            return {
+                content: mdxContent,
+                hasChanges: false,
+                transformedImports: [],
+            };
+        }
+    }
+    else {
+        // For non-default locales, use the original logic
+        if (!mdxContent.includes(patternHead.replace(/\/$/, ''))) {
+            return {
+                content: mdxContent,
+                hasChanges: false,
+                transformedImports: [],
+            };
+        }
+    }
+    // Parse the MDX content into an AST
+    let processedAst;
+    try {
+        const parseProcessor = unified()
+            .use(remarkParse)
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx);
+        const ast = parseProcessor.parse(mdxContent);
+        processedAst = parseProcessor.runSync(ast);
+    }
+    catch (error) {
+        console.warn(`Failed to parse MDX content: ${error instanceof Error ? error.message : String(error)}`);
+        console.warn('Returning original content unchanged due to parsing error.');
+        return {
+            content: mdxContent,
+            hasChanges: false,
+            transformedImports: [],
+        };
+    }
+    // Visit only mdxjsEsm nodes (import/export statements)
+    visit(processedAst, 'mdxjsEsm', (node) => {
+        if (node.value && node.value.includes(patternHead.replace(/\/$/, ''))) {
+            // Find and transform import paths in the node value
+            const lines = node.value.split('\n');
+            const transformedLines = lines.map((line) => {
+                // Only process import lines that match our pattern
+                if (!line.trim().startsWith('import ')) {
+                    return line;
+                }
+                // Check if this line should be processed
+                if (!shouldProcessImportPath(line, patternHead, targetLocale, defaultLocale)) {
+                    return line;
+                }
+                // 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}`;
+                    let startIndex = line.indexOf(startPattern);
+                    // If pattern has trailing slash but path doesn't, try without slash
+                    if (startIndex === -1 && patternHead.endsWith('/')) {
+                        const patternWithoutSlash = patternHead.slice(0, -1);
+                        startPattern = `${quote}${patternWithoutSlash}`;
+                        startIndex = line.indexOf(startPattern);
+                    }
+                    if (startIndex === -1)
+                        continue;
+                    const pathStart = startIndex + 1; // After the quote
+                    const pathEnd = line.indexOf(quote, pathStart);
+                    if (pathEnd === -1)
+                        continue;
+                    const fullPath = line.slice(pathStart, pathEnd);
+                    // Transform the import path
+                    const newPath = transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale);
+                    if (!newPath) {
+                        continue; // No transformation needed
+                    }
+                    // Check exclusions
+                    if (isImportPathExcluded(fullPath, exclude, defaultLocale)) {
+                        continue;
+                    }
+                    // Apply the transformation
+                    transformedImports.push({ originalPath: fullPath, newPath });
+                    transformedLine =
+                        line.slice(0, pathStart) + newPath + line.slice(pathEnd);
+                    break;
+                }
+                return transformedLine;
+            });
+            node.value = transformedLines.join('\n');
         }
     });
-    return localizedFile;
+    // 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,
+        transformedImports,
+    };
+}
+/**
+ * AST-based transformation for MDX files only
+ */
+function localizeStaticImportsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
+exclude = [], isMarkdown = false) {
+    // Skip .md files entirely - they cannot have imports
+    if (isMarkdown) {
+        return file;
+    }
+    // For MDX files, use AST-based transformation
+    const result = transformMdxImports(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude);
+    return result.content;
 }

package/dist/utils/localizeStaticUrls.js

@@ -1,6 +1,12 @@
 import * as fs from 'fs';
 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;
 /**
  * Localizes static urls in content files.
@@ -24,147 +30,355 @@ export default async function localizeStaticUrls(settings) {
     const { resolvedPaths: sourceFiles } = settings.files;
     const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, settings.defaultLocale);
     // Process all file types at once with a single call
-    await Promise.all(Object.entries(fileMapping).map(async ([locale, filesMap]) => {
+    const processPromises = [];
+    // First, process default locale files (from source files)
+    // This is needed because they might not be in the fileMapping if they're not being translated
+    if (!fileMapping[settings.defaultLocale]) {
+        const defaultLocaleFiles = [];
+        // Collect all .md and .mdx files from sourceFiles
+        if (sourceFiles.md) {
+            defaultLocaleFiles.push(...sourceFiles.md);
+        }
+        if (sourceFiles.mdx) {
+            defaultLocaleFiles.push(...sourceFiles.mdx);
+        }
+        if (defaultLocaleFiles.length > 0) {
+            const defaultPromise = Promise.all(defaultLocaleFiles.map(async (filePath) => {
+                // Get file content
+                const fileContent = await fs.promises.readFile(filePath, 'utf8');
+                // Localize the file using default locale
+                const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
+                settings.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls);
+                // Write the localized file back to the same path
+                await fs.promises.writeFile(filePath, localizedFile);
+            }));
+            processPromises.push(defaultPromise);
+        }
+    }
+    // Then process all other locales from fileMapping
+    const mappingPromises = Object.entries(fileMapping).map(async ([locale, filesMap]) => {
         // Get all files that are md or mdx
         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) => {
             // Get file content
             const fileContent = await fs.promises.readFile(filePath, 'utf8');
-            // Localize the file
+            // Localize the file (handles both URLs and hrefs in single AST pass)
             const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls);
-            const localizedFileHrefs = localizeStaticHrefsForFile(localizedFile, settings.defaultLocale, locale, settings.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls);
             // Write the localized file to the target path
-            await fs.promises.writeFile(filePath, localizedFileHrefs);
+            await fs.promises.writeFile(filePath, localizedFile);
         }));
-    }));
+    });
+    processPromises.push(...mappingPromises);
+    await Promise.all(processPromises);
 }
-// Naive find and replace, in the future, construct an AST
-function localizeStaticUrlsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = []) {
-    if (!pattern.startsWith('/')) {
-        pattern = '/' + pattern;
+/**
+ * Determines if a URL should be processed based on pattern matching
+ */
+function shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale) {
+    const patternWithoutSlash = patternHead.replace(/\/$/, '');
+    if (targetLocale === defaultLocale) {
+        // For default locale processing, check if URL contains the pattern
+        return originalUrl.includes(patternWithoutSlash);
     }
-    // 1. Search for all instances of:
-    const patternHead = pattern.split('[locale]')[0];
-    // Escape special regex characters and remove trailing slash if present
-    const escapedPatternHead = patternHead
-        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-        .replace(/\/$/, '');
-    let regex;
+    else {
+        // For non-default locales, check if URL starts with pattern
+        return originalUrl.startsWith(patternWithoutSlash);
+    }
+}
+/**
+ * Checks if a URL should be excluded based on exclusion patterns
+ */
+function isUrlExcluded(originalUrl, exclude, defaultLocale) {
+    const excludePatterns = exclude.map((p) => p.replace(/\[locale\]/g, defaultLocale));
+    return excludePatterns.some((pattern) => isMatch(originalUrl, pattern));
+}
+/**
+ * Transforms URL for default locale processing
+ */
+function transformDefaultLocaleUrl(originalUrl, patternHead, defaultLocale, hideDefaultLocale) {
     if (hideDefaultLocale) {
-        // Match complete markdown links: `](/docs/...)` or `](/docs)`
-        regex = new RegExp(`\\]\\(${escapedPatternHead}(?:/([^)]*))?\\)`, 'g');
+        // Remove locale from URLs that have it: '/docs/en/file' -> '/docs/file'
+        if (originalUrl.includes(`/${defaultLocale}/`)) {
+            return originalUrl.replace(`/${defaultLocale}/`, '/');
+        }
+        else if (originalUrl.endsWith(`/${defaultLocale}`)) {
+            return originalUrl.replace(`/${defaultLocale}`, '');
+        }
+        return null; // URL doesn't have default locale
     }
     else {
-        // Match complete markdown links with default locale: `](/docs/${defaultLocale}/...)` or `](/docs/${defaultLocale})`
-        regex = new RegExp(`\\]\\(${escapedPatternHead}/${defaultLocale}(?:/([^)]*))?\\)`, 'g');
-    }
-    const matches = file.match(regex);
-    if (!matches) {
-        return file;
-    }
-    exclude = exclude.map((pattern) => pattern.replace(/\[locale\]/g, defaultLocale));
-    // 2. Replace the default locale with the target locale in all matched instances
-    const localizedFile = file.replace(regex, (match, pathContent) => {
-        if (exclude.length > 0) {
-            // Check if this path should be excluded from localization
-            let matchPath = '';
-            if (pathContent) {
-                matchPath = hideDefaultLocale
-                    ? `${patternHead}${pathContent}`
-                    : `${patternHead}${defaultLocale}/${pathContent}`;
+        // Add locale to URLs that don't have it: '/docs/file' -> '/docs/en/file'
+        if (originalUrl.includes(`/${defaultLocale}/`) ||
+            originalUrl.endsWith(`/${defaultLocale}`)) {
+            return null; // Already has default locale
+        }
+        if (originalUrl.startsWith(patternHead)) {
+            const pathAfterHead = originalUrl.slice(patternHead.length);
+            if (pathAfterHead) {
+                return `${patternHead}${defaultLocale}/${pathAfterHead}`;
             }
             else {
-                matchPath = hideDefaultLocale
-                    ? `${patternHead}`
-                    : `${patternHead}${defaultLocale}`;
-            }
-            if (exclude.some((pattern) => isMatch(matchPath, pattern))) {
-                return match; // Don't localize excluded paths
+                return `${patternHead.replace(/\/$/, '')}/${defaultLocale}`;
             }
         }
-        if (hideDefaultLocale) {
-            // For hideDefaultLocale, check if path already has target locale
-            if (pathContent) {
-                if (pathContent.startsWith(`${targetLocale}/`) ||
-                    pathContent === targetLocale) {
-                    return match; // Already localized
-                }
-            }
-            // Add target locale to the path
-            if (!pathContent || pathContent === '') {
-                return `](${patternHead}${targetLocale})`;
-            }
-            return `](${patternHead}${targetLocale}/${pathContent})`;
+        return null; // URL doesn't match pattern
+    }
+}
+/**
+ * Transforms URL for non-default locale processing with hideDefaultLocale=true
+ */
+function transformNonDefaultLocaleUrlWithHidden(originalUrl, patternHead, targetLocale, defaultLocale) {
+    // Check if already localized
+    if (originalUrl.startsWith(`${patternHead}${targetLocale}/`) ||
+        originalUrl === `${patternHead}${targetLocale}`) {
+        return null;
+    }
+    // Replace default locale with target locale
+    const expectedPathWithDefaultLocale = `${patternHead}${defaultLocale}`;
+    if (originalUrl.startsWith(`${expectedPathWithDefaultLocale}/`) ||
+        originalUrl === expectedPathWithDefaultLocale) {
+        return originalUrl.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
+    }
+    // Handle exact pattern match
+    if (originalUrl === patternHead.replace(/\/$/, '')) {
+        return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+    }
+    // Add target locale to URL without any locale
+    const pathAfterHead = originalUrl.slice(patternHead.length);
+    return pathAfterHead
+        ? `${patternHead}${targetLocale}/${pathAfterHead}`
+        : `${patternHead}${targetLocale}`;
+}
+/**
+ * Transforms URL for non-default locale processing with hideDefaultLocale=false
+ */
+function transformNonDefaultLocaleUrl(originalUrl, patternHead, targetLocale, defaultLocale) {
+    const expectedPathWithLocale = `${patternHead}${defaultLocale}`;
+    if (originalUrl.startsWith(`${expectedPathWithLocale}/`) ||
+        originalUrl === expectedPathWithLocale) {
+        // Replace existing default locale with target locale
+        return originalUrl.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
+    }
+    else if (originalUrl.startsWith(patternHead)) {
+        // Add target locale to URL that doesn't have any locale
+        const pathAfterHead = originalUrl.slice(patternHead.length);
+        if (pathAfterHead) {
+            return `${patternHead}${targetLocale}/${pathAfterHead}`;
         }
         else {
-            // For non-hideDefaultLocale, replace defaultLocale with targetLocale
-            // pathContent contains everything after the default locale (no leading slash if present)
-            const result = `](${patternHead}${targetLocale}${pathContent ? '/' + pathContent : ''})`;
-            return result;
+            return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
         }
-    });
-    return localizedFile;
+    }
+    return null; // URL doesn't match pattern
 }
-function localizeStaticHrefsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = []) {
+/**
+ * Main URL transformation function that delegates to specific scenarios
+ */
+function transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale) {
+    if (targetLocale === defaultLocale) {
+        return transformDefaultLocaleUrl(originalUrl, patternHead, defaultLocale, hideDefaultLocale);
+    }
+    else if (hideDefaultLocale) {
+        return transformNonDefaultLocaleUrlWithHidden(originalUrl, patternHead, targetLocale, defaultLocale);
+    }
+    else {
+        return transformNonDefaultLocaleUrl(originalUrl, patternHead, targetLocale, defaultLocale);
+    }
+}
+/**
+ * AST-based transformation for MDX files using remark-mdx
+ */
+function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = []) {
+    const transformedUrls = [];
     if (!pattern.startsWith('/')) {
         pattern = '/' + pattern;
     }
-    // 1. Search for all instances of:
     const patternHead = pattern.split('[locale]')[0];
-    // Escape special regex characters and remove trailing slash if present
-    const escapedPatternHead = patternHead
-        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-        .replace(/\/$/, '');
-    let regex;
-    if (hideDefaultLocale) {
-        // Match complete href attributes: `href="/docs/..."` or `href="/docs"`
-        regex = new RegExp(`href="${escapedPatternHead}(?:/([^"]*))?"`, 'g');
+    // Quick check: if the file doesn't contain the pattern, skip expensive AST parsing
+    // For default locale processing, we also need to check if content might need adjustment
+    if (targetLocale === defaultLocale) {
+        // For default locale files, we always need to check as we're looking for either:
+        // - paths without locale (when hideDefaultLocale=false)
+        // - paths with default locale (when hideDefaultLocale=true)
+        const patternWithoutSlash = patternHead.replace(/\/$/, '');
+        if (!mdxContent.includes(patternWithoutSlash)) {
+            return {
+                content: mdxContent,
+                hasChanges: false,
+                transformedUrls: [],
+            };
+        }
     }
     else {
-        // Match complete href attributes with default locale: `href="/docs/${defaultLocale}/..."` or `href="/docs/${defaultLocale}"`
-        regex = new RegExp(`href="${escapedPatternHead}/${defaultLocale}(?:/([^"]*))?"`, 'g');
-    }
-    const matches = file.match(regex);
-    if (!matches) {
-        return file;
-    }
-    exclude = exclude.map((pattern) => pattern.replace(/\[locale\]/g, defaultLocale));
-    // 2. Replace the default locale with the target locale in all matched instances
-    const localizedFile = file.replace(regex, (match, pathContent) => {
-        // Check if this path should be excluded from localization
-        if (exclude.length > 0) {
-            let matchPath = patternHead;
-            if (pathContent) {
-                matchPath = hideDefaultLocale
-                    ? `${patternHead}${pathContent}`
-                    : `${patternHead}${defaultLocale}/${pathContent}`;
+        // For non-default locales, use the original logic
+        if (!mdxContent.includes(patternHead.replace(/\/$/, ''))) {
+            return {
+                content: mdxContent,
+                hasChanges: false,
+                transformedUrls: [],
+            };
+        }
+    }
+    // Parse the MDX content into an AST
+    let processedAst;
+    try {
+        const parseProcessor = unified()
+            .use(remarkParse)
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx);
+        const ast = parseProcessor.parse(mdxContent);
+        processedAst = parseProcessor.runSync(ast);
+    }
+    catch (error) {
+        console.warn(`Failed to parse MDX content: ${error instanceof Error ? error.message : String(error)}`);
+        console.warn('Returning original content unchanged due to parsing error.');
+        return {
+            content: mdxContent,
+            hasChanges: false,
+            transformedUrls: [],
+        };
+    }
+    // Helper function to transform URL based on pattern
+    const transformUrl = (originalUrl, linkType) => {
+        // Check if URL should be processed
+        if (!shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale)) {
+            return null;
+        }
+        // Transform the URL based on locale and configuration
+        const newUrl = transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale);
+        if (!newUrl) {
+            return null;
+        }
+        // Check exclusions
+        if (isUrlExcluded(originalUrl, exclude, defaultLocale)) {
+            return null;
+        }
+        transformedUrls.push({
+            originalPath: originalUrl,
+            newPath: newUrl,
+            type: linkType,
+        });
+        return newUrl;
+    };
+    // Visit markdown link nodes: [text](url)
+    visit(processedAst, 'link', (node) => {
+        if (node.url) {
+            const newUrl = transformUrl(node.url, 'markdown');
+            if (newUrl) {
+                node.url = newUrl;
             }
-            if (exclude.some((pattern) => isMatch(matchPath, pattern))) {
-                return match; // Don't localize excluded paths
+        }
+    });
+    // Visit JSX/HTML elements for href attributes: <a href="url"> or <Card href="url">
+    visit(processedAst, ['mdxJsxFlowElement', 'mdxJsxTextElement'], (node) => {
+        const jsxNode = node;
+        if (jsxNode.attributes) {
+            for (const attr of jsxNode.attributes) {
+                if (attr.type === 'mdxJsxAttribute' &&
+                    attr.name === 'href' &&
+                    attr.value) {
+                    // Handle MdxJsxAttribute with string or MdxJsxAttributeValueExpression
+                    const hrefValue = typeof attr.value === 'string' ? attr.value : attr.value.value;
+                    if (typeof hrefValue === 'string') {
+                        const newUrl = transformUrl(hrefValue, 'href');
+                        if (newUrl) {
+                            if (typeof attr.value === 'string') {
+                                attr.value = newUrl;
+                            }
+                            else {
+                                attr.value.value = newUrl;
+                            }
+                        }
+                    }
+                }
             }
         }
-        if (hideDefaultLocale) {
-            // For hideDefaultLocale, check if path already has target locale
-            if (pathContent) {
-                if (pathContent.startsWith(`${targetLocale}/`) ||
-                    pathContent === targetLocale) {
-                    return match; // Already localized
+    });
+    // Visit raw JSX nodes for href attributes in JSX strings
+    visit(processedAst, 'jsx', (node) => {
+        if (node.value && typeof node.value === 'string') {
+            const jsxContent = node.value;
+            // Use regex to find href attributes in the JSX string
+            const hrefRegex = /href\s*=\s*["']([^"']+)["']/g;
+            let match;
+            const replacements = [];
+            // Reset regex lastIndex to avoid issues with global flag
+            hrefRegex.lastIndex = 0;
+            while ((match = hrefRegex.exec(jsxContent)) !== null) {
+                const originalHref = match[1];
+                const newUrl = transformUrl(originalHref, 'href');
+                if (newUrl) {
+                    // Store replacement info
+                    const oldHrefAttr = match[0]; // The full match like 'href="/quickstart"'
+                    const quote = oldHrefAttr.includes('"') ? '"' : "'";
+                    const newHrefAttr = `href=${quote}${newUrl}${quote}`;
+                    replacements.push({
+                        start: match.index,
+                        end: match.index + oldHrefAttr.length,
+                        oldHrefAttr,
+                        newHrefAttr,
+                    });
                 }
             }
-            // Add target locale to the path
-            if (!pathContent || pathContent === '') {
-                return `href="${patternHead}${targetLocale}"`;
+            // Apply replacements in reverse order (from end to start) to avoid position shifts
+            if (replacements.length > 0) {
+                let newJsxContent = jsxContent;
+                replacements
+                    .sort((a, b) => b.start - a.start)
+                    .forEach(({ start, end, newHrefAttr }) => {
+                    newJsxContent =
+                        newJsxContent.slice(0, start) +
+                            newHrefAttr +
+                            newJsxContent.slice(end);
+                });
+                node.value = newJsxContent;
             }
-            return `href="${patternHead}${targetLocale}/${pathContent}"`;
-        }
-        else {
-            // For non-hideDefaultLocale, replace defaultLocale with targetLocale
-            // pathContent contains everything after the default locale (no leading slash if present)
-            return `href="${patternHead}${targetLocale}${pathContent ? '/' + pathContent : ''}"`;
         }
     });
-    return localizedFile;
+    // Convert the modified AST back to MDX string
+    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);
+    }
+    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,
+            transformedUrls: [],
+        };
+    }
+    // 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: transformedUrls.length > 0,
+        transformedUrls,
+    };
+}
+// AST-based transformation for MDX files using remark
+function localizeStaticUrlsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
+exclude = []) {
+    // Use AST-based transformation for MDX files
+    const result = transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude);
+    return result.content;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -94,8 +94,14 @@
     "micromatch": "^4.0.8",
     "open": "^10.1.1",
     "ora": "^8.2.0",
+    "remark-frontmatter": "^5.0.0",
+    "remark-mdx": "^3.1.0",
+    "remark-parse": "^11.0.0",
+    "remark-stringify": "^11.0.0",
     "resolve": "^1.22.10",
     "tsconfig-paths": "^4.2.0",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0"
   },
   "devDependencies": {
@@ -109,6 +115,7 @@
     "@types/resolve": "^1.20.2",
     "eslint": "^9.20.0",
     "esm": "^3.2.25",
+    "mdast": "^3.0.0",
     "prettier": "^3.4.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.5.4"