gtx-cli 2.4.15 → 2.5.0-alpha.1

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

@@ -1,6 +1,8 @@
-import { SendFilesResult } from '../../api/sendFiles.js';
+import { EnqueueFilesResult } from 'generaltranslation/types';
 import { TranslateFlags } from '../../types/index.js';
 import { Settings } from '../../types/index.js';
-export declare function handleTranslate(options: TranslateFlags, settings: Settings, filesTranslationResponse: SendFilesResult | undefined): Promise<void>;
+import { FileTranslationData } from '../../workflow/download.js';
+import { BranchData } from '../../types/branch.js';
+export declare function handleTranslate(options: TranslateFlags, settings: Settings, fileVersionData: FileTranslationData | undefined, jobData: EnqueueFilesResult | undefined, branchData: BranchData | undefined): Promise<void>;
 export declare function handleDownload(options: TranslateFlags, settings: Settings): Promise<void>;
 export declare function postProcessTranslations(settings: Settings, includeFiles?: Set<string>): Promise<void>;

package/dist/cli/commands/translate.js

@@ -1,4 +1,4 @@
-import { checkFileTranslations } from '../../api/checkFileTranslations.js';
+import { downloadTranslations, } from '../../workflow/download.js';
 import { createFileMapping } from '../../formats/files/fileMapping.js';
 import { logError } from '../../console/logging.js';
 import { getStagedVersions } from '../../fs/config/updateVersions.js';
@@ -9,13 +9,12 @@ import processAnchorIds from '../../utils/processAnchorIds.js';
 import { noFilesError, noVersionIdError } from '../../console/index.js';
 import localizeStaticImports from '../../utils/localizeStaticImports.js';
 // Downloads translations that were completed
-export async function handleTranslate(options, settings, filesTranslationResponse) {
-    if (filesTranslationResponse) {
+export async function handleTranslate(options, settings, fileVersionData, jobData, branchData) {
+    if (fileVersionData) {
         const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
         const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
-        const { data } = filesTranslationResponse;
         // Check for remaining translations
-        await checkFileTranslations(data, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale]?.[sourcePath] ?? null, settings, options.force, options.forceDownload);
+        await downloadTranslations(fileVersionData, jobData, branchData, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale]?.[sourcePath] ?? null, settings, options.force, options.forceDownload);
     }
 }
 // Downloads translations that were originally staged
