@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/scanners/cicd-scanner.js

@@ -0,0 +1,230 @@
+/**
+ * CI/CD Scanner
+ *
+ * Detects CI/CD platforms and workflows in a project
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const CICD_PATTERNS = [
+    {
+        name: 'github-actions',
+        displayName: 'GitHub Actions',
+        configPaths: ['.github/workflows'],
+        workflowPattern: /\.ya?ml$/,
+    },
+    {
+        name: 'gitlab-ci',
+        displayName: 'GitLab CI',
+        configPaths: ['.gitlab-ci.yml', '.gitlab-ci.yaml'],
+    },
+    {
+        name: 'jenkins',
+        displayName: 'Jenkins',
+        configPaths: ['Jenkinsfile', 'jenkins/Jenkinsfile', '.jenkins'],
+    },
+    {
+        name: 'circleci',
+        displayName: 'CircleCI',
+        configPaths: ['.circleci/config.yml', '.circleci/config.yaml'],
+    },
+    {
+        name: 'travis-ci',
+        displayName: 'Travis CI',
+        configPaths: ['.travis.yml', '.travis.yaml'],
+    },
+    {
+        name: 'azure-pipelines',
+        displayName: 'Azure Pipelines',
+        configPaths: ['azure-pipelines.yml', 'azure-pipelines.yaml', '.azure-pipelines'],
+    },
+    {
+        name: 'bitbucket-pipelines',
+        displayName: 'Bitbucket Pipelines',
+        configPaths: ['bitbucket-pipelines.yml', 'bitbucket-pipelines.yaml'],
+    },
+    {
+        name: 'drone',
+        displayName: 'Drone CI',
+        configPaths: ['.drone.yml', '.drone.yaml'],
+    },
+    {
+        name: 'buildkite',
+        displayName: 'Buildkite',
+        configPaths: ['.buildkite/pipeline.yml', '.buildkite/pipeline.yaml', 'buildkite.yml'],
+    },
+    {
+        name: 'teamcity',
+        displayName: 'TeamCity',
+        configPaths: ['.teamcity'],
+    },
+    {
+        name: 'concourse',
+        displayName: 'Concourse CI',
+        configPaths: ['ci/pipeline.yml', 'ci/pipeline.yaml', 'concourse.yml'],
+    },
+    {
+        name: 'codebuild',
+        displayName: 'AWS CodeBuild',
+        configPaths: ['buildspec.yml', 'buildspec.yaml'],
+    },
+    {
+        name: 'cloudbuild',
+        displayName: 'Google Cloud Build',
+        configPaths: ['cloudbuild.yaml', 'cloudbuild.yml'],
+    },
+    {
+        name: 'tekton',
+        displayName: 'Tekton',
+        configPaths: ['.tekton', 'tekton'],
+    },
+    {
+        name: 'argo-workflows',
+        displayName: 'Argo Workflows',
+        configPaths: ['.argo'],
+    },
+    {
+        name: 'woodpecker',
+        displayName: 'Woodpecker CI',
+        configPaths: ['.woodpecker.yml', '.woodpecker.yaml', '.woodpecker'],
+    },
+    {
+        name: 'earthly',
+        displayName: 'Earthly',
+        configPaths: ['Earthfile'],
+    },
+    {
+        name: 'dagger',
+        displayName: 'Dagger',
+        configPaths: ['dagger.json', 'dagger'],
+    },
+    {
+        name: 'taskfile',
+        displayName: 'Task (Taskfile)',
+        configPaths: ['Taskfile.yml', 'Taskfile.yaml', 'Taskfile.dist.yml'],
+    },
+    {
+        name: 'makefile',
+        displayName: 'Make',
+        configPaths: ['Makefile', 'makefile', 'GNUmakefile'],
+    },
+    {
+        name: 'justfile',
+        displayName: 'Just',
+        configPaths: ['justfile', 'Justfile', '.justfile'],
+    },
+];
+export class CICDScanner {
+    name = 'cicd';
+    async scan(cwd, _options) {
+        const cicd = await this.detectCICD(cwd);
+        return {
+            detected: cicd.length > 0,
+            confidence: cicd.length > 0 ? cicd[0].confidence : 'low',
+            details: {
+                cicd,
+            },
+        };
+    }
+    async detectCICD(cwd) {
+        const detected = [];
+        for (const pattern of CICD_PATTERNS) {
+            const result = await this.detectCICDPlatform(cwd, pattern);
+            if (result) {
+                detected.push(result);
+            }
+        }
+        // Sort by confidence, then prioritize CI/CD over build tools
+        return detected.sort((a, b) => {
+            const order = { high: 3, medium: 2, low: 1 };
+            const confDiff = order[b.confidence] - order[a.confidence];
+            if (confDiff !== 0) {
+                return confDiff;
+            }
+            // Prioritize CI/CD platforms over local build tools
+            const buildTools = ['makefile', 'taskfile', 'justfile'];
+            const aIsBuildTool = buildTools.includes(a.platform);
+            const bIsBuildTool = buildTools.includes(b.platform);
+            if (aIsBuildTool && !bIsBuildTool) {
+                return 1;
+            }
+            if (!aIsBuildTool && bIsBuildTool) {
+                return -1;
+            }
+            return 0;
+        });
+    }
+    async detectCICDPlatform(cwd, pattern) {
+        let confidence = 'low';
+        const workflows = [];
+        for (const configPath of pattern.configPaths) {
+            const fullPath = path.join(cwd, configPath);
+            if (fs.existsSync(fullPath)) {
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    // It's a directory, look for workflow files
+                    try {
+                        const files = fs.readdirSync(fullPath);
+                        for (const file of files) {
+                            if (pattern.workflowPattern) {
+                                if (pattern.workflowPattern.test(file)) {
+                                    workflows.push(path.join(configPath, file));
+                                    confidence = 'high';
+                                }
+                            }
+                            else {
+                                workflows.push(path.join(configPath, file));
+                                confidence = 'high';
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore read errors
+                    }
+                }
+                else {
+                    // It's a file
+                    workflows.push(configPath);
+                    confidence = 'high';
+                }
+            }
+        }
+        if (workflows.length === 0) {
+            return null;
+        }
+        return {
+            platform: pattern.name,
+            workflows,
+            confidence,
+        };
+    }
+    /**
+     * Get all CI/CD workflow files
+     */
+    async getCICDFiles(cwd) {
+        const files = [];
+        const cicdInfo = await this.detectCICD(cwd);
+        for (const info of cicdInfo) {
+            files.push(...info.workflows);
+        }
+        return [...new Set(files)];
+    }
+    /**
+     * Get the primary CI/CD platform
+     */
+    async getPrimaryCICDPlatform(cwd) {
+        const cicdInfo = await this.detectCICD(cwd);
+        // Filter out local build tools
+        const buildTools = ['makefile', 'taskfile', 'justfile'];
+        const platforms = cicdInfo.filter(info => !buildTools.includes(info.platform));
+        if (platforms.length === 0) {
+            return null;
+        }
+        return platforms[0].platform;
+    }
+}
+/**
+ * Create CI/CD scanner instance
+ */
+export function createCICDScanner() {
+    return new CICDScanner();
+}

