gt 0.10.0 → 2.7.0

package/dist/cli/base.js

@@ -0,0 +1,529 @@
+import { createOrUpdateConfig } from '../fs/config/setupConfig.js';
+import findFilepath from '../fs/findFilepath.js';
+import { displayHeader, promptText, logErrorAndExit, promptConfirm, promptMultiSelect, promptSelect, } from '../console/logging.js';
+import { logger } from '../console/logger.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import { generateSettings } from '../config/generateSettings.js';
+import chalk from 'chalk';
+import { FILE_EXT_TO_EXT_LABEL } from '../formats/files/supportedFiles.js';
+import { handleSetupReactCommand } from '../setup/wizard.js';
+import { isPackageInstalled, searchForPackageJson, } from '../utils/packageJson.js';
+import { getDesiredLocales } from '../setup/userInput.js';
+import { installPackage } from '../utils/installPackage.js';
+import { getPackageManager } from '../utils/packageManager.js';
+import { retrieveCredentials, setCredentials } from '../utils/credentials.js';
+import { areCredentialsSet } from '../utils/credentials.js';
+import { upload } from './commands/upload.js';
+import { attachSharedFlags, attachTranslateFlags } from './flags.js';
+import { handleStage } from './commands/stage.js';
+import { handleSetupProject } from './commands/setupProject.js';
+import { handleDownload } from './commands/download.js';
+import { handleTranslate, postProcessTranslations, } from './commands/translate.js';
+import { getDownloaded, clearDownloaded } from '../state/recentDownloads.js';
+import { clearWarnings } from '../state/translateWarnings.js';
+import { displayTranslateSummary } from '../console/displayTranslateSummary.js';
+import updateConfig from '../fs/config/updateConfig.js';
+import { createLoadTranslationsFile } from '../fs/createLoadTranslationsFile.js';
+import { saveLocalEdits } from '../api/saveLocalEdits.js';
+import processSharedStaticAssets, { mirrorAssetsToLocales, } from '../utils/sharedStaticAssets.js';
+import { setupLocadex } from '../locadex/setupFlow.js';
+import { detectFramework } from '../setup/detectFramework.js';
+import { getFrameworkDisplayName, getReactFrameworkLibrary, } from '../setup/frameworkUtils.js';
+import { findAgentFiles, findAgentFilesWithInstructions, hasCursorRulesDir, CURSOR_GT_RULES_FILE, getAgentInstructions, appendAgentInstructions, } from '../setup/agentInstructions.js';
+import { determineLibrary } from '../fs/determineFramework.js';
+import { INLINE_LIBRARIES } from '../types/libraries.js';
+import { handleEnqueue } from './commands/enqueue.js';
+export class BaseCLI {
+    library;
+    additionalModules;
+    program;
+    // Constructor is shared amongst all CLI class types
+    constructor(program, library, additionalModules) {
+        this.program = program;
+        this.library = library;
+        this.additionalModules = additionalModules || [];
+        this.setupInitCommand();
+        this.setupConfigureCommand();
+        this.setupUploadCommand();
+        this.setupLoginCommand();
+        this.setupSendDiffsCommand();
+        this.setupUpdateInstructionsCommand();
+    }
+    // Init is never called in a child class
+    init() {
+        this.setupSetupProjectCommand();
+        this.setupStageCommand();
+        this.setupTranslateCommand();
+        this.setupDownloadCommand();
+        this.setupEnqueueCommand();
+    }
+    // Execute is called by the main program
+    execute() {
+        // If no command is specified, run 'init'
+        if (process.argv.length <= 2) {
+            process.argv.push('init');
+        }
+    }
+    setupSetupProjectCommand() {
+        attachTranslateFlags(this.program
+            .command('setup')
+            .description('Upload source files and setup the project for translation')).action(async (initOptions) => {
+            displayHeader('Uploading source files and setting up project...');
+            await this.handleSetupProject(initOptions);
+            logger.endCommand('Done!');
+        });
+    }
+    setupStageCommand() {
+        attachTranslateFlags(this.program
+            .command('stage')
+            .description('Submits the project to the General Translation API for translation. Translations created using this command will require human approval.')).action(async (initOptions) => {
+            displayHeader('Staging project for translation with approval required...');
+            await this.handleStage(initOptions);
+            logger.endCommand('Done!');
+        });
+    }
+    /**
+     * Enqueues translations for a given set of files
+     * @param initOptions - The options for the command
+     * @returns The results of the command
+     */
+    setupEnqueueCommand() {
+        attachTranslateFlags(this.program
+            .command('enqueue')
+            .description('Enqueues translations for a given set of files')).action(async (initOptions) => {
+            displayHeader('Enqueuing translations...');
+            await this.handleEnqueue(initOptions);
+            logger.endCommand('Done!');
+        });
+    }
+    /**
+     * Downloads translations that were originally staged
+     * @param initOptions - The options for the command
+     * @returns The results of the command
+     */
+    setupDownloadCommand() {
+        attachTranslateFlags(this.program
+            .command('download')
+            .description('Download translations that were originally staged')).action(async (initOptions) => {
+            displayHeader('Downloading translations...');
+            await this.handleDownload(initOptions);
+            logger.endCommand('Done!');
+        });
+    }
+    setupTranslateCommand() {
+        attachTranslateFlags(this.program
+            .command('translate')
+            .description('Translate your project using General Translation')).action(async (initOptions) => {
+            displayHeader('Starting translation...');
+            await this.handleTranslate(initOptions);
+            logger.endCommand('Done!');
+        });
+    }
+    setupSendDiffsCommand() {
+        attachSharedFlags(this.program
+            .command('save-local')
+            .description('Save local edits for all configured files by sending diffs (no translation enqueued)')).action(async (initOptions) => {
+            displayHeader('Saving local edits...');
+            const settings = await generateSettings(initOptions);
+            await saveLocalEdits(settings);
+            logger.endCommand('Saved local edits');
+        });
+    }
+    async handleSetupProject(initOptions) {
+        const settings = await generateSettings(initOptions);
+        // Preprocess shared static assets if configured (move + rewrite sources)
+        await processSharedStaticAssets(settings);
+        await handleSetupProject(initOptions, settings, this.library);
+    }
+    async handleStage(initOptions) {
+        const settings = await generateSettings(initOptions);
+        // Preprocess shared static assets if configured (move + rewrite sources)
+        await processSharedStaticAssets(settings);
+        if (!settings.stageTranslations) {
+            // Update settings.stageTranslations to true
+            settings.stageTranslations = true;
+            await updateConfig(settings.config, {
+                stageTranslations: true,
+            });
+        }
+        await handleStage(initOptions, settings, this.library, true);
+    }
+    /**
+     * Enqueues translations for a given set of files
+     * @param initOptions - The options for the command
+     * @returns The results of the command
+     */
+    async handleEnqueue(initOptions) {
+        const settings = await generateSettings(initOptions);
+        await handleEnqueue(initOptions, settings, this.library);
+    }
+    /**
+     * Downloads translations that were originally staged
+     * @param initOptions - The options for the command
+     * @returns The results of the command
+     */
+    async handleDownload(initOptions) {
+        const settings = await generateSettings(initOptions);
+        await handleDownload(initOptions, settings, this.library);
+    }
+    async handleTranslate(initOptions) {
+        const settings = await generateSettings(initOptions);
+        // Preprocess shared static assets if configured (move + rewrite sources)
+        await processSharedStaticAssets(settings);
+        if (!settings.stageTranslations) {
+            const results = await handleStage(initOptions, settings, this.library, false);
+            if (results) {
+                await handleTranslate(initOptions, settings, results.fileVersionData, results.jobData, results.branchData);
+            }
+        }
+        else {
+            await handleDownload(initOptions, settings, this.library);
+        }
+        // Only postprocess files downloaded in this run
+        const include = getDownloaded();
+        if (include.size > 0) {
+            await postProcessTranslations(settings, include);
+        }
+        // Mirror assets after translations are downloaded and locale dirs are populated
+        await mirrorAssetsToLocales(settings);
+        clearDownloaded();
+        displayTranslateSummary();
+        clearWarnings();
+    }
+    setupUploadCommand() {
+        attachTranslateFlags(this.program
+            .command('upload')
+            .description('Upload source files and translations to the General Translation platform')).action(async (initOptions) => {
+            displayHeader('Starting upload...');
+            const settings = await generateSettings(initOptions);
+            const options = { ...initOptions, ...settings };
+            await this.handleUploadCommand(options);
+            logger.endCommand('Done!');
+        });
+    }
+    setupLoginCommand() {
+        this.program
+            .command('auth')
+            .description('Generate a General Translation API key and project ID')
+            .option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', findFilepath(['gt.config.json']))
+            .option('-t, --key-type <type>', 'Type of key to generate, production | development')
+            .action(async (options) => {
+            displayHeader('Authenticating with General Translation...');
+            if (!options.keyType) {
+                const packageJson = await searchForPackageJson();
+                if (packageJson &&
+                    INLINE_LIBRARIES.some((lib) => isPackageInstalled(lib, packageJson))) {
+                    options.keyType = 'development';
+                }
+                else {
+                    options.keyType = 'production';
+                }
+            }
+            else {
+                if (options.keyType !== 'development' &&
+                    options.keyType !== 'production') {
+                    logErrorAndExit('Invalid key type, must be development or production');
+                }
+            }
+            await this.handleLoginCommand(options);
+            logger.endCommand(`Done! A ${options.keyType} key has been generated and saved to your .env.local file.`);
+        });
+    }
+    setupInitCommand() {
+        this.program
+            .command('init')
+            .description('Run the setup wizard to configure your project for General Translation')
+            .option('--src <paths...>', "Space-separated list of glob patterns containing the app's source code, by default 'src/**/*.{js,jsx,ts,tsx}' 'app/**/*.{js,jsx,ts,tsx}' 'pages/**/*.{js,jsx,ts,tsx}' 'components/**/*.{js,jsx,ts,tsx}'")
+            .option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', findFilepath(['gt.config.json']))
+            .action(async (options) => {
+            const settings = await generateSettings(options);
+            displayHeader('Running setup wizard...');
+            const framework = await detectFramework();
+            const useAgent = await (async () => {
+                let useAgentMessage;
+                if (framework.name === 'mintlify') {
+                    useAgentMessage = `Mintlify project detected. Would you like to connect to GitHub so that the Locadex AI Agent can translate your project automatically?`;
+                }
+                if (framework.name === 'next-app') {
+                    useAgentMessage = `Next.js App Router detected. Would you like to connect to GitHub so that the Locadex AI Agent can set up your project automatically?`;
+                }
+                if (useAgentMessage) {
+                    return await promptConfirm({
+                        message: useAgentMessage,
+                        defaultValue: false,
+                    });
+                }
+                return false;
+            })();
+            if (useAgent) {
+                await setupLocadex(settings);
+                await this.promptAgentInstructions();
+                logger.endCommand('Once installed, Locadex will open a PR to your repository. See the docs for more information: https://generaltranslation.com/docs/locadex');
+            }
+            else {
+                // Get framework display info for the defaults message
+                const frameworkDisplayName = framework.type === 'react'
+                    ? getFrameworkDisplayName(framework)
+                    : null;
+                const library = framework.type === 'react'
+                    ? getReactFrameworkLibrary(framework)
+                    : null;
+                // Build defaults description based on detected framework
+                const defaultsDescription = framework.type === 'react'
+                    ? `${library} & GTProvider, ${frameworkDisplayName}, Files saved locally in ./public/_gt`
+                    : 'Files saved locally in ./public/_gt';
+                // Ask if user wants to use defaults
+                const useDefaults = await promptConfirm({
+                    message: `Would you like to use the recommended General Translation defaults? ${chalk.dim(`(${defaultsDescription})`)}`,
+                    defaultValue: true,
+                });
+                let ranReactSetup = false;
+                // so that people can run init in non-js projects
+                if (framework.type === 'react') {
+                    const wrap = useDefaults
+                        ? true
+                        : await promptConfirm({
+                            message: `Would you like to install ${library} and add the GTProvider? See the docs for more information: https://generaltranslation.com/docs/react/tutorials/quickstart`,
+                            defaultValue: true,
+                        });
+                    if (wrap) {
+                        logger.info(`${chalk.yellow('[EXPERIMENTAL]')} Configuring project...`);
+                        await handleSetupReactCommand(options, framework, useDefaults);
+                        logger.endCommand(`Done! Since this wizard is experimental, please review the changes and make modifications as needed.
+\nNext step: start internationalizing! See the docs for more information: https://generaltranslation.com/docs/react/tutorials/quickstart`);
+                        ranReactSetup = true;
+                    }
+                }
+                if (ranReactSetup) {
+                    logger.startCommand('Setting up project config...');
+                }
+                // Configure gt.config.json
+                await this.handleInitCommand(ranReactSetup, useDefaults);
+                await this.promptAgentInstructions(useDefaults);
+                logger.endCommand('Done! Check out our docs for more information on how to use General Translation: https://generaltranslation.com/docs');
+            }
+        });
+    }
+    setupConfigureCommand() {
+        this.program
+            .command('configure')
+            .description('Configure your project for General Translation. This will create a gt.config.json file in your codebase.')
+            .action(async () => {
+            displayHeader('Configuring project...');
+            logger.info('Welcome! This tool will help you configure your gt.config.json file. See the docs: https://generaltranslation.com/docs/cli/reference/config for more information.');
+            // Configure gt.config.json
+            await this.handleInitCommand(false);
+            logger.endCommand('Done! Make sure you have an API key and project ID to use General Translation. Get them on the dashboard: https://generaltranslation.com/dashboard');
+        });
+    }
+    async handleUploadCommand(settings) {
+        // dataFormat for JSONs
+        let dataFormat;
+        if (this.library === 'next-intl') {
+            dataFormat = 'ICU';
+        }
+        else if (this.library === 'i18next') {
+            if (this.additionalModules.includes('i18next-icu')) {
+                dataFormat = 'ICU';
+            }
+            else {
+                dataFormat = 'I18NEXT';
+            }
+        }
+        else {
+            dataFormat = 'JSX';
+        }
+        if (!settings.files) {
+            return;
+        }
+        const { resolvedPaths: sourceFiles, placeholderPaths, transformPaths, } = settings.files;
+        // Process all file types at once with a single call
+        await upload(sourceFiles, placeholderPaths, transformPaths, dataFormat, settings);
+    }
+    // Wizard for configuring gt.config.json
+    async handleInitCommand(ranReactSetup, useDefaults = false) {
+        const { defaultLocale, locales } = await getDesiredLocales(); // Locales should still be asked for even if using defaults
+        const packageJson = await searchForPackageJson();
+        // Ask if using another i18n library
+        const gtInstalled = !!packageJson &&
+            INLINE_LIBRARIES.some((lib) => isPackageInstalled(lib, packageJson));
+        const isUsingGT = ranReactSetup || gtInstalled;
+        // Ask where the translations are stored
+        const usingCDN = await (async () => {
+            if (!isUsingGT)
+                return false;
+            if (useDefaults)
+                return false; // Default to local
+            const selectedValue = await promptSelect({
+                message: `Would you like to save translation files locally or use the General Translation CDN to store them?`,
+                options: [
+                    { value: 'local', label: 'Save locally' },
+                    { value: 'cdn', label: 'Use CDN' },
+                ],
+                defaultValue: 'local',
+            });
+            return selectedValue === 'cdn';
+        })();
+        // Ask where the translations are stored
+        const translationsDir = isUsingGT && !usingCDN
+            ? useDefaults
+                ? './public/_gt'
+                : await promptText({
+                    message: 'What is the path to the directory where you would like to store your translation files?',
+                    defaultValue: './public/_gt',
+                })
+            : null;
+        // Determine final translations directory with fallback
+        const finalTranslationsDir = translationsDir?.trim() || './public/_gt';
+        if (isUsingGT && !usingCDN) {
+            // Create loadTranslations.js file for local translations
+            await createLoadTranslationsFile(process.cwd(), finalTranslationsDir, locales);
+            logger.message(`Created ${chalk.cyan('loadTranslations.js')} file for local translations.
+Make sure to add this function to your app configuration.
+See https://generaltranslation.com/en/docs/next/guides/local-tx`);
+        }
+        const message = !isUsingGT
+            ? 'What is the format of your language resource files? Select as many as applicable.\nAdditionally, you can translate any other files you have in your project.'
+            : `Do you have any additional files in this project to translate? For example, Markdown files for docs. ${chalk.dim('(To continue without selecting press Enter)')}`;
+        const fileExtensions = useDefaults && isUsingGT
+            ? [] // Skip for GT projects when using defaults
+            : await promptMultiSelect({
+                message,
+                options: [
+                    { value: 'json', label: FILE_EXT_TO_EXT_LABEL.json },
+                    { value: 'md', label: FILE_EXT_TO_EXT_LABEL.md },
+                    { value: 'mdx', label: FILE_EXT_TO_EXT_LABEL.mdx },
+                    { value: 'ts', label: FILE_EXT_TO_EXT_LABEL.ts },
+                    { value: 'js', label: FILE_EXT_TO_EXT_LABEL.js },
+                    { value: 'yaml', label: FILE_EXT_TO_EXT_LABEL.yaml },
+                ],
+                required: !isUsingGT,
+            });
+        const files = {};
+        for (const fileExtension of fileExtensions) {
+            const paths = await promptText({
+                message: `${chalk.cyan(FILE_EXT_TO_EXT_LABEL[fileExtension])}: Please enter a space-separated list of glob patterns matching the location of the ${FILE_EXT_TO_EXT_LABEL[fileExtension]} files you would like to translate.\nMake sure to include [locale] in the patterns.\nSee https://generaltranslation.com/docs/cli/reference/config#include for more information.`,
+                defaultValue: `./**/[locale]/*.${fileExtension}`,
+            });
+            files[fileExtension] = {
+                include: paths.split(' '),
+            };
+        }
+        // Add GT translations if using GT and storing locally
+        if (isUsingGT && !usingCDN) {
+            files.gt = {
+                output: path.join(finalTranslationsDir, `[locale].json`),
+            };
+        }
+        let configFilepath = 'gt.config.json';
+        if (fs.existsSync('src/gt.config.json')) {
+            configFilepath = 'src/gt.config.json';
+        }
+        // Create gt.config.json
+        await createOrUpdateConfig(configFilepath, {
+            defaultLocale,
+            locales,
+            files: Object.keys(files).length > 0 ? files : undefined,
+            publish: isUsingGT && usingCDN,
+        });
+        logger.success(`Edit ${chalk.cyan(configFilepath)} to customize your translation setup. Docs: https://generaltranslation.com/docs/cli/reference/config`);
+        // Install gt if not installed
+        const isCLIInstalled = packageJson
+            ? isPackageInstalled('gt', packageJson, true, true)
+            : true; // if no package.json, we can't install it
+        if (!isCLIInstalled) {
+            const packageManager = await getPackageManager();
+            const spinner = logger.createSpinner();
+            spinner.start(`Installing gt as a dev dependency with ${packageManager.name}...`);
+            await installPackage('gt', packageManager, true);
+            spinner.stop(chalk.green('Installed gt.'));
+        }
+        // Set credentials
+        if (!areCredentialsSet()) {
+            const loginQuestion = useDefaults
+                ? true
+                : await promptConfirm({
+                    message: `Would you like the wizard to automatically generate a ${isUsingGT ? 'development' : 'production'} API key and project ID for you?`,
+                    defaultValue: true,
+                });
+            if (loginQuestion) {
+                const settings = await generateSettings({});
+                const keyType = isUsingGT ? 'development' : 'production';
+                const credentials = await retrieveCredentials(settings, keyType);
+                await setCredentials(credentials, keyType, settings.framework);
+            }
+        }
+    }
+    async handleLoginCommand(options) {
+        const settings = await generateSettings({});
+        const keyType = options.keyType || 'production';
+        const credentials = await retrieveCredentials(settings, keyType);
+        await setCredentials(credentials, keyType, settings.framework);
+    }
+    setupUpdateInstructionsCommand() {
+        this.program
+            .command('update-instructions')
+            .description('Update GT usage instructions in AI agent files')
+            .option('--new', 'Add instructions to all agent files, even those without existing GT instructions')
+            .action(async (options) => {
+            const agentFiles = options.new
+                ? findAgentFiles()
+                : findAgentFilesWithInstructions();
+            if (options.new &&
+                hasCursorRulesDir() &&
+                !agentFiles.includes(CURSOR_GT_RULES_FILE)) {
+                agentFiles.push(CURSOR_GT_RULES_FILE);
+            }
+            if (agentFiles.length === 0) {
+                logger.warn(options.new
+                    ? 'No agent files found. Create a CLAUDE.md or similar agent file first.'
+                    : 'No agent files with GT instructions found. Use --new to add instructions to existing agent files.');
+                return;
+            }
+            const { library } = determineLibrary();
+            const instructions = getAgentInstructions(library);
+            let updatedCount = 0;
+            for (const file of agentFiles) {
+                if (appendAgentInstructions(file, instructions)) {
+                    updatedCount++;
+                }
+            }
+            if (updatedCount > 0) {
+                logger.success(`Updated GT instructions in ${updatedCount} file${updatedCount > 1 ? 's' : ''}.`);
+            }
+            else {
+                logger.info('All agent instruction files are already up to date.');
+            }
+        });
+    }
+    async promptAgentInstructions(useDefaults = false) {
+        const agentFiles = findAgentFiles();
+        // Include .cursor/rules/gt-i18n.mdc if the directory exists but the file doesn't yet
+        if (hasCursorRulesDir() && !agentFiles.includes(CURSOR_GT_RULES_FILE)) {
+            agentFiles.push(CURSOR_GT_RULES_FILE);
+        }
+        if (agentFiles.length === 0)
+            return;
+        const addInstructions = useDefaults
+            ? true
+            : await promptConfirm({
+                message: `Found AI agent instruction files (${agentFiles.map((f) => path.basename(f)).join(', ')}). Would you like to add GT usage instructions?`,
+                defaultValue: true,
+            });
+        if (addInstructions) {
+            // Re-detect library since packages may have been installed during init
+            const { library } = determineLibrary();
+            const instructions = getAgentInstructions(library);
+            let updatedCount = 0;
+            for (const file of agentFiles) {
+                if (appendAgentInstructions(file, instructions)) {
+                    updatedCount++;
+                }
+            }
+            if (updatedCount > 0) {
+                logger.success('Added GT instructions to agent files.');
+            }
+        }
+    }
+}

