magicpath-ai 1.2.0 → 1.3.0-beta.1

package/dist/util/integrate.js

@@ -0,0 +1,660 @@
+import fs from 'fs-extra';
+import path from 'path';
+import axios from 'axios';
+import { createTwoFilesPatch } from 'diff';
+import { makeIntegrateUrl } from './api.js';
+import { getAuthHeaders } from './auth.js';
+import { MagicPathError } from './error.js';
+import { AuthRequiredError } from './authError.js';
+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 = 1024 * 1024; // 1MB
+/**
+ * Quick heuristic to check if a file contains visual UI content.
+ */
+function hasVisualContent(content, language) {
+    switch (language) {
+        case 'js':
+            return /className[=:]|<[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 };
+}
+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.`);
+}
+export async function requestIntegration(request) {
+    const url = makeIntegrateUrl();
+    let headers;
+    try {
+        headers = getAuthHeaders();
+    }
+    catch {
+        throw new AuthRequiredError();
+    }
+    try {
+        const response = await axios.post(url, request, {
+            headers,
+            timeout: 240000,
+        });
+        return response.data.data;
+    }
+    catch (error) {
+        handleIntegrateApiError(error, 'Integration');
+    }
+}
+export async function requestRetheme(request) {
+    const url = makeIntegrateUrl();
+    let headers;
+    try {
+        headers = getAuthHeaders();
+    }
+    catch {
+        throw new AuthRequiredError();
+    }
+    try {
+        const response = await axios.post(url, request, {
+            headers,
+            timeout: 240000,
+            maxBodyLength: 5 * 1024 * 1024,
+        });
+        return response.data.data;
+    }
+    catch (error) {
+        handleIntegrateApiError(error, 'Retheme');
+    }
+}
+//# sourceMappingURL=integrate.js.map