wiggum-cli 0.1.0

package/src/scanner/detectors/core/packageManager.ts

@@ -0,0 +1,91 @@
+/**
+ * Package Manager Detector
+ * Detects: pnpm, yarn, bun, npm
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Detector, DetectionResult } from '../../types.js';
+
+interface LockFileInfo {
+  name: string;
+  file: string;
+  confidence: number;
+}
+
+const LOCK_FILES: LockFileInfo[] = [
+  { name: 'pnpm', file: 'pnpm-lock.yaml', confidence: 95 },
+  { name: 'yarn', file: 'yarn.lock', confidence: 95 },
+  { name: 'bun', file: 'bun.lockb', confidence: 95 },
+  { name: 'npm', file: 'package-lock.json', confidence: 95 },
+];
+
+/**
+ * Package manager detector
+ */
+export const packageManagerDetector: Detector = {
+  category: 'packageManager',
+  name: 'Package Manager Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult | null> {
+    const evidence: string[] = [];
+
+    // Check for lock files in order of preference
+    for (const lockFile of LOCK_FILES) {
+      const lockFilePath = join(projectRoot, lockFile.file);
+      if (existsSync(lockFilePath)) {
+        evidence.push(`${lockFile.file} found`);
+
+        return {
+          name: lockFile.name,
+          confidence: lockFile.confidence,
+          evidence,
+        };
+      }
+    }
+
+    // Check for packageManager field in package.json
+    const packageJsonPath = join(projectRoot, 'package.json');
+    if (existsSync(packageJsonPath)) {
+      try {
+        const { readFileSync } = await import('node:fs');
+        const content = readFileSync(packageJsonPath, 'utf-8');
+        const pkg = JSON.parse(content);
+
+        if (pkg.packageManager) {
+          const match = pkg.packageManager.match(/^(pnpm|yarn|npm|bun)@/);
+          if (match) {
+            const manager = match[1];
+            const versionMatch = pkg.packageManager.match(/@([^\s]+)/);
+            evidence.push(`packageManager field: ${pkg.packageManager}`);
+
+            return {
+              name: manager,
+              version: versionMatch ? versionMatch[1] : undefined,
+              confidence: 90,
+              evidence,
+            };
+          }
+        }
+      } catch {
+        // Ignore parse errors
+      }
+    }
+
+    // Check for node_modules (fallback, assume npm)
+    const nodeModulesPath = join(projectRoot, 'node_modules');
+    if (existsSync(nodeModulesPath)) {
+      evidence.push('node_modules exists, no lock file found');
+      return {
+        name: 'npm',
+        confidence: 30, // Low confidence since we're just guessing
+        evidence,
+      };
+    }
+
+    // No package manager detected
+    return null;
+  },
+};
+
+export default packageManagerDetector;

package/src/scanner/detectors/core/styling.ts

