gt 0.10.0 → 2.7.0

package/dist/react/parse/wrapContent.js

@@ -0,0 +1,162 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as t from '@babel/types';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import generateModule from '@babel/generator';
+// Handle CommonJS/ESM interop
+const traverse = traverseModule.default || traverseModule;
+const generate = generateModule.default || generateModule;
+import { isMeaningful } from '../jsx/evaluateJsx.js';
+import { handleJsxElement } from '../jsx/wrapJsx.js';
+import { getRelativePath } from '../../fs/findFilepath.js';
+import { generateImportMap, createImports, } from '../jsx/utils/parseAst.js';
+import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
+import { matchFiles } from '../../fs/matchFiles.js';
+import { Libraries } from '../../types/libraries.js';
+const IMPORT_MAP = {
+    T: { name: 'T', source: Libraries.GT_REACT },
+    Var: { name: 'Var', source: Libraries.GT_REACT },
+    GTT: { name: 'T', source: Libraries.GT_REACT },
+    GTVar: { name: 'Var', source: Libraries.GT_REACT },
+    GTProvider: { name: 'GTProvider', source: Libraries.GT_REACT },
+};
+/**
+ * Wraps all JSX elements in the src directory with a <T> tag, with unique ids.
+ * - Ignores pure strings
+ *
+ * @param options - The options object
+ * @returns An object containing the updates and errors
+ */
+export async function wrapContentReact(options, pkg, framework, errors, warnings) {
+    const filePatterns = options.src || DEFAULT_SRC_PATTERNS;
+    const files = matchFiles(process.cwd(), filePatterns);
+    const filesUpdated = [];
+    for (const file of files) {
+        const baseFileName = path.basename(file);
+        const configPath = path.relative(path.dirname(file), path.resolve(process.cwd(), options.config));
+        // Ensure the path starts with ./ or ../
+        const normalizedConfigPath = configPath.startsWith('.')
+            ? configPath
+            : './' + configPath;
+        const code = await fs.promises.readFile(file, 'utf8');
+        // Create relative path from src directory and remove extension
+        const relativePath = getRelativePath(file, process.cwd());
+        let ast;
+        try {
+            ast = parse(code, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript'],
+                tokens: true,
+                createParenthesizedExpressions: true,
+            });
+        }
+        catch (error) {
+            errors.push(`Error:Failed to parse ${file}: ${error}`);
+            continue;
+        }
+        let modified = false;
+        const usedImports = [];
+        const { importAlias, initialImports } = generateImportMap(ast, pkg);
+        // If the file already has a T import, skip processing it
+        if (initialImports.includes(IMPORT_MAP.T.name)) {
+            continue;
+        }
+        let globalId = 0;
+        traverse(ast, {
+            JSXElement(path) {
+                if (framework === 'next-pages' &&
+                    options.addGTProvider &&
+                    (baseFileName === '_app.tsx' || baseFileName === '_app.jsx')) {
+                    // Check if this is the Component element with pageProps
+                    const isComponentWithPageProps = t.isJSXElement(path.node) &&
+                        t.isJSXIdentifier(path.node.openingElement.name) &&
+                        path.node.openingElement.name.name === 'Component' &&
+                        path.node.openingElement.attributes.some((attr) => t.isJSXSpreadAttribute(attr) &&
+                            t.isIdentifier(attr.argument) &&
+                            attr.argument.name === 'pageProps');
+                    if (!isComponentWithPageProps) {
+                        return;
+                    }
+                    // Check if GTProvider already exists in the ancestors
+                    let hasGTProvider = false;
+                    let currentPath = path;
+                    while (currentPath.parentPath) {
+                        if (t.isJSXElement(currentPath.node) &&
+                            t.isJSXIdentifier(currentPath.node.openingElement.name) &&
+                            currentPath.node.openingElement.name.name === 'GTProvider') {
+                            hasGTProvider = true;
+                            break;
+                        }
+                        currentPath = currentPath.parentPath;
+                    }
+                    if (!hasGTProvider) {
+                        // Wrap the Component element with GTProvider
+                        const gtProviderJsx = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier('GTProvider'), [t.jsxSpreadAttribute(t.identifier('gtConfig'))], false), t.jsxClosingElement(t.jsxIdentifier('GTProvider')), [path.node]);
+                        path.replaceWith(gtProviderJsx);
+                        usedImports.push('GTProvider');
+                        usedImports.push({
+                            local: 'gtConfig',
+                            imported: 'default',
+                            source: normalizedConfigPath,
+                        });
+                        modified = true;
+                        path.skip();
+                        return;
+                    }
+                }
+                // Check if this JSX element has any JSX element ancestors
+                if (t.isJSXElement(path.parentPath?.node) ||
+                    t.isJSXExpressionContainer(path.parentPath?.node)) {
+                    // If we're nested inside JSX, skip processing this node
+                    return;
+                }
+                // At this point, we're only processing top-level JSX elements
+                const opts = {
+                    ...importAlias,
+                    idPrefix: relativePath,
+                    idCount: globalId,
+                    usedImports,
+                    modified: false,
+                    createIds: !options.disableIds,
+                    warnings,
+                    file,
+                };
+                const wrapped = handleJsxElement(path.node, opts, isMeaningful);
+                path.replaceWith(wrapped.node);
+                // Update global counters
+                modified = modified || opts.modified;
+                globalId = opts.idCount;
+            },
+        });
+        if (!modified)
+            continue;
+        const needsImport = usedImports.filter((imp) => typeof imp === 'string'
+            ? !initialImports.includes(imp)
+            : !initialImports.includes(imp.local));
+        if (needsImport.length > 0) {
+            createImports(ast, needsImport, IMPORT_MAP);
+        }
+        try {
+            const output = generate(ast, {
+                retainLines: true,
+                retainFunctionParens: true,
+                comments: true,
+                compact: 'auto',
+            }, code);
+            // Post-process the output to fix import spacing
+            let processedCode = output.code;
+            if (needsImport.length > 0) {
+                // Add newline after the comment only
+                processedCode = processedCode.replace(/((?:import\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*from|const\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*=\s*require)\s*['"]gt-(?:next|react)(?:\/server)?['"];?)/, '\n$1\n');
+            }
+            // Write the modified code back to the file
+            await fs.promises.writeFile(file, processedCode);
+            filesUpdated.push(file);
+        }
+        catch (error) {
+            errors.push(`Error: Failed to write ${file}: ${error}`);
+        }
+    }
+    return { filesUpdated };
+}

package/dist/react/utils/flattenDictionary.d.ts

@@ -0,0 +1,20 @@
+import { Dictionary, FlattenedDictionary, FlattenedJSONDictionary, JSONDictionary } from '../../types/data.js';
+/**
+ * Flattens a nested dictionary by concatenating nested keys.
+ * Throws an error if two keys result in the same flattened key.
+ * @param {Record<string, any>} dictionary - The dictionary to flatten.
+ * @param {string} [prefix=''] - The prefix for nested keys.
+ * @returns {Record<string, React.ReactNode>} The flattened dictionary object.
+ * @throws {Error} If two keys result in the same flattened key.
+ */
+export default function flattenDictionary(dictionary: Dictionary, prefix?: string): FlattenedDictionary;
+/**
+ * Flattens a nested dictionary containing only string values
+ * Throws an error if two keys result in the same flattened key.
+ * @param {JSONDictionary} dictionary - The dictionary to flatten.
+ * @param {string} [prefix=''] - The prefix for nested keys.
+ * @returns {FlattenedJSONDictionary} The flattened dictionary with string values.
+ * @throws {Error} If two keys result in the same flattened key.
+ * @throws {Error} If a value is an array.
+ */
+export declare function flattenJsonDictionary(dictionary: JSONDictionary, prefix?: string): FlattenedJSONDictionary;

package/dist/react/utils/flattenDictionary.js

@@ -0,0 +1,75 @@
+import { logErrorAndExit } from '../../console/logging.js';
+const createDuplicateKeyError = (key) => `Duplicate key found in dictionary: "${key}"`;
+/**
+ * Flattens a nested dictionary by concatenating nested keys.
+ * Throws an error if two keys result in the same flattened key.
+ * @param {Record<string, any>} dictionary - The dictionary to flatten.
+ * @param {string} [prefix=''] - The prefix for nested keys.
+ * @returns {Record<string, React.ReactNode>} The flattened dictionary object.
+ * @throws {Error} If two keys result in the same flattened key.
+ */
+export default function flattenDictionary(dictionary, prefix = '') {
+    const flattened = {};
+    for (const key in dictionary) {
+        if (dictionary.hasOwnProperty(key)) {
+            const newKey = prefix ? `${prefix}.${key}` : key;
+            if (typeof dictionary[key] === 'object' &&
+                dictionary[key] !== null &&
+                !Array.isArray(dictionary[key])) {
+                const nestedFlattened = flattenDictionary(dictionary[key], newKey);
+                for (const flatKey in nestedFlattened) {
+                    if (flattened.hasOwnProperty(flatKey)) {
+                        logErrorAndExit(createDuplicateKeyError(flatKey));
+                    }
+                    flattened[flatKey] = nestedFlattened[flatKey];
+                }
+            }
+            else {
+                if (flattened.hasOwnProperty(newKey)) {
+                    logErrorAndExit(createDuplicateKeyError(newKey));
+                }
+                flattened[newKey] = dictionary[key];
+            }
+        }
+    }
+    return flattened;
+}
+/**
+ * Flattens a nested dictionary containing only string values
+ * Throws an error if two keys result in the same flattened key.
+ * @param {JSONDictionary} dictionary - The dictionary to flatten.
+ * @param {string} [prefix=''] - The prefix for nested keys.
+ * @returns {FlattenedJSONDictionary} The flattened dictionary with string values.
+ * @throws {Error} If two keys result in the same flattened key.
+ * @throws {Error} If a value is an array.
+ */
+export function flattenJsonDictionary(dictionary, prefix = '') {
+    const flattened = {};
+    for (const key in dictionary) {
+        if (dictionary.hasOwnProperty(key)) {
+            const newKey = prefix ? `${prefix}.${key}` : key;
+            const value = dictionary[key];
+            if (Array.isArray(value)) {
+                logErrorAndExit(`Arrays are not supported in JSON dictionary at key: "${newKey}"`);
+            }
+            else if (typeof value === 'object' && value !== null) {
+                // Recursively flatten nested objects
+                const nestedFlattened = flattenJsonDictionary(value, newKey);
+                for (const flatKey in nestedFlattened) {
+                    if (flattened.hasOwnProperty(flatKey)) {
+                        logErrorAndExit(createDuplicateKeyError(flatKey));
+                    }
+                    flattened[flatKey] = nestedFlattened[flatKey];
+                }
+            }
+            else if (typeof value === 'string') {
+                // Handle string values
+                if (flattened.hasOwnProperty(newKey)) {
+                    logErrorAndExit(createDuplicateKeyError(newKey));
+                }
+                flattened[newKey] = value;
+            }
+        }
+    }
+    return flattened;
+}

package/dist/react/utils/getEntryAndMetadata.d.ts

@@ -0,0 +1,5 @@
+import { DictionaryEntry, DictionaryMetadata } from '../../types/data.js';
+export default function getEntryAndMetadata(value: DictionaryEntry): {
+    entry: string;
+    metadata?: DictionaryMetadata;
+};

package/dist/react/utils/getEntryAndMetadata.js

@@ -0,0 +1,11 @@
+export default function getEntryAndMetadata(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 1) {
+            return { entry: value[0] };
+        }
+        if (value.length === 2) {
+            return { entry: value[0], metadata: value[1] };
+        }
+    }
+    return { entry: value };
+}

