gtx-cli 2.5.7 → 2.5.9

package/dist/cli/react.js

@@ -1,4 +1,5 @@
-import { displayHeader, endCommand, logError, logStep, logSuccess, logWarning, promptConfirm, } from '../console/logging.js';
+import { displayHeader, exitSync, promptConfirm } from '../console/logging.js';
+import { logger } from '../console/logger.js';
 import loadJSON from '../fs/loadJSON.js';
 import findFilepath from '../fs/findFilepath.js';
 import chalk from 'chalk';
@@ -20,6 +21,7 @@ export class ReactCLI extends BaseCLI {
         super(command, library, additionalModules);
     }
     init() {
+        this.setupSetupProjectCommand();
         this.setupStageCommand();
         this.setupTranslateCommand();
         this.setupGenerateSourceCommand();
@@ -31,13 +33,22 @@ export class ReactCLI extends BaseCLI {
     wrapContent(options, framework, errors, warnings) {
         return wrapContentReact(options, pkg, framework, errors, warnings);
     }
+    setupSetupProjectCommand() {
+        attachAdditionalReactTranslateFlags(attachTranslateFlags(this.program
+            .command('setup')
+            .description('Upload source files and setup the project for translation'))).action(async (options) => {
+            displayHeader('Uploading source files and setting up project...');
+            await this.handleSetupProject(options);
+            logger.endCommand('Done!');
+        });
+    }
     setupStageCommand() {
         attachAdditionalReactTranslateFlags(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 (options) => {
             displayHeader('Staging project for translation with approval required...');
             await this.handleStage(options);
-            endCommand('Done!');
+            logger.endCommand('Done!');
         });
     }
     setupTranslateCommand() {
@@ -46,7 +57,7 @@ export class ReactCLI extends BaseCLI {
             .description('Scans the project for a dictionary and/or <T> tags, and sends the updates to the General Translation API for translation.'))).action(async (options) => {
             displayHeader('Translating project...');
             await this.handleTranslate(options);
-            endCommand('Done!');
+            logger.endCommand('Done!');
         });
     }
     setupValidateCommand() {
@@ -62,7 +73,7 @@ export class ReactCLI extends BaseCLI {
             // intro here since we don't want to show the ascii title
             intro(chalk.cyan('Validating project...'));
             await this.handleValidate(options, files);
-            endCommand('Done!');
+            logger.endCommand('Done!');
         });
     }
     setupGenerateSourceCommand() {
@@ -71,7 +82,7 @@ export class ReactCLI extends BaseCLI {
             .description('Generate a translation file for the source locale. This command should be used if you are handling your own translations.'))).action(async (initOptions) => {
             displayHeader('Generating source templates...');
             await this.handleGenerateSourceCommand(initOptions);
-            endCommand('Done!');
+            logger.endCommand('Done!');
         });
     }
     async handleGenerateSourceCommand(initOptions) {
@@ -93,11 +104,11 @@ export class ReactCLI extends BaseCLI {
         if (settings.files && settings.files.placeholderPaths.gt) {
             const translationFiles = resolveLocaleFiles(settings.files.placeholderPaths, settings.defaultLocale);
             if (!translationFiles.gt) {
-                logError(noFilesError);
-                process.exit(1);
+                logger.error(noFilesError);
+                exitSync(1);
             }
             await saveJSON(translationFiles.gt, newData);
-            logStep('Source file saved successfully!');
+            logger.step('Source file saved successfully!');
             // Also save translations (after merging with existing translations)
             for (const locale of settings.locales) {
                 const translationsFile = resolveLocaleFiles(settings.files.placeholderPaths, locale);
@@ -113,7 +124,7 @@ export class ReactCLI extends BaseCLI {
                 const filteredTranslations = Object.fromEntries(Object.entries(mergedTranslations).filter(([key]) => newData[key]));
                 await saveJSON(translationsFile.gt, filteredTranslations);
             }
-            logStep('Merged translations successfully!');
+            logger.step('Merged translations successfully!');
         }
     }
     async handleScanCommand(options) {
@@ -123,8 +134,8 @@ export class ReactCLI extends BaseCLI {
             defaultValue: true,
         });
         if (!answer) {
-            logError('Operation cancelled.');
-            process.exit(0);
+            logger.error('Operation cancelled.');
+            exitSync(0);
         }
         // ----- Create a starter gt.config.json file -----
         await generateSettings(options);
@@ -139,18 +150,18 @@ export class ReactCLI extends BaseCLI {
         // Wrap all JSX elements in the src directory with a <T> tag, with unique ids
         const { filesUpdated } = await this.wrapContent(options, 'react', errors, warnings);
         if (errors.length > 0) {
-            logError(chalk.red('Failed to write files:\n') + errors.join('\n'));
+            logger.error(chalk.red('Failed to write files:\n') + errors.join('\n'));
         }
         // Format updated files if formatters are available
         if (!options.disableFormatting)
             await formatFiles(filesUpdated);
-        logSuccess(`Success! Added <T> tags and updated ${chalk.bold.cyan(filesUpdated.length)} files:\n` +
+        logger.success(`Success! Added <T> tags and updated ${chalk.bold.cyan(filesUpdated.length)} files:\n` +
             filesUpdated.map((file) => `${chalk.green('-')} ${file}`).join('\n'));
         if (filesUpdated.length > 0) {
-            logStep(chalk.green('Please verify the changes before committing.'));
+            logger.step(chalk.green('Please verify the changes before committing.'));
         }
         if (warnings.length > 0) {
-            logWarning(chalk.yellow('Warnings encountered:') +
+            logger.warn(chalk.yellow('Warnings encountered:') +
                 '\n' +
                 warnings
                     .map((warning) => `${chalk.yellow('-')} ${warning}`)

package/dist/config/generateSettings.js

@@ -1,4 +1,4 @@
-import { displayProjectId, logErrorAndExit, warnApiKeyInConfig, } from '../console/logging.js';
+import { displayProjectId, exitSync, logErrorAndExit, warnApiKeyInConfig, } from '../console/logging.js';
 import { loadConfig } from '../fs/config/loadConfig.js';
 import { defaultBaseUrl, libraryDefaultLocale, } from 'generaltranslation/internal';
 import fs from 'node:fs';
@@ -46,7 +46,7 @@ export async function generateSettings(flags, cwd = process.cwd()) {
     // Warn if apiKey is present in gt.config.json
     if (gtConfig.apiKey) {
         warnApiKeyInConfig(flags.config);
-        process.exit(1);
+        exitSync(1);
     }
     const projectIdEnv = resolveProjectId();
     // Resolve mismatched projectIds

package/dist/config/validateSettings.d.ts

@@ -1,3 +1,3 @@
 import { Settings } from '../types/index.js';
-export declare function validateSettings(settings: Settings): void;
+export declare function validateSettings(settings: Settings): undefined;
 export declare function validateConfigExists(): string;

package/dist/config/validateSettings.js

@@ -6,19 +6,19 @@ export function validateSettings(settings) {
     // Validate locales
     for (const locale of settings.locales) {
         if (!isValidLocale(locale, settings.customMapping)) {
-            logErrorAndExit(`Provided locales: "${settings?.locales?.join()}", ${locale} is not a valid locale!`);
+            return logErrorAndExit(`Provided locales: "${settings?.locales?.join()}", ${locale} is not a valid locale!`);
         }
     }
     if (settings.defaultLocale &&
         !isValidLocale(settings.defaultLocale, settings.customMapping)) {
-        logErrorAndExit(`defaultLocale: ${settings.defaultLocale} is not a valid locale!`);
+        return logErrorAndExit(`defaultLocale: ${settings.defaultLocale} is not a valid locale!`);
     }
     // defaultLocale cannot be a superset of any other locale
     if (settings.defaultLocale &&
         settings.locales.some((locale) => isSupersetLocale(settings.defaultLocale, locale) &&
             !isSupersetLocale(locale, settings.defaultLocale))) {
         const locale = settings.locales.find((locale) => isSupersetLocale(settings.defaultLocale, locale));
-        logErrorAndExit(`defaultLocale: ${settings.defaultLocale} is a superset of another locale (${locale})! Please change the defaultLocale to a more specific locale.`);
+        return logErrorAndExit(`defaultLocale: ${settings.defaultLocale} is a superset of another locale (${locale})! Please change the defaultLocale to a more specific locale.`);
     }
 }
 export function validateConfigExists() {
@@ -28,5 +28,5 @@ export function validateConfigExists() {
             return possibleConfigPath;
         }
     }
-    logErrorAndExit('No gt.config.json file found. Are you in the correct directory?');
+    return logErrorAndExit('No gt.config.json file found. Are you in the correct directory?');
 }

package/dist/console/logger.d.ts

@@ -0,0 +1,35 @@
+import type { SpinnerResult, ProgressResult } from '@clack/prompts';
+export type LogFormat = 'default' | 'json';
+/**
+ * GT_LOG_FORMAT: default | json.
+ * - If default, logs will be pretty-printed using @clack/prompts.
+ * - If json, logs will be written in JSON format to the console.
+ * GT_LOG_FILE: If specified, logs will be written to the file.
+ * GT_LOG_LEVEL: The level of logs to write. If not specified, defaults to 'info'.
+ * - Valid levels: debug, info, warn, error.
+ */
+declare class Logger {
+    private static instance;
+    private pinoLogger;
+    private fileLogger;
+    private logFormat;
+    private constructor();
+    static getInstance(): Logger;
+    trace(message: string): void;
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    fatal(message: string): void;
+    silent(message: string): void;
+    success(message: string): void;
+    step(message: string): void;
+    message(message: string, symbol?: string): void;
+    createSpinner(indicator?: 'dots' | 'timer'): SpinnerResult;
+    createProgressBar(total: number): ProgressResult;
+    startCommand(message: string): void;
+    endCommand(message: string): void;
+    flush(): void;
+}
+export declare const logger: Logger;
+export {};

package/dist/console/logger.js

@@ -0,0 +1,270 @@
+import chalk from 'chalk';
+import { randomUUID } from 'node:crypto';
+import { pino, transport } from 'pino';
+import { log as clackLog, spinner, progress, intro, outro, } from '@clack/prompts';
+// Mock spinner that logs to console instead of updating terminal UI
+class MockSpinner {
+    currentMessage = '';
+    logger;
+    isCancelled = false;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    start(message) {
+        if (message) {
+            this.currentMessage = message;
+            this.logger.info(`[Spinner] ${message}`);
+        }
+    }
+    stop(message) {
+        const msg = message || this.currentMessage;
+        if (msg) {
+            this.logger.info(`[Spinner] ${msg}`);
+        }
+        this.currentMessage = '';
+    }
+    message(message) {
+        if (message) {
+            this.currentMessage = message;
+            this.logger.info(`[Spinner] ${message}`);
+        }
+    }
+}
+// Mock progress bar that logs to console instead of updating terminal UI
+class MockProgress {
+    max;
+    current = 0;
+    logger;
+    isCancelled = false;
+    constructor(max, logger) {
+        this.max = max;
+        this.logger = logger;
+    }
+    start(message) {
+        const msg = message || 'Starting progress';
+        this.logger.info(`[Progress] ${msg} (0/${this.max})`);
+    }
+    stop(message) {
+        const msg = message || 'Complete';
+        this.logger.info(`[Progress] ${msg} (${this.current}/${this.max})`);
+    }
+    message(message) {
+        if (message) {
+            this.logger.info(`[Progress] ${message} (${this.current}/${this.max})`);
+        }
+    }
+    advance(amount, message) {
+        this.current += amount;
+        const msg = message || 'Progress';
+        this.logger.info(`[Progress] ${msg} (${this.current}/${this.max})`);
+    }
+}
+/**
+ * GT_LOG_FORMAT: default | json.
+ * - If default, logs will be pretty-printed using @clack/prompts.
+ * - If json, logs will be written in JSON format to the console.
+ * GT_LOG_FILE: If specified, logs will be written to the file.
+ * GT_LOG_LEVEL: The level of logs to write. If not specified, defaults to 'info'.
+ * - Valid levels: debug, info, warn, error.
+ */
+class Logger {
+    static instance;
+    pinoLogger = null;
+    fileLogger = null;
+    logFormat;
+    constructor() {
+        // Read configuration from environment variables
+        const format = (process.env.GT_LOG_FORMAT || 'default').toLowerCase();
+        const logFile = process.env.GT_LOG_FILE;
+        const logLevel = process.env.GT_LOG_LEVEL || 'info';
+        if (format !== 'default' && format !== 'json') {
+            console.error('Invalid log format');
+            process.exit(1);
+        }
+        if (logLevel !== 'debug' &&
+            logLevel !== 'info' &&
+            logLevel !== 'warn' &&
+            logLevel !== 'error') {
+            console.error('Invalid log level');
+            process.exit(1);
+        }
+        this.logFormat = format;
+        const transports = [];
+        // Console output (stdout)
+        if (format === 'json') {
+            // JSON formatted console output
+            transports.push({
+                level: logLevel,
+                target: 'pino/file',
+                options: { destination: 1 }, // stdout
+            });
+        }
+        // For 'default' format, we don't add a console transport - we'll use @clack/prompts directly
+        // Create console logger if we have console transports
+        if (transports.length > 0) {
+            this.pinoLogger = pino({
+                level: logLevel,
+                mixin: () => ({
+                    logId: randomUUID(),
+                }),
+            }, transport({
+                targets: transports,
+            }));
+        }
+        // File output (if specified) - always JSON format
+        if (logFile) {
+            this.fileLogger = pino({
+                level: logLevel,
+                mixin: () => ({
+                    logId: randomUUID(),
+                }),
+            }, transport({
+                targets: [
+                    {
+                        level: logLevel,
+                        target: 'pino/file',
+                        options: { destination: logFile },
+                    },
+                ],
+            }));
+        }
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    // Standard logging methods
+    trace(message) {
+        if (this.logFormat === 'default') {
+            // @clack/prompts doesn't have trace, use message
+            clackLog.message(message, { symbol: chalk.dim('•') });
+        }
+        else {
+            this.pinoLogger?.trace(message);
+        }
+        this.fileLogger?.trace(message);
+    }
+    debug(message) {
+        if (this.logFormat === 'default') {
+            // @clack/prompts doesn't have debug, use message
+            clackLog.message(message, { symbol: chalk.dim('◆') });
+        }
+        else {
+            this.pinoLogger?.debug(message);
+        }
+        this.fileLogger?.debug(message);
+    }
+    info(message) {
+        if (this.logFormat === 'default') {
+            clackLog.info(message);
+        }
+        else {
+            this.pinoLogger?.info(message);
+        }
+        this.fileLogger?.info(message);
+    }
+    warn(message) {
+        if (this.logFormat === 'default') {
+            clackLog.warn(message);
+        }
+        else {
+            this.pinoLogger?.warn(message);
+        }
+        this.fileLogger?.warn(message);
+    }
+    error(message) {
+        if (this.logFormat === 'default') {
+            clackLog.error(message);
+        }
+        else {
+            this.pinoLogger?.error(message);
+        }
+        this.fileLogger?.error(message);
+    }
+    fatal(message) {
+        if (this.logFormat === 'default') {
+            clackLog.error(message); // @clack/prompts doesn't have fatal, use error
+        }
+        else {
+            this.pinoLogger?.fatal(message);
+        }
+        this.fileLogger?.fatal(message);
+    }
+    silent(message) {
+        // Silent doesn't log to console, only to file
+        this.fileLogger?.silent(message);
+    }
+    // @clack/prompts specific methods (for 'default' format)
+    success(message) {
+        if (this.logFormat === 'default') {
+            clackLog.success(message);
+        }
+        else {
+            this.pinoLogger?.info(message); // Map to info for non-default formats
+        }
+        this.fileLogger?.info(message);
+    }
+    step(message) {
+        if (this.logFormat === 'default') {
+            clackLog.step(message);
+        }
+        else {
+            this.pinoLogger?.info(message); // Map to info for non-default formats
+        }
+        this.fileLogger?.info(message);
+    }
+    message(message, symbol) {
+        if (this.logFormat === 'default') {
+            clackLog.message(message, symbol ? { symbol } : undefined);
+        }
+        else {
+            this.pinoLogger?.info(message); // Map to info for non-default formats
+        }
+        this.fileLogger?.info(message);
+    }
+    // Spinner functionality
+    createSpinner(indicator = 'timer') {
+        if (this.logFormat === 'default') {
+            return spinner({ indicator });
+        }
+        else {
+            return new MockSpinner(this);
+        }
+    }
+    // Progress bar functionality
+    createProgressBar(total) {
+        if (this.logFormat === 'default') {
+            return progress({ max: total });
+        }
+        else {
+            return new MockProgress(total, this);
+        }
+    }
+    // Command start/end markers
+    startCommand(message) {
+        if (this.logFormat === 'default') {
+            intro(chalk.cyan(message));
+        }
+        else {
+            this.info(`╭─ ${message}`);
+        }
+        this.fileLogger?.info(`[START] ${message}`);
+    }
+    endCommand(message) {
+        if (this.logFormat === 'default') {
+            outro(chalk.cyan(message));
+        }
+        else {
+            this.info(`╰─ ${message}`);
+        }
+        this.fileLogger?.info(`[END] ${message}`);
+    }
+    // Flush logs to ensure they're written before process exit
+    flush() {
+        this.pinoLogger?.flush();
+        this.fileLogger?.flush();
+    }
+}
+export const logger = Logger.getInstance();

package/dist/console/logging.d.ts

@@ -1,21 +1,12 @@
-export declare function logInfo(message: string): void;
-export declare function logWarning(message: string): void;
-export declare function logError(message: string): void;
-export declare function logSuccess(message: string): void;
-export declare function logStep(message: string): void;
-export declare function logMessage(message: string): void;
+import { FileToUpload } from 'generaltranslation/types';
 export declare function logErrorAndExit(message: string): never;
-export declare function exit(code: number): never;
-export declare function startCommand(message: string): void;
-export declare function endCommand(message: string): void;
+export declare function exitSync(code: number): never;
 export declare function displayHeader(introString?: string): void;
 export declare function displayProjectId(projectId: string): void;
 export declare function displayResolvedPaths(resolvedPaths: [string, string][]): void;
 export declare function displayCreatedConfigFile(configFilepath: string): void;
 export declare function displayUpdatedConfigFile(configFilepath: string): void;
 export declare function displayUpdatedVersionsFile(versionFilepath: string): void;
-export declare function createSpinner(indicator?: 'dots' | 'timer'): import("@clack/prompts").SpinnerResult;
-export declare function createProgressBar(total: number): import("@clack/prompts").ProgressResult;
 export declare function promptText({ message, defaultValue, validate, }: {
     message: string;
     defaultValue?: string;
@@ -51,3 +42,7 @@ export declare function warnHasUnwrappedExpression(file: string, id: string, unw
 export declare function warnNonStaticExpression(file: string, attrName: string, value: string): void;
 export declare function warnTemplateLiteral(file: string, value: string): void;
 export declare function warnTernary(file: string): void;
+/**
+ * Helper: Log all collected files
+ */
+export declare function logCollectedFiles(files: FileToUpload[], reactComponents?: number): void;