gt 2.10.2 → 2.10.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 2.10.3
+
+### Patch Changes
+
+- [#1110](https://github.com/generaltranslation/gt/pull/1110) [`38ecda0`](https://github.com/generaltranslation/gt/commit/38ecda003b6873464e350aff0463a8dc64030565) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Adding monorepo GT package version check, remove writing to agent files
+
 ## 2.10.2
 
 ### Patch Changes

package/dist/cli/base.d.ts

@@ -55,6 +55,4 @@ 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

@@ -30,8 +30,6 @@ 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/index.js';
 import { INLINE_LIBRARIES } from '../types/libraries.js';
 import { handleEnqueue } from './commands/enqueue.js';
 export class BaseCLI {
@@ -43,12 +41,12 @@ export class BaseCLI {
         this.program = program;
         this.library = library;
         this.additionalModules = additionalModules || [];
+        this.program.option('--skip-version-check', 'Skip the monorepo GT package version consistency check');
         this.setupInitCommand();
         this.setupConfigureCommand();
         this.setupUploadCommand();
         this.setupLoginCommand();
         this.setupSendDiffsCommand();
-        this.setupUpdateInstructionsCommand();
     }
     // Init is never called in a child class
     init() {
@@ -260,7 +258,6 @@ 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 {
@@ -302,7 +299,6 @@ 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');
             }
         });
@@ -474,69 +470,4 @@ See https://generaltranslation.com/en/docs/next/guides/local-tx`);
         const credentials = await retrieveCredentials(settings, keyType);
         await setCredentials(credentials, 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/node.js

@@ -1,9 +1,16 @@
 import { InlineCLI } from './inline.js';
+import { NODE_LIBRARIES } from '../types/libraries.js';
+import { checkMonorepoVersionConsistency } from '../utils/monorepoVersionCheck.js';
 /**
  * CLI tool for managing translations with gt-node
  */
 export class NodeCLI extends InlineCLI {
     constructor(command, library, additionalModules) {
         super(command, library, additionalModules);
+        this.program.hook('preAction', () => {
+            if (this.program.opts().skipVersionCheck)
+                return;
+            checkMonorepoVersionConsistency(NODE_LIBRARIES);
+        });
     }
 }

package/dist/cli/react.js

@@ -6,11 +6,17 @@ import { wrapContentReact } from '../react/parse/wrapContent.js';
 import { generateSettings } from '../config/generateSettings.js';
 import { attachInlineTranslateFlags, attachTranslateFlags } from './flags.js';
 import { InlineCLI } from './inline.js';
-import { Libraries } from '../types/libraries.js';
+import { Libraries, REACT_LIBRARIES } from '../types/libraries.js';
+import { checkMonorepoVersionConsistency } from '../utils/monorepoVersionCheck.js';
 const pkg = Libraries.GT_REACT;
 export class ReactCLI extends InlineCLI {
     constructor(command, library, additionalModules) {
         super(command, library, additionalModules);
+        this.program.hook('preAction', () => {
+            if (this.program.opts().skipVersionCheck)
+                return;
+            checkMonorepoVersionConsistency([...REACT_LIBRARIES, Libraries.GT_I18N]);
+        });
     }
     init() {
         super.init();

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.10.2";
+export declare const PACKAGE_VERSION = "2.10.3";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const PACKAGE_VERSION = '2.10.2';
+export const PACKAGE_VERSION = '2.10.3';

package/dist/types/libraries.d.ts

@@ -8,25 +8,31 @@ export declare enum Libraries {
     GT_NODE = "gt-node",
     GT_I18N = "gt-i18n",
     GT_REACT_CORE = "@generaltranslation/react-core",
+    GT_TANSTACK_START = "gt-tanstack-start",
     GT_FLASK = "gt-flask",
     GT_FASTAPI = "gt-fastapi"
 }
 /**
  * A list of all the libraries that support the CLI
  */
-export declare const GT_LIBRARIES: readonly [Libraries.GT_REACT, Libraries.GT_NEXT, Libraries.GT_REACT_NATIVE, Libraries.GT_NODE, Libraries.GT_I18N, Libraries.GT_REACT_CORE, Libraries.GT_FLASK, Libraries.GT_FASTAPI];
+export declare const GT_LIBRARIES: readonly [Libraries.GT_REACT, Libraries.GT_NEXT, Libraries.GT_REACT_NATIVE, Libraries.GT_NODE, Libraries.GT_I18N, Libraries.GT_REACT_CORE, Libraries.GT_TANSTACK_START, Libraries.GT_FLASK, Libraries.GT_FASTAPI];
 export type GTLibrary = (typeof GT_LIBRARIES)[number];
 /**
  * Libraries that support inline translation
  */
-export declare const INLINE_LIBRARIES: readonly [Libraries.GT_REACT, Libraries.GT_NEXT, Libraries.GT_NODE, Libraries.GT_REACT_NATIVE, Libraries.GT_REACT_CORE, Libraries.GT_I18N, Libraries.GT_FLASK, Libraries.GT_FASTAPI];
+export declare const INLINE_LIBRARIES: readonly [Libraries.GT_REACT, Libraries.GT_NEXT, Libraries.GT_NODE, Libraries.GT_REACT_NATIVE, Libraries.GT_REACT_CORE, Libraries.GT_TANSTACK_START, Libraries.GT_I18N, Libraries.GT_FLASK, Libraries.GT_FASTAPI];
 export type InlineLibrary = (typeof INLINE_LIBRARIES)[number];
 export declare function isInlineLibrary(lib: string): lib is InlineLibrary;
 /**
  * Libraries that support react primitives
  */
-export declare const REACT_LIBRARIES: readonly [Libraries.GT_NEXT, Libraries.GT_REACT, Libraries.GT_REACT_NATIVE, Libraries.GT_REACT_CORE];
+export declare const REACT_LIBRARIES: readonly [Libraries.GT_NEXT, Libraries.GT_REACT, Libraries.GT_REACT_NATIVE, Libraries.GT_REACT_CORE, Libraries.GT_TANSTACK_START];
 export type ReactLibrary = (typeof REACT_LIBRARIES)[number];
+/**
+ * Node/server-side libraries
+ */
+export declare const NODE_LIBRARIES: readonly [Libraries.GT_NODE, Libraries.GT_I18N];
+export type NodeLibrary = (typeof NODE_LIBRARIES)[number];
 /**
  * Python libraries
  */

package/dist/types/libraries.js

@@ -9,6 +9,7 @@ export var Libraries;
     Libraries["GT_NODE"] = "gt-node";
     Libraries["GT_I18N"] = "gt-i18n";
     Libraries["GT_REACT_CORE"] = "@generaltranslation/react-core";
+    Libraries["GT_TANSTACK_START"] = "gt-tanstack-start";
     Libraries["GT_FLASK"] = "gt-flask";
     Libraries["GT_FASTAPI"] = "gt-fastapi";
 })(Libraries || (Libraries = {}));
@@ -22,6 +23,7 @@ export const GT_LIBRARIES = [
     Libraries.GT_NODE,
     Libraries.GT_I18N,
     Libraries.GT_REACT_CORE,
+    Libraries.GT_TANSTACK_START,
     Libraries.GT_FLASK,
     Libraries.GT_FASTAPI,
 ];
@@ -34,6 +36,7 @@ export const INLINE_LIBRARIES = [
     Libraries.GT_NODE,
     Libraries.GT_REACT_NATIVE,
     Libraries.GT_REACT_CORE,
+    Libraries.GT_TANSTACK_START,
     Libraries.GT_I18N,
     Libraries.GT_FLASK,
     Libraries.GT_FASTAPI,
@@ -49,7 +52,12 @@ export const REACT_LIBRARIES = [
     Libraries.GT_REACT,
     Libraries.GT_REACT_NATIVE,
     Libraries.GT_REACT_CORE,
+    Libraries.GT_TANSTACK_START,
 ];
+/**
+ * Node/server-side libraries
+ */
+export const NODE_LIBRARIES = [Libraries.GT_NODE, Libraries.GT_I18N];
 /**
  * Python libraries
  */
@@ -84,6 +92,12 @@ export const GT_LIBRARIES_UPSTREAM = {
     ],
     [Libraries.GT_NODE]: [Libraries.GT_I18N, Libraries.GT_NODE],
     [Libraries.GT_REACT_CORE]: [Libraries.GT_I18N, Libraries.GT_REACT_CORE],
+    [Libraries.GT_TANSTACK_START]: [
+        Libraries.GT_I18N,
+        Libraries.GT_REACT_CORE,
+        Libraries.GT_REACT,
+        Libraries.GT_TANSTACK_START,
+    ],
     [Libraries.GT_I18N]: [Libraries.GT_I18N],
     [Libraries.GT_FLASK]: [Libraries.GT_FLASK],
     [Libraries.GT_FASTAPI]: [Libraries.GT_FASTAPI],

package/dist/utils/monorepoVersionCheck.d.ts

@@ -0,0 +1,8 @@
+import type { GTLibrary } from '../types/libraries.js';
+/**
+ * Run the monorepo version consistency check.
+ * If mismatched GT package versions are found, logs an error and exits with code 1.
+ * Silently returns if not in a monorepo or if all versions are consistent.
+ * Can be skipped via the --skip-version-check flag or "skipVersionCheck": true in gt.config.json.
+ */
+export declare function checkMonorepoVersionConsistency(libraries: readonly GTLibrary[]): void;

package/dist/utils/monorepoVersionCheck.js

@@ -0,0 +1,176 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+import chalk from 'chalk';
+import { logger } from '../console/logger.js';
+import { resolveConfig } from '../config/resolveConfig.js';
+const LOCKFILES = [
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lock',
+    'bun.lockb',
+    'deno.lock',
+];
+/**
+ * Walk up from startDir to find the monorepo root by looking for a lockfile.
+ */
+function findMonorepoRoot(startDir) {
+    let dir = startDir;
+    while (true) {
+        if (LOCKFILES.some((lf) => fs.existsSync(path.join(dir, lf)))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * Scan for all directories containing package.json under the root.
+ */
+function scanForPackageDirs(rootDir) {
+    const matches = fg.sync('**/package.json', {
+        cwd: rootDir,
+        absolute: true,
+        onlyFiles: true,
+        ignore: ['**/node_modules/**'],
+    });
+    return matches.map((m) => path.dirname(m)).filter((dir) => dir !== rootDir);
+}
+/**
+ * Creates a cached reader for workspace package.json files.
+ * Cache is scoped to a single check invocation to avoid stale data.
+ */
+function createPackageJsonReader() {
+    const cache = new Map();
+    return (workspaceDir) => {
+        if (cache.has(workspaceDir))
+            return cache.get(workspaceDir) ?? null;
+        const pkgPath = path.join(workspaceDir, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+            cache.set(workspaceDir, null);
+            return null;
+        }
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            cache.set(workspaceDir, pkg);
+            return pkg;
+        }
+        catch {
+            cache.set(workspaceDir, null);
+            return null;
+        }
+    };
+}
+/**
+ * Check if a version specifier is a real semver version
+ */
+function isSemverSpecifier(version) {
+    return /^[\^~>=<*]?\d/.test(version);
+}
+/**
+ * Get the declared version specifier for a GT package from a workspace's package.json.
+ * Returns null if the package is not found or uses a non-semver protocol
+ * (e.g. workspace:*, link:, file:, etc.)
+ */
+function getDeclaredVersion(packageName, workspaceDir, readPkgJson) {
+    const pkg = readPkgJson(workspaceDir);
+    if (!pkg)
+        return null;
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const version = deps[packageName];
+    if (!version || !isSemverSpecifier(version))
+        return null;
+    return version;
+}
+/**
+ * Scan all packages for mismatched GT package version specifiers.
+ * Compares the declared versions in each package.json directly.
+ */
+function findVersionMismatches(workspaceDirs, readPkgJson, libraries) {
+    // Map: packageName -> Map<versionSpecifier, workspaceNames[]>
+    const packageVersions = new Map();
+    for (const wsDir of workspaceDirs) {
+        const wsName = getWorkspaceName(wsDir, readPkgJson);
+        for (const pkg of libraries) {
+            const version = getDeclaredVersion(pkg, wsDir, readPkgJson);
+            if (!version)
+                continue;
+            if (!packageVersions.has(pkg)) {
+                packageVersions.set(pkg, new Map());
+            }
+            const versionMap = packageVersions.get(pkg);
+            if (!versionMap.has(version)) {
+                versionMap.set(version, []);
+            }
+            versionMap.get(version).push(wsName);
+        }
+    }
+    const mismatches = [];
+    for (const [packageName, versionMap] of packageVersions) {
+        if (versionMap.size > 1) {
+            const versions = [];
+            for (const [version, workspaces] of versionMap) {
+                versions.push({ version, workspaces });
+            }
+            // Sort by version descending so the latest appears first
+            versions.sort((a, b) => b.version.localeCompare(a.version, undefined, { numeric: true }));
+            mismatches.push({ packageName, versions });
+        }
+    }
+    return mismatches;
+}
+/**
+ * Get a human-readable name for a workspace directory.
+ */
+function getWorkspaceName(wsDir, readPkgJson) {
+    const pkg = readPkgJson(wsDir);
+    return pkg?.name ?? path.basename(wsDir);
+}
+/**
+ * Format version mismatches into a human-readable error message.
+ */
+function formatMismatchError(mismatches) {
+    const lines = [
+        chalk.red.bold('Mismatched GT package versions detected across your monorepo!'),
+        '',
+        chalk.yellow('Please update all workspaces to use the same version of each GT package, then reinstall.'),
+        '',
+    ];
+    for (const mismatch of mismatches) {
+        lines.push(chalk.white.bold(`  ${mismatch.packageName}:`));
+        for (const { version, workspaces } of mismatch.versions) {
+            lines.push(`    ${chalk.cyan(version)} ${chalk.dim('←')} ${workspaces.join(', ')}`);
+        }
+        lines.push('');
+    }
+    lines.push(chalk.dim('To skip this check, use --skip-version-check or set "skipVersionCheck": true in gt.config.json.\n'));
+    return lines.join('\n');
+}
+/**
+ * Run the monorepo version consistency check.
+ * If mismatched GT package versions are found, logs an error and exits with code 1.
+ * Silently returns if not in a monorepo or if all versions are consistent.
+ * Can be skipped via the --skip-version-check flag or "skipVersionCheck": true in gt.config.json.
+ */
+export function checkMonorepoVersionConsistency(libraries) {
+    const cwd = process.cwd();
+    // Check if skipped via config
+    const resolved = resolveConfig(cwd);
+    if (resolved?.config?.skipVersionCheck)
+        return;
+    const rootDir = findMonorepoRoot(cwd);
+    if (!rootDir)
+        return; // No lockfile found — nothing to check
+    const workspaceDirs = scanForPackageDirs(rootDir);
+    if (workspaceDirs.length <= 1)
+        return; // Single package — no mismatches possible
+    const readPkgJson = createPackageJsonReader();
+    const mismatches = findVersionMismatches(workspaceDirs, readPkgJson, libraries);
+    if (mismatches.length === 0)
+        return; // All consistent
+    logger.error(formatMismatchError(mismatches));
+    process.exit(1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.10.2",
+  "version": "2.10.3",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -110,9 +110,9 @@
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
     "yaml": "^2.8.0",
-    "@generaltranslation/python-extractor": "0.1.2",
     "generaltranslation": "8.1.16",
-    "gt-remark": "1.0.5"
+    "gt-remark": "1.0.5",
+    "@generaltranslation/python-extractor": "0.1.2"
   },
   "devDependencies": {
     "@babel/types": "^7.28.4",

package/dist/setup/agentInstructions.d.ts

@@ -1,24 +0,0 @@
-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

@@ -1,138 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { getCLIVersion, getPackageVersion } from '../utils/packageJson.js';
-import { Libraries } from '../types/libraries.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- **gt**: v${getCLIVersion()}`
-        : `- **gt**: v${getCLIVersion()}`;
-    const base = fs.readFileSync(path.join(INSTRUCTIONS_DIR, 'base.md'), 'utf8');
-    let body = '';
-    const libToFile = {
-        [Libraries.GT_NEXT]: 'gt-next.md',
-        [Libraries.GT_REACT]: 'gt-react.md',
-        // TODO: add gt-react-native.md
-        [Libraries.GT_REACT_NATIVE]: '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;
-}