gtx-cli 2.6.29 → 2.6.30-alpha.0

package/dist/utils/packageManager.js

@@ -1,269 +0,0 @@
-// 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/parse/needsCJS.d.ts

@@ -1,20 +0,0 @@
-import { ParseResult } from '@babel/parser';
-import * as t from '@babel/types';
-/**
- * Given an AST determines if the file needs to be compiled as CommonJS or ESM.
- * @param ast - The AST to analyze
- * @returns True if the file needs to be compiled as CommonJS, false if it needs to be compiled as ESM
- */
-export declare function needsCJS({ ast, warnings, filepath, packageJson, tsconfigJson, }: {
-    ast: ParseResult<t.File>;
-    warnings: string[];
-    filepath: string;
-    packageJson?: {
-        type?: string;
-    };
-    tsconfigJson?: {
-        compilerOptions?: {
-            module?: string;
-        };
-    };
-}): boolean;

package/dist/utils/parse/needsCJS.js

@@ -1,72 +0,0 @@
-import traverseModule from '@babel/traverse';
-import * as t from '@babel/types';
-// Handle CommonJS/ESM interop
-const traverse = traverseModule.default || traverseModule;
-/**
- * Given an AST determines if the file needs to be compiled as CommonJS or ESM.
- * @param ast - The AST to analyze
- * @returns True if the file needs to be compiled as CommonJS, false if it needs to be compiled as ESM
- */
-export function needsCJS({ ast, warnings, filepath, packageJson, tsconfigJson, }) {
-    // Analyze the actual file content to determine module system
-    let hasES6Imports = false;
-    let hasCommonJSRequire = false;
-    traverse(ast, {
-        ImportDeclaration() {
-            hasES6Imports = true;
-        },
-        CallExpression(path) {
-            if (t.isIdentifier(path.node.callee, { name: 'require' })) {
-                hasCommonJSRequire = true;
-            }
-        },
-    });
-    // Determine if we need CommonJS based on actual file content and fallback to config-based logic
-    let needsCJS = false;
-    if (hasES6Imports && !hasCommonJSRequire) {
-        // File uses ES6 imports, so we should use ES6 imports
-        needsCJS = false;
-    }
-    else if (hasCommonJSRequire && !hasES6Imports) {
-        // File uses CommonJS require, so we should use CommonJS require
-        needsCJS = true;
-    }
-    else if (hasES6Imports && hasCommonJSRequire) {
-        // Mixed usage - this is unusual but we'll default to ES6 imports
-        warnings.push(`Mixed ES6 imports and CommonJS require detected in ${filepath}. Defaulting to ES6 imports.`);
-        needsCJS = false;
-    }
-    else {
-        // No imports/requires found, fall back to configuration-based logic
-        if (filepath.endsWith('.ts') || filepath.endsWith('.tsx')) {
-            // For TypeScript files, check tsconfig.json compilerOptions.module
-            const moduleSetting = tsconfigJson?.compilerOptions?.module;
-            if (moduleSetting === 'commonjs' || moduleSetting === 'node') {
-                needsCJS = true;
-            }
-            else if (moduleSetting === 'esnext' ||
-                moduleSetting === 'es2022' ||
-                moduleSetting === 'es2020' ||
-                moduleSetting === 'es2015' ||
-                moduleSetting === 'es6' ||
-                moduleSetting === 'node16' ||
-                moduleSetting === 'nodenext') {
-                needsCJS = false;
-            }
-            else {
-                // Default to ESM for TypeScript files if no module setting is specified
-                needsCJS = false;
-            }
-        }
-        else if (filepath.endsWith('.js')) {
-            // For JavaScript files, check package.json type
-            // If package.json has "type": "module", .js files are treated as ES modules
-            needsCJS = packageJson?.type !== 'module';
-        }
-        else {
-            // For other file extensions, default to ESM
-            needsCJS = false;
-        }
-    }
-    return needsCJS;
-}

package/dist/utils/persistPostprocessHashes.d.ts

@@ -1,12 +0,0 @@
-import type { Settings } from '../types/index.js';
-type DownloadMeta = {
-    branchId: string;
-    fileId: string;
-    versionId: string;
-    locale: string;
-};
-/**
- * Persist postprocessed content hashes for recently downloaded files into gt-lock.json.
- */
-export declare function persistPostProcessHashes(settings: Settings, includeFiles: Set<string> | undefined, downloadedMeta: Map<string, DownloadMeta>): void;
-export {};

