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}
${INCLUDEUSAGEPATTERNS=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

• ${PROJECTTYPE == "Auto-detect" ? "Scan the codebase for project files, configuration files, and dependencies to determine all technology stacks in use" : "Focus on ${PROJECTTYPE} 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

${PROJECTTYPE == ".NET" || PROJECTTYPE == "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" : ""}

${PROJECTTYPE == "Java" || PROJECTTYPE == "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.)" : ""}

${PROJECTTYPE == "JavaScript" || PROJECTTYPE == "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" : ""}

${PROJECTTYPE == "React.js" || PROJECTTYPE == "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" : ""}

${PROJECTTYPE == "Python" || PROJECTTYPE == "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

${INCLUDEUSAGEPATTERNS ?
"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

${DEPTHLEVEL == "Comprehensive" || DEPTHLEVEL == "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

${PROJECTTYPE == ".NET" || PROJECTTYPE == "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" : ""}

${PROJECTTYPE == "React.js" || PROJECTTYPE == "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 'TechnologyStackBlueprint.${OUTPUTFORMAT == "Markdown" ? "md" : OUTPUTFORMAT.toLowerCase()}'
"