@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/scanners/index.js

@@ -0,0 +1,454 @@
+/**
+ * Project Scanners
+ *
+ * Orchestrates all project scanners to build a complete project context
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { createLanguageScanner } from './language-scanner';
+import { createFrameworkScanner } from './framework-scanner';
+import { createPackageManagerScanner } from './package-manager-scanner';
+import { createIaCScanner } from './iac-scanner';
+import { createCICDScanner } from './cicd-scanner';
+import { createCloudScanner } from './cloud-scanner';
+// Re-export types
+export * from './types';
+// Re-export scanners
+export { LanguageScanner, createLanguageScanner } from './language-scanner';
+export { FrameworkScanner, createFrameworkScanner } from './framework-scanner';
+export { PackageManagerScanner, createPackageManagerScanner } from './package-manager-scanner';
+export { IaCScanner, createIaCScanner } from './iac-scanner';
+export { CICDScanner, createCICDScanner } from './cicd-scanner';
+export { CloudScanner, createCloudScanner } from './cloud-scanner';
+/**
+ * Default scan options
+ */
+const DEFAULT_SCAN_OPTIONS = {
+    depth: 'standard',
+    maxFiles: 1000,
+    includeHidden: false,
+    instructions: '',
+    maxDepth: 10,
+};
+/**
+ * Project Scanner Orchestrator
+ *
+ * Coordinates all individual scanners to build a complete project context
+ */
+export class ProjectScanner {
+    languageScanner;
+    frameworkScanner;
+    packageManagerScanner;
+    iacScanner;
+    cicdScanner;
+    cloudScanner;
+    constructor() {
+        this.languageScanner = createLanguageScanner();
+        this.frameworkScanner = createFrameworkScanner();
+        this.packageManagerScanner = createPackageManagerScanner();
+        this.iacScanner = createIaCScanner();
+        this.cicdScanner = createCICDScanner();
+        this.cloudScanner = createCloudScanner();
+    }
+    /**
+     * Scan a project directory and return complete context
+     */
+    async scan(cwd, options = {}) {
+        const opts = { ...DEFAULT_SCAN_OPTIONS, ...options };
+        // Run all scanners in parallel
+        const [languageResult, frameworkResult, packageManagerResult, iacResult, cicdResult, cloudResult, gitInfo,] = await Promise.all([
+            this.languageScanner.scan(cwd, opts),
+            this.frameworkScanner.scan(cwd, opts),
+            this.packageManagerScanner.scan(cwd, opts),
+            this.iacScanner.scan(cwd, opts),
+            this.cicdScanner.scan(cwd, opts),
+            this.cloudScanner.scan(cwd, opts),
+            this.getGitInfo(cwd),
+        ]);
+        // Extract detailed results
+        const languages = languageResult.details.languages;
+        const frameworks = frameworkResult.details.frameworks;
+        const packageManagers = packageManagerResult.details.packageManagers;
+        const iac = iacResult.details.iac;
+        const cicd = cicdResult.details.cicd;
+        const cloud = cloudResult.details.cloud;
+        // Get file lists
+        const terraformFiles = await this.iacScanner.getTerraformFiles(cwd);
+        const kubernetesFiles = await this.iacScanner.getKubernetesFiles(cwd);
+        const dockerFiles = await this.iacScanner.getDockerFiles(cwd);
+        const cicdFiles = await this.cicdScanner.getCICDFiles(cwd);
+        // Determine project type
+        const projectType = this.determineProjectType({
+            languages,
+            frameworks,
+            packageManagers,
+            iac,
+            cicd,
+            cloud,
+            git: gitInfo,
+            projectType: 'unknown',
+        });
+        // Get primary CI/CD platform
+        const primaryCICD = await this.cicdScanner.getPrimaryCICDPlatform(cwd);
+        // Build project context
+        const context = {
+            project: {
+                name: this.getProjectName(cwd),
+                path: cwd,
+                detected_at: new Date().toISOString(),
+            },
+            structure: {
+                type: projectType,
+                languages: languages.map(l => ({
+                    name: l.name,
+                    version: l.version,
+                    confidence: l.confidence,
+                    files: l.files,
+                })),
+                frameworks: frameworks.map(f => ({
+                    name: f.name,
+                    version: f.version,
+                    confidence: f.confidence,
+                    language: f.language,
+                })),
+                packageManagers: packageManagers.map(pm => ({
+                    name: pm.name,
+                    lockFile: pm.lockFile,
+                    confidence: pm.confidence,
+                })),
+            },
+            files: {
+                terraform: terraformFiles,
+                kubernetes: kubernetesFiles,
+                docker: dockerFiles,
+                cicd: cicdFiles,
+            },
+            git: gitInfo,
+            cicd: {
+                platform: primaryCICD,
+                workflows: cicdFiles,
+            },
+            cloud: {
+                providers: cloud.map(c => c.provider),
+                regions: [...new Set(cloud.flatMap(c => c.regions))],
+            },
+            instructions: opts.instructions || '',
+        };
+        return context;
+    }
+    /**
+     * Run a quick scan (config files only)
+     */
+    async quickScan(cwd) {
+        const [languageResult, frameworkResult, packageManagerResult, iacResult, cicdResult, cloudResult, gitInfo,] = await Promise.all([
+            this.languageScanner.scan(cwd),
+            this.frameworkScanner.scan(cwd),
+            this.packageManagerScanner.scan(cwd),
+            this.iacScanner.scan(cwd),
+            this.cicdScanner.scan(cwd),
+            this.cloudScanner.scan(cwd),
+            this.getGitInfo(cwd),
+        ]);
+        const result = {
+            languages: languageResult.details.languages,
+            frameworks: frameworkResult.details.frameworks,
+            packageManagers: packageManagerResult.details.packageManagers,
+            iac: iacResult.details.iac,
+            cicd: cicdResult.details.cicd,
+            cloud: cloudResult.details.cloud,
+            git: gitInfo,
+            projectType: 'unknown',
+        };
+        result.projectType = this.determineProjectType(result);
+        return result;
+    }
+    /**
+     * Get git repository information
+     */
+    async getGitInfo(cwd) {
+        const gitDir = path.join(cwd, '.git');
+        const isRepo = fs.existsSync(gitDir);
+        if (!isRepo) {
+            return {
+                isRepo: false,
+                remote: null,
+                branch: '',
+                hasUncommittedChanges: false,
+            };
+        }
+        let remote = null;
+        let branch = '';
+        let hasUncommittedChanges = false;
+        try {
+            // Get remote URL
+            remote = execSync('git remote get-url origin', { cwd, encoding: 'utf-8' }).trim();
+        }
+        catch {
+            remote = null;
+        }
+        try {
+            // Get current branch
+            branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd, encoding: 'utf-8' }).trim();
+        }
+        catch {
+            branch = 'unknown';
+        }
+        try {
+            // Check for uncommitted changes
+            const status = execSync('git status --porcelain', { cwd, encoding: 'utf-8' }).trim();
+            hasUncommittedChanges = status.length > 0;
+        }
+        catch {
+            hasUncommittedChanges = false;
+        }
+        return {
+            isRepo,
+            remote,
+            branch,
+            hasUncommittedChanges,
+        };
+    }
+    /**
+     * Get project name from package.json or directory name
+     */
+    getProjectName(cwd) {
+        // Try package.json
+        const packageJsonPath = path.join(cwd, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+                if (packageJson.name) {
+                    return packageJson.name;
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+        // Try pyproject.toml
+        const pyprojectPath = path.join(cwd, 'pyproject.toml');
+        if (fs.existsSync(pyprojectPath)) {
+            try {
+                const content = fs.readFileSync(pyprojectPath, 'utf-8');
+                const match = content.match(/name\s*=\s*["']([^"']+)["']/);
+                if (match) {
+                    return match[1];
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+        // Try Cargo.toml
+        const cargoPath = path.join(cwd, 'Cargo.toml');
+        if (fs.existsSync(cargoPath)) {
+            try {
+                const content = fs.readFileSync(cargoPath, 'utf-8');
+                const match = content.match(/name\s*=\s*["']([^"']+)["']/);
+                if (match) {
+                    return match[1];
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+        // Fall back to directory name
+        return path.basename(cwd);
+    }
+    /**
+     * Determine project type based on scan results
+     */
+    determineProjectType(result) {
+        const { languages, frameworks, iac, cloud: _cloud } = result;
+        // Check for monorepo indicators
+        const isMonorepo = this.isMonorepo(languages, frameworks);
+        if (isMonorepo) {
+            return 'monorepo';
+        }
+        // Check for infrastructure-only project
+        if (iac.length > 0 && languages.length === 0) {
+            return 'infrastructure';
+        }
+        // Check for mobile frameworks
+        const mobileFrameworks = ['react-native', 'flutter', 'expo'];
+        if (frameworks.some(f => mobileFrameworks.includes(f.name))) {
+            return 'mobile';
+        }
+        // Check for CLI indicators
+        const cliIndicators = ['commander', 'yargs', 'oclif', 'clap', 'cobra', 'click', 'typer'];
+        if (frameworks.some(f => cliIndicators.includes(f.name))) {
+            return 'cli';
+        }
+        // Check for fullstack
+        const frontendFrameworks = [
+            'next.js',
+            'nuxt',
+            'remix',
+            'angular',
+            'vue',
+            'react',
+            'svelte',
+            'astro',
+        ];
+        const backendFrameworks = [
+            'express',
+            'fastify',
+            'nestjs',
+            'django',
+            'fastapi',
+            'flask',
+            'spring-boot',
+            'gin',
+            'actix-web',
+        ];
+        const hasFrontend = frameworks.some(f => frontendFrameworks.includes(f.name));
+        const hasBackend = frameworks.some(f => backendFrameworks.includes(f.name));
+        if (hasFrontend && hasBackend) {
+            return 'fullstack';
+        }
+        if (hasFrontend) {
+            return 'frontend';
+        }
+        if (hasBackend) {
+            return 'backend';
+        }
+        // Check for library indicators
+        if (this.isLibrary(languages)) {
+            return 'library';
+        }
+        return 'unknown';
+    }
+    /**
+     * Check if project is a monorepo
+     */
+    isMonorepo(languages, _frameworks) {
+        // Check for monorepo tools
+        const _monorepoTools = ['lerna', 'nx', 'turborepo', 'rush', 'pnpm-workspace'];
+        // This would need to be detected from package.json or config files
+        // For now, check if multiple languages with high confidence
+        const highConfidenceLanguages = languages.filter(l => l.confidence === 'high');
+        return highConfidenceLanguages.length >= 3;
+    }
+    /**
+     * Check if project is a library
+     */
+    isLibrary(languages) {
+        // Libraries typically have specific config files
+        // This is a simplified heuristic
+        return languages.some(l => l.files.some(f => f.includes('.gemspec') || f.includes('setup.py') || f.includes('Cargo.toml')));
+    }
+}
+/**
+ * Generate project.yaml content from project context
+ */
+export function generateProjectYaml(context) {
+    const lines = [];
+    // Project section
+    lines.push('project:');
+    lines.push(`  name: ${context.project.name}`);
+    lines.push(`  detected_at: ${context.project.detected_at}`);
+    lines.push('');
+    // Structure section
+    lines.push('structure:');
+    lines.push(`  type: ${context.structure.type}`);
+    if (context.structure.languages.length > 0) {
+        lines.push('  languages:');
+        for (const lang of context.structure.languages) {
+            if (lang.version) {
+                lines.push(`    - name: ${lang.name}`);
+                lines.push(`      version: "${lang.version}"`);
+            }
+            else {
+                lines.push(`    - name: ${lang.name}`);
+            }
+        }
+    }
+    if (context.structure.frameworks.length > 0) {
+        lines.push('  frameworks:');
+        for (const fw of context.structure.frameworks) {
+            lines.push(`    - name: ${fw.name}`);
+            if (fw.version) {
+                lines.push(`      version: "${fw.version}"`);
+            }
+        }
+    }
+    if (context.structure.packageManagers.length > 0) {
+        lines.push(`  packageManagers: [${context.structure.packageManagers.map(pm => pm.name).join(', ')}]`);
+    }
+    lines.push('');
+    // Files section
+    lines.push('files:');
+    if (context.files.terraform.length > 0) {
+        lines.push(`  terraform: ["${context.files.terraform.slice(0, 10).join('", "')}"]`);
+    }
+    else {
+        lines.push('  terraform: []');
+    }
+    if (context.files.kubernetes.length > 0) {
+        lines.push(`  kubernetes: ["${context.files.kubernetes.slice(0, 10).join('", "')}"]`);
+    }
+    else {
+        lines.push('  kubernetes: []');
+    }
+    if (context.files.docker.length > 0) {
+        lines.push(`  docker: ["${context.files.docker.slice(0, 10).join('", "')}"]`);
+    }
+    else {
+        lines.push('  docker: []');
+    }
+    if (context.files.cicd.length > 0) {
+        lines.push(`  cicd: ["${context.files.cicd.slice(0, 10).join('", "')}"]`);
+    }
+    else {
+        lines.push('  cicd: []');
+    }
+    lines.push('');
+    // Git section
+    lines.push('git:');
+    lines.push(`  remote: ${context.git.remote || 'null'}`);
+    lines.push(`  branch: ${context.git.branch}`);
+    lines.push(`  isRepo: ${context.git.isRepo}`);
+    lines.push('');
+    // CI/CD section
+    lines.push('cicd:');
+    lines.push(`  platform: ${context.cicd.platform || 'null'}`);
+    if (context.cicd.workflows.length > 0) {
+        lines.push(`  workflows: ["${context.cicd.workflows.slice(0, 10).join('", "')}"]`);
+    }
+    else {
+        lines.push('  workflows: []');
+    }
+    lines.push('');
+    // Cloud section
+    lines.push('cloud:');
+    if (context.cloud.providers.length > 0) {
+        lines.push(`  providers: [${context.cloud.providers.join(', ')}]`);
+    }
+    else {
+        lines.push('  providers: []');
+    }
+    if (context.cloud.regions.length > 0) {
+        lines.push(`  regions: [${context.cloud.regions.join(', ')}]`);
+    }
+    else {
+        lines.push('  regions: []');
+    }
+    // Instructions section (if provided)
+    if (context.instructions) {
+        lines.push('');
+        lines.push('# Custom project instructions');
+        lines.push(`instructions: |`);
+        for (const line of context.instructions.split('\n')) {
+            lines.push(`  ${line}`);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+/**
+ * Create project scanner instance
+ */
+export function createProjectScanner() {
+    return new ProjectScanner();
+}