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 utility functions
- **Test Cases**: Well-structured unit tests` : ""}

### 4. Architecture Layer Exemplars

- **Presentation Layer**:
  - User interface components
  - Controllers/API endpoints
  - View models/DTOs
  
- **Business Logic Layer**:
  - Service implementations
  - Business logic components
  - Workflow orchestration
  
- **Data Access Layer**:
  - Repository implementations
  - Data models
  - Query patterns
  
- **Cross-Cutting Concerns**:
  - Logging implementations
  - Error handling
  - Authentication/authorization
  - Validation

### 5. Exemplar Documentation Format

For each identified exemplar, document:
- File path (relative to repository root)
- Brief description of what makes it exemplary
- Pattern or component type it represents
${INCLUDE_COMMENTS ? "- Key implementation details and coding principles demonstrated" : ""}
${INCLUDE_CODE_SNIPPETS ? "- Small, representative code snippet (if applicable)" : ""}

${SCAN_DEPTH == "Comprehensive" ? `### 6. Additional Documentation

- **Consistency Patterns**: Note consistent patterns observed across the codebase
- **Architecture Observations**: Document architectural patterns evident in the code
- **Implementation Conventions**: Identify naming and structural conventions
- **Anti-patterns to Avoid**: Note any areas where the codebase deviates from best practices` : ""}

### ${SCAN_DEPTH == "Comprehensive" ? "7" : "6"}. Output Format

Create exemplars.md with:
1. Introduction explaining the purpose of the document
2. Table of contents with links to categories
3. Organized sections based on ${CATEGORIZATION}
4. Up to ${MAX_EXAMPLES_PER_CATEGORY} exemplars per category
5. Conclusion with recommendations for maintaining code quality

The document should be actionable for developers needing guidance on implementing new features consistent with existing patterns.

Important: Only include actual files from the codebase. Verify all file paths exist. Do not include placeholder or hypothetical examples.
"

## Expected Output
Upon running this prompt, GitHub Copilot will scan your codebase and generate an exemplars.md file containing real references to high-quality code examples in your repository, organized according to your selected parameters.