gtx-cli 2.6.17 → 2.6.19

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # gtx-cli
 
+## 2.6.19
+
+### Patch Changes
+
+- [#1014](https://github.com/generaltranslation/gt/pull/1014) [`e421292`](https://github.com/generaltranslation/gt/commit/e421292739807db8696d7912da8b92731fb34b2b) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - refactor: library names
+
+- [#1018](https://github.com/generaltranslation/gt/pull/1018) [`3ac2e30`](https://github.com/generaltranslation/gt/commit/3ac2e30dcd76bf5819f1a385397eb59bcc158732) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - fix: gt-react-native inline tx
+
+## 2.6.18
+
+### Patch Changes
+
+- [#1009](https://github.com/generaltranslation/gt/pull/1009) [`ffd6995`](https://github.com/generaltranslation/gt/commit/ffd6995d57e5444157071696e533ee29abcc2df4) Thanks [@pie575](https://github.com/pie575)! - added ai instructions on how to use the gt library
+
+- [#1013](https://github.com/generaltranslation/gt/pull/1013) [`d01b29c`](https://github.com/generaltranslation/gt/commit/d01b29c0f5a4442f49a1ab6d8d5ee72403c6fa17) Thanks [@pie575](https://github.com/pie575)! - added flag to update-instructions add comments to ai files even if they weren't there before
+
+- [#1007](https://github.com/generaltranslation/gt/pull/1007) [`7aaac80`](https://github.com/generaltranslation/gt/commit/7aaac80b67f4f6ffa8d9ef9aa00f6fc669596003) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - chore: add gt-node support
+
 ## 2.6.17
 
 ### Patch Changes

package/dist/cli/base.d.ts

@@ -30,4 +30,6 @@ export declare class BaseCLI {
     protected handleUploadCommand(settings: Settings & UploadOptions): Promise<void>;
     protected handleInitCommand(ranReactSetup: boolean, useDefaults?: boolean): Promise<void>;
     protected handleLoginCommand(options: LoginOptions): Promise<void>;
+    protected setupUpdateInstructionsCommand(): void;
+    protected promptAgentInstructions(useDefaults?: boolean): Promise<void>;
 }

package/dist/cli/base.js

@@ -29,6 +29,9 @@ import processSharedStaticAssets, { mirrorAssetsToLocales, } from '../utils/shar
 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';
 export class BaseCLI {
     library;
     additionalModules;
@@ -43,6 +46,7 @@ export class BaseCLI {
         this.setupUploadCommand();
         this.setupLoginCommand();
         this.setupSendDiffsCommand();
+        this.setupUpdateInstructionsCommand();
     }
     // Init is never called in a child class
     init() {
@@ -158,13 +162,8 @@ export class BaseCLI {
             displayHeader('Authenticating with General Translation...');
             if (!options.keyType) {
                 const packageJson = await searchForPackageJson();
-                const isUsingGTNext = packageJson
-                    ? isPackageInstalled('gt-next', packageJson)
-                    : false;
-                const isUsingGTReact = packageJson
-                    ? isPackageInstalled('gt-react', packageJson)
-                    : false;
-                if (isUsingGTNext || isUsingGTReact) {
+                if (packageJson &&
+                    INLINE_LIBRARIES.some((lib) => isPackageInstalled(lib, packageJson))) {
                     options.keyType = 'development';
                 }
                 else {
@@ -209,6 +208,7 @@ export class BaseCLI {
             })();
             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 {
@@ -250,6 +250,7 @@ export class BaseCLI {
                 }
                 // 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');
             }
         });
@@ -294,14 +295,10 @@ export class BaseCLI {
     async handleInitCommand(ranReactSetup, useDefaults = false) {
         const { defaultLocale, locales } = await getDesiredLocales(); // Locales should still be asked for even if using defaults
         const packageJson = await searchForPackageJson();
-        const isUsingGTNext = packageJson
-            ? isPackageInstalled('gt-next', packageJson)
-            : false;
-        const isUsingGTReact = packageJson
-            ? isPackageInstalled('gt-react', packageJson)
-            : false;
         // Ask if using another i18n library
-        const isUsingGT = isUsingGTNext || isUsingGTReact || ranReactSetup;
+        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)
@@ -414,4 +411,69 @@ See https://generaltranslation.com/en/docs/next/guides/local-tx`);
         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/flags.d.ts

@@ -1,4 +1,15 @@
 import { Command } from 'commander';
 export declare function attachSharedFlags(command: Command): Command;
 export declare function attachTranslateFlags(command: Command): Command;
-export declare function attachAdditionalReactTranslateFlags(command: Command): Command;
+/**
+ * Attaches flags necessary for validating a project
+ * @param command
+ * @returns The command with the validate flags attached
+ */
+export declare function attachValidateFlags(command: Command): Command;
+/**
+ * Attaches flags necessary for translating a project
+ * @param command
+ * @returns The command with the translate flags attached
+ */
+export declare function attachInlineTranslateFlags(command: Command): Command;

package/dist/cli/flags.js

@@ -40,12 +40,31 @@ export function attachTranslateFlags(command) {
         .option('--remote-name <name>', 'Specify a custom remote name to use for branch detection', DEFAULT_GIT_REMOTE_NAME);
     return command;
 }
-export function attachAdditionalReactTranslateFlags(command) {
-    command
+/**
+ * Attaches flags necessary for parsing inline content
+ * @param command - The command to attach the flags to
+ * @returns The command with the inline content parsing flags attached
+ */
+function attachInlineContentParsingFlags(command) {
+    return command
         .option('--tsconfig, --jsconfig <path>', 'Path to custom jsconfig or tsconfig file', findFilepath(['./tsconfig.json', './jsconfig.json']))
         .option('--dictionary <path>', 'Path to dictionary file')
         .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('--inline', 'Include inline <T> tags in addition to dictionary file', true)
-        .option('--ignore-errors', 'Ignore errors encountered while scanning for <T> tags', false);
-    return command;
+        .option('--inline', 'Include inline content in translations (e.g., inline jsx translations, inline string translations, etc.)', true);
+}
+/**
+ * Attaches flags necessary for validating a project
+ * @param command
+ * @returns The command with the validate flags attached
+ */
+export function attachValidateFlags(command) {
+    return attachInlineContentParsingFlags(command.option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', findFilepath(['gt.config.json'])));
+}
+/**
+ * Attaches flags necessary for translating a project
+ * @param command
+ * @returns The command with the translate flags attached
+ */
+export function attachInlineTranslateFlags(command) {
+    return attachInlineContentParsingFlags(command.option('--ignore-errors', 'Ignore errors encountered while scanning for inline content', false));
 }

package/dist/cli/inline.d.ts

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { BaseCLI } from './base.js';
+import { SupportedLibraries, TranslateFlags, Options } from '../types/index.js';
+import { InlineLibrary } from '../types/libraries.js';
+/**
+ * Stand in for a CLI tool that does any sort of inline content translations
+ */
+export declare class InlineCLI extends BaseCLI {
+    constructor(command: Command, library: InlineLibrary, additionalModules?: SupportedLibraries[]);
+    init(): void;
+    protected setupStageCommand(): void;
+    protected setupTranslateCommand(): void;
+    protected setupValidateCommand(): void;
+    protected setupGenerateSourceCommand(): void;
+    protected handleGenerateSourceCommand(initOptions: TranslateFlags): Promise<void>;
+    protected handleValidate(initOptions: Options, files?: string[]): Promise<void>;
+}

package/dist/cli/inline.js

@@ -0,0 +1,133 @@
+import { BaseCLI } from './base.js';
+import { attachInlineTranslateFlags, attachTranslateFlags, attachValidateFlags, } from './flags.js';
+import { displayHeader, exitSync } from '../console/logging.js';
+import { logger } from '../console/logger.js';
+import { intro } from '@clack/prompts';
+import chalk from 'chalk';
+import { resolveLocaleFiles } from '../fs/config/parseFilesConfig.js';
+import { noFilesError } from '../console/index.js';
+import { saveJSON } from '../fs/saveJSON.js';
+import loadJSON from '../fs/loadJSON.js';
+import { generateSettings } from '../config/generateSettings.js';
+import { aggregateInlineTranslations } from '../translation/stage.js';
+import { validateConfigExists } from '../config/validateSettings.js';
+import { validateProject } from '../translation/validate.js';
+import { Libraries } from '../types/libraries.js';
+/**
+ * Stand in for a CLI tool that does any sort of inline content translations
+ */
+export class InlineCLI extends BaseCLI {
+    constructor(command, library, additionalModules) {
+        super(command, library, additionalModules);
+    }
+    init() {
+        this.setupStageCommand();
+        this.setupTranslateCommand();
+        this.setupGenerateSourceCommand();
+        this.setupValidateCommand();
+    }
+    setupStageCommand() {
+        attachInlineTranslateFlags(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);
+            logger.endCommand('Done!');
+        });
+    }
+    setupTranslateCommand() {
+        attachInlineTranslateFlags(attachTranslateFlags(this.program
+            .command('translate')
+            .description('Scans the project for a dictionary and inline translations and sends the updates to the General Translation API for translation.'))).action(async (options) => {
+            displayHeader('Translating project...');
+            await this.handleTranslate(options);
+            logger.endCommand('Done!');
+        });
+    }
+    setupValidateCommand() {
+        attachValidateFlags(this.program
+            .command('validate [files...]')
+            .description('Scans the project for a dictionary and/or inline content and validates the project for errors.')).action(async (files, options) => {
+            // intro here since we don't want to show the ascii title
+            intro(chalk.cyan('Validating project...'));
+            await this.handleValidate(options, files);
+            logger.endCommand('Done!');
+        });
+    }
+    setupGenerateSourceCommand() {
+        attachInlineTranslateFlags(attachTranslateFlags(this.program
+            .command('generate')
+            .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);
+            logger.endCommand('Done!');
+        });
+    }
+    async handleGenerateSourceCommand(initOptions) {
+        const settings = await generateSettings(initOptions);
+        const updates = await aggregateInlineTranslations(initOptions, settings, fallbackToGtReact(this.library));
+        // Convert updates to the proper data format
+        const newData = {};
+        for (const update of updates) {
+            const { source, metadata } = update;
+            const { hash, id } = metadata;
+            if (id) {
+                newData[id] = source;
+            }
+            else {
+                newData[hash] = source;
+            }
+        }
+        // Save source file if files.json is provided
+        if (settings.files && settings.files.placeholderPaths.gt) {
+            const translationFiles = resolveLocaleFiles(settings.files.placeholderPaths, settings.defaultLocale);
+            if (!translationFiles.gt) {
+                logger.error(noFilesError);
+                exitSync(1);
+            }
+            await saveJSON(translationFiles.gt, newData);
+            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);
+                if (!translationsFile.gt) {
+                    continue;
+                }
+                const existingTranslations = loadJSON(translationsFile.gt);
+                const mergedTranslations = {
+                    ...newData,
+                    ...existingTranslations,
+                };
+                // Filter out keys that don't exist in newData
+                const filteredTranslations = Object.fromEntries(Object.entries(mergedTranslations).filter(([key]) => newData[key]));
+                await saveJSON(translationsFile.gt, filteredTranslations);
+            }
+            logger.step('Merged translations successfully!');
+        }
+    }
+    async handleValidate(initOptions, files) {
+        validateConfigExists();
+        const settings = await generateSettings(initOptions);
+        // First run the base class's handleTranslate method
+        const options = { ...initOptions, ...settings };
+        // Fallback to gt-react
+        const pkg = fallbackToGtReact(this.library);
+        if (files && files.length > 0) {
+            // Validate specific files using createInlineUpdates
+            await validateProject(options, pkg, files);
+        }
+        else {
+            // Validate whole project as before
+            await validateProject(options, pkg);
+        }
+    }
+}
+function fallbackToGtReact(library) {
+    return [
+        Libraries.GT_NEXT,
+        Libraries.GT_NODE,
+        Libraries.GT_REACT_NATIVE,
+    ].includes(library)
+        ? library
+        : Libraries.GT_REACT;
+}

package/dist/cli/next.d.ts

@@ -1,10 +1,9 @@
 import { WrapOptions, SupportedFrameworks, SupportedLibraries } from '../types/index.js';
 import { ReactCLI } from './react.js';
 import { Command } from 'commander';
+import { Libraries } from '../types/libraries.js';
 export declare class NextCLI extends ReactCLI {
-    constructor(command: Command, library: 'gt-next', additionalModules?: SupportedLibraries[]);
-    init(): void;
-    execute(): void;
+    constructor(command: Command, library: typeof Libraries.GT_NEXT, additionalModules?: SupportedLibraries[]);
     protected wrapContent(options: WrapOptions, framework: SupportedFrameworks, errors: string[], warnings: string[]): Promise<{
         filesUpdated: string[];
     }>;

package/dist/cli/next.js

@@ -1,20 +1,11 @@
 import { ReactCLI } from './react.js';
 import { wrapContentNext } from '../next/parse/wrapContent.js';
-const pkg = 'gt-next';
+import { Libraries } from '../types/libraries.js';
+const pkg = Libraries.GT_NEXT;
 export class NextCLI extends ReactCLI {
     constructor(command, library, additionalModules) {
         super(command, library, additionalModules);
     }
-    init() {
-        this.setupSetupProjectCommand();
-        this.setupStageCommand();
-        this.setupTranslateCommand();
-        this.setupGenerateSourceCommand();
-        this.setupValidateCommand();
-    }
-    execute() {
-        super.execute();
-    }
     wrapContent(options, framework, errors, warnings) {
         return wrapContentNext(options, pkg, errors, warnings);
     }

package/dist/cli/node.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+import { SupportedLibraries } from '../types/index.js';
+import { InlineCLI } from './inline.js';
+import { Libraries } from '../types/libraries.js';
+/**
+ * CLI tool for managing translations with gt-node
+ */
+export declare class NodeCLI extends InlineCLI {
+    constructor(command: Command, library: typeof Libraries.GT_NODE, additionalModules?: SupportedLibraries[]);
+}

package/dist/cli/node.js

@@ -0,0 +1,9 @@
+import { InlineCLI } from './inline.js';
+/**
+ * CLI tool for managing translations with gt-node
+ */
+export class NodeCLI extends InlineCLI {
+    constructor(command, library, additionalModules) {
+        super(command, library, additionalModules);
+    }
+}

package/dist/cli/react.d.ts

@@ -1,19 +1,12 @@
 import { Command } from 'commander';
-import { Options, SupportedFrameworks, WrapOptions, SupportedLibraries, TranslateFlags } from '../types/index.js';
-import { BaseCLI } from './base.js';
-export declare class ReactCLI extends BaseCLI {
-    constructor(command: Command, library: 'gt-react' | 'gt-next', additionalModules?: SupportedLibraries[]);
+import { Framework, SupportedFrameworks, WrapOptions, SupportedLibraries } from '../types/index.js';
+import { InlineCLI } from './inline.js';
+export declare class ReactCLI extends InlineCLI {
+    constructor(command: Command, library: Framework, additionalModules?: SupportedLibraries[]);
     init(): void;
-    execute(): void;
     protected wrapContent(options: WrapOptions, framework: SupportedFrameworks, errors: string[], warnings: string[]): Promise<{
         filesUpdated: string[];
     }>;
     protected setupSetupProjectCommand(): void;
-    protected setupStageCommand(): void;
-    protected setupTranslateCommand(): void;
-    protected setupValidateCommand(): void;
-    protected setupGenerateSourceCommand(): void;
-    protected handleGenerateSourceCommand(initOptions: TranslateFlags): Promise<void>;
     protected handleScanCommand(options: WrapOptions): Promise<void>;
-    protected handleValidate(initOptions: Options, files?: string[]): Promise<void>;
 }

package/dist/cli/react.js

@@ -1,40 +1,26 @@
 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';
 import { formatFiles } from '../hooks/postProcess.js';
-import { BaseCLI } from './base.js';
 import { wrapContentReact } from '../react/parse/wrapContent.js';
 import { generateSettings } from '../config/generateSettings.js';
-import { saveJSON } from '../fs/saveJSON.js';
-import { resolveLocaleFiles } from '../fs/config/parseFilesConfig.js';
-import { noFilesError } from '../console/index.js';
-import { aggregateReactTranslations } from '../translation/stage.js';
-import { validateConfigExists } from '../config/validateSettings.js';
-import { validateProject } from '../translation/validate.js';
-import { intro } from '@clack/prompts';
-import { attachAdditionalReactTranslateFlags, attachTranslateFlags, } from './flags.js';
-const pkg = 'gt-react';
-export class ReactCLI extends BaseCLI {
+import { attachInlineTranslateFlags, attachTranslateFlags } from './flags.js';
+import { InlineCLI } from './inline.js';
+import { Libraries } from '../types/libraries.js';
+const pkg = Libraries.GT_REACT;
+export class ReactCLI extends InlineCLI {
     constructor(command, library, additionalModules) {
         super(command, library, additionalModules);
     }
     init() {
+        super.init();
         this.setupSetupProjectCommand();
-        this.setupStageCommand();
-        this.setupTranslateCommand();
-        this.setupGenerateSourceCommand();
-        this.setupValidateCommand();
-    }
-    execute() {
-        super.execute();
     }
     wrapContent(options, framework, errors, warnings) {
         return wrapContentReact(options, pkg, framework, errors, warnings);
     }
     setupSetupProjectCommand() {
-        attachAdditionalReactTranslateFlags(attachTranslateFlags(this.program
+        attachInlineTranslateFlags(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...');
@@ -42,91 +28,6 @@ export class ReactCLI extends BaseCLI {
             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);
-            logger.endCommand('Done!');
-        });
-    }
-    setupTranslateCommand() {
-        attachAdditionalReactTranslateFlags(attachTranslateFlags(this.program
-            .command('translate')
-            .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);
-            logger.endCommand('Done!');
-        });
-    }
-    setupValidateCommand() {
-        this.program
-            .command('validate [files...]')
-            .description('Scans the project for a dictionary and/or <T> tags, and validates the project for errors.')
-            .option('-c, --config <path>', 'Filepath to config file, by default gt.config.json', findFilepath(['gt.config.json']))
-            .option('--tsconfig, --jsconfig <path>', 'Path to jsconfig or tsconfig file', findFilepath(['./tsconfig.json', './jsconfig.json']))
-            .option('--dictionary <path>', 'Path to dictionary file')
-            .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('--inline', 'Include inline <T> tags in addition to dictionary file', true)
-            .action(async (files, options) => {
-            // intro here since we don't want to show the ascii title
-            intro(chalk.cyan('Validating project...'));
-            await this.handleValidate(options, files);
-            logger.endCommand('Done!');
-        });
-    }
-    setupGenerateSourceCommand() {
-        attachAdditionalReactTranslateFlags(attachTranslateFlags(this.program
-            .command('generate')
-            .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);
-            logger.endCommand('Done!');
-        });
-    }
-    async handleGenerateSourceCommand(initOptions) {
-        const settings = await generateSettings(initOptions);
-        const updates = await aggregateReactTranslations(initOptions, settings, this.library === 'gt-next' ? 'gt-next' : 'gt-react');
-        // Convert updates to the proper data format
-        const newData = {};
-        for (const update of updates) {
-            const { source, metadata } = update;
-            const { hash, id } = metadata;
-            if (id) {
-                newData[id] = source;
-            }
-            else {
-                newData[hash] = source;
-            }
-        }
-        // Save source file if files.json is provided
-        if (settings.files && settings.files.placeholderPaths.gt) {
-            const translationFiles = resolveLocaleFiles(settings.files.placeholderPaths, settings.defaultLocale);
-            if (!translationFiles.gt) {
-                logger.error(noFilesError);
-                exitSync(1);
-            }
-            await saveJSON(translationFiles.gt, newData);
-            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);
-                if (!translationsFile.gt) {
-                    continue;
-                }
-                const existingTranslations = loadJSON(translationsFile.gt);
-                const mergedTranslations = {
-                    ...newData,
-                    ...existingTranslations,
-                };
-                // Filter out keys that don't exist in newData
-                const filteredTranslations = Object.fromEntries(Object.entries(mergedTranslations).filter(([key]) => newData[key]));
-                await saveJSON(translationsFile.gt, filteredTranslations);
-            }
-            logger.step('Merged translations successfully!');
-        }
-    }
     async handleScanCommand(options) {
         // Ask user for confirmation using inquirer
         const answer = await promptConfirm({
@@ -168,19 +69,4 @@ export class ReactCLI extends BaseCLI {
                     .join('\n'));
         }
     }
-    async handleValidate(initOptions, files) {
-        validateConfigExists();
-        const settings = await generateSettings(initOptions);
-        // First run the base class's handleTranslate method
-        const options = { ...initOptions, ...settings };
-        const pkg = this.library === 'gt-next' ? 'gt-next' : 'gt-react';
-        if (files && files.length > 0) {
-            // Validate specific files using createInlineUpdates
-            await validateProject(options, pkg, files);
-        }
-        else {
-            // Validate whole project as before
-            await validateProject(options, pkg);
-        }
-    }
 }

package/dist/formats/files/collectFiles.js

@@ -1,16 +1,17 @@
 import { logErrorAndExit } from '../../console/logging.js';
 import { invalidConfigurationError } from '../../console/index.js';
 import { aggregateFiles } from '../../formats/files/translate.js';
-import { aggregateReactTranslations } from '../../translation/stage.js';
+import { aggregateInlineTranslations } from '../../translation/stage.js';
 import { hashStringSync } from '../../utils/hash.js';
 import { TEMPLATE_FILE_NAME, TEMPLATE_FILE_ID } from '../../utils/constants.js';
+import { isInlineLibrary } from '../../types/libraries.js';
 export async function collectFiles(options, settings, library) {
     // Aggregate files
     const allFiles = await aggregateFiles(settings);
     // Parse for React components
     let reactComponents = 0;
-    if (library === 'gt-react' || library === 'gt-next') {
-        const updates = await aggregateReactTranslations(options, settings, library);
+    if (isInlineLibrary(library)) {
+        const updates = await aggregateInlineTranslations(options, settings, library);
         if (updates.length > 0) {
             if (!settings.publish && !settings.files?.placeholderPaths.gt) {
                 logErrorAndExit(invalidConfigurationError);