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"} <!-- Primary technology -->

${DEPTH_LEVEL="Basic|Standard|Comprehensive|Implementation-Ready"} <!-- Analysis depth -->

${INCLUDE_VERSIONS=true|false} <!-- Include version information -->

${INCLUDE_LICENSES=true|false} <!-- Include license information -->

${INCLUDE_DIAGRAMS=true|false} <!-- Generate architecture diagrams -->

${INCLUDE_USAGE_PATTERNS=true|false} <!-- Include code usage patterns -->

${INCLUDE_CONVENTIONS=true|false} <!-- Document coding conventions -->

${OUTPUT_FORMAT="Markdown|JSON|YAML|HTML"} <!-- Select output format -->

${CATEGORIZATION="Technology Type|Layer|Purpose"} <!-- Organization method -->

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 Conventio