Code-Exemplars-Blueprint-Generator

# Code Exemplars Blueprint Generator

Configuration Variables

${PROJECT_TYPE="Auto-detect|.NET|Java|JavaScript|TypeScript|React|Angular|Python|Other"} <!-- Primary technology -->

${SCAN_DEPTH="Basic|Standard|Comprehensive"} <!-- How deeply to analyze the codebase -->

${INCLUDE_CODE_SNIPPETS=true|false} <!-- Include actual code snippets in addition to file references -->

${CATEGORIZATION="Pattern Type|Architecture Layer|File Type"} <!-- How to organize exemplars -->

${MAX_EXAMPLES_PER_CATEGORY=3} <!-- Maximum number of examples per category -->

${INCLUDE_COMMENTS=true|false} <!-- Include explanatory comments for each exemplar -->

Generated Prompt

"Scan this codebase and generate an exemplars.md file that identifies high-quality, representative code examples. The exemplars should demonstrate our coding standards and patterns to help maintain consistency. Use the following approach:

1. Codebase Analysis Phase

- ${PROJECT_TYPE == "Auto-detect" ? "Automatically detect primary programming languages and frameworks by scanning file extensions and configuration files" : `Focus on ${PROJECT_TYPE} code files`}

- Identify files with high-quality implementation, good documentation, and clear structure

- Look for commonly used patterns, architecture components, and well-structured implementations

- Prioritize files that demonstrate best practices for our technology stack

- Only reference actual files that exist in the codebase - no hypothetical examples

2. Exemplar Identification Criteria

- Well-structured, readable code with clear naming conventions

- Comprehensive comments and documentation

- Proper error handling and validation

- Adherence to design patterns and architectural principles

- Separation of concerns and single responsibility principle

- Efficient implementation without code smells

- Representative of our standard approaches

3. Core Pattern Categories

${PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect" ? `#### .NET Exemplars (if detected)

- **Domain Models**: Find entities that properly implement encapsulation and domain logic

- **Repository Implementations**: Examples of our data access approach

- **Service Layer Components**: Well-structured business logic implementations

- **Controller Patterns**: Clean API controllers with proper validation and responses

- **Dependency Injection Usage**: Good examples of DI configuration and usage

- **Middleware Components**: Custom middleware implementations

- **Unit Test Patterns**: Well-structured tests with proper arrangement and assertions` : ""}

${(PROJECT_TYPE == "JavaScript" || PROJECT_TYPE == "TypeScript" || PROJECT_TYPE == "React" || PROJECT_TYPE == "Angular" || PROJECT_TYPE == "Auto-detect") ? `#### Frontend Exemplars (if detected)

- **Component Structure**: Clean, well-structured components

- **State Management**: Good examples of state handling

- **API Integration**: Well-implemented service calls and data handling

- **Form Handling**: Validation and submission patterns

- **Routing Implementation**: Navigation and route configuration

- **UI Components**: Reusable, well-structured UI elements

- **Unit Test Examples**: Component and service tests` : ""}

${PROJECT_TYPE == "Java" || PROJECT_TYPE == "Auto-detect" ? `#### Java Exemplars (if detected)

- **Entity Classes**: Well-designed JPA entities or domain models

- **Service Implementations**: Clean service layer components

- **Repository Patterns**: Data access implementations

- **Controller/Resource Classes**: API endpoint implementations

- **Configuration Classes**: Application configuration

- **Unit Tests**: Well-structured JUnit tests` : ""}

${PROJECT_TYPE == "Python" || PROJECT_TYPE == "Auto-detect" ? `#### Python Exemplars (if detected)

- **Class Definitions**: Well-structured classes with proper documentation

- **API Routes/Views**: Clean API implementations

- **Data Models**: ORM model definitions

- **Service Functions**: Business logic implementations

- **Utility Modules**: Helper and uti