wiggum-cli 0.1.0

package/src/scanner/detectors/data/orm.ts

@@ -0,0 +1,180 @@
+/**
+ * ORM Detector
+ * Detects ORMs: Prisma, Drizzle
+ */
+
+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 };
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Detect Prisma
+ */
+function detectPrisma(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @prisma/client
+  if (deps['@prisma/client']) {
+    evidence.push(`@prisma/client@${deps['@prisma/client']} in dependencies`);
+    confidence += 50;
+  }
+
+  // Check for prisma CLI
+  if (deps.prisma) {
+    evidence.push(`prisma@${deps.prisma} in devDependencies`);
+    confidence += 30;
+  }
+
+  // Check for prisma schema file
+  const schemaPath = join(projectRoot, 'prisma', 'schema.prisma');
+  if (existsSync(schemaPath)) {
+    evidence.push('prisma/schema.prisma found');
+    confidence += 30;
+  }
+
+  // Also check for schema in root (less common but valid)
+  const rootSchema = join(projectRoot, 'schema.prisma');
+  if (existsSync(rootSchema)) {
+    evidence.push('schema.prisma found in root');
+    confidence += 20;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Prisma',
+    version: deps['@prisma/client'] || deps.prisma,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Drizzle ORM
+ */
+function detectDrizzle(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for drizzle-orm
+  if (deps['drizzle-orm']) {
+    evidence.push(`drizzle-orm@${deps['drizzle-orm']} in dependencies`);
+    confidence += 60;
+  }
+
+  // Check for drizzle-kit (migration tool)
+  if (deps['drizzle-kit']) {
+    evidence.push(`drizzle-kit@${deps['drizzle-kit']} in dependencies`);
+    confidence += 20;
+  }
+
+  // Check for drizzle config file
+  const configExtensions = ['.config.ts', '.config.js', '.config.mjs'];
+  const configFile = findConfigFile(projectRoot, 'drizzle', configExtensions);
+  if (configFile) {
+    evidence.push(`${configFile} found`);
+    confidence += 20;
+  }
+
+  // Detect database adapter
+  let variant: string | undefined;
+  if (deps['@planetscale/database'] || deps['drizzle-orm/planetscale-serverless']) {
+    variant = 'planetscale';
+  } else if (deps['@neondatabase/serverless']) {
+    variant = 'neon';
+  } else if (deps['@libsql/client'] || deps['better-sqlite3']) {
+    variant = 'sqlite';
+  } else if (deps.pg || deps.postgres) {
+    variant = 'postgres';
+  } else if (deps.mysql2) {
+    variant = 'mysql';
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Drizzle',
+    version: deps['drizzle-orm'],
+    variant,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * ORM detector
+ * Returns the primary ORM detected
+ */
+export const ormDetector: Detector = {
+  category: 'orm',
+  name: 'ORM Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      return null;
+    }
+
+    const deps = getDependencies(pkg);
+
+    // Check both ORMs and return the one with higher confidence
+    const prisma = detectPrisma(projectRoot, deps);
+    const drizzle = detectDrizzle(projectRoot, deps);
+
+    // Return the one with higher confidence, or first one if equal
+    if (prisma && drizzle) {
+      return prisma.confidence >= drizzle.confidence ? prisma : drizzle;
+    }
+
+    if (prisma && prisma.confidence >= 40) {
+      return prisma;
+    }
+
+    if (drizzle && drizzle.confidence >= 40) {
+      return drizzle;
+    }
+
+    return null;
+  },
+};
+
+export default ormDetector;

package/src/scanner/detectors/frontend/formHandling.ts

@@ -0,0 +1,244 @@
+/**
+ * Form Handling Detector
+ * Detects: React Hook Form, Formik, Zod, Yup
+ */
+
+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 };
+}
+
+/**
+ * Detect React Hook Form
+ */
+function detectReactHookForm(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps['react-hook-form']) {
+    evidence.push(`react-hook-form@${deps['react-hook-form']} in dependencies`);
+    confidence += 80;
+  }
+
+  // Check for @hookform/resolvers (validation integrations)
+  if (deps['@hookform/resolvers']) {
+    evidence.push('@hookform/resolvers found');
+    confidence += 10;
+  }
+
+  // Check for @hookform/devtools
+  if (deps['@hookform/devtools']) {
+    evidence.push('@hookform/devtools found');
+    confidence += 5;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'React Hook Form',
+    version: deps['react-hook-form'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Formik
+ */
+function detectFormik(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.formik) {
+    evidence.push(`formik@${deps.formik} in dependencies`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Formik',
+    version: deps.formik,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Zod
+ */
+function detectZod(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.zod) {
+    evidence.push(`zod@${deps.zod} in dependencies`);
+    confidence += 80;
+  }
+
+  // Check for zod-to-json-schema
+  if (deps['zod-to-json-schema']) {
+    evidence.push('zod-to-json-schema found');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Zod',
+    version: deps.zod,
+    variant: 'validation',
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Yup
+ */
+function detectYup(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.yup) {
+    evidence.push(`yup@${deps.yup} in dependencies`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Yup',
+    version: deps.yup,
+    variant: 'validation',
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Valibot (lightweight alternative to Zod)
+ */
+function detectValibot(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.valibot) {
+    evidence.push(`valibot@${deps.valibot} in dependencies`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Valibot',
+    version: deps.valibot,
+    variant: 'validation',
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect TanStack Form
+ */
+function detectTanStackForm(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps['@tanstack/react-form']) {
+    evidence.push(`@tanstack/react-form@${deps['@tanstack/react-form']} in dependencies`);
+    confidence += 80;
+  }
+
+  if (deps['@tanstack/vue-form']) {
+    evidence.push(`@tanstack/vue-form@${deps['@tanstack/vue-form']} in dependencies`);
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'TanStack Form',
+    version: deps['@tanstack/react-form'] || deps['@tanstack/vue-form'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Form handling detector
+ * Returns all detected form/validation libraries (projects often use multiple)
+ */
+export const formHandlingDetector: Detector = {
+  category: 'formHandling',
+  name: 'Form Handling Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult[] | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      return null;
+    }
+
+    const deps = getDependencies(pkg);
+    const results: DetectionResult[] = [];
+
+    // Check form libraries
+    const formDetectors = [
+      () => detectReactHookForm(deps),
+      () => detectFormik(deps),
+      () => detectTanStackForm(deps),
+    ];
+
+    // Check validation libraries
+    const validationDetectors = [
+      () => detectZod(deps),
+      () => detectYup(deps),
+      () => detectValibot(deps),
+    ];
+
+    // Add form libraries
+    for (const detector of formDetectors) {
+      const result = detector();
+      if (result && result.confidence >= 40) {
+        results.push(result);
+      }
+    }
+
+    // Add validation libraries
+    for (const detector of validationDetectors) {
+      const result = detector();
+      if (result && result.confidence >= 40) {
+        results.push(result);
+      }
+    }
+
+    return results.length > 0 ? results : null;
+  },
+};
+
+export default formHandlingDetector;

package/src/scanner/detectors/frontend/stateManagement.ts

@@ -0,0 +1,261 @@
+/**
+ * State Management Detector
+ * Detects: Redux, Zustand, Jotai, Pinia, Recoil, MobX
+ */
+
+import type { Detector, DetectionResult } from '../../types.js';
+import {
+  readPackageJson,
+  getDependencies,
+  type DependencyMap,
+} from '../utils.js';
+
+/**
+ * Detect Redux / Redux Toolkit
+ */
+function detectRedux(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+  let variant: string | undefined;
+
+  // Check for Redux Toolkit (modern approach)
+  if (deps['@reduxjs/toolkit']) {
+    evidence.push(`@reduxjs/toolkit@${deps['@reduxjs/toolkit']} in dependencies`);
+    confidence += 70;
+    variant = 'toolkit';
+  }
+
+  // Check for classic redux
+  if (deps.redux) {
+    evidence.push(`redux@${deps.redux} in dependencies`);
+    confidence += 50;
+    if (!variant) variant = 'classic';
+  }
+
+  // Check for react-redux bindings
+  if (deps['react-redux']) {
+    evidence.push(`react-redux@${deps['react-redux']} in dependencies`);
+    confidence += 20;
+  }
+
+  // Check for redux-saga or redux-thunk
+  if (deps['redux-saga']) {
+    evidence.push('redux-saga detected');
+    confidence += 10;
+  }
+  if (deps['redux-thunk']) {
+    evidence.push('redux-thunk detected');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Redux',
+    version: deps['@reduxjs/toolkit'] || deps.redux,
+    variant,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Zustand
+ */
+function detectZustand(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.zustand) {
+    evidence.push(`zustand@${deps.zustand} in dependencies`);
+    confidence += 90;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Zustand',
+    version: deps.zustand,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Jotai
+ */
+function detectJotai(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.jotai) {
+    evidence.push(`jotai@${deps.jotai} in dependencies`);
+    confidence += 90;
+  }
+
+  // Check for jotai utils
+  if (deps['jotai-devtools']) {
+    evidence.push('jotai-devtools detected');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Jotai',
+    version: deps.jotai,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Pinia (Vue state management)
+ */
+function detectPinia(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.pinia) {
+    evidence.push(`pinia@${deps.pinia} in dependencies`);
+    confidence += 90;
+  }
+
+  // Check for pinia plugins
+  if (deps['pinia-plugin-persistedstate']) {
+    evidence.push('pinia-plugin-persistedstate detected');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Pinia',
+    version: deps.pinia,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Recoil
+ */
+function detectRecoil(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.recoil) {
+    evidence.push(`recoil@${deps.recoil} in dependencies`);
+    confidence += 90;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Recoil',
+    version: deps.recoil,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect MobX
+ */
+function detectMobX(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.mobx) {
+    evidence.push(`mobx@${deps.mobx} in dependencies`);
+    confidence += 70;
+  }
+
+  // Check for mobx-react bindings
+  if (deps['mobx-react'] || deps['mobx-react-lite']) {
+    evidence.push('mobx-react bindings detected');
+    confidence += 20;
+  }
+
+  // Check for mobx-state-tree
+  if (deps['mobx-state-tree']) {
+    evidence.push('mobx-state-tree detected');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'MobX',
+    version: deps.mobx,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Valtio
+ */
+function detectValtio(deps: DependencyMap): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  if (deps.valtio) {
+    evidence.push(`valtio@${deps.valtio} in dependencies`);
+    confidence += 90;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Valtio',
+    version: deps.valtio,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * State management detector
+ * Returns the primary state management solution detected
+ */
+export const stateManagementDetector: Detector = {
+  category: 'stateManagement',
+  name: 'State Management Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      return null;
+    }
+
+    const deps = getDependencies(pkg);
+
+    // Modern/lightweight solutions preferred in detection order
+    const detectors = [
+      () => detectZustand(deps),
+      () => detectJotai(deps),
+      () => detectValtio(deps),
+      () => detectPinia(deps),
+      () => detectRecoil(deps),
+      () => detectRedux(deps),
+      () => detectMobX(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 stateManagementDetector;