@build-astron-co/nimbus 0.4.1 → 0.4.3

package/src/scanners/language-scanner.ts

@@ -1,276 +0,0 @@
-/**
- * Language Scanner
- *
- * Detects programming languages in a project
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import type { Scanner, ScanResult, ScanOptions, LanguageInfo, ConfidenceLevel } from './types';
-
-interface LanguagePattern {
-  name: string;
-  configFiles: string[];
-  extensions: string[];
-  versionExtractor?: (cwd: string) => string | undefined;
-}
-
-const LANGUAGE_PATTERNS: LanguagePattern[] = [
-  {
-    name: 'typescript',
-    configFiles: ['tsconfig.json', 'tsconfig.base.json'],
-    extensions: ['.ts', '.tsx'],
-    versionExtractor: (cwd: string) => {
-      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: string) => {
-      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: string) => {
-      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: string) => {
-      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: string) => {
-      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: string) => {
-      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 implements Scanner {
-  name = 'language';
-
-  async scan(cwd: string, _options?: ScanOptions): Promise<ScanResult> {
-    const languages = await this.detectLanguages(cwd);
-
-    return {
-      detected: languages.length > 0,
-      confidence: languages.length > 0 ? languages[0].confidence : 'low',
-      details: {
-        languages,
-      },
-    };
-  }
-
-  async detectLanguages(cwd: string): Promise<LanguageInfo[]> {
-    const detected: LanguageInfo[] = [];
-
-    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: Record<ConfidenceLevel, number> = { high: 3, medium: 2, low: 1 };
-      return order[b.confidence] - order[a.confidence];
-    });
-  }
-
-  private async detectLanguage(
-    cwd: string,
-    pattern: LanguagePattern
-  ): Promise<LanguageInfo | null> {
-    const foundFiles: string[] = [];
-    let confidence: ConfidenceLevel = '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(): LanguageScanner {
-  return new LanguageScanner();
-}

package/src/scanners/package-manager-scanner.ts

@@ -1,277 +0,0 @@
-/**
- * Package Manager Scanner
- *
- * Detects package managers used in a project
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import type {
-  Scanner,
-  ScanResult,
-  ScanOptions,
-  PackageManagerInfo,
-  ConfidenceLevel,
-} from './types';
-
-interface PackageManagerPattern {
-  name: string;
-  lockFiles: string[];
-  configFiles: string[];
-  language: string;
-}
-
-const PACKAGE_MANAGER_PATTERNS: PackageManagerPattern[] = [
-  // 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 implements Scanner {
-  name = 'package-manager';
-
-  async scan(cwd: string, _options?: ScanOptions): Promise<ScanResult> {
-    const packageManagers = await this.detectPackageManagers(cwd);
-
-    return {
-      detected: packageManagers.length > 0,
-      confidence: packageManagers.length > 0 ? packageManagers[0].confidence : 'low',
-      details: {
-        packageManagers,
-      },
-    };
-  }
-
-  async detectPackageManagers(cwd: string): Promise<PackageManagerInfo[]> {
-    const detected: PackageManagerInfo[] = [];
-
-    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: Record<ConfidenceLevel, number> = { high: 3, medium: 2, low: 1 };
-      return order[b.confidence] - order[a.confidence];
-    });
-  }
-
-  private async detectPackageManager(
-    cwd: string,
-    pattern: PackageManagerPattern
-  ): Promise<PackageManagerInfo | null> {
-    let confidence: ConfidenceLevel = 'low';
-    let lockFile: string | undefined;
-
-    // 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(): PackageManagerScanner {
-  return new PackageManagerScanner();
-}

package/src/scanners/types.ts

@@ -1,172 +0,0 @@
-/**
- * Scanner Types
- *
- * Type definitions for project scanners
- */
-
-/**
- * Confidence level for detection
- */
-export type ConfidenceLevel = 'high' | 'medium' | 'low';
-
-/**
- * Base scan result for all scanners
- */
-export interface ScanResult {
-  detected: boolean;
-  confidence: ConfidenceLevel;
-  details: Record<string, unknown>;
-}
-
-/**
- * Scanner interface
- */
-export interface Scanner {
-  name: string;
-  scan(cwd: string, options?: ScanOptions): Promise<ScanResult>;
-}
-
-/**
- * Language detection result
- */
-export interface LanguageInfo {
-  name: string;
-  version?: string;
-  confidence: ConfidenceLevel;
-  files: string[];
-}
-
-/**
- * Framework detection result
- */
-export interface FrameworkInfo {
-  name: string;
-  version?: string;
-  confidence: ConfidenceLevel;
-  language: string;
-}
-
-/**
- * Package manager detection result
- */
-export interface PackageManagerInfo {
-  name: string;
-  lockFile?: string;
-  confidence: ConfidenceLevel;
-}
-
-/**
- * Infrastructure as Code detection result
- */
-export interface IaCInfo {
-  name: string;
-  type: 'terraform' | 'pulumi' | 'cdk' | 'cloudformation' | 'ansible' | 'other';
-  files: string[];
-  confidence: ConfidenceLevel;
-}
-
-/**
- * CI/CD detection result
- */
-export interface CICDInfo {
-  platform: string;
-  workflows: string[];
-  confidence: ConfidenceLevel;
-}
-
-/**
- * Cloud provider detection result
- */
-export interface CloudInfo {
-  provider: string;
-  regions: string[];
-  services: string[];
-  confidence: ConfidenceLevel;
-}
-
-/**
- * Git repository info
- */
-export interface GitInfo {
-  isRepo: boolean;
-  remote: string | null;
-  branch: string;
-  hasUncommittedChanges: boolean;
-}
-
-/**
- * Complete project context from scanning
- */
-export interface ProjectContext {
-  project: {
-    name: string;
-    path: string;
-    detected_at: string;
-  };
-  structure: {
-    type: ProjectType;
-    languages: LanguageInfo[];
-    frameworks: FrameworkInfo[];
-    packageManagers: PackageManagerInfo[];
-  };
-  files: {
-    terraform: string[];
-    kubernetes: string[];
-    docker: string[];
-    cicd: string[];
-  };
-  git: GitInfo;
-  cicd: {
-    platform: string | null;
-    workflows: string[];
-  };
-  cloud: {
-    providers: string[];
-    regions: string[];
-  };
-  instructions: string;
-}
-
-/**
- * Project type classification
- */
-export type ProjectType =
-  | 'frontend'
-  | 'backend'
-  | 'fullstack'
-  | 'monorepo'
-  | 'library'
-  | 'infrastructure'
-  | 'mobile'
-  | 'cli'
-  | 'unknown';
-
-/**
- * Scan options
- */
-export interface ScanOptions {
-  /** Scan depth: quick, standard, or deep */
-  depth: 'quick' | 'standard' | 'deep';
-  /** Maximum files to scan per pattern */
-  maxFiles?: number;
-  /** Include hidden directories */
-  includeHidden?: boolean;
-  /** Custom project instructions */
-  instructions?: string;
-  /** Maximum directory depth for scanning */
-  maxDepth?: number;
-}
-
-/**
- * Aggregate scan results from all scanners
- */
-export interface AggregateScanResult {
-  languages: LanguageInfo[];
-  frameworks: FrameworkInfo[];
-  packageManagers: PackageManagerInfo[];
-  iac: IaCInfo[];
-  cicd: CICDInfo[];
-  cloud: CloudInfo[];
-  git: GitInfo;
-  projectType: ProjectType;
-}