@haystackeditor/cli 0.18.0 → 0.20.0

package/dist/utils/detect.js

@@ -1,507 +0,0 @@
-/**
- * Project detection utilities
- *
- * Auto-detects framework, package manager, monorepo structure, services,
- * and inter-service dependencies from proxy configurations.
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-/**
- * Detect project configuration
- */
-export async function detectProject(rootDir = process.cwd()) {
-    const result = {
-        packageManager: await detectPackageManager(rootDir),
-        isMonorepo: false,
-    };
-    // Detect monorepo
-    const monorepo = await detectMonorepo(rootDir);
-    if (monorepo) {
-        result.isMonorepo = true;
-        result.monorepoTool = monorepo.tool;
-        result.services = await detectServices(rootDir, monorepo.workspaces);
-        // Detect proxy dependencies and add them to services
-        if (result.services && result.services.length > 0) {
-            result.services = await suggestServiceDependencies(rootDir, result.services);
-        }
-    }
-    // Detect framework
-    result.framework = await detectFramework(rootDir);
-    // Extract custom port from config if framework supports it
-    const customPort = await extractPortFromConfig(rootDir, result.framework);
-    if (customPort) {
-        result.suggestedPort = customPort;
-    }
-    // Set suggestions based on framework (won't override customPort if set)
-    setSuggestions(result);
-    // Detect auth bypass from .env.example
-    result.suggestedAuthBypass = await detectAuthBypass(rootDir);
-    return result;
-}
-/**
- * Detect package manager from lockfiles
- */
-async function detectPackageManager(rootDir) {
-    const checks = [
-        { file: 'pnpm-lock.yaml', manager: 'pnpm' },
-        { file: 'yarn.lock', manager: 'yarn' },
-        { file: 'bun.lockb', manager: 'bun' },
-        { file: 'package-lock.json', manager: 'npm' },
-    ];
-    for (const { file, manager } of checks) {
-        try {
-            await fs.access(path.join(rootDir, file));
-            return manager;
-        }
-        catch {
-            // Not found, continue
-        }
-    }
-    return 'npm'; // Default
-}
-/**
- * Detect monorepo structure
- */
-async function detectMonorepo(rootDir) {
-    // Check pnpm workspaces
-    try {
-        const pnpmWorkspace = await fs.readFile(path.join(rootDir, 'pnpm-workspace.yaml'), 'utf-8');
-        const match = pnpmWorkspace.match(/packages:\s*\n([\s\S]*?)(?:\n\w|$)/);
-        if (match) {
-            const workspaces = match[1]
-                .split('\n')
-                .map((line) => line.trim().replace(/^-\s*['"]?|['"]?$/g, ''))
-                .filter(Boolean);
-            return { tool: 'pnpm-workspaces', workspaces };
-        }
-    }
-    catch {
-        // Not found
-    }
-    // Check package.json workspaces (yarn/npm)
-    try {
-        const pkgJson = JSON.parse(await fs.readFile(path.join(rootDir, 'package.json'), 'utf-8'));
-        if (pkgJson.workspaces) {
-            const workspaces = Array.isArray(pkgJson.workspaces)
-                ? pkgJson.workspaces
-                : pkgJson.workspaces.packages || [];
-            return { tool: 'pnpm-workspaces', workspaces };
-        }
-    }
-    catch {
-        // Not found
-    }
-    // Check for nx.json
-    try {
-        await fs.access(path.join(rootDir, 'nx.json'));
-        return { tool: 'nx', workspaces: ['packages/*', 'apps/*'] };
-    }
-    catch {
-        // Not found
-    }
-    // Check for turbo.json
-    try {
-        await fs.access(path.join(rootDir, 'turbo.json'));
-        return { tool: 'turborepo', workspaces: ['packages/*', 'apps/*'] };
-    }
-    catch {
-        // Not found
-    }
-    // Check for lerna.json
-    try {
-        await fs.access(path.join(rootDir, 'lerna.json'));
-        return { tool: 'lerna', workspaces: ['packages/*'] };
-    }
-    catch {
-        // Not found
-    }
-    return null;
-}
-/**
- * Detect services in a monorepo
- */
-async function detectServices(rootDir, workspacePatterns) {
-    const services = [];
-    const glob = await import('fast-glob');
-    for (const pattern of workspacePatterns) {
-        const matches = await glob.default(pattern, {
-            cwd: rootDir,
-            onlyDirectories: true,
-            ignore: ['node_modules'],
-        });
-        for (const match of matches) {
-            const service = await detectService(rootDir, match);
-            if (service) {
-                services.push(service);
-            }
-        }
-    }
-    // Also check common directories
-    const commonDirs = ['infra', 'services', 'apps', 'packages'];
-    for (const dir of commonDirs) {
-        try {
-            const entries = await fs.readdir(path.join(rootDir, dir), {
-                withFileTypes: true,
-            });
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    const servicePath = path.join(dir, entry.name);
-                    // Skip if already detected
-                    if (services.some((s) => s.root === servicePath))
-                        continue;
-                    const service = await detectService(rootDir, servicePath);
-                    if (service) {
-                        services.push(service);
-                    }
-                }
-            }
-        }
-        catch {
-            // Directory doesn't exist
-        }
-    }
-    return services;
-}
-/**
- * Detect a single service
- */
-async function detectService(rootDir, servicePath) {
-    const fullPath = path.join(rootDir, servicePath);
-    // Check for package.json
-    let pkgJson = null;
-    try {
-        pkgJson = JSON.parse(await fs.readFile(path.join(fullPath, 'package.json'), 'utf-8'));
-    }
-    catch {
-        return null; // No package.json, not a service
-    }
-    const name = pkgJson?.name?.replace(/^@[^/]+\//, '') || path.basename(servicePath);
-    const scripts = pkgJson?.scripts || {};
-    // Detect if it's a Cloudflare Worker
-    const isWorker = await hasFile(fullPath, 'wrangler.toml') ||
-        await hasFile(fullPath, 'wrangler.jsonc') ||
-        await hasFile(fullPath, 'wrangler.json');
-    // Detect framework
-    let framework;
-    let suggestedCommand;
-    let suggestedPort;
-    if (isWorker) {
-        framework = 'cloudflare-worker';
-        suggestedCommand = 'pnpm wrangler dev --local';
-        suggestedPort = 8787;
-    }
-    else if (await hasFile(fullPath, 'vite.config.ts') || await hasFile(fullPath, 'vite.config.js')) {
-        framework = 'vite';
-        suggestedCommand = 'pnpm dev';
-        // Try to extract custom port from vite config, fallback to default
-        suggestedPort = await extractPortFromConfig(fullPath, 'vite') ?? 5173;
-    }
-    else if (await hasFile(fullPath, 'next.config.js') || await hasFile(fullPath, 'next.config.ts')) {
-        framework = 'nextjs';
-        suggestedCommand = 'pnpm dev';
-        // Try to extract custom port from next config, fallback to default
-        suggestedPort = await extractPortFromConfig(fullPath, 'nextjs') ?? 3000;
-    }
-    else if (scripts.dev) {
-        suggestedCommand = 'pnpm dev';
-        suggestedPort = 3000;
-    }
-    else if (scripts.start) {
-        suggestedCommand = 'pnpm start';
-    }
-    // Determine if it's a batch job or server
-    const type = name.includes('analysis') || name.includes('batch') || name.includes('job')
-        ? 'batch'
-        : 'server';
-    return {
-        name,
-        root: servicePath,
-        type,
-        framework,
-        suggestedCommand,
-        suggestedPort: type === 'server' ? suggestedPort : undefined,
-    };
-}
-/**
- * Detect framework from config files
- */
-async function detectFramework(rootDir) {
-    const checks = [
-        { files: ['vite.config.ts', 'vite.config.js'], framework: 'vite' },
-        { files: ['next.config.js', 'next.config.ts', 'next.config.mjs'], framework: 'nextjs' },
-        { files: ['remix.config.js', 'remix.config.ts'], framework: 'remix' },
-        { files: ['nuxt.config.ts', 'nuxt.config.js'], framework: 'nuxt' },
-        { files: ['svelte.config.js', 'svelte.config.ts'], framework: 'sveltekit' },
-        { files: ['astro.config.mjs', 'astro.config.ts'], framework: 'astro' },
-        { files: ['wrangler.toml', 'wrangler.jsonc'], framework: 'cloudflare-worker' },
-    ];
-    for (const { files, framework } of checks) {
-        for (const file of files) {
-            if (await hasFile(rootDir, file)) {
-                return framework;
-            }
-        }
-    }
-    // Check for CRA
-    try {
-        const pkgJson = JSON.parse(await fs.readFile(path.join(rootDir, 'package.json'), 'utf-8'));
-        if (pkgJson.dependencies?.['react-scripts']) {
-            return 'cra';
-        }
-    }
-    catch {
-        // Not found
-    }
-    return undefined;
-}
-/**
- * Detect auth bypass env var from .env.example
- */
-async function detectAuthBypass(rootDir) {
-    const envFiles = ['.env.example', '.env.local.example', '.env.development'];
-    for (const file of envFiles) {
-        try {
-            const content = await fs.readFile(path.join(rootDir, file), 'utf-8');
-            // Common patterns
-            const patterns = [
-                /^(SKIP_AUTH)=/m,
-                /^(BYPASS_AUTH)=/m,
-                /^(AUTH_DISABLED)=/m,
-                /^(MOCK_AUTH)=/m,
-                /^(NEXT_PUBLIC_MOCK_AUTH)=/m,
-                /^(VITE_MOCK_AUTH)=/m,
-                /^(VITE_SKIP_AUTH)=/m,
-            ];
-            for (const pattern of patterns) {
-                const match = content.match(pattern);
-                if (match) {
-                    return `${match[1]}=true`;
-                }
-            }
-        }
-        catch {
-            // File not found
-        }
-    }
-    // No evidence of an auth-bypass variable — suggest nothing rather than
-    // fabricating a SKIP_AUTH the app doesn't read.
-    return undefined;
-}
-/**
- * Set suggestions based on detected framework
- * Note: This is sync, so custom port extraction happens in detectProject
- */
-function setSuggestions(result) {
-    const frameworkDefaults = {
-        vite: { command: 'pnpm dev', port: 5173, ready: 'Local:' },
-        nextjs: { command: 'pnpm dev', port: 3000, ready: 'Ready' },
-        remix: { command: 'pnpm dev', port: 3000, ready: 'started' },
-        nuxt: { command: 'pnpm dev', port: 3000, ready: 'Local:' },
-        sveltekit: { command: 'pnpm dev', port: 5173, ready: 'Local:' },
-        astro: { command: 'pnpm dev', port: 4321, ready: 'Local:' },
-        cra: { command: 'pnpm start', port: 3000, ready: 'Compiled' },
-        'cloudflare-worker': { command: 'pnpm wrangler dev', port: 8787, ready: 'Ready' },
-    };
-    const defaults = result.framework ? frameworkDefaults[result.framework] : null;
-    result.suggestedDevCommand = defaults?.command || `${result.packageManager} dev`;
-    // suggestedPort may already be set from custom config extraction
-    result.suggestedPort = result.suggestedPort || defaults?.port || 3000;
-    result.suggestedReadyPattern = defaults?.ready || 'ready|started|listening|Local:';
-}
-/**
- * Check if a file exists
- */
-async function hasFile(dir, file) {
-    try {
-        await fs.access(path.join(dir, file));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Extract custom port from framework config files
- *
- * Parses vite.config.ts, next.config.js, etc. to find custom port settings
- * Returns undefined if no custom port is configured (use framework default)
- */
-async function extractPortFromConfig(rootDir, framework) {
-    if (!framework)
-        return undefined;
-    // Config files to check based on framework
-    const configFiles = {
-        vite: ['vite.config.ts', 'vite.config.js', 'vite.config.mjs'],
-        nextjs: ['next.config.js', 'next.config.ts', 'next.config.mjs'],
-        nuxt: ['nuxt.config.ts', 'nuxt.config.js'],
-        sveltekit: ['svelte.config.js', 'svelte.config.ts'],
-        astro: ['astro.config.mjs', 'astro.config.ts'],
-    };
-    const files = configFiles[framework];
-    if (!files)
-        return undefined;
-    let configContent = null;
-    for (const file of files) {
-        try {
-            configContent = await fs.readFile(path.join(rootDir, file), 'utf-8');
-            break;
-        }
-        catch {
-            // File not found, try next
-        }
-    }
-    if (!configContent)
-        return undefined;
-    // Patterns to match port configuration
-    // Vite: server: { port: 3000 } or server.port = 3000
-    // Next: env: { PORT: 3000 } or experimental.serverPort
-    const patterns = [
-        /server\s*:\s*\{[^}]*port\s*:\s*(\d+)/s, // server: { port: 3000 }
-        /server\s*\.\s*port\s*[=:]\s*(\d+)/, // server.port = 3000
-        /port\s*:\s*(\d+)/, // port: 3000 (generic)
-        /PORT\s*[=:]\s*['"]?(\d+)['"]?/, // PORT = 3000
-    ];
-    for (const pattern of patterns) {
-        const match = configContent.match(pattern);
-        if (match) {
-            const port = parseInt(match[1], 10);
-            if (port > 0 && port < 65536) {
-                return port;
-            }
-        }
-    }
-    return undefined;
-}
-/**
- * Detect proxy dependencies from vite.config.ts/js
- *
- * Parses the vite config file to find proxy targets that point to localhost,
- * which indicate dependencies on other local services.
- *
- * @example
- * // vite.config.ts with proxy
- * server: {
- *   proxy: {
- *     '/api/review-chat': {
- *       target: 'http://localhost:8787',
- *     }
- *   }
- * }
- * // Returns: [{ path: '/api/review-chat', port: 8787, host: 'localhost' }]
- */
-export async function detectProxyDependencies(rootDir) {
-    const dependencies = [];
-    // Try vite.config.ts, then vite.config.js
-    const configFiles = ['vite.config.ts', 'vite.config.js', 'vite.config.mjs'];
-    let configContent = null;
-    for (const file of configFiles) {
-        try {
-            configContent = await fs.readFile(path.join(rootDir, file), 'utf-8');
-            break;
-        }
-        catch {
-            // File not found, try next
-        }
-    }
-    if (!configContent) {
-        return dependencies;
-    }
-    // Parse proxy configurations using regex
-    // Matches patterns like:
-    //   '/api/path': { target: 'http://localhost:8787' }
-    //   '/api/path': 'http://localhost:8787'
-    //   proxy: { '/api/path': { target: 'http://localhost:8787' } }
-    // Pattern for object-style proxy: '/path': { target: 'http://localhost:PORT' }
-    const objectProxyRegex = /['"]([^'"]+)['"]\s*:\s*\{[^}]*target\s*:\s*['"]https?:\/\/(localhost|127\.0\.0\.1):(\d+)['"]/g;
-    let match;
-    while ((match = objectProxyRegex.exec(configContent)) !== null) {
-        dependencies.push({
-            path: match[1],
-            host: match[2],
-            port: parseInt(match[3], 10),
-        });
-    }
-    // Pattern for string-style proxy: '/path': 'http://localhost:PORT'
-    const stringProxyRegex = /['"]([^'"]+)['"]\s*:\s*['"]https?:\/\/(localhost|127\.0\.0\.1):(\d+)['"]/g;
-    let stringMatch;
-    while ((stringMatch = stringProxyRegex.exec(configContent)) !== null) {
-        // Avoid duplicates from object pattern
-        const exists = dependencies.some(d => d.path === stringMatch[1] && d.port === parseInt(stringMatch[3], 10));
-        if (!exists) {
-            dependencies.push({
-                path: stringMatch[1],
-                host: stringMatch[2],
-                port: parseInt(stringMatch[3], 10),
-            });
-        }
-    }
-    return dependencies;
-}
-/**
- * Match proxy dependencies to detected services
- *
- * Given a list of proxy targets (ports) and detected services,
- * determines which services are dependencies based on port matching.
- */
-export function matchProxyToServices(proxyDeps, services) {
-    // Create a port → service name mapping
-    const portToService = new Map();
-    for (const service of services) {
-        if (service.suggestedPort) {
-            portToService.set(service.suggestedPort, service.name);
-        }
-    }
-    // For each service that has proxy deps pointing to another service's port,
-    // record the dependency
-    const serviceDeps = new Map();
-    for (const dep of proxyDeps) {
-        const matchedService = portToService.get(dep.port);
-        if (matchedService) {
-            dep.matchedService = matchedService;
-        }
-    }
-    return serviceDeps;
-}
-/**
- * Suggest depends_on for services based on proxy configuration
- *
- * For the main service (usually frontend), detect if it proxies to other local services
- * and suggest those as dependencies.
- */
-export async function suggestServiceDependencies(rootDir, services) {
-    // Detect proxy dependencies from vite config
-    const proxyDeps = await detectProxyDependencies(rootDir);
-    if (proxyDeps.length === 0) {
-        return services;
-    }
-    // Create port → service mapping
-    const portToService = new Map();
-    for (const service of services) {
-        if (service.suggestedPort) {
-            portToService.set(service.suggestedPort, service.name);
-        }
-    }
-    // Match proxy ports to services
-    const dependsOn = [];
-    for (const dep of proxyDeps) {
-        const serviceName = portToService.get(dep.port);
-        if (serviceName) {
-            dep.matchedService = serviceName;
-            if (!dependsOn.includes(serviceName)) {
-                dependsOn.push(serviceName);
-            }
-        }
-    }
-    // Update the main frontend service with depends_on
-    // The main service is typically the one at root with port 3000/5173
-    return services.map(service => {
-        // If this service is at root and has detected proxy dependencies
-        if ((service.root === '.' || service.root === './') && dependsOn.length > 0) {
-            return {
-                ...service,
-                suggestedDependsOn: dependsOn,
-            };
-        }
-        return service;
-    });
-}