gtx-cli 2.3.6-alpha.2 → 2.3.6

package/dist/utils/packageManager.js

@@ -0,0 +1,269 @@
+// This file is MIT licensed and was adapted from https://github.com/getsentry/sentry-wizard/blob/master/src/utils/package-manager.ts and https://github.com/getsentry/sentry-wizard/blob/master/src/utils/clack/index.ts
+import * as fs from 'fs';
+import * as path from 'path';
+import { getPackageJson, updatePackageJson } from './packageJson.js';
+import { promptSelect } from '../console/logging.js';
+export class NoPackageManagerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NoPackageManagerError';
+    }
+}
+export const BUN = {
+    id: 'bun',
+    name: 'bun',
+    label: 'Bun',
+    installCommand: 'add',
+    installAllCommand: 'bun install',
+    buildCommand: 'bun run build',
+    runScriptCommand: 'bun run',
+    flags: '',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--dev',
+    detect: (cwd) => ['bun.lockb', 'bun.lock'].some((lockFile) => {
+        try {
+            return fs.existsSync(path.join(cwd, lockFile));
+        }
+        catch (e) {
+            return false;
+        }
+    }),
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const overrides = packageDotJson.overrides || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            overrides: {
+                ...overrides,
+                [pkgName]: pkgVersion,
+            },
+        });
+    },
+};
+export const DENO = {
+    id: 'deno',
+    name: 'deno',
+    label: 'Deno',
+    installCommand: 'install',
+    installAllCommand: 'deno install',
+    buildCommand: 'deno task build',
+    runScriptCommand: 'deno task',
+    flags: '',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--dev',
+    registry: 'npm',
+    detect: (cwd) => {
+        try {
+            return fs.existsSync(path.join(cwd, 'deno.lock'));
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const overrides = packageDotJson.overrides || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            overrides: {
+                ...overrides,
+                [pkgName]: pkgVersion,
+            },
+        });
+    },
+};
+export const YARN_V1 = {
+    id: 'yarn_v1',
+    name: 'yarn',
+    label: 'Yarn V1',
+    installCommand: 'add',
+    installAllCommand: 'yarn install',
+    buildCommand: 'yarn build',
+    runScriptCommand: 'yarn',
+    flags: '--ignore-workspace-root-check',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--dev',
+    detect: (cwd) => {
+        try {
+            return fs
+                .readFileSync(path.join(cwd, 'yarn.lock'), 'utf-8')
+                .slice(0, 500)
+                .includes('yarn lockfile v1');
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const resolutions = packageDotJson.resolutions || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            resolutions: {
+                ...resolutions,
+                [pkgName]: pkgVersion,
+            },
+        });
+    },
+};
+/** YARN V2/3/4 */
+export const YARN_V2 = {
+    id: 'yarn_v2',
+    name: 'yarn',
+    label: 'Yarn V2/3/4',
+    installCommand: 'add',
+    installAllCommand: 'yarn install',
+    buildCommand: 'yarn build',
+    runScriptCommand: 'yarn',
+    flags: '',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--dev',
+    detect: (cwd) => {
+        try {
+            return fs
+                .readFileSync(path.join(cwd, 'yarn.lock'), 'utf-8')
+                .slice(0, 500)
+                .includes('__metadata');
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const resolutions = packageDotJson.resolutions || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            resolutions: {
+                ...resolutions,
+                [pkgName]: pkgVersion,
+            },
+        });
+    },
+};
+export const PNPM = {
+    id: 'pnpm',
+    name: 'pnpm',
+    label: 'PNPM',
+    installCommand: 'add',
+    installAllCommand: 'pnpm install',
+    buildCommand: 'pnpm build',
+    runScriptCommand: 'pnpm',
+    flags: '--ignore-workspace-root-check',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--save-dev',
+    detect: (cwd) => {
+        try {
+            return fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'));
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const pnpm = packageDotJson.pnpm || {};
+        const overrides = pnpm.overrides || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            pnpm: {
+                ...pnpm,
+                overrides: {
+                    ...overrides,
+                    [pkgName]: pkgVersion,
+                },
+            },
+        });
+    },
+};
+export const NPM = {
+    id: 'npm',
+    name: 'npm',
+    label: 'NPM',
+    installCommand: 'install',
+    installAllCommand: 'npm ci',
+    buildCommand: 'npm run build',
+    runScriptCommand: 'npm run',
+    flags: '',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--save-dev',
+    detect: (cwd) => {
+        try {
+            return fs.existsSync(path.join(cwd, 'package-lock.json'));
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const overrides = packageDotJson.overrides || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            overrides: {
+                ...overrides,
+                [pkgName]: pkgVersion,
+            },
+        });
+    },
+};
+export const packageManagers = [NPM, YARN_V1, YARN_V2, PNPM, BUN, DENO];
+export function _detectPackageManger(cwd) {
+    const foundPackageMangers = packageManagers.filter((packageManager) => packageManager.detect(cwd));
+    // Only consider a package manager detected if we found exactly one.
+    // If we find more than one, we should not make any assumptions.
+    if (foundPackageMangers.length === 1) {
+        return foundPackageMangers[0];
+    }
+    return null;
+}
+// Get the package manager for the current project
+// Uses a global cache to avoid prompting the user multiple times
+export async function getPackageManager(cwd = process.cwd(), specifiedPackageManager, errorIfNotFound = false) {
+    const globalWizard = global;
+    if (globalWizard._gt_wizard_cached_package_manager) {
+        return globalWizard._gt_wizard_cached_package_manager;
+    }
+    if (specifiedPackageManager) {
+        const packageManager = packageManagers.find((packageManager) => packageManager.id === specifiedPackageManager);
+        if (packageManager) {
+            globalWizard._gt_wizard_cached_package_manager = packageManager;
+            return packageManager;
+        }
+    }
+    const detectedPackageManager = _detectPackageManger(cwd);
+    if (detectedPackageManager) {
+        globalWizard._gt_wizard_cached_package_manager = detectedPackageManager;
+        return detectedPackageManager;
+    }
+    if (errorIfNotFound) {
+        throw new NoPackageManagerError('No package manager found');
+    }
+    const selectedPackageManager = await promptSelect({
+        message: 'Please select your package manager.',
+        options: packageManagers.map((packageManager) => ({
+            value: packageManager,
+            label: packageManager.label,
+        })),
+    });
+    globalWizard._gt_wizard_cached_package_manager = selectedPackageManager;
+    return selectedPackageManager;
+}

package/dist/utils/processAnchorIds.d.ts

@@ -0,0 +1,6 @@
+import { Settings } from '../types/index.js';
+/**
+ * Processes all translated MD/MDX files to add explicit anchor IDs
+ * This preserves navigation links when headings are translated
+ */
+export default function processAnchorIds(settings: Settings): Promise<void>;

package/dist/utils/processAnchorIds.js

@@ -0,0 +1,47 @@
+import { addExplicitAnchorIds, extractHeadingInfo, } from './addExplicitAnchorIds.js';
+import { readFile } from '../fs/findFilepath.js';
+import { createFileMapping } from '../formats/files/fileMapping.js';
+import * as fs from 'fs';
+/**
+ * Processes all translated MD/MDX files to add explicit anchor IDs
+ * This preserves navigation links when headings are translated
+ */
+export default async function processAnchorIds(settings) {
+    if (!settings.files)
+        return;
+    const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
+    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
+    // Process each locale's translated files
+    const processPromises = Object.entries(fileMapping)
+        .filter(([locale, filesMap]) => locale !== settings.defaultLocale) // Skip default locale
+        .map(async ([locale, filesMap]) => {
+        // Get all translated files that are md or mdx
+        const translatedFiles = Object.values(filesMap).filter((path) => path && (path.endsWith('.md') || path.endsWith('.mdx')));
+        for (const translatedPath of translatedFiles) {
+            try {
+                // Check if translated file exists before processing
+                if (!fs.existsSync(translatedPath)) {
+                    continue;
+                }
+                // Find the corresponding source file
+                const sourcePath = Object.keys(filesMap).find((key) => filesMap[key] === translatedPath);
+                if (!sourcePath) {
+                    continue;
+                }
+                // Extract heading info from source file
+                const sourceContent = readFile(sourcePath);
+                const sourceHeadingMap = extractHeadingInfo(sourceContent);
+                // Read translated file and apply anchor IDs
+                const translatedContent = readFile(translatedPath);
+                const result = addExplicitAnchorIds(translatedContent, sourceHeadingMap, settings, sourcePath, translatedPath);
+                if (result.hasChanges) {
+                    fs.writeFileSync(translatedPath, result.content, 'utf8');
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to process IDs for ${translatedPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    });
+    await Promise.all(processPromises);
+}

package/dist/utils/sanitizeFileContent.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Processes content to escape curl commands within tick marks and existing escape strings
+ * @param content - The content to process
+ * @returns the processed content with escaped curl commands
+ */
+export default function sanitizeFileContent(content: string): string;

package/dist/utils/sanitizeFileContent.js

@@ -0,0 +1,29 @@
+/**
+ * Processes content to escape curl commands within tick marks and existing escape strings
+ * @param content - The content to process
+ * @returns the processed content with escaped curl commands
+ */
+export default function sanitizeFileContent(content) {
+    const ESCAPE_STRING = '_GT_INTERNAL_ESCAPE';
+    const allTickMarkRegex = /`([^`]*)`/g;
+    let processedContent = content;
+    // First, escape any existing tick marks followed by _GT_INTERNAL_ESCAPE
+    // This protects pre-existing escapes
+    processedContent = processedContent.replace(new RegExp('`' + ESCAPE_STRING, 'g'), '`' + ESCAPE_STRING + ESCAPE_STRING);
+    // Then find ALL tick mark pairs and process them individually
+    // This approach is more reliable than negative lookahead with modified content
+    processedContent = processedContent.replace(allTickMarkRegex, (match, innerContent) => {
+        // Skip if this already starts with our escape string (protected or already processed)
+        if (innerContent.startsWith(ESCAPE_STRING)) {
+            return match;
+        }
+        // Check if the content contains a curl command
+        if (/\bcurl\b/i.test(innerContent)) {
+            // Insert escape string after opening tick
+            return '`' + ESCAPE_STRING + innerContent + '`';
+        }
+        // Return original match if no curl command found
+        return match;
+    });
+    return processedContent;
+}

package/dist/utils/validateMdx.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Validates if an MDX file content can be parsed as a valid AST
+ * @param content - The MDX file content to validate
+ * @param filePath - The file path for error reporting
+ * @returns object with isValid boolean and optional error message
+ */
+export declare function isValidMdx(content: string, filePath: string): {
+    isValid: boolean;
+    error?: string;
+};

package/dist/utils/validateMdx.js

@@ -0,0 +1,25 @@
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkMdx from 'remark-mdx';
+import remarkFrontmatter from 'remark-frontmatter';
+/**
+ * Validates if an MDX file content can be parsed as a valid AST
+ * @param content - The MDX file content to validate
+ * @param filePath - The file path for error reporting
+ * @returns object with isValid boolean and optional error message
+ */
+export function isValidMdx(content, filePath) {
+    try {
+        const parseProcessor = unified()
+            .use(remarkParse)
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx);
+        const ast = parseProcessor.parse(content);
+        parseProcessor.runSync(ast);
+        return { isValid: true };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { isValid: false, error: errorMessage };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.3.6-alpha.2",
+  "version": "2.3.6",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -91,7 +91,7 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "generaltranslation": "7.6.4-alpha.1"
+    "generaltranslation": "7.6.4"
   },
   "devDependencies": {
     "@babel/types": "^7.28.4",
@@ -116,7 +116,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "build:clean": "rm -rf dist; pnpm run build",
+    "build:clean": "sh ../../scripts/clean.sh && pnpm run build",
     "build:release": "pnpm run build:clean",
     "lint": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\"",
     "lint:fix": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\" --fix",