architecture-blueprint-generator（建筑蓝图生成器）

Comprehensive Project Architecture Blueprint Generator

Configuration Variables

${PROJECT_TYPE="Auto-detect|.NET|Java|React|Angular|Python|Node.js|Flutter|Other"} ${ARCHITECTURE_PATTERN="Auto-detect|Clean Architecture|Microservices|Layered|MVVM|MVC|Hexagonal|Event-Driven|Serverless|Monolithic|Other"} ${DIAGRAM_TYPE="C4|UML|Flow|Component|None"} ${DETAIL_LEVEL="High-level|Detailed|Comprehensive|Implementation-Ready"} ${INCLUDES_CODE_EXAMPLES=true|false} ${INCLUDES_IMPLEMENTATION_PATTERNS=true|false} ${INCLUDES_DECISION_RECORDS=true|false} ${FOCUS_ON_EXTENSIBILITY=true|false}

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:}

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

• Host and application model implementation
• Middleware pipeline organization
• Framework service integration patterns
• ORM and data access approaches
• API implementation patterns (controllers, minimal APIs, etc.)
• Dependency injection container configuration": ""}

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

• Application container and bootstrap process
• Dependency injection framework usage (Spring, CDI, etc.)
• AOP implementation patterns
• Transaction boundary management
• ORM configuration and usage patterns
• Service implementation patterns": ""}

${(PROJECT_TYPE == "React" || PROJECT_TYPE == "Auto-detect")? "#### React Architectural Patterns (if detected)

• Component composition and reuse strategies
• State management architecture
• Side effect handling patterns
• Routing and navigation approach
• Data fetching and caching patterns
• Rendering optimization strategies": ""}

${(PROJECT_TYPE == "Angular" || PROJECT_TYPE == "Auto-detect")? "#### Angular Architectural Patterns (if detected)

• Module organization strategy
• Component hierarchy design
• Service and dependency injection patterns
• State management approach
• Reactive programming patterns
• Route guard implementation": ""}

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

• Module organization approach
• Dependency management strategy
• OOP vs. functional implementation patterns
• Framework integration patterns
• Asynchronous programming approach": ""}

10. Implementation Patterns

${INCLUDES_IMPLEMENTATION_PATTERNS? "Document concrete implementation patterns for key architectural components:

• Interface Design Patterns:

- Interface segregation approaches - Abstraction level decisions - Generic vs. specific interface patterns - Default implementation patterns

• Service Implementation Patterns:

- Service lifetime management - Service composition patterns - Operation implementation templates - Error handling within services

• Repository Implementation Patterns:

- Query pattern implementations - Transaction management - Concurrency handling - Bulk operation patterns

• Controller/API Implementation Patterns:

- Request handling patterns - Response formatting approaches - Parameter validation - API versioning implementation

• Domain Model Implementation:

- Entity implementation patterns - Value object patterns - Domain event implementation - Business rule enforcement": "Mention that detailed implementation patterns vary across the codebase."}

11. Testing Architecture

• Document testing strategies aligned with the architecture
• Identify test boundary patterns (unit, integration, system)
• Map test doubles and mocking approaches
• Document test data strategies
• Note testing tools and frameworks integration

12. Deployment Architecture

• Document deployment topology derived from configuration
• Identify environment-specific architectural adaptations
• Map runtime dependency resolution patterns
• Document configuration management across environments
• Identify containerization and orchestration approaches
• Note cloud service integration patterns

13. Extension and Evolution Patterns

${FOCUS_ON_EXTENSIBILITY? "Provide detailed guidance for extending the architecture:

• Feature Addition Patterns:

- How to add new features while preserving architectural integrity - Where to place new components by type - Dependency introduction guidelines - Configuration extension patterns

• Modification Patterns:

- How to safely modify existing components - Strategies for maintaining backward compatibility - Deprecation patterns - Migration approaches

• Integration Patterns:

- How to integrate new external systems - Adapter implementation patterns - Anti-corruption layer patterns - Service facade implementation": "Document key extension points in the architecture."}

${INCLUDES_CODE_EXAMPLES? "### 14. Architectural Pattern Examples Extract representative code examples that illustrate key architectural patterns:

• Layer Separation Examples:

- Interface definition and implementation separation - Cross-layer communication patterns - Dependency injection examples

• Component Communication Examples:

- Service invocation patterns - Event publication and handling - Message passing implementation

• Extension Point Examples:

- Plugin registration and discovery - Extension interface implementations - Configuration-driven extension patterns

Include enough context with each example to show the pattern clearly, but keep examples concise and focused on architectural concepts.": ""}

${INCLUDES_DECISION_RECORDS? "### 15. Architectural Decision Records Document key architectural decisions evident in the codebase:

• Architectural Style Decisions:

- Why the current architectural pattern was chosen - Alternatives considered (based on code evolution) - Constraints that influenced the decision

• Technology Selection Decisions:

- Key technology choices and their architectural impact - Framework selection rationales - Custom vs. off-the-shelf component decisions

• Implementation Approach Decisions:

- Specific implementation patterns chosen - Standard pattern adaptations - Performance vs. maintainability tradeoffs

For each decision, note:

• Context that made the decision necessary
• Factors considered in making the decision
• Resulting consequences (positive and negative)
• Future flexibility or limitations introduced": ""}

${INCLUDES_DECISION_RECORDS? "16": INCLUDES_CODE_EXAMPLES? "15": "14"}. Architecture Governance

• Document how architectural consistency is maintained
• Identify automated checks for architectural compliance
• Note architectural review processes evident in the codebase
• Document architectural documentation practices

${INCLUDES_DECISION_RECORDS? "17": INCLUDES_CODE_EXAMPLES? "16": "15"}. Blueprint for New Development

Create a clear architectural guide for implementing new features:

• Development Workflow:

- Starting points for different feature types - Component creation sequence - Integration steps with existing architecture - Testing approach by architectural layer

• Implementation Templates:

- Base class/interface templates for key architectural components - Standard file organization for new components - Dependency declaration patterns - Documentation requirements

• Common Pitfalls:

- Architecture violations to avoid - Common architectural mistakes - Performance considerations - Testing blind spots

Include information about when this blueprint was generated and recommendations for keeping it updated as the architecture evolves."