technology-stack-blueprint-generator（技术栈蓝图生成器）

Comprehensive Technology Stack Blueprint Generator

Configuration Variables

${PROJECT_TYPE="Auto-detect|.NET|Java|JavaScript|React.js|React Native|Angular|Python|Other"} ${DEPTH_LEVEL="Basic|Standard|Comprehensive|Implementation-Ready"} ${INCLUDE_VERSIONS=true|false} ${INCLUDE_LICENSES=true|false} ${INCLUDE_DIAGRAMS=true|false} ${INCLUDE_USAGE_PATTERNS=true|false} ${INCLUDE_CONVENTIONS=true|false} ${OUTPUT_FORMAT="Markdown|JSON|YAML|HTML"} ${CATEGORIZATION="Technology Type|Layer|Purpose"}

Generated Prompt

"Analyze the codebase and generate a ${DEPTH_LEVEL} technology stack blueprint that thoroughly documents technologies and implementation patterns to facilitate consistent code generation. Use the following approach:

1. Technology Identification Phase

• ${PROJECT_TYPE == "Auto-detect"? "Scan the codebase for project files, configuration files, and dependencies to determine all technology stacks in use": "Focus on ${PROJECT_TYPE} technologies"}
• Identify all programming languages by examining file extensions and content
• Analyze configuration files (package.json,.csproj, pom.xml, etc.) to extract dependencies
• Examine build scripts and pipeline definitions for tooling information
• ${INCLUDE_VERSIONS? "Extract precise version information from package files and configuration": "Skip version details"}
• ${INCLUDE_LICENSES? "Document license information for all dependencies": ""}

2. Core Technologies Analysis

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

• Target frameworks and language versions (detect from project files)
• All NuGet package references with versions and purpose comments
• Project structure and organization patterns
• Configuration approach (appsettings.json, IOptions, etc.)
• Authentication mechanisms (Identity, JWT, etc.)
• API design patterns (REST, GraphQL, minimal APIs, etc.)
• Data access approaches (EF Core, Dapper, etc.)
• Dependency injection patterns
• Middleware pipeline components": ""}

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

• JDK version and core frameworks
• All Maven/Gradle dependencies with versions and purpose
• Package structure organization
• Spring Boot usage and configurations
• Annotation patterns
• Dependency injection approach
• Data access technologies (JPA, JDBC, etc.)
• API design (Spring MVC, JAX-RS, etc.)": ""}