package/dist/react/utils/getVariableName.d.ts

@@ -0,0 +1,25 @@
+import { VariableType } from 'generaltranslation/types';
+/**
+ * These are the names of the variable components as they appear in gt-next and gt-react
+ */
+export declare const defaultVariableNames: {
+    readonly Var: "value";
+    readonly Num: "n";
+    readonly DateTime: "date";
+    readonly Currency: "cost";
+};
+/**
+ * Minify the variable type from the name of the variable component (from gt-next and gt-react)
+ * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
+ * @returns The minified variable type
+ */
+export declare const minifyVariableType: (variableType: keyof typeof defaultVariableNames) => VariableType;
+export declare const baseVariablePrefix = "_gt_";
+/**
+ * Get the name of a variable
+ * @param props - The props of the variable
+ * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
+ * @param id - The id of the variable
+ * @returns The name of the variable
+ */
+export declare function getVariableName(props: Record<string, any> | undefined, variableType: keyof typeof defaultVariableNames, id: number): string;

package/dist/react/utils/getVariableName.js

@@ -0,0 +1,37 @@
+/**
+ * These are the names of the variable components as they appear in gt-next and gt-react
+ */
+export const defaultVariableNames = {
+    Var: 'value',
+    Num: 'n',
+    DateTime: 'date',
+    Currency: 'cost',
+};
+const minifyVariableTypeMap = {
+    Var: 'v',
+    Num: 'n',
+    DateTime: 'd',
+    Currency: 'c',
+};
+/**
+ * Minify the variable type from the name of the variable component (from gt-next and gt-react)
+ * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
+ * @returns The minified variable type
+ */
+export const minifyVariableType = (variableType) => {
+    return minifyVariableTypeMap[variableType];
+};
+export const baseVariablePrefix = '_gt_';
+/**
+ * Get the name of a variable
+ * @param props - The props of the variable
+ * @param variableType - The type of the variable (Var, Num, DateTime, Currency)
+ * @param id - The id of the variable
+ * @returns The name of the variable
+ */
+export function getVariableName(props = {}, variableType, id) {
+    if (props.name)
+        return props.name;
+    const baseVariableName = defaultVariableNames[variableType] || 'value';
+    return `${baseVariablePrefix}${baseVariableName}_${id}`;
+}

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,138 @@
+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;
+}

