gtx-cli 2.6.17 → 2.6.18

package/dist/react/jsx/utils/constants.d.ts

@@ -1,6 +1,6 @@
 export declare const DECLARE_VAR_FUNCTION = "declareVar";
 export declare const DECLARE_STATIC_FUNCTION = "declareStatic";
-export declare const MSG_TRANSLATION_FUNCTION = "msg";
+export declare const MSG_REGISTRATION_FUNCTION = "msg";
 export declare const INLINE_TRANSLATION_HOOK = "useGT";
 export declare const INLINE_TRANSLATION_HOOK_ASYNC = "getGT";
 export declare const INLINE_MESSAGE_HOOK = "useMessages";
@@ -12,6 +12,13 @@ export declare const VARIABLE_COMPONENTS: string[];
 export declare const GT_ATTRIBUTES_WITH_SUGAR: readonly ["$id", "$context", "$maxChars"];
 export declare const GT_ATTRIBUTES: readonly ["id", "context", "maxChars", "$id", "$context", "$maxChars"];
 export declare function mapAttributeName(attrName: string): string;
-export declare const GT_LIBRARIES: readonly ["gt-react", "gt-next", "gt-react-native", "gt-i18n", "@generaltranslation/react-core"];
+export declare const GT_LIBRARIES: readonly ["gt-react", "gt-next", "gt-react-native", "gt-node", "gt-i18n", "@generaltranslation/react-core"];
 export type GTLibrary = (typeof GT_LIBRARIES)[number];
+/**
+ * GT Libraries that use react translations
+ */
+export type GTReactLibrary = 'gt-react' | 'gt-react-native' | 'gt-next' | '@generaltranslation/react-core';
+/**
+ * A mapping of each library to their upstream dependencies for filtering imports
+ */
 export declare const GT_LIBRARIES_UPSTREAM: Record<GTLibrary, GTLibrary[]>;

package/dist/react/jsx/utils/constants.js

@@ -1,6 +1,6 @@
 export const DECLARE_VAR_FUNCTION = 'declareVar';
 export const DECLARE_STATIC_FUNCTION = 'declareStatic';
-export const MSG_TRANSLATION_FUNCTION = 'msg';
+export const MSG_REGISTRATION_FUNCTION = 'msg';
 export const INLINE_TRANSLATION_HOOK = 'useGT';
 export const INLINE_TRANSLATION_HOOK_ASYNC = 'getGT';
 export const INLINE_MESSAGE_HOOK = 'useMessages';
