magicpath-ai 1.3.0-beta.9 → 1.3.0

package/dist/util/integrate.js

@@ -1,762 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import axios from 'axios';
-import { createTwoFilesPatch } from 'diff';
-import { makeIntegrateUrl, makeIntegrateJobUrl } from './api.js';
-import { getAuthHeaders } from './auth.js';
-import { MagicPathError } from './error.js';
-import { AuthRequiredError } from './authError.js';
-import { logger } from './logger.js';
-/** Thrown when the user presses 's' to skip the current file during retheme. */
-export class SkipFileError extends Error {
-    constructor() {
-        super('File skipped by user');
-        this.name = 'SkipFileError';
-    }
-}
-export function detectFramework(cwd) {
-    const pkgPath = path.join(cwd, 'package.json');
-    if (!fs.existsSync(pkgPath))
-        return 'unknown';
-    try {
-        const pkg = fs.readJsonSync(pkgPath);
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-        if (deps.next) {
-            if (fs.existsSync(path.join(cwd, 'app')) ||
-                fs.existsSync(path.join(cwd, 'src', 'app'))) {
-                return 'nextjs-app';
-            }
-            if (fs.existsSync(path.join(cwd, 'pages')) ||
-                fs.existsSync(path.join(cwd, 'src', 'pages'))) {
-                return 'nextjs-pages';
-            }
-            return 'nextjs-app'; // default for Next.js
-        }
-        if (deps.vite)
-            return 'vite';
-        // tslint:disable-next-line:no-string-literal
-        if (deps['react-scripts'])
-            return 'cra';
-    }
-    catch {
-        // ignore
-    }
-    return 'unknown';
-}
-const LANGUAGE_CONFIGS = {
-    js: {
-        displayName: 'JavaScript/TypeScript',
-        extensions: ['.tsx', '.ts', '.jsx', '.js'],
-        excludedDirs: [
-            'node_modules',
-            '.git',
-            'dist',
-            '.next',
-            'build',
-            'out',
-            '.turbo',
-            '.vercel',
-        ],
-        excludedPatterns: [
-            /\.test\.[jt]sx?$/,
-            /\.spec\.[jt]sx?$/,
-            /\.stories\.[jt]sx?$/,
-            /\.config\.[jt]sx?$/,
-            /\.d\.ts$/,
-            /\.env/,
-        ],
-    },
-    swift: {
-        displayName: 'Swift/SwiftUI',
-        extensions: ['.swift'],
-        excludedDirs: [
-            '.git',
-            '.build',
-            'DerivedData',
-            'Pods',
-            '.swiftpm',
-            'build',
-        ],
-        excludedPatterns: [
-            /Tests?\.swift$/,
-            /\.generated\.swift$/,
-            /Package\.swift$/,
-        ],
-    },
-    kotlin: {
-        displayName: 'Kotlin/Jetpack Compose',
-        extensions: ['.kt', '.kts'],
-        excludedDirs: ['.git', '.gradle', 'build', '.idea', 'gradle'],
-        excludedPatterns: [/Test\.kt$/, /\.generated\.kt$/],
-    },
-    dart: {
-        displayName: 'Dart/Flutter',
-        extensions: ['.dart'],
-        excludedDirs: ['.git', '.dart_tool', 'build', '.idea', '.pub-cache'],
-        excludedPatterns: [/_test\.dart$/, /\.g\.dart$/, /\.freezed\.dart$/],
-    },
-};
-export function detectLanguageFromExtension(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    if (['.tsx', '.ts', '.jsx', '.js'].includes(ext))
-        return 'js';
-    for (const [lang, config] of Object.entries(LANGUAGE_CONFIGS)) {
-        if (config.extensions.includes(ext))
-            return lang;
-    }
-    return ext.replace(/^\./, '') || 'unknown';
-}
-export function detectProjectLanguage(cwd) {
-    const markers = [
-        ['Package.swift', 'swift'],
-        ['build.gradle', 'kotlin'],
-        ['build.gradle.kts', 'kotlin'],
-        ['pubspec.yaml', 'dart'],
-        ['package.json', 'js'],
-    ];
-    for (const [file, lang] of markers) {
-        if (fs.existsSync(path.join(cwd, file)))
-            return lang;
-    }
-    // Check for Xcode project directories
-    try {
-        const entries = fs.readdirSync(cwd);
-        if (entries.some((e) => e.endsWith('.xcodeproj') || e.endsWith('.xcworkspace'))) {
-            return 'swift';
-        }
-    }
-    catch {
-        // ignore unreadable directory
-    }
-    // No manifest found — infer language from file extensions in the directory
-    try {
-        const entries = fs.readdirSync(cwd);
-        for (const [lang, config] of Object.entries(LANGUAGE_CONFIGS)) {
-            if (lang === 'js')
-                continue; // JS requires package.json
-            if (entries.some((e) => config.extensions.some((ext) => e.endsWith(ext)))) {
-                return lang;
-            }
-        }
-    }
-    catch {
-        // ignore unreadable directory
-    }
-    return 'unknown';
-}
-export function getLanguageDisplayName(language) {
-    return LANGUAGE_CONFIGS[language]?.displayName ?? language;
-}
-const EXCLUDED_DIRS = LANGUAGE_CONFIGS.js.excludedDirs;
-const EXCLUDED_PATTERNS = LANGUAGE_CONFIGS.js.excludedPatterns;
-function walkSync(dir, base, maxDepth, depth = 0, opts) {
-    if (depth > maxDepth)
-        return [];
-    const results = [];
-    const effectiveExcludedDirs = opts?.excludedDirs ?? EXCLUDED_DIRS;
-    const effectiveExcludedPatterns = opts?.excludedPatterns ?? EXCLUDED_PATTERNS;
-    const extensionRegex = opts?.extensions
-        ? new RegExp(`(${opts.extensions.map((e) => e.replace('.', '\\.')).join('|')})$`)
-        : /\.[jt]sx?$/;
-    let entries;
-    try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return results;
-    }
-    for (const entry of entries) {
-        if (effectiveExcludedDirs.some((d) => d.toLowerCase() === entry.name.toLowerCase()))
-            continue;
-        const fullPath = path.join(dir, entry.name);
-        const rel = path.relative(base, fullPath);
-        if (entry.isDirectory()) {
-            results.push(...walkSync(fullPath, base, maxDepth, depth + 1, opts));
-        }
-        else if (extensionRegex.test(entry.name)) {
-            if (!effectiveExcludedPatterns.some((p) => p.test(rel))) {
-                results.push(rel);
-            }
-        }
-    }
-    return results;
-}
-function labelForFile(rel, framework) {
-    if (/app\/.*page\.[jt]sx?$/.test(rel))
-        return '(page)';
-    if (/app\/.*layout\.[jt]sx?$/.test(rel))
-        return '(layout)';
-    if (/pages\/.*\.[jt]sx?$/.test(rel))
-        return '(page)';
-    if (/App\.[jt]sx?$/.test(rel))
-        return '(app root)';
-    return '';
-}
-export function findIntegrationCandidates(cwd, framework) {
-    const candidates = [];
-    switch (framework) {
-        case 'nextjs-app': {
-            // Check both root app/ and src/app/
-            const appDir = fs.existsSync(path.join(cwd, 'src', 'app'))
-                ? path.join(cwd, 'src', 'app')
-                : path.join(cwd, 'app');
-            if (fs.existsSync(appDir)) {
-                const pages = walkSync(appDir, cwd, 4).filter((f) => /page\.[jt]sx?$/.test(f));
-                candidates.push(...pages);
-            }
-            break;
-        }
-        case 'nextjs-pages': {
-            const pagesDir = fs.existsSync(path.join(cwd, 'src', 'pages'))
-                ? path.join(cwd, 'src', 'pages')
-                : path.join(cwd, 'pages');
-            if (fs.existsSync(pagesDir)) {
-                const pages = walkSync(pagesDir, cwd, 4).filter((f) => !/_(app|document)\.[jt]sx?$/.test(f));
-                candidates.push(...pages);
-            }
-            break;
-        }
-        case 'vite':
-        case 'cra': {
-            const viteSrcDir = path.join(cwd, 'src');
-            const appFile = ['src/App.tsx', 'src/App.jsx'].find((f) => fs.existsSync(path.join(cwd, f)));
-            if (appFile)
-                candidates.push(appFile);
-            const pagesDir = path.join(viteSrcDir, 'pages');
-            if (fs.existsSync(pagesDir)) {
-                candidates.push(...walkSync(pagesDir, cwd, 4));
-            }
-            break;
-        }
-        default:
-            break;
-    }
-    // Always include other .tsx/.jsx files from src/ (after framework-specific ones)
-    const srcDir = path.join(cwd, 'src');
-    if (fs.existsSync(srcDir)) {
-        const files = walkSync(srcDir, cwd, 4).filter((f) => /\.[jt]sx$/.test(f));
-        candidates.push(...files);
-    }
-    // Deduplicate
-    const unique = [...new Set(candidates)];
-    return unique.map((rel) => ({
-        relativePath: rel,
-        label: labelForFile(rel, framework),
-    }));
-}
-/**
- * Find integration candidate files for any language.
- * For JS/TS, delegates to the framework-aware findIntegrationCandidates.
- * For other languages, scans using LANGUAGE_CONFIGS.
- */
-export function findCandidates(cwd, language, framework) {
-    if (language === 'js') {
-        return findIntegrationCandidates(cwd, framework);
-    }
-    const config = LANGUAGE_CONFIGS[language];
-    const walkOpts = config
-        ? {
-            extensions: config.extensions,
-            excludedDirs: config.excludedDirs,
-            excludedPatterns: config.excludedPatterns,
-        }
-        : undefined;
-    const candidates = walkSync(cwd, cwd, 10, 0, walkOpts);
-    const unique = [...new Set(candidates)];
-    return unique.map((rel) => ({
-        relativePath: rel,
-        label: '',
-    }));
-}
-const MAX_TOTAL_SIZE = 100 * 1024; // 100KB
-const RESOLVE_EXTENSIONS = [
-    '.tsx',
-    '.ts',
-    '.jsx',
-    '.js',
-    '/index.tsx',
-    '/index.ts',
-];
-/**
- * Resolve an import specifier to an absolute file path.
- * Handles relative paths (./foo, ../bar) and @/ alias (mapped to src/).
- */
-function resolveImportPath(specifier, fromDir, cwd) {
-    let basePath;
-    if (specifier.startsWith('.')) {
-        basePath = path.resolve(fromDir, specifier);
-    }
-    else if (specifier.startsWith('@/')) {
-        basePath = path.resolve(cwd, 'src', specifier.slice(2));
-    }
-    else {
-        return null; // node_modules / external
-    }
-    // Try with extensions
-    for (const ext of RESOLVE_EXTENSIONS) {
-        const candidate = basePath + ext;
-        if (fs.existsSync(candidate))
-            return candidate;
-    }
-    // Try exact path
-    if (fs.existsSync(basePath) && fs.statSync(basePath).isFile()) {
-        return basePath;
-    }
-    return null;
-}
-/**
- * Find files under src/ that import the target file (reverse dependencies / "parents").
- */
-export function findReverseDependencies(targetPath, cwd, sizeBudget) {
-    const targetAbs = path.resolve(cwd, targetPath);
-    const srcDir = path.join(cwd, 'src');
-    if (!fs.existsSync(srcDir))
-        return [];
-    const allFiles = walkSync(srcDir, cwd, 4);
-    const results = [];
-    const importRegex = /(?:import|from)\s+['"]([^'"]+)['"]/g;
-    for (const relFile of allFiles) {
-        if (results.length >= 5)
-            break;
-        const absFile = path.resolve(cwd, relFile);
-        if (absFile === targetAbs)
-            continue; // skip self
-        try {
-            const content = fs.readFileSync(absFile, 'utf8');
-            let imports = false;
-            importRegex.lastIndex = 0;
-            let match = importRegex.exec(content);
-            while (match !== null) {
-                const resolved = resolveImportPath(match[1], path.dirname(absFile), cwd);
-                if (resolved === targetAbs) {
-                    imports = true;
-                    break;
-                }
-                match = importRegex.exec(content);
-            }
-            if (imports) {
-                const size = Buffer.byteLength(content);
-                if (size > sizeBudget.remaining)
-                    continue; // skip if too large, try next
-                sizeBudget.remaining -= size;
-                results.push({ path: relFile, content });
-            }
-        }
-        catch {
-            // skip unreadable files
-        }
-    }
-    return results;
-}
-/**
- * Read the target file, its imports (children), and files that import it (parents).
- */
-/**
- * Extract local imports from file content and resolve them to FileContent entries.
- * Skips files already in the seenPaths set and respects the size budget.
- */
-function extractImports(fileContent, fileAbsPath, cwd, seenPaths, sizeBudget, maxFiles) {
-    const results = [];
-    const importRegex = /(?:import|from)\s+['"]([.@][^'"]+)['"]/g;
-    const matches = [];
-    let m = importRegex.exec(fileContent);
-    while (m !== null) {
-        matches.push(m);
-        m = importRegex.exec(fileContent);
-    }
-    for (const match of matches) {
-        if (results.length >= maxFiles)
-            break;
-        const specifier = match[1];
-        const resolved = resolveImportPath(specifier, path.dirname(fileAbsPath), cwd);
-        if (!resolved)
-            continue;
-        if (resolved.includes('node_modules'))
-            continue;
-        const relPath = path.relative(cwd, resolved);
-        // Skip UI library primitives (e.g. components/ui/button) and static assets
-        if (/\/(ui|assets)\//.test(relPath))
-            continue;
-        if (seenPaths.has(relPath))
-            continue;
-        try {
-            const content = fs.readFileSync(resolved, 'utf8');
-            const size = Buffer.byteLength(content);
-            if (size > sizeBudget.remaining)
-                continue;
-            sizeBudget.remaining -= size;
-            seenPaths.add(relPath);
-            results.push({ path: relPath, content });
-        }
-        catch {
-            // skip unreadable files
-        }
-    }
-    return results;
-}
-// ── Non-JS context gathering (type-name-based reverse deps) ──────────
-/**
- * Extract declared type names (struct, class, enum, protocol, etc.) from source code.
- * Intentionally broad regex that works across Swift, Kotlin, Dart, and similar languages.
- */
-function extractTypeNames(content) {
-    const typeRegex = /(?:struct|class|enum|protocol|extension|typealias)\s+([A-Z][a-zA-Z0-9]*)/g;
-    const names = new Set();
-    let match = typeRegex.exec(content);
-    while (match !== null) {
-        names.add(match[1]);
-        match = typeRegex.exec(content);
-    }
-    return [...names];
-}
-/**
- * Find files that reference any of the given type names (reverse dependencies by name).
- * Used for non-JS languages where import resolution isn't feasible.
- */
-function findReverseDependenciesByName(targetPath, typeNames, cwd, language, sizeBudget) {
-    const targetAbs = path.resolve(cwd, targetPath);
-    const config = LANGUAGE_CONFIGS[language];
-    const walkOpts = config
-        ? {
-            extensions: config.extensions,
-            excludedDirs: config.excludedDirs,
-            excludedPatterns: config.excludedPatterns,
-        }
-        : undefined;
-    const allFiles = walkSync(cwd, cwd, 10, 0, walkOpts);
-    const results = [];
-    // Build a single regex that matches any of the type names as whole words
-    const namePattern = new RegExp(`\\b(${typeNames.join('|')})\\b`);
-    for (const relFile of allFiles) {
-        if (results.length >= 5)
-            break;
-        const absFile = path.resolve(cwd, relFile);
-        if (absFile === targetAbs)
-            continue;
-        try {
-            const content = fs.readFileSync(absFile, 'utf8');
-            if (namePattern.test(content)) {
-                const size = Buffer.byteLength(content);
-                if (size > sizeBudget.remaining)
-                    continue;
-                sizeBudget.remaining -= size;
-                results.push({ path: relFile, content });
-            }
-        }
-        catch {
-            // skip unreadable files
-        }
-    }
-    return results;
-}
-/**
- * Read the target file, its imports (children), and files that import it (parents).
- * Also follows imports from componentFiles so their dependencies are included.
- */
-export function readTargetWithContext(targetPath, cwd, componentFiles, language) {
-    const absPath = path.resolve(cwd, targetPath);
-    const content = fs.readFileSync(absPath, 'utf8');
-    const targetFile = {
-        path: targetPath,
-        content,
-    };
-    const targetSize = Buffer.byteLength(content);
-    const sizeBudget = { remaining: MAX_TOTAL_SIZE - targetSize };
-    // For non-JS languages, use type-name-based reverse-dep scanning instead of JS import resolution
-    if (language && language !== 'js') {
-        const typeNames = extractTypeNames(content);
-        const nonJsReferencingFiles = typeNames.length > 0
-            ? findReverseDependenciesByName(targetPath, typeNames, cwd, language, sizeBudget)
-            : [];
-        return {
-            targetFile,
-            importedFiles: [],
-            referencingFiles: nonJsReferencingFiles,
-        };
-    }
-    // Track all paths we've already included to avoid duplicates
-    const seenPaths = new Set([targetPath]);
-    if (componentFiles) {
-        for (const cf of componentFiles) {
-            seenPaths.add(cf.path);
-        }
-    }
-    // Extract imports from target file
-    const importedFiles = extractImports(content, absPath, cwd, seenPaths, sizeBudget, 5);
-    // Also extract imports from component files (e.g. FilesGrid imported by the component)
-    if (componentFiles) {
-        for (const cf of componentFiles) {
-            if (importedFiles.length >= 10)
-                break;
-            const cfAbsPath = path.resolve(cwd, cf.path);
-            const remaining = 10 - importedFiles.length;
-            const cfImports = extractImports(cf.content, cfAbsPath, cwd, seenPaths, sizeBudget, remaining);
-            importedFiles.push(...cfImports);
-        }
-    }
-    // Find reverse dependencies (parents)
-    const referencingFiles = findReverseDependencies(targetPath, cwd, sizeBudget);
-    return { targetFile, importedFiles, referencingFiles };
-}
-// ── Diff preview ─────────────────────────────────────────────────────
-export function generateDiff(originalPath, originalContent, newContent) {
-    return createTwoFilesPatch(originalPath, originalPath, originalContent, newContent, '', '', { context: 3 });
-}
-export function colorDiff(diff) {
-    return diff
-        .split('\n')
-        .map((line) => {
-        if (line.startsWith('+') && !line.startsWith('+++')) {
-            return `\x1b[32m${line}\x1b[0m`; // green
-        }
-        if (line.startsWith('-') && !line.startsWith('---')) {
-            return `\x1b[31m${line}\x1b[0m`; // red
-        }
-        if (line.startsWith('@@')) {
-            return `\x1b[36m${line}\x1b[0m`; // cyan
-        }
-        return line;
-    })
-        .join('\n');
-}
-// ── Gather project files for retheme ─────────────────────────────────
-const RETHEME_MAX_TOTAL_SIZE = 4 * 1024 * 1024; // 4MB
-/**
- * Quick heuristic to check if a file contains visual UI content.
- */
-function hasVisualContent(content, language) {
-    switch (language) {
-        case 'js':
-            return /className[=:]|(?<!\w)<[A-Z]|<div|<span|<section|<main|<header|<footer|<nav|<aside|tailwind|@apply|style[=:{]/i.test(content);
-        case 'swift':
-            return /some\s+View|VStack|HStack|ZStack|List\s*\{|NavigationStack|NavigationView|Form\s*\{|ScrollView|TabView|\.padding|\.font|\.foregroundColor|\.background|GeometryReader|@ViewBuilder/i.test(content);
-        case 'kotlin':
-            return /@Composable|Column\s*\(|Row\s*\(|Box\s*\(|LazyColumn|Scaffold|Modifier\./i.test(content);
-        case 'dart':
-            return /Widget\b|Scaffold|Column\(|Row\(|Container\(|Padding\(|ListView|GridView|AppBar/i.test(content);
-        default:
-            return true;
-    }
-}
-/**
- * Priority score for file ordering: pages/layouts/views first, then components, then other.
- */
-function filePriority(rel) {
-    // JS/TS
-    if (/app\/.*layout\.[jt]sx?$/.test(rel))
-        return 0;
-    if (/app\/.*page\.[jt]sx?$/.test(rel))
-        return 1;
-    if (/pages\/.*\.[jt]sx?$/.test(rel))
-        return 2;
-    if (/App\.[jt]sx?$/.test(rel))
-        return 3;
-    // Swift — main app views and tabs
-    if (/App\/.*Tab\.swift$/.test(rel))
-        return 1;
-    if (/AppView\.swift$/.test(rel))
-        return 0;
-    if (/View\.swift$/.test(rel))
-        return 2;
-    // General
-    if (/component/i.test(rel))
-        return 4;
-    return 5;
-}
-/**
- * Collect all UI source files from the project for retheme.
- * For JS: filters to files containing visual content (JSX/className/Tailwind).
- * Prioritizes pages/layouts first, then components, then other files.
- * Respects a 1MB total size budget.
- */
-export function gatherProjectFiles(cwd, language, framework) {
-    const config = LANGUAGE_CONFIGS[language] ?? LANGUAGE_CONFIGS.js;
-    const walkOpts = {
-        extensions: config.extensions,
-        excludedDirs: config.excludedDirs,
-        excludedPatterns: config.excludedPatterns,
-    };
-    const allRelPaths = walkSync(cwd, cwd, 6, 0, walkOpts);
-    // Sort by priority
-    allRelPaths.sort((a, b) => filePriority(a) - filePriority(b));
-    const files = [];
-    const skippedFiles = [];
-    let totalSize = 0;
-    let truncated = false;
-    for (const rel of allRelPaths) {
-        const absFile = path.resolve(cwd, rel);
-        try {
-            const content = fs.readFileSync(absFile, 'utf8');
-            const size = Buffer.byteLength(content);
-            // Skip non-visual files (hooks, utils, types, manifests, etc.)
-            if (!hasVisualContent(content, language)) {
-                continue;
-            }
-            if (totalSize + size > RETHEME_MAX_TOTAL_SIZE) {
-                truncated = true;
-                skippedFiles.push(rel);
-                continue;
-            }
-            totalSize += size;
-            files.push({ path: rel, content });
-        }
-        catch {
-            // skip unreadable files
-        }
-    }
-    return { files, truncated, skippedFiles };
-}
-// ── Theme file detection ─────────────────────────────────────────────
-const THEME_FILE_CANDIDATES = [
-    'src/app/globals.css',
-    'app/globals.css',
-    'src/index.css',
-    'src/styles/globals.css',
-    'styles/globals.css',
-    'src/global.css',
-    'src/app/global.css',
-    'app/global.css',
-];
-/**
- * Search for a CSS theme file (globals.css, index.css, etc.) in common framework locations.
- * Only applies to JS/TS projects — CSS themes don't apply to Swift/Kotlin/Dart.
- * Returns the first match as a FileContent, or null if none found.
- */
-export function findThemeFile(cwd, language, _framework) {
-    if (language !== 'js')
-        return null;
-    for (const candidate of THEME_FILE_CANDIDATES) {
-        const absPath = path.join(cwd, candidate);
-        if (fs.existsSync(absPath)) {
-            try {
-                const content = fs.readFileSync(absPath, 'utf8');
-                return { path: candidate, content };
-            }
-            catch {
-                // skip unreadable files
-            }
-        }
-    }
-    return null;
-}
-function handleIntegrateApiError(error, label) {
-    if (axios.isAxiosError(error)) {
-        if (error.response?.status === 401) {
-            throw new AuthRequiredError();
-        }
-        if (error.response?.status === 403) {
-            throw new MagicPathError('A Pro subscription is required for AI integration. Visit https://www.magicpath.ai/documentation/help/plans to see the plans available.');
-        }
-        if (error.response?.status === 404) {
-            throw new MagicPathError('Component not found. Please check the component name and try again.');
-        }
-        if (error.code === 'ECONNABORTED') {
-            throw new MagicPathError(`${label} request timed out. Please try again.`);
-        }
-        throw new MagicPathError(`${label} failed: ${error.message}`);
-    }
-    throw new MagicPathError(`${label} failed. Please check your internet connection and try again.`);
-}
-async function pollIntegrateJob(jobId, headers, label, signal) {
-    const pollUrl = makeIntegrateJobUrl(jobId);
-    const pollIntervalMs = 2000;
-    const maxPollMs = 20 * 60 * 1000; // 20 minutes
-    const startTime = Date.now();
-    while (Date.now() - startTime < maxPollMs) {
-        if (signal?.aborted)
-            throw new SkipFileError();
-        await new Promise((resolve, reject) => {
-            const timer = setTimeout(resolve, pollIntervalMs);
-            if (signal) {
-                const onAbort = () => {
-                    clearTimeout(timer);
-                    reject(new SkipFileError());
-                };
-                signal.addEventListener('abort', onAbort, { once: true });
-            }
-        });
-        let jobData;
-        try {
-            const resp = await axios.get(pollUrl, {
-                headers,
-                timeout: 15000,
-            });
-            jobData = resp.data.data;
-        }
-        catch (error) {
-            // Transient network errors during polling — keep trying
-            logger.warn(`Polling error for ${label} job ${jobId}, retrying...`);
-            continue;
-        }
-        switch (jobData.status) {
-            case 'completed':
-                if (!jobData.resultData) {
-                    throw new MagicPathError(`${label} completed but returned no data.`);
-                }
-                return jobData.resultData;
-            case 'failed':
-                throw new MagicPathError(jobData.error
-                    ? `${label} failed: ${jobData.error}`
-                    : `${label} failed. Please try again.`);
-            case 'cancelled':
-                throw new MagicPathError(`${label} was cancelled.`);
-            case 'pending':
-            case 'processing':
-                // Keep polling
-                break;
-        }
-    }
-    throw new MagicPathError(`${label} timed out after 20 minutes. Please try again.`);
-}
-export async function requestIntegration(request, signal) {
-    const url = makeIntegrateUrl();
-    let headers;
-    try {
-        headers = getAuthHeaders();
-    }
-    catch {
-        throw new AuthRequiredError();
-    }
-    let jobId;
-    try {
-        const response = await axios.post(url, request, {
-            headers,
-            timeout: 30000,
-            signal,
-        });
-        jobId = response.data.data.jobId;
-    }
-    catch (error) {
-        if (signal?.aborted)
-            throw new SkipFileError();
-        handleIntegrateApiError(error, 'Integration');
-    }
-    return pollIntegrateJob(jobId, headers, 'Integration', signal);
-}
-export async function requestRetheme(request, signal) {
-    const url = makeIntegrateUrl();
-    let headers;
-    try {
-        headers = getAuthHeaders();
-    }
-    catch {
-        throw new AuthRequiredError();
-    }
-    let jobId;
-    try {
-        const response = await axios.post(url, request, {
-            headers,
-            timeout: 30000,
-            maxBodyLength: 5 * 1024 * 1024,
-            signal,
-        });
-        jobId = response.data.data.jobId;
-    }
-    catch (error) {
-        if (signal?.aborted)
-            throw new SkipFileError();
-        handleIntegrateApiError(error, 'Retheme');
-    }
-    return pollIntegrateJob(jobId, headers, 'Retheme', signal);
-}
-//# sourceMappingURL=integrate.js.map