package/dist/setup/detectFramework.d.ts

@@ -0,0 +1,31 @@
+import { FrameworkObject } from '../types/index.js';
+/**
+ * Detects the frontend framework used in the current project.
+ *
+ * Analyzes the project structure and dependencies to identify the framework.
+ * Detection order: Mintlify → Next.js (App/Pages Router) → Gatsby → RedwoodJS → Vite → React.
+ *
+ * For Next.js projects, further determines whether it uses App Router or Pages Router
+ * by checking for the presence of `app/` or `pages/` directories.
+ *
+ * @returns A promise resolving to a FrameworkObject containing:
+ *   - `name`: The detected framework identifier (e.g., 'next-app', 'gatsby', 'react')
+ *             or undefined if no framework is detected
+ *   - `type`: The framework category (currently only 'react' for React-based frameworks)
+ */
+export declare function detectFramework(): Promise<FrameworkObject | {
+    name: undefined;
+    type?: undefined;
+}>;
+/**
+ * Detects if the current project is a Mintlify documentation project.
+ *
+ * Checks for the presence of docs.json (preferred) or mint.json (legacy) files.
+ * For docs.json, validates that the $schema field contains "mintlify.com/docs.json".
+ * Rejects projects with Next.js config files to avoid misclassification.
+ *
+ * @param _packageJson - The parsed package.json object (not used for Mintlify detection,
+ *                       but kept for API consistency with other detection functions)
+ * @returns True if the project is identified as a Mintlify project, false otherwise
+ */
+export declare function isMintlifyProject(_packageJson: Record<string, any> | null): boolean;