@@ -13,7 +13,7 @@ export const GT_TRANSLATION_FUNCS = [
     INLINE_TRANSLATION_HOOK_ASYNC,
     INLINE_MESSAGE_HOOK,
     INLINE_MESSAGE_HOOK_ASYNC,
-    MSG_TRANSLATION_FUNCTION,
+    MSG_REGISTRATION_FUNCTION,
     DECLARE_VAR_FUNCTION,
     DECLARE_STATIC_FUNCTION,
     TRANSLATION_COMPONENT,
@@ -57,9 +57,13 @@ export const GT_LIBRARIES = [
     'gt-react',
     'gt-next',
     'gt-react-native',
+    'gt-node',
     'gt-i18n',
     '@generaltranslation/react-core',
 ];
+/**
+ * A mapping of each library to their upstream dependencies for filtering imports
+ */
 export const GT_LIBRARIES_UPSTREAM = {
     'gt-next': [
         'gt-i18n',
@@ -79,6 +83,7 @@ export const GT_LIBRARIES_UPSTREAM = {
         'gt-react-native',
         'gt-react', // allow for cross-library compatibility (gt-react/gt-react-native only)
     ],
+    'gt-node': ['gt-i18n', '@generaltranslation/react-core', 'gt-node'],
     '@generaltranslation/react-core': [
         'gt-i18n',
         '@generaltranslation/react-core',

package/dist/react/jsx/utils/getPathsAndAliases.js

@@ -1,5 +1,5 @@
 import traverseModule from '@babel/traverse';
-import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_TRANSLATION_FUNCTION, TRANSLATION_COMPONENT, } from '../../jsx/utils/constants.js';
+import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, MSG_REGISTRATION_FUNCTION, TRANSLATION_COMPONENT, } from '../../jsx/utils/constants.js';
 import { extractImportName } from './parseAst.js';
 // Handle CommonJS/ESM interop
 const traverse = traverseModule.default || traverseModule;
@@ -23,7 +23,7 @@ export function getPathsAndAliases(ast, pkgs) {
                         name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
                         name.original === INLINE_MESSAGE_HOOK ||
                         name.original === INLINE_MESSAGE_HOOK_ASYNC ||
-                        name.original === MSG_TRANSLATION_FUNCTION) {
+                        name.original === MSG_REGISTRATION_FUNCTION) {
                         inlineTranslationPaths.push({
                             localName: name.local,
                             path,
@@ -60,8 +60,7 @@ export function getPathsAndAliases(ast, pkgs) {
                             if (name.original === INLINE_TRANSLATION_HOOK ||
                                 name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
                                 name.original === INLINE_MESSAGE_HOOK ||
-                                name.original === INLINE_MESSAGE_HOOK_ASYNC ||
-                                name.original === MSG_TRANSLATION_FUNCTION) {
+                                name.original === INLINE_MESSAGE_HOOK_ASYNC) {
                                 inlineTranslationPaths.push({
                                     localName: name.local,
                                     path: parentPath,

package/dist/react/jsx/utils/parseStringFunction.js

@@ -1,6 +1,6 @@
 import * as t from '@babel/types';
 import { isStaticExpression, isValidIcu } from '../evaluateJsx.js';
-import { GT_ATTRIBUTES_WITH_SUGAR, MSG_TRANSLATION_FUNCTION, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, mapAttributeName, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, } from './constants.js';
+import { GT_ATTRIBUTES_WITH_SUGAR, MSG_REGISTRATION_FUNCTION, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, mapAttributeName, INLINE_MESSAGE_HOOK, INLINE_MESSAGE_HOOK_ASYNC, } from './constants.js';
 import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, warnInvalidIcuSync, warnInvalidMaxCharsSync, } from '../../../console/index.js';
 import generateModule from '@babel/generator';
 import traverseModule from '@babel/traverse';
@@ -432,7 +432,7 @@ export function parseStrings(importName, originalName, path, config, output) {
     const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
     for (const refPath of referencePaths) {
         // Handle msg() calls directly without variable assignment
-        if (originalName === MSG_TRANSLATION_FUNCTION) {
+        if (originalName === MSG_REGISTRATION_FUNCTION) {
             const msgConfig = {
                 parsingOptions: config.parsingOptions,
                 file: config.file,

package/dist/react/parse/createInlineUpdates.js

@@ -41,24 +41,26 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
             }, { updates, errors, warnings });
         }
         // Parse <T> components
-        for (const { localName, path } of translationComponentPaths) {
-            parseTranslationComponent({
-                originalName: localName,
-                localName,
-                path,
-                updates,
-                config: {
-                    importAliases,
-                    parsingOptions,
-                    pkgs,
-                    file,
-                },
-                output: {
-                    errors,
-                    warnings,
-                    unwrappedExpressions: [],
-                },
-            });
+        if (pkg !== 'gt-node') {
+            for (const { localName, path } of translationComponentPaths) {
+                parseTranslationComponent({
+                    originalName: localName,
+                    localName,
+                    path,
+                    updates,
+                    config: {
+                        importAliases,
+                        parsingOptions,
+                        pkgs,
+                        file,
+                    },
+                    output: {
+                        errors,
+                        warnings,
+                        unwrappedExpressions: [],
+                    },
+                });
+            }
         }
     }
     // Post processing steps:
@@ -69,7 +71,8 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
 }
 /**
  * Given a package name, return the upstream packages that it depends on
- * @param pkg
+ * @param pkg - The package name
+ * @returns The upstream packages that the package depends on
  */
 function getUpstreamPackages(pkg) {
     return GT_LIBRARIES_UPSTREAM[pkg];

package/dist/setup/agentInstructions.d.ts

@@ -0,0 +1,24 @@
+import { SupportedLibraries } from '../types/index.js';
+export declare const CURSOR_GT_RULES_FILE = ".cursor/rules/gt-i18n.mdc";
+/**
+ * Detect existing AI agent instruction files in the project.
+ */
+export declare function findAgentFiles(): string[];
+/**
+ * Find agent files that already contain GT instructions.
+ */
+export declare function findAgentFilesWithInstructions(): string[];
+/**
+ * Check if the .cursor/rules/ directory exists (for offering to create gt-i18n.mdc).
+ */
+export declare function hasCursorRulesDir(): boolean;
+/**
+ * Generate GT agent instructions content based on the detected library.
+ */
+export declare function getAgentInstructions(library: SupportedLibraries): string;
+/**
+ * Append or replace GT instructions in an agent file.
+ * Skips writing if the file already contains identical instructions.
+ * For .cursor/rules/gt.md, writes the file fresh (dedicated GT rules file).
+ */
+export declare function appendAgentInstructions(filePath: string, instructions: string): boolean;

package/dist/setup/agentInstructions.js

@@ -0,0 +1,135 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getCLIVersion, getPackageVersion } from '../utils/packageJson.js';
+const INSTRUCTIONS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'instructions');
+const AGENT_FILE_PATHS = [
+    'CLAUDE.md',
+    'AGENTS.md',
+    'GPT.md',
+    'CHATGPT.md',
+    '.cursorrules',
+];
+const CURSOR_RULES_DIR = '.cursor/rules';
+export const CURSOR_GT_RULES_FILE = '.cursor/rules/gt-i18n.mdc';
+const GT_SECTION_START = '<!-- GT I18N RULES START -->';
+const GT_SECTION_END = '<!-- GT I18N RULES END -->';
+function getLibraryVersion(library) {
+    const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+    if (!fs.existsSync(packageJsonPath))
+        return undefined;
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        return getPackageVersion(library, packageJson);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Detect existing AI agent instruction files in the project.
+ */
+export function findAgentFiles() {
+    const cwd = process.cwd();
+    const found = [];
+    for (const filePath of [...AGENT_FILE_PATHS, CURSOR_GT_RULES_FILE]) {
+        const fullPath = path.resolve(cwd, filePath);
+        if (fs.existsSync(fullPath)) {
+            found.push(filePath);
+        }
+    }
+    return found;
+}
+/**
+ * Find agent files that already contain GT instructions.
+ */
+export function findAgentFilesWithInstructions() {
+    const cwd = process.cwd();
+    const found = [];
+    for (const filePath of [...AGENT_FILE_PATHS, CURSOR_GT_RULES_FILE]) {
+        const fullPath = path.resolve(cwd, filePath);
+        if (fs.existsSync(fullPath)) {
+            const content = fs.readFileSync(fullPath, 'utf8');
+            if (content.includes(GT_SECTION_START)) {
+                found.push(filePath);
+            }
+        }
+    }
+    return found;
+}
+/**
+ * Check if the .cursor/rules/ directory exists (for offering to create gt-i18n.mdc).
+ */
+export function hasCursorRulesDir() {
+    const cursorRulesDir = path.resolve(process.cwd(), CURSOR_RULES_DIR);
+    return (fs.existsSync(cursorRulesDir) && fs.statSync(cursorRulesDir).isDirectory());
+}
+/**
+ * Generate GT agent instructions content based on the detected library.
+ */
+export function getAgentInstructions(library) {
+    const libraryVersion = getLibraryVersion(library);
+    const versionLine = libraryVersion
+        ? `- **${library}**: ${libraryVersion}\n- **gtx-cli**: v${getCLIVersion()}`
+        : `- **gtx-cli**: v${getCLIVersion()}`;
+    const base = fs.readFileSync(path.join(INSTRUCTIONS_DIR, 'base.md'), 'utf8');
+    let body = '';
+    const libToFile = {
+        'gt-next': 'gt-next.md',
+        'gt-react': 'gt-react.md',
+    };
+    const instructionFile = libToFile[library];
+    if (instructionFile) {
+        body += '\n\n'; // add two newlines between the base and the specific instructions
+        body += fs.readFileSync(path.join(INSTRUCTIONS_DIR, instructionFile), 'utf8');
+    }
+    return `${GT_SECTION_START}
+
+${versionLine}
+
+${base}${body}
+${GT_SECTION_END}`;
+}
+/**
+ * Append or replace GT instructions in an agent file.
+ * Skips writing if the file already contains identical instructions.
+ * For .cursor/rules/gt.md, writes the file fresh (dedicated GT rules file).
+ */
+export function appendAgentInstructions(filePath, instructions) {
+    const fullPath = path.resolve(process.cwd(), filePath);
+    // For .cursor/rules/gt.md, write as a standalone file with frontmatter
+    if (filePath === CURSOR_GT_RULES_FILE) {
+        const cursorContent = `---\ndescription: GT internationalization instructions\nalwaysApply: true\n---\n${instructions}\n`;
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        if (fs.existsSync(fullPath)) {
+            const existing = fs.readFileSync(fullPath, 'utf8');
+            if (existing === cursorContent)
+                return false;
+        }
+        fs.writeFileSync(fullPath, cursorContent, 'utf8');
+        return true;
+    }
+    // For other files, read existing content and append/replace
+    let content = '';
+    if (fs.existsSync(fullPath)) {
+        content = fs.readFileSync(fullPath, 'utf8');
+    }
+    // Already has identical instructions — skip
+    if (content.includes(instructions))
+        return false;
+    const startIdx = content.indexOf(GT_SECTION_START);
+    const endIdx = startIdx !== -1 ? content.indexOf(GT_SECTION_END, startIdx) : -1;
+    if (startIdx !== -1 && endIdx !== -1) {
+        // Replace existing section
+        const before = content.substring(0, startIdx);
+        const after = content.substring(endIdx + GT_SECTION_END.length);
+        content = before + instructions + after;
+    }
+    else {
+        // Append to end
+        const separator = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
+        content = content + separator + '\n' + instructions + '\n';
+    }
+    fs.writeFileSync(fullPath, content, 'utf8');
+    return true;
+}

package/dist/setup/instructions/base.md

@@ -0,0 +1,29 @@
+## General Translation (GT) Internationalization Rules
+
+This project is using [General Translation](https://generaltranslation.com/docs/overview.md) for internationalization (i18n) and translations. General Translation is a developer-first localization stack, built for the world's best engineering teams to ship apps in every language with ease.
+
+### Configuration
+
+The General Translation configuration file is called `gt.config.json`. It is usually located in the root or src directory of a project.
+
+```json
+{
+  "defaultLocale": "en",
+  "locales": ["es", "fr", "de"],
+  "files": {
+    "json": {
+      "include": ["./**/[locale]/*.json"]
+    }
+  }
+}
+```
+
+The API reference for the config file can be found at https://generaltranslation.com/docs/cli/reference/config.md.
+
+### Translation
+
+Run `npx gtx-cli translate` to create translation files for your project. You must have an API key to do this.
+
+### Documentation 
+
+https://generaltranslation.com/llms.txt

package/dist/setup/instructions/gt-next.md

@@ -0,0 +1,107 @@
+### gt-next
+
+This project is using the `gt-next` internationalization library for Next.js App Router.
+
+### gt-next setup
+
+- `GTProvider` must wrap the app in the root layout to provide translation context.
+- The `withGTConfig()` plugin wraps `next.config` in the Next.js config file.
+- (optional) `createNextMiddleware()` is used in `proxy.ts` for automatic locale routing.
+
+### Translating JSX 
+
+`gt-next` uses the `<T>` component for translation.
+
+Pass JSX content as the direct children of `<T>` to translate it. Children of `<T>` must be static — no JS expressions or variables directly inside.
+
+```jsx
+import { T } from 'gt-next';
+
+<T>
+  <h1>Welcome to our store</h1>
+  <p>
+    Browse our <a href='/products'>latest products</a> and find something you
+    love.
+  </p>
+</T>;
+```
+
+You can also add a `context` prop to `<T>` to give context to the translator. For example: 
+
+```jsx
+import { T } from 'gt-next';
+
+<T context="Cookies as in web cookies">
+  View your <a href="/cookies">Cookies</a>
+</T>;
+```
+
+### Translating simple strings
+
+Use the `gt` function returned by the `useGT()` hook to translate strings directly. Invoke `useGT()` in synchronous components or `await getGT()` in async components only.
+
+```js
+import { useGT } from 'gt-next';
+const gt = useGT();
+gt('Hello, world!'); // returns "Hola, mundo"
+```
+
+```js
+import { getGT } from 'gt-next/server';
+const gt = await getGT(); // use await version in async components only
+gt('Hello, world!');
+```
+
+- Just like with the children of the `<T>` component, all strings passed to `gt()` must be static string literals. No variables or template literals.
+
+### Translating shared or out-of-scope strings
+
+Use `msg()` to register strings for translation, and `useMessages()` to translate them. `const m = useMessages()` should be used equivalently to `const gt = useGT()`. 
+
+```js
+import { msg, useMessages } from 'gt-next';
+
+const greeting = msg('Hello, world!');
+
+export default function Greeting() {
+  const m = useMessages();
+  return <p>{m(greeting)}</p>;
+}
+```
+
+- All strings passed to `msg()` must be static string literals. No variables or template literals.
+- Use the equivalent `await getMessages()` for async components.
+- `useMessages()` / `getMessages()` take no arguments.
+
+### Dynamic content inside `<T>`
+
+Use variable components for dynamic values inside `<T>`:
+
+- `<Var>{value}</Var>` — variables (strings, numbers, etc.)
+- `<Num>{value}</Num>` — formatted numbers
+- `<Currency>{value}</Currency>` — formatted currency
+- `<DateTime>{value}</DateTime>` — formatted dates/times
+
+```jsx
+import { T, Var, Num } from 'gt-next';
+
+<T>
+  <Var>{userName}</Var> ordered <Num>{itemCount}</Num> items.
+</T>;
+```
+
+### Utility hooks
+
+#### `useLocale()`
+
+`useLocale` returns the user's current language, as a BCP 47 locale tag.
+
+```js
+import { useLocale } from 'gt-next'
+
+const locale = useLocale(); // "en-US"
+```
+
+### Quickstart
+
+See https://generaltranslation.com/docs/next.md

package/dist/setup/instructions/gt-react.md

@@ -0,0 +1,98 @@
+### gt-react
+
+This project is using the `gt-react` internationalization library.
+
+### gt-react setup
+
+- `GTProvider` must wrap the app in the root layout to provide translation context.
+
+### Translating JSX 
+
+`gt-react` uses the `<T>` component for translation.
+
+Pass JSX content as the direct children of `<T>` to translate it. Children of `<T>` must be static — no JS expressions or variables directly inside.
+
+```jsx
+import { T } from 'gt-react';
+
+<T>
+  <h1>Welcome to our store</h1>
+  <p>
+    Browse our <a href='/products'>latest products</a> and find something you
+    love.
+  </p>
+</T>;
+```
+
+You can also add a `context` prop to `<T>` to give context to the translator. For example: 
+
+```jsx
+import { T } from 'gt-react';
+
+<T context="Cookies as in web cookies">
+  View your <a href="/cookies">Cookies</a>
+</T>;
+```
+
+### Translating simple strings
+
+Use the `gt` function returned by the `useGT()` hook to translate strings directly.
+
+```js
+import { useGT } from 'gt-react';
+const gt = useGT();
+gt('Hello, world!'); // returns "Hola, mundo"
+```
+
+- Just like with the children of the `<T>` component, all strings passed to `gt()` must be static string literals. No variables or template literals.
+
+### Translating shared or out-of-scope strings
+
+Use `msg()` to register strings for translation, and `useMessages()` to translate them. `const m = useMessages()` should be used equivalently to `const gt = useGT()`. 
+
+```js
+import { msg, useMessages } from 'gt-react';
+
+const greeting = msg('Hello, world!');
+
+export default function Greeting() {
+  const m = useMessages();
+  return <p>{m(greeting)}</p>;
+}
+```
+
+- All strings passed to `msg()` must be static string literals. No variables or template literals.
+- `useMessages()` / `getMessages()` take no arguments.
+
+### Dynamic content inside `<T>`
+
+Use variable components for dynamic values inside `<T>`:
+
+- `<Var>{value}</Var>` — variables (strings, numbers, etc.)
+- `<Num>{value}</Num>` — formatted numbers
+- `<Currency>{value}</Currency>` — formatted currency
+- `<DateTime>{value}</DateTime>` — formatted dates/times
+
+```jsx
+import { T, Var, Num } from 'gt-react';
+
+<T>
+  <Var>{userName}</Var> ordered <Num>{itemCount}</Num> items.
+</T>;
+```
+
+### Utility hooks
+
+#### `useLocale()`
+
+`useLocale` returns the user's current language, as a BCP 47 locale tag.
+
+```js
+import { useLocale } from 'gt-react'
+
+const locale = useLocale(); // "en-US"
+```
+
+### Quickstart
+
+See https://generaltranslation.com/docs/react.md

package/dist/translation/parse.d.ts

@@ -9,7 +9,7 @@ import type { ParsingConfigOptions } from '../types/parsing.js';
  * @param pkg - The package name
  * @returns An object containing the updates and errors
  */
-export declare function createUpdates(options: TranslateFlags, src: string[] | undefined, sourceDictionary: string | undefined, pkg: 'gt-react' | 'gt-next', validate: boolean, parsingOptions: ParsingConfigOptions): Promise<{
+export declare function createUpdates(options: TranslateFlags, src: string[] | undefined, sourceDictionary: string | undefined, pkg: 'gt-react' | 'gt-next' | 'gt-node', validate: boolean, parsingOptions: ParsingConfigOptions): Promise<{
     updates: Updates;
     errors: string[];
     warnings: string[];

package/dist/translation/stage.d.ts

@@ -1,2 +1,2 @@
 import { Settings, TranslateFlags, Updates } from '../types/index.js';
-export declare function aggregateReactTranslations(options: TranslateFlags, settings: Settings, library: 'gt-react' | 'gt-next'): Promise<Updates>;
+export declare function aggregateInlineTranslations(options: TranslateFlags, settings: Settings, library: 'gt-react' | 'gt-next' | 'gt-node'): Promise<Updates>;

package/dist/translation/stage.js

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import findFilepath from '../fs/findFilepath.js';
 import { logger } from '../console/logger.js';
 import { createUpdates } from './parse.js';
-export async function aggregateReactTranslations(options, settings, library) {
+export async function aggregateInlineTranslations(options, settings, library) {
     if (!options.dictionary) {
         options.dictionary = findFilepath([
             './dictionary.js',

package/dist/translation/validate.d.ts

@@ -10,4 +10,4 @@ export type ValidationResult = Record<string, ValidationMessage[]>;
  * Equivalent to running `gtx-cli validate` but returns data.
  */
 export declare function getValidateJson(settings: Options & Settings, pkg: 'gt-react' | 'gt-next', files?: string[]): Promise<ValidationResult>;
-export declare function validateProject(settings: Options & Settings, pkg: 'gt-react' | 'gt-next', files?: string[]): Promise<void>;
+export declare function validateProject(settings: Options & Settings, pkg: 'gt-react' | 'gt-next' | 'gt-node', files?: string[]): Promise<void>;

package/dist/types/index.d.ts

@@ -111,7 +111,7 @@ export type SupportedFrameworks = FrameworkObject['name'];
 export type SupportedReactFrameworks = Extract<FrameworkObject, {
     type: 'react';
 }>['name'];
-export type SupportedLibraries = 'gt-next' | 'gt-react' | 'next-intl' | 'react-i18next' | 'next-i18next' | 'i18next' | 'i18next-icu' | 'base';
+export type SupportedLibraries = 'gt-next' | 'gt-react' | 'next-intl' | 'react-i18next' | 'next-i18next' | 'i18next' | 'i18next-icu' | 'gt-node' | 'base';
 export interface ContentScanner {
     scanForContent(options: WrapOptions, framework: Framework): Promise<{
         errors: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.6.17",
+  "version": "2.6.18",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -134,10 +134,10 @@
     "typescript": "^5.5.4"
   },
   "scripts": {
-    "build": "node scripts/generate-version.js && tsc",
+    "build": "node scripts/generate-version.js && tsc && rm -rf dist/setup/instructions && cp -r src/setup/instructions dist/setup/instructions",
     "build:clean": "sh ../../scripts/clean.sh && pnpm bin:restore && rm -rf binaries && pnpm run build",
     "build:release": "pnpm run build:clean",
-    "build:bin": "node scripts/generate-version.js && tsc && sh scripts/build-exe.sh all",
+    "build:bin": "node scripts/generate-version.js && tsc && rm -rf dist/setup/instructions && cp -r src/setup/instructions dist/setup/instructions && sh scripts/build-exe.sh all",
     "build:bin:clean": "sh ../../scripts/clean.sh && rm -rf binaries && pnpm run build:bin",
     "build:bin:release": "pnpm run build:bin:clean && pnpm run build:bin",
     "build:bin:darwin-x64": "sh scripts/build-exe.sh darwin-x64",