gtx-cli 2.6.31 → 2.7.0

package/dist/utils/processOpenApi.js

@@ -1,651 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { unified } from 'unified';
-import remarkParse from 'remark-parse';
-import remarkFrontmatter from 'remark-frontmatter';
-import YAML, { isMap, isScalar } from 'yaml';
-import { logger } from '../console/logger.js';
-import { createFileMapping } from '../formats/files/fileMapping.js';
-const HTTP_METHODS = new Set([
-    'GET',
-    'POST',
-    'PUT',
-    'PATCH',
-    'DELETE',
-    'OPTIONS',
-    'HEAD',
-    'TRACE',
-]);
-const OPENAPI_SPEC_EXTENSIONS = new Set(['.json', '.yaml', '.yml']);
-/**
- * Postprocess Mintlify OpenAPI references to point to locale-specific spec files.
- * - Uses openapi.files (ordered) to resolve ambiguities (first match wins).
- * - Relies on the user's json transform rules for locale paths.
- * - Warns on missing/ambiguous references but keeps behavior deterministic.
- */
-export default async function processOpenApi(settings, includeFiles) {
-    const openapiConfig = settings.options?.mintlify?.openapi;
-    if (!openapiConfig || !openapiConfig.files?.length)
-        return;
-    if (!settings.files)
-        return;
-    const configDir = path.dirname(settings.config);
-    const specAnalyses = buildSpecAnalyses(openapiConfig.files, configDir);
-    if (!specAnalyses.length)
-        return;
-    const warnings = new Set();
-    const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
-    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
-    const fileMappingAbs = {};
-    for (const [locale, mapping] of Object.entries(fileMapping)) {
-        fileMappingAbs[locale] = {};
-        for (const [src, dest] of Object.entries(mapping)) {
-            const absSrc = path.resolve(configDir, src);
-            const absDest = path.resolve(configDir, dest);
-            fileMappingAbs[locale][absSrc] = absDest;
-        }
-    }
-    // Also rewrite default-locale source files so they use the deterministic spec selection
-    const defaultFiles = [
-        ...(resolvedPaths.mdx || []),
-        ...(resolvedPaths.md || []),
-    ];
-    for (const filePath of defaultFiles) {
-        if (!fs.existsSync(filePath))
-            continue;
-        const content = fs.readFileSync(filePath, 'utf8');
-        const updated = rewriteFrontmatter(content, filePath, settings.defaultLocale, specAnalyses, fileMappingAbs, warnings, configDir);
-        if (updated?.changed) {
-            await fs.promises.writeFile(filePath, updated.content, 'utf8');
-        }
-    }
-    for (const [locale, filesMap] of Object.entries(fileMapping)) {
-        const targetFiles = Object.values(filesMap).filter((p) => (p.endsWith('.md') || p.endsWith('.mdx')) &&
-            (!includeFiles || includeFiles.has(p)));
-        for (const filePath of targetFiles) {
-            if (!fs.existsSync(filePath))
-                continue;
-            const content = fs.readFileSync(filePath, 'utf8');
-            const updated = rewriteFrontmatter(content, filePath, locale, specAnalyses, fileMappingAbs, warnings, configDir);
-            if (updated?.changed) {
-                await fs.promises.writeFile(filePath, updated.content, 'utf8');
-            }
-        }
-    }
-    const docsJsonTargets = collectDocsJsonTargets(settings, fileMapping, includeFiles);
-    for (const target of docsJsonTargets) {
-        if (!fs.existsSync(target.path))
-            continue;
-        const content = fs.readFileSync(target.path, 'utf8');
-        const updated = rewriteDocsJsonOpenApi(content, target.path, target.localeHint, specAnalyses, fileMappingAbs, fileMapping, warnings, configDir, settings.defaultLocale);
-        if (updated?.changed) {
-            await fs.promises.writeFile(target.path, updated.content, 'utf8');
-        }
-    }
-    for (const message of warnings) {
-        logger.warn(message);
-    }
-}
-function collectDocsJsonTargets(settings, fileMapping, includeFiles) {
-    const targets = [];
-    const seen = new Map();
-    const addTarget = (filePath, locale) => {
-        const canonicalPath = path.resolve(filePath);
-        if (includeFiles &&
-            !includeFiles.has(filePath) &&
-            !includeFiles.has(canonicalPath)) {
-            return;
-        }
-        const locales = seen.get(canonicalPath) ?? new Set();
-        if (locale)
-            locales.add(locale);
-        seen.set(canonicalPath, locales);
-    };
-    if (!includeFiles && settings.files?.resolvedPaths.json) {
-        for (const filePath of settings.files.resolvedPaths.json) {
-            addTarget(filePath, settings.defaultLocale);
-        }
-    }
-    for (const [locale, filesMap] of Object.entries(fileMapping)) {
-        for (const filePath of Object.values(filesMap)) {
-            if (!filePath.endsWith('.json'))
-                continue;
-            addTarget(filePath, locale);
-        }
-    }
-    for (const [filePath, locales] of seen.entries()) {
-        const localeHint = locales.size === 1 ? Array.from(locales)[0] : undefined;
-        targets.push({ path: filePath, localeHint });
-    }
-    return targets;
-}
-function isMintlifyDocsJson(filePath, json) {
-    if (!isRecord(json))
-        return false;
-    const schema = json.$schema;
-    if (typeof schema === 'string') {
-        return (schema.includes('mintlify.com/docs.json') ||
-            schema.includes('mintlify.com/mint.json'));
-    }
-    const base = path.basename(filePath);
-    return base === 'docs.json' || base === 'mint.json';
-}
-function rewriteDocsJsonOpenApi(content, filePath, localeHint, specs, fileMappingAbs, fileMappingRel, warnings, configDir, defaultLocale) {
-    let json;
-    try {
-        json = JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-    if (!isMintlifyDocsJson(filePath, json))
-        return null;
-    let changed = false;
-    const visitNode = (node, activeLocale) => {
-        if (Array.isArray(node)) {
-            node.forEach((item) => visitNode(item, activeLocale));
-            return;
-        }
-        if (!isRecord(node))
-            return;
-        let nextLocale = activeLocale;
-        if (typeof node.language === 'string') {
-            nextLocale = node.language;
-        }
-        const locale = nextLocale || localeHint || defaultLocale;
-        if (typeof node.openapi === 'string') {
-            const sourceValue = node.openapi;
-            const localizedSource = localizeDocsJsonSpecPath(sourceValue, locale, filePath, specs, fileMappingAbs, fileMappingRel, warnings, configDir);
-            if (localizedSource && localizedSource !== sourceValue) {
-                node.openapi = localizedSource;
-                changed = true;
-            }
-        }
-        else if (isRecord(node.openapi)) {
-            const openapiConfig = node.openapi;
-            const sourceValue = openapiConfig.source;
-            if (typeof sourceValue === 'string') {
-                const localizedSource = localizeDocsJsonSpecPath(sourceValue, locale, filePath, specs, fileMappingAbs, fileMappingRel, warnings, configDir);
-                if (localizedSource && localizedSource !== sourceValue) {
-                    openapiConfig.source = localizedSource;
-                    changed = true;
-                }
-            }
-        }
-        if (Array.isArray(node.pages)) {
-            const pages = node.pages;
-            for (let i = 0; i < pages.length; i += 1) {
-                const page = pages[i];
-                if (typeof page !== 'string')
-                    continue;
-                const updated = stripLocaleFromOpenApiPage(page, locale);
-                if (updated !== page) {
-                    pages[i] = updated;
-                    changed = true;
-                }
-            }
-        }
-        for (const value of Object.values(node)) {
-            visitNode(value, nextLocale);
-        }
-    };
-    visitNode(json, undefined);
-    if (!changed)
-        return null;
-    return { changed, content: JSON.stringify(json, null, 2) };
-}
-function stripLocaleFromOpenApiPage(value, locale) {
-    const trimmed = value.trim();
-    const prefix = `${locale}/`;
-    if (!trimmed.startsWith(prefix))
-        return value;
-    const candidate = trimmed.slice(prefix.length);
-    const parsed = parseOpenApiValue(candidate);
-    if (!parsed)
-        return value;
-    return candidate;
-}
-function localizeDocsJsonSpecPath(source, locale, filePath, specs, fileMappingAbs, _fileMappingRel, warnings, configDir) {
-    const resolvedAbs = resolveDocsJsonSpecPath(source, filePath, configDir);
-    const matched = matchSpecBySource(source, resolvedAbs, specs, warnings);
-    if (!matched)
-        return source;
-    const localizedSpecPath = resolveLocalizedSpecPath(matched, locale, fileMappingAbs, configDir, source);
-    const localizedAbs = resolveDocsJsonSpecPath(localizedSpecPath, filePath, configDir);
-    if (!fs.existsSync(localizedAbs)) {
-        warnings.add(`OpenAPI source "${source}" localized for locale "${locale}" points to a missing file (${localizedAbs}). Keeping original source.`);
-        return source;
-    }
-    const rel = normalizeSlashes(path.relative(configDir, localizedAbs));
-    return formatSpecPathForDocsJson(rel, source);
-}
-function resolveDocsJsonSpecPath(source, filePath, configDir) {
-    if (source.startsWith('/')) {
-        return path.resolve(configDir, source.replace(/^\/+/, ''));
-    }
-    if (source.startsWith('./') || source.startsWith('../')) {
-        return path.resolve(path.dirname(filePath), source);
-    }
-    return path.resolve(configDir, source);
-}
-function matchSpecBySource(source, resolvedAbs, specs, warnings) {
-    const exact = specs.find((spec) => samePath(resolvedAbs, spec.absPath));
-    if (exact)
-        return exact;
-    const normalizedExplicit = normalizeSlashes(source).replace(/^\.?\/+/, '');
-    const explicitWithoutExt = stripExtension(normalizedExplicit);
-    const explicitBase = path.basename(normalizedExplicit);
-    const explicitBaseWithoutExt = stripExtension(explicitBase);
-    const matches = specs.filter((spec) => {
-        const configPath = normalizeSlashes(spec.configPath).replace(/^\.?\/+/, '');
-        const configBase = path.basename(configPath);
-        const configPathNoExt = stripExtension(configPath);
-        const configBaseNoExt = stripExtension(configBase);
-        return (configPath === normalizedExplicit ||
-            configPathNoExt === explicitWithoutExt ||
-            configBase === explicitBase ||
-            configBaseNoExt === explicitBaseWithoutExt);
-    });
-    if (matches.length === 1)
-        return matches[0];
-    if (matches.length > 1) {
-        warnings.add(`OpenAPI source "${source}" matches multiple specs (${matches
-            .map((m) => m.configPath)
-            .join(', ')}). Using the first configured match (${matches[0].configPath}).`);
-        return matches[0];
-    }
-    return null;
-}
-function formatSpecPathForDocsJson(relativePath, originalPathText) {
-    const normalized = normalizeSlashes(relativePath);
-    const base = normalized.replace(/^\.\//, '').replace(/\/+/g, '/');
-    if (originalPathText.startsWith('/')) {
-        return `/${base.replace(/^\/+/, '')}`;
-    }
-    if (originalPathText.startsWith('../')) {
-        return normalized;
-    }
-    if (originalPathText.startsWith('./')) {
-        return `./${base.replace(/^\/+/, '')}`;
-    }
-    return base.replace(/^\/+/, '');
-}
-/**
- * Resolve configured OpenAPI files to absolute paths and collect the operations,
- * schemas, and webhooks they expose. Warns and skips when files are missing,
- * unsupported (non-JSON/YAML), or fail to parse so later steps can continue gracefully.
- */
-function buildSpecAnalyses(openapiFiles, configDir) {
-    const analyses = [];
-    for (const configEntry of openapiFiles) {
-        const absPath = path.resolve(configDir, configEntry);
-        if (!fs.existsSync(absPath)) {
-            logger.warn(`OpenAPI file not found: ${configEntry}`);
-            continue;
-        }
-        const ext = path.extname(absPath).toLowerCase();
-        if (!OPENAPI_SPEC_EXTENSIONS.has(ext)) {
-            logger.warn(`Skipping OpenAPI file (only .json/.yml/.yaml supported): ${configEntry}`);
-            continue;
-        }
-        let spec;
-        try {
-            const raw = fs.readFileSync(absPath, 'utf8');
-            spec = ext === '.json' ? JSON.parse(raw) : YAML.parse(raw);
-        }
-        catch {
-            const format = ext === '.json' ? 'JSON' : 'YAML';
-            logger.warn(`Failed to parse OpenAPI ${format}: ${configEntry}`);
-            continue;
-        }
-        analyses.push({
-            absPath,
-            configPath: configEntry,
-            operations: extractOperations(spec),
-            schemas: extractSchemas(spec),
-            webhooks: extractWebhooks(spec),
-        });
-    }
-    return analyses;
-}
-function isRecord(val) {
-    return typeof val === 'object' && val !== null;
-}
-/**
- * Collect path+method identifiers (e.g., "POST /foo") from an OpenAPI spec.
- * Safely no-ops when paths is missing or malformed.
- */
-function extractOperations(spec) {
-    const ops = new Set();
-    if (!isRecord(spec) || !isRecord(spec.paths))
-        return ops;
-    const paths = spec.paths;
-    for (const [route, methods] of Object.entries(paths)) {
-        if (!isRecord(methods))
-            continue;
-        for (const [method, operation] of Object.entries(methods)) {
-            if (!isRecord(operation))
-                continue;
-            const upper = method.toUpperCase();
-            if (!HTTP_METHODS.has(upper))
-                continue;
-            ops.add(`${upper} ${route}`);
-        }
-    }
-    return ops;
-}
-/**
- * Collect schema names from components.schemas.
- * Returns empty set if components/schemas are missing or malformed.
- */
-function extractSchemas(spec) {
-    if (!isRecord(spec) || !isRecord(spec.components))
-        return new Set();
-    const components = spec.components;
-    if (!isRecord(components.schemas))
-        return new Set();
-    return new Set(Object.keys(components.schemas));
-}
-/**
- * Collect webhook names from webhooks (OpenAPI 3.1+).
- * Returns empty set if webhooks is missing or malformed.
- */
-function extractWebhooks(spec) {
-    if (!isRecord(spec) || !isRecord(spec.webhooks))
-        return new Set();
-    return new Set(Object.keys(spec.webhooks));
-}
-/**
- * Parse MDX/MD frontmatter, rewrite openapi/openapi-schema entries to the
- * resolved (possibly localized) spec path, and return updated content.
- * Uses remark to find the YAML node so the rest of the document remains
- * untouched. When parsing fails or no relevant keys exist, it returns null.
- */
-function rewriteFrontmatter(content, filePath, locale, specs, fileMapping, warnings, configDir) {
-    let tree;
-    try {
-        tree = unified()
-            .use(remarkParse)
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .parse(content);
-    }
-    catch {
-        return null;
-    }
-    const yamlNode = tree.children.find((node) => node.type === 'yaml');
-    if (!yamlNode ||
-        !yamlNode.position ||
-        yamlNode.position.start?.offset === undefined) {
-        return null;
-    }
-    const start = yamlNode.position.start.offset;
-    const end = yamlNode.position.end.offset;
-    const frontmatterRaw = yamlNode.value || '';
-    const doc = YAML.parseDocument(frontmatterRaw, {
-        prettyErrors: false,
-        keepSourceTokens: true,
-    });
-    if (doc.errors?.length)
-        return null;
-    if (!isMap(doc.contents))
-        return null;
-    let changed = false;
-    const openapiNode = doc.get('openapi', true);
-    if (isScalar(openapiNode) && typeof openapiNode.value === 'string') {
-        const parsedValue = parseOpenApiValue(openapiNode.value);
-        if (parsedValue) {
-            const matchKey = parsedValue.kind === 'operation'
-                ? {
-                    type: 'operation',
-                    key: `${parsedValue.method.toUpperCase()} ${parsedValue.operationPath}`,
-                }
-                : { type: 'webhook', key: parsedValue.name };
-            const spec = resolveSpec(parsedValue.specPath, specs, filePath, configDir, warnings, describeOpenApiRef(parsedValue), matchKey);
-            if (spec) {
-                const descriptor = formatOpenApiDescriptor(parsedValue);
-                const localizedSpecPath = resolveLocalizedSpecPath(spec, locale, fileMapping, configDir, parsedValue.specPath || spec.configPath);
-                const newValue = `${localizedSpecPath} ${descriptor}`.trim();
-                if (newValue !== openapiNode.value) {
-                    doc.set('openapi', newValue);
-                    changed = true;
-                }
-            }
-        }
-    }
-    const schemaNode = doc.get('openapi-schema', true);
-    if (isScalar(schemaNode) && typeof schemaNode.value === 'string') {
-        const parsedValue = parseSchemaValue(schemaNode.value);
-        if (parsedValue) {
-            const spec = resolveSpec(parsedValue.specPath, specs, filePath, configDir, warnings, `schema "${parsedValue.schemaName}"`, { type: 'schema', key: parsedValue.schemaName });
-            if (spec) {
-                const localizedSpecPath = resolveLocalizedSpecPath(spec, locale, fileMapping, configDir, parsedValue.specPath || spec.configPath);
-                const newValue = `${localizedSpecPath} ${parsedValue.schemaName}`.trim();
-                if (newValue !== schemaNode.value) {
-                    doc.set('openapi-schema', newValue);
-                    changed = true;
-                }
-            }
-        }
-    }
-    if (!changed)
-        return null;
-    const fmString = doc.toString().trimEnd();
-    const rebuilt = `${content.slice(0, start)}---\n${fmString}\n---${content.slice(end)}`;
-    return { changed, content: rebuilt };
-}
-function stripWrappingQuotes(value) {
-    return value.trim().replace(/^['"]|['"]$/g, '');
-}
-/**
- * Parse frontmatter openapi string into spec/method/path or webhook.
- * Supports optional leading spec file, the webhook keyword, quoted values,
- * and forgiving whitespace. Returns null when the structure is unrecognized.
- */
-function parseOpenApiValue(value) {
-    const stripped = stripWrappingQuotes(value);
-    const tokens = stripped.split(/\s+/).filter(Boolean);
-    if (!tokens.length)
-        return null;
-    let cursor = 0;
-    let specPath;
-    const first = tokens[0];
-    const second = tokens[1];
-    const methodCandidate = second?.toUpperCase();
-    const firstLooksLikeSpec = hasOpenApiSpecExtension(first) ||
-        (second &&
-            (second.toLowerCase() === 'webhook' ||
-                (methodCandidate && HTTP_METHODS.has(methodCandidate))));
-    if (firstLooksLikeSpec) {
-        specPath = tokens[0];
-        cursor = 1;
-    }
-    if (cursor >= tokens.length)
-        return null;
-    const keyword = tokens[cursor];
-    if (keyword.toLowerCase() === 'webhook') {
-        const name = tokens.slice(cursor + 1).join(' ');
-        if (!name)
-            return null;
-        return { kind: 'webhook', specPath, name };
-    }
-    const method = keyword.toUpperCase();
-    if (!HTTP_METHODS.has(method))
-        return null;
-    const operationPath = tokens.slice(cursor + 1).join(' ');
-    if (!operationPath)
-        return null;
-    return { kind: 'operation', specPath, method, operationPath };
-}
-/**
- * Parse frontmatter openapi-schema string into spec/schemaName.
- * Accepts optional leading spec file and quoted values; returns null on invalid
- * shapes so callers can skip rewrites gracefully.
- */
-function parseSchemaValue(value) {
-    const stripped = stripWrappingQuotes(value);
-    const tokens = stripped.split(/\s+/).filter(Boolean);
-    if (!tokens.length)
-        return null;
-    let cursor = 0;
-    let specPath;
-    if (hasOpenApiSpecExtension(tokens[0])) {
-        specPath = tokens[0];
-        cursor = 1;
-    }
-    const schemaName = tokens.slice(cursor).join(' ');
-    if (!schemaName)
-        return null;
-    return { specPath, schemaName };
-}
-/**
- * Choose which configured spec a reference should use.
- * - If an explicit spec path is provided, resolve it relative to the config
- *   and the referencing file, warn when unknown, and bail.
- * - Otherwise, try to match by operation/webhook/schema name; resolve
- *   ambiguity using config order and warn when ambiguous or missing.
- */
-function resolveSpec(explicitPath, specs, filePath, configDir, warnings, refDescription, match) {
-    if (!specs.length)
-        return null;
-    if (explicitPath) {
-        const normalizedExplicit = normalizeSlashes(explicitPath.replace(/^\.?\/+/, ''));
-        const candidates = [
-            path.resolve(configDir, normalizedExplicit),
-            path.resolve(path.dirname(filePath), normalizedExplicit),
-        ];
-        const foundSpec = specs.find((spec) => {
-            const normalizedSpecPath = normalizeSlashes(spec.absPath);
-            return candidates.some((candidate) => samePath(candidate, normalizedSpecPath));
-        });
-        if (foundSpec) {
-            if (specHasMatch(foundSpec, match)) {
-                return foundSpec;
-            }
-            const alternatives = specs.filter((spec) => spec !== foundSpec && specHasMatch(spec, match));
-            if (alternatives.length === 1) {
-                warnings.add(`OpenAPI reference ${refDescription} in ${filePath} points to ${foundSpec.configPath}, but the entry was not found there. Using ${alternatives[0].configPath} instead.`);
-                return alternatives[0];
-            }
-            if (alternatives.length > 1) {
-                warnings.add(`OpenAPI reference ${refDescription} in ${filePath} points to ${foundSpec.configPath}, but the entry was not found there and matches multiple specs (${alternatives
-                    .map((spec) => spec.configPath)
-                    .join(', ')}). Skipping localization for this reference.`);
-                return null;
-            }
-            warnings.add(`OpenAPI reference ${refDescription} in ${filePath} points to ${foundSpec.configPath}, but the entry was not found in any configured spec. Skipping localization for this reference.`);
-            return null;
-        }
-        const explicitWithoutExt = stripExtension(normalizedExplicit);
-        const explicitBase = path.basename(normalizedExplicit);
-        const explicitBaseWithoutExt = stripExtension(explicitBase);
-        const matches = specs.filter((spec) => {
-            const configPath = normalizeSlashes(spec.configPath).replace(/^\.?\/+/, '');
-            const configBase = path.basename(configPath);
-            const configPathNoExt = stripExtension(configPath);
-            const configBaseNoExt = stripExtension(configBase);
-            return (configPath === normalizedExplicit ||
-                configPathNoExt === explicitWithoutExt ||
-                configBase === explicitBase ||
-                configBaseNoExt === explicitBaseWithoutExt);
-        });
-        if (matches.length === 1)
-            return matches[0];
-        if (matches.length > 1) {
-            warnings.add(`OpenAPI reference ${refDescription} in ${filePath} matches multiple specs (${matches
-                .map((m) => m.configPath)
-                .join(', ')}). Using the first configured match (${matches[0].configPath}).`);
-            return matches[0];
-        }
-        warnings.add(`OpenAPI reference ${refDescription} in ${filePath} points to an unconfigured spec (${explicitPath}). Skipping localization for this reference.`);
-        return null;
-    }
-    // No explicit spec: try to find by contents
-    const matches = specs.filter((spec) => {
-        if (match.type === 'schema') {
-            return spec.schemas.has(match.key);
-        }
-        if (match.type === 'webhook') {
-            return spec.webhooks.has(match.key);
-        }
-        // operation
-        return spec.operations.has(match.key);
-    });
-    if (matches.length === 1)
-        return matches[0];
-    if (matches.length > 1) {
-        warnings.add(`OpenAPI reference ${refDescription} in ${filePath} is available in multiple specs. Skipping localization for this reference.`);
-        return null;
-    }
-    warnings.add(`OpenAPI reference ${refDescription} in ${filePath} was not found in any configured spec. Skipping localization for this reference.`);
-    return null;
-}
-function specHasMatch(spec, match) {
-    if (match.type === 'schema') {
-        return spec.schemas.has(match.key);
-    }
-    if (match.type === 'webhook') {
-        return spec.webhooks.has(match.key);
-    }
-    return spec.operations.has(match.key);
-}
-/**
- * Map a spec to the locale-specific file path when available and normalize it
- * for frontmatter. Falls back to the source spec when the locale copy does
- * not exist to preserve deterministic behavior.
- */
-function resolveLocalizedSpecPath(spec, locale, fileMapping, configDir, originalPathText) {
-    const mapping = fileMapping[locale]?.[spec.absPath];
-    const chosenAbs = mapping || spec.absPath;
-    const rel = normalizeSlashes(path.relative(configDir, chosenAbs));
-    const rooted = `/${rel.replace(/^\/+/, '')}`;
-    return formatSpecPathForFrontmatter(rooted, originalPathText || spec.configPath);
-}
-/**
- * Format the path that will be written back to frontmatter:
- * - Preserve the user's absolute style when they used a leading slash.
- * - Preserve upward relative references (../) exactly.
- * - Otherwise return a repo-root-relative path with a leading slash so Mintlify
- *   resolves consistently regardless of the MDX file location.
- */
-function formatSpecPathForFrontmatter(relativePath, originalPathText) {
-    const normalized = normalizeSlashes(relativePath);
-    const base = normalized.replace(/^\.\//, '').replace(/\/+/g, '/');
-    if (originalPathText.startsWith('/')) {
-        // Force repo-root absolute style
-        return `/${base.replace(/^\/+/, '')}`;
-    }
-    if (originalPathText.startsWith('../')) {
-        // Preserve explicit relative upward references
-        return normalized;
-    }
-    // Default to repo-root relative with leading slash to avoid resolving relative to the MDX directory
-    return `/${base.replace(/^\/+/, '')}`;
-}
-/** Normalize the descriptive portion after the spec path for frontmatter. */
-function formatOpenApiDescriptor(value) {
-    if (value.kind === 'webhook')
-        return `webhook ${value.name}`;
-    return `${value.method.toUpperCase()} ${value.operationPath}`;
-}
-/** Human-readable description a specific OpenAPI reference. */
-function describeOpenApiRef(value) {
-    if (value.kind === 'webhook')
-        return `webhook ${value.name}`;
-    return `${value.method.toUpperCase()} ${value.operationPath}`;
-}
-/** Remove a single trailing file extension while preserving directory segments. */
-function stripExtension(p) {
-    const parsed = path.parse(p);
-    return normalizeSlashes(path.join(parsed.dir, parsed.name));
-}
-function hasOpenApiSpecExtension(value) {
-    return OPENAPI_SPEC_EXTENSIONS.has(path.extname(value).toLowerCase());
-}
-/** Normalize separators for stable comparisons and output. */
-function normalizeSlashes(p) {
-    return p.replace(/\\/g, '/');
-}
-/** Compare paths after resolution to avoid casing/separator mismatches. */
-function samePath(a, b) {
-    return path.resolve(a) === path.resolve(b);
-}

package/dist/utils/sanitizeFileContent.d.ts

@@ -1,6 +0,0 @@
-/**
- * Processes content to escape curl commands within tick marks and existing escape strings
- * @param content - The content to process
- * @returns the processed content with escaped curl commands
- */
-export default function sanitizeFileContent(content: string): string;

package/dist/utils/sanitizeFileContent.js

@@ -1,29 +0,0 @@
-/**
- * Processes content to escape curl commands within tick marks and existing escape strings
- * @param content - The content to process
- * @returns the processed content with escaped curl commands
- */
-export default function sanitizeFileContent(content) {
-    const ESCAPE_STRING = '_GT_INTERNAL_ESCAPE';
-    const allTickMarkRegex = /`([^`]*)`/g;
-    let processedContent = content;
-    // First, escape any existing tick marks followed by _GT_INTERNAL_ESCAPE
-    // This protects pre-existing escapes
-    processedContent = processedContent.replace(new RegExp('`' + ESCAPE_STRING, 'g'), '`' + ESCAPE_STRING + ESCAPE_STRING);
-    // Then find ALL tick mark pairs and process them individually
-    // This approach is more reliable than negative lookahead with modified content
-    processedContent = processedContent.replace(allTickMarkRegex, (match, innerContent) => {
-        // Skip if this already starts with our escape string (protected or already processed)
-        if (innerContent.startsWith(ESCAPE_STRING)) {
-            return match;
-        }
-        // Check if the content contains a curl command
-        if (/\bcurl\b/i.test(innerContent)) {
-            // Insert escape string after opening tick
-            return '`' + ESCAPE_STRING + innerContent + '`';
-        }
-        // Return original match if no curl command found
-        return match;
-    });
-    return processedContent;
-}