gtx-cli 2.4.15 → 2.5.0-alpha.1

package/dist/workflow/SetupStep.js

@@ -0,0 +1,71 @@
+import { WorkflowStep } from './Workflow.js';
+import { createSpinner } from '../console/logging.js';
+import chalk from 'chalk';
+export class SetupStep extends WorkflowStep {
+    gt;
+    settings;
+    timeoutMs;
+    spinner = createSpinner('dots');
+    setupJobId = null;
+    files = null;
+    completed = false;
+    constructor(gt, settings, timeoutMs) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+        this.timeoutMs = timeoutMs;
+    }
+    async run(files) {
+        this.files = files;
+        this.spinner.start('Setting up project...');
+        if (files.length === 0) {
+            this.completed = true;
+            return [];
+        }
+        const result = await this.gt.setupProject(files, {
+            locales: this.settings.locales,
+        });
+        if (result.status === 'completed') {
+            this.completed = true;
+            return files;
+        }
+        if (result.status === 'queued') {
+            this.setupJobId = result.setupJobId;
+            return files;
+        }
+        // Unknown status
+        this.completed = true;
+        return files;
+    }
+    async wait() {
+        if (this.completed) {
+            this.spinner.stop(chalk.green('Setup successfully completed'));
+            return;
+        }
+        if (!this.setupJobId) {
+            this.spinner.stop(chalk.yellow('Setup status unknown — proceeding without setup'));
+            return;
+        }
+        // Poll for completion
+        const start = Date.now();
+        const pollInterval = 5000; // 5 seconds
+        while (Date.now() - start < this.timeoutMs) {
+            const status = await this.gt.checkJobStatus([this.setupJobId]);
+            if (!status[0]) {
+                this.spinner.stop(chalk.yellow('Setup status unknown — proceeding without setup'));
+                return;
+            }
+            if (status[0].status === 'completed') {
+                this.spinner.stop(chalk.green('Setup successfully completed'));
+                return;
+            }
+            if (status[0].status === 'failed') {
+                this.spinner.stop(chalk.yellow(`Setup failed: ${status[0].error?.message || 'Unknown error'} — proceeding without setup`));
+                return;
+            }
+            await new Promise((r) => setTimeout(r, pollInterval));
+        }
+        // Timeout
+        this.spinner.stop(chalk.yellow('Setup timed out — proceeding without setup'));
+    }
+}

package/dist/workflow/UploadStep.d.ts

@@ -0,0 +1,21 @@
+import type { FileToUpload } from 'generaltranslation/types';
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+import { BranchData } from '../types/branch.js';
+import type { FileReference } from 'generaltranslation/types';
+export declare class UploadStep extends WorkflowStep<{
+    files: FileToUpload[];
+    branchData: BranchData;
+}, FileReference[]> {
+    private gt;
+    private settings;
+    private spinner;
+    private result;
+    constructor(gt: GT, settings: Settings);
+    run({ files, branchData, }: {
+        files: FileToUpload[];
+        branchData: BranchData;
+    }): Promise<FileReference[]>;
+    wait(): Promise<void>;
+}

package/dist/workflow/UploadStep.js

@@ -0,0 +1,72 @@
+import { WorkflowStep } from './Workflow.js';
+import { createSpinner, logInfo } from '../console/logging.js';
+import chalk from 'chalk';
+export class UploadStep extends WorkflowStep {
+    gt;
+    settings;
+    spinner = createSpinner('dots');
+    result = null;
+    constructor(gt, settings) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+    }
+    async run({ files, branchData, }) {
+        if (files.length === 0) {
+            logInfo('No files to upload found... skipping upload step');
+            return [];
+        }
+        this.spinner.start(`Syncing ${files.length} file${files.length !== 1 ? 's' : ''} with General Translation API...`);
+        // First, figure out which files need to be uploaded
+        const fileData = await this.gt.queryFileData({
+            sourceFiles: files.map((f) => ({
+                fileId: f.fileId,
+                versionId: f.versionId,
+                branchId: f.branchId ?? branchData.currentBranch.id,
+            })),
+        });
+        // build a map of branch:fileId:versionId to fileData
+        const fileDataMap = new Map();
+        fileData.sourceFiles?.forEach((f) => {
+            fileDataMap.set(`${f.branchId}:${f.fileId}:${f.versionId}`, f);
+        });
+        // Build a list of files that need to be uploaded
+        const filesToUpload = [];
+        const filesToSkipUpload = [];
+        files.forEach((f) => {
+            if (fileDataMap.has(`${f.branchId ?? branchData.currentBranch.id}:${f.fileId}:${f.versionId}`)) {
+                filesToSkipUpload.push(f);
+            }
+            else {
+                filesToUpload.push(f);
+            }
+        });
+        const response = await this.gt.uploadSourceFiles(filesToUpload.map((f) => ({
+            source: {
+                ...f,
+                branchId: f.branchId ?? branchData.currentBranch.id,
+                locale: this.settings.defaultLocale,
+                incomingBranchId: branchData.incomingBranch?.id,
+                checkedOutBranchId: branchData.checkedOutBranch?.id,
+            },
+        })), {
+            sourceLocale: this.settings.defaultLocale,
+            modelProvider: this.settings.modelProvider,
+        });
+        this.result = response.uploadedFiles;
+        // Merge files that were already uploaded into the result
+        this.result.push(...filesToSkipUpload.map((f) => ({
+            fileId: f.fileId,
+            versionId: f.versionId,
+            branchId: f.branchId ?? branchData.currentBranch.id,
+            fileName: f.fileName,
+            fileFormat: f.fileFormat,
+            dataFormat: f.dataFormat,
+        })));
+        this.spinner.stop(chalk.green('Files uploaded successfully'));
+        return this.result;
+    }
+    async wait() {
+        return;
+    }
+}