${PROJECT_TYPE == "JavaScript" || PROJECT_TYPE == "Auto-detect"? "#### JavaScript Stack Analysis (if detected)

• ECMAScript version and transpiler settings
• All npm dependencies categorized by purpose
• Module system (ESM, CommonJS)
• Build tooling (webpack, Vite, etc.) with configuration
• TypeScript usage and configuration
• Testing frameworks and patterns": ""}

${PROJECT_TYPE == "React.js" || PROJECT_TYPE == "Auto-detect"? "#### React Analysis (if detected)

• React version and key patterns (hooks vs class components)
• State management approach (Context, Redux, Zustand, etc.)
• Component library usage (Material-UI, Chakra, etc.)
• Routing implementation
• Form handling strategies
• API integration patterns
• Testing approach for components": ""}

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

• Python version and key language features used
• Package dependencies and virtual environment setup
• Web framework details (Django, Flask, FastAPI)
• ORM usage patterns
• Project structure organization
• API design patterns": ""}

3. Implementation Patterns & Conventions

${INCLUDE_CONVENTIONS? "Document coding conventions and patterns for each technology area:

Naming Conventions

• Class/type naming patterns
• Method/function naming patterns
• Variable naming conventions
• File naming and organization conventions
• Interface/abstract class patterns

Code Organization

• File structure and organization
• Folder hierarchy patterns
• Component/module boundaries
• Code separation and responsibility patterns

Common Patterns

• Error handling approaches
• Logging patterns
• Configuration access
• Authentication/authorization implementation
• Validation strategies
• Testing patterns": ""}

4. Usage Examples

${INCLUDE_USAGE_PATTERNS? "Extract representative code examples showing standard implementation patterns:

API Implementation Examples

• Standard controller/endpoint implementation
• Request DTO pattern
• Response formatting
• Validation approach
• Error handling

Data Access Examples

• Repository pattern implementation
• Entity/model definitions
• Query patterns
• Transaction handling

Service Layer Examples

• Service class implementation
• Business logic organization
• Cross-cutting concerns integration
• Dependency injection usage

UI Component Examples (if applicable)

• Component structure
• State management pattern
• Event handling
• API integration pattern": ""}

5. Technology Stack Map

${DEPTH_LEVEL == "Comprehensive" || DEPTH_LEVEL == "Implementation-Ready"? "Create a comprehensive technology map including:

Core Framework Usage

• Primary frameworks and their specific usage in the project
• Framework-specific configurations and customizations
• Extension points and customizations

Integration Points

• How different technology components integrate
• Authentication flow between components
• Data flow between frontend and backend
• Third-party service integration patterns

Development Tooling

• IDE settings and conventions
• Code analysis tools
• Linters and formatters with configuration
• Build and deployment pipeline
• Testing frameworks and approaches

Infrastructure

• Deployment environment details
• Container technologies
• Cloud services utilized
• Monitoring and logging infrastructure": ""}

6. Technology-Specific Implementation Details

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

• Dependency Injection Pattern:

- Service registration approach (Scoped/Singleton/Transient patterns) - Configuration binding patterns

• Controller Patterns:

- Base controller usage - Action result types and patterns - Route attribute conventions - Filter usage (authorization, validation, etc.)

• Data Access Patterns:

- ORM configuration and usage - Entity configuration approach - Relationship definitions - Query patterns and optimization approaches

• API Design Patterns (if used):

- Endpoint organization - Parameter binding approaches - Response type handling

• Language Features Used:

- Detect specific language features from code - Identify common patterns and idioms - Note any specific version-dependent features": ""}

${PROJECT_TYPE == "React.js" || PROJECT_TYPE == "Auto-detect"? "#### React Implementation Details (if detected)

• Component Structure:

- Function vs class components - Props interface definitions - Component composition patterns

• Hook Usage Patterns:

- Custom hook implementation style - useState patterns - useEffect cleanup approaches - Context usage patterns

• State Management:

- Local vs global state decisions - State management library patterns - Store configuration - Selector patterns

• Styling Approach:

- CSS methodology (CSS modules, styled-components, etc.) - Theme implementation - Responsive design patterns": ""}

7. Blueprint for New Code Implementation

${DEPTH_LEVEL == "Implementation-Ready"? "Based on the analysis, provide a detailed blueprint for implementing new features:

• File/Class Templates: Standard structure for common component types
• Code Snippets: Ready-to-use code patterns for common operations
• Implementation Checklist: Standard steps for implementing features end-to-end
• Integration Points: How to connect new code with existing systems
• Testing Requirements: Standard test patterns for different component types
• Documentation Requirements: Standard doc patterns for new features": ""}

${INCLUDE_DIAGRAMS? "### 8. Technology Relationship Diagrams

• Stack Diagram: Visual representation of the complete technology stack
• Dependency Flow: How different technologies interact
• Component Relationships: How major components depend on each other
• Data Flow: How data flows through the technology stack": ""}

${INCLUDE_DIAGRAMS? "9": "8"}. Technology Decision Context

• Document apparent reasons for technology choices
• Note any legacy or deprecated technologies marked for replacement
• Identify technology constraints and boundaries
• Document technology upgrade paths and compatibility considerations

Format the output as ${OUTPUT_FORMAT} and categorize technologies by ${CATEGORIZATION}.

Save the output as 'Technology_Stack_Blueprint.${OUTPUT_FORMAT == "Markdown"? "md": OUTPUT_FORMAT.toLowerCase()}' "