@build-astron-co/nimbus 0.2.0

package/src/scanners/language-scanner.ts

@@ -0,0 +1,276 @@
+/**
+ * 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

@@ -0,0 +1,277 @@
+/**
+ * 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

@@ -0,0 +1,172 @@
+/**
+ * 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;
+}