Implement Project Analysis Service for Automatic Config Generation

[JeremyDev87]

Implement Project Analysis Service for Automatic Config Generation

📋 Summary

Implements a comprehensive project analysis service that automatically extracts project information (tech stack, architecture patterns, config files, code samples) to enable automatic CodingBuddy configuration generation. This eliminates the need for manual config file creation.

Closes #21

🎯 Problem

Manual Configuration is Tedious

When developers apply CodingBuddy to a new project, they must manually write codingbuddy.config.js from scratch. This is time-consuming and error-prone, especially when:

• Projects already contain information about their tech stack in package.json
• Architecture patterns are evident in directory structure
• Coding style is visible in source code

Information Already Exists

Projects contain rich information that can be automatically extracted:

• Dependencies: package.json lists frameworks, libraries, tools
• Architecture: Directory structure reveals patterns (Next.js App Router, NestJS Modular, FSD, etc.)
• Config: TypeScript, ESLint, Prettier configs show coding conventions
• Code Style: Source code samples demonstrate actual patterns

Why manually recreate what already exists?

✨ Solution

Project Analysis Service

A comprehensive analysis engine that automatically collects and structures project information:

1. Package Analyzer - Extracts dependencies and detects frameworks
2. Directory Analyzer - Scans structure and detects architecture patterns
3. Config Analyzer - Parses TypeScript, ESLint, Prettier configs
4. Code Sampler - Samples and categorizes source code files
5. Analyzer Service - Integrates all analyzers into a unified NestJS service

1. Package Analyzer (package.analyzer.ts)

Features:

• Parses package.json (name, version, description, type, scripts)
• Detects 50+ frameworks/libraries across categories:
  • Frontend: React, Vue, Angular, Svelte, Solid
  • Fullstack: Next.js, Nuxt, Remix, Astro
  • Backend: NestJS, Express, Fastify, Hono, Koa
  • Testing: Jest, Vitest, Mocha, Playwright, Cypress
  • Build: Vite, Webpack, esbuild, Rollup, Turbopack
  • Linting: ESLint, Prettier, Biome
  • Styling: Tailwind CSS, Styled Components, Emotion, Sass
  • Database: Prisma, TypeORM, Drizzle, Mongoose
• Categorizes frameworks (frontend, backend, fullstack, testing, build, etc.)
• Returns PackageInfo with detected frameworks and versions

Key Functions:

• analyzePackage(projectRoot): Loads and analyzes package.json
• parsePackageJson(content): Parses JSON content
• detectFrameworks(deps, devDeps): Detects frameworks from dependencies

2. Directory Analyzer (directory.analyzer.ts)

Features:

• Recursively scans project directory structure
• Respects ignore patterns (uses ignore.parser from config module)
• Detects 8 architecture patterns:
  • Next.js App Router (app/, components/, lib/, public/)
  • Next.js Pages Router (pages/, components/, styles/)
  • NestJS Modular (src/modules/, src/common/, src/config/)
  • Feature-Sliced Design (src/features/, src/entities/, src/shared/)
  • Component-Based (src/components/, src/hooks/, src/utils/)
  • Monorepo (packages/, apps/, libs/)
  • MVC (src/models/, src/views/, src/controllers/)
  • Clean Architecture (src/domain/, src/application/, src/infrastructure/)
• Calculates confidence scores (0-1) based on matching indicators
• Categorizes directories (source, test, config, build, dependencies, static)
• Returns file/directory counts and all file paths

Key Functions:

• analyzeDirectory(projectRoot, ignorePatterns): Scans directory structure
• detectArchitecturePatterns(directories): Detects patterns with confidence
• categorizeDirectory(dirName): Categorizes directory by name

3. Config Analyzer (config.analyzer.ts)

Features:

• Detects 30+ config file types:
  • TypeScript: tsconfig.json, tsconfig.*.json
  • ESLint: .eslintrc.*, eslint.config.*
  • Prettier: .prettierrc.*, prettier.config.*
  • Testing: jest.config.*, vitest.config.*, playwright.config.*
  • Build: vite.config.*, webpack.config.*, rollup.config.*
• Parses TypeScript config:
  • Strict mode, target ES version, module system
  • Path aliases detection
• Parses ESLint config:
  • Legacy format (.eslintrc.json) and flat format (eslint.config.js)
  • Extended configs and plugins
• Parses Prettier config:
  • Tab width, semicolons, quotes, trailing commas
• Returns structured summaries for each config type

Key Functions:

• analyzeConfigs(projectRoot, rootFiles): Analyzes config files
• parseTsConfig(content, filePath): Parses TypeScript config
• parseEslintConfig(content, filePath, format): Parses ESLint config
• parsePrettierConfig(content, filePath): Parses Prettier config
• detectConfigFiles(files): Detects config files from file list

4. Code Sampler (code.sampler.ts)

Features:

• Detects 20+ programming languages from file extensions:
  • TypeScript, JavaScript, Python, Java, Kotlin
  • Go, Rust, C/C++, C#, Ruby, PHP, Swift
  • CSS, SCSS, SQL, GraphQL, Shell scripts
• Categorizes files by purpose:
  • component: React/Vue components
  • page: Next.js pages, routes
  • hook: React hooks (useXxx)
  • util: Utility functions
  • api: API routes, endpoints
  • service: Service classes
  • model: Data models, entities
  • test: Test files (excluded from samples)
  • config: Configuration files