package/dist/setup/detectFramework.js

@@ -0,0 +1,106 @@
+import { isPackageInstalled } from '../utils/packageJson.js';
+import { searchForPackageJson } from '../utils/packageJson.js';
+import fs from 'node:fs';
+import path from 'node:path';
+/* ----- MAIN ----- */
+/**
+ * Detects the frontend framework used in the current project.
+ *
+ * Analyzes the project structure and dependencies to identify the framework.
+ * Detection order: Mintlify → Next.js (App/Pages Router) → Gatsby → RedwoodJS → Vite → React.
+ *
+ * For Next.js projects, further determines whether it uses App Router or Pages Router
+ * by checking for the presence of `app/` or `pages/` directories.
+ *
+ * @returns A promise resolving to a FrameworkObject containing:
+ *   - `name`: The detected framework identifier (e.g., 'next-app', 'gatsby', 'react')
+ *             or undefined if no framework is detected
+ *   - `type`: The framework category (currently only 'react' for React-based frameworks)
+ */
+export async function detectFramework() {
+    const packageJson = await searchForPackageJson();
+    if (isMintlifyProject(packageJson)) {
+        return { name: 'mintlify' };
+    }
+    if (!packageJson) {
+        return { name: undefined };
+    }
+    // Check for Next.js first
+    if (isPackageInstalled('next', packageJson, false, true)) {
+        // Determine if it's App Router or Pages Router
+        const cwd = process.cwd();
+        const hasAppDir = fs.existsSync(path.join(cwd, 'app')) ||
+            fs.existsSync(path.join(cwd, 'src', 'app'));
+        const hasPagesDir = fs.existsSync(path.join(cwd, 'pages')) ||
+            fs.existsSync(path.join(cwd, 'src', 'pages'));
+        // App Router takes precedence if both exist
+        if (hasAppDir) {
+            return { name: 'next-app', type: 'react' };
+        }
+        if (hasPagesDir) {
+            return { name: 'next-pages', type: 'react' };
+        }
+        // Default to app router for new Next.js projects
+        return { name: 'next-app', type: 'react' };
+    }
+    // Check for Gatsby
+    if (isPackageInstalled('gatsby', packageJson, false, true)) {
+        return { name: 'gatsby', type: 'react' };
+    }
+    // Check for RedwoodJS
+    if (isPackageInstalled('@redwoodjs/core', packageJson, false, true)) {
+        return { name: 'redwood', type: 'react' };
+    }
+    // Check for Vite
+    if (isPackageInstalled('vite', packageJson, false, true)) {
+        return { name: 'vite', type: 'react' };
+    }
+    // Check for React (generic)
+    if (isPackageInstalled('react', packageJson, false, true)) {
+        return { name: 'react', type: 'react' };
+    }
+    return { name: undefined };
+}
+// ----- HELPER FUNCTIONS ----- //
+/**
+ * Detects if the current project is a Mintlify documentation project.
+ *
+ * Checks for the presence of docs.json (preferred) or mint.json (legacy) files.
+ * For docs.json, validates that the $schema field contains "mintlify.com/docs.json".
+ * Rejects projects with Next.js config files to avoid misclassification.
+ *
+ * @param _packageJson - The parsed package.json object (not used for Mintlify detection,
+ *                       but kept for API consistency with other detection functions)
+ * @returns True if the project is identified as a Mintlify project, false otherwise
+ */
+export function isMintlifyProject(_packageJson) {
+    const cwd = process.cwd();
+    // Check for Next.js config files - if present, this is not a Mintlify project
+    const nextConfigFiles = [
+        'next.config.js',
+        'next.config.ts',
+        'next.config.mjs',
+        'next.config.cjs',
+    ];
+    for (const configFile of nextConfigFiles) {
+        if (fs.existsSync(path.join(cwd, configFile))) {
+            return false;
+        }
+    }
+    // Check for docs.json (preferred format)
+    const docsJsonPath = path.join(cwd, 'docs.json');
+    if (fs.existsSync(docsJsonPath)) {
+        try {
+            const docsJson = JSON.parse(fs.readFileSync(docsJsonPath, 'utf-8'));
+            // Validate the $schema field contains mintlify.com/docs.json
+            if (docsJson.$schema &&
+                docsJson.$schema.includes('mintlify.com/docs.json')) {
+                return true;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}

package/dist/setup/frameworkUtils.d.ts

@@ -0,0 +1,3 @@
+import { FrameworkObject, ReactFrameworkObject } from '../types/index.js';
+export declare function getFrameworkDisplayName(frameworkObject: FrameworkObject): string;
+export declare function getReactFrameworkLibrary(frameworkObject: ReactFrameworkObject): string;