@@ -0,0 +1,261 @@
+/**
+ * Styling Detector
+ * Detects: Tailwind, CSS Modules, styled-components, Sass/SCSS
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Detector, DetectionResult } from '../../types.js';
+
+/**
+ * Read and parse package.json from a directory
+ */
+function readPackageJson(projectRoot: string): Record<string, unknown> | null {
+  const packageJsonPath = join(projectRoot, 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(packageJsonPath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get all dependencies from package.json (deps + devDeps)
+ */
+function getDependencies(pkg: Record<string, unknown>): Record<string, string> {
+  const deps = (pkg.dependencies as Record<string, string>) || {};
+  const devDeps = (pkg.devDependencies as Record<string, string>) || {};
+  return { ...deps, ...devDeps };
+}
+
+/**
+ * Check if a config file exists (supports multiple extensions)
+ */
+function findConfigFile(projectRoot: string, baseName: string, extensions: string[]): string | null {
+  for (const ext of extensions) {
+    const filePath = join(projectRoot, `${baseName}${ext}`);
+    if (existsSync(filePath)) {
+      return `${baseName}${ext}`;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if CSS Module files exist in common directories
+ */
+function hasCssModules(projectRoot: string): boolean {
+  const dirsToCheck = ['src', 'app', 'pages', 'components', 'styles'];
+
+  for (const dir of dirsToCheck) {
+    const dirPath = join(projectRoot, dir);
+    if (existsSync(dirPath)) {
+      try {
+        const files = readdirSync(dirPath, { recursive: true });
+        for (const file of files) {
+          const fileName = typeof file === 'string' ? file : file.toString();
+          if (fileName.includes('.module.css') || fileName.includes('.module.scss')) {
+            return true;
+          }
+        }
+      } catch {
+        // Ignore directory read errors
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Detect Tailwind CSS
+ */
+function detectTailwind(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.tailwindcss) {
+    evidence.push(`tailwindcss@${deps.tailwindcss} in dependencies`);
+    confidence += 50;
+  }
+
+  // Check for tailwind config
+  const configExtensions = ['.config.js', '.config.ts', '.config.mjs', '.config.cjs'];
+  const configFile = findConfigFile(projectRoot, 'tailwind', configExtensions);
+  if (configFile) {
+    evidence.push(`${configFile} found`);
+    confidence += 40;
+  }
+
+  // Check for postcss config (often paired with Tailwind)
+  const postcssConfig = findConfigFile(projectRoot, 'postcss.config', ['.js', '.mjs', '.cjs']);
+  if (postcssConfig && deps.tailwindcss) {
+    evidence.push(`${postcssConfig} found`);
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  // Detect Tailwind v4 (uses CSS-based config)
+  let variant: string | undefined;
+  if (deps.tailwindcss) {
+    const version = deps.tailwindcss.replace(/[\^~]/, '');
+    if (version.startsWith('4.')) {
+      variant = 'v4';
+    }
+  }
+
+  return {
+    name: 'Tailwind CSS',
+    version: deps.tailwindcss,
+    variant,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect styled-components
+ */
+function detectStyledComponents(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps['styled-components']) {
+    evidence.push(`styled-components@${deps['styled-components']} in dependencies`);
+    confidence += 80;
+  }
+
+  // Check for babel plugin
+  if (deps['babel-plugin-styled-components']) {
+    evidence.push('babel-plugin-styled-components in dependencies');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'styled-components',
+    version: deps['styled-components'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Emotion
+ */
+function detectEmotion(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps['@emotion/react'] || deps['@emotion/styled']) {
+    const version = deps['@emotion/react'] || deps['@emotion/styled'];
+    evidence.push(`@emotion packages@${version} in dependencies`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Emotion',
+    version: deps['@emotion/react'] || deps['@emotion/styled'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Sass/SCSS
+ */
+function detectSass(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.sass) {
+    evidence.push(`sass@${deps.sass} in dependencies`);
+    confidence += 70;
+  } else if (deps['node-sass']) {
+    evidence.push(`node-sass@${deps['node-sass']} in dependencies`);
+    confidence += 70;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Sass/SCSS',
+    version: deps.sass || deps['node-sass'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect CSS Modules
+ */
+function detectCssModules(projectRoot: string): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (hasCssModules(projectRoot)) {
+    evidence.push('*.module.css or *.module.scss files found');
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'CSS Modules',
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Styling detector
+ * Returns the primary styling approach detected
+ */
+export const stylingDetector: Detector = {
+  category: 'styling',
+  name: 'Styling Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      // Still check for CSS Modules even without package.json
+      return detectCssModules(projectRoot);
+    }
+
+    const deps = getDependencies(pkg);
+
+    // Priority order for styling detection
+    // Tailwind is checked first as it's often the primary styling approach
+    const detectors = [
+      () => detectTailwind(projectRoot, deps),
+      () => detectStyledComponents(projectRoot, deps),
+      () => detectEmotion(projectRoot, deps),
+      () => detectSass(projectRoot, deps),
+      () => detectCssModules(projectRoot),
+    ];
+
+    // Find the highest confidence result
+    let bestResult: DetectionResult | null = null;
+    let bestConfidence = 0;
+
+    for (const detector of detectors) {
+      const result = detector();
+      if (result && result.confidence > bestConfidence) {
+        bestResult = result;
+        bestConfidence = result.confidence;
+      }
+    }
+
+    return bestResult;
+  },
+};
+
+export default stylingDetector;

package/src/scanner/detectors/core/testing.ts

@@ -0,0 +1,221 @@
+/**
+ * Testing Framework Detector
+ * Detects unit testing (Jest, Vitest) and E2E testing (Playwright, Cypress)
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Detector, DetectionResult } from '../../types.js';
+import {
+  readPackageJson,
+  getDependencies,
+  findConfigFile,
+  type PackageJson,
+  type DependencyMap,
+} from '../utils.js';
+
+/**
+ * Detect Vitest
+ */
+function detectVitest(projectRoot: string, deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.vitest) {
+    evidence.push(`vitest@${deps.vitest} in dependencies`);
+    confidence += 60;
+  }
+
+  // Check for vitest config
+  const configExtensions = ['.config.ts', '.config.js', '.config.mts', '.config.mjs'];
+  const configFile = findConfigFile(projectRoot, 'vitest', configExtensions);
+  if (configFile) {
+    evidence.push(`${configFile} found`);
+    confidence += 30;
+  }
+
+  // Vitest can also be configured in vite.config
+  if (!configFile && deps.vitest) {
+    const viteConfig = findConfigFile(projectRoot, 'vite.config', ['.ts', '.js', '.mjs']);
+    if (viteConfig) {
+      evidence.push('Vitest likely configured in vite.config');
+      confidence += 10;
+    }
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Vitest',
+    version: deps.vitest,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Jest
+ */
+function detectJest(projectRoot: string, deps: DependencyMap, pkg: PackageJson): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.jest) {
+    evidence.push(`jest@${deps.jest} in dependencies`);
+    confidence += 50;
+  }
+
+  // Check for jest config files
+  const configExtensions = ['.config.js', '.config.ts', '.config.mjs', '.config.cjs'];
+  const configFile = findConfigFile(projectRoot, 'jest', configExtensions);
+  if (configFile) {
+    evidence.push(`${configFile} found`);
+    confidence += 30;
+  }
+
+  // Check for jest field in package.json
+  if (pkg.jest) {
+    evidence.push('jest config in package.json');
+    confidence += 20;
+  }
+
+  // Check for related packages
+  if (deps['@types/jest']) {
+    evidence.push('@types/jest in dependencies');
+    confidence += 10;
+  }
+  if (deps['ts-jest']) {
+    evidence.push('ts-jest in dependencies');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Jest',
+    version: deps.jest,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Playwright
+ */
+function detectPlaywright(projectRoot: string, deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps['@playwright/test']) {
+    evidence.push(`@playwright/test@${deps['@playwright/test']} in dependencies`);
+    confidence += 60;
+  } else if (deps.playwright) {
+    evidence.push(`playwright@${deps.playwright} in dependencies`);
+    confidence += 50;
+  }
+
+  // Check for playwright config
+  const configExtensions = ['.config.ts', '.config.js', '.config.mjs'];
+  const configFile = findConfigFile(projectRoot, 'playwright', configExtensions);
+  if (configFile) {
+    evidence.push(`${configFile} found`);
+    confidence += 30;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Playwright',
+    version: deps['@playwright/test'] || deps.playwright,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Cypress
+ */
+function detectCypress(projectRoot: string, deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.cypress) {
+    evidence.push(`cypress@${deps.cypress} in dependencies`);
+    confidence += 60;
+  }
+
+  // Check for cypress config
+  const configExtensions = ['.config.ts', '.config.js', '.config.mjs', '.config.cjs'];
+  const configFile = findConfigFile(projectRoot, 'cypress', configExtensions);
+  if (configFile) {
+    evidence.push(`${configFile} found`);
+    confidence += 30;
+  }
+
+  // Check for cypress folder
+  const cypressFolder = join(projectRoot, 'cypress');
+  if (existsSync(cypressFolder)) {
+    evidence.push('cypress/ folder found');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Cypress',
+    version: deps.cypress,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Testing framework detector
+ * Returns both unit and e2e test frameworks
+ */
+export const testingDetector: Detector = {
+  category: 'testing',
+  name: 'Testing Framework Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult[] | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      return null;
+    }
+
+    const deps = getDependencies(pkg);
+    const results: DetectionResult[] = [];
+
+    // Detect unit testing frameworks
+    // Prefer Vitest if both are present (as Vitest is often added later)
+    const vitest = detectVitest(projectRoot, deps);
+    const jest = detectJest(projectRoot, deps, pkg);
+
+    if (vitest && vitest.confidence >= 40) {
+      results.push({ ...vitest, variant: 'unit' });
+    } else if (jest && jest.confidence >= 40) {
+      results.push({ ...jest, variant: 'unit' });
+    }
+
+    // Detect E2E testing frameworks
+    const playwright = detectPlaywright(projectRoot, deps);
+    const cypress = detectCypress(projectRoot, deps);
+
+    // If both are present, include the one with higher confidence
+    if (playwright && cypress) {
+      if (playwright.confidence >= cypress.confidence) {
+        results.push({ ...playwright, variant: 'e2e' });
+      } else {
+        results.push({ ...cypress, variant: 'e2e' });
+      }
+    } else if (playwright && playwright.confidence >= 40) {
+      results.push({ ...playwright, variant: 'e2e' });
+    } else if (cypress && cypress.confidence >= 40) {
+      results.push({ ...cypress, variant: 'e2e' });
+    }
+
+    return results.length > 0 ? results : null;
+  },
+};
+
+export default testingDetector;