package/dist/cli/commands/download.d.ts

@@ -0,0 +1,8 @@
+import { SupportedLibraries, TranslateFlags } from '../../types/index.js';
+import { Settings } from '../../types/index.js';
+/**
+ * Downloads translations that were originally staged
+ * @param options - The options for the command
+ * @param settings - The settings for the command
+ */
+export declare function handleDownload(options: TranslateFlags, settings: Settings, library: SupportedLibraries): Promise<undefined>;

package/dist/cli/commands/download.js

@@ -0,0 +1,51 @@
+import { noVersionIdError, noFilesError } from '../../console/index.js';
+import { createFileMapping } from '../../formats/files/fileMapping.js';
+import { getStagedVersions } from '../../fs/config/updateVersions.js';
+import { runDownloadWorkflow, } from '../../workflows/download.js';
+import { exitSync, logErrorAndExit } from '../../console/logging.js';
+import { convertToFileTranslationData } from '../../formats/files/convertToFileTranslationData.js';
+import { collectFiles } from '../../formats/files/collectFiles.js';
+import { hasValidCredentials, hasValidLocales } from './utils/validation.js';
+// Downloads translations that were originally staged
+/**
+ * Downloads translations that were originally staged
+ * @param options - The options for the command
+ * @param settings - The settings for the command
+ */
+export async function handleDownload(options, settings, library) {
+    if (!hasValidLocales(settings))
+        return exitSync(1);
+    // Validate credentials if not in dry run
+    if (!options.dryRun && !hasValidCredentials(settings))
+        return exitSync(1);
+    if (!settings._versionId) {
+        return logErrorAndExit(noVersionIdError);
+    }
+    if (!settings.files) {
+        return logErrorAndExit(noFilesError);
+    }
+    // Files
+    const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
+    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
+    // Collect the hashes for all files we need to download
+    let fileVersionData;
+    if (settings.stageTranslations) {
+        fileVersionData = await getStagedVersions(settings.configDirectory);
+    }
+    else {
+        const { files } = await collectFiles(options, settings, library);
+        fileVersionData = convertToFileTranslationData(files);
+    }
+    // Check for remaining translations
+    await runDownloadWorkflow({
+        fileVersionData: fileVersionData,
+        jobData: undefined,
+        branchData: undefined,
+        locales: settings.locales,
+        timeoutDuration: options.timeout,
+        resolveOutputPath: (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null,
+        options: settings,
+        forceRetranslation: false, // force is not applicable for downloading staged translations
+        forceDownload: options.force || options.forceDownload,
+    });
+}

package/dist/cli/commands/enqueue.d.ts

@@ -0,0 +1,9 @@
+import { EnqueueFilesResult } from 'generaltranslation/types';
+import { Settings, SupportedLibraries, TranslateFlags } from '../../types/index.js';
+/**
+ * Enqueues translations for a given set of files
+ * @param options - The options for the enqueue operation
+ * @param settings - The settings for the enqueue operation
+ * @returns {Promise<EnqueueFilesResult>} The enqueue result
+ */
+export declare function handleEnqueue(options: TranslateFlags, settings: Settings, library: SupportedLibraries): Promise<EnqueueFilesResult>;

package/dist/cli/commands/enqueue.js

@@ -0,0 +1,27 @@
+import { runEnqueueWorkflow } from '../../workflows/enqueue.js';
+import { collectFiles } from '../../formats/files/collectFiles.js';
+import { noFilesError, noVersionIdError } from '../../console/index.js';
+import { hasValidCredentials, hasValidLocales } from './utils/validation.js';
+import { exitSync, logErrorAndExit } from '../../console/logging.js';
+/**
+ * Enqueues translations for a given set of files
+ * @param options - The options for the enqueue operation
+ * @param settings - The settings for the enqueue operation
+ * @returns {Promise<EnqueueFilesResult>} The enqueue result
+ */
+export async function handleEnqueue(options, settings, library) {
+    if (!hasValidLocales(settings))
+        return exitSync(1);
+    // Validate credentials if not in dry run
+    if (!options.dryRun && !hasValidCredentials(settings))
+        return exitSync(1);
+    if (!settings._versionId) {
+        return logErrorAndExit(noVersionIdError);
+    }
+    if (!settings.files) {
+        return logErrorAndExit(noFilesError);
+    }
+    // Collect the data for all files we need to enqueue
+    const { files } = await collectFiles(options, settings, library);
+    return runEnqueueWorkflow({ files, options, settings });
+}

package/dist/cli/commands/setupProject.d.ts

@@ -0,0 +1,7 @@
+import { Settings, SupportedLibraries, TranslateFlags } from '../../types/index.js';
+import { FileTranslationData } from '../../workflows/download.js';
+import { BranchData } from '../../types/branch.js';
+export declare function handleSetupProject(options: TranslateFlags, settings: Settings, library: SupportedLibraries): Promise<{
+    fileVersionData: FileTranslationData | undefined;
+    branchData: BranchData | undefined;
+} | null>;