Architecture-Blueprint-Generator

# Comprehensive Project Architecture Blueprint Generator

Configuration Variables

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

${ARCHITECTURE_PATTERN="Auto-detect|Clean Architecture|Microservices|Layered|MVVM|MVC|Hexagonal|Event-Driven|Serverless|Monolithic|Other"} <!-- Primary architectural pattern -->

${DIAGRAM_TYPE="C4|UML|Flow|Component|None"} <!-- Architecture diagram type -->

${DETAIL_LEVEL="High-level|Detailed|Comprehensive|Implementation-Ready"} <!-- Level of detail to include -->

${INCLUDES_CODE_EXAMPLES=true|false} <!-- Include sample code to illustrate patterns -->

${INCLUDES_IMPLEMENTATION_PATTERNS=true|false} <!-- Include detailed implementation patterns -->

${INCLUDES_DECISION_RECORDS=true|false} <!-- Include architectural decision records -->

${FOCUS_ON_EXTENSIBILITY=true|false} <!-- Emphasize extension points and patterns -->

Generated Prompt

"Create a comprehensive 'Project_Architecture_Blueprint.md' document that thoroughly analyzes the architectural patterns in the codebase to serve as a definitive reference for maintaining architectural consistency. Use the following approach:

1. Architecture Detection and Analysis

- ${PROJECT_TYPE == "Auto-detect" ? "Analyze the project structure to identify all technology stacks and frameworks in use by examining:

- Project and configuration files

- Package dependencies and import statements

- Framework-specific patterns and conventions

- Build and deployment configurations" : "Focus on ${PROJECT_TYPE} specific patterns and practices"}

- ${ARCHITECTURE_PATTERN == "Auto-detect" ? "Determine the architectural pattern(s) by analyzing:

- Folder organization and namespacing

- Dependency flow and component boundaries

- Interface segregation and abstraction patterns

- Communication mechanisms between components" : "Document how the ${ARCHITECTURE_PATTERN} architecture is implemented"}

2. Architectural Overview

- Provide a clear, concise explanation of the overall architectural approach

- Document the guiding principles evident in the architectural choices

- Identify architectural boundaries and how they're enforced

- Note any hybrid architectural patterns or adaptations of standard patterns

3. Architecture Visualization

${DIAGRAM_TYPE != "None" ? `Create ${DIAGRAM_TYPE} diagrams at multiple levels of abstraction:

- High-level architectural overview showing major subsystems

- Component interaction diagrams showing relationships and dependencies

- Data flow diagrams showing how information moves through the system

- Ensure diagrams accurately reflect the actual implementation, not theoretical patterns` : "Describe the component relationships based on actual code dependencies, providing clear textual explanations of:

- Subsystem organization and boundaries

- Dependency directions and component interactions

- Data flow and process sequences"}

4. Core Architectural Components

For each architectural component discovered in the codebase:

- **Purpose and Responsibility**:

- Primary function within the architecture

- Business domains or technical concerns addressed

- Boundaries and scope limitations

- **Internal Structure**:

- Organization of classes/modules within the component

- Key abstractions and their implementations

- Design patterns utilized

- **Interaction Patterns**:

- How the component communicates with others

- Interfaces exposed and consumed

- Dependency injection patterns

- Event publishing/subscription mechanisms

- **Evolution Patterns**:

- How the component can be extended

- Variation points and plugin mechanisms

- Configuration and customization approaches

5. Architectural Layers and Dependencies

- Map the layer structure as implemented in the codebase

- Document the dependency rules between layers

- Identify abstraction mechanisms that enable layer separation

- Note any circular dependencies or layer violations

- Document de