project-workflow-analysis-blueprint-generator

Project Workflow Documentation Generator

Configuration Variables

${PROJECT_TYPE="Auto-detect|.NET|Java|Spring|Node.js|Python|React|Angular|Microservices|Other"}
<!-- Primary technology stack -->

${ENTRY_POINT="API|GraphQL|Frontend|CLI|Message Consumer|Scheduled Job|Custom"}
<!-- Starting point for the flow -->

${PERSISTENCE_TYPE="Auto-detect|SQL Database|NoSQL Database|File System|External API|Message Queue|Cache|None"}
<!-- Data storage type -->

${ARCHITECTURE_PATTERN="Auto-detect|Layered|Clean|CQRS|Microservices|MVC|MVVM|Serverless|Event-Driven|Other"}
<!-- Primary architecture pattern -->

${WORKFLOW_COUNT=1-5}
<!-- Number of workflows to document -->

${DETAIL_LEVEL="Standard|Implementation-Ready"}

${INCLUDE_SEQUENCE_DIAGRAM=true|false}

${INCLUDE_TEST_PATTERNS=true|false}


## Generated Prompt

"Analyze the codebase and document ${WORKFLOW_COUNT} representative end-to-end workflows that can serve as implementation templates for similar features. Use the following approach:


### Initial Detection Phase