package/dist/src/scanners/cloud-scanner.js

@@ -0,0 +1,415 @@
+/**
+ * Cloud Scanner
+ *
+ * Detects cloud providers and configurations in a project
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const CLOUD_PATTERNS = [
+    {
+        name: 'aws',
+        displayName: 'Amazon Web Services',
+        configFiles: [
+            '.aws/credentials',
+            '.aws/config',
+            'samconfig.toml',
+            'cdk.json',
+            'serverless.yml',
+            'template.yaml',
+            'buildspec.yml',
+        ],
+        envVarPrefixes: ['AWS_'],
+        sdkPackages: [
+            '@aws-sdk',
+            'aws-sdk',
+            'boto3',
+            'botocore',
+            'aws-cdk-lib',
+            'github.com/aws/aws-sdk-go',
+        ],
+        regions: [
+            'us-east-1',
+            'us-east-2',
+            'us-west-1',
+            'us-west-2',
+            'eu-west-1',
+            'eu-west-2',
+            'eu-west-3',
+            'eu-central-1',
+            'eu-north-1',
+            'ap-southeast-1',
+            'ap-southeast-2',
+            'ap-northeast-1',
+            'ap-northeast-2',
+            'ap-south-1',
+            'sa-east-1',
+            'ca-central-1',
+        ],
+    },
+    {
+        name: 'gcp',
+        displayName: 'Google Cloud Platform',
+        configFiles: ['.gcloud/credentials.json', 'app.yaml', 'cloudbuild.yaml', 'cloudrun.yaml'],
+        envVarPrefixes: ['GOOGLE_', 'GCLOUD_', 'GCP_'],
+        sdkPackages: [
+            '@google-cloud',
+            'google-cloud',
+            'google-api-python-client',
+            'cloud.google.com/go',
+        ],
+        regions: [
+            'us-central1',
+            'us-east1',
+            'us-east4',
+            'us-west1',
+            'us-west2',
+            'europe-west1',
+            'europe-west2',
+            'europe-west3',
+            'europe-west4',
+            'asia-east1',
+            'asia-east2',
+            'asia-northeast1',
+            'asia-southeast1',
+        ],
+    },
+    {
+        name: 'azure',
+        displayName: 'Microsoft Azure',
+        configFiles: ['.azure/credentials', 'azure-pipelines.yml', 'host.json', 'local.settings.json'],
+        envVarPrefixes: ['AZURE_', 'ARM_'],
+        sdkPackages: [
+            '@azure',
+            'azure-sdk',
+            'azure-identity',
+            'azure-mgmt',
+            'github.com/Azure/azure-sdk-for-go',
+        ],
+        regions: [
+            'eastus',
+            'eastus2',
+            'westus',
+            'westus2',
+            'centralus',
+            'westeurope',
+            'northeurope',
+            'uksouth',
+            'ukwest',
+            'southeastasia',
+            'eastasia',
+            'japaneast',
+            'australiaeast',
+        ],
+    },
+    {
+        name: 'digitalocean',
+        displayName: 'DigitalOcean',
+        configFiles: ['.do/app.yaml', 'do.yaml'],
+        envVarPrefixes: ['DIGITALOCEAN_', 'DO_'],
+        sdkPackages: ['digitalocean', 'do-spaces'],
+        regions: [
+            'nyc1',
+            'nyc2',
+            'nyc3',
+            'sfo1',
+            'sfo2',
+            'sfo3',
+            'ams2',
+            'ams3',
+            'sgp1',
+            'lon1',
+            'fra1',
+            'tor1',
+            'blr1',
+        ],
+    },
+    {
+        name: 'heroku',
+        displayName: 'Heroku',
+        configFiles: ['Procfile', 'app.json', 'heroku.yml'],
+        envVarPrefixes: ['HEROKU_'],
+        sdkPackages: [],
+        regions: ['us', 'eu'],
+    },
+    {
+        name: 'vercel',
+        displayName: 'Vercel',
+        configFiles: ['vercel.json', '.vercel/project.json'],
+        envVarPrefixes: ['VERCEL_'],
+        sdkPackages: ['vercel', '@vercel/node'],
+        regions: ['iad1', 'sfo1', 'hnd1', 'cdg1'],
+    },
+    {
+        name: 'netlify',
+        displayName: 'Netlify',
+        configFiles: ['netlify.toml', '.netlify/state.json'],
+        envVarPrefixes: ['NETLIFY_'],
+        sdkPackages: ['netlify', '@netlify/functions'],
+        regions: [],
+    },
+    {
+        name: 'cloudflare',
+        displayName: 'Cloudflare',
+        configFiles: ['wrangler.toml', 'wrangler.json'],
+        envVarPrefixes: ['CLOUDFLARE_', 'CF_'],
+        sdkPackages: ['@cloudflare/workers-types', 'wrangler'],
+        regions: [],
+    },
+    {
+        name: 'fly',
+        displayName: 'Fly.io',
+        configFiles: ['fly.toml'],
+        envVarPrefixes: ['FLY_'],
+        sdkPackages: ['flyctl'],
+        regions: ['iad', 'lax', 'sjc', 'ord', 'dfw', 'sea', 'lhr', 'ams', 'fra', 'sin', 'syd', 'nrt'],
+    },
+    {
+        name: 'render',
+        displayName: 'Render',
+        configFiles: ['render.yaml'],
+        envVarPrefixes: ['RENDER_'],
+        sdkPackages: [],
+        regions: ['oregon', 'ohio', 'virginia', 'frankfurt', 'singapore'],
+    },
+    {
+        name: 'railway',
+        displayName: 'Railway',
+        configFiles: ['railway.json', 'railway.toml'],
+        envVarPrefixes: ['RAILWAY_'],
+        sdkPackages: [],
+        regions: [],
+    },
+];
+export class CloudScanner {
+    name = 'cloud';
+    async scan(cwd, _options) {
+        const cloud = await this.detectCloud(cwd);
+        return {
+            detected: cloud.length > 0,
+            confidence: cloud.length > 0 ? cloud[0].confidence : 'low',
+            details: {
+                cloud,
+            },
+        };
+    }
+    async detectCloud(cwd) {
+        const detected = [];
+        // Load package.json for SDK detection
+        const packageJson = this.loadPackageJson(cwd);
+        const requirements = this.loadRequirements(cwd);
+        const goMod = this.loadGoMod(cwd);
+        const terraformFiles = this.scanTerraformProviders(cwd);
+        for (const pattern of CLOUD_PATTERNS) {
+            const result = await this.detectCloudProvider(cwd, pattern, {
+                packageJson,
+                requirements,
+                goMod,
+                terraformFiles,
+            });
+            if (result) {
+                detected.push(result);
+            }
+        }
+        // Sort by confidence
+        return detected.sort((a, b) => {
+            const order = { high: 3, medium: 2, low: 1 };
+            return order[b.confidence] - order[a.confidence];
+        });
+    }
+    loadPackageJson(cwd) {
+        const packageJsonPath = path.join(cwd, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                return JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    loadRequirements(cwd) {
+        const requirementsPath = path.join(cwd, 'requirements.txt');
+        if (fs.existsSync(requirementsPath)) {
+            try {
+                return fs.readFileSync(requirementsPath, 'utf-8');
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    loadGoMod(cwd) {
+        const goModPath = path.join(cwd, 'go.mod');
+        if (fs.existsSync(goModPath)) {
+            try {
+                return fs.readFileSync(goModPath, 'utf-8');
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    scanTerraformProviders(cwd) {
+        const result = { providers: [], regions: [] };
+        const tfDirs = ['.', 'terraform', 'infra', 'infrastructure'];
+        for (const dir of tfDirs) {
+            const dirPath = path.join(cwd, dir);
+            if (!fs.existsSync(dirPath)) {
+                continue;
+            }
+            try {
+                const files = fs.readdirSync(dirPath);
+                for (const file of files) {
+                    if (file.endsWith('.tf')) {
+                        const content = fs.readFileSync(path.join(dirPath, file), 'utf-8');
+                        // Check for providers
+                        if (content.includes('provider "aws"') ||
+                            content.includes('source = "hashicorp/aws"')) {
+                            if (!result.providers.includes('aws')) {
+                                result.providers.push('aws');
+                            }
+                        }
+                        if (content.includes('provider "google"') ||
+                            content.includes('source = "hashicorp/google"')) {
+                            if (!result.providers.includes('gcp')) {
+                                result.providers.push('gcp');
+                            }
+                        }
+                        if (content.includes('provider "azurerm"') ||
+                            content.includes('source = "hashicorp/azurerm"')) {
+                            if (!result.providers.includes('azure')) {
+                                result.providers.push('azure');
+                            }
+                        }
+                        // Extract regions
+                        const regionMatches = content.match(/region\s*=\s*["']([^"']+)["']/g);
+                        if (regionMatches) {
+                            for (const match of regionMatches) {
+                                const region = match.match(/["']([^"']+)["']/)?.[1];
+                                if (region && !result.regions.includes(region)) {
+                                    result.regions.push(region);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return result;
+    }
+    async detectCloudProvider(cwd, pattern, deps) {
+        let confidence = 'low';
+        const detectedRegions = [];
+        const detectedServices = [];
+        // Check Terraform providers first (highest confidence)
+        if (deps.terraformFiles.providers.includes(pattern.name)) {
+            confidence = 'high';
+            detectedRegions.push(...deps.terraformFiles.regions.filter(r => pattern.regions.includes(r)));
+        }
+        // Check config files
+        for (const configFile of pattern.configFiles) {
+            const configPath = path.join(cwd, configFile);
+            if (fs.existsSync(configPath)) {
+                confidence = 'high';
+                break;
+            }
+        }
+        // Check SDK packages in package.json
+        if (deps.packageJson) {
+            const allDeps = {
+                ...(deps.packageJson.dependencies || {}),
+                ...(deps.packageJson.devDependencies || {}),
+            };
+            for (const pkg of pattern.sdkPackages) {
+                for (const depName of Object.keys(allDeps)) {
+                    if (depName.startsWith(pkg) || depName === pkg) {
+                        if (confidence === 'low') {
+                            confidence = 'medium';
+                        }
+                        detectedServices.push(depName);
+                    }
+                }
+            }
+        }
+        // Check Python requirements
+        if (deps.requirements) {
+            for (const pkg of pattern.sdkPackages) {
+                if (deps.requirements.toLowerCase().includes(pkg.toLowerCase())) {
+                    if (confidence === 'low') {
+                        confidence = 'medium';
+                    }
+                }
+            }
+        }
+        // Check Go modules
+        if (deps.goMod) {
+            for (const pkg of pattern.sdkPackages) {
+                if (deps.goMod.includes(pkg)) {
+                    if (confidence === 'low') {
+                        confidence = 'medium';
+                    }
+                }
+            }
+        }
+        // Check for .env files with cloud env vars
+        const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
+        for (const envFile of envFiles) {
+            const envPath = path.join(cwd, envFile);
+            if (fs.existsSync(envPath)) {
+                try {
+                    const content = fs.readFileSync(envPath, 'utf-8');
+                    for (const prefix of pattern.envVarPrefixes) {
+                        if (content.includes(prefix)) {
+                            if (confidence === 'low') {
+                                confidence = 'medium';
+                            }
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    // Ignore errors
+                }
+            }
+        }
+        if (confidence === 'low') {
+            return null;
+        }
+        return {
+            provider: pattern.name,
+            regions: [...new Set(detectedRegions)],
+            services: [...new Set(detectedServices)],
+            confidence,
+        };
+    }
+    /**
+     * Get all detected cloud providers
+     */
+    async getProviders(cwd) {
+        const cloudInfo = await this.detectCloud(cwd);
+        return cloudInfo.map(info => info.provider);
+    }
+    /**
+     * Get all detected cloud regions
+     */
+    async getRegions(cwd) {
+        const cloudInfo = await this.detectCloud(cwd);
+        const regions = [];
+        for (const info of cloudInfo) {
+            regions.push(...info.regions);
+        }
+        return [...new Set(regions)];
+    }
+}
+/**
+ * Create cloud scanner instance
+ */
+export function createCloudScanner() {
+    return new CloudScanner();
+}