genbox 1.0.2 → 1.0.4

package/dist/scanner/runtime-detector.js

@@ -0,0 +1,330 @@
+"use strict";
+/**
+ * Runtime Detector
+ *
+ * Detects programming languages, versions, and package managers
+ */
+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.RuntimeDetector = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const RUNTIME_DETECTORS = {
+    node: {
+        indicators: ['package.json'],
+        versionFiles: [
+            {
+                file: '.nvmrc',
+                parser: (c) => c.trim().replace(/^v/, ''),
+            },
+            {
+                file: '.node-version',
+                parser: (c) => c.trim().replace(/^v/, ''),
+            },
+            {
+                file: 'package.json',
+                parser: (c) => {
+                    try {
+                        const pkg = JSON.parse(c);
+                        const engines = pkg.engines?.node;
+                        if (engines) {
+                            // Extract version from semver constraint (e.g., ">=18.0.0" -> "18")
+                            const match = engines.match(/(\d+)/);
+                            return match ? match[1] : undefined;
+                        }
+                    }
+                    catch { }
+                    return undefined;
+                },
+            },
+            {
+                file: '.tool-versions',
+                parser: (c) => parseAsdf(c, 'nodejs'),
+            },
+        ],
+        packageManagers: [
+            { lockfile: 'pnpm-lock.yaml', manager: 'pnpm' },
+            { lockfile: 'yarn.lock', manager: 'yarn' },
+            { lockfile: 'package-lock.json', manager: 'npm' },
+            { lockfile: 'bun.lockb', manager: 'bun' },
+        ],
+    },
+    python: {
+        indicators: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile'],
+        versionFiles: [
+            {
+                file: '.python-version',
+                parser: (c) => c.trim(),
+            },
+            {
+                file: 'pyproject.toml',
+                parser: (c) => {
+                    // Look for python version requirement
+                    const match = c.match(/python\s*=\s*["'](?:[><=^~]*)?(\d+\.\d+)/);
+                    return match ? match[1] : undefined;
+                },
+            },
+            {
+                file: 'runtime.txt',
+                parser: (c) => {
+                    const match = c.match(/python-(\d+\.\d+)/);
+                    return match ? match[1] : undefined;
+                },
+            },
+            {
+                file: '.tool-versions',
+                parser: (c) => parseAsdf(c, 'python'),
+            },
+        ],
+        packageManagers: [
+            { lockfile: 'poetry.lock', manager: 'poetry' },
+            { lockfile: 'Pipfile.lock', manager: 'pipenv' },
+            { lockfile: 'uv.lock', manager: 'uv' },
+            { lockfile: 'requirements.txt', manager: 'pip' },
+        ],
+    },
+    go: {
+        indicators: ['go.mod'],
+        versionFiles: [
+            {
+                file: 'go.mod',
+                parser: (c) => {
+                    const match = c.match(/^go\s+(\d+\.\d+)/m);
+                    return match ? match[1] : undefined;
+                },
+            },
+            {
+                file: '.tool-versions',
+                parser: (c) => parseAsdf(c, 'golang'),
+            },
+        ],
+    },
+    ruby: {
+        indicators: ['Gemfile'],
+        versionFiles: [
+            {
+                file: '.ruby-version',
+                parser: (c) => c.trim().replace(/^ruby-/, ''),
+            },
+            {
+                file: 'Gemfile',
+                parser: (c) => {
+                    const match = c.match(/ruby\s+['"](\d+\.\d+)/);
+                    return match ? match[1] : undefined;
+                },
+            },
+            {
+                file: '.tool-versions',
+                parser: (c) => parseAsdf(c, 'ruby'),
+            },
+        ],
+        packageManagers: [
+            { lockfile: 'Gemfile.lock', manager: 'bundler' },
+        ],
+    },
+    rust: {
+        indicators: ['Cargo.toml'],
+        versionFiles: [
+            {
+                file: 'rust-toolchain.toml',
+                parser: (c) => {
+                    const match = c.match(/channel\s*=\s*["'](\d+\.\d+)/);
+                    return match ? match[1] : undefined;
+                },
+            },
+            {
+                file: 'rust-toolchain',
+                parser: (c) => c.trim(),
+            },
+            {
+                file: '.tool-versions',
+                parser: (c) => parseAsdf(c, 'rust'),
+            },
+        ],
+        packageManagers: [
+            { lockfile: 'Cargo.lock', manager: 'cargo' },
+        ],
+    },
+    java: {
+        indicators: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+        versionFiles: [
+            {
+                file: '.java-version',
+                parser: (c) => c.trim(),
+            },
+            {
+                file: '.tool-versions',
+                parser: (c) => parseAsdf(c, 'java'),
+            },
+            {
+                file: 'pom.xml',
+                parser: (c) => {
+                    const match = c.match(/<java\.version>(\d+)<\/java\.version>/);
+                    return match ? match[1] : undefined;
+                },
+            },
+        ],
+    },
+    php: {
+        indicators: ['composer.json'],
+        versionFiles: [
+            {
+                file: '.php-version',
+                parser: (c) => c.trim(),
+            },
+            {
+                file: 'composer.json',
+                parser: (c) => {
+                    try {
+                        const pkg = JSON.parse(c);
+                        const php = pkg.require?.php;
+                        if (php) {
+                            const match = php.match(/(\d+\.\d+)/);
+                            return match ? match[1] : undefined;
+                        }
+                    }
+                    catch { }
+                    return undefined;
+                },
+            },
+            {
+                file: '.tool-versions',
+                parser: (c) => parseAsdf(c, 'php'),
+            },
+        ],
+    },
+    dotnet: {
+        indicators: ['*.csproj', '*.fsproj', 'global.json'],
+        versionFiles: [
+            {
+                file: 'global.json',
+                parser: (c) => {
+                    try {
+                        const config = JSON.parse(c);
+                        return config.sdk?.version;
+                    }
+                    catch { }
+                    return undefined;
+                },
+            },
+        ],
+    },
+};
+/**
+ * Parse .tool-versions file (asdf version manager)
+ */
+function parseAsdf(content, tool) {
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts[0] === tool && parts[1]) {
+            return parts[1];
+        }
+    }
+    return undefined;
+}
+class RuntimeDetector {
+    /**
+     * Detect all runtimes in the project
+     */
+    async detect(root, structure) {
+        const runtimes = [];
+        for (const [lang, config] of Object.entries(RUNTIME_DETECTORS)) {
+            // Check if any indicator files exist
+            const hasIndicator = config.indicators.some(indicator => {
+                // Handle glob patterns like *.csproj
+                if (indicator.includes('*')) {
+                    try {
+                        const files = fs.readdirSync(root);
+                        const pattern = new RegExp(indicator.replace('*', '.*'));
+                        return files.some(f => pattern.test(f));
+                    }
+                    catch {
+                        return false;
+                    }
+                }
+                return fs.existsSync(path.join(root, indicator));
+            });
+            if (!hasIndicator)
+                continue;
+            // Detect version
+            let version;
+            let versionSource;
+            for (const detector of config.versionFiles) {
+                const filePath = path.join(root, detector.file);
+                if (fs.existsSync(filePath)) {
+                    try {
+                        const content = fs.readFileSync(filePath, 'utf8');
+                        const detectedVersion = detector.parser(content);
+                        if (detectedVersion) {
+                            version = detectedVersion;
+                            versionSource = detector.file;
+                            break;
+                        }
+                    }
+                    catch { }
+                }
+            }
+            // Detect package manager
+            let packageManager;
+            let lockfile;
+            if (config.packageManagers) {
+                for (const pm of config.packageManagers) {
+                    if (fs.existsSync(path.join(root, pm.lockfile))) {
+                        packageManager = pm.manager;
+                        lockfile = pm.lockfile;
+                        break;
+                    }
+                }
+            }
+            runtimes.push({
+                language: lang,
+                version,
+                versionSource,
+                packageManager,
+                lockfile,
+            });
+        }
+        return runtimes;
+    }
+    /**
+     * Detect runtime for a specific app/directory
+     */
+    async detectForApp(appPath) {
+        const runtimes = await this.detect(appPath, { type: 'single-app', confidence: 'low', indicators: [] });
+        return runtimes[0];
+    }
+}
+exports.RuntimeDetector = RuntimeDetector;