folder-structure-blueprint-generator

SKILL.md

Project Folder Structure Blueprint Generator

Configuration Variables

${PROJECT_TYPE="Auto-detect|.NET|Java|React|Angular|Python|Node.js|Flutter|Other"}

${INCLUDES_MICROSERVICES="Auto-detect|true|false"}

${INCLUDES_FRONTEND="Auto-detect|true|false"}

${IS_MONOREPO="Auto-detect|true|false"}

${VISUALIZATION_STYLE="ASCII|Markdown List|Table"}
${DEPTH_LEVEL=1-5}

${INCLUDE_FILE_COUNTS=true|false}

${INCLUDE_GENERATED_FOLDERS=true|false}

${INCLUDE_FILE_PATTERNS=true|false}

${INCLUDE_TEMPLATES=true|false}

Generated Prompt

"Analyze the project's folder structure and create a comprehensive 'Project_Folders_Structure_Blueprint.md' document that serves as a definitive guide for maintaining consistent code organization. Use the following approach:

Initial Auto-detection Phase

${PROJECT_TYPE == "Auto-detect" ?
"Begin by scanning the folder structure for key files that identify the project type:

Look for solution/project files (.sln, .csproj, .fsproj, .vbproj) to identify .NET projects

Check for build files (pom.xml, build.gradle, settings.gradle) for Java projects

Identify package.json with dependencies for JavaScript/TypeScript projects

Look for specific framework files (angular.json, react-scripts entries, next.config.js)

Check for Python project identifiers (requirements.txt, setup.py, pyproject.toml)

Examine mobile app identifiers (pubspec.yaml, android/ios folders)

Note all technology signatures found and their versions" :
"Focus analysis on ${PROJECT_TYPE} project structure"}

