@build-astron-co/nimbus 0.2.0 → 0.4.0

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

@@ -0,0 +1,258 @@
+/**
+ * Language Scanner
+ *
+ * Detects programming languages in a project
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const LANGUAGE_PATTERNS = [
+    {
+        name: 'typescript',
+        configFiles: ['tsconfig.json', 'tsconfig.base.json'],
+        extensions: ['.ts', '.tsx'],
+        versionExtractor: (cwd) => {
+            const tsconfigPath = path.join(cwd, 'tsconfig.json');
+            if (fs.existsSync(tsconfigPath)) {
+                try {
+                    const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, 'utf-8'));
+                    return tsconfig.compilerOptions?.target;
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return undefined;
+        },
+    },
+    {
+        name: 'javascript',
+        configFiles: ['package.json', 'jsconfig.json'],
+        extensions: ['.js', '.jsx', '.mjs', '.cjs'],
+    },
+    {
+        name: 'python',
+        configFiles: ['requirements.txt', 'pyproject.toml', 'setup.py', 'Pipfile', 'setup.cfg'],
+        extensions: ['.py', '.pyw', '.pyi'],
+        versionExtractor: (cwd) => {
+            const pyprojectPath = path.join(cwd, 'pyproject.toml');
+            if (fs.existsSync(pyprojectPath)) {
+                try {
+                    const content = fs.readFileSync(pyprojectPath, 'utf-8');
+                    const match = content.match(/requires-python\s*=\s*["']([^"']+)["']/);
+                    return match ? match[1] : undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return undefined;
+        },
+    },
+    {
+        name: 'go',
+        configFiles: ['go.mod', 'go.sum'],
+        extensions: ['.go'],
+        versionExtractor: (cwd) => {
+            const goModPath = path.join(cwd, 'go.mod');
+            if (fs.existsSync(goModPath)) {
+                try {
+                    const content = fs.readFileSync(goModPath, 'utf-8');
+                    const match = content.match(/^go\s+(\d+\.\d+)/m);
+                    return match ? match[1] : undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return undefined;
+        },
+    },
+    {
+        name: 'rust',
+        configFiles: ['Cargo.toml', 'Cargo.lock'],
+        extensions: ['.rs'],
+        versionExtractor: (cwd) => {
+            const cargoPath = path.join(cwd, 'Cargo.toml');
+            if (fs.existsSync(cargoPath)) {
+                try {
+                    const content = fs.readFileSync(cargoPath, 'utf-8');
+                    const match = content.match(/rust-version\s*=\s*["']([^"']+)["']/);
+                    return match ? match[1] : undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return undefined;
+        },
+    },
+    {
+        name: 'java',
+        configFiles: ['pom.xml', 'build.gradle', 'build.gradle.kts', 'settings.gradle'],
+        extensions: ['.java'],
+    },
+    {
+        name: 'kotlin',
+        configFiles: ['build.gradle.kts'],
+        extensions: ['.kt', '.kts'],
+    },
+    {
+        name: 'swift',
+        configFiles: ['Package.swift', '*.xcodeproj', '*.xcworkspace'],
+        extensions: ['.swift'],
+    },
+    {
+        name: 'ruby',
+        configFiles: ['Gemfile', 'Gemfile.lock', '*.gemspec'],
+        extensions: ['.rb', '.rake'],
+        versionExtractor: (cwd) => {
+            const rubyVersionPath = path.join(cwd, '.ruby-version');
+            if (fs.existsSync(rubyVersionPath)) {
+                try {
+                    return fs.readFileSync(rubyVersionPath, 'utf-8').trim();
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return undefined;
+        },
+    },
+    {
+        name: 'php',
+        configFiles: ['composer.json', 'composer.lock'],
+        extensions: ['.php'],
+        versionExtractor: (cwd) => {
+            const composerPath = path.join(cwd, 'composer.json');
+            if (fs.existsSync(composerPath)) {
+                try {
+                    const composer = JSON.parse(fs.readFileSync(composerPath, 'utf-8'));
+                    return composer.require?.php?.replace(/[^0-9.]/g, '');
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return undefined;
+        },
+    },
+    {
+        name: 'csharp',
+        configFiles: ['*.csproj', '*.sln'],
+        extensions: ['.cs'],
+    },
+    {
+        name: 'scala',
+        configFiles: ['build.sbt', 'build.sc'],
+        extensions: ['.scala', '.sc'],
+    },
+    {
+        name: 'elixir',
+        configFiles: ['mix.exs'],
+        extensions: ['.ex', '.exs'],
+    },
+    {
+        name: 'haskell',
+        configFiles: ['*.cabal', 'stack.yaml'],
+        extensions: ['.hs', '.lhs'],
+    },
+    {
+        name: 'lua',
+        configFiles: ['.luacheckrc', 'rockspec'],
+        extensions: ['.lua'],
+    },
+    {
+        name: 'dart',
+        configFiles: ['pubspec.yaml'],
+        extensions: ['.dart'],
+    },
+];
+export class LanguageScanner {
+    name = 'language';
+    async scan(cwd, _options) {
+        const languages = await this.detectLanguages(cwd);
+        return {
+            detected: languages.length > 0,
+            confidence: languages.length > 0 ? languages[0].confidence : 'low',
+            details: {
+                languages,
+            },
+        };
+    }
+    async detectLanguages(cwd) {
+        const detected = [];
+        for (const pattern of LANGUAGE_PATTERNS) {
+            const result = await this.detectLanguage(cwd, pattern);
+            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];
+        });
+    }
+    async detectLanguage(cwd, pattern) {
+        const foundFiles = [];
+        let confidence = 'low';
+        // Check for config files
+        for (const configFile of pattern.configFiles) {
+            if (configFile.includes('*')) {
+                // Glob pattern - simple check for directory existence
+                const parts = configFile.split('*');
+                const dir = path.join(cwd, parts[0]);
+                if (fs.existsSync(dir)) {
+                    foundFiles.push(configFile);
+                    confidence = 'high';
+                }
+            }
+            else {
+                const filePath = path.join(cwd, configFile);
+                if (fs.existsSync(filePath)) {
+                    foundFiles.push(configFile);
+                    confidence = 'high';
+                }
+            }
+        }
+        // Quick extension check in common directories
+        const dirsToCheck = ['src', 'lib', 'app', 'pkg', 'internal', 'cmd', '.'];
+        for (const dir of dirsToCheck) {
+            const dirPath = path.join(cwd, dir);
+            if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+                try {
+                    const files = fs.readdirSync(dirPath).slice(0, 20); // Limit for performance
+                    for (const file of files) {
+                        const ext = path.extname(file);
+                        if (pattern.extensions.includes(ext)) {
+                            foundFiles.push(path.join(dir, file));
+                            if (confidence === 'low') {
+                                confidence = 'medium';
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore read errors
+                }
+            }
+        }
+        if (foundFiles.length === 0) {
+            return null;
+        }
+        // Extract version if available
+        const version = pattern.versionExtractor?.(cwd);
+        return {
+            name: pattern.name,
+            version,
+            confidence,
+            files: foundFiles.slice(0, 10), // Limit files reported
+        };
+    }
+}
+/**
+ * Create language scanner instance
+ */
+export function createLanguageScanner() {
+    return new LanguageScanner();
+}

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

