# Dependencies
node_modules/
vendor/

# Builds
dist/
build/
*.exe
*.dll

# Logs
*.log
logs/

# Local configuration
.env
.env.local

# Cache
.cache/
tmp/

**`.gitattributes`** - File attributes configuration
```bash
# Auto detect text files and perform LF normalization
* text=auto

# Explicit declaration of binary files
*.png binary
*.jpg binary
*.gif binary
*.ico binary
*.pdf binary

**`.gitmodules`** - Git submodules configuration (if applicable)
```ini
[submodule "external/library"]
    path = external/library
    url = https://github.com/example/library.git

#### Docker Files

**`.dockerignore`** - Docker build exclusions
```bash
node_modules
npm-debug.log
Dockerfile*
docker-compose*
.dockerignore
.git
.gitignore
README.md
.env
.nyc_output
coverage
.nyc_output

#### Documentation

**`README.md`** - Main project documentation

# Project Name

## Description
Clear and concise project description.

## Installation
```bash
npm install

## Usage
Basic usage instructions.

## Contributing
Guidelines for contributing to the project.

## License
License type used.

**`LICENSE.md`** - License file

MIT License

Copyright (c) [year] [name]

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction...

## Best Practices

### 1. Logical Organization
- Clearly separate source code, tests, and documentation
- Use explicit and consistent folder names
- Avoid overly deep nesting levels

### 2. Centralized Configuration
- Group all configuration files in `.config/`
- Use environment variables for sensitive parameters
- Document each configuration file

### 3. Dependency Management
- Keep `package.json` or equivalent up to date
- Use `dep/` folder for external dependencies not managed by package managers
- Version critical dependencies

### 4. Documentation
- Maintain a complete and up-to-date README.md
- Document API in `doc/` folder
- Include examples in `samples/`

### 5. Testing
- Separate tests by type (unit, integration, e2e)
- Maintain high test coverage
- Include performance tests if necessary

## Concrete Examples

### Frontend Web Project
my-webapp/
├── .config/
│   ├── webpack.config.js
│   └── babel.config.js
├── public/
│   ├── index.html
│   └── favicon.ico
├── src/
│   ├── components/
│   ├── pages/
│   ├── hooks/
│   └── utils/
├── test/
│   ├── __mocks__/
│   └── components/
├── doc/
│   ├── api.md
│   └── deployment.md
└── package.json

### Backend API Project
my-api/
├── .config/
│   └── database.config.js
├── src/
│   ├── controllers/
│   ├── models/
│   ├── routes/
│   ├── middleware/
│   └── utils/
├── test/
│   ├── unit/
│   └── integration/
├── doc/
│   ├── api-reference.md
│   └── database-schema.md
├── tools/
│   ├── migration.js
│   └── seed.js
└── server.js

## Validation Tools

### Verification Scripts
Create scripts to validate structure:

```bash
#!/bin/bash
# tools/validate-structure.sh

echo "Validating repository structure..."

# Check essential folders
required_dirs=("src" "test" "doc")
for dir in "${required_dirs[@]}"; do
    if [ ! -d "$dir" ]; then
        echo "❌ Missing folder: $dir"
        exit 1
    fi
done

# Check essential files
required_files=("README.md" ".gitignore" "package.json")
for file in "${required_files[@]}"; do
    if [ ! -f "$file" ]; then
        echo "❌ Missing file: $file"
        exit 1
    fi
done

echo "✅ Structure validated successfully"

### Repository Template
Create a template to standardize new project creation:

```json
{
  "name": "project-template",
  "version": "1.0.0",
  "scripts": {
    "init": "node tools/init-project.js",
    "validate": "bash tools/validate-structure.sh"
  }
}

## Additional Resources

- [GitHub Guide for organizing repositories](https://docs.github.com/en/repositories/creating-and-managing-repositories/about-repositories)
- [Git Flow Convention](https://nvie.com/posts/a-successful-git-branching-model/)
- [Semantic Versioning](https://semver.org/)
- [Keep a Changelog](https://keepachangelog.com/)

---

A consistent and well-documented repository structure is the foundation of a successful project. It facilitates onboarding of new developers and improves team productivity.