wiggum-cli 0.1.0

package/src/scanner/index.ts

@@ -0,0 +1,354 @@
+/**
+ * Scanner Orchestrator
+ * Main entry point for project scanning
+ */
+
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { createDefaultRegistry, DetectorRegistry } from './registry.js';
+import type { ScanResult, ScannerOptions, DetectedStack, DetectionResult } from './types.js';
+
+// Re-export types
+export type {
+  DetectionResult,
+  DetectedStack,
+  MCPStack,
+  DetectorCategory,
+  Detector,
+  ScannerOptions,
+  ScanResult,
+} from './types.js';
+
+// Re-export registry
+export { DetectorRegistry, createDefaultRegistry } from './registry.js';
+
+/**
+ * Scanner class
+ * Orchestrates detection of project tech stack
+ */
+export class Scanner {
+  private registry: DetectorRegistry;
+  private options: ScannerOptions;
+
+  constructor(options: ScannerOptions = {}) {
+    this.registry = createDefaultRegistry();
+    this.options = {
+      includeLowConfidence: false,
+      minConfidence: 40,
+      ...options,
+    };
+  }
+
+  /**
+   * Scan a project directory and detect its tech stack
+   */
+  async scan(projectRoot: string): Promise<ScanResult> {
+    const startTime = Date.now();
+    const errors: string[] = [];
+
+    // Resolve to absolute path
+    const absolutePath = resolve(projectRoot);
+
+    // Validate project root exists
+    if (!existsSync(absolutePath)) {
+      throw new Error(`Project root does not exist: ${absolutePath}`);
+    }
+
+    // Run all detectors
+    let stack: DetectedStack;
+    try {
+      stack = await this.registry.runAllDetectors(absolutePath);
+    } catch (error) {
+      errors.push(`Detection error: ${error instanceof Error ? error.message : String(error)}`);
+      stack = {};
+    }
+
+    // Filter by confidence threshold if configured
+    if (!this.options.includeLowConfidence && this.options.minConfidence) {
+      stack = this.filterByConfidence(stack, this.options.minConfidence);
+    }
+
+    const scanTime = Date.now() - startTime;
+
+    return {
+      projectRoot: absolutePath,
+      stack,
+      scanTime,
+      errors: errors.length > 0 ? errors : undefined,
+    };
+  }
+
+  /**
+   * Filter array of detection results by confidence
+   */
+  private filterArrayByConfidence(
+    results: DetectionResult[] | undefined,
+    minConfidence: number
+  ): DetectionResult[] | undefined {
+    if (!results) return undefined;
+    const filtered = results.filter(r => r.confidence >= minConfidence);
+    return filtered.length > 0 ? filtered : undefined;
+  }
+
+  /**
+   * Filter stack results by minimum confidence
+   */
+  private filterByConfidence(stack: DetectedStack, minConfidence: number): DetectedStack {
+    const filtered: DetectedStack = {};
+
+    // Core
+    if (stack.framework && stack.framework.confidence >= minConfidence) {
+      filtered.framework = stack.framework;
+    }
+
+    if (stack.packageManager && stack.packageManager.confidence >= minConfidence) {
+      filtered.packageManager = stack.packageManager;
+    }
+
+    if (stack.testing) {
+      const testing: DetectedStack['testing'] = {};
+      if (stack.testing.unit && stack.testing.unit.confidence >= minConfidence) {
+        testing.unit = stack.testing.unit;
+      }
+      if (stack.testing.e2e && stack.testing.e2e.confidence >= minConfidence) {
+        testing.e2e = stack.testing.e2e;
+      }
+      if (testing.unit || testing.e2e) {
+        filtered.testing = testing;
+      }
+    }
+
+    if (stack.styling && stack.styling.confidence >= minConfidence) {
+      filtered.styling = stack.styling;
+    }
+
+    // Data Layer
+    if (stack.database && stack.database.confidence >= minConfidence) {
+      filtered.database = stack.database;
+    }
+
+    if (stack.orm && stack.orm.confidence >= minConfidence) {
+      filtered.orm = stack.orm;
+    }
+
+    filtered.api = this.filterArrayByConfidence(stack.api, minConfidence);
+
+    // Frontend
+    if (stack.stateManagement && stack.stateManagement.confidence >= minConfidence) {
+      filtered.stateManagement = stack.stateManagement;
+    }
+
+    filtered.uiComponents = this.filterArrayByConfidence(stack.uiComponents, minConfidence);
+    filtered.formHandling = this.filterArrayByConfidence(stack.formHandling, minConfidence);
+
+    // Services
+    if (stack.auth && stack.auth.confidence >= minConfidence) {
+      filtered.auth = stack.auth;
+    }
+
+    filtered.analytics = this.filterArrayByConfidence(stack.analytics, minConfidence);
+
+    if (stack.payments && stack.payments.confidence >= minConfidence) {
+      filtered.payments = stack.payments;
+    }
+
+    if (stack.email && stack.email.confidence >= minConfidence) {
+      filtered.email = stack.email;
+    }
+
+    // Infrastructure
+    filtered.deployment = this.filterArrayByConfidence(stack.deployment, minConfidence);
+
+    if (stack.monorepo && stack.monorepo.confidence >= minConfidence) {
+      filtered.monorepo = stack.monorepo;
+    }
+
+    // MCP (keep as-is since it has its own structure)
+    if (stack.mcp) {
+      filtered.mcp = stack.mcp;
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Get the detector registry for custom detector registration
+   */
+  getRegistry(): DetectorRegistry {
+    return this.registry;
+  }
+}
+
+/**
+ * Convenience function to scan a project
+ */
+export async function scanProject(projectRoot: string, options?: ScannerOptions): Promise<ScanResult> {
+  const scanner = new Scanner(options);
+  return scanner.scan(projectRoot);
+}
+
+/**
+ * Helper to format a single detection result
+ */
+function formatDetection(label: string, result: DetectionResult | undefined, indent = ''): string[] {
+  const lines: string[] = [];
+  if (result) {
+    const version = result.version ? `@${result.version}` : '';
+    const variant = result.variant ? ` (${result.variant})` : '';
+    lines.push(`${indent}${label}: ${result.name}${version}${variant} [${result.confidence}%]`);
+    lines.push(`${indent}  Evidence: ${result.evidence.join(', ')}`);
+  }
+  return lines;
+}
+
+/**
+ * Helper to format an array of detection results
+ */
+function formatDetectionArray(label: string, results: DetectionResult[] | undefined, indent = ''): string[] {
+  const lines: string[] = [];
+  if (results && results.length > 0) {
+    lines.push(`${indent}${label}:`);
+    for (const result of results) {
+      const version = result.version ? `@${result.version}` : '';
+      const variant = result.variant ? ` (${result.variant})` : '';
+      lines.push(`${indent}  - ${result.name}${version}${variant} [${result.confidence}%]`);
+    }
+  }
+  return lines;
+}
+
+/**
+ * Format a scan result for display
+ */
+export function formatScanResult(result: ScanResult): string {
+  const lines: string[] = [];
+  const { stack } = result;
+
+  lines.push(`Project: ${result.projectRoot}`);
+  lines.push(`Scan time: ${result.scanTime}ms`);
+  lines.push('');
+
+  // ============ Core ============
+  lines.push('=== Core ===');
+
+  if (stack.framework) {
+    lines.push(...formatDetection('Framework', stack.framework));
+  } else {
+    lines.push('Framework: Not detected');
+  }
+
+  if (stack.packageManager) {
+    lines.push(...formatDetection('Package Manager', stack.packageManager));
+  } else {
+    lines.push('Package Manager: Not detected');
+  }
+
+  if (stack.testing) {
+    if (stack.testing.unit) {
+      lines.push(...formatDetection('Unit Testing', stack.testing.unit));
+    }
+    if (stack.testing.e2e) {
+      lines.push(...formatDetection('E2E Testing', stack.testing.e2e));
+    }
+  }
+
+  if (stack.styling) {
+    lines.push(...formatDetection('Styling', stack.styling));
+  }
+
+  // ============ Data Layer ============
+  if (stack.database || stack.orm || stack.api) {
+    lines.push('');
+    lines.push('=== Data Layer ===');
+
+    if (stack.database) {
+      lines.push(...formatDetection('Database', stack.database));
+    }
+
+    if (stack.orm) {
+      lines.push(...formatDetection('ORM', stack.orm));
+    }
+
+    lines.push(...formatDetectionArray('API Patterns', stack.api));
+  }
+
+  // ============ Frontend ============
+  if (stack.stateManagement || stack.uiComponents || stack.formHandling) {
+    lines.push('');
+    lines.push('=== Frontend ===');
+
+    if (stack.stateManagement) {
+      lines.push(...formatDetection('State Management', stack.stateManagement));
+    }
+
+    lines.push(...formatDetectionArray('UI Components', stack.uiComponents));
+    lines.push(...formatDetectionArray('Form Handling', stack.formHandling));
+  }
+
+  // ============ Services ============
+  if (stack.auth || stack.analytics || stack.payments || stack.email) {
+    lines.push('');
+    lines.push('=== Services ===');
+
+    if (stack.auth) {
+      lines.push(...formatDetection('Auth', stack.auth));
+    }
+
+    lines.push(...formatDetectionArray('Analytics', stack.analytics));
+
+    if (stack.payments) {
+      lines.push(...formatDetection('Payments', stack.payments));
+    }
+
+    if (stack.email) {
+      lines.push(...formatDetection('Email', stack.email));
+    }
+  }
+
+  // ============ Infrastructure ============
+  if (stack.deployment || stack.monorepo) {
+    lines.push('');
+    lines.push('=== Infrastructure ===');
+
+    lines.push(...formatDetectionArray('Deployment', stack.deployment));
+
+    if (stack.monorepo) {
+      lines.push(...formatDetection('Monorepo', stack.monorepo));
+    }
+  }
+
+  // ============ MCP ============
+  if (stack.mcp) {
+    lines.push('');
+    lines.push('=== MCP ===');
+
+    if (stack.mcp.isProject) {
+      lines.push('Type: MCP Server Project');
+      if (stack.mcp.projectInfo) {
+        lines.push(...formatDetection('Project Info', stack.mcp.projectInfo, '  '));
+      }
+    }
+
+    if (stack.mcp.detected && stack.mcp.detected.length > 0) {
+      lines.push('Configured MCP Servers:');
+      for (const server of stack.mcp.detected) {
+        lines.push(`  - ${server.name}`);
+      }
+    }
+
+    if (stack.mcp.recommended && stack.mcp.recommended.length > 0) {
+      lines.push(`Recommended MCP Servers: ${stack.mcp.recommended.join(', ')}`);
+    }
+  }
+
+  // ============ Errors ============
+  if (result.errors && result.errors.length > 0) {
+    lines.push('');
+    lines.push('Errors:');
+    for (const error of result.errors) {
+      lines.push(`  - ${error}`);
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/scanner/registry.ts

@@ -0,0 +1,301 @@
+/**
+ * Detector Registry
+ * Registers and manages all detectors for the scanner
+ */
+
+import type { Detector, DetectorCategory, DetectionResult, DetectedStack, MCPStack } from './types.js';
+
+// Import core detectors
+import { frameworkDetector } from './detectors/core/framework.js';
+import { packageManagerDetector } from './detectors/core/packageManager.js';
+import { testingDetector } from './detectors/core/testing.js';
+import { stylingDetector } from './detectors/core/styling.js';
+
+// Import data layer detectors
+import { databaseDetector } from './detectors/data/database.js';
+import { ormDetector } from './detectors/data/orm.js';
+import { apiDetector } from './detectors/data/api.js';
+
+// Import frontend detectors
+import { stateManagementDetector } from './detectors/frontend/stateManagement.js';
+import { uiComponentsDetector } from './detectors/frontend/uiComponents.js';
+import { formHandlingDetector } from './detectors/frontend/formHandling.js';
+
+// Import services detectors
+import { authDetector } from './detectors/services/auth.js';
+import { analyticsDetector } from './detectors/services/analytics.js';
+import { paymentsDetector } from './detectors/services/payments.js';
+import { emailDetector } from './detectors/services/email.js';
+
+// Import infrastructure detectors
+import { deploymentDetector } from './detectors/infra/deployment.js';
+import { monorepoDetector } from './detectors/infra/monorepo.js';
+
+// Import MCP detectors
+import { mcpServersDetector, getRecommendedMCPServers } from './detectors/mcp/mcpServers.js';
+import { mcpProjectDetector } from './detectors/mcp/mcpProject.js';
+
+/**
+ * All detector categories
+ */
+const ALL_CATEGORIES: DetectorCategory[] = [
+  // Core
+  'framework',
+  'packageManager',
+  'testing',
+  'styling',
+  // Data Layer
+  'database',
+  'orm',
+  'api',
+  // Frontend
+  'stateManagement',
+  'uiComponents',
+  'formHandling',
+  // Services
+  'auth',
+  'analytics',
+  'payments',
+  'email',
+  // Infrastructure
+  'deployment',
+  'monorepo',
+  // MCP
+  'mcp',
+];
+
+/**
+ * Detector Registry class
+ * Manages registration and execution of detectors
+ */
+export class DetectorRegistry {
+  private detectors: Map<DetectorCategory, Detector[]> = new Map();
+
+  constructor() {
+    // Initialize all categories
+    for (const category of ALL_CATEGORIES) {
+      this.detectors.set(category, []);
+    }
+  }
+
+  /**
+   * Register a detector
+   */
+  register(detector: Detector): void {
+    const category = this.detectors.get(detector.category);
+    if (category) {
+      category.push(detector);
+    }
+  }
+
+  /**
+   * Get all detectors for a category
+   */
+  getDetectors(category: DetectorCategory): Detector[] {
+    return this.detectors.get(category) || [];
+  }
+
+  /**
+   * Get all registered detectors
+   */
+  getAllDetectors(): Detector[] {
+    const all: Detector[] = [];
+    for (const detectors of this.detectors.values()) {
+      all.push(...detectors);
+    }
+    return all;
+  }
+
+  /**
+   * Run a single-result detector category
+   */
+  private async runSingleDetector(
+    projectRoot: string,
+    category: DetectorCategory
+  ): Promise<DetectionResult | null> {
+    for (const detector of this.getDetectors(category)) {
+      const result = await detector.detect(projectRoot);
+      if (result && !Array.isArray(result)) {
+        return result;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Run a multi-result detector category
+   */
+  private async runMultiDetector(
+    projectRoot: string,
+    category: DetectorCategory
+  ): Promise<DetectionResult[] | null> {
+    for (const detector of this.getDetectors(category)) {
+      const result = await detector.detect(projectRoot);
+      if (result) {
+        return Array.isArray(result) ? result : [result];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Run all detectors for a project
+   */
+  async runAllDetectors(projectRoot: string): Promise<DetectedStack> {
+    const stack: DetectedStack = {};
+
+    // ============ Core ============
+
+    // Run framework detector
+    stack.framework = await this.runSingleDetector(projectRoot, 'framework') || undefined;
+
+    // Run package manager detector
+    stack.packageManager = await this.runSingleDetector(projectRoot, 'packageManager') || undefined;
+
+    // Run testing detectors
+    for (const detector of this.getDetectors('testing')) {
+      const result = await detector.detect(projectRoot);
+      if (result) {
+        stack.testing = {};
+        if (Array.isArray(result)) {
+          for (const r of result) {
+            if (r.variant === 'unit') {
+              stack.testing.unit = r;
+            } else if (r.variant === 'e2e') {
+              stack.testing.e2e = r;
+            }
+          }
+        } else {
+          // Single result, determine type from name
+          if (result.name === 'Jest' || result.name === 'Vitest') {
+            stack.testing.unit = result;
+          } else {
+            stack.testing.e2e = result;
+          }
+        }
+        break;
+      }
+    }
+
+    // Run styling detector
+    stack.styling = await this.runSingleDetector(projectRoot, 'styling') || undefined;
+
+    // ============ Data Layer ============
+
+    // Run database detector
+    stack.database = await this.runSingleDetector(projectRoot, 'database') || undefined;
+
+    // Run ORM detector
+    stack.orm = await this.runSingleDetector(projectRoot, 'orm') || undefined;
+
+    // Run API detector (multi-result)
+    stack.api = await this.runMultiDetector(projectRoot, 'api') || undefined;
+
+    // ============ Frontend ============
+
+    // Run state management detector
+    stack.stateManagement = await this.runSingleDetector(projectRoot, 'stateManagement') || undefined;
+
+    // Run UI components detector (multi-result)
+    stack.uiComponents = await this.runMultiDetector(projectRoot, 'uiComponents') || undefined;
+
+    // Run form handling detector (multi-result)
+    stack.formHandling = await this.runMultiDetector(projectRoot, 'formHandling') || undefined;
+
+    // ============ Services ============
+
+    // Run auth detector
+    stack.auth = await this.runSingleDetector(projectRoot, 'auth') || undefined;
+
+    // Run analytics detector (multi-result)
+    stack.analytics = await this.runMultiDetector(projectRoot, 'analytics') || undefined;
+
+    // Run payments detector
+    stack.payments = await this.runSingleDetector(projectRoot, 'payments') || undefined;
+
+    // Run email detector
+    stack.email = await this.runSingleDetector(projectRoot, 'email') || undefined;
+
+    // ============ Infrastructure ============
+
+    // Run deployment detector (multi-result)
+    stack.deployment = await this.runMultiDetector(projectRoot, 'deployment') || undefined;
+
+    // Run monorepo detector
+    stack.monorepo = await this.runSingleDetector(projectRoot, 'monorepo') || undefined;
+
+    // ============ MCP ============
+
+    // Run MCP detectors
+    const mcpStack: MCPStack = {};
+
+    // Detect configured MCP servers
+    const mcpServers = await this.runMultiDetector(projectRoot, 'mcp');
+
+    // Separate MCP server configs from MCP project detection
+    if (mcpServers) {
+      const serverConfigs = mcpServers.filter(r => r.name.startsWith('MCP:') || r.name === 'MCP Config Directory');
+      const projectInfo = mcpServers.find(r => r.name === 'MCP Server Project' || r.name === 'MCP Client');
+
+      if (serverConfigs.length > 0) {
+        mcpStack.detected = serverConfigs;
+      }
+
+      if (projectInfo) {
+        mcpStack.isProject = projectInfo.name === 'MCP Server Project';
+        mcpStack.projectInfo = projectInfo;
+      }
+    }
+
+    // Get recommended MCP servers based on stack
+    mcpStack.recommended = getRecommendedMCPServers(projectRoot);
+
+    // Only add MCP stack if there's meaningful data
+    if (mcpStack.detected || mcpStack.isProject || (mcpStack.recommended && mcpStack.recommended.length > 0)) {
+      stack.mcp = mcpStack;
+    }
+
+    return stack;
+  }
+}
+
+/**
+ * Create a registry with all core detectors pre-registered
+ */
+export function createDefaultRegistry(): DetectorRegistry {
+  const registry = new DetectorRegistry();
+
+  // Register core detectors
+  registry.register(frameworkDetector);
+  registry.register(packageManagerDetector);
+  registry.register(testingDetector);
+  registry.register(stylingDetector);
+
+  // Register data layer detectors
+  registry.register(databaseDetector);
+  registry.register(ormDetector);
+  registry.register(apiDetector);
+
+  // Register frontend detectors
+  registry.register(stateManagementDetector);
+  registry.register(uiComponentsDetector);
+  registry.register(formHandlingDetector);
+
+  // Register services detectors
+  registry.register(authDetector);
+  registry.register(analyticsDetector);
+  registry.register(paymentsDetector);
+  registry.register(emailDetector);
+
+  // Register infrastructure detectors
+  registry.register(deploymentDetector);
+  registry.register(monorepoDetector);
+
+  // Register MCP detectors
+  registry.register(mcpServersDetector);
+  registry.register(mcpProjectDetector);
+
+  return registry;
+}
+
+export { DetectorRegistry as Registry };