${PROJECT_TYPE == "Auto-detect" ? "Begin by examining the codebase structure to identify technologies:

Check for .NET solutions/projects, Spring configurations, Node.js/Express files, etc.
Identify the primary programming language(s) and frameworks in use
Determine the architectural patterns based on folder structure and key components" : "Focus on ${PROJECT_TYPE} patterns and conventions"}

${ENTRY_POINT == "Auto-detect" ? "Identify typical entry points by looking for:

API controllers or route definitions
GraphQL resolvers
UI components that initiate network requests
Message handlers or event subscribers
Scheduled job definitions" : "Focus on ${ENTRY_POINT} entry points"}

${PERSISTENCE_TYPE == "Auto-detect" ? "Determine persistence mechanisms by examining:

Database context/connection configurations
Repository implementations
ORM mappings
External API clients
File system interactions" : "Focus on ${PERSISTENCE_TYPE} interactions"}


### Workflow Documentation Instructions

For each of the `${WORKFLOW_COUNT}` most representative workflow(s) in the system:

#### 1. Workflow Overview
   - Provide a name and brief description of the workflow
   - Explain the business purpose it serves
   - Identify the triggering action or event
   - List all files/classes involved in the complete workflow

#### 2. Entry Point Implementation

**API Entry Points:**

${ENTRY_POINT == "API" || ENTRY_POINT == "Auto-detect" ? "- Document the API controller class and method that receives the request

Show the complete method signature including attributes/annotations
Include the full request DTO/model class definition
Document validation attributes and custom validators
Show authentication/authorization attributes and checks" : ""}


**GraphQL Entry Points:**

${ENTRY_POINT == "GraphQL" || ENTRY_POINT == "Auto-detect" ? "- Document the GraphQL resolver class and method

Show the complete schema definition for the query/mutation
Include input type definitions
Show resolver method implementation with parameter handling" : ""}


**Frontend Entry Points:**

${ENTRY_POINT == "Frontend" || ENTRY_POINT == "Auto-detect" ? "- Document the component that initiates the API call

Show the event handler that triggers the request
Include the API client service method
Show state management code related to the request" : ""}


**Message Consumer Entry Points:**

${ENTRY_POINT == "Message Consumer" || ENTRY_POINT == "Auto-detect" ? "- Document the message handler class and method

Show message subscription configuration
Include the complete message model definition
Show deserialization and validation logic" : ""}


#### 3. Service Layer Implementation
   - Document each service class involved with their dependencies
   - Show the complete method signatures with parameters and return types
   - Include actual method implementations with key business logic
   - Document interface definitions where applicable
   - Show dependency injection registration patterns

**CQRS Patterns:**

${ARCHITECTURE_PATTERN == "CQRS" || ARCHITECTURE_PATTERN == "Auto-detect" ? "- Include complete command/query handler implementations" : ""}


**Clean Architecture Patterns:**

${ARCHITECTURE_PATTERN == "Clean" || ARCHITECTURE_PATTERN == "Auto-detect" ? "- Show use case/interactor implementations" : ""}


#### 4. Data Mapping Patterns
   - Document DTO to domain model mapping code
   - Show object mapper configurations or manual mapping methods
   - Include validation logic during mapping
   - Document any domain events created during mapping

#### 5. Data Access Implementation
   - Document repository interfaces and their implementations
   - Show complete method signatures with parameters and return types
   - Include actual query implementations
   - Document entity/model class definitions with all properties
   - Show transaction handling patterns

**SQL Database Patterns:**

${PERSISTENCE_TYPE == "SQL Database" || PERSISTENCE_TYPE == "Auto-detect" ? "- Include ORM configurations, annotations, or Fluent API usage

Show actual SQL queries or ORM statements" : ""}


**NoSQL Database Patterns:**

${PERSISTENCE_TYPE == "NoSQL Database" || PERSISTENCE_TYPE == "Auto-detect" ? "- Show document structure definitions

Include document query/update operations" : ""}


#### 6. Response Construction
   - Document response DTO/model class definitions
   - Show mapping from domain/entity models to response models
   - Include status code selection logic
   - Document error response structure and generation

#### 7. Error Handling Patterns
   - Document exception types used in the workflow
   - Show try/catch patterns at each layer
   - Include global exception handler configurations
   - Document error logging implementations
   - Show retry policies or circuit breaker patterns
   - Include compensating actions for failure scenarios

#### 8. Asynchronous Processing Patterns
   - Document background job scheduling code
   - Show event publication implementations
   - Include message queue sending patterns
   - Document callback or webhook implementations
   - Show how async operations are tracked and monitored

**Testing Approach (Optional):**

${INCLUDE_TEST_PATTERNS ? "9. Testing Approach - Document unit test implementations for each layer - Show mocking patterns and test fixture setup - Include integration test implementations - Document test data generation approaches - Show API/controller test implementations" : ""}


**Sequence Diagram (Optional):**

${INCLUDE_SEQUENCE_DIAGRAM ? "10. Sequence Diagram - Generate a detailed sequence diagram showing all components - Include method calls with parameter types - Show return values between components - Document conditional flows and error paths" : ""}


#### 11. Naming Conventions
Document consistent patterns for:
- Controller naming (e.g., `EntityNameController`)
- Service naming (e.g., `EntityNameService`)
- Repository naming (e.g., `IEntityNameRepository`)
- DTO naming (e.g., `EntityNameRequest`, `EntityNameResponse`)
- Method naming patterns for CRUD operations
- Variable naming conventions
- File organization patterns

#### 12. Implementation Templates
Provide reusable code templates for:
- Creating a new API endpoint following the pattern
- Implementing a new service method
- Adding a new repository method
- Creating new domain model classes
- Implementing proper error handling

### Technology-Specific Implementation Patterns

**.NET Implementation Patterns (if detected):**

${PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect" ? "- Complete controller class with attributes, filters, and dependency injection

Service registration in Startup.cs or Program.cs
Entity Framework DbContext configuration
Repository implementation with EF Core or Dapper
AutoMapper profile configurations
Middleware implementations for cross-cutting concerns
Extension method patterns
Options pattern implementation for configuration
Logging implementation with ILogger
Authentication/authorization filter or policy implementations" : ""}


**Spring Implementation Patterns (if detected):**

${PROJECT_TYPE == "Java" || PROJECT_TYPE == "Spring" || PROJECT_TYPE == "Auto-detect" ? "- Complete controller class with annotations and dependency injection

Service implementation with transaction boundaries
Repository interface and implementation
JPA entity definitions with relationships
DTO class implementations
Bean configuration and component scanning
Exception handler implementations
Custom validator implementations" : ""}


**React Implementation Patterns (if detected):**

${PROJECT_TYPE == "React" || PROJECT_TYPE == "Auto-detect" ? "- Component structure with props and state

Hook implementation patterns (useState, useEffect, custom hooks)
API service implementation
State management patterns (Context, Redux)
Form handling implementations
Route configuration" : ""}


### Implementation Guidelines

Based on the documented workflows, provide specific guidance for implementing new features:

#### 1. Step-by-Step Implementation Process
- Where to start when adding a similar feature
- Order of implementation (e.g., model → repository → service → controller)
- How to integrate with existing cross-cutting concerns

#### 2. Common Pitfalls to Avoid
- Identify error-prone areas in the current implementation
- Note performance considerations
- List common bugs or issues encountered

#### 3. Extension Mechanisms
- Document how to plug into existing extension points
- Show how to add new behavior without modifying existing code
- Explain configuration-driven feature patterns

**Conclusion:**
Conclude with a summary of the most important patterns that should be followed when 
implementing new features to maintain consistency with the codebase."

About this skill

Configuration Variables