gabeujin/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 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()}' "