genbox 1.0.2 → 1.0.4

package/dist/scanner/framework-detector.js

@@ -0,0 +1,621 @@
+"use strict";
+/**
+ * Framework Detector
+ *
+ * Detects frameworks and their configurations:
+ * - Node.js: Next.js, NestJS, Express, etc.
+ * - Python: Django, FastAPI, Flask, etc.
+ * - Go: Gin, Echo, Fiber, etc.
+ * - Ruby: Rails, Sinatra
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameworkDetector = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FRAMEWORK_SIGNATURES = {
+    // Node.js - Fullstack/Frontend
+    nextjs: {
+        language: 'node',
+        detection: [
+            { type: 'file', value: 'next.config.js' },
+            { type: 'file', value: 'next.config.mjs' },
+            { type: 'file', value: 'next.config.ts' },
+            { type: 'dependency', value: 'next' },
+        ],
+        defaults: {
+            type: 'fullstack',
+            defaultPort: 3000,
+            devCommand: 'next dev',
+            buildCommand: 'next build',
+            startCommand: 'next start',
+            outputDir: '.next',
+        },
+    },
+    nuxt: {
+        language: 'node',
+        detection: [
+            { type: 'file', value: 'nuxt.config.ts' },
+            { type: 'file', value: 'nuxt.config.js' },
+            { type: 'dependency', value: 'nuxt' },
+        ],
+        defaults: {
+            type: 'fullstack',
+            defaultPort: 3000,
+            devCommand: 'nuxt dev',
+            buildCommand: 'nuxt build',
+            startCommand: 'nuxt start',
+            outputDir: '.output',
+        },
+    },
+    remix: {
+        language: 'node',
+        detection: [
+            { type: 'file', value: 'remix.config.js' },
+            { type: 'dependency', value: '@remix-run/react' },
+        ],
+        defaults: {
+            type: 'fullstack',
+            defaultPort: 3000,
+            devCommand: 'remix dev',
+            buildCommand: 'remix build',
+            startCommand: 'remix-serve build',
+            outputDir: 'build',
+        },
+    },
+    astro: {
+        language: 'node',
+        detection: [
+            { type: 'file', value: 'astro.config.mjs' },
+            { type: 'file', value: 'astro.config.ts' },
+            { type: 'dependency', value: 'astro' },
+        ],
+        defaults: {
+            type: 'frontend',
+            defaultPort: 4321,
+            devCommand: 'astro dev',
+            buildCommand: 'astro build',
+            outputDir: 'dist',
+        },
+    },
+    gatsby: {
+        language: 'node',
+        detection: [
+            { type: 'file', value: 'gatsby-config.js' },
+            { type: 'file', value: 'gatsby-config.ts' },
+            { type: 'dependency', value: 'gatsby' },
+        ],
+        defaults: {
+            type: 'frontend',
+            defaultPort: 8000,
+            devCommand: 'gatsby develop',
+            buildCommand: 'gatsby build',
+            outputDir: 'public',
+        },
+    },
+    sveltekit: {
+        language: 'node',
+        detection: [
+            { type: 'file', value: 'svelte.config.js' },
+            { type: 'dependency', value: '@sveltejs/kit' },
+        ],
+        defaults: {
+            type: 'fullstack',
+            defaultPort: 5173,
+            devCommand: 'vite dev',
+            buildCommand: 'vite build',
+            outputDir: 'build',
+        },
+    },
+    react: {
+        language: 'node',
+        detection: [
+            { type: 'dependency', value: 'react' },
+            { type: 'dependency', value: 'react-dom' },
+        ],
+        defaults: {
+            type: 'frontend',
+            defaultPort: 3000,
+            devCommand: 'vite dev',
+            buildCommand: 'vite build',
+            outputDir: 'dist',
+        },
+    },
+    vue: {
+        language: 'node',
+        detection: [
+            { type: 'dependency', value: 'vue' },
+        ],
+        defaults: {
+            type: 'frontend',
+            defaultPort: 5173,
+            devCommand: 'vite dev',
+            buildCommand: 'vite build',
+            outputDir: 'dist',
+        },
+    },
+    angular: {
+        language: 'node',
+        detection: [
+            { type: 'file', value: 'angular.json' },
+            { type: 'dependency', value: '@angular/core' },
+        ],
+        defaults: {
+            type: 'frontend',
+            defaultPort: 4200,
+            devCommand: 'ng serve',
+            buildCommand: 'ng build',
+            outputDir: 'dist',
+        },
+    },
+    svelte: {
+        language: 'node',
+        detection: [
+            { type: 'dependency', value: 'svelte' },
+        ],
+        defaults: {
+            type: 'frontend',
+            defaultPort: 5173,
+            devCommand: 'vite dev',
+            buildCommand: 'vite build',
+            outputDir: 'dist',
+        },
+    },
+    solid: {
+        language: 'node',
+        detection: [
+            { type: 'dependency', value: 'solid-js' },
+        ],
+        defaults: {
+            type: 'frontend',
+            defaultPort: 3000,
+            devCommand: 'vite dev',
+            buildCommand: 'vite build',
+            outputDir: 'dist',
+        },
+    },
+    vite: {
+        language: 'node',
+        detection: [
+            { type: 'file', value: 'vite.config.ts' },
+            { type: 'file', value: 'vite.config.js' },
+            { type: 'dependency', value: 'vite' },
+        ],
+        defaults: {
+            type: 'frontend',
+            defaultPort: 5173,
+            devCommand: 'vite',
+            buildCommand: 'vite build',
+            outputDir: 'dist',
+        },
+    },
+    // Node.js - Backend
+    nestjs: {
+        language: 'node',
+        detection: [
+            { type: 'file', value: 'nest-cli.json' },
+            { type: 'dependency', value: '@nestjs/core' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 3000,
+            devCommand: 'nest start --watch',
+            buildCommand: 'nest build',
+            startCommand: 'node dist/main',
+            outputDir: 'dist',
+        },
+    },
+    express: {
+        language: 'node',
+        detection: [
+            { type: 'dependency', value: 'express' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 3000,
+            devCommand: 'node --watch src/index.js',
+            startCommand: 'node src/index.js',
+        },
+    },
+    fastify: {
+        language: 'node',
+        detection: [
+            { type: 'dependency', value: 'fastify' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 3000,
+            devCommand: 'node --watch src/index.js',
+            startCommand: 'node src/index.js',
+        },
+    },
+    koa: {
+        language: 'node',
+        detection: [
+            { type: 'dependency', value: 'koa' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 3000,
+            devCommand: 'node --watch src/index.js',
+            startCommand: 'node src/index.js',
+        },
+    },
+    hono: {
+        language: 'node',
+        detection: [
+            { type: 'dependency', value: 'hono' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 3000,
+            devCommand: 'node --watch src/index.ts',
+            startCommand: 'node dist/index.js',
+        },
+    },
+    hapi: {
+        language: 'node',
+        detection: [
+            { type: 'dependency', value: '@hapi/hapi' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 3000,
+            devCommand: 'node --watch src/index.js',
+            startCommand: 'node src/index.js',
+        },
+    },
+    // Python
+    django: {
+        language: 'python',
+        detection: [
+            { type: 'file', value: 'manage.py' },
+            { type: 'dependency', value: 'django' },
+            { type: 'dependency', value: 'Django' },
+        ],
+        defaults: {
+            type: 'fullstack',
+            defaultPort: 8000,
+            devCommand: 'python manage.py runserver',
+            startCommand: 'gunicorn app.wsgi:application',
+        },
+    },
+    fastapi: {
+        language: 'python',
+        detection: [
+            { type: 'dependency', value: 'fastapi' },
+            { type: 'pattern', value: /from\s+fastapi\s+import/ },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 8000,
+            devCommand: 'uvicorn main:app --reload',
+            startCommand: 'uvicorn main:app --host 0.0.0.0',
+        },
+    },
+    flask: {
+        language: 'python',
+        detection: [
+            { type: 'dependency', value: 'flask' },
+            { type: 'dependency', value: 'Flask' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 5000,
+            devCommand: 'flask run --debug',
+            startCommand: 'gunicorn app:app',
+        },
+    },
+    starlette: {
+        language: 'python',
+        detection: [
+            { type: 'dependency', value: 'starlette' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 8000,
+            devCommand: 'uvicorn main:app --reload',
+            startCommand: 'uvicorn main:app',
+        },
+    },
+    // Go
+    gin: {
+        language: 'go',
+        detection: [
+            { type: 'dependency', value: 'github.com/gin-gonic/gin' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 8080,
+            devCommand: 'go run .',
+            buildCommand: 'go build -o app',
+            startCommand: './app',
+        },
+    },
+    echo: {
+        language: 'go',
+        detection: [
+            { type: 'dependency', value: 'github.com/labstack/echo' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 8080,
+            devCommand: 'go run .',
+            buildCommand: 'go build -o app',
+            startCommand: './app',
+        },
+    },
+    fiber: {
+        language: 'go',
+        detection: [
+            { type: 'dependency', value: 'github.com/gofiber/fiber' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 3000,
+            devCommand: 'go run .',
+            buildCommand: 'go build -o app',
+            startCommand: './app',
+        },
+    },
+    chi: {
+        language: 'go',
+        detection: [
+            { type: 'dependency', value: 'github.com/go-chi/chi' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 8080,
+            devCommand: 'go run .',
+            buildCommand: 'go build -o app',
+            startCommand: './app',
+        },
+    },
+    // Ruby
+    rails: {
+        language: 'ruby',
+        detection: [
+            { type: 'file', value: 'config/routes.rb' },
+            { type: 'dependency', value: 'rails' },
+        ],
+        defaults: {
+            type: 'fullstack',
+            defaultPort: 3000,
+            devCommand: 'rails server',
+            startCommand: 'rails server -e production',
+        },
+    },
+    sinatra: {
+        language: 'ruby',
+        detection: [
+            { type: 'dependency', value: 'sinatra' },
+        ],
+        defaults: {
+            type: 'backend',
+            defaultPort: 4567,
+            devCommand: 'ruby app.rb',
+            startCommand: 'ruby app.rb -e production',
+        },
+    },
+};
+// Priority order for detection (more specific frameworks first)
+const DETECTION_PRIORITY = [
+    // Node.js fullstack (most specific)
+    'nextjs', 'nuxt', 'remix', 'sveltekit', 'gatsby', 'astro',
+    // Node.js backend
+    'nestjs', 'fastify', 'hono', 'hapi', 'koa', 'express',
+    // Node.js frontend
+    'angular', 'vue', 'svelte', 'solid', 'react', 'vite',
+    // Python
+    'django', 'fastapi', 'flask', 'starlette',
+    // Go
+    'gin', 'echo', 'fiber', 'chi',
+    // Ruby
+    'rails', 'sinatra',
+];
+class FrameworkDetector {
+    /**
+     * Detect frameworks in the project
+     */
+    async detect(root, runtimes) {
+        const frameworks = [];
+        const detectedLanguages = new Set(runtimes.map(r => r.language));
+        const alreadyDetected = new Set();
+        // Check frameworks in priority order
+        for (const framework of DETECTION_PRIORITY) {
+            if (alreadyDetected.has(framework))
+                continue;
+            const signature = FRAMEWORK_SIGNATURES[framework];
+            // Skip if language not detected
+            if (!detectedLanguages.has(signature.language))
+                continue;
+            // Check detection rules
+            const matches = await this.matchesSignature(root, signature.detection);
+            if (matches) {
+                // For generic frameworks (react, vue, express), check they're not part of a fullstack framework
+                if (this.isGenericFramework(framework)) {
+                    const hasFullstackFramework = frameworks.some(f => FRAMEWORK_SIGNATURES[f.name].defaults.type === 'fullstack');
+                    if (hasFullstackFramework)
+                        continue;
+                }
+                const version = await this.getFrameworkVersion(root, framework);
+                frameworks.push({
+                    name: framework,
+                    version,
+                    ...signature.defaults,
+                });
+                alreadyDetected.add(framework);
+            }
+        }
+        return frameworks;
+    }
+    isGenericFramework(framework) {
+        return ['react', 'vue', 'svelte', 'solid', 'express', 'vite'].includes(framework);
+    }
+    async matchesSignature(root, rules) {
+        for (const rule of rules) {
+            const matches = await this.matchRule(root, rule);
+            if (matches)
+                return true;
+        }
+        return false;
+    }
+    async matchRule(root, rule) {
+        switch (rule.type) {
+            case 'file':
+                return fs.existsSync(path.join(root, rule.value));
+            case 'dependency':
+                return this.hasDependency(root, rule.value);
+            case 'pattern':
+                return this.matchesPattern(root, rule.value);
+            default:
+                return false;
+        }
+    }
+    hasDependency(root, dep) {
+        // Check Node.js package.json
+        const pkgPath = path.join(root, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+                const allDeps = {
+                    ...(pkg.dependencies || {}),
+                    ...(pkg.devDependencies || {}),
+                    ...(pkg.peerDependencies || {}),
+                };
+                if (allDeps[dep])
+                    return true;
+            }
+            catch { }
+        }
+        // Check Python requirements
+        const reqPath = path.join(root, 'requirements.txt');
+        if (fs.existsSync(reqPath)) {
+            try {
+                const content = fs.readFileSync(reqPath, 'utf8').toLowerCase();
+                if (content.includes(dep.toLowerCase()))
+                    return true;
+            }
+            catch { }
+        }
+        // Check Python pyproject.toml
+        const pyprojectPath = path.join(root, 'pyproject.toml');
+        if (fs.existsSync(pyprojectPath)) {
+            try {
+                const content = fs.readFileSync(pyprojectPath, 'utf8').toLowerCase();
+                if (content.includes(dep.toLowerCase()))
+                    return true;
+            }
+            catch { }
+        }
+        // Check Go go.mod
+        const goModPath = path.join(root, 'go.mod');
+        if (fs.existsSync(goModPath)) {
+            try {
+                const content = fs.readFileSync(goModPath, 'utf8');
+                if (content.includes(dep))
+                    return true;
+            }
+            catch { }
+        }
+        // Check Ruby Gemfile
+        const gemfilePath = path.join(root, 'Gemfile');
+        if (fs.existsSync(gemfilePath)) {
+            try {
+                const content = fs.readFileSync(gemfilePath, 'utf8').toLowerCase();
+                if (content.includes(dep.toLowerCase()))
+                    return true;
+            }
+            catch { }
+        }
+        return false;
+    }
+    matchesPattern(root, pattern) {
+        // Search common source files for the pattern
+        const sourceFiles = [
+            'main.py', 'app.py', 'src/main.py', 'src/app.py',
+            'main.go', 'cmd/main.go',
+            'app.rb', 'config.ru',
+        ];
+        for (const file of sourceFiles) {
+            const filePath = path.join(root, file);
+            if (fs.existsSync(filePath)) {
+                try {
+                    const content = fs.readFileSync(filePath, 'utf8');
+                    if (pattern.test(content))
+                        return true;
+                }
+                catch { }
+            }
+        }
+        return false;
+    }
+    async getFrameworkVersion(root, framework) {
+        const signature = FRAMEWORK_SIGNATURES[framework];
+        if (signature.language === 'node') {
+            // Get from package.json
+            const pkgPath = path.join(root, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                try {
+                    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+                    const allDeps = {
+                        ...(pkg.dependencies || {}),
+                        ...(pkg.devDependencies || {}),
+                    };
+                    // Find the main dependency
+                    for (const rule of signature.detection) {
+                        if (rule.type === 'dependency') {
+                            const version = allDeps[rule.value];
+                            if (version) {
+                                // Strip semver operators
+                                return version.replace(/^[\^~>=<]+/, '');
+                            }
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Detect framework for a specific app
+     */
+    async detectForApp(appPath, runtime) {
+        const frameworks = await this.detect(appPath, [runtime]);
+        return frameworks[0];
+    }
+}
+exports.FrameworkDetector = FrameworkDetector;