genbox 1.0.3 → 1.0.5

package/dist/scanner/index.js

@@ -0,0 +1,424 @@
+"use strict";
+/**
+ * Multi-Layer Project Scanner
+ *
+ * Industry-standard approach for detecting:
+ * - Project structure (single-app, monorepo, microservices)
+ * - Runtime/language versions
+ * - Frameworks
+ * - Services from docker-compose
+ * - Environment variables
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectScanner = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./structure-detector"), exports);
+__exportStar(require("./runtime-detector"), exports);
+__exportStar(require("./framework-detector"), exports);
+__exportStar(require("./compose-parser"), exports);
+__exportStar(require("./env-analyzer"), exports);
+__exportStar(require("./config-generator"), exports);
+const structure_detector_1 = require("./structure-detector");
+const runtime_detector_1 = require("./runtime-detector");
+const framework_detector_1 = require("./framework-detector");
+const compose_parser_1 = require("./compose-parser");
+const env_analyzer_1 = require("./env-analyzer");
+class ProjectScanner {
+    structureDetector;
+    runtimeDetector;
+    frameworkDetector;
+    composeParser;
+    envAnalyzer;
+    constructor() {
+        this.structureDetector = new structure_detector_1.StructureDetector();
+        this.runtimeDetector = new runtime_detector_1.RuntimeDetector();
+        this.frameworkDetector = new framework_detector_1.FrameworkDetector();
+        this.composeParser = new compose_parser_1.ComposeParser();
+        this.envAnalyzer = new env_analyzer_1.EnvAnalyzer();
+    }
+    /**
+     * Perform a comprehensive project scan
+     */
+    async scan(root, options = {}) {
+        // Layer 1: Detect project structure
+        const structure = await this.structureDetector.detect(root, options.exclude);
+        // Layer 2: Detect runtimes and versions
+        const runtimes = await this.runtimeDetector.detect(root, structure);
+        // Layer 3: Detect frameworks
+        const frameworks = await this.frameworkDetector.detect(root, runtimes);
+        // Layer 4: Parse docker-compose if present (skip if option set)
+        const compose = options.skipCompose ? null : await this.composeParser.parse(root);
+        // Layer 5: Discover apps (different approach based on structure)
+        const apps = await this.discoverApps(root, structure, compose, options.exclude);
+        // Layer 6: Analyze environment variables (skip if option set)
+        const envAnalysis = options.skipEnv
+            ? { required: [], optional: [], secrets: [], references: [], sources: [] }
+            : await this.envAnalyzer.analyze(root, apps, compose);
+        // Layer 7: Detect git info
+        const git = await this.detectGit(root);
+        // Layer 8: Find scripts (skip if option set)
+        const scripts = options.skipScripts ? [] : await this.findScripts(root);
+        return {
+            projectName: this.getProjectName(root),
+            root,
+            structure,
+            runtimes,
+            frameworks,
+            compose,
+            apps,
+            envAnalysis,
+            git,
+            scripts,
+        };
+    }
+    getProjectName(root) {
+        const path = require('path');
+        return path.basename(root);
+    }
+    async discoverApps(root, structure, compose, exclude) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        const apps = [];
+        if (structure.type === 'hybrid') {
+            // Multi-repo workspace - scan all subdirectories with package.json/etc.
+            const subApps = await this.discoverMultiRepoApps(root, exclude);
+            apps.push(...subApps);
+        }
+        else if (structure.type === 'microservices' && compose) {
+            // Apps from docker-compose services
+            for (const service of compose.applications) {
+                apps.push({
+                    name: service.name,
+                    path: service.build?.context || root,
+                    type: this.inferAppType(service.name),
+                    port: service.ports[0]?.host,
+                    dependencies: service.dependsOn,
+                    scripts: {},
+                });
+            }
+        }
+        else if (structure.type.startsWith('monorepo')) {
+            // Discover workspace apps
+            const workspaceApps = await this.discoverWorkspaceApps(root, structure);
+            apps.push(...workspaceApps);
+        }
+        else {
+            // Single app - the root itself
+            const pkgPath = path.join(root, 'package.json');
+            let scripts = {};
+            try {
+                const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+                scripts = pkg.scripts || {};
+            }
+            catch { }
+            apps.push({
+                name: this.getProjectName(root),
+                path: root,
+                type: 'backend', // Will be refined by framework detection
+                scripts,
+            });
+        }
+        return apps;
+    }
+    /**
+     * Discover apps in a multi-repo workspace (each subdir is independent project)
+     */
+    async discoverMultiRepoApps(root, exclude) {
+        const fs = require('fs').promises;
+        const fsSync = require('fs');
+        const path = require('path');
+        const apps = [];
+        // Default exclusions
+        const defaultExclusions = ['node_modules', 'dist', 'build', '.git', 'backup', 'backups', 'logs'];
+        const exclusions = new Set([...defaultExclusions, ...(exclude || [])]);
+        try {
+            const entries = fsSync.readdirSync(root, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (entry.name.startsWith('.'))
+                    continue;
+                if (exclusions.has(entry.name))
+                    continue;
+                const subPath = path.join(root, entry.name);
+                const pkgPath = path.join(subPath, 'package.json');
+                // Check for Node.js project
+                if (fsSync.existsSync(pkgPath)) {
+                    try {
+                        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+                        const hasStartScript = !!(pkg.scripts?.start || pkg.scripts?.dev || pkg.scripts?.serve);
+                        const type = this.inferAppTypeFromPackage(entry.name, pkg, hasStartScript);
+                        // Try to detect framework
+                        let framework;
+                        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                        if (deps['next'])
+                            framework = 'nextjs';
+                        else if (deps['@nestjs/core'])
+                            framework = 'nestjs';
+                        else if (deps['react-admin'])
+                            framework = 'react-admin';
+                        else if (deps['react'])
+                            framework = 'react';
+                        else if (deps['vue'])
+                            framework = 'vue';
+                        else if (deps['express'])
+                            framework = 'express';
+                        // Try to detect port from package.json scripts
+                        let port;
+                        const devScript = pkg.scripts?.dev || pkg.scripts?.start || '';
+                        const portMatch = devScript.match(/--port[=\s](\d+)|PORT[=\s](\d+)|-p[=\s](\d+)/);
+                        if (portMatch) {
+                            port = parseInt(portMatch[1] || portMatch[2] || portMatch[3], 10);
+                        }
+                        apps.push({
+                            name: entry.name,
+                            path: entry.name,
+                            type,
+                            framework: framework,
+                            port,
+                            scripts: pkg.scripts || {},
+                            dependencies: Object.keys(pkg.dependencies || {}),
+                        });
+                    }
+                    catch {
+                        // Invalid package.json, skip
+                    }
+                }
+                // Check for Go project
+                const goModPath = path.join(subPath, 'go.mod');
+                if (fsSync.existsSync(goModPath)) {
+                    apps.push({
+                        name: entry.name,
+                        path: entry.name,
+                        type: 'backend',
+                        scripts: {},
+                    });
+                }
+                // Check for Python project
+                const pyprojectPath = path.join(subPath, 'pyproject.toml');
+                const requirementsPath = path.join(subPath, 'requirements.txt');
+                if (fsSync.existsSync(pyprojectPath) || fsSync.existsSync(requirementsPath)) {
+                    apps.push({
+                        name: entry.name,
+                        path: entry.name,
+                        type: 'backend',
+                        scripts: {},
+                    });
+                }
+            }
+        }
+        catch {
+            // Error reading directory
+        }
+        return apps;
+    }
+    async discoverWorkspaceApps(root, structure) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        const glob = require('fast-glob');
+        const apps = [];
+        // Get workspace patterns based on type
+        let patterns = [];
+        switch (structure.type) {
+            case 'monorepo-pnpm': {
+                // Read pnpm-workspace.yaml
+                try {
+                    const yaml = require('js-yaml');
+                    const content = await fs.readFile(path.join(root, 'pnpm-workspace.yaml'), 'utf8');
+                    const workspace = yaml.load(content);
+                    patterns = workspace.packages || [];
+                }
+                catch { }
+                break;
+            }
+            case 'monorepo-npm':
+            case 'monorepo-yarn': {
+                // Read package.json workspaces
+                try {
+                    const pkg = JSON.parse(await fs.readFile(path.join(root, 'package.json'), 'utf8'));
+                    const workspaces = pkg.workspaces;
+                    if (Array.isArray(workspaces)) {
+                        patterns = workspaces;
+                    }
+                    else if (workspaces?.packages) {
+                        patterns = workspaces.packages;
+                    }
+                }
+                catch { }
+                break;
+            }
+            case 'monorepo-nx': {
+                // Check apps/ and libs/ directories
+                patterns = ['apps/*', 'libs/*', 'packages/*'];
+                break;
+            }
+            case 'monorepo-turborepo': {
+                // Check apps/ and packages/ directories
+                patterns = ['apps/*', 'packages/*'];
+                break;
+            }
+            default:
+                patterns = ['packages/*', 'apps/*'];
+        }
+        // Find all matching directories with package.json
+        for (const pattern of patterns) {
+            const dirs = await glob(pattern, {
+                cwd: root,
+                onlyDirectories: true,
+                absolute: false,
+            });
+            for (const dir of dirs) {
+                const pkgPath = path.join(root, dir, 'package.json');
+                try {
+                    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+                    // Determine if it's an app or library
+                    const hasStartScript = !!(pkg.scripts?.start || pkg.scripts?.dev || pkg.scripts?.serve);
+                    const type = this.inferAppTypeFromPackage(dir, pkg, hasStartScript);
+                    apps.push({
+                        name: pkg.name || path.basename(dir),
+                        path: dir,
+                        type,
+                        scripts: pkg.scripts || {},
+                        dependencies: Object.keys(pkg.dependencies || {}),
+                    });
+                }
+                catch {
+                    // No package.json, skip
+                }
+            }
+        }
+        return apps;
+    }
+    inferAppType(name) {
+        const lowerName = name.toLowerCase();
+        if (/gateway|proxy|ingress/.test(lowerName))
+            return 'gateway';
+        if (/frontend|web|ui|client|app/.test(lowerName))
+            return 'frontend';
+        if (/worker|queue|consumer|job/.test(lowerName))
+            return 'worker';
+        if (/backend|server|service|api/.test(lowerName))
+            return 'backend';
+        return 'backend';
+    }
+    inferAppTypeFromPackage(dir, pkg, hasStartScript) {
+        const deps = pkg.dependencies || {};
+        const name = (pkg.name || dir).toLowerCase();
+        // Check dependencies for type hints
+        if (deps.react || deps.vue || deps.svelte || deps['@angular/core']) {
+            return 'frontend';
+        }
+        if (deps['@nestjs/core'] || deps.express || deps.fastify || deps.koa) {
+            return 'backend';
+        }
+        if (deps['bull'] || deps['bullmq'] || deps['bee-queue']) {
+            return 'worker';
+        }
+        // Path-based inference
+        if (dir.includes('libs/') || dir.includes('packages/shared')) {
+            return 'library';
+        }
+        if (/web|frontend|ui|client/.test(name))
+            return 'frontend';
+        if (/api|backend|server/.test(name))
+            return 'backend';
+        if (/worker|queue/.test(name))
+            return 'worker';
+        // If it has a start script, it's probably an app
+        return hasStartScript ? 'backend' : 'library';
+    }
+    async detectGit(root) {
+        const { execSync } = require('child_process');
+        try {
+            const remote = execSync('git remote get-url origin', {
+                cwd: root,
+                stdio: 'pipe',
+                encoding: 'utf8',
+            }).trim();
+            if (!remote)
+                return undefined;
+            const isSSH = remote.startsWith('git@') || remote.startsWith('ssh://');
+            // Extract provider
+            let provider = 'other';
+            if (remote.includes('github.com'))
+                provider = 'github';
+            else if (remote.includes('gitlab.com'))
+                provider = 'gitlab';
+            else if (remote.includes('bitbucket.org'))
+                provider = 'bitbucket';
+            // Get current branch
+            let branch = 'main';
+            try {
+                branch = execSync('git rev-parse --abbrev-ref HEAD', {
+                    cwd: root,
+                    stdio: 'pipe',
+                    encoding: 'utf8',
+                }).trim();
+            }
+            catch { }
+            return {
+                remote,
+                type: isSSH ? 'ssh' : 'https',
+                provider,
+                branch,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async findScripts(root) {
+        const fs = require('fs').promises;
+        const path = require('path');
+        const glob = require('fast-glob');
+        const scripts = [];
+        // Find shell scripts in common locations
+        const scriptPatterns = [
+            'scripts/**/*.sh',
+            'bin/*.sh',
+            '*.sh',
+            'Makefile',
+        ];
+        const files = await glob(scriptPatterns, {
+            cwd: root,
+            ignore: ['node_modules/**', '.git/**', 'vendor/**'],
+        });
+        for (const file of files) {
+            const fullPath = path.join(root, file);
+            const stat = await fs.stat(fullPath);
+            // Determine script type based on location/name
+            let stage = 'setup';
+            const lowerFile = file.toLowerCase();
+            if (/setup|init|install/.test(lowerFile))
+                stage = 'setup';
+            else if (/build|compile/.test(lowerFile))
+                stage = 'build';
+            else if (/start|run|serve/.test(lowerFile))
+                stage = 'start';
+            else if (/deploy|release/.test(lowerFile))
+                stage = 'post-start';
+            scripts.push({
+                name: path.basename(file),
+                path: file,
+                stage,
+                isExecutable: (stat.mode & 0o111) !== 0,
+            });
+        }
+        return scripts;
+    }
+}
+exports.ProjectScanner = ProjectScanner;