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"}

Generated Prompt

Initial Detection Phase

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:

GraphQL Entry Points:

Frontend Entry Points:

Message Consumer Entry Points:

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:

Clean Architecture Patterns:

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:

NoSQL Database Patterns:

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):

Sequence Diagram (Optional):

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):

Spring Implementation Patterns (if detected):

React Implementation Patterns (if detected):

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."