gtx-cli 2.5.7 → 2.5.8

package/dist/console/logger.js

@@ -0,0 +1,255 @@
+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})`);
+    }
+}
+class Logger {
+    static instance;
+    pinoLogger = null;
+    fileLogger = null;
+    logFormat;
+    constructor() {
+        // Read configuration from environment variables
+        const format = (process.env.GT_LOG_FORMAT || 'default').toLowerCase();
+        if (format !== 'default' && format !== 'json') {
+            console.error('Invalid log format');
+            process.exit(1);
+        }
+        const logFile = process.env.GT_LOG_FILE;
+        const logLevel = process.env.GT_LOG_LEVEL || 'info';
+        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,11 @@
-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;
 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;

package/dist/console/logging.js

@@ -1,45 +1,22 @@
-import { log, spinner, intro, outro, text, select, confirm, isCancel, cancel, multiselect, progress, } from '@clack/prompts';
+import { text, select, confirm, isCancel, cancel, multiselect, } from '@clack/prompts';
 import chalk from 'chalk';
 import { getCLIVersion } from '../utils/packageJson.js';
-// Basic logging functions
-export function logInfo(message) {
-    log.info(message);
-}
-export function logWarning(message) {
-    log.warn(message);
-}
-export function logError(message) {
-    log.error(message);
-}
-export function logSuccess(message) {
-    log.success(message);
-}
-export function logStep(message) {
-    log.step(message);
-}
-export function logMessage(message) {
-    log.message(message, { symbol: chalk.cyan('~') });
-}
+import { logger } from './logger.js';
 export function logErrorAndExit(message) {
-    log.error(message);
-    exit(1);
+    logger.error(message);
+    return exitSync(1);
 }
-export function exit(code) {
+export function exitSync(code) {
+    // Flush logs before exit
+    logger.flush();
     process.exit(code);
 }
-// Clack prompts
-export function startCommand(message) {
-    intro(chalk.cyan(message));
-}
-export function endCommand(message) {
-    outro(chalk.cyan(message));
-}
 // GT specific logging
 export function displayHeader(introString) {
     displayAsciiTitle();
     displayInitializingText();
     if (introString) {
-        startCommand(introString);
+        logger.startCommand(introString);
     }
 }
 function displayAsciiTitle() {
@@ -59,30 +36,22 @@ ${chalk.dim('https://generaltranslation.com/docs')}
 ${chalk.dim(`CLI Version: ${version}\n`)}`);
 }
 export function displayProjectId(projectId) {
-    logMessage(chalk.dim(`Project ID: ${chalk.bold(projectId)}`));
+    logger.message(chalk.dim(`Project ID: ${chalk.bold(projectId)}`), chalk.cyan('~'));
 }
 export function displayResolvedPaths(resolvedPaths) {
     const paths = resolvedPaths.map(([key, resolvedPath]) => {
         return chalk.dim(`'${chalk.white(key)}' → '${chalk.green(resolvedPath)}'`);
     });
-    log.step(`Resolved path aliases:\n${paths.join('\n')}`);
+    logger.step(`Resolved path aliases:\n${paths.join('\n')}`);
 }
 export function displayCreatedConfigFile(configFilepath) {
-    log.step(`Created config file ${chalk.cyan(configFilepath)}`);
+    logger.step(`Created config file ${chalk.cyan(configFilepath)}`);
 }
 export function displayUpdatedConfigFile(configFilepath) {
-    log.success(`Updated config file ${chalk.cyan(configFilepath)}`);
+    logger.success(`Updated config file ${chalk.cyan(configFilepath)}`);
 }
 export function displayUpdatedVersionsFile(versionFilepath) {
-    log.success(`Updated versions file ${chalk.cyan(versionFilepath)}`);
-}
-// Spinner functionality
-export function createSpinner(indicator = 'timer') {
-    return spinner({ indicator });
-}
-// Spinner functionality
-export function createProgressBar(total) {
-    return progress({ max: total });
+    logger.success(`Updated versions file ${chalk.cyan(versionFilepath)}`);
 }
 // Input prompts
 export async function promptText({ message, defaultValue, validate, }) {
@@ -98,7 +67,7 @@ export async function promptText({ message, defaultValue, validate, }) {
     });
     if (isCancel(result)) {
         cancel('Operation cancelled');
-        process.exit(0);
+        return exitSync(0);
     }
     return result;
 }
@@ -116,7 +85,7 @@ export async function promptSelect({ message, options, defaultValue, }) {
     });
     if (isCancel(result)) {
         cancel('Operation cancelled');
-        process.exit(0);
+        return exitSync(0);
     }
     return result;
 }
@@ -134,7 +103,7 @@ export async function promptMultiSelect({ message, options, required = true, })
     });
     if (isCancel(result)) {
         cancel('Operation cancelled');
-        process.exit(0);
+        return exitSync(0);
     }
     return result;
 }
@@ -145,25 +114,25 @@ export async function promptConfirm({ message, defaultValue = true, cancelMessag
     });
     if (isCancel(result)) {
         cancel(cancelMessage);
-        process.exit(0);
+        return exitSync(0);
     }
     return result;
 }
 // Warning display functions
 export function warnApiKeyInConfig(optionsFilepath) {
-    log.warn(`Found ${chalk.cyan('apiKey')} in "${chalk.green(optionsFilepath)}". ` +
+    logger.warn(`Found ${chalk.cyan('apiKey')} in "${chalk.green(optionsFilepath)}". ` +
         chalk.white('Your API key is exposed! Please remove it from the file and include it as an environment variable.'));
 }
 export function warnVariableProp(file, attrName, value) {
-    log.warn(`Found ${chalk.green('<T>')} component in ${chalk.cyan(file)} with variable ${attrName}: "${chalk.white(value)}". ` +
+    logger.warn(`Found ${chalk.green('<T>')} component in ${chalk.cyan(file)} with variable ${attrName}: "${chalk.white(value)}". ` +
         `Change "${attrName}" to ensure this content is translated.`);
 }
 export function warnNoId(file) {
-    log.warn(`Found ${chalk.green('<T>')} component in ${chalk.cyan(file)} with no id. ` +
+    logger.warn(`Found ${chalk.green('<T>')} component in ${chalk.cyan(file)} with no id. ` +
         chalk.white('Add an id to ensure the content is translated.'));
 }
 export function warnHasUnwrappedExpression(file, id, unwrappedExpressions) {
-    log.warn(`${chalk.green('<T>')} with id "${id}" in ${chalk.cyan(file)} has children: ${unwrappedExpressions.join(', ')} that could change at runtime. ` +
+    logger.warn(`${chalk.green('<T>')} with id "${id}" in ${chalk.cyan(file)} has children: ${unwrappedExpressions.join(', ')} that could change at runtime. ` +
         chalk.white('Use a variable component like ') +
         chalk.green('<Var>') +
         chalk.white(' (') +
@@ -171,14 +140,14 @@ export function warnHasUnwrappedExpression(file, id, unwrappedExpressions) {
         chalk.white(') to translate this properly.'));
 }
 export function warnNonStaticExpression(file, attrName, value) {
-    log.warn(`Found non-static expression in ${chalk.cyan(file)} for attribute ${attrName}: "${chalk.white(value)}". ` +
+    logger.warn(`Found non-static expression in ${chalk.cyan(file)} for attribute ${attrName}: "${chalk.white(value)}". ` +
         `Change "${attrName}" to ensure this content is translated.`);
 }
 export function warnTemplateLiteral(file, value) {
-    log.warn(`Found template literal with quasis (${value}) in ${chalk.cyan(file)}. ` +
+    logger.warn(`Found template literal with quasis (${value}) in ${chalk.cyan(file)}. ` +
         chalk.white('Change the template literal to a string to ensure this content is translated.'));
 }
 export function warnTernary(file) {
-    log.warn(`Found ternary expression in ${chalk.cyan(file)}. ` +
+    logger.warn(`Found ternary expression in ${chalk.cyan(file)}. ` +
         chalk.white('A Branch component may be more appropriate here.'));
 }

package/dist/formats/files/save.js

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 import path from 'node:path';
-import { logSuccess } from '../../console/logging.js';
+import { logger } from '../../console/logger.js';
 /**
  * Saves translated MDX/MD file content to the appropriate location
  */
@@ -12,6 +12,6 @@ export async function saveTranslatedFile(translatedContent, outputDir, fileName,
         // Save the translated file with the appropriate extension
         const outputPath = path.join(localeDir, fileName);
         await fs.writeFile(outputPath, translatedContent);
-        logSuccess(`Saved translated ${dataFormat} file to: ${outputPath}`);
+        logger.success(`Saved translated ${dataFormat} file to: ${outputPath}`);
     }
 }

package/dist/formats/files/translate.js

@@ -1,4 +1,4 @@
-import { logError, logWarning } from '../../console/logging.js';
+import { logger } from '../../console/logger.js';
 import { getRelative, readFile } from '../../fs/findFilepath.js';
 import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
 import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
@@ -46,7 +46,7 @@ export async function aggregateFiles(settings) {
                 JSON.parse(content);
             }
             catch (e) {
-                logWarning(`Skipping ${relativePath}: JSON file is not parsable`);
+                logger.warn(`Skipping ${relativePath}: JSON file is not parsable`);
                 return null;
             }
             const parsedJson = parseJson(content, filePath, settings.options || {}, settings.defaultLocale);
@@ -63,7 +63,7 @@ export async function aggregateFiles(settings) {
             if (!file)
                 return false;
             if (typeof file.content !== 'string' || !file.content.trim()) {
-                logWarning(`Skipping ${file.fileName}: JSON file is empty`);
+                logger.warn(`Skipping ${file.fileName}: JSON file is empty`);
                 return false;
             }
             return true;
@@ -81,7 +81,7 @@ export async function aggregateFiles(settings) {
                 YAML.parse(content);
             }
             catch (e) {
-                logWarning(`Skipping ${relativePath}: YAML file is not parsable`);
+                logger.warn(`Skipping ${relativePath}: YAML file is not parsable`);
                 return null;
             }
             const { content: parsedYaml, fileFormat } = parseYaml(content, filePath, settings.options || {});
@@ -95,7 +95,7 @@ export async function aggregateFiles(settings) {
         })
             .filter((file) => {
             if (!file || typeof file.content !== 'string' || !file.content.trim()) {
-                logWarning(`Skipping ${file?.fileName ?? 'unknown'}: YAML file is empty`);
+                logger.warn(`Skipping ${file?.fileName ?? 'unknown'}: YAML file is empty`);
                 return false;
             }
             return true;
@@ -113,7 +113,7 @@ export async function aggregateFiles(settings) {
                 if (fileType === 'mdx') {
                     const validation = isValidMdx(content, filePath);
                     if (!validation.isValid) {
-                        logWarning(`Skipping ${relativePath}: MDX file is not AST parsable${validation.error ? `: ${validation.error}` : ''}`);
+                        logger.warn(`Skipping ${relativePath}: MDX file is not AST parsable${validation.error ? `: ${validation.error}` : ''}`);
                         return null;
                     }
                 }
@@ -130,7 +130,7 @@ export async function aggregateFiles(settings) {
                 if (!file ||
                     typeof file.content !== 'string' ||
                     !file.content.trim()) {
-                    logWarning(`Skipping ${file?.fileName ?? 'unknown'}: File is empty after sanitization`);
+                    logger.warn(`Skipping ${file?.fileName ?? 'unknown'}: File is empty after sanitization`);
                     return false;
                 }
                 return true;
@@ -139,7 +139,7 @@ export async function aggregateFiles(settings) {
         }
     }
     if (allFiles.length === 0 && !settings.publish) {
-        logError('No files to translate were found. Please check your configuration and try again.');
+        logger.error('No files to translate were found. Please check your configuration and try again.');
     }
     return allFiles;
 }

package/dist/formats/files/upload.js

@@ -1,5 +1,6 @@
 import { noSupportedFormatError, noDefaultLocaleError, noApiKeyError, noProjectIdError, devApiKeyError, } from '../../console/index.js';
-import { logErrorAndExit, logError } from '../../console/logging.js';
+import { logErrorAndExit } from '../../console/logging.js';
+import { logger } from '../../console/logger.js';
 import { getRelative, readFile } from '../../fs/findFilepath.js';
 import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
 import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
@@ -80,20 +81,20 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
         }
     }
     if (allFiles.length === 0) {
-        logError('No files to upload were found. Please check your configuration and try again.');
+        logger.error('No files to upload were found. Please check your configuration and try again.');
         return;
     }
     if (!options.defaultLocale) {
-        logErrorAndExit(noDefaultLocaleError);
+        return logErrorAndExit(noDefaultLocaleError);
     }
     if (!options.apiKey) {
-        logErrorAndExit(noApiKeyError);
+        return logErrorAndExit(noApiKeyError);
     }
     if (options.apiKey.startsWith('gtx-dev-')) {
-        logErrorAndExit(devApiKeyError);
+        return logErrorAndExit(devApiKeyError);
     }
     if (!options.projectId) {
-        logErrorAndExit(noProjectIdError);
+        return logErrorAndExit(noProjectIdError);
     }
     const locales = options.locales || [];
     // Create file mapping for all file types

package/dist/formats/gt/save.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { logError } from '../../console/logging.js';
+import { logger } from '../../console/logger.js';
+import { exitSync } from '../../console/logging.js';
 import { noFilesError } from '../../console/index.js';
 import { resolveLocaleFiles } from '../../fs/config/parseFilesConfig.js';
 /**
@@ -14,8 +15,8 @@ export async function saveTranslations(translations, placeholderPaths) {
         const locale = translation.locale;
         const translationFiles = resolveLocaleFiles(placeholderPaths, locale);
         if (!translationFiles.gt) {
-            logError(noFilesError);
-            process.exit(1);
+            logger.error(noFilesError);
+            exitSync(1);
         }
         const filepath = translationFiles.gt;
         const translationData = translation.translation;

package/dist/formats/json/flattenJson.js

@@ -1,5 +1,5 @@
 import { JSONPath } from 'jsonpath-plus';
-import { logError } from '../../console/logging.js';
+import { logger } from '../../console/logger.js';
 /**
  * Flattens a JSON object according to a list of JSON paths.
  * @param json - The JSON object to flatten
@@ -25,7 +25,7 @@ export function flattenJson(json, jsonPaths) {
             });
         }
         catch (error) {
-            logError(`Error with JSONPath pattern: ${jsonPath}`);
+            logger.error(`Error with JSONPath pattern: ${jsonPath}`);
         }
     }
     return extractedJson;
@@ -57,7 +57,7 @@ export function flattenJsonWithStringFilter(json, jsonPaths) {
             });
         }
         catch {
-            logError(`Error with JSONPath pattern: ${jsonPath}`);
+            logger.error(`Error with JSONPath pattern: ${jsonPath}`);
         }
     }
     return extractedJson;