package/dist/workflow/UserEditDiffsStep.d.ts

@@ -0,0 +1,11 @@
+import type { FileReference } from 'generaltranslation/types';
+import { WorkflowStep } from './Workflow.js';
+import { Settings } from '../types/index.js';
+export declare class UserEditDiffsStep extends WorkflowStep<FileReference[], FileReference[]> {
+    private settings;
+    private spinner;
+    private completed;
+    constructor(settings: Settings);
+    run(files: FileReference[]): Promise<FileReference[]>;
+    wait(): Promise<void>;
+}

package/dist/workflow/UserEditDiffsStep.js

@@ -0,0 +1,30 @@
+import { WorkflowStep } from './Workflow.js';
+import { createSpinner } from '../console/logging.js';
+import chalk from 'chalk';
+import { collectAndSendUserEditDiffs } from '../api/collectUserEditDiffs.js';
+export class UserEditDiffsStep extends WorkflowStep {
+    settings;
+    spinner = createSpinner('dots');
+    completed = false;
+    constructor(settings) {
+        super();
+        this.settings = settings;
+    }
+    async run(files) {
+        this.spinner.start('Updating translations...');
+        try {
+            await collectAndSendUserEditDiffs(files, this.settings);
+            this.completed = true;
+        }
+        catch {
+            // Non-fatal; keep going to enqueue
+            this.completed = true;
+        }
+        return files;
+    }
+    async wait() {
+        if (this.completed) {
+            this.spinner.stop(chalk.green('Updated translations'));
+        }
+    }
+}

package/dist/workflow/Workflow.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class WorkflowStep<TInput = void, TOutput = void> {
+    abstract run(input: TInput): Promise<TOutput>;
+    abstract wait(): Promise<void>;
+}

package/dist/workflow/Workflow.js

@@ -0,0 +1,2 @@
+export class WorkflowStep {
+}

package/dist/workflow/download.d.ts

@@ -0,0 +1,22 @@
+import { Settings } from '../types/index.js';
+import { EnqueueFilesResult } from 'generaltranslation/types';
+import { BranchData } from '../types/branch.js';
+export type FileTranslationData = {
+    [fileId: string]: {
+        versionId: string;
+        fileName: string;
+    };
+};
+/**
+ * Checks the status of translations and downloads them using a workflow pattern
+ * @param fileVersionData - Mapping of file IDs to their version and name information
+ * @param jobData - Optional job data from enqueue operation
+ * @param locales - The locales to wait for
+ * @param timeoutDuration - The timeout duration for the wait in seconds
+ * @param resolveOutputPath - Function to resolve the output path for a given source path and locale
+ * @param options - Settings configuration
+ * @param forceRetranslation - Whether to force retranslation
+ * @param forceDownload - Whether to force download even if file exists
+ * @returns True if all translations are downloaded successfully, false otherwise
+ */
+export declare function downloadTranslations(fileVersionData: FileTranslationData, jobData: EnqueueFilesResult | undefined, branchData: BranchData | undefined, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string | null, options: Settings, forceRetranslation?: boolean, forceDownload?: boolean): Promise<boolean>;

package/dist/workflow/download.js

