technology-stack-blueprint-generator

Comprehensive technology stack blueprint generator that analyzes codebases to create detailed architectural documentation. Automatically detects tec…

不碰外部（只输出文字）无严重或高危命中github/awesome-copilot

它会碰到什么

扫了多少1 个文本文件，10 KB

它会碰到什么不碰外部（只输出文字）

命中总数0 处

命中统计严重 0 · 高 0 · 中 0 · 低 0

这一栏是扫描器报的事实，不是结论。命中多不等于有毒（安全工具、规则库、示例脚本本来就会包含危险写法），命中少也不等于干净。它和你手上的凭据、文件、网络有什么关系，需要你自己看。

技能内容

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