wiggum-cli 0.1.0

package/src/scanner/detectors/services/email.ts

@@ -0,0 +1,244 @@
+/**
+ * Email Provider Detector
+ * Detects: Resend, SendGrid, Nodemailer
+ */
+
+import { existsSync, readFileSync } 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 };
+}
+
+/**
+ * Find all matching dependencies by pattern
+ */
+function findMatchingDeps(deps: Record<string, string>, pattern: string): string[] {
+  return Object.keys(deps).filter(name => name.startsWith(pattern));
+}
+
+/**
+ * Detect Resend
+ */
+function detectResend(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.resend) {
+    evidence.push(`resend@${deps.resend} in dependencies`);
+    confidence += 80;
+  }
+
+  // Check for react-email (often used with Resend)
+  if (deps['react-email'] || deps['@react-email/components']) {
+    evidence.push('React Email detected (commonly paired with Resend)');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Resend',
+    version: deps.resend,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect SendGrid
+ */
+function detectSendGrid(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @sendgrid/mail
+  if (deps['@sendgrid/mail']) {
+    evidence.push(`@sendgrid/mail@${deps['@sendgrid/mail']} in dependencies`);
+    confidence += 80;
+  }
+
+  // Check for other SendGrid packages
+  const sendgridPackages = findMatchingDeps(deps, '@sendgrid/');
+  if (sendgridPackages.length > 1) {
+    evidence.push(`Multiple SendGrid packages found: ${sendgridPackages.join(', ')}`);
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'SendGrid',
+    version: deps['@sendgrid/mail'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Nodemailer
+ */
+function detectNodemailer(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.nodemailer) {
+    evidence.push(`nodemailer@${deps.nodemailer} in dependencies`);
+    confidence += 80;
+  }
+
+  // Check for nodemailer types
+  if (deps['@types/nodemailer']) {
+    evidence.push('@types/nodemailer found');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Nodemailer',
+    version: deps.nodemailer,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Postmark
+ */
+function detectPostmark(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.postmark) {
+    evidence.push(`postmark@${deps.postmark} in dependencies`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Postmark',
+    version: deps.postmark,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Mailgun
+ */
+function detectMailgun(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps['mailgun.js'] || deps['mailgun-js']) {
+    const version = deps['mailgun.js'] || deps['mailgun-js'];
+    evidence.push(`Mailgun package@${version} in dependencies`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Mailgun',
+    version: deps['mailgun.js'] || deps['mailgun-js'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect AWS SES
+ */
+function detectAWSSES(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for AWS SDK v3 SES client
+  if (deps['@aws-sdk/client-ses']) {
+    evidence.push(`@aws-sdk/client-ses@${deps['@aws-sdk/client-ses']} in dependencies`);
+    confidence += 80;
+  }
+
+  // Check for AWS SDK v2 (legacy, but still used)
+  if (deps['aws-sdk'] && !deps['@aws-sdk/client-ses']) {
+    evidence.push('aws-sdk found (may include SES)');
+    confidence += 40; // Lower confidence since we can't confirm SES usage
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'AWS SES',
+    version: deps['@aws-sdk/client-ses'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Email provider detector
+ * Returns the primary email provider detected
+ */
+export const emailDetector: Detector = {
+  category: 'email',
+  name: 'Email Provider Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      return null;
+    }
+
+    const deps = getDependencies(pkg);
+
+    // Priority order based on modern usage patterns
+    const detectors = [
+      () => detectResend(deps),
+      () => detectSendGrid(deps),
+      () => detectPostmark(deps),
+      () => detectMailgun(deps),
+      () => detectAWSSES(deps),
+      () => detectNodemailer(deps), // Last as it's often a transport, not a provider
+    ];
+
+    // 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 && bestResult.confidence >= 40 ? bestResult : null;
+  },
+};
+
+export default emailDetector;

package/src/scanner/detectors/services/payments.ts

@@ -0,0 +1,213 @@
+/**
+ * Payments Provider Detector
+ * Detects: Stripe, Lemon Squeezy, Paddle
+ */
+
+import { existsSync, readFileSync } 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 };
+}
+
+/**
+ * Find all matching dependencies by pattern
+ */
+function findMatchingDeps(deps: Record<string, string>, pattern: string): string[] {
+  return Object.keys(deps).filter(name => name.startsWith(pattern));
+}
+
+/**
+ * Detect Stripe
+ */
+function detectStripe(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+  let variant: string | undefined;
+
+  // Check for stripe (Node.js SDK)
+  if (deps.stripe) {
+    evidence.push(`stripe@${deps.stripe} in dependencies`);
+    confidence += 70;
+    variant = 'server';
+  }
+
+  // Check for @stripe/* packages
+  const stripePackages = findMatchingDeps(deps, '@stripe/');
+  if (stripePackages.length > 0) {
+    evidence.push(`Stripe packages found: ${stripePackages.join(', ')}`);
+    confidence += 20;
+
+    if (deps['@stripe/stripe-js']) {
+      variant = variant === 'server' ? 'full-stack' : 'client';
+    }
+    if (deps['@stripe/react-stripe-js']) {
+      evidence.push('React Stripe.js integration detected');
+      confidence += 10;
+    }
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Stripe',
+    version: deps.stripe || deps['@stripe/stripe-js'],
+    variant,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Lemon Squeezy
+ */
+function detectLemonSqueezy(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @lemonsqueezy/* packages
+  const lsPackages = findMatchingDeps(deps, '@lemonsqueezy/');
+  if (lsPackages.length > 0) {
+    evidence.push(`Lemon Squeezy packages found: ${lsPackages.join(', ')}`);
+    confidence += 80;
+  }
+
+  // Check for lemonsqueezy.js
+  if (deps['lemonsqueezy.js']) {
+    evidence.push(`lemonsqueezy.js@${deps['lemonsqueezy.js']} in dependencies`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Lemon Squeezy',
+    version: deps['@lemonsqueezy/lemonsqueezy.js'] || deps['lemonsqueezy.js'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Paddle
+ */
+function detectPaddle(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @paddle/* packages
+  const paddlePackages = findMatchingDeps(deps, '@paddle/');
+  if (paddlePackages.length > 0) {
+    evidence.push(`Paddle packages found: ${paddlePackages.join(', ')}`);
+    confidence += 80;
+  }
+
+  // Check for paddle-sdk
+  if (deps['paddle-sdk']) {
+    evidence.push(`paddle-sdk@${deps['paddle-sdk']} in dependencies`);
+    confidence += 70;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Paddle',
+    version: deps['@paddle/paddle-js'] || deps['paddle-sdk'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect PayPal
+ */
+function detectPayPal(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @paypal/* packages
+  const paypalPackages = findMatchingDeps(deps, '@paypal/');
+  if (paypalPackages.length > 0) {
+    evidence.push(`PayPal packages found: ${paypalPackages.join(', ')}`);
+    confidence += 80;
+  }
+
+  // Check for paypal-rest-sdk
+  if (deps['paypal-rest-sdk']) {
+    evidence.push(`paypal-rest-sdk@${deps['paypal-rest-sdk']} in dependencies`);
+    confidence += 70;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'PayPal',
+    version: deps['@paypal/paypal-js'] || deps['paypal-rest-sdk'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Payments provider detector
+ * Returns the primary payment provider detected
+ */
+export const paymentsDetector: Detector = {
+  category: 'payments',
+  name: 'Payments Provider Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      return null;
+    }
+
+    const deps = getDependencies(pkg);
+
+    // Priority order based on popularity
+    const detectors = [
+      () => detectStripe(deps),
+      () => detectLemonSqueezy(deps),
+      () => detectPaddle(deps),
+      () => detectPayPal(deps),
+    ];
+
+    // 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 && bestResult.confidence >= 40 ? bestResult : null;
+  },
+};
+
+export default paymentsDetector;

package/src/scanner/detectors/utils.ts

@@ -0,0 +1,251 @@
+/**
+ * Shared Utilities for Detectors
+ * Common functions used across multiple detector files
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Package.json type definition
+ */
+export type PackageJson = Record<string, unknown>;
+
+/**
+ * Dependencies map type
+ */
+export type DependencyMap = Record<string, string>;
+
+/**
+ * Read and parse package.json from a directory
+ *
+ * @param projectRoot - The root directory of the project
+ * @returns Parsed package.json object or null if not found/invalid
+ *
+ * @example
+ * const pkg = readPackageJson('/path/to/project');
+ * if (pkg) {
+ *   console.log(pkg.name);
+ * }
+ */
+export function readPackageJson(projectRoot: string): PackageJson | 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 combined)
+ *
+ * @param pkg - Parsed package.json object
+ * @returns Combined dependencies and devDependencies map
+ *
+ * @example
+ * const pkg = readPackageJson(projectRoot);
+ * const deps = getDependencies(pkg);
+ * if (deps.react) {
+ *   console.log(`React version: ${deps.react}`);
+ * }
+ */
+export function getDependencies(pkg: PackageJson | null): DependencyMap {
+  if (!pkg) return {};
+  const deps = (pkg.dependencies as DependencyMap) || {};
+  const devDeps = (pkg.devDependencies as DependencyMap) || {};
+  return { ...deps, ...devDeps };
+}
+
+/**
+ * Find a config file with various possible extensions
+ *
+ * @param projectRoot - The root directory of the project
+ * @param baseName - The base name of the config file (e.g., 'next.config')
+ * @param extensions - Array of extensions to try (e.g., ['.js', '.ts', '.mjs'])
+ * @returns The full filename if found, or null
+ *
+ * @example
+ * const configFile = findConfigFile(projectRoot, 'next.config', ['.js', '.mjs', '.ts']);
+ * if (configFile) {
+ *   console.log(`Found: ${configFile}`);
+ * }
+ */
+export 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 a directory exists
+ *
+ * @param projectRoot - The root directory of the project
+ * @param dirName - The directory name to check
+ * @returns True if the directory exists
+ *
+ * @example
+ * if (checkDirectoryExists(projectRoot, 'src')) {
+ *   console.log('Source directory found');
+ * }
+ */
+export function checkDirectoryExists(projectRoot: string, dirName: string): boolean {
+  return existsSync(join(projectRoot, dirName));
+}
+
+/**
+ * Check if a file exists
+ *
+ * @param projectRoot - The root directory of the project
+ * @param fileName - The file name to check
+ * @returns True if the file exists
+ *
+ * @example
+ * if (checkFileExists(projectRoot, 'vercel.json')) {
+ *   console.log('Vercel config found');
+ * }
+ */
+export function checkFileExists(projectRoot: string, fileName: string): boolean {
+  return existsSync(join(projectRoot, fileName));
+}
+
+/**
+ * Find all dependencies matching a prefix pattern
+ *
+ * @param deps - Dependencies map
+ * @param pattern - Prefix pattern to match (e.g., '@supabase/')
+ * @returns Array of matching dependency names
+ *
+ * @example
+ * const supabasePackages = findMatchingDeps(deps, '@supabase/');
+ * // Returns: ['@supabase/supabase-js', '@supabase/ssr', ...]
+ */
+export function findMatchingDeps(deps: DependencyMap, pattern: string): string[] {
+  return Object.keys(deps).filter(
+    (name) => name.startsWith(pattern) || name === pattern
+  );
+}
+
+/**
+ * Check if any dependency matches a pattern and return its version
+ *
+ * @param deps - Dependencies map
+ * @param pattern - Prefix pattern to match
+ * @returns Version string if found, undefined otherwise
+ *
+ * @example
+ * const version = hasDependencyPattern(deps, '@supabase/');
+ * if (version) {
+ *   console.log(`Found supabase package: ${version}`);
+ * }
+ */
+export function hasDependencyPattern(
+  deps: DependencyMap,
+  pattern: string
+): string | undefined {
+  for (const [name, version] of Object.entries(deps)) {
+    if (name.startsWith(pattern) || name === pattern) {
+      return version;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Read file content safely
+ *
+ * @param filePath - Full path to the file
+ * @returns File content as string, or null if read fails
+ *
+ * @example
+ * const content = readFileSafe('/path/to/config.json');
+ * if (content) {
+ *   const config = JSON.parse(content);
+ * }
+ */
+export function readFileSafe(filePath: string): string | null {
+  try {
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    return readFileSync(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse JSON file safely
+ *
+ * @param projectRoot - The root directory of the project
+ * @param fileName - The JSON file name
+ * @returns Parsed JSON object or null if invalid
+ *
+ * @example
+ * const config = parseJsonFile(projectRoot, 'tsconfig.json');
+ * if (config?.compilerOptions) {
+ *   console.log('TypeScript config found');
+ * }
+ */
+export function parseJsonFile(
+  projectRoot: string,
+  fileName: string
+): Record<string, unknown> | null {
+  try {
+    const filePath = join(projectRoot, fileName);
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    const content = readFileSync(filePath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Common config file extensions
+ */
+export const CONFIG_EXTENSIONS = {
+  /** JavaScript/TypeScript config extensions */
+  JS_TS: ['.js', '.ts', '.mjs', '.cjs'],
+  /** JSON/YAML config extensions */
+  DATA: ['.json', '.yaml', '.yml', '.toml'],
+  /** All common config extensions */
+  ALL: ['.js', '.ts', '.mjs', '.cjs', '.json', '.yaml', '.yml', '.toml'],
+};
+
+/**
+ * Get npm scripts from package.json
+ *
+ * @param pkg - Parsed package.json object
+ * @returns Scripts object or empty object
+ */
+export function getScripts(pkg: PackageJson | null): Record<string, string> {
+  if (!pkg) return {};
+  return (pkg.scripts as Record<string, string>) || {};
+}
+
+/**
+ * Check if a specific npm script exists
+ *
+ * @param pkg - Parsed package.json object
+ * @param scriptName - Name of the script to check
+ * @returns True if the script exists
+ */
+export function hasScript(pkg: PackageJson | null, scriptName: string): boolean {
+  const scripts = getScripts(pkg);
+  return scriptName in scripts;
+}