${IS_MONOREPO == "Auto-detect" ?
"Determine if this is a monorepo by looking for:

Multiple distinct projects with their own configuration files

Workspace configuration files (lerna.json, nx.json, turborepo.json, etc.)

Cross-project references and shared dependency patterns

Root-level orchestration scripts and configuration" : ""}

${INCLUDES_MICROSERVICES == "Auto-detect" ?
"Check for microservices architecture indicators:

Multiple service directories with similar/repeated structures

Service-specific Dockerfiles or deployment configurations

Inter-service communication patterns (APIs, message brokers)

Service registry or discovery configuration

API gateway configuration files

Shared libraries or utilities across services" : ""}

${INCLUDES_FRONTEND == "Auto-detect" ?
"Identify frontend components by looking for:

Web asset directories (wwwroot, public, dist, static)

UI framework files (components, modules, pages)

Frontend build configuration (webpack, vite, rollup, etc.)

Style sheet organization (CSS, SCSS, styled-components)

Static asset organization (images, fonts, icons)" : ""}

1. Structural Overview

Provide a high-level overview of the ${PROJECT_TYPE == "Auto-detect" ? "detected project type(s)" : PROJECT_TYPE} project's organization principles and folder structure:

Document the overall architectural approach reflected in the folder structure

Identify the main organizational principles (by feature, by layer, by domain, etc.)

Note any structural patterns that repeat throughout the codebase

Document the rationale behind the structure where it can be inferred

${IS_MONOREPO == "Auto-detect" ?
"If detected as a monorepo, explain how the monorepo is organized and the relationship between projects." :
IS_MONOREPO ? "Explain how the monorepo is organized and the relationship between projects." : ""}

${INCLUDES_MICROSERVICES == "Auto-detect" ?
"If microservices are detected, describe how they are structured and organized." :
INCLUDES_MICROSERVICES ? "Describe how the microservices are structured and organized." : ""}

2. Directory Visualization

${VISUALIZATION_STYLE == "ASCII" ?
"Create an ASCII tree representation of the folder hierarchy to depth level ${DEPTH_LEVEL}." : ""}

${VISUALIZATION_STYLE == "Markdown List" ?
"Use nested markdown lists to represent the folder hierarchy to depth level ${DEPTH_LEVEL}." : ""}

${VISUALIZATION_STYLE == "Table" ?
"Create a table with columns for Path, Purpose, Content Types, and Conventions." : ""}

${INCLUDE_GENERATED_FOLDERS ?
"Include all folders including generated ones." :
"Exclude auto-generated folders like bin/, obj/, node_modules/, etc."}

3. Key Directory Analysis

Document each significant directory's purpose, contents, and patterns:

${PROJECT_TYPE == "Auto-detect" ?
"For each detected technology, analyze directory structures based on observed usage patterns:" : ""}

${(PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect") ?
"#### .NET Project Structure (if detected)

Solution Organization:

How projects are grouped and related

Solution folder organization patterns

Multi-targeting project patterns

Project Organization:

Internal folder structure patterns

Source code organization approach

Resource organization

Project dependencies and references

Domain/Feature Organization:

How business domains or features are separated

Domain boundary enforcement patterns

Layer Organization:

Separation of concerns (Controllers, Services, Repositories, etc.)

Layer interaction and dependency patterns

Configuration Management:

Configuration file locations and purposes

Environment-specific configurations

Secret management approach

Test Project Organization:

Test project structure and naming

Test categories and organization

Test data and mock locations" : ""}

${(PROJECT_TYPE == "React" || PROJECT_TYPE == "Angular" || PROJECT_TYPE == "Auto-detect") ?
"#### UI Project Structure (if detected)

Component Organization:

Component folder structure patterns

Grouping strategies (by feature, type, etc.)

Shared vs. feature-specific components

State Management:

State-related file organization

Store structure for global state

Local state management patterns

Routing Organization:

Route definition locations

Page/view component organization

Route parameter handling

API Integration:

API client organization

Service layer structure

Data fetching patterns

Asset Management:

Static resource organization

Image/media file structure

Font and icon organization

Style Organization:

CSS/SCSS file structure

Theme organization

Style module patterns" : ""}

4. File Placement Patterns

${INCLUDE_FILE_PATTERNS ?
"Document the patterns that determine where different types of files should be placed:

Configuration Files:

Locations for different types of configuration

Environment-specific configuration patterns

Model/Entity Definitions:

Where domain models are defined

Data transfer object (DTO) locations

Schema definition locations

Business Logic:

Service implementation locations

Business rule organization

Utility and helper function placement

Interface Definitions:

Where interfaces and abstractions are defined

How interfaces are grouped and organized

Test Files:

Unit test location patterns

Integration test placement

Test utility and mock locations

Documentation Files:

API documentation placement

Internal documentation organization

README file distribution" :
"Document where key file types are located in the project."}

5. Naming and Organization Conventions

Document the naming and organizational conventions observed across the project:

File Naming Patterns:

Case conventions (PascalCase, camelCase, kebab-case)

Prefix and suffix patterns

Type indicators in filenames

Folder Naming Patterns:

Naming conventions for different folder types

Hierarchical naming patterns

Grouping and categorization conventions

Namespace/Module Patterns:

How namespaces/modules map to folder structure

Import/using statement organization

Internal vs. public API separation

Organizational Patterns:

Code co-location strategies

Feature encapsulation approaches

Cross-cutting concern organization

6. Navigation and Development Workflow

Provide guidance for navigating and working with the codebase structure:

Entry Points:

Main application entry points

Key configuration starting points

Initial files for understanding the project

Common Development Tasks:

Where to add new features

How to extend existing functionality

Where to place new tests

Configuration modification locations

Dependency Patterns:

How dependencies flow between folders

Import/reference patterns

Dependency injection registration locations

${INCLUDE_FILE_COUNTS ?
"- Content Statistics:

Files per directory analysis

Code distribution metrics

Complexity concentration areas" : ""}

7. Build and Output Organization

Document the build process and output organization:

Build Configuration:

Build script locations and purposes

Build pipeline organization

Build task definitions

Output Structure:

Compiled/built output locations

Output organization patterns

Distribution package structure

Environment-Specific Builds:

Development vs. production differences

Environment configuration strategies

Build variant organization

8. Technology-Specific Organization

${(PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect") ?
"#### .NET-Specific Structure Patterns (if detected)

Project File Organization:

Project file structure and patterns

Target framework configuration

Property group organization

Item group patterns

Assembly Organization:

Assembly naming patterns

Multi-assembly architecture

Assembly reference patterns

Resource Organization:

Embedded resource patterns

Localization file structure

Static web asset organization

Package Management:

NuGet configuration locations

Package reference organization

Package version management" : ""}

${(PROJECT_TYPE == "Java" || PROJECT_TYPE == "Auto-detect") ?
"#### Java-Specific Structure Patterns (if detected)

Package Hierarchy:

Package naming and nesting conventions

Domain vs. technical packages

Visibility and access patterns

Build Tool Organization:

Maven/Gradle structure patterns

Module organization

Plugin configuration patterns

Resource Organization:

Resource folder structures

Environment-specific resources

Properties file organization" : ""}

${(PROJECT_TYPE == "Node.js" || PROJECT_TYPE == "Auto-detect") ?
"#### Node.js-Specific Structure Patterns (if detected)

Module Organization:

CommonJS vs. ESM organization

Internal module patterns

Third-party dependency management

Script Organization:

npm/yarn script definition patterns

Utility script locations

Development tool scripts

Configuration Management:

Configuration file locations

Environment variable management

Secret management approaches" : ""}

9. Extension and Evolution

Document how the project structure is designed to be extended:

Extension Points:

How to add new modules/features while maintaining conventions

Plugin/extension folder patterns

Customization directory structures

Scalability Patterns:

How the structure scales for larger features

Approach for breaking down large modules

Code splitting strategies

Refactoring Patterns:

Common refactoring approaches observed

How structural changes are managed

Incremental reorganization patterns

${INCLUDE_TEMPLATES ?
"### 10. Structure Templates

Provide templates for creating new components that follow project conventions:

New Feature Template:

Folder structure for adding a complete feature

Required file types and their locations

Naming patterns to follow

New Component Template:

Directory structure for a typical component

Essential files to include

Integration points with existing structure

New Service Template:

Structure for adding a new service

Interface and implementation placement

Configuration and registration patterns

New Test Structure:

Folder structure for test projects/files

Test file organization templates

Test resource organization" : ""}

${INCLUDE_TEMPLATES ? "11" : "10"}. Structure Enforcement

Document how the project structure is maintained and enforced:

Structure Validation:

Tools/scripts that enforce structure

Build checks for structural compliance

Linting rules related to structure

Documentation Practices:

How structural changes are documented

Where architectural decisions are recorded

Structure evolution history

Include a section at the end about maintaining this blueprint and when it was last updated.
"