@@ -0,0 +1,104 @@
+import path from 'node:path';
+import { gt } from '../utils/gt.js';
+import { clearLocaleDirs } from '../fs/clearLocaleDirs.js';
+import { PollTranslationJobsStep } from './PollJobsStep.js';
+import { DownloadTranslationsStep } from './DownloadStep.js';
+import { logErrorAndExit } from '../console/logging.js';
+import { BranchStep } from './BranchStep.js';
+/**
+ * Checks the status of translations and downloads them using a workflow pattern
+ * @param fileVersionData - Mapping of file IDs to their version and name information
+ * @param jobData - Optional job data from enqueue operation
+ * @param locales - The locales to wait for
+ * @param timeoutDuration - The timeout duration for the wait in seconds
+ * @param resolveOutputPath - Function to resolve the output path for a given source path and locale
+ * @param options - Settings configuration
+ * @param forceRetranslation - Whether to force retranslation
+ * @param forceDownload - Whether to force download even if file exists
+ * @returns True if all translations are downloaded successfully, false otherwise
+ */
+export async function downloadTranslations(fileVersionData, jobData, branchData, locales, timeoutDuration, resolveOutputPath, options, forceRetranslation, forceDownload) {
+    if (!branchData) {
+        // Run the branch step
+        const branchStep = new BranchStep(gt, options);
+        const branchResult = await branchStep.run();
+        await branchStep.wait();
+        if (!branchResult) {
+            logErrorAndExit('Failed to resolve git branch information.');
+        }
+        branchData = branchResult;
+    }
+    // Prepare the query data
+    const fileQueryData = prepareFileQueryData(fileVersionData, locales, branchData);
+    // Clear translated files before any downloads (if enabled)
+    if (options.options?.experimentalClearLocaleDirs === true &&
+        fileQueryData.length > 0) {
+        const translatedFiles = new Set(fileQueryData
+            .map((file) => {
+            const outputPath = resolveOutputPath(file.fileName, file.locale);
+            // Only clear if the output path is different from the source (i.e., there's a transform)
+            return outputPath !== null && outputPath !== file.fileName
+                ? outputPath
+                : null;
+        })
+            .filter((path) => path !== null));
+        // Derive cwd from config path
+        const cwd = path.dirname(options.config);
+        await clearLocaleDirs(translatedFiles, locales, options.options?.clearLocaleDirsExclude, cwd);
+    }
+    // Initialize download status
+    const fileTracker = {
+        completed: new Map(),
+        inProgress: new Map(),
+        failed: new Map(),
+        skipped: new Map(),
+    };
+    // Step 1: Poll translation jobs if jobData exists
+    if (jobData) {
+        const pollStep = new PollTranslationJobsStep(gt);
+        const pollResult = await pollStep.run({
+            fileTracker,
+            fileQueryData,
+            jobData,
+            timeoutDuration,
+            forceRetranslation,
+        });
+        await pollStep.wait();
+        if (!pollResult.success) {
+            return false;
+        }
+    }
+    else {
+        for (const file of fileQueryData) {
+            // Staging - assume all files are completed
+            fileTracker.completed.set(`${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`, file);
+        }
+    }
+    // Step 2: Download translations
+    const downloadStep = new DownloadTranslationsStep(gt, options);
+    const downloadResult = await downloadStep.run({
+        fileTracker,
+        resolveOutputPath,
+        forceDownload,
+    });
+    await downloadStep.wait();
+    return downloadResult;
+}
+/**
+ * Prepares the file query data from input data and locales
+ */
+function prepareFileQueryData(fileVersionData, locales, branchData) {
+    const fileQueryData = [];
+    for (const fileId in fileVersionData) {
+        for (const locale of locales) {
+            fileQueryData.push({
+                versionId: fileVersionData[fileId].versionId,
+                fileName: fileVersionData[fileId].fileName,
+                fileId,
+                locale,
+                branchId: branchData.currentBranch.id,
+            });
+        }
+    }
+    return fileQueryData;
+}

package/dist/workflow/stage.d.ts

@@ -0,0 +1,14 @@
+import { Settings, TranslateFlags } from '../types/index.js';
+import { EnqueueFilesResult, FileToUpload } from 'generaltranslation/types';
+import { BranchData } from '../types/branch.js';
+/**
+ * Sends multiple files for translation to the API using a workflow pattern
+ * @param files - Array of file objects to translate
+ * @param options - The options for the API call
+ * @param settings - Settings configuration
+ * @returns The translated content or version ID
+ */
+export declare function stageFiles(files: FileToUpload[], options: TranslateFlags, settings: Settings): Promise<{
+    branchData: BranchData;
+    enqueueResult: EnqueueFilesResult;
+}>;

