gtx-cli 2.3.11 → 2.3.12

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 2.3.12
+
+### Patch Changes
+
+- [#735](https://github.com/generaltranslation/gt/pull/735) [`8e4612e`](https://github.com/generaltranslation/gt/commit/8e4612e0b2c426d64153b6ca460e619fa29cb8e8) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - fix: auto enable gt compiler in default config
+
 ## 2.3.11
 
 ### Patch Changes

package/dist/next/parse/handleInitGT.js

@@ -7,6 +7,7 @@ const traverse = traverseModule.default || traverseModule;
 const generate = generateModule.default || generateModule;
 import * as t from '@babel/types';
 import { logError } from '../../console/logging.js';
+import { needsCJS } from '../../utils/parse/needsCJS.js';
 export async function handleInitGT(filepath, errors, warnings, filesUpdated, packageJson, tsconfigJson) {
     const code = await fs.promises.readFile(filepath, 'utf8');
     let ast;
@@ -17,66 +18,14 @@ export async function handleInitGT(filepath, errors, warnings, filesUpdated, pac
             tokens: true,
             createParenthesizedExpressions: true,
         });
-        // Analyze the actual file content to determine module system
-        let hasES6Imports = false;
-        let hasCommonJSRequire = false;
-        traverse(ast, {
-            ImportDeclaration() {
-                hasES6Imports = true;
-            },
-            CallExpression(path) {
-                if (t.isIdentifier(path.node.callee, { name: 'require' })) {
-                    hasCommonJSRequire = true;
-                }
-            },
+        // Get cjs or esm
+        const cjsEnabled = needsCJS({
+            ast,
+            warnings,
+            filepath,
+            packageJson,
+            tsconfigJson,
         });
-        // Determine if we need CommonJS based on actual file content and fallback to config-based logic
-        let needsCJS = false;
-        if (hasES6Imports && !hasCommonJSRequire) {
-            // File uses ES6 imports, so we should use ES6 imports
-            needsCJS = false;
-        }
-        else if (hasCommonJSRequire && !hasES6Imports) {
-            // File uses CommonJS require, so we should use CommonJS require
-            needsCJS = true;
-        }
-        else if (hasES6Imports && hasCommonJSRequire) {
-            // Mixed usage - this is unusual but we'll default to ES6 imports
-            warnings.push(`Mixed ES6 imports and CommonJS require detected in ${filepath}. Defaulting to ES6 imports.`);
-            needsCJS = false;
-        }
-        else {
-            // No imports/requires found, fall back to configuration-based logic
-            if (filepath.endsWith('.ts') || filepath.endsWith('.tsx')) {
-                // For TypeScript files, check tsconfig.json compilerOptions.module
-                const moduleSetting = tsconfigJson?.compilerOptions?.module;
-                if (moduleSetting === 'commonjs' || moduleSetting === 'node') {
-                    needsCJS = true;
-                }
-                else if (moduleSetting === 'esnext' ||
-                    moduleSetting === 'es2022' ||
-                    moduleSetting === 'es2020' ||
-                    moduleSetting === 'es2015' ||
-                    moduleSetting === 'es6' ||
-                    moduleSetting === 'node16' ||
-                    moduleSetting === 'nodenext') {
-                    needsCJS = false;
-                }
-                else {
-                    // Default to ESM for TypeScript files if no module setting is specified
-                    needsCJS = false;
-                }
-            }
-            else if (filepath.endsWith('.js')) {
-                // For JavaScript files, check package.json type
-                // If package.json has "type": "module", .js files are treated as ES modules
-                needsCJS = packageJson?.type !== 'module';
-            }
-            else {
-                // For other file extensions, default to ESM
-                needsCJS = false;
-            }
-        }
         // Check if withGTConfig or initGT is already imported/required
         let hasGTConfig = false;
         let hasInitGT = false;
@@ -145,7 +94,7 @@ export async function handleInitGT(filepath, errors, warnings, filesUpdated, pac
         if (hasGTConfig || hasInitGT) {
             return;
         }
-        ast.program.body.unshift(needsCJS
+        ast.program.body.unshift(cjsEnabled
             ? t.variableDeclaration('const', [
                 t.variableDeclarator(t.identifier('withGTConfig'), t.memberExpression(t.callExpression(t.identifier('require'), [
                     t.stringLiteral('gt-next/config'),

package/dist/react/parse/addVitePlugin/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Adds the gt compiler plugin to the vite config file
+ */
+export declare function addVitePlugin({ errors, warnings, filesUpdated, packageJson, tsconfigJson, }: {
+    errors: string[];
+    warnings: string[];
+    filesUpdated: string[];
+    packageJson?: {
+        type?: string;
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+    };
+    tsconfigJson?: {
+        compilerOptions?: {
+            module?: string;
+        };
+    };
+}): Promise<{
+    errors: string[];
+    warnings: string[];
+    filesUpdated: string[];
+}>;

package/dist/react/parse/addVitePlugin/index.js

@@ -0,0 +1,40 @@
+import findFilepath from '../../../fs/findFilepath.js';
+import { logError } from '../../../console/logging.js';
+import { installCompiler } from './installCompiler.js';
+import { updateViteConfig } from './updateViteConfig.js';
+const VITE_CONFIG_PATH_BASE = './vite.config.';
+/**
+ * Adds the gt compiler plugin to the vite config file
+ */
+export async function addVitePlugin({ errors, warnings, filesUpdated, packageJson, tsconfigJson, }) {
+    // Resolve file path
+    const viteConfigPath = findFilepath([
+        VITE_CONFIG_PATH_BASE + 'js',
+        VITE_CONFIG_PATH_BASE + 'ts',
+        VITE_CONFIG_PATH_BASE + 'mjs',
+        VITE_CONFIG_PATH_BASE + 'mts',
+        VITE_CONFIG_PATH_BASE + 'cjs',
+        VITE_CONFIG_PATH_BASE + 'cts',
+    ]);
+    if (!viteConfigPath) {
+        logError(`No ${VITE_CONFIG_PATH_BASE}[js|ts|mjs|mts|cjs|cts] file found. Please add the @generaltranslation/compiler plugin to your vite configuration file:
+      import { vite as gtCompiler } from '@generaltranslation/compiler';
+      export default defineConfig({
+        plugins: [gtCompiler()],
+      });
+      `);
+        process.exit(1);
+    }
+    // Install @generaltranslation/compiler if not installed
+    await installCompiler({ packageJson });
+    // Update the config file
+    await updateViteConfig({
+        errors,
+        warnings,
+        filesUpdated,
+        viteConfigPath,
+        packageJson,
+        tsconfigJson,
+    });
+    return { errors, warnings, filesUpdated };
+}

package/dist/react/parse/addVitePlugin/installCompiler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Installs @generaltranslation/compiler if not installed
+ */
+export declare function installCompiler({ packageJson, }: {
+    packageJson?: {
+        type?: string;
+    };
+}): Promise<void>;

package/dist/react/parse/addVitePlugin/installCompiler.js

@@ -0,0 +1,22 @@
+import { createSpinner } from '../../../console/logging.js';
+import { installPackage } from '../../../utils/installPackage.js';
+import { isPackageInstalled } from '../../../utils/packageJson.js';
+import { getPackageManager } from '../../../utils/packageManager.js';
+import chalk from 'chalk';
+/**
+ * Installs @generaltranslation/compiler if not installed
+ */
+export async function installCompiler({ packageJson, }) {
+    // Check if installed
+    if (isPackageInstalled('@generaltranslation/compiler', packageJson || {})) {
+        return;
+    }
+    // Animation
+    const spinner = createSpinner();
+    spinner.start(`Installing @generaltranslation/compiler...`);
+    // Install
+    const packageManager = await getPackageManager();
+    await installPackage('@generaltranslation/compiler', packageManager, true);
+    // Animation
+    spinner.stop(chalk.green('Installed @generaltranslation/compiler.'));
+}

package/dist/react/parse/addVitePlugin/updateViteConfig.d.ts

@@ -0,0 +1,19 @@
+/**
+ * - Reads the vite config file
+ * - Updates the ast to add the gt compiler plugin
+ * - Writes the file back to the filesystem
+ */
+export declare function updateViteConfig({ errors, warnings, filesUpdated, viteConfigPath, packageJson, tsconfigJson, }: {
+    errors: string[];
+    warnings: string[];
+    filesUpdated: string[];
+    viteConfigPath: string;
+    packageJson?: {
+        type?: string;
+    };
+    tsconfigJson?: {
+        compilerOptions?: {
+            module?: string;
+        };
+    };
+}): Promise<void>;

package/dist/react/parse/addVitePlugin/updateViteConfig.js

@@ -0,0 +1,123 @@
+import { createSpinner } from '../../../console/logging.js';
+import { logError } from '../../../console/logging.js';
+import fs from 'node:fs';
+import chalk from 'chalk';
+import generateModule from '@babel/generator';
+import { parse } from '@babel/parser';
+import { needsCJS } from '../../../utils/parse/needsCJS.js';
+import { addCompilerImport } from './utils/addCompilerImport.js';
+import { checkCompilerImport } from './utils/checkCompilerImport.js';
+import { checkPluginInvocation } from './utils/checkPluginInvocation.js';
+import { addPluginInvocation } from './utils/addPluginInvocation.js';
+// Handle CommonJS/ESM interop
+const generate = generateModule.default || generateModule;
+/**
+ * - Reads the vite config file
+ * - Updates the ast to add the gt compiler plugin
+ * - Writes the file back to the filesystem
+ */
+export async function updateViteConfig({ errors, warnings, filesUpdated, viteConfigPath, packageJson, tsconfigJson, }) {
+    // Animation
+    const spinner = createSpinner();
+    spinner.start(`Adding gt compiler plugin to ${viteConfigPath}...`);
+    // Read the file
+    let code;
+    try {
+        code = await fs.promises.readFile(viteConfigPath, 'utf8');
+    }
+    catch (error) {
+        logError(`Error: Failed to read ${viteConfigPath}: ${error}`);
+        process.exit(1);
+        return;
+    }
+    // Update the ast
+    let updatedCode, success;
+    try {
+        ({ updatedCode, success } = await updateViteConfigAst({
+            code,
+            errors,
+            warnings,
+            viteConfigPath,
+            packageJson,
+            tsconfigJson,
+        }));
+    }
+    catch (error) {
+        logError(`Error: Failed to update ${viteConfigPath}: ${error}`);
+        process.exit(1);
+        return;
+    }
+    // Write the file
+    try {
+        await fs.promises.writeFile(viteConfigPath, updatedCode);
+        filesUpdated.push(viteConfigPath);
+    }
+    catch (error) {
+        logError(`Error: Failed to write ${viteConfigPath}: ${error}`);
+        process.exit(1);
+        return;
+    }
+    // Animation
+    spinner.stop(success
+        ? chalk.green(`Success! Added gt compiler plugin to ${viteConfigPath}`)
+        : chalk.red(`Failed to add gt compiler plugin to ${viteConfigPath}. Continuing setup...`));
+}
+/**
+ * Orchestrates AST manipulation
+ * @param code - The code to update
+ * @param errors - The errors to update
+ * @param warnings - The warnings to update
+ * @param viteConfigPath - The path to the vite config file
+ * @param packageJson - The package.json file
+ * @param tsconfigJson - The tsconfig.json file
+ * @returns
+ */
+async function updateViteConfigAst({ code, warnings, viteConfigPath, packageJson, tsconfigJson, }) {
+    // Parse the code
+    const ast = parse(code, {
+        sourceType: 'module',
+        plugins: ['jsx', 'typescript'],
+    });
+    // Get cjs or esm
+    const cjsEnabled = needsCJS({
+        ast,
+        warnings,
+        filepath: viteConfigPath,
+        packageJson,
+        tsconfigJson,
+    });
+    // Check if the compiler import is already present
+    let { hasCompilerImport, alias, namespaces } = checkCompilerImport(ast);
+    // Add the import declaration
+    if (!hasCompilerImport) {
+        addCompilerImport({ ast, cjsEnabled });
+        hasCompilerImport = true;
+        alias = 'gtCompiler';
+        namespaces = [];
+    }
+    // Check if plugin is already present
+    let pluginAlreadyPresent = false;
+    if (hasCompilerImport) {
+        pluginAlreadyPresent = checkPluginInvocation({ ast, alias, namespaces });
+    }
+    // Insert plugin invocation
+    let success = false;
+    if (!pluginAlreadyPresent) {
+        success = addPluginInvocation({ ast, alias, namespaces });
+        if (!success) {
+            warnings.push(`Failed to add gt compiler plugin to ${viteConfigPath}. Please add the plugin manually:
+import { vite as gtCompiler } from '@generaltranslation/compiler';
+export default defineConfig({
+  plugins: [gtCompiler()],
+});`);
+        }
+    }
+    // Generate the modified code
+    const output = generate(ast, {
+        retainLines: true,
+        retainFunctionParens: true,
+        comments: true,
+        compact: 'auto',
+    }, code);
+    return { updatedCode: output.code, success };
+}

package/dist/react/parse/addVitePlugin/utils/addCompilerImport.d.ts

@@ -0,0 +1,9 @@
+import { ParseResult } from '@babel/parser';
+import * as t from '@babel/types';
+/**
+ * Given the vite config file ast, inserts the import declaration for the @generaltranslation/compiler package
+ */
+export declare function addCompilerImport({ ast, cjsEnabled, }: {
+    ast: ParseResult<t.File>;
+    cjsEnabled: boolean;
+}): void;

package/dist/react/parse/addVitePlugin/utils/addCompilerImport.js

@@ -0,0 +1,34 @@
+import * as t from '@babel/types';
+/**
+ * Given the vite config file ast, inserts the import declaration for the @generaltranslation/compiler package
+ */
+export function addCompilerImport({ ast, cjsEnabled, }) {
+    if (cjsEnabled) {
+        handleCjsImport(ast);
+    }
+    else {
+        handleEsmImport(ast);
+    }
+}
+/**
+ * Adds a CJS import declaration for the @generaltranslation/compiler package
+ * @param ast - The ast of the file
+ * const gtCompiler = require('@generaltranslation/compiler').vite;
+ */
+function handleCjsImport(ast) {
+    const variableDeclaration = t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('gtCompiler'), t.memberExpression(t.callExpression(t.identifier('require'), [
+            t.stringLiteral('@generaltranslation/compiler'),
+        ]), t.identifier('vite'))),
+    ]);
+    ast.program.body.unshift(variableDeclaration);
+}
+/**
+ * Adds an ESM import declaration for the @generaltranslation/compiler package
+ * @param ast - The ast of the file
+ * import { vite as gtCompiler } from '@generaltranslation/compiler';
+ */
+function handleEsmImport(ast) {
+    const importDeclaration = t.importDeclaration([t.importSpecifier(t.identifier('gtCompiler'), t.identifier('vite'))], t.stringLiteral('@generaltranslation/compiler'));
+    ast.program.body.unshift(importDeclaration);
+}

package/dist/react/parse/addVitePlugin/utils/addPluginInvocation.d.ts

@@ -0,0 +1,11 @@
+import * as t from '@babel/types';
+import { ParseResult } from '@babel/parser';
+/**
+ * Adds the plugin invocation to the vite config file
+ * Naive solution: look for an object with a plugins property only inside of a defineConfig call
+ */
+export declare function addPluginInvocation({ ast, alias, namespaces, }: {
+    ast: ParseResult<t.File>;
+    alias: string | null;
+    namespaces: string[];
+}): boolean;

package/dist/react/parse/addVitePlugin/utils/addPluginInvocation.js

@@ -0,0 +1,48 @@
+import * as t from '@babel/types';
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+/**
+ * Adds the plugin invocation to the vite config file
+ * Naive solution: look for an object with a plugins property only inside of a defineConfig call
+ */
+export function addPluginInvocation({ ast, alias, namespaces, }) {
+    let addedPlugin = false;
+    if (namespaces.length === 0 && !alias) {
+        return false;
+    }
+    const pluginInvocation = alias
+        ? t.callExpression(t.identifier(alias), [])
+        : t.callExpression(t.memberExpression(t.identifier(namespaces[0]), t.identifier('vite')), []);
+    traverse(ast, {
+        CallExpression(path) {
+            if (!t.isIdentifier(path.node.callee, { name: 'defineConfig' }) ||
+                !path.node.arguments.length ||
+                !t.isObjectExpression(path.node.arguments[0])) {
+                return;
+            }
+            for (const property of path.node.arguments[0].properties) {
+                if (!t.isObjectProperty(property) || !isPluginsProperty(property))
+                    continue;
+                if (t.isArrayExpression(property.value)) {
+                    // Add to array: [react()] -> [react(), gtCompiler()]
+                    property.value.elements.push(pluginInvocation);
+                    addedPlugin = true;
+                }
+                else {
+                    // Spread the array: someList -> [...someList, gtCompiler()]
+                    property.value = t.arrayExpression([
+                        t.spreadElement(property.value),
+                        pluginInvocation,
+                    ]);
+                    addedPlugin = true;
+                }
+            }
+        },
+    });
+    return addedPlugin;
+}
+function isPluginsProperty(node) {
+    return (t.isIdentifier(node.key, { name: 'plugins' }) ||
+        t.isStringLiteral(node.key, { value: 'plugins' }));
+}

package/dist/react/parse/addVitePlugin/utils/checkCompilerImport.d.ts

@@ -0,0 +1,15 @@
+import { ParseResult } from '@babel/parser';
+import * as t from '@babel/types';
+export interface CheckCompilerImportResult {
+    hasCompilerImport: boolean;
+    alias: string | null;
+    namespaces: string[];
+}
+/**
+ * Given the vite config file ast, checks if the @generaltranslation/compiler package is imported.
+ * If it is imported, capture any aliases or namespace.
+ *
+ * Does not handle:
+ * - Nested expressions
+ */
+export declare function checkCompilerImport(ast: ParseResult<t.File>): CheckCompilerImportResult;

package/dist/react/parse/addVitePlugin/utils/checkCompilerImport.js

@@ -0,0 +1,113 @@
+import * as t from '@babel/types';
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+/**
+ * Given the vite config file ast, checks if the @generaltranslation/compiler package is imported.
+ * If it is imported, capture any aliases or namespace.
+ *
+ * Does not handle:
+ * - Nested expressions
+ */
+export function checkCompilerImport(ast) {
+    const result = {
+        hasCompilerImport: false,
+        alias: null,
+        namespaces: [],
+    };
+    traverse(ast, {
+        ImportDeclaration(path) {
+            handleImportDeclaration(path, result);
+        },
+        VariableDeclaration(path) {
+            handleVariableDeclaration(path, result);
+        },
+    });
+    return result;
+}
+/* =============================== */
+/* Parsing Functions */
+/* =============================== */
+/**
+ * Checks an import declaration for a compiler import
+ * @param path - The import declaration path
+ * @param result - The result object
+ */
+function handleImportDeclaration(path, result) {
+    if (path.node.source.value !== '@generaltranslation/compiler')
+        return;
+    for (const spec of path.node.specifiers) {
+        if (t.isImportSpecifier(spec)) {
+            // Handle named import: import { vite as gtCompiler } from '@generaltranslation/compiler'
+            if (t.isIdentifier(spec.imported) && spec.imported.name === 'vite') {
+                result.hasCompilerImport = true;
+                result.alias = spec.local.name;
+            }
+        }
+        else {
+            // Handle default import: import gtCompiler from '@generaltranslation/compiler'
+            // Handle namespace import: import * as gtCompiler from '@generaltranslation/compiler'
+            result.hasCompilerImport = true;
+            result.namespaces.push(spec.local.name);
+        }
+    }
+}
+/**
+ * Handles a variable declaration for a compiler import
+ * @param path - The variable declaration path
+ * @param result - The result object
+ */
+function handleVariableDeclaration(path, result) {
+    path.node.declarations.forEach((dec) => {
+        // Handle destructuring: const { withGTConfig } = require('@generaltranslation/compiler')
+        if (t.isCallExpression(dec.init) &&
+            t.isIdentifier(dec.init.callee, { name: 'require' }) &&
+            t.isStringLiteral(dec.init.arguments[0], {
+                value: '@generaltranslation/compiler',
+            })) {
+            if (t.isIdentifier(dec.id)) {
+                // Handle namespace assignment: const gtCompiler = require('@generaltranslation/compiler')
+                result.hasCompilerImport = true;
+                result.namespaces.push(dec.id.name);
+            }
+            else if (t.isObjectPattern(dec.id)) {
+                // Handle destructuring: const { vite: gtCompiler } = require('@generaltranslation/compiler')
+                let foundVite = false;
+                const restElements = [];
+                for (const prop of dec.id.properties) {
+                    if (t.isObjectProperty(prop) &&
+                        t.isIdentifier(prop.key) &&
+                        t.isIdentifier(prop.value) &&
+                        prop.key.name === 'vite') {
+                        // Handle destructing alias assignment: const { vite: gtCompiler } = require('@generaltranslation/compiler')
+                        result.hasCompilerImport = true;
+                        result.alias = prop.value.name;
+                        foundVite = true;
+                        break;
+                    }
+                    else if (t.isRestElement(prop) && t.isIdentifier(prop.argument)) {
+                        // Track list of rest elements
+                        restElements.push(prop.argument.name);
+                    }
+                }
+                // Handle destructuring rest elements: const { ...some, b, ...others, d } = require('@generaltranslation/compiler')
+                if (!foundVite && restElements.length > 0) {
+                    result.hasCompilerImport = true;
+                    result.namespaces.push(...restElements);
+                }
+            }
+        }
+        else if (t.isMemberExpression(dec.init) &&
+            t.isCallExpression(dec.init.object) &&
+            t.isIdentifier(dec.init.object.callee, { name: 'require' }) &&
+            t.isStringLiteral(dec.init.object.arguments[0], {
+                value: '@generaltranslation/compiler',
+            }) &&
+            t.isIdentifier(dec.init.property, { name: 'vite' }) &&
+            t.isIdentifier(dec.id)) {
+            // Handle member access: const gtCompiler = require('@generaltranslation/compiler').vite
+            result.hasCompilerImport = true;
+            result.alias = dec.id.name;
+        }
+    });
+}

package/dist/react/parse/addVitePlugin/utils/checkPluginInvocation.d.ts

@@ -0,0 +1,12 @@
+import { ParseResult } from '@babel/parser';
+import * as t from '@babel/types';
+/**
+ * Checks if the given AST is exporting the gtCompiler plugin
+ *
+ * Naive check: see if the plugin has been invoked anywhere in the file
+ */
+export declare function checkPluginInvocation({ ast, alias, namespaces, }: {
+    ast: ParseResult<t.File>;
+    alias: string | null;
+    namespaces: string[];
+}): boolean;

package/dist/react/parse/addVitePlugin/utils/checkPluginInvocation.js

@@ -0,0 +1,32 @@
+import * as t from '@babel/types';
+import traverseModule from '@babel/traverse';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+/**
+ * Checks if the given AST is exporting the gtCompiler plugin
+ *
+ * Naive check: see if the plugin has been invoked anywhere in the file
+ */
+export function checkPluginInvocation({ ast, alias, namespaces, }) {
+    let result = false;
+    traverse(ast, {
+        CallExpression(path) {
+            // Handle: gtCompiler()
+            if (!alias)
+                return;
+            if (t.isIdentifier(path.node.callee, { name: alias })) {
+                result = true;
+            }
+        },
+        MemberExpression(path) {
+            // Handle: gtCompiler.vite()
+            if (t.isIdentifier(path.node.object) &&
+                namespaces.includes(path.node.object.name) &&
+                t.isCallExpression(path.parent) &&
+                t.isIdentifier(path.node.property, { name: 'vite' })) {
+                result = true;
+            }
+        },
+    });
+    return result;
+}

package/dist/setup/wizard.js

@@ -12,6 +12,7 @@ import { getPackageManager } from '../utils/packageManager.js';
 import { installPackage } from '../utils/installPackage.js';
 import { createOrUpdateConfig } from '../fs/config/setupConfig.js';
 import { loadConfig } from '../fs/config/loadConfig.js';
+import { addVitePlugin } from '../react/parse/addVitePlugin/index.js';
 export async function handleSetupReactCommand(options) {
     // Ask user for confirmation using inquirer
     const answer = await promptConfirm({
@@ -73,6 +74,9 @@ Please let us know what you would like to see supported at https://github.com/ge
     const errors = [];
     const warnings = [];
     let filesUpdated = [];
+    // Read tsconfig.json if it exists
+    const tsconfigPath = findFilepath(['tsconfig.json']);
+    const tsconfigJson = tsconfigPath ? loadConfig(tsconfigPath) : undefined;
     if (frameworkType === 'next-app') {
         // Check if they have a next.config.js file
         const nextConfigPath = findFilepath([
@@ -98,13 +102,20 @@ Please let us know what you would like to see supported at https://github.com/ge
         const { filesUpdated: filesUpdatedNext } = await wrapContentNext(mergeOptions, 'gt-next', errors, warnings);
         filesUpdated = [...filesUpdated, ...filesUpdatedNext];
         spinner.stop(chalk.green(`Success! Updated ${chalk.bold.cyan(filesUpdated.length)} files:\n`) + filesUpdated.map((file) => `${chalk.green('-')} ${file}`).join('\n'));
-        // Read tsconfig.json if it exists
-        const tsconfigPath = findFilepath(['tsconfig.json']);
-        const tsconfigJson = tsconfigPath ? loadConfig(tsconfigPath) : undefined;
         // Add the withGTConfig() function to the next.config.js file
         await handleInitGT(nextConfigPath, errors, warnings, filesUpdated, packageJson, tsconfigJson);
         logStep(chalk.green(`Added withGTConfig() to your ${nextConfigPath} file.`));
     }
+    // Add gt compiler plugin
+    if (frameworkType === 'vite') {
+        await addVitePlugin({
+            errors,
+            warnings,
+            filesUpdated,
+            packageJson,
+            tsconfigJson,
+        });
+    }
     if (errors.length > 0) {
         logError(chalk.red('Failed to write files:\n') + errors.join('\n'));
     }

package/dist/utils/parse/needsCJS.d.ts

@@ -0,0 +1,20 @@
+import { ParseResult } from '@babel/parser';
+import * as t from '@babel/types';
+/**
+ * Given an AST determines if the file needs to be compiled as CommonJS or ESM.
+ * @param ast - The AST to analyze
+ * @returns True if the file needs to be compiled as CommonJS, false if it needs to be compiled as ESM
+ */
+export declare function needsCJS({ ast, warnings, filepath, packageJson, tsconfigJson, }: {
+    ast: ParseResult<t.File>;
+    warnings: string[];
+    filepath: string;
+    packageJson?: {
+        type?: string;
+    };
+    tsconfigJson?: {
+        compilerOptions?: {
+            module?: string;
+        };
+    };
+}): boolean;

package/dist/utils/parse/needsCJS.js

@@ -0,0 +1,72 @@
+import traverseModule from '@babel/traverse';
+import * as t from '@babel/types';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+/**
+ * Given an AST determines if the file needs to be compiled as CommonJS or ESM.
+ * @param ast - The AST to analyze
+ * @returns True if the file needs to be compiled as CommonJS, false if it needs to be compiled as ESM
+ */
+export function needsCJS({ ast, warnings, filepath, packageJson, tsconfigJson, }) {
+    // Analyze the actual file content to determine module system
+    let hasES6Imports = false;
+    let hasCommonJSRequire = false;
+    traverse(ast, {
+        ImportDeclaration() {
+            hasES6Imports = true;
+        },
+        CallExpression(path) {
+            if (t.isIdentifier(path.node.callee, { name: 'require' })) {
+                hasCommonJSRequire = true;
+            }
+        },
+    });
+    // Determine if we need CommonJS based on actual file content and fallback to config-based logic
+    let needsCJS = false;
+    if (hasES6Imports && !hasCommonJSRequire) {
+        // File uses ES6 imports, so we should use ES6 imports
+        needsCJS = false;
+    }
+    else if (hasCommonJSRequire && !hasES6Imports) {
+        // File uses CommonJS require, so we should use CommonJS require
+        needsCJS = true;
+    }
+    else if (hasES6Imports && hasCommonJSRequire) {
+        // Mixed usage - this is unusual but we'll default to ES6 imports
+        warnings.push(`Mixed ES6 imports and CommonJS require detected in ${filepath}. Defaulting to ES6 imports.`);
+        needsCJS = false;
+    }
+    else {
+        // No imports/requires found, fall back to configuration-based logic
+        if (filepath.endsWith('.ts') || filepath.endsWith('.tsx')) {
+            // For TypeScript files, check tsconfig.json compilerOptions.module
+            const moduleSetting = tsconfigJson?.compilerOptions?.module;
+            if (moduleSetting === 'commonjs' || moduleSetting === 'node') {
+                needsCJS = true;
+            }
+            else if (moduleSetting === 'esnext' ||
+                moduleSetting === 'es2022' ||
+                moduleSetting === 'es2020' ||
+                moduleSetting === 'es2015' ||
+                moduleSetting === 'es6' ||
+                moduleSetting === 'node16' ||
+                moduleSetting === 'nodenext') {
+                needsCJS = false;
+            }
+            else {
+                // Default to ESM for TypeScript files if no module setting is specified
+                needsCJS = false;
+            }
+        }
+        else if (filepath.endsWith('.js')) {
+            // For JavaScript files, check package.json type
+            // If package.json has "type": "module", .js files are treated as ES modules
+            needsCJS = packageJson?.type !== 'module';
+        }
+        else {
+            // For other file extensions, default to ESM
+            needsCJS = false;
+        }
+    }
+    return needsCJS;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.3.11",
+  "version": "2.3.12",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [