feat(analyzer): implement project analysis service

- Analyze package.json and detect 50+ frameworks
- Detect architecture patterns from directory structure
- Parse TypeScript, ESLint, Prettier config files
- Sample and categorize source code files
- NestJS service integrating all analyzers
- Comprehensive test coverage

Enables automatic config generation from project analysis.

close #21

Author: wishket-pjw

mcp-server/src/analyzer/analyzer.module.ts

@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { AnalyzerService } from './analyzer.service';
+
+/**
+ * Module for project analysis functionality
+ *
+ * Provides services for analyzing:
+ * - Package.json (dependencies, frameworks)
+ * - Directory structure (architecture patterns)
+ * - Config files (TypeScript, ESLint, Prettier)
+ * - Source code samples
+ */
+@Module({
+  providers: [AnalyzerService],
+  exports: [AnalyzerService],
+})
+export class AnalyzerModule {}

mcp-server/src/analyzer/analyzer.service.spec.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { AnalyzerService } from './analyzer.service';
+
+describe('AnalyzerService', () => {
+  const service = new AnalyzerService();
+
+  describe('analyzeProject', () => {
+    it('should return null packageInfo for non-existent path', async () => {
+      const result = await service.analyzeProject('/non/existent/path');
+
+      expect(result.packageInfo).toBeNull();
+      expect(result.directoryStructure.rootDirs).toEqual([]);
+      expect(result.directoryStructure.rootFiles).toEqual([]);
+      expect(result.codeSamples).toEqual([]);
+    });
+
+    it('should analyze current project', async () => {
+      // Analyze the mcp-server itself
+      const result = await service.analyzeProject(process.cwd());
+
+      // Should find package.json
+      expect(result.packageInfo).not.toBeNull();
+      expect(result.packageInfo?.name).toBeDefined();
+
+      // Should detect TypeScript
+      expect(result.detectedPatterns).toContain('TypeScript');
+
+      // Should find some directories
+      expect(result.directoryStructure.rootDirs).toContain('src');
+      expect(result.directoryStructure.totalDirs).toBeGreaterThan(0);
+      expect(result.directoryStructure.totalFiles).toBeGreaterThan(0);
+
+      // Should have allFiles populated
+      expect(result.directoryStructure.allFiles.length).toBe(
+        result.directoryStructure.totalFiles,
+      );
+    });
+
+    it('should respect maxCodeSamples option', async () => {
+      const result = await service.analyzeProject(process.cwd(), {
+        maxCodeSamples: 2,
+      });
+
+      expect(result.codeSamples.length).toBeLessThanOrEqual(2);
+    });
+
+    it('should detect NestJS framework', async () => {
+      const result = await service.analyzeProject(process.cwd());
+
+      expect(result.packageInfo?.detectedFrameworks).toContainEqual(
+        expect.objectContaining({ name: 'NestJS', category: 'backend' }),
+      );
+
+      expect(result.detectedPatterns).toContain('NestJS Backend');
+    });
+
+    it('should detect config files', async () => {
+      const result = await service.analyzeProject(process.cwd());
+
+      // Should find tsconfig.json
+      expect(result.configFiles.typescript).toBeDefined();
+      expect(result.configFiles.typescript?.path).toBe('tsconfig.json');
+    });
+  });
+
+  describe('quickAnalyze', () => {
+    it('should return package info only', async () => {
+      const result = await service.quickAnalyze(process.cwd());
+
+      expect(result).not.toBeNull();
+      expect(result?.name).toBeDefined();
+      expect(result?.detectedFrameworks).toBeDefined();
+    });
+
+    it('should return null for non-existent path', async () => {
+      const result = await service.quickAnalyze('/non/existent/path');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('inferPatterns', () => {
+    it('should infer patterns from analysis results', async () => {
+      const result = await service.analyzeProject(process.cwd());
+
+      // Should have detected patterns
+      expect(result.detectedPatterns.length).toBeGreaterThan(0);
+
+      // Should include TypeScript since we have it as dependency
+      expect(result.detectedPatterns).toContain('TypeScript');
+    });
+
+    it('should remove duplicate patterns', async () => {
+      const result = await service.analyzeProject(process.cwd());
+
+      const uniquePatterns = new Set(result.detectedPatterns);
+      expect(result.detectedPatterns.length).toBe(uniquePatterns.size);
+    });
+  });
+});

mcp-server/src/analyzer/analyzer.service.ts

@@ -0,0 +1,123 @@
+import { Injectable } from '@nestjs/common';
+import type { ProjectAnalysis, PackageInfo } from './analyzer.types';
+import { analyzePackage } from './package.analyzer';
+import { analyzeDirectory } from './directory.analyzer';
+import { analyzeConfigs } from './config.analyzer';
+import { sampleCode } from './code.sampler';
+
+/**
+ * Options for project analysis
+ */
+export interface AnalyzeOptions {
+  /** Maximum number of code samples to collect */
+  maxCodeSamples?: number;
+  /** Custom ignore patterns */
+  ignorePatterns?: string[];
+}
+
+/**
+ * Default analysis options
+ */
+const DEFAULT_OPTIONS: Required<AnalyzeOptions> = {
+  maxCodeSamples: 5,
+  ignorePatterns: [],
+};
+
+/**
+ * Service for analyzing project structure and configuration
+ */
+@Injectable()
+export class AnalyzerService {
+  /**
+   * Perform a complete project analysis
+   *
+   * @param projectRoot - Root directory of the project to analyze
+   * @param options - Analysis options
+   * @returns Complete project analysis result
+   */
+  async analyzeProject(
+    projectRoot: string,
+    options: AnalyzeOptions = {},
+  ): Promise<ProjectAnalysis> {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+
+    // Run all analyzers in parallel
+    const [packageInfo, dirAnalysis] = await Promise.all([
+      analyzePackage(projectRoot),
+      analyzeDirectory(projectRoot, opts.ignorePatterns),
+    ]);
+
+    // Config analysis depends on directory analysis for root files
+    const configFiles = await analyzeConfigs(projectRoot, dirAnalysis.rootFiles);
+
+    // Sample code files using all scanned files
+    const codeSamples = await sampleCode(projectRoot, dirAnalysis.allFiles, opts.maxCodeSamples);
+
+    // Infer patterns from all collected data
+    const detectedPatterns = this.inferPatterns(packageInfo, dirAnalysis);
+
+    return {
+      packageInfo,
+      directoryStructure: dirAnalysis,
+      configFiles,
+      codeSamples,
+      detectedPatterns,
+    };
+  }
+
+  /**
+   * Infer high-level patterns from analysis results
+   */
+  private inferPatterns(
+    packageInfo: PackageInfo | null,
+    dirAnalysis: { patterns: { name: string; confidence: number }[] },
+  ): string[] {
+    const patterns: string[] = [];
+
+    // Add architecture patterns with high confidence
+    for (const pattern of dirAnalysis.patterns) {
+      if (pattern.confidence >= 0.5) {
+        patterns.push(pattern.name);
+      }
+    }
+
+    // Add framework patterns from package.json
+    if (packageInfo) {
+      for (const framework of packageInfo.detectedFrameworks) {
+        if (framework.category === 'frontend' || framework.category === 'fullstack') {
+          patterns.push(`${framework.name} Project`);
+        }
+        if (framework.category === 'backend') {
+          patterns.push(`${framework.name} Backend`);
+        }
+      }
+
+      // Detect TypeScript project
+      if (
+        packageInfo.devDependencies['typescript'] ||
+        packageInfo.dependencies['typescript']
+      ) {
+        patterns.push('TypeScript');
+      }
+
+      // Detect monorepo patterns
+      if (
+        packageInfo.devDependencies['lerna'] ||
+        packageInfo.devDependencies['turbo'] ||
+        packageInfo.devDependencies['nx']
+      ) {
+        patterns.push('Monorepo');
+      }
+    }
+
+    // Remove duplicates
+    return [...new Set(patterns)];
+  }
+
+  /**
+   * Quick analysis - package.json only
+   */
+  async quickAnalyze(projectRoot: string): Promise<PackageInfo | null> {
+    return analyzePackage(projectRoot);
+  }
+}