wiggum-cli 0.1.0

package/src/scanner/detectors/infra/monorepo.ts

@@ -0,0 +1,251 @@
+/**
+ * Monorepo Tool Detector
+ * Detects: Turborepo, Nx, pnpm workspaces, Lerna
+ */
+
+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 Turborepo
+ */
+function detectTurborepo(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for turbo.json
+  const turboJson = join(projectRoot, 'turbo.json');
+  if (existsSync(turboJson)) {
+    evidence.push('turbo.json found');
+    confidence += 60;
+  }
+
+  // Check for turbo in dependencies
+  if (deps.turbo) {
+    evidence.push(`turbo@${deps.turbo} in devDependencies`);
+    confidence += 40;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Turborepo',
+    version: deps.turbo,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Nx
+ */
+function detectNx(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for nx.json
+  const nxJson = join(projectRoot, 'nx.json');
+  if (existsSync(nxJson)) {
+    evidence.push('nx.json found');
+    confidence += 60;
+  }
+
+  // Check for nx in dependencies
+  if (deps.nx) {
+    evidence.push(`nx@${deps.nx} in devDependencies`);
+    confidence += 40;
+  }
+
+  // Check for @nrwl/* packages (older Nx packages)
+  if (deps['@nrwl/workspace'] || deps['@nx/workspace']) {
+    evidence.push('Nx workspace package found');
+    confidence += 20;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Nx',
+    version: deps.nx,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect pnpm workspaces
+ */
+function detectPnpmWorkspaces(projectRoot: string): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for pnpm-workspace.yaml
+  const pnpmWorkspace = join(projectRoot, 'pnpm-workspace.yaml');
+  if (existsSync(pnpmWorkspace)) {
+    evidence.push('pnpm-workspace.yaml found');
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'pnpm Workspaces',
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect npm/yarn workspaces
+ */
+function detectNpmYarnWorkspaces(projectRoot: string, pkg: Record<string, unknown>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+  let variant: string | undefined;
+
+  // Check for workspaces field in package.json
+  if (pkg.workspaces) {
+    evidence.push('workspaces field in package.json');
+    confidence += 70;
+
+    // Determine if it's yarn or npm based on lock files
+    const yarnLock = join(projectRoot, 'yarn.lock');
+    const npmLock = join(projectRoot, 'package-lock.json');
+
+    if (existsSync(yarnLock)) {
+      variant = 'yarn';
+      evidence.push('yarn.lock found');
+    } else if (existsSync(npmLock)) {
+      variant = 'npm';
+      evidence.push('package-lock.json found');
+    }
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: variant === 'yarn' ? 'Yarn Workspaces' : 'npm Workspaces',
+    variant,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Lerna
+ */
+function detectLerna(projectRoot: string, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for lerna.json
+  const lernaJson = join(projectRoot, 'lerna.json');
+  if (existsSync(lernaJson)) {
+    evidence.push('lerna.json found');
+    confidence += 70;
+  }
+
+  // Check for lerna in dependencies
+  if (deps.lerna) {
+    evidence.push(`lerna@${deps.lerna} in devDependencies`);
+    confidence += 30;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Lerna',
+    version: deps.lerna,
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect Rush
+ */
+function detectRush(projectRoot: string): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for rush.json
+  const rushJson = join(projectRoot, 'rush.json');
+  if (existsSync(rushJson)) {
+    evidence.push('rush.json found');
+    confidence += 80;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'Rush',
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Monorepo tool detector
+ * Returns the primary monorepo tool detected
+ */
+export const monorepoDetector: Detector = {
+  category: 'monorepo',
+  name: 'Monorepo Tool Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult | null> {
+    const pkg = readPackageJson(projectRoot);
+    const deps = pkg ? getDependencies(pkg) : {};
+
+    // Priority: dedicated monorepo tools first, then workspace configs
+    const detectors = [
+      () => detectTurborepo(projectRoot, deps),
+      () => detectNx(projectRoot, deps),
+      () => detectLerna(projectRoot, deps),
+      () => detectRush(projectRoot),
+      () => detectPnpmWorkspaces(projectRoot),
+      () => pkg ? detectNpmYarnWorkspaces(projectRoot, pkg) : null,
+    ];
+
+    // 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 monorepoDetector;

package/src/scanner/detectors/mcp/mcpProject.ts

@@ -0,0 +1,176 @@
+/**
+ * MCP Project Detector
+ * Detects if the project is building an MCP server
+ */
+
+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 if project is an MCP server
+ */
+function detectMCPServer(projectRoot: string, pkg: Record<string, unknown>, deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for @modelcontextprotocol/sdk
+  if (deps['@modelcontextprotocol/sdk']) {
+    evidence.push(`@modelcontextprotocol/sdk@${deps['@modelcontextprotocol/sdk']} in dependencies`);
+    confidence += 70;
+  }
+
+  // Check for mcp-* or *-mcp in package name
+  const packageName = pkg.name as string | undefined;
+  if (packageName) {
+    if (packageName.startsWith('mcp-') || packageName.endsWith('-mcp')) {
+      evidence.push(`Package name "${packageName}" follows MCP naming convention`);
+      confidence += 20;
+    }
+    if (packageName.includes('mcp-server') || packageName.includes('server-mcp')) {
+      evidence.push(`Package name "${packageName}" indicates MCP server`);
+      confidence += 10;
+    }
+  }
+
+  // Check for MCP-related keywords in package.json
+  const keywords = pkg.keywords as string[] | undefined;
+  if (keywords && Array.isArray(keywords)) {
+    const mcpKeywords = keywords.filter(k =>
+      k.toLowerCase().includes('mcp') ||
+      k.toLowerCase().includes('model-context-protocol') ||
+      k.toLowerCase().includes('claude')
+    );
+    if (mcpKeywords.length > 0) {
+      evidence.push(`MCP-related keywords: ${mcpKeywords.join(', ')}`);
+      confidence += 10;
+    }
+  }
+
+  // Check for MCP server files
+  const serverFiles = [
+    'src/index.ts',
+    'src/server.ts',
+    'src/mcp.ts',
+    'index.ts',
+    'server.ts',
+  ];
+
+  for (const file of serverFiles) {
+    const filePath = join(projectRoot, file);
+    if (existsSync(filePath)) {
+      try {
+        const content = readFileSync(filePath, 'utf-8');
+        if (content.includes('@modelcontextprotocol/sdk') || content.includes('McpServer')) {
+          evidence.push(`MCP server code found in ${file}`);
+          confidence += 20;
+          break;
+        }
+      } catch {
+        // Ignore read errors
+      }
+    }
+  }
+
+  // Check for package.json bin field (common for MCP servers)
+  if (pkg.bin && deps['@modelcontextprotocol/sdk']) {
+    evidence.push('Package has bin field (likely a CLI MCP server)');
+    confidence += 10;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'MCP Server Project',
+    version: deps['@modelcontextprotocol/sdk'],
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * Detect if project uses MCP client
+ */
+function detectMCPClient(deps: Record<string, string>): DetectionResult | null {
+  const evidence: string[] = [];
+  let confidence = 0;
+
+  // Check for MCP client packages
+  if (deps['@anthropic-ai/sdk']) {
+    evidence.push(`@anthropic-ai/sdk@${deps['@anthropic-ai/sdk']} in dependencies`);
+    confidence += 50;
+  }
+
+  if (deps['@modelcontextprotocol/sdk']) {
+    // Could be either client or server, lower confidence
+    evidence.push('MCP SDK found (could be client usage)');
+    confidence += 30;
+  }
+
+  if (confidence === 0) return null;
+
+  return {
+    name: 'MCP Client',
+    confidence: Math.min(confidence, 100),
+    evidence,
+  };
+}
+
+/**
+ * MCP project detector
+ * Detects if the project is an MCP server or uses MCP
+ */
+export const mcpProjectDetector: Detector = {
+  category: 'mcp',
+  name: 'MCP Project Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult | null> {
+    const pkg = readPackageJson(projectRoot);
+    if (!pkg) {
+      return null;
+    }
+
+    const deps = getDependencies(pkg);
+
+    // First check if it's an MCP server project
+    const serverResult = detectMCPServer(projectRoot, pkg, deps);
+    if (serverResult && serverResult.confidence >= 40) {
+      return serverResult;
+    }
+
+    // Then check if it uses MCP client
+    const clientResult = detectMCPClient(deps);
+    if (clientResult && clientResult.confidence >= 40) {
+      return clientResult;
+    }
+
+    return null;
+  },
+};
+
+export default mcpProjectDetector;

package/src/scanner/detectors/mcp/mcpServers.ts

@@ -0,0 +1,237 @@
+/**
+ * MCP Servers Detector
+ * Detects usable MCP tools from config files and infers from dependencies
+ */
+
+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 };
+}
+
+/**
+ * Read JSON file safely
+ */
+function readJsonFile(filePath: string): Record<string, unknown> | null {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * MCP configuration structure
+ */
+interface MCPConfig {
+  mcpServers?: Record<string, {
+    command?: string;
+    args?: string[];
+    url?: string;
+  }>;
+}
+
+/**
+ * Detect MCP configuration from .claude directory
+ */
+function detectClaudeMCP(projectRoot: string): DetectionResult[] {
+  const results: DetectionResult[] = [];
+  const claudeDir = join(projectRoot, '.claude');
+
+  if (!existsSync(claudeDir)) {
+    return results;
+  }
+
+  // Check for mcp.json in .claude directory
+  const mcpConfigPath = join(claudeDir, 'mcp.json');
+  const config = readJsonFile(mcpConfigPath) as MCPConfig | null;
+
+  if (config?.mcpServers) {
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+      results.push({
+        name: `MCP: ${name}`,
+        confidence: 90,
+        evidence: [`Configured in .claude/mcp.json`],
+        variant: serverConfig.command || serverConfig.url || 'configured',
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Detect MCP configuration from .cursor directory
+ */
+function detectCursorMCP(projectRoot: string): DetectionResult[] {
+  const results: DetectionResult[] = [];
+  const cursorDir = join(projectRoot, '.cursor');
+
+  if (!existsSync(cursorDir)) {
+    return results;
+  }
+
+  // Check for mcp.json in .cursor directory
+  const mcpConfigPath = join(cursorDir, 'mcp.json');
+  const config = readJsonFile(mcpConfigPath) as MCPConfig | null;
+
+  if (config?.mcpServers) {
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+      results.push({
+        name: `MCP: ${name}`,
+        confidence: 90,
+        evidence: [`Configured in .cursor/mcp.json`],
+        variant: serverConfig.command || serverConfig.url || 'configured',
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Detect MCP configuration from root mcp.json
+ */
+function detectRootMCP(projectRoot: string): DetectionResult[] {
+  const results: DetectionResult[] = [];
+  const mcpConfigPath = join(projectRoot, 'mcp.json');
+  const config = readJsonFile(mcpConfigPath) as MCPConfig | null;
+
+  if (config?.mcpServers) {
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+      results.push({
+        name: `MCP: ${name}`,
+        confidence: 90,
+        evidence: [`Configured in mcp.json`],
+        variant: serverConfig.command || serverConfig.url || 'configured',
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Infer recommended MCP servers from dependencies
+ */
+function inferMCPFromDeps(deps: Record<string, string>): string[] {
+  const recommendations: string[] = [];
+
+  // Supabase → Supabase MCP
+  if (deps['@supabase/supabase-js'] || deps['@supabase/ssr']) {
+    recommendations.push('supabase');
+  }
+
+  // GitHub (if repo uses git) → GitHub MCP
+  // This is almost always useful
+  recommendations.push('github');
+
+  // Stripe → Stripe MCP (if available)
+  if (deps.stripe) {
+    recommendations.push('stripe');
+  }
+
+  // PostgreSQL → Postgres MCP
+  if (deps.pg || deps.postgres || deps['@prisma/client']) {
+    recommendations.push('postgres');
+  }
+
+  // Filesystem is almost always useful
+  recommendations.push('filesystem');
+
+  // Memory/knowledge base
+  recommendations.push('memory');
+
+  return [...new Set(recommendations)]; // Remove duplicates
+}
+
+/**
+ * MCP servers detector
+ * Returns detected MCP configurations and recommendations
+ */
+export const mcpServersDetector: Detector = {
+  category: 'mcp',
+  name: 'MCP Servers Detector',
+
+  async detect(projectRoot: string): Promise<DetectionResult[] | null> {
+    const results: DetectionResult[] = [];
+
+    // Detect configured MCP servers
+    results.push(...detectClaudeMCP(projectRoot));
+    results.push(...detectCursorMCP(projectRoot));
+    results.push(...detectRootMCP(projectRoot));
+
+    // Deduplicate by name
+    const seen = new Set<string>();
+    const uniqueResults = results.filter(r => {
+      if (seen.has(r.name)) return false;
+      seen.add(r.name);
+      return true;
+    });
+
+    // If we found configured servers, return them
+    if (uniqueResults.length > 0) {
+      return uniqueResults;
+    }
+
+    // Otherwise, check for MCP config directories existence
+    const claudeDir = join(projectRoot, '.claude');
+    const cursorDir = join(projectRoot, '.cursor');
+
+    if (existsSync(claudeDir) || existsSync(cursorDir)) {
+      return [{
+        name: 'MCP Config Directory',
+        confidence: 50,
+        evidence: [
+          existsSync(claudeDir) ? '.claude/ directory found' : '',
+          existsSync(cursorDir) ? '.cursor/ directory found' : '',
+        ].filter(Boolean),
+      }];
+    }
+
+    return null;
+  },
+};
+
+/**
+ * Get recommended MCP servers based on project stack
+ * This is a utility function, not a detector
+ */
+export function getRecommendedMCPServers(projectRoot: string): string[] {
+  const pkg = readPackageJson(projectRoot);
+  if (!pkg) {
+    return ['filesystem', 'github', 'memory'];
+  }
+
+  const deps = getDependencies(pkg);
+  return inferMCPFromDeps(deps);
+}
+
+export default mcpServersDetector;