@@ -0,0 +1,252 @@
+/**
+ * Package Manager Scanner
+ *
+ * Detects package managers used in a project
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const PACKAGE_MANAGER_PATTERNS = [
+    // JavaScript/TypeScript
+    {
+        name: 'npm',
+        lockFiles: ['package-lock.json'],
+        configFiles: ['.npmrc'],
+        language: 'javascript',
+    },
+    {
+        name: 'yarn',
+        lockFiles: ['yarn.lock'],
+        configFiles: ['.yarnrc', '.yarnrc.yml'],
+        language: 'javascript',
+    },
+    {
+        name: 'pnpm',
+        lockFiles: ['pnpm-lock.yaml'],
+        configFiles: ['.pnpmrc', 'pnpm-workspace.yaml'],
+        language: 'javascript',
+    },
+    {
+        name: 'bun',
+        lockFiles: ['bun.lockb'],
+        configFiles: ['bunfig.toml'],
+        language: 'javascript',
+    },
+    // Python
+    {
+        name: 'pip',
+        lockFiles: [],
+        configFiles: ['requirements.txt', 'requirements-dev.txt'],
+        language: 'python',
+    },
+    {
+        name: 'pipenv',
+        lockFiles: ['Pipfile.lock'],
+        configFiles: ['Pipfile'],
+        language: 'python',
+    },
+    {
+        name: 'poetry',
+        lockFiles: ['poetry.lock'],
+        configFiles: ['pyproject.toml'],
+        language: 'python',
+    },
+    {
+        name: 'uv',
+        lockFiles: ['uv.lock'],
+        configFiles: ['pyproject.toml'],
+        language: 'python',
+    },
+    {
+        name: 'conda',
+        lockFiles: ['conda-lock.yml'],
+        configFiles: ['environment.yml', 'environment.yaml'],
+        language: 'python',
+    },
+    // Go
+    {
+        name: 'go-modules',
+        lockFiles: ['go.sum'],
+        configFiles: ['go.mod'],
+        language: 'go',
+    },
+    // Rust
+    {
+        name: 'cargo',
+        lockFiles: ['Cargo.lock'],
+        configFiles: ['Cargo.toml'],
+        language: 'rust',
+    },
+    // Ruby
+    {
+        name: 'bundler',
+        lockFiles: ['Gemfile.lock'],
+        configFiles: ['Gemfile'],
+        language: 'ruby',
+    },
+    // PHP
+    {
+        name: 'composer',
+        lockFiles: ['composer.lock'],
+        configFiles: ['composer.json'],
+        language: 'php',
+    },
+    // Java
+    {
+        name: 'maven',
+        lockFiles: [],
+        configFiles: ['pom.xml'],
+        language: 'java',
+    },
+    {
+        name: 'gradle',
+        lockFiles: ['gradle.lockfile'],
+        configFiles: ['build.gradle', 'build.gradle.kts', 'settings.gradle'],
+        language: 'java',
+    },
+    // .NET
+    {
+        name: 'nuget',
+        lockFiles: ['packages.lock.json'],
+        configFiles: ['*.csproj', 'nuget.config'],
+        language: 'csharp',
+    },
+    // Swift
+    {
+        name: 'swift-pm',
+        lockFiles: ['Package.resolved'],
+        configFiles: ['Package.swift'],
+        language: 'swift',
+    },
+    // Dart
+    {
+        name: 'pub',
+        lockFiles: ['pubspec.lock'],
+        configFiles: ['pubspec.yaml'],
+        language: 'dart',
+    },
+    // Elixir
+    {
+        name: 'mix',
+        lockFiles: ['mix.lock'],
+        configFiles: ['mix.exs'],
+        language: 'elixir',
+    },
+    // Haskell
+    {
+        name: 'stack',
+        lockFiles: ['stack.yaml.lock'],
+        configFiles: ['stack.yaml'],
+        language: 'haskell',
+    },
+    {
+        name: 'cabal',
+        lockFiles: ['cabal.project.freeze'],
+        configFiles: ['*.cabal'],
+        language: 'haskell',
+    },
+];
+export class PackageManagerScanner {
+    name = 'package-manager';
+    async scan(cwd, _options) {
+        const packageManagers = await this.detectPackageManagers(cwd);
+        return {
+            detected: packageManagers.length > 0,
+            confidence: packageManagers.length > 0 ? packageManagers[0].confidence : 'low',
+            details: {
+                packageManagers,
+            },
+        };
+    }
+    async detectPackageManagers(cwd) {
+        const detected = [];
+        for (const pattern of PACKAGE_MANAGER_PATTERNS) {
+            const result = await this.detectPackageManager(cwd, pattern);
+            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];
+        });
+    }
+    async detectPackageManager(cwd, pattern) {
+        let confidence = 'low';
+        let lockFile;
+        // Check for lock files first (highest confidence)
+        for (const file of pattern.lockFiles) {
+            const filePath = path.join(cwd, file);
+            if (fs.existsSync(filePath)) {
+                confidence = 'high';
+                lockFile = file;
+                break;
+            }
+        }
+        // Check for config files
+        if (confidence !== 'high') {
+            for (const file of pattern.configFiles) {
+                if (file.includes('*')) {
+                    // Glob pattern - simple check
+                    const extension = file.replace('*', '');
+                    try {
+                        const files = fs.readdirSync(cwd);
+                        if (files.some(f => f.endsWith(extension))) {
+                            confidence = 'medium';
+                            break;
+                        }
+                    }
+                    catch {
+                        // Ignore errors
+                    }
+                }
+                else {
+                    const filePath = path.join(cwd, file);
+                    if (fs.existsSync(filePath)) {
+                        // Special handling for pyproject.toml - need to check for poetry section
+                        if (file === 'pyproject.toml' && pattern.name === 'poetry') {
+                            try {
+                                const content = fs.readFileSync(filePath, 'utf-8');
+                                if (content.includes('[tool.poetry]')) {
+                                    confidence = 'high';
+                                }
+                            }
+                            catch {
+                                // Ignore errors
+                            }
+                        }
+                        else if (file === 'pyproject.toml' && pattern.name === 'uv') {
+                            try {
+                                const content = fs.readFileSync(filePath, 'utf-8');
+                                if (content.includes('[tool.uv]')) {
+                                    confidence = 'high';
+                                }
+                            }
+                            catch {
+                                // Ignore errors
+                            }
+                        }
+                        else {
+                            confidence = confidence === 'low' ? 'medium' : confidence;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        if (confidence === 'low') {
+            return null;
+        }
+        return {
+            name: pattern.name,
+            lockFile,
+            confidence,
+        };
+    }
+}
+/**
+ * Create package manager scanner instance
+ */
+export function createPackageManagerScanner() {
+    return new PackageManagerScanner();
+}

package/dist/src/scanners/types.js

@@ -0,0 +1,6 @@
+/**
+ * Scanner Types
+ *
+ * Type definitions for project scanners
+ */
+export {};