genbox 1.0.3 → 1.0.4

package/dist/scanner/structure-detector.js

@@ -0,0 +1,412 @@
+"use strict";
+/**
+ * Structure Detector
+ *
+ * Detects project structure type:
+ * - Single app
+ * - Monorepo (npm/pnpm/yarn/nx/turborepo/lerna)
+ * - Microservices (docker-compose based)
+ * - Go workspaces
+ * - Python monorepos
+ */
+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.StructureDetector = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class StructureDetector {
+    /**
+     * Detect project structure
+     */
+    async detect(root, exclude) {
+        // Run detectors in order of specificity (most specific first)
+        const detectors = [
+            () => this.detectNx(root),
+            () => this.detectTurborepo(root),
+            () => this.detectLerna(root),
+            () => this.detectPnpmWorkspace(root),
+            () => this.detectNpmWorkspace(root),
+            () => this.detectGoWorkspace(root),
+            () => this.detectPythonWorkspace(root),
+            () => this.detectMultiRepoWorkspace(root, exclude), // Multi-repo before microservices
+            () => this.detectMicroservices(root),
+            () => this.detectSingleApp(root),
+        ];
+        for (const detector of detectors) {
+            const result = detector();
+            if (result) {
+                return {
+                    type: result.type,
+                    confidence: result.confidence,
+                    indicators: result.indicators,
+                    workspaceRoot: root,
+                };
+            }
+        }
+        // Fallback
+        return {
+            type: 'single-app',
+            confidence: 'low',
+            indicators: ['No specific structure detected'],
+            workspaceRoot: root,
+        };
+    }
+    detectNx(root) {
+        const nxJsonPath = path.join(root, 'nx.json');
+        if (!fs.existsSync(nxJsonPath))
+            return null;
+        const indicators = ['nx.json'];
+        // Check for additional Nx files
+        const workspaceJson = path.join(root, 'workspace.json');
+        if (fs.existsSync(workspaceJson)) {
+            indicators.push('workspace.json');
+        }
+        // Check for project.json files in subdirectories
+        const projectDirs = ['apps', 'libs', 'packages'];
+        for (const dir of projectDirs) {
+            const dirPath = path.join(root, dir);
+            if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+                indicators.push(`${dir}/ directory`);
+            }
+        }
+        return {
+            type: 'monorepo-nx',
+            confidence: 'high',
+            indicators,
+        };
+    }
+    detectTurborepo(root) {
+        const turboJsonPath = path.join(root, 'turbo.json');
+        if (!fs.existsSync(turboJsonPath))
+            return null;
+        const indicators = ['turbo.json'];
+        // Verify it has pipeline configuration
+        try {
+            const turboConfig = JSON.parse(fs.readFileSync(turboJsonPath, 'utf8'));
+            if (turboConfig.pipeline || turboConfig.tasks) {
+                indicators.push('Has pipeline/tasks configuration');
+            }
+        }
+        catch { }
+        return {
+            type: 'monorepo-turborepo',
+            confidence: 'high',
+            indicators,
+        };
+    }
+    detectLerna(root) {
+        const lernaJsonPath = path.join(root, 'lerna.json');
+        if (!fs.existsSync(lernaJsonPath))
+            return null;
+        const indicators = ['lerna.json'];
+        try {
+            const lernaConfig = JSON.parse(fs.readFileSync(lernaJsonPath, 'utf8'));
+            if (lernaConfig.packages) {
+                indicators.push(`Packages: ${lernaConfig.packages.join(', ')}`);
+            }
+        }
+        catch { }
+        return {
+            type: 'monorepo-lerna',
+            confidence: 'high',
+            indicators,
+        };
+    }
+    detectPnpmWorkspace(root) {
+        const pnpmWorkspacePath = path.join(root, 'pnpm-workspace.yaml');
+        if (!fs.existsSync(pnpmWorkspacePath))
+            return null;
+        const indicators = ['pnpm-workspace.yaml'];
+        // Check for pnpm-lock.yaml
+        if (fs.existsSync(path.join(root, 'pnpm-lock.yaml'))) {
+            indicators.push('pnpm-lock.yaml');
+        }
+        return {
+            type: 'monorepo-pnpm',
+            confidence: 'high',
+            indicators,
+        };
+    }
+    detectNpmWorkspace(root) {
+        const packageJsonPath = path.join(root, 'package.json');
+        if (!fs.existsSync(packageJsonPath))
+            return null;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            // Check for workspaces field
+            if (!pkg.workspaces)
+                return null;
+            const workspaces = Array.isArray(pkg.workspaces)
+                ? pkg.workspaces
+                : pkg.workspaces.packages || [];
+            if (workspaces.length === 0)
+                return null;
+            const indicators = [`package.json workspaces: ${workspaces.join(', ')}`];
+            // Determine if it's yarn or npm based on lockfile
+            const hasYarnLock = fs.existsSync(path.join(root, 'yarn.lock'));
+            return {
+                type: hasYarnLock ? 'monorepo-yarn' : 'monorepo-npm',
+                confidence: 'high',
+                indicators,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    detectGoWorkspace(root) {
+        const goWorkPath = path.join(root, 'go.work');
+        if (!fs.existsSync(goWorkPath))
+            return null;
+        const indicators = ['go.work'];
+        try {
+            const content = fs.readFileSync(goWorkPath, 'utf8');
+            const useMatches = content.match(/use\s+\./g);
+            if (useMatches) {
+                indicators.push(`${useMatches.length} use directives`);
+            }
+        }
+        catch { }
+        return {
+            type: 'monorepo-go',
+            confidence: 'high',
+            indicators,
+        };
+    }
+    detectPythonWorkspace(root) {
+        const pyprojectPath = path.join(root, 'pyproject.toml');
+        if (!fs.existsSync(pyprojectPath))
+            return null;
+        try {
+            const content = fs.readFileSync(pyprojectPath, 'utf8');
+            // Check for Poetry workspace or PDM workspace
+            if (content.includes('[tool.poetry.packages]') ||
+                content.includes('[tool.pdm.packages]')) {
+                return {
+                    type: 'monorepo-python',
+                    confidence: 'high',
+                    indicators: ['pyproject.toml with workspace packages'],
+                };
+            }
+            // Check for multiple Python projects in subdirectories
+            const projectDirs = ['packages', 'libs', 'services'];
+            const foundDirs = [];
+            for (const dir of projectDirs) {
+                const dirPath = path.join(root, dir);
+                if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+                    const subDirs = fs.readdirSync(dirPath);
+                    const pythonProjects = subDirs.filter(sub => {
+                        const subPath = path.join(dirPath, sub);
+                        return fs.existsSync(path.join(subPath, 'pyproject.toml')) ||
+                            fs.existsSync(path.join(subPath, 'setup.py'));
+                    });
+                    if (pythonProjects.length > 0) {
+                        foundDirs.push(...pythonProjects.map(p => `${dir}/${p}`));
+                    }
+                }
+            }
+            if (foundDirs.length > 1) {
+                return {
+                    type: 'monorepo-python',
+                    confidence: 'medium',
+                    indicators: foundDirs,
+                };
+            }
+        }
+        catch { }
+        return null;
+    }
+    /**
+     * Detect multi-repo workspace (multiple separate projects/repos in subdirectories)
+     * This is common when a directory contains multiple related but independent projects
+     */
+    detectMultiRepoWorkspace(root, exclude) {
+        // Skip if there's a root package.json (would be detected as npm/yarn workspace)
+        if (fs.existsSync(path.join(root, 'package.json')))
+            return null;
+        if (fs.existsSync(path.join(root, 'pnpm-workspace.yaml')))
+            return null;
+        const indicators = [];
+        const projectDirs = [];
+        // Default exclusions
+        const defaultExclusions = ['node_modules', 'dist', 'build', '.git', 'backup', 'backups', 'logs'];
+        const exclusions = new Set([...defaultExclusions, ...(exclude || [])]);
+        // Look for subdirectories that are independent projects
+        try {
+            const entries = fs.readdirSync(root, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (entry.name.startsWith('.'))
+                    continue; // Skip hidden dirs
+                if (exclusions.has(entry.name))
+                    continue; // Skip excluded dirs
+                const subPath = path.join(root, entry.name);
+                // Check if this subdir is a project (has package.json, go.mod, etc.)
+                const isProject = fs.existsSync(path.join(subPath, 'package.json')) ||
+                    fs.existsSync(path.join(subPath, 'go.mod')) ||
+                    fs.existsSync(path.join(subPath, 'pyproject.toml')) ||
+                    fs.existsSync(path.join(subPath, 'Cargo.toml')) ||
+                    fs.existsSync(path.join(subPath, 'Gemfile'));
+                if (isProject) {
+                    // Check if it's a separate git repo
+                    const hasOwnGit = fs.existsSync(path.join(subPath, '.git'));
+                    projectDirs.push(entry.name);
+                    indicators.push(`${entry.name}/${hasOwnGit ? ' (git repo)' : ''}`);
+                }
+            }
+        }
+        catch {
+            return null;
+        }
+        // Need at least 2 project subdirectories to be a workspace
+        if (projectDirs.length >= 2) {
+            return {
+                type: 'hybrid', // Use 'hybrid' for multi-repo workspaces
+                confidence: projectDirs.length >= 3 ? 'high' : 'medium',
+                indicators: [
+                    `${projectDirs.length} independent projects`,
+                    ...indicators.slice(0, 8), // Limit indicator list
+                ],
+            };
+        }
+        return null;
+    }
+    detectMicroservices(root) {
+        // Look for docker-compose files
+        const composeFiles = this.findComposeFiles(root);
+        if (composeFiles.length === 0)
+            return null;
+        // Parse docker-compose to count services
+        const indicators = [];
+        let totalServices = 0;
+        let buildServices = 0;
+        for (const file of composeFiles) {
+            try {
+                const yaml = require('js-yaml');
+                const content = yaml.load(fs.readFileSync(file, 'utf8'));
+                if (content && content.services) {
+                    const services = Object.entries(content.services);
+                    totalServices += services.length;
+                    // Count services with build context (actual application code)
+                    for (const [name, config] of services) {
+                        const svc = config;
+                        if (svc.build) {
+                            buildServices++;
+                            indicators.push(`${name} (build)`);
+                        }
+                    }
+                }
+            }
+            catch { }
+        }
+        // Consider it microservices if there are multiple buildable services
+        if (buildServices >= 2) {
+            return {
+                type: 'microservices',
+                confidence: 'high',
+                indicators: [
+                    `${composeFiles.length} docker-compose file(s)`,
+                    `${totalServices} total services`,
+                    `${buildServices} buildable services`,
+                    ...indicators.slice(0, 5), // Limit indicators
+                ],
+            };
+        }
+        return null;
+    }
+    detectSingleApp(root) {
+        // Check for common single-app indicators
+        const indicators = [];
+        // Node.js
+        if (fs.existsSync(path.join(root, 'package.json'))) {
+            indicators.push('package.json');
+        }
+        // Python
+        if (fs.existsSync(path.join(root, 'pyproject.toml'))) {
+            indicators.push('pyproject.toml');
+        }
+        else if (fs.existsSync(path.join(root, 'requirements.txt'))) {
+            indicators.push('requirements.txt');
+        }
+        // Go
+        if (fs.existsSync(path.join(root, 'go.mod'))) {
+            indicators.push('go.mod');
+        }
+        // Ruby
+        if (fs.existsSync(path.join(root, 'Gemfile'))) {
+            indicators.push('Gemfile');
+        }
+        // Rust
+        if (fs.existsSync(path.join(root, 'Cargo.toml'))) {
+            indicators.push('Cargo.toml');
+        }
+        if (indicators.length > 0) {
+            return {
+                type: 'single-app',
+                confidence: indicators.length >= 2 ? 'high' : 'medium',
+                indicators,
+            };
+        }
+        return null;
+    }
+    findComposeFiles(root) {
+        const files = [];
+        const patterns = [
+            'docker-compose.yml',
+            'docker-compose.yaml',
+            'docker-compose.dev.yml',
+            'docker-compose.dev.yaml',
+            'docker-compose.local.yml',
+            'docker-compose.local.yaml',
+            'docker-compose.override.yml',
+            'docker-compose.override.yaml',
+            'docker-compose.prod.yml',
+            'docker-compose.prod.yaml',
+            'docker-compose.production.yml',
+            'docker-compose.production.yaml',
+            'compose.yml',
+            'compose.yaml',
+        ];
+        for (const pattern of patterns) {
+            const filePath = path.join(root, pattern);
+            if (fs.existsSync(filePath)) {
+                files.push(filePath);
+            }
+        }
+        return files;
+    }
+}
+exports.StructureDetector = StructureDetector;

package/dist/scanner/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Scanner Type Definitions
+ *
+ * Comprehensive types for multi-layer project scanning
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schema-v3.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Genbox Configuration Schema v3
+ *
+ * Supports:
+ * - Multi-level configs (workspace/project/user)
+ * - Flexible app selection (profiles, CLI, interactive)
+ * - External environment connections
+ * - Database modes (none/local/copy/remote)
+ * - Dependency resolution
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genbox",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {
@@ -54,6 +54,7 @@
   },
   "dependencies": {
     "@inquirer/confirm": "^6.0.2",
+    "@inquirer/prompts": "^8.0.2",
     "@inquirer/select": "^5.0.2",
     "chalk": "^5.6.2",
     "commander": "^14.0.2",