wiggum-cli 0.1.0

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

@@ -0,0 +1,303 @@
+/**
+ * API Pattern Detector
+ * Detects: tRPC, GraphQL, TanStack Query, REST patterns
+ */
+
+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 };
+}
+
+/**
+ * Find all matching dependencies by pattern
+ */
+function findMatchingDeps(deps: Record<string, string>, pattern: string): string[] {
+  return Object.keys(deps).filter(name => name.startsWith(pattern) || name === pattern);
+}
+
+/**
+ * Detect tRPC
+ */
+function detectTRPC(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @trpc/* packages
+  const trpcPackages = findMatchingDeps(deps, '@trpc/');
+  if (trpcPackages.length > 0) {
+    const mainVersion = deps['@trpc/server'] || deps['@trpc/client'];
+    evidence.push(`tRPC packages found: ${trpcPackages.join(', ')}`);
+    confidence += 70;
+
+    // Check for specific packages
+    if (deps['@trpc/server'] && deps['@trpc/client']) {
+      confidence += 20;
+    }
+    if (deps['@trpc/react-query'] || deps['@trpc/next']) {
+      evidence.push('tRPC React/Next integration detected');
+      confidence += 10;
+    }
+
+    return {
+      name: 'tRPC',
+      version: mainVersion,
+      confidence: Math.min(confidence, 100),
+      evidence,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Detect GraphQL
+ */
+function detectGraphQL(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for graphql package
+  if (deps.graphql) {
+    evidence.push(`graphql@${deps.graphql} in dependencies`);
+    confidence += 40;
+  }
+
+  // Check for Apollo packages
+  const apolloPackages = findMatchingDeps(deps, '@apollo/');
+  if (apolloPackages.length > 0) {
+    evidence.push(`Apollo packages found: ${apolloPackages.join(', ')}`);
+    confidence += 40;
+
+    return {
+      name: 'GraphQL',
+      version: deps.graphql,
+      variant: 'apollo',
+      confidence: Math.min(confidence, 100),
+      evidence,
+    };
+  }
+
+  // Check for urql
+  if (deps.urql || deps['@urql/core']) {
+    evidence.push('urql client detected');
+    confidence += 40;
+
+    return {
+      name: 'GraphQL',
+      version: deps.graphql,
+      variant: 'urql',
+      confidence: Math.min(confidence, 100),
+      evidence,
+    };
+  }
+
+  // Check for relay
+  if (deps['react-relay'] || deps['relay-runtime']) {
+    evidence.push('Relay detected');
+    confidence += 40;
+
+    return {
+      name: 'GraphQL',
+      version: deps.graphql,
+      variant: 'relay',
+      confidence: Math.min(confidence, 100),
+      evidence,
+    };
+  }
+
+  // Check for schema files
+  const schemaFiles = ['schema.graphql', 'schema.gql'];
+  for (const file of schemaFiles) {
+    if (existsSync(join(projectRoot, file))) {
+      evidence.push(`${file} found`);
+      confidence += 20;
+    }
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'GraphQL',
+    version: deps.graphql,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect TanStack Query (React Query, Vue Query)
+ */
+function detectTanStackQuery(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+  let variant: string | undefined;
+
+  // Check for @tanstack/react-query
+  if (deps['@tanstack/react-query']) {
+    evidence.push(`@tanstack/react-query@${deps['@tanstack/react-query']} in dependencies`);
+    confidence += 80;
+    variant = 'react';
+  }
+
+  // Check for @tanstack/vue-query
+  if (deps['@tanstack/vue-query']) {
+    evidence.push(`@tanstack/vue-query@${deps['@tanstack/vue-query']} in dependencies`);
+    confidence += 80;
+    variant = 'vue';
+  }
+
+  // Check for @tanstack/svelte-query
+  if (deps['@tanstack/svelte-query']) {
+    evidence.push(`@tanstack/svelte-query@${deps['@tanstack/svelte-query']} in dependencies`);
+    confidence += 80;
+    variant = 'svelte';
+  }
+
+  // Check for old react-query package (v3)
+  if (deps['react-query']) {
+    evidence.push(`react-query@${deps['react-query']} in dependencies (legacy)`);
+    confidence += 70;
+    variant = 'react-legacy';
+  }
+
+  // Check for devtools
+  if (deps['@tanstack/react-query-devtools'] || deps['@tanstack/vue-query-devtools']) {
+    evidence.push('TanStack Query devtools detected');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  const version = deps['@tanstack/react-query'] || deps['@tanstack/vue-query'] ||
+                  deps['@tanstack/svelte-query'] || deps['react-query'];
+
+  return {
+    name: 'TanStack Query',
+    version,
+    variant,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect REST patterns (axios, fetch wrappers)
+ */
+function detectREST(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+  let variant: string | undefined;
+
+  // Check for axios
+  if (deps.axios) {
+    evidence.push(`axios@${deps.axios} in dependencies`);
+    confidence += 60;
+    variant = 'axios';
+  }
+
+  // Check for ky (modern fetch wrapper)
+  if (deps.ky) {
+    evidence.push(`ky@${deps.ky} in dependencies`);
+    confidence += 60;
+    variant = 'ky';
+  }
+
+  // Check for got (Node.js HTTP client)
+  if (deps.got) {
+    evidence.push(`got@${deps.got} in dependencies`);
+    confidence += 50;
+    variant = 'got';
+  }
+
+  // Check for node-fetch
+  if (deps['node-fetch']) {
+    evidence.push(`node-fetch@${deps['node-fetch']} in dependencies`);
+    confidence += 40;
+    variant = 'node-fetch';
+  }
+
+  // Check for SWR (while not strictly REST, often used with REST)
+  if (deps.swr) {
+    evidence.push(`swr@${deps.swr} in dependencies`);
+    confidence += 50;
+    variant = 'swr';
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'REST',
+    version: deps.axios || deps.ky || deps.got || deps['node-fetch'] || deps.swr,
+    variant,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * API pattern detector
+ * Returns all detected API patterns
+ */
+export const apiDetector: Detector = {
+  category: 'api',
+  name: 'API Pattern Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult[] | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      return null;
+    }
+
+    const deps = getDependencies(pkg);
+    const results: DetectionResult[] = [];
+
+    // Detect all API patterns (project can use multiple)
+    const trpc = detectTRPC(projectRoot, deps);
+    if (trpc && trpc.confidence >= 40) {
+      results.push(trpc);
+    }
+
+    const graphql = detectGraphQL(projectRoot, deps);
+    if (graphql && graphql.confidence >= 40) {
+      results.push(graphql);
+    }
+
+    const tanstack = detectTanStackQuery(projectRoot, deps);
+    if (tanstack && tanstack.confidence >= 40) {
+      results.push(tanstack);
+    }
+
+    const rest = detectREST(projectRoot, deps);
+    if (rest && rest.confidence >= 40) {
+      results.push(rest);
+    }
+
+    return results.length > 0 ? results : null;
+  },
+};
+
+export default apiDetector;

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

@@ -0,0 +1,245 @@
+/**
+ * Database Detector
+ * Detects databases: Supabase, Firebase, MongoDB, PostgreSQL
+ */
+
+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 any dependency matches a pattern
+ */
+function hasDependencyPattern(deps: Record<string, string>, pattern: string): string | undefined {
+  for (const [name, version] of Object.entries(deps)) {
+    if (name.startsWith(pattern) || name === pattern) {
+      return version;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Find all matching dependencies by pattern
+ */
+function findMatchingDeps(deps: Record<string, string>, pattern: string): string[] {
+  return Object.keys(deps).filter(name => name.startsWith(pattern) || name === pattern);
+}
+
+/**
+ * Detect Supabase
+ */
+function detectSupabase(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @supabase/* packages
+  if (deps['@supabase/supabase-js']) {
+    evidence.push(`@supabase/supabase-js@${deps['@supabase/supabase-js']} in dependencies`);
+    confidence += 70;
+  }
+
+  const supabasePackages = findMatchingDeps(deps, '@supabase/');
+  if (supabasePackages.length > 1) {
+    evidence.push(`Multiple @supabase packages found: ${supabasePackages.join(', ')}`);
+    confidence += 10;
+  }
+
+  // Check for supabase directory
+  const supabaseDir = join(projectRoot, 'supabase');
+  if (existsSync(supabaseDir)) {
+    evidence.push('supabase/ directory found');
+    confidence += 20;
+  }
+
+  // Check for supabase config
+  const configPath = join(supabaseDir, 'config.toml');
+  if (existsSync(configPath)) {
+    evidence.push('supabase/config.toml found');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Supabase',
+    version: deps['@supabase/supabase-js'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Firebase
+ */
+function detectFirebase(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for firebase package
+  if (deps.firebase) {
+    evidence.push(`firebase@${deps.firebase} in dependencies`);
+    confidence += 70;
+  }
+
+  // Check for @firebase/* packages
+  const firebasePackages = findMatchingDeps(deps, '@firebase/');
+  if (firebasePackages.length > 0) {
+    evidence.push(`Firebase packages found: ${firebasePackages.slice(0, 3).join(', ')}${firebasePackages.length > 3 ? '...' : ''}`);
+    confidence += 20;
+  }
+
+  // Check for firebase admin
+  if (deps['firebase-admin']) {
+    evidence.push(`firebase-admin@${deps['firebase-admin']} in dependencies`);
+    confidence += 20;
+  }
+
+  // Check for firebase.json config
+  const firebaseConfig = join(projectRoot, 'firebase.json');
+  if (existsSync(firebaseConfig)) {
+    evidence.push('firebase.json found');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Firebase',
+    version: deps.firebase || deps['firebase-admin'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect MongoDB (via mongoose or mongodb driver)
+ */
+function detectMongoDB(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for mongoose (ODM)
+  if (deps.mongoose) {
+    evidence.push(`mongoose@${deps.mongoose} in dependencies`);
+    confidence += 80;
+    return {
+      name: 'MongoDB',
+      version: deps.mongoose,
+      variant: 'mongoose',
+      confidence: Math.min(confidence, 100),
+      evidence,
+    };
+  }
+
+  // Check for native mongodb driver
+  if (deps.mongodb) {
+    evidence.push(`mongodb@${deps.mongodb} in dependencies`);
+    confidence += 80;
+    return {
+      name: 'MongoDB',
+      version: deps.mongodb,
+      variant: 'native-driver',
+      confidence: Math.min(confidence, 100),
+      evidence,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Detect PostgreSQL
+ */
+function detectPostgreSQL(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for pg (node-postgres)
+  if (deps.pg) {
+    evidence.push(`pg@${deps.pg} in dependencies`);
+    confidence += 70;
+  }
+
+  // Check for postgres (modern driver)
+  if (deps.postgres) {
+    evidence.push(`postgres@${deps.postgres} in dependencies`);
+    confidence += 70;
+  }
+
+  // Note: Supabase and Prisma also use Postgres, but they're separate categories
+  // This detector is for direct Postgres usage
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'PostgreSQL',
+    version: deps.pg || deps.postgres,
+    variant: deps.pg ? 'node-postgres' : 'postgres.js',
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Database detector
+ * Returns the primary database detected
+ */
+export const databaseDetector: Detector = {
+  category: 'database',
+  name: 'Database Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      return null;
+    }
+
+    const deps = getDependencies(pkg);
+
+    // Priority: Supabase > Firebase > MongoDB > PostgreSQL
+    // (BaaS solutions take precedence as they encompass more)
+    const detectors = [
+      () => detectSupabase(projectRoot, deps),
+      () => detectFirebase(projectRoot, deps),
+      () => detectMongoDB(projectRoot, deps),
+      () => detectPostgreSQL(projectRoot, deps),
+    ];
+
+    for (const detector of detectors) {
+      const result = detector();
+      if (result && result.confidence >= 40) {
+        return result;
+      }
+    }
+
+    return null;
+  },
+};
+
+export default databaseDetector;