• Selects diverse samples across categories (round-robin)
• Extracts preview (first 50 lines) and line count
• Filters out test files and large files (>100KB)

Key Functions:

• sampleCode(projectRoot, files, maxSamples): Samples code files
• categorizeFile(filePath): Categorizes file by path
• detectLanguage(filePath): Detects programming language
• selectSampleFiles(files, maxSamples): Selects diverse samples

5. Analyzer Service (analyzer.service.ts)

Features:

• NestJS injectable service integrating all analyzers
• Parallel execution for performance (package + directory analysis run simultaneously)
• Pattern inference from all collected data:
  • Architecture patterns from directory structure
  • Framework patterns from package.json
  • TypeScript detection
  • Monorepo detection
• Provides unified ProjectAnalysis interface:
  • packageInfo: Package.json analysis
  • directoryStructure: Directory analysis
  • configFiles: Config file summaries
  • codeSamples: Sampled code files
  • detectedPatterns: High-level patterns (e.g., "TypeScript", "NestJS Backend")
• Quick analysis mode (quickAnalyze) for package.json only
• Configurable options (max code samples, custom ignore patterns)

Key Methods:

• analyzeProject(projectRoot, options): Complete project analysis
• quickAnalyze(projectRoot): Package.json only (fast)
• inferPatterns(packageInfo, dirAnalysis): Infers high-level patterns

🧪 Testing

Test Coverage

• Package Analyzer: 13 tests covering parsing, framework detection
• Directory Analyzer: 17 tests covering pattern detection, categorization
• Config Analyzer: 17 tests covering TypeScript, ESLint, Prettier parsing
• Code Sampler: 23 tests covering language detection, categorization, sampling
• Analyzer Service: 8 tests covering integration, pattern inference

Total: 70+ analyzer tests, all passing ✅

Test Scenarios

Package Analyzer:

• ✅ Parse minimal and full package.json
• ✅ Detect React, Next.js, NestJS, Vue, etc.
• ✅ Detect testing frameworks from devDependencies
• ✅ Handle missing fields gracefully

Directory Analyzer:

• ✅ Detect Next.js App Router pattern
• ✅ Detect NestJS Modular pattern
• ✅ Detect Feature-Sliced Design
• ✅ Calculate confidence scores correctly
• ✅ Categorize directories correctly

Config Analyzer:

• ✅ Parse TypeScript config (strict mode, path aliases)
• ✅ Parse ESLint config (legacy and flat formats)
• ✅ Parse Prettier config
• ✅ Detect config files from file list

Code Sampler:

• ✅ Detect programming languages
• ✅ Categorize files correctly
• ✅ Select diverse samples across categories
• ✅ Filter out test files
• ✅ Handle large files

Analyzer Service:

• ✅ Complete project analysis
• ✅ Pattern inference
• ✅ Quick analysis mode
• ✅ Respect maxCodeSamples option

🎯 Benefits

1. Time Savings

No need to manually write config files. Analysis takes seconds, config generation is automatic.

2. Accuracy

Configuration reflects actual project state, not assumptions or outdated information.

3. Discovery

Identifies project characteristics developers might not be aware of (e.g., architecture patterns).

4. Standardization

Consistent analysis result format enables reliable config generation.

5. Extensibility

Easy to add new framework detections, architecture patterns, or config parsers.

📖 Usage Example

// In MCP server handler
import { AnalyzerService } from './analyzer/analyzer.service';

@Injectable()
export class ConfigHandler {
  constructor(private analyzerService: AnalyzerService) {}

  async generateConfig(projectRoot: string) {
    // Analyze project
    const analysis = await this.analyzerService.analyzeProject(projectRoot, {
      maxCodeSamples: 5,
    });

    // Use analysis to generate config
    const config = {
      language: 'ko', // from user preference or default
      projectName: analysis.packageInfo?.name,
      techStack: {
        frontend: analysis.packageInfo?.detectedFrameworks
          .filter(f => f.category === 'frontend')
          .map(f => f.name),
        backend: analysis.packageInfo?.detectedFrameworks
          .filter(f => f.category === 'backend')
          .map(f => f.name),
      },
      architecture: {
        patterns: analysis.detectedPatterns,
      },
      // ... more fields from analysis
    };

    return config;
  }
}

📝 Design Decisions

Why Separate Analyzers?

• Separation of Concerns: Each analyzer has a single responsibility
• Testability: Easy to test each analyzer independently
• Reusability: Analyzers can be used outside the service if needed
• Performance: Parallel execution possible

Why Pattern Detection?

• Architecture patterns help AI understand project structure
• Confidence scores indicate how certain we are about patterns
• Multiple patterns can be detected (e.g., Next.js + Component-Based)

Why Code Sampling?

• Representative samples show actual code style
• Diverse categories ensure coverage across project types
• Preview only (50 lines) keeps analysis fast and focused

Why NestJS Service?

• Dependency Injection: Easy to inject AnalyzerService into handlers
• Integration: Works seamlessly with existing NestJS MCP server
• Lifecycle: Can be initialized on module startup if needed

✅ Acceptance Criteria

• Parse package.json and extract information
• Directory structure analysis capability
• Detect and summarize major config files
• Source code sampling logic (select representative files)
• Structure analysis results (JSON format)
• Detect 50+ frameworks/libraries
• Detect 8 architecture patterns
• Parse TypeScript, ESLint, Prettier configs
• Comprehensive test coverage (70+ tests)