@@ -33,7 +32,7 @@ export async function handleDownload(options, settings) {
     const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
     const stagedVersionData = await getStagedVersions(settings.configDirectory);
     // Check for remaining translations
-    await checkFileTranslations(stagedVersionData, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings, false, // force is not applicable for downloading staged translations
+    await downloadTranslations(stagedVersionData, undefined, undefined, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings, false, // force is not applicable for downloading staged translations
     options.forceDownload);
 }
 export async function postProcessTranslations(settings, includeFiles) {

package/dist/cli/flags.js

@@ -28,7 +28,10 @@ export function attachTranslateFlags(command) {
         .option('--experimental-localize-static-imports', 'Triggering this will run a script after the cli tool that localizes all static imports in content files. Currently only supported for md and mdx files.', false)
         .option('--force', 'Force a retranslation, invalidating all existing cached translations if they exist.', false)
         .option('--force-download', 'Force download and overwrite local files, bypassing gt-lock.json checks.', false)
-        .option('--experimental-clear-locale-dirs', 'Clear locale directories before downloading new translations', false);
+        .option('--experimental-clear-locale-dirs', 'Clear locale directories before downloading new translations', false)
+        .option('--branch <branch>', 'Specify a custom branch to use for translations')
+        .option('--disable-branch-detection', 'Disable additional branch detection and optimizations and use the manually specified branch', false)
+        .option('--enable-branching', 'Enable branching for the project', false); // disabled by default for now
     return command;
 }
 export function attachAdditionalReactTranslateFlags(command) {

package/dist/config/generateSettings.js

@@ -159,6 +159,16 @@ export async function generateSettings(flags, cwd = process.cwd()) {
     mergedOptions.parsingOptions = mergedOptions.parsingOptions || {};
     mergedOptions.parsingOptions.conditionNames = mergedOptions.parsingOptions
         .conditionNames || ['browser', 'module', 'import', 'require', 'default'];
+    // Add branch options if not provided
+    const branchOptions = mergedOptions.branchOptions || {};
+    branchOptions.enabled = flags.enableBranching ?? false;
+    branchOptions.currentBranch =
+        flags.branch ?? gtConfig.branchOptions?.currentBranch ?? undefined;
+    branchOptions.autoDetectBranches = flags.disableBranchDetection
+        ? false
+        : true;
+    branchOptions.remoteName = gtConfig.branchOptions?.remoteName ?? 'origin';
+    mergedOptions.branchOptions = branchOptions;
     // if there's no existing config file, creates one
     // does not include the API key to avoid exposing it
     if (!fs.existsSync(mergedOptions.config)) {

package/dist/console/logging.d.ts

@@ -15,7 +15,7 @@ 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 createOraSpinner(indicator?: 'dots' | 'circleHalves'): Promise<import("ora").Ora>;
+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,4 +1,4 @@
-import { log, spinner, intro, outro, text, select, confirm, isCancel, cancel, multiselect, } from '@clack/prompts';
+import { log, spinner, intro, outro, text, select, confirm, isCancel, cancel, multiselect, progress, } from '@clack/prompts';
 import chalk from 'chalk';
 import { getCLIVersion } from '../utils/packageJson.js';
 // Basic logging functions
@@ -81,9 +81,8 @@ export function createSpinner(indicator = 'timer') {
     return spinner({ indicator });
 }
 // Spinner functionality
-export async function createOraSpinner(indicator = 'circleHalves') {
-    const ora = await import('ora');
-    return ora.default({ spinner: indicator });
+export function createProgressBar(total) {
+    return progress({ max: total });
 }
 // Input prompts
 export async function promptText({ message, defaultValue, validate, }) {

package/dist/formats/files/translate.d.ts

@@ -1,4 +1,4 @@
 import { Settings } from '../../types/index.js';
-import { FileToTranslate } from '../../types/data.js';
+import type { FileToUpload } from '../../types/data.js';
 export declare const SUPPORTED_DATA_FORMATS: string[];
-export declare function aggregateFiles(settings: Settings): Promise<FileToTranslate[]>;
+export declare function aggregateFiles(settings: Settings): Promise<FileToUpload[]>;

package/dist/formats/files/translate.js

@@ -7,6 +7,7 @@ import parseYaml from '../yaml/parseYaml.js';
 import YAML from 'yaml';
 import { determineLibrary } from '../../fs/determineFramework.js';
 import { isValidMdx } from '../../utils/validateMdx.js';
+import { hashStringSync } from '../../utils/hash.js';
 export const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
 export async function aggregateFiles(settings) {
     // Aggregate all files to translate
@@ -50,6 +51,8 @@ export async function aggregateFiles(settings) {
             }
             const parsedJson = parseJson(content, filePath, settings.options || {}, settings.defaultLocale);
             return {
+                fileId: hashStringSync(relativePath),
+                versionId: hashStringSync(parsedJson),
                 content: parsedJson,
                 fileName: relativePath,
                 fileFormat: 'JSON',
@@ -65,7 +68,7 @@ export async function aggregateFiles(settings) {
             }
             return true;
         });
-        allFiles.push(...jsonFiles);
+        allFiles.push(...jsonFiles.filter((file) => file !== null));
     }
     // Process YAML files
     if (filePaths.yaml) {
@@ -86,18 +89,18 @@ export async function aggregateFiles(settings) {
                 content: parsedYaml,
                 fileName: relativePath,
                 fileFormat,
+                fileId: hashStringSync(relativePath),
+                versionId: hashStringSync(parsedYaml),
             };
         })
             .filter((file) => {
-            if (!file)
-                return false;
-            if (typeof file.content !== 'string' || !file.content.trim()) {
-                logWarning(`Skipping ${file.fileName}: YAML file is empty`);
+            if (!file || typeof file.content !== 'string' || !file.content.trim()) {
+                logWarning(`Skipping ${file?.fileName ?? 'unknown'}: YAML file is empty`);
                 return false;
             }
             return true;
         });
-        allFiles.push(...yamlFiles);
+        allFiles.push(...yamlFiles.filter((file) => file !== null));
     }
     for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
         if (fileType === 'json' || fileType === 'yaml')
@@ -119,6 +122,8 @@ export async function aggregateFiles(settings) {
                     content: sanitizedContent,
                     fileName: relativePath,
                     fileFormat: fileType.toUpperCase(),
+                    fileId: hashStringSync(relativePath),
+                    versionId: hashStringSync(content),
                 };
             })
                 .filter((file) => {
@@ -130,7 +135,7 @@ export async function aggregateFiles(settings) {
                 }
                 return true;
             });
-            allFiles.push(...files);
+            allFiles.push(...files.filter((file) => file !== null));
         }
     }
     if (allFiles.length === 0 && !settings.publish) {

package/dist/fs/config/downloadedVersions.d.ts

@@ -1,12 +1,19 @@
 export type DownloadedVersionEntry = {
-    versionId: string;
-    fileId?: string;
     fileName?: string;
     updatedAt?: string;
 };
 export type DownloadedVersions = {
     version: number;
-    entries: Record<string, DownloadedVersionEntry>;
+    entries: {
+        [branchId: string]: {
+            [fileId: string]: {
+                [versionId: string]: {
+                    [locale: string]: DownloadedVersionEntry;
+                };
+            };
+        };
+    };
 };
 export declare function getDownloadedVersions(configDirectory: string): DownloadedVersions;
 export declare function saveDownloadedVersions(configDirectory: string, lock: DownloadedVersions): void;
+export declare function ensureNestedObject(obj: any, path: string[]): any;

package/dist/fs/config/downloadedVersions.js

@@ -40,3 +40,11 @@ export function saveDownloadedVersions(configDirectory, lock) {
         logError(`An error occurred while updating ${GT_LOCK_FILE}: ${error}`);
     }
 }
+export function ensureNestedObject(obj, path) {
+    return path.reduce((current, key, index) => {
+        if (index === path.length - 1)
+            return current;
+        current[key] = current[key] || {};
+        return current[key];
+    }, obj);
+}

package/dist/fs/config/updateVersions.d.ts

@@ -1,4 +1,5 @@
-type StagedVersionData = Record<string, {
+type StagedVersionData = Record<string, // fileId
+{
     fileName: string;
     versionId: string;
 }>;

package/dist/git/branches.d.ts

@@ -0,0 +1,7 @@
+export declare function getCurrentBranch(remoteName: string): Promise<{
+    currentBranchName: string;
+    defaultBranch: boolean;
+    defaultBranchName: string;
+} | null>;
+export declare function getIncomingBranches(remoteName: string): Promise<string[]>;
+export declare function getCheckedOutBranches(remoteName: string): Promise<string[]>;

package/dist/git/branches.js

@@ -0,0 +1,88 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(execFile);
+const MAX_BRANCHES = 5;
+export async function getCurrentBranch(remoteName) {
+    try {
+        const { stdout } = await execAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        const currentBranchName = stdout.trim();
+        // Get the default branch (usually main or master)
+        const { stdout: defaultBranchRef } = await execAsync('git', ['symbolic-ref', `refs/remotes/${remoteName}/HEAD`], { encoding: 'utf8', windowsHide: true });
+        const defaultBranchName = defaultBranchRef
+            .trim()
+            .replace(`refs/remotes/${remoteName}/`, '');
+        const defaultBranch = currentBranchName === defaultBranchName;
+        return { currentBranchName, defaultBranch, defaultBranchName };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getIncomingBranches(remoteName) {
+    try {
+        // Get merge commits into the current branch
+        const { stdout } = await execAsync('git', [
+            'log',
+            '--merges',
+            '--first-parent',
+            '--pretty=format:%s',
+            `-${MAX_BRANCHES}`,
+        ], {
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        if (!stdout.trim()) {
+            return [];
+        }
+        const branches = [];
+        const lines = stdout.trim().split('\n');
+        for (const line of lines) {
+            // Parse merge commit messages:
+            // - "Merge branch 'feature-name'" or "Merge branch 'feature-name' into main"
+            // - "Merge pull request #123 from user/branch-name"
+            const branchMatch = line.match(/Merge branch '([^']+)'/);
+            const prMatch = line.match(/Merge pull request #\d+ from [^/]+\/(.+)/);
+            if (branchMatch && branchMatch[1]) {
+                branches.push(branchMatch[1]);
+            }
+            else if (prMatch && prMatch[1]) {
+                branches.push(prMatch[1]);
+            }
+        }
+        return branches.slice(0, MAX_BRANCHES);
+    }
+    catch {
+        // If log fails or no merges found, return empty array
+        return [];
+    }
+}
+export async function getCheckedOutBranches(remoteName) {
+    try {
+        // Get current branch
+        const currentBranchResult = await getCurrentBranch(remoteName);
+        if (!currentBranchResult) {
+            return [];
+        }
+        // If we're already on the default branch, return empty
+        if (currentBranchResult.defaultBranch) {
+            return [];
+        }
+        // Check if there's a merge-base (common ancestor) between default branch and current
+        // This means the branch was at some point checked out from the default branch
+        try {
+            await execAsync('git', ['merge-base', currentBranchResult.defaultBranchName, 'HEAD'], { encoding: 'utf8', windowsHide: true });
+            // If merge-base exists, the branch shares history with default branch
+            return [currentBranchResult.defaultBranchName];
+        }
+        catch {
+            // No common ancestor found
+            return [];
+        }
+    }
+    catch {
+        return [];
+    }
+}

package/dist/types/branch.d.ts

@@ -0,0 +1,14 @@
+export type BranchData = {
+    currentBranch: {
+        id: string;
+        name: string;
+    };
+    incomingBranch: {
+        id: string;
+        name: string;
+    } | null;
+    checkedOutBranch: {
+        id: string;
+        name: string;
+    } | null;
+};

package/dist/types/branch.js

@@ -0,0 +1 @@
+export {};

package/dist/types/data.d.ts

@@ -17,7 +17,7 @@ export type JSONDictionary = {
 export type FlattenedJSONDictionary = {
     [key: string]: string;
 };
-export type { FileFormat, DataFormat, FileToTranslate, } from 'generaltranslation/types';
+export type { FileFormat, DataFormat, FileToUpload, } from 'generaltranslation/types';
 export type JsxChildren = string | string[] | any;
 export type Translations = {
     [key: string]: JsxChildren;

package/dist/types/files.d.ts

@@ -1 +1,8 @@
 export type FileMapping = Record<string, Record<string, string>>;
+export type FileProperties = {
+    versionId: string;
+    fileName: string;
+    fileId: string;
+    locale: string;
+    branchId: string;
+};

package/dist/types/index.d.ts

@@ -133,6 +133,13 @@ export type Settings = {
     options?: AdditionalOptions;
     modelProvider?: string;
     parsingOptions: ParsingConfigOptions;
+    branchOptions: BranchOptions;
+};
+export type BranchOptions = {
+    currentBranch?: string;
+    autoDetectBranches?: boolean;
+    remoteName: string;
+    enabled: boolean;
 };
 export type AdditionalOptions = {
     jsonSchema?: {

package/dist/utils/SpinnerManager.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Centralized spinner management for tracking multiple async operations
+ */
+export declare class SpinnerManager {
+    private spinners;
+    /**
+     * Run an async operation with a spinner
+     */
+    run<T>(id: string, message: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Mark a spinner as successful
+     */
+    succeed(id: string, message: string): void;
+    /**
+     * Mark a spinner as warning
+     */
+    warn(id: string, message: string): void;
+    /**
+     * Start a new spinner
+     */
+    start(id: string, message: string): void;
+    /**
+     * Stop a specific spinner
+     */
+    stop(id: string, message?: string): void;
+    /**
+     * Stop all running spinners
+     */
+    stopAll(): void;
+}

package/dist/utils/SpinnerManager.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import { createSpinner } from '../console/logging.js';
+/**
+ * Centralized spinner management for tracking multiple async operations
+ */
+export class SpinnerManager {
+    spinners = new Map();
+    /**
+     * Run an async operation with a spinner
+     */
+    async run(id, message, fn) {
+        const spinner = createSpinner('dots');
+        this.spinners.set(id, spinner);
+        spinner.start(message);
+        try {
+            const result = await fn();
+            spinner.stop(chalk.green('✓'));
+            return result;
+        }
+        catch (error) {
+            spinner.stop(chalk.red('✗'));
+            throw error;
+        }
+        finally {
+            this.spinners.delete(id);
+        }
+    }
+    /**
+     * Mark a spinner as successful
+     */
+    succeed(id, message) {
+        const spinner = this.spinners.get(id);
+        if (spinner) {
+            spinner.stop(chalk.green(message));
+            this.spinners.delete(id);
+        }
+    }
+    /**
+     * Mark a spinner as warning
+     */
+    warn(id, message) {
+        const spinner = this.spinners.get(id);
+        if (spinner) {
+            spinner.stop(chalk.yellow(message));
+            this.spinners.delete(id);
+        }
+    }
+    /**
+     * Start a new spinner
+     */
+    start(id, message) {
+        const spinner = createSpinner('dots');
+        this.spinners.set(id, spinner);
+        spinner.start(message);
+    }
+    /**
+     * Stop a specific spinner
+     */
+    stop(id, message) {
+        const spinner = this.spinners.get(id);
+        if (spinner) {
+            spinner.stop(message);
+            this.spinners.delete(id);
+        }
+    }
+    /**
+     * Stop all running spinners
+     */
+    stopAll() {
+        this.spinners.forEach((s) => s.stop());
+        this.spinners.clear();
+    }
+}

package/dist/utils/gitDiff.js

@@ -9,24 +9,26 @@ const execFileAsync = promisify(execFile);
  * Throws if git is unavailable or another error occurs.
  */
 export async function getGitUnifiedDiff(oldPath, newPath) {
-    const res = await execFileAsync('git', [
-        'diff',
-        '--no-index',
-        '--text',
-        '--unified=3',
-        '--no-color',
-        '--',
-        oldPath,
-        newPath,
-    ], {
-        windowsHide: true,
-    }).catch((error) => {
+    try {
+        const res = await execFileAsync('git', [
+            'diff',
+            '--no-index',
+            '--text',
+            '--unified=3',
+            '--no-color',
+            '--',
+            oldPath,
+            newPath,
+        ], {
+            windowsHide: true,
+        });
+        return res.stdout || '';
+    }
+    catch (error) {
         // Exit code 1 means differences found; stdout contains the diff
         if (error && error.code === 1 && typeof error.stdout === 'string') {
-            return { stdout: error.stdout };
+            return error.stdout;
         }
         throw error;
-    });
-    // When there are no changes, stdout is empty string and exit code 0
-    return res.stdout || '';
+    }
 }

package/dist/workflow/BranchStep.d.ts

@@ -0,0 +1,13 @@
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+import { BranchData } from '../types/branch.js';
+export declare class BranchStep extends WorkflowStep<null, BranchData | null> {
+    private spinner;
+    private branchData;
+    private settings;
+    private gt;
+    constructor(gt: GT, settings: Settings);
+    run(): Promise<BranchData | null>;
+    wait(): Promise<void>;
+}