package/dist/utils/persistPostprocessHashes.js

@@ -1,39 +0,0 @@
-import * as fs from 'node:fs';
-import { ensureNestedObject, getDownloadedVersions, saveDownloadedVersions, } from '../fs/config/downloadedVersions.js';
-import { hashStringSync } from './hash.js';
-/**
- * Persist postprocessed content hashes for recently downloaded files into gt-lock.json.
- */
-export function persistPostProcessHashes(settings, includeFiles, downloadedMeta) {
-    if (!includeFiles || includeFiles.size === 0 || downloadedMeta.size === 0) {
-        return;
-    }
-    const downloadedVersions = getDownloadedVersions(settings.configDirectory);
-    let lockUpdated = false;
-    for (const filePath of includeFiles) {
-        const meta = downloadedMeta.get(filePath);
-        if (!meta)
-            continue;
-        if (!fs.existsSync(filePath))
-            continue;
-        const content = fs.readFileSync(filePath, 'utf8');
-        const hash = hashStringSync(content);
-        ensureNestedObject(downloadedVersions.entries, [
-            meta.branchId,
-            meta.fileId,
-            meta.versionId,
-            meta.locale,
-        ]);
-        const existing = downloadedVersions.entries[meta.branchId][meta.fileId][meta.versionId][meta.locale] || {};
-        if (existing.postProcessHash !== hash) {
-            downloadedVersions.entries[meta.branchId][meta.fileId][meta.versionId][meta.locale] = {
-                ...existing,
-                postProcessHash: hash,
-            };
-            lockUpdated = true;
-        }
-    }
-    if (lockUpdated) {
-        saveDownloadedVersions(settings.configDirectory, downloadedVersions);
-    }
-}

package/dist/utils/processAnchorIds.d.ts

@@ -1,6 +0,0 @@
-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, includeFiles?: Set<string>): Promise<void>;

package/dist/utils/processAnchorIds.js

@@ -1,56 +0,0 @@
-import { addExplicitAnchorIds, extractHeadingInfo, } from './addExplicitAnchorIds.js';
-import { getRelative, 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, includeFiles) {
-    if (!settings.files)
-        return;
-    const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
-    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
-    const sourceTypeByPath = new Map();
-    if (resolvedPaths.md) {
-        for (const filePath of resolvedPaths.md) {
-            sourceTypeByPath.set(getRelative(filePath), 'md');
-        }
-    }
-    if (resolvedPaths.mdx) {
-        for (const filePath of resolvedPaths.mdx) {
-            sourceTypeByPath.set(getRelative(filePath), 'mdx');
-        }
-    }
-    // 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 whose sources are md or mdx
-        const mdFiles = Object.entries(filesMap).filter(([sourcePath, translatedPath]) => translatedPath &&
-            sourceTypeByPath.has(sourcePath) &&
-            (!includeFiles || includeFiles.has(translatedPath)));
-        for (const [sourcePath, translatedPath] of mdFiles) {
-            try {
-                // Check if translated file exists before processing
-                if (!fs.existsSync(translatedPath)) {
-                    continue;
-                }
-                // Extract heading info from source file
-                const sourceContent = readFile(sourcePath);
-                const sourceHeadingMap = extractHeadingInfo(sourceContent);
-                const fileTypeHint = sourceTypeByPath.get(sourcePath);
-                // Read translated file and apply anchor IDs
-                const translatedContent = readFile(translatedPath);
-                const result = addExplicitAnchorIds(translatedContent, sourceHeadingMap, settings, sourcePath, translatedPath, fileTypeHint);
-                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/processOpenApi.d.ts

@@ -1,8 +0,0 @@
-import { Settings } from '../types/index.js';
-/**
- * Postprocess Mintlify OpenAPI references to point to locale-specific spec files.
- * - Uses openapi.files (ordered) to resolve ambiguities (first match wins).
- * - Relies on the user's json transform rules for locale paths.
- * - Warns on missing/ambiguous references but keeps behavior deterministic.
- */
-export default function processOpenApi(settings: Settings, includeFiles?: Set<string>): Promise<void>;