@haystackeditor/cli 0.8.1 → 0.9.0

package/dist/tools/detect.js

@@ -0,0 +1,853 @@
+import { existsSync, readFileSync, statSync } from 'fs';
+import { join } from 'path';
+import { globSync } from 'glob';
+const FRAMEWORK_PATTERNS = [
+    // Vite
+    {
+        files: ['vite.config.ts', 'vite.config.js', 'vite.config.mjs'],
+        framework: {
+            name: 'vite',
+            devCommand: 'pnpm dev',
+            port: 5173,
+            readyPattern: 'Local:',
+        },
+    },
+    // Next.js
+    {
+        files: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
+        framework: {
+            name: 'nextjs',
+            devCommand: 'pnpm dev',
+            port: 3000,
+            readyPattern: 'Ready in',
+        },
+    },
+    // Remix
+    {
+        files: ['remix.config.js', 'remix.config.ts'],
+        framework: {
+            name: 'remix',
+            devCommand: 'pnpm dev',
+            port: 3000,
+            readyPattern: 'started',
+        },
+    },
+    // Nuxt
+    {
+        files: ['nuxt.config.ts', 'nuxt.config.js'],
+        framework: {
+            name: 'nuxt',
+            devCommand: 'pnpm dev',
+            port: 3000,
+            readyPattern: 'Listening',
+        },
+    },
+    // SvelteKit
+    {
+        files: ['svelte.config.js', 'svelte.config.ts'],
+        framework: {
+            name: 'sveltekit',
+            devCommand: 'pnpm dev',
+            port: 5173,
+            readyPattern: 'Local:',
+        },
+    },
+    // Astro
+    {
+        files: ['astro.config.mjs', 'astro.config.ts'],
+        framework: {
+            name: 'astro',
+            devCommand: 'pnpm dev',
+            port: 4321,
+            readyPattern: 'Local',
+        },
+    },
+    // Create React App
+    {
+        files: ['react-scripts'], // Check in package.json dependencies
+        framework: {
+            name: 'create-react-app',
+            devCommand: 'npm start',
+            port: 3000,
+            readyPattern: 'Compiled',
+        },
+    },
+    // Cloudflare Workers (Wrangler)
+    {
+        files: ['wrangler.toml', 'wrangler.json'],
+        framework: {
+            name: 'cloudflare-worker',
+            devCommand: 'pnpm wrangler dev --local',
+            port: 8787,
+            readyPattern: 'Ready on',
+        },
+    },
+    // Express/Node.js (generic)
+    {
+        files: ['server.js', 'server.ts', 'app.js', 'app.ts'],
+        framework: {
+            name: 'node-server',
+            devCommand: 'pnpm dev',
+            port: 3000,
+            readyPattern: 'listening',
+        },
+    },
+];
+const MONOREPO_INDICATORS = [
+    'pnpm-workspace.yaml',
+    'lerna.json',
+    'nx.json',
+    'turbo.json',
+    'rush.json',
+];
+const PACKAGE_MANAGER_LOCKFILES = {
+    'pnpm-lock.yaml': 'pnpm',
+    'yarn.lock': 'yarn',
+    'package-lock.json': 'npm',
+    'bun.lockb': 'bun',
+};
+/**
+ * Detect the package manager from lockfiles
+ */
+function detectPackageManager(rootDir) {
+    for (const [lockfile, manager] of Object.entries(PACKAGE_MANAGER_LOCKFILES)) {
+        if (existsSync(join(rootDir, lockfile))) {
+            return manager;
+        }
+    }
+    return 'npm';
+}
+/**
+ * Check if a file exists in a directory
+ */
+function hasFile(dir, filename) {
+    return existsSync(join(dir, filename));
+}
+/**
+ * Detect framework from files in a directory
+ */
+function detectFramework(dir) {
+    for (const pattern of FRAMEWORK_PATTERNS) {
+        for (const file of pattern.files) {
+            if (hasFile(dir, file)) {
+                return {
+                    ...pattern.framework,
+                    configFile: file,
+                };
+            }
+        }
+    }
+    // Check package.json for react-scripts (CRA)
+    const pkgPath = join(dir, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            if (pkg.dependencies?.['react-scripts'] || pkg.devDependencies?.['react-scripts']) {
+                return {
+                    name: 'create-react-app',
+                    devCommand: 'npm start',
+                    port: 3000,
+                    readyPattern: 'Compiled',
+                    configFile: 'package.json',
+                };
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    return null;
+}
+/**
+ * Detect if project is a monorepo
+ */
+function detectMonorepo(rootDir) {
+    return MONOREPO_INDICATORS.some((file) => hasFile(rootDir, file));
+}
+/**
+ * Find workspace packages in a pnpm monorepo
+ */
+function findPnpmWorkspaces(rootDir) {
+    const workspaceFile = join(rootDir, 'pnpm-workspace.yaml');
+    if (!existsSync(workspaceFile))
+        return [];
+    try {
+        const content = readFileSync(workspaceFile, 'utf-8');
+        const lines = content.split('\n');
+        const packages = [];
+        let inPackages = false;
+        for (const line of lines) {
+            // Check for packages: section start
+            if (line.match(/^packages:/)) {
+                inPackages = true;
+                continue;
+            }
+            // New section starts (non-indented, non-comment line)
+            if (inPackages && line.match(/^[a-z]/)) {
+                break;
+            }
+            // Parse package entries (handles comments between entries)
+            if (inPackages) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith('-') && !trimmed.startsWith('#')) {
+                    // Extract package path, removing quotes and inline comments
+                    const pkg = trimmed
+                        .replace(/^-\s*['"]?/, '')
+                        .replace(/['"]?\s*$/, '')
+                        .replace(/#.*/, '')
+                        .trim();
+                    if (pkg)
+                        packages.push(pkg);
+                }
+            }
+        }
+        return packages;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Expand glob patterns to actual directories
+ */
+function expandWorkspaceGlobs(rootDir, patterns) {
+    const dirs = [];
+    for (const pattern of patterns) {
+        // Remove trailing /* or /**
+        const cleanPattern = pattern.replace(/\/\*+$/, '');
+        try {
+            // Use glob to find matches
+            const matches = globSync(cleanPattern, { cwd: rootDir });
+            // Filter to only directories
+            for (const match of matches) {
+                const fullPath = join(rootDir, match);
+                try {
+                    if (statSync(fullPath).isDirectory()) {
+                        dirs.push(match);
+                    }
+                }
+                catch {
+                    // Skip if stat fails
+                }
+            }
+        }
+        catch {
+            // If glob fails, try as literal path
+            if (existsSync(join(rootDir, cleanPattern))) {
+                dirs.push(cleanPattern);
+            }
+        }
+    }
+    return [...new Set(dirs)];
+}
+/**
+ * Detect services in a monorepo
+ */
+function detectServices(rootDir) {
+    const services = [];
+    // Find workspace packages
+    const workspacePatterns = findPnpmWorkspaces(rootDir);
+    const packageDirs = expandWorkspaceGlobs(rootDir, workspacePatterns);
+    // Also check common directories
+    const commonDirs = [
+        'packages',
+        'apps',
+        'services',
+        'infra',
+        'workers',
+        'functions',
+        'api',
+        'web',
+        'frontend',
+        'backend',
+    ];
+    for (const dir of commonDirs) {
+        if (existsSync(join(rootDir, dir)) && !packageDirs.includes(dir)) {
+            packageDirs.push(dir);
+        }
+    }
+    // Detect framework in each directory
+    for (const dir of packageDirs) {
+        const fullPath = join(rootDir, dir);
+        if (!existsSync(fullPath))
+            continue;
+        // Check if this directory has its own package.json (is a package)
+        if (!hasFile(fullPath, 'package.json'))
+            continue;
+        const framework = detectFramework(fullPath);
+        const name = dir.split('/').pop() || dir;
+        services.push({
+            name,
+            root: dir,
+            type: framework?.name === 'cloudflare-worker' ? 'server' : 'server',
+            framework: framework || undefined,
+        });
+    }
+    // Also check the root directory
+    const rootFramework = detectFramework(rootDir);
+    if (rootFramework) {
+        services.unshift({
+            name: 'frontend',
+            root: './',
+            type: 'server',
+            framework: rootFramework,
+        });
+    }
+    return services;
+}
+/**
+ * Get project name from package.json
+ */
+function getProjectName(rootDir) {
+    const pkgPath = join(rootDir, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            return pkg.name || 'my-app';
+        }
+        catch {
+            // Ignore
+        }
+    }
+    return 'my-app';
+}
+/**
+ * Detect common auth bypass patterns
+ */
+function detectAuthBypass(rootDir) {
+    // Check for common env var patterns in code
+    const envFiles = ['.env.example', '.env.sample', '.env.template'];
+    for (const envFile of envFiles) {
+        const path = join(rootDir, envFile);
+        if (existsSync(path)) {
+            try {
+                const content = readFileSync(path, 'utf-8');
+                // Look for auth-related env vars
+                const authPatterns = [
+                    /^(SKIP_AUTH|BYPASS_AUTH|DISABLE_AUTH|VITE_SKIP_AUTH|NEXT_PUBLIC_SKIP_AUTH)=/m,
+                    /^(AUTH_DISABLED|NO_AUTH|DEV_AUTH)=/m,
+                ];
+                for (const pattern of authPatterns) {
+                    const match = content.match(pattern);
+                    if (match) {
+                        return `${match[1]}=true`;
+                    }
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract localhost URLs and ports from a string.
+ * Handles patterns like: http://localhost:8787, localhost:3001, 127.0.0.1:8080
+ */
+function extractLocalhostTargets(content, pathPattern) {
+    const targets = [];
+    const urlRegex = /(?:https?:\/\/)?(?:localhost|127\.0\.0\.1):(\d+)/g;
+    let match;
+    while ((match = urlRegex.exec(content)) !== null) {
+        const port = parseInt(match[1], 10);
+        const target = match[0].startsWith('http') ? match[0] : `http://${match[0]}`;
+        // Avoid duplicates
+        if (!targets.some((t) => t.port === port)) {
+            targets.push({
+                path: pathPattern || '/api',
+                target,
+                port,
+            });
+        }
+    }
+    return targets;
+}
+/**
+ * Detect proxy targets from various config files.
+ * Supports: Vite, Next.js, Create React App, Vercel, Webpack
+ * This helps identify backend services the frontend depends on.
+ */
+function detectProxyTargets(dir) {
+    const targets = [];
+    const seenPorts = new Set();
+    const addTarget = (target) => {
+        if (!seenPorts.has(target.port)) {
+            seenPorts.add(target.port);
+            targets.push(target);
+        }
+    };
+    // 1. Vite - vite.config.ts/js with server.proxy
+    const viteConfigs = ['vite.config.ts', 'vite.config.js', 'vite.config.mjs'];
+    for (const configFile of viteConfigs) {
+        const configPath = join(dir, configFile);
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, 'utf-8');
+                // Look for proxy patterns like: '/api': { target: 'http://localhost:8787' }
+                const proxyMatches = content.matchAll(/['"]([^'"]+)['"]\s*:\s*(?:\{[^}]*target\s*:\s*['"]([^'"]+)['"]|['"]([^'"]+)['"])/g);
+                for (const match of proxyMatches) {
+                    const path = match[1];
+                    const target = match[2] || match[3];
+                    if (target && (target.includes('localhost') || target.includes('127.0.0.1'))) {
+                        const portMatch = target.match(/:(\d+)/);
+                        if (portMatch) {
+                            addTarget({
+                                path,
+                                target,
+                                port: parseInt(portMatch[1], 10),
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    // 2. Next.js - next.config.js/mjs/ts with rewrites()
+    const nextConfigs = ['next.config.js', 'next.config.mjs', 'next.config.ts'];
+    for (const configFile of nextConfigs) {
+        const configPath = join(dir, configFile);
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, 'utf-8');
+                // Look for rewrite patterns: { source: '/api/:path*', destination: 'http://localhost:3001/:path*' }
+                const rewriteMatches = content.matchAll(/destination\s*:\s*['"`]([^'"`]+)['"`]/g);
+                for (const match of rewriteMatches) {
+                    const destination = match[1];
+                    if (destination.includes('localhost') || destination.includes('127.0.0.1')) {
+                        const portMatch = destination.match(/:(\d+)/);
+                        if (portMatch) {
+                            // Try to find the associated source
+                            const sourceMatch = content.match(new RegExp(`source\\s*:\\s*['"\`]([^'"\`]+)['"\`][^}]*destination\\s*:\\s*['"\`]${destination.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+                            addTarget({
+                                path: sourceMatch?.[1] || '/api',
+                                target: destination.replace(/\/:[^/]+\*?/g, ''), // Remove path params
+                                port: parseInt(portMatch[1], 10),
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    // 3. Create React App - package.json with "proxy" field
+    const pkgPath = join(dir, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            if (typeof pkg.proxy === 'string') {
+                const portMatch = pkg.proxy.match(/:(\d+)/);
+                if (portMatch) {
+                    addTarget({
+                        path: '/api',
+                        target: pkg.proxy,
+                        port: parseInt(portMatch[1], 10),
+                    });
+                }
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // 4. Create React App - setupProxy.js (http-proxy-middleware)
+    const setupProxyPath = join(dir, 'src', 'setupProxy.js');
+    if (existsSync(setupProxyPath)) {
+        try {
+            const content = readFileSync(setupProxyPath, 'utf-8');
+            // Look for: createProxyMiddleware('/api', { target: 'http://localhost:3001' })
+            const proxyMatches = content.matchAll(/createProxyMiddleware\s*\(\s*['"]([^'"]+)['"]\s*,\s*\{[^}]*target\s*:\s*['"]([^'"]+)['"]/g);
+            for (const match of proxyMatches) {
+                const path = match[1];
+                const target = match[2];
+                const portMatch = target.match(/:(\d+)/);
+                if (portMatch) {
+                    addTarget({
+                        path,
+                        target,
+                        port: parseInt(portMatch[1], 10),
+                    });
+                }
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // 5. Vercel - vercel.json with rewrites
+    const vercelPath = join(dir, 'vercel.json');
+    if (existsSync(vercelPath)) {
+        try {
+            const vercelConfig = JSON.parse(readFileSync(vercelPath, 'utf-8'));
+            if (Array.isArray(vercelConfig.rewrites)) {
+                for (const rewrite of vercelConfig.rewrites) {
+                    if (rewrite.destination && (rewrite.destination.includes('localhost') || rewrite.destination.includes('127.0.0.1'))) {
+                        const portMatch = rewrite.destination.match(/:(\d+)/);
+                        if (portMatch) {
+                            addTarget({
+                                path: rewrite.source || '/api',
+                                target: rewrite.destination,
+                                port: parseInt(portMatch[1], 10),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // 6. Webpack - webpack.config.js with devServer.proxy
+    const webpackConfigs = ['webpack.config.js', 'webpack.config.ts'];
+    for (const configFile of webpackConfigs) {
+        const configPath = join(dir, configFile);
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, 'utf-8');
+                // Look for devServer.proxy patterns
+                const proxyMatches = content.matchAll(/['"]([^'"]+)['"]\s*:\s*(?:\{[^}]*target\s*:\s*['"]([^'"]+)['"]|['"]([^'"]+)['"])/g);
+                for (const match of proxyMatches) {
+                    const path = match[1];
+                    const target = match[2] || match[3];
+                    if (target && (target.includes('localhost') || target.includes('127.0.0.1'))) {
+                        const portMatch = target.match(/:(\d+)/);
+                        if (portMatch) {
+                            addTarget({
+                                path,
+                                target,
+                                port: parseInt(portMatch[1], 10),
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    // 7. Vue CLI - vue.config.js with devServer.proxy (same pattern as webpack)
+    const vueConfigPath = join(dir, 'vue.config.js');
+    if (existsSync(vueConfigPath)) {
+        try {
+            const content = readFileSync(vueConfigPath, 'utf-8');
+            const proxyMatches = content.matchAll(/['"]([^'"]+)['"]\s*:\s*(?:\{[^}]*target\s*:\s*['"]([^'"]+)['"]|['"]([^'"]+)['"])/g);
+            for (const match of proxyMatches) {
+                const path = match[1];
+                const target = match[2] || match[3];
+                if (target && (target.includes('localhost') || target.includes('127.0.0.1'))) {
+                    const portMatch = target.match(/:(\d+)/);
+                    if (portMatch) {
+                        addTarget({
+                            path,
+                            target,
+                            port: parseInt(portMatch[1], 10),
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // 8. Angular - proxy.conf.json or proxy.conf.js
+    const angularProxyConfigs = ['proxy.conf.json', 'proxy.conf.js'];
+    for (const configFile of angularProxyConfigs) {
+        const configPath = join(dir, configFile);
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, 'utf-8');
+                if (configFile.endsWith('.json')) {
+                    // JSON format: { "/api": { "target": "http://localhost:3000" } }
+                    const config = JSON.parse(content);
+                    for (const [path, settings] of Object.entries(config)) {
+                        const target = settings?.target;
+                        if (target && (target.includes('localhost') || target.includes('127.0.0.1'))) {
+                            const portMatch = target.match(/:(\d+)/);
+                            if (portMatch) {
+                                addTarget({
+                                    path,
+                                    target,
+                                    port: parseInt(portMatch[1], 10),
+                                });
+                            }
+                        }
+                    }
+                }
+                else {
+                    // JS format - use regex
+                    const proxyMatches = content.matchAll(/['"]([^'"]+)['"]\s*:\s*\{[^}]*target\s*:\s*['"]([^'"]+)['"]/g);
+                    for (const match of proxyMatches) {
+                        const path = match[1];
+                        const target = match[2];
+                        if (target && (target.includes('localhost') || target.includes('127.0.0.1'))) {
+                            const portMatch = target.match(/:(\d+)/);
+                            if (portMatch) {
+                                addTarget({
+                                    path,
+                                    target,
+                                    port: parseInt(portMatch[1], 10),
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    // 9. Nuxt.js - nuxt.config.ts/js with routeRules or proxy
+    const nuxtConfigs = ['nuxt.config.ts', 'nuxt.config.js'];
+    for (const configFile of nuxtConfigs) {
+        const configPath = join(dir, configFile);
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, 'utf-8');
+                // Look for proxy or routeRules with proxy settings
+                const proxyMatches = content.matchAll(/(?:proxy|target)\s*:\s*['"]([^'"]+)['"]/g);
+                for (const match of proxyMatches) {
+                    const target = match[1];
+                    if (target && (target.includes('localhost') || target.includes('127.0.0.1'))) {
+                        const portMatch = target.match(/:(\d+)/);
+                        if (portMatch) {
+                            addTarget({
+                                path: '/api',
+                                target,
+                                port: parseInt(portMatch[1], 10),
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    // 10. Gatsby - gatsby-config.js with proxy
+    const gatsbyConfigPath = join(dir, 'gatsby-config.js');
+    if (existsSync(gatsbyConfigPath)) {
+        try {
+            const content = readFileSync(gatsbyConfigPath, 'utf-8');
+            // Look for developMiddleware proxy patterns
+            const proxyMatches = content.matchAll(/proxy\s*:\s*\{[^}]*url\s*:\s*['"]([^'"]+)['"]/g);
+            for (const match of proxyMatches) {
+                const target = match[1];
+                if (target && (target.includes('localhost') || target.includes('127.0.0.1'))) {
+                    const portMatch = target.match(/:(\d+)/);
+                    if (portMatch) {
+                        addTarget({
+                            path: '/api',
+                            target,
+                            port: parseInt(portMatch[1], 10),
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // 11. Parcel - .proxyrc or .proxyrc.json
+    const parcelProxyConfigs = ['.proxyrc', '.proxyrc.json'];
+    for (const configFile of parcelProxyConfigs) {
+        const configPath = join(dir, configFile);
+        if (existsSync(configPath)) {
+            try {
+                const content = readFileSync(configPath, 'utf-8');
+                const config = JSON.parse(content);
+                // Parcel format: { "/api": { "target": "http://localhost:3000" } }
+                for (const [path, settings] of Object.entries(config)) {
+                    const target = settings?.target;
+                    if (target && (target.includes('localhost') || target.includes('127.0.0.1'))) {
+                        const portMatch = target.match(/:(\d+)/);
+                        if (portMatch) {
+                            addTarget({
+                                path,
+                                target,
+                                port: parseInt(portMatch[1], 10),
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    // 12. Netlify - netlify.toml with redirects
+    const netlifyConfigPath = join(dir, 'netlify.toml');
+    if (existsSync(netlifyConfigPath)) {
+        try {
+            const content = readFileSync(netlifyConfigPath, 'utf-8');
+            // Look for redirect rules with localhost: [[redirects]] from = "/api/*" to = "http://localhost:3000/:splat"
+            const redirectMatches = content.matchAll(/\[\[redirects\]\][^[]*from\s*=\s*["']([^"']+)["'][^[]*to\s*=\s*["']([^"']+)["']/gs);
+            for (const match of redirectMatches) {
+                const path = match[1];
+                const target = match[2];
+                if (target && (target.includes('localhost') || target.includes('127.0.0.1'))) {
+                    const portMatch = target.match(/:(\d+)/);
+                    if (portMatch) {
+                        addTarget({
+                            path,
+                            target,
+                            port: parseInt(portMatch[1], 10),
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // 13. Remix - remix.config.js doesn't have proxy, but check for serverBuildTarget
+    // Remix uses loaders, so no proxy detection needed
+    // 14. Esbuild/custom - check for common proxy middleware in server files
+    const serverFiles = ['server.js', 'server.ts', 'dev-server.js', 'dev-server.ts'];
+    for (const serverFile of serverFiles) {
+        const serverPath = join(dir, serverFile);
+        if (existsSync(serverPath)) {
+            try {
+                const content = readFileSync(serverPath, 'utf-8');
+                // Look for http-proxy-middleware or manual proxy setups
+                const proxyMatches = content.matchAll(/(?:createProxyMiddleware|proxy)\s*\(\s*['"]([^'"]+)['"]\s*,\s*\{[^}]*target\s*:\s*['"]([^'"]+)['"]/g);
+                for (const match of proxyMatches) {
+                    const path = match[1];
+                    const target = match[2];
+                    if (target && (target.includes('localhost') || target.includes('127.0.0.1'))) {
+                        const portMatch = target.match(/:(\d+)/);
+                        if (portMatch) {
+                            addTarget({
+                                path,
+                                target,
+                                port: parseInt(portMatch[1], 10),
+                            });
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+    }
+    return targets;
+}
+/**
+ * Match proxy targets to detected services by port.
+ * Returns service names that match the proxy targets.
+ */
+function matchProxyToServices(proxyTargets, services) {
+    const dependsOn = [];
+    for (const proxy of proxyTargets) {
+        // Find a service running on this port
+        const matchingService = services.find((s) => s.framework?.port === proxy.port);
+        if (matchingService && !dependsOn.includes(matchingService.name)) {
+            dependsOn.push(matchingService.name);
+        }
+    }
+    return dependsOn;
+}
+/**
+ * Main detection function - analyzes a project directory
+ */
+export function detectProject(rootDir = process.cwd()) {
+    const isMonorepo = detectMonorepo(rootDir);
+    const packageManager = detectPackageManager(rootDir);
+    const projectName = getProjectName(rootDir);
+    let frameworks = [];
+    let services = [];
+    let proxyTargets = [];
+    if (isMonorepo) {
+        services = detectServices(rootDir);
+        frameworks = services
+            .filter((s) => s.framework)
+            .map((s) => s.framework);
+        // Detect proxy targets from root config
+        proxyTargets = detectProxyTargets(rootDir);
+        // Match proxy targets to services and set depends_on
+        if (proxyTargets.length > 0) {
+            const dependsOn = matchProxyToServices(proxyTargets, services);
+            // Find the frontend/main service and add depends_on
+            const frontendService = services.find((s) => s.root === './' || s.root === '.' || s.name === 'frontend');
+            if (frontendService && dependsOn.length > 0) {
+                frontendService.depends_on = dependsOn;
+            }
+        }
+    }
+    else {
+        const framework = detectFramework(rootDir);
+        if (framework) {
+            frameworks = [framework];
+        }
+        proxyTargets = detectProxyTargets(rootDir);
+    }
+    // Build suggestions based on detection
+    const primaryFramework = frameworks[0];
+    const runPrefix = packageManager === 'npm' ? 'npm run' : packageManager;
+    const suggestions = {
+        projectName,
+        devCommand: primaryFramework?.devCommand || `${runPrefix} dev`,
+        port: primaryFramework?.port || 3000,
+        readyPattern: primaryFramework?.readyPattern || 'ready|started|listening',
+        authBypassEnv: detectAuthBypass(rootDir),
+    };
+    return {
+        isMonorepo,
+        packageManager,
+        frameworks,
+        services,
+        proxyTargets,
+        suggestions,
+    };
+}
+/**
+ * Format detection results for display to user
+ */
+export function formatDetectionSummary(detection) {
+    const lines = [];
+    lines.push(`Project: ${detection.suggestions.projectName}`);
+    lines.push(`Package Manager: ${detection.packageManager}`);
+    lines.push(`Monorepo: ${detection.isMonorepo ? 'Yes' : 'No'}`);
+    if (detection.frameworks.length > 0) {
+        lines.push(`\nDetected Frameworks:`);
+        for (const fw of detection.frameworks) {
+            lines.push(`  - ${fw.name} (${fw.configFile})`);
+        }
+    }
+    if (detection.isMonorepo && detection.services.length > 0) {
+        lines.push(`\nDetected Services:`);
+        for (const svc of detection.services) {
+            const fw = svc.framework ? ` (${svc.framework.name})` : '';
+            const deps = svc.depends_on?.length ? ` → depends on: ${svc.depends_on.join(', ')}` : '';
+            lines.push(`  - ${svc.name}: ${svc.root}${fw}${deps}`);
+        }
+    }
+    if (detection.proxyTargets.length > 0) {
+        lines.push(`\nDetected Proxy Targets:`);
+        for (const proxy of detection.proxyTargets) {
+            lines.push(`  - ${proxy.path} → ${proxy.target}`);
+        }
+    }
+    lines.push(`\nSuggested Settings:`);
+    lines.push(`  Dev Command: ${detection.suggestions.devCommand}`);
+    lines.push(`  Port: ${detection.suggestions.port}`);
+    lines.push(`  Ready Pattern: "${detection.suggestions.readyPattern}"`);
+    if (detection.suggestions.authBypassEnv) {
+        lines.push(`  Auth Bypass: ${detection.suggestions.authBypassEnv}`);
+    }
+    return lines.join('\n');
+}