wiggum-cli 0.1.0

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

@@ -0,0 +1,273 @@
+/**
+ * Analytics Detector
+ * Detects: PostHog, Mixpanel, Vercel Analytics, Google Analytics
+ */
+
+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 PostHog
+ */
+function detectPostHog(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+  let variant: string | undefined;
+
+  // Check for posthog-js (browser)
+  if (deps['posthog-js']) {
+    evidence.push(`posthog-js@${deps['posthog-js']} in dependencies`);
+    confidence += 80;
+    variant = 'browser';
+  }
+
+  // Check for posthog-node (server)
+  if (deps['posthog-node']) {
+    evidence.push(`posthog-node@${deps['posthog-node']} in dependencies`);
+    confidence += 80;
+    variant = variant ? 'full-stack' : 'server';
+  }
+
+  // Check for Next.js specific package
+  if (deps['posthog-react']) {
+    evidence.push('posthog-react found');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'PostHog',
+    version: deps['posthog-js'] || deps['posthog-node'],
+    variant,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Mixpanel
+ */
+function detectMixpanel(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for mixpanel packages
+  const mixpanelPackages = findMatchingDeps(deps, 'mixpanel');
+  if (mixpanelPackages.length > 0) {
+    evidence.push(`Mixpanel packages found: ${mixpanelPackages.join(', ')}`);
+    confidence += 80;
+  }
+
+  // Check for @mixpanel/* packages
+  const mixpanelScopedPackages = findMatchingDeps(deps, '@mixpanel/');
+  if (mixpanelScopedPackages.length > 0) {
+    evidence.push(`@mixpanel packages found: ${mixpanelScopedPackages.join(', ')}`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Mixpanel',
+    version: deps.mixpanel || deps['mixpanel-browser'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Vercel Analytics
+ */
+function detectVercelAnalytics(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps['@vercel/analytics']) {
+    evidence.push(`@vercel/analytics@${deps['@vercel/analytics']} in dependencies`);
+    confidence += 80;
+  }
+
+  // Check for @vercel/speed-insights (often used together)
+  if (deps['@vercel/speed-insights']) {
+    evidence.push('@vercel/speed-insights found');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Vercel Analytics',
+    version: deps['@vercel/analytics'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Google Analytics
+ */
+function detectGoogleAnalytics(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for various GA packages
+  if (deps['@google-analytics/data']) {
+    evidence.push('@google-analytics/data found');
+    confidence += 70;
+  }
+
+  if (deps['react-ga4'] || deps['react-ga']) {
+    evidence.push('React GA package found');
+    confidence += 70;
+  }
+
+  if (deps['ga-4-react']) {
+    evidence.push('ga-4-react found');
+    confidence += 70;
+  }
+
+  // Check for gtag
+  if (deps.gtag) {
+    evidence.push('gtag found');
+    confidence += 60;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Google Analytics',
+    version: deps['react-ga4'] || deps['@google-analytics/data'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Amplitude
+ */
+function detectAmplitude(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @amplitude/* packages
+  const amplitudePackages = findMatchingDeps(deps, '@amplitude/');
+  if (amplitudePackages.length > 0) {
+    evidence.push(`Amplitude packages found: ${amplitudePackages.join(', ')}`);
+    confidence += 80;
+  }
+
+  // Check for amplitude-js
+  if (deps['amplitude-js']) {
+    evidence.push(`amplitude-js@${deps['amplitude-js']} in dependencies`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Amplitude',
+    version: deps['@amplitude/analytics-browser'] || deps['amplitude-js'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Plausible
+ */
+function detectPlausible(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps['plausible-tracker']) {
+    evidence.push(`plausible-tracker@${deps['plausible-tracker']} in dependencies`);
+    confidence += 80;
+  }
+
+  if (deps['next-plausible']) {
+    evidence.push('next-plausible found');
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Plausible',
+    version: deps['plausible-tracker'] || deps['next-plausible'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Analytics detector
+ * Returns all detected analytics solutions (projects often use multiple)
+ */
+export const analyticsDetector: Detector = {
+  category: 'analytics',
+  name: 'Analytics Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult[] | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      return null;
+    }
+
+    const deps = getDependencies(pkg);
+    const results: DetectionResult[] = [];
+
+    const detectors = [
+      () => detectPostHog(deps),
+      () => detectMixpanel(deps),
+      () => detectVercelAnalytics(deps),
+      () => detectGoogleAnalytics(deps),
+      () => detectAmplitude(deps),
+      () => detectPlausible(deps),
+    ];
+
+    for (const detector of detectors) {
+      const result = detector();
+      if (result && result.confidence >= 40) {
+        results.push(result);
+      }
+    }
+
+    return results.length > 0 ? results : null;
+  },
+};
+
+export default analyticsDetector;

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

@@ -0,0 +1,254 @@
+/**
+ * Auth Provider Detector
+ * Detects: NextAuth, Clerk, Auth0, Supabase Auth
+ */
+
+import type { Detector, DetectionResult } from '../../types.js';
+import {
+  readPackageJson,
+  getDependencies,
+  findMatchingDeps,
+  type DependencyMap,
+} from '../utils.js';
+
+/**
+ * Detect NextAuth.js / Auth.js
+ */
+function detectNextAuth(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+  let variant: string | undefined;
+
+  // Check for next-auth (v4 and below)
+  if (deps['next-auth']) {
+    evidence.push(`next-auth@${deps['next-auth']} in dependencies`);
+    confidence += 80;
+    variant = 'v4';
+  }
+
+  // Check for @auth/* packages (Auth.js v5+)
+  const authPackages = findMatchingDeps(deps, '@auth/');
+  if (authPackages.length > 0) {
+    evidence.push(`Auth.js packages found: ${authPackages.join(', ')}`);
+    confidence += 80;
+    variant = 'v5';
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'NextAuth.js',
+    version: deps['next-auth'] || deps['@auth/core'],
+    variant,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Clerk
+ */
+function detectClerk(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @clerk/* packages
+  const clerkPackages = findMatchingDeps(deps, '@clerk/');
+  if (clerkPackages.length > 0) {
+    const mainVersion = deps['@clerk/nextjs'] || deps['@clerk/clerk-react'] || deps['@clerk/express'];
+    evidence.push(`Clerk packages found: ${clerkPackages.join(', ')}`);
+    confidence += 80;
+
+    // Detect framework variant
+    let variant: string | undefined;
+    if (deps['@clerk/nextjs']) {
+      variant = 'nextjs';
+    } else if (deps['@clerk/clerk-react']) {
+      variant = 'react';
+    } else if (deps['@clerk/express']) {
+      variant = 'express';
+    }
+
+    return {
+      name: 'Clerk',
+      version: mainVersion,
+      variant,
+      confidence: Math.min(confidence, 100),
+      evidence,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Detect Auth0
+ */
+function detectAuth0(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+  let variant: string | undefined;
+
+  // Check for @auth0/* packages
+  const auth0Packages = findMatchingDeps(deps, '@auth0/');
+  if (auth0Packages.length > 0) {
+    evidence.push(`Auth0 packages found: ${auth0Packages.join(', ')}`);
+    confidence += 70;
+
+    if (deps['@auth0/nextjs-auth0']) {
+      variant = 'nextjs';
+      confidence += 10;
+    } else if (deps['@auth0/auth0-react']) {
+      variant = 'react';
+      confidence += 10;
+    }
+  }
+
+  // Check for auth0 package
+  if (deps.auth0) {
+    evidence.push(`auth0@${deps.auth0} in dependencies`);
+    confidence += 60;
+    variant = 'node';
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Auth0',
+    version: deps['@auth0/nextjs-auth0'] || deps['@auth0/auth0-react'] || deps.auth0,
+    variant,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Supabase Auth
+ */
+function detectSupabaseAuth(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @supabase/auth-helpers-* packages
+  const authHelperPackages = findMatchingDeps(deps, '@supabase/auth-helpers-');
+  if (authHelperPackages.length > 0) {
+    evidence.push(`Supabase auth helpers found: ${authHelperPackages.join(', ')}`);
+    confidence += 70;
+  }
+
+  // Check for @supabase/ssr (newer auth approach)
+  if (deps['@supabase/ssr']) {
+    evidence.push(`@supabase/ssr@${deps['@supabase/ssr']} in dependencies`);
+    confidence += 70;
+  }
+
+  // Check for @supabase/auth-ui-react
+  if (deps['@supabase/auth-ui-react']) {
+    evidence.push('@supabase/auth-ui-react found');
+    confidence += 20;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Supabase Auth',
+    version: deps['@supabase/ssr'] || authHelperPackages[0] ? deps[authHelperPackages[0]] : undefined,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Lucia Auth
+ */
+function detectLucia(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.lucia) {
+    evidence.push(`lucia@${deps.lucia} in dependencies`);
+    confidence += 80;
+  }
+
+  // Check for @lucia-auth/* adapters
+  const luciaPackages = findMatchingDeps(deps, '@lucia-auth/');
+  if (luciaPackages.length > 0) {
+    evidence.push(`Lucia adapters found: ${luciaPackages.join(', ')}`);
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Lucia',
+    version: deps.lucia,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Better Auth
+ */
+function detectBetterAuth(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps['better-auth']) {
+    evidence.push(`better-auth@${deps['better-auth']} in dependencies`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Better Auth',
+    version: deps['better-auth'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Auth provider detector
+ * Returns the primary auth solution detected
+ */
+export const authDetector: Detector = {
+  category: 'auth',
+  name: 'Auth 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/comprehensiveness
+    const detectors = [
+      () => detectClerk(deps),
+      () => detectNextAuth(deps),
+      () => detectAuth0(deps),
+      () => detectLucia(deps),
+      () => detectBetterAuth(deps),
+      () => detectSupabaseAuth(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 authDetector;