package/dist/workflow/stage.js

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import { logErrorAndExit, logMessage } from '../console/logging.js';
+import { gt } from '../utils/gt.js';
+import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
+import { UploadStep } from './UploadStep.js';
+import { SetupStep } from './SetupStep.js';
+import { EnqueueStep } from './EnqueueStep.js';
+import { BranchStep } from './BranchStep.js';
+import { UserEditDiffsStep } from './UserEditDiffsStep.js';
+/**
+ * Helper: Calculate timeout with validation
+ */
+function calculateTimeout(timeout) {
+    const value = timeout !== undefined ? Number(timeout) : 600;
+    return (Number.isFinite(value) ? value : 600) * 1000;
+}
+/**
+ * Helper: Log files to be translated
+ */
+function logFilesToTranslate(files) {
+    logMessage(chalk.cyan('Files found in project:') +
+        '\n' +
+        files
+            .map((file) => {
+            if (file.fileName === TEMPLATE_FILE_NAME) {
+                return `- <React Elements>`;
+            }
+            return `- ${file.fileName}`;
+        })
+            .join('\n'));
+}
+/**
+ * Sends multiple files for translation to the API using a workflow pattern
+ * @param files - Array of file objects to translate
+ * @param options - The options for the API call
+ * @param settings - Settings configuration
+ * @returns The translated content or version ID
+ */
+export async function stageFiles(files, options, settings) {
+    try {
+        // Log files to be translated
+        logFilesToTranslate(files);
+        // Calculate timeout for setup step
+        const timeoutMs = calculateTimeout(options.timeout);
+        // Create workflow with steps
+        const branchStep = new BranchStep(gt, settings);
+        const uploadStep = new UploadStep(gt, settings);
+        const userEditDiffsStep = new UserEditDiffsStep(settings);
+        const setupStep = new SetupStep(gt, settings, timeoutMs);
+        const enqueueStep = new EnqueueStep(gt, settings, options.force);
+        // first run the branch step
+        const branchData = await branchStep.run();
+        await branchStep.wait();
+        if (!branchData) {
+            logErrorAndExit('Failed to resolve git branch information.');
+        }
+        // then run the upload step
+        const uploadedFiles = await uploadStep.run({ files, branchData });
+        await uploadStep.wait();
+        // optionally run the user edit diffs step
+        if (options?.saveLocal) {
+            await userEditDiffsStep.run(uploadedFiles);
+            await userEditDiffsStep.wait();
+        }
+        // then run the setup step
+        await setupStep.run(uploadedFiles);
+        await setupStep.wait();
+        // then run the enqueue step
+        const enqueueResult = await enqueueStep.run(uploadedFiles);
+        await enqueueStep.wait();
+        return { branchData, enqueueResult };
+    }
+    catch (error) {
+        logErrorAndExit('Failed to send files for translation. ' + error);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.4.15",
+  "version": "2.5.0-alpha.1",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -67,7 +67,7 @@
     "@babel/parser": "^7.25.7",
     "@babel/plugin-transform-react-jsx": "^7.25.9",
     "@babel/traverse": "^7.25.7",
-    "@clack/prompts": "^1.0.0-alpha.1",
+    "@clack/prompts": "^1.0.0-alpha.6",
     "@formatjs/icu-messageformat-parser": "^2.11.4",
     "chalk": "^5.4.1",
     "commander": "^12.1.0",
@@ -77,6 +77,7 @@
     "fast-glob": "^3.3.3",
     "fast-json-stable-stringify": "^2.1.0",
     "form-data": "^4.0.4",
+    "generaltranslation": "8.0.0-alpha.1",
     "gt-remark": "^1.0.1",
     "json-pointer": "^0.6.2",
     "jsonpath-plus": "^10.3.0",
@@ -84,7 +85,6 @@
     "mdast-util-find-and-replace": "^3.0.2",
     "micromatch": "^4.0.8",
     "open": "^10.1.1",
-    "ora": "^8.2.0",
     "remark-frontmatter": "^5.0.0",
     "remark-mdx": "^3.1.0",
     "remark-parse": "^11.0.0",
@@ -93,8 +93,7 @@
     "tsconfig-paths": "^4.2.0",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
-    "yaml": "^2.8.0",
-    "generaltranslation": "7.9.1"
+    "yaml": "^2.8.0"
   },
   "devDependencies": {
     "@babel/types": "^7.28.4",

package/dist/api/checkFileTranslations.d.ts

@@ -1,23 +0,0 @@
-import { Settings } from '../types/index.js';
-export type CheckFileTranslationData = {
-    [key: string]: {
-        versionId: string;
-        fileName: string;
-    };
-};
-/**
- * Checks the status of translations for a given version ID
- * @param apiKey - The API key for the General Translation API
- * @param baseUrl - The base URL for the General Translation API
- * @param versionId - The version ID of the project
- * @param locales - The locales to wait for
- * @param startTime - The start time of the wait
- * @param timeoutDuration - The timeout duration for the wait in seconds
- * @returns True if all translations are deployed, false otherwise
- */
-export declare function checkFileTranslations(data: {
-    [key: string]: {
-        versionId: string;
-        fileName: string;
-    };
-}, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string | null, options: Settings, forceRetranslation?: boolean, forceDownload?: boolean): Promise<boolean>;