${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 dependency injection patterns used to maintain separation
6. Data Architecture
Document domain model structure and organization
Map entity relationships and aggregation patterns
Identify data access patterns (repositories, data mappers, etc.)
Document data transformation and mapping approaches
Note caching strategies and implementations
Document data validation patterns
7. Cross-Cutting Concerns Implementation
Document implementation patterns for cross-cutting concerns:
**Authentication & Authorization**:
Security model implementation
Permission enforcement patterns
Identity management approach
Security boundary patterns
**Error Handling & Resilience**:
Exception handling patterns
Retry and circuit breaker implementations
Fallback and graceful degradation strategies
Error reporting and monitoring approaches
**Logging & Monitoring**:
Instrumentation patterns
Observability implementation
Diagnostic information flow
Performance monitoring approach
**Validation**:
Input validation strategies
Business rule validation implementation
Validation responsibility distribution
Error reporting patterns
**Configuration Management**:
Configuration source patterns
Environment-specific configuration strategies
Secret management approach
Feature flag implementation
8. Service Communication Patterns
Document service boundary definitions
Identify communication protocols and formats
Map synchronous vs. asynchronous communication patterns
Document API versioning strategies
Identify service discovery mechanisms
Note resilience patterns in service communication
9. Technology-Specific Architectural Patterns
${PROJECT_TYPE == "Auto-detect" ? "For each detected technology stack, document specific architectural patterns:" : `Document ${PROJECT_TYPE}-specific architectural patterns:`}