auto-organize 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christian Mathías Rincón
+
+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, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.es.md

@@ -0,0 +1,198 @@
+![Auto Organize CLI Banner](assets/banner.png)
+
+<br>
+
+# Auto Organize CLI
+
+Leer en: [Inglés](README.md) | **Español** 
+
+<br>
+
+Una herramienta de línea de comandos (CLI) para **organizar automáticamente archivos** en cualquier carpeta del sistema.
+
+<br>
+
+## ¿Qué problema resuelve?
+
+Cuando trabajamos con carpetas que acumulan archivos (Descargas, Escritorio, proyectos, etc), el orden se suele alterar y vemos:
+
+* Archivos mezclados por tipo.
+* Pérdida de tiempo clasificando los archivos manualmente.
+* Movemos o borramos archivos incorrectos.
+
+<br>
+
+> **Auto Organize CLI** automatiza y corrige ese proceso.
+
+<br>
+
+## Características principales
+
+* Organización automática por tipo de archivo (clasificación por extensión).
+* Modo simulación (`--preview`) para previsualizar.
+* Filtros por tipo (`--only`, `--exclude`).
+* **Solo mueve archivos — nunca los elimina.**
+* Probado en **Windows** y **Linux** (Se espera compatibilidad con **macOS** gracias al soporte multiplataforma de **Node.js**)
+
+<br>
+
+## Instalación
+
+Requiere **Node.js >= 16**
+
+> [Descarga Node aquí](https://nodejs.org/es/download) 
+
+### Opción 1: Uso sin instalación (Para uso puntual)
+```bash
+npx auto-organize
+```
+
+### Opción 2: Instalación Global (Para uso continuo)
+```bash
+npm install -g auto-organize
+```
+
+<br>
+
+## Uso básico
+
+Ubicate en cualquier carpeta del sistema. Por ejemplo '/descargas'
+
+```bash
+cd /users/descargas
+```
+
+y ejecuta:
+
+```bash
+auto-organize
+```
+
+Esto, dependiendo del tipo de archivos presentes, creará carpetas como:
+
+```txt
+Images/
+Documents/
+Audio/
+Video/
+Archives/
+Others/
+```
+
+y clasificará los archivos en la carpeta correspondiente.
+
+```txt
+foto.jpg -> Images/
+
+documento.pdf -> Documents/ 
+
+canción.mp3 -> Audio/ 
+
+video.mp4 -> Video/ 
+
+archivo.rar -> Archives/ 
+
+config.json -> Others/ 
+```
+
+<br>
+
+## Modo simulación (preview)
+
+Antes de ejecutar cambios reales, se puede previsualizar si la clasificación es correcta:
+
+```bash
+auto-organize --preview
+```
+
+Salida de ejemplo:
+
+```txt
+Images/
+    foto.jpg
+
+Documents/
+    contrato.pdf
+
+Audio/
+    cancion.mp3
+```
+
+<br>
+
+## Configuraciones disponibles (flags)
+
+### `--only <type>`
+
+Organiza **solo** un tipo específico de archivo.
+
+```bash
+auto-organize --only images
+```
+
+---
+
+### `--exclude <type>`
+
+Excluye un tipo de archivo de la organización.
+
+```bash
+auto-organize --exclude archives
+```
+
+---
+
+### `--help`
+
+Muestra una guía completa y los tipos disponibles.
+
+```bash
+auto-organize --help
+```
+
+<br>
+
+## Tipos soportados
+
+* images
+* documents
+* spreadsheets
+* presentations
+* archives
+* audio
+* video
+* others
+
+<br>
+
+## Casos típicos de uso
+
+* Organizar la carpeta de Descargas.
+* Limpieza rápida del Escritorio.
+* Automatizar la clasificación de archivos de un proyecto (por ejemplo la carpeta '/public').
+
+<br>
+
+## Contribuciones
+
+Las contribuciones son bienvenidas. Por favor:
+1. Realiza un fork del proyecto.
+2. Crea una rama con tu feature: `git checkout -b feature/{tu-feature}`
+3. Haz commit de tus cambios: `git commit -m 'Add some feature'`
+4. Haz push a la rama: `git push origin feature/{tu-feature}`
+5. Abre un Pull Request.
+
+<br>
+
+## Licencia
+
+* MIT
+
+<br>
+
+## Autor
+
+* LinkedIn: https://www.linkedin.com/in/christian-math%C3%ADas-rinc%C3%B3n-037a90297/
+
+* GitHub: https://github.com/ChristianRincon
+

package/README.md

@@ -0,0 +1,199 @@
+![Auto Organize CLI Banner](assets/banner.png)
+
+<br>
+
+# Auto Organize CLI
+
+Read this in: **English** | [Spanish](README.es.md)
+
+<br>
+
+A command-line tool (CLI) to **automatically organize files** in any directory on your system.
+
+<br>
+
+## What problem does it solve?
+
+When working with folders that accumulate files (Downloads, Desktop, projects, etc.), things usually get messy:
+
+* Files mixed by type.
+* Time wasted manually sorting files.
+* Risk of moving or deleting the wrong files.
+
+<br>
+
+> **Auto Organize CLI** automates and fixes this process.
+
+<br>
+
+## Key Features
+
+* Automatic file organization by type (based on file extensions).
+* Simulation mode (`--preview`) to preview changes.
+* Type filters (`--only`, `--exclude`).
+* **Only moves files — never deletes them.**
+* Tested on **Windows** and **Linux** (**macOS** compatibility is expected due to **Node.js** cross-platform support).
+
+
+<br>
+
+## Installation
+
+Requires **Node.js >= 16**
+
+> [Download Node here](https://nodejs.org/en/download)
+
+### Option 1: Without installation (For one-time use)
+```bash
+npx auto-organize
+```
+
+### Option 2: Global Installation (For regular use)
+```bash
+npm install -g auto-organize
+```
+
+<br>
+
+## Basic Usage
+
+Navigate to any directory on your system. For example:
+
+```bash
+cd /users/downloads
+```
+
+Then run:
+
+```bash
+auto-organize
+```
+
+Depending on the files present, it will create folders such as:
+
+```txt
+Images/
+Documents/
+Audio/
+Video/
+Archives/
+Others/
+```
+
+And move files into their corresponding folders.
+
+```txt
+photo.jpg -> Images/
+
+document.pdf -> Documents/
+
+song.mp3 -> Audio/
+
+video.mp4 -> Video/
+
+archive.rar -> Archives/
+
+config.json -> Others/
+```
+
+<br>
+
+## Simulation Mode (preview)
+
+Preview the organization before applying real changes:
+
+```bash
+auto-organize --preview
+```
+
+Example output:
+
+```txt
+Images/
+    photo.jpg
+
+Documents/
+    contract.pdf 
+
+Audio/    
+    song.mp3
+```
+
+<br>
+
+## Available Flags
+
+### `--only <type>`
+
+Organize **only** a specific file type.
+
+```bash
+auto-organize --only images
+```
+
+---
+
+### `--exclude <type>`
+
+Exclude a specific file type from organization.
+
+```bash
+auto-organize --exclude archives
+```
+
+---
+
+### `--help`
+
+Display the help guide and available types.
+
+```bash
+auto-organize --help
+```
+
+<br>
+
+## Supported Types
+
+* images
+* documents
+* spreadsheets
+* presentations
+* archives
+* audio
+* video
+* others
+
+<br>
+
+## Common Use Cases
+
+* Organizing the Downloads folder
+* Quick Desktop cleanup
+* Automatically classifying project files (e.g. a `/public` directory)
+
+<br>
+
+## Contributing
+
+Contributions are welcome:
+
+1. Fork the project.
+2. Create a feature branch: `git checkout -b feature/{your-feature}`
+3. Commit your changes: `git commit -m 'Add your feature'`
+4. Push the branch: `git push origin feature/{your-feature}`
+5. Open a pull request.
+
+<br>
+
+## License
+
+* MIT
+
+<br>
+
+## Author
+
+* LinkedIn: https://www.linkedin.com/in/christian-math%C3%ADas-rinc%C3%B3n-037a90297/
+
+* GitHub: https://github.com/ChristianRincon

package/bin/auto-organize.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+try {
+  await import('../src/index.js');
+} catch (error) {
+  console.error('Error running auto-organize');
+  console.error(error.message);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "auto-organize",
+  "version": "1.0.0",
+  "description": "CLI tool to organize files in a directory based on their file types.",
+  "main": "./bin/auto-organize.js",
+  "bin": {
+    "auto-organize": "./bin/auto-organize.js"
+  },
+  "type": "module",
+  "files": [
+    "bin",
+    "src"
+  ],
+  "keywords": [
+    "cli",
+    "automation",
+    "file-organizer",
+    "file-management",
+    "organize",
+    "sort",
+    "cleanup",
+    "files",
+    "folders",
+    "directories",
+    "command-line",
+    "terminal",
+    "nodejs",
+    "filesystem",
+    "productivity"
+  ],
+  "author": {
+    "name": "Christian Mathías Rincón",
+    "url": "https://www.linkedin.com/in/christian-math%C3%ADas-rinc%C3%B3n-037a90297/"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ChristianRincon/auto-organize.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ChristianRincon/auto-organize/issues"
+  },
+  "homepage": "https://github.com/ChristianRincon/auto-organize",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2"
+  }
+}

package/src/cli/cliActions.js

@@ -0,0 +1,20 @@
+import { showHelp } from '../utils/helpMenu.js';
+import { validateFlags, validateTypes, validateFlagsAndTypes } from '../utils/validators.js';
+import { renderBanners } from './renderBanners.js';
+
+function cliActions(cliFlags, availableTypes) {
+  validateFlags(cliFlags);
+  validateTypes(availableTypes);
+  validateFlagsAndTypes(cliFlags, availableTypes);
+
+  if (cliFlags.help) {
+    showHelp(availableTypes);
+    return { exit: true, code: 0 };
+  }
+
+  renderBanners(cliFlags);
+
+  return { exit: false };
+}
+
+export { cliActions };

package/src/cli/renderBanners.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+
+function renderBanners(cliFlags) {
+  const currentDir = process.cwd();
+
+  const scannedDirectoryText = 'SCANNED DIRECTORY';
+  let textMargin = 0;
+
+  if(currentDir.length > scannedDirectoryText.length){
+    textMargin = (currentDir.length - scannedDirectoryText.length) / 2 + 2;
+  }
+
+  console.log(chalk.yellow("\n" + " ".repeat(textMargin) + scannedDirectoryText + "\n"));
+  console.log(chalk.yellow('* ') + currentDir + chalk.yellow(' *'));
+
+  if (cliFlags.preview) {
+    const previewModeText = 'PREVIEW MODE';
+    console.log("\n" + " ".repeat(textMargin) + chalk.blueBright(previewModeText));
+  }
+}
+
+export { renderBanners };

package/src/cli/renderEmptyFolderText.js

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+
+function renderEmptyFolderText() {
+  const emptyDirectoryText = 'NO FILES TO ORGANIZE';
+  const emptyDirectoryTextMargin = 10;
+
+  console.log("\n" + " ".repeat(emptyDirectoryTextMargin) + chalk.bgRed(" ".repeat(emptyDirectoryText.length + 2)));
+  console.log(" ".repeat(emptyDirectoryTextMargin) + chalk.bgRed.whiteBright(" " +emptyDirectoryText+ " "));
+  console.log(" ".repeat(emptyDirectoryTextMargin) + chalk.bgRed(" ".repeat(emptyDirectoryText.length + 2)) + "\n");
+}
+
+export { renderEmptyFolderText };

package/src/cli/renderSummary.js

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+
+function renderFoldersSummary(summary) {
+  const { foldersByExtensionType, folderWasCreated, previewMode } = summary;
+  
+  Object.entries(foldersByExtensionType).forEach(([folder, files]) => {
+    if (previewMode) {
+      console.log(`\n${chalk.blueBright('o ')}${folder}/`);
+    }else{
+      console.log(`\n${chalk.green('o ')}${folder}/`);
+    }
+    
+    files.forEach(file => {
+      const FILE_TAB = 4;
+      const line = `${' '.repeat(FILE_TAB)}• ${file}`;
+      
+      if (previewMode) {
+        console.log(chalk.blueBright(line));
+      } else {
+        console.log(chalk.greenBright(line));
+      }
+    });
+  });
+
+  if (folderWasCreated && !previewMode) {
+    const foldersCreatedTab = 1;
+    console.log(`\n${' '.repeat(foldersCreatedTab)} ${Object.keys(foldersByExtensionType).length} Folder(s) created\n`);
+  }
+}
+
+export { renderFoldersSummary };

package/src/index.js

@@ -0,0 +1,32 @@
+import { organizeDirectory } from './organizer/organizeDirectory.js';
+import { renderFoldersSummary } from './cli/renderSummary.js';
+import { parseArgs } from './utils/parseArgs.js';
+import { getAvailableTypes } from './rules/byType.js';
+import { cliActions } from './cli/cliActions.js';
+
+function main() {
+  try {
+    const cliArguments = process.argv.slice(2);
+    const cliFlags = parseArgs(cliArguments);
+    const availableTypes = getAvailableTypes();
+    const currentDir = process.cwd();
+
+    const cliResult = cliActions(cliFlags, availableTypes);
+
+    if (cliResult.exit) {
+      process.exit(cliResult.code);
+    }
+
+    const summary = organizeDirectory(currentDir, cliFlags);
+
+    if(!summary) return;
+    
+    renderFoldersSummary(summary);
+
+  } catch (error) {
+    console.error(`\nError: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/src/organizer/organizeDirectory.js

@@ -0,0 +1,54 @@
+import path from 'path';
+import { getFilesFromDirectory, ensureDirectoryExists, moveFile } from '../utils/fsHelpers.js';
+import { getFolderNameByExtensionType } from '../rules/byType.js';
+import { shouldSkipFile } from '../utils/filesFilters.js';
+import { renderEmptyFolderText } from '../cli/renderEmptyFolderText.js';
+
+function organizeDirectory(baseDir, cliFlags = {}) {
+  try{
+    const files = getFilesFromDirectory(baseDir);
+    const fileIsEmpty = files.length === 0;
+
+    if(fileIsEmpty){
+      renderEmptyFolderText();
+      return null;
+    }
+
+    const outputFoldersSummary = {};
+    let folderByExtensionTypeCreated = false;
+
+    files.forEach(file => {
+      const fileExtension = path.extname(file.name);
+      const folderNameByExtensionType = getFolderNameByExtensionType(fileExtension);
+
+      if (shouldSkipFile(folderNameByExtensionType, cliFlags)) return;
+
+      if (!outputFoldersSummary[folderNameByExtensionType]) {
+        outputFoldersSummary[folderNameByExtensionType] = [];
+      }
+
+      outputFoldersSummary[folderNameByExtensionType].push(file.name);
+
+      if (cliFlags.preview) return;
+
+      const folderPathByExtensionType = path.join(baseDir, folderNameByExtensionType);
+      const filePathByExtension = path.join(folderPathByExtensionType, file.name);
+      const folderByExtensionTypeWasCreated = ensureDirectoryExists(folderPathByExtensionType);
+
+      if (folderByExtensionTypeWasCreated) folderByExtensionTypeCreated = true;
+
+      moveFile(file.path, filePathByExtension);
+    });
+
+    return {
+      foldersByExtensionType: outputFoldersSummary,
+      folderWasCreated: folderByExtensionTypeCreated,
+      previewMode: cliFlags.preview,
+    };
+  } 
+  catch(error){
+    throw new Error(`Error organizing directory: ${error.message}`);
+  }
+}
+
+export { organizeDirectory };

package/src/rules/byType.js

@@ -0,0 +1,29 @@
+const RULES_BY_TYPE = {
+  Images: ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg', '.bmp', '.tiff', '.ico', '.heic', '.psd', '.eps'],
+  Documents: ['.pdf', '.doc', '.docx', '.txt', '.md', '.rtf', '.odt', '.tex', '.wpd', '.epub', '.fb2', '.djvu', '.xps', '.pages'],
+  Spreadsheets: ['.xls', '.xlsx', '.csv', '.ods', '.tsv', '.xlsm', '.xltx', '.xltm', '.xlsb', '.xlam', '.xla', '.xlw', '.xlc', '.xlt'],
+  Presentations: ['.ppt', '.pptx', '.odp', '.key', '.ppsx', '.potx', '.pptm', '.ppsm', '.potm', '.pps', '.pot', '.ppa', '.thmx', '.sldx', '.sldm'],
+  Archives: ['.zip', '.rar', '.7z', '.tar', '.gz', '.bz2', '.xz', '.tgz', '.tbz2'],
+  Audio: ['.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a'],
+  Video: ['.mp4', '.mov', '.avi', '.mkv', '.webm', '.wmv', '.flv']
+};
+
+const DEFAULT_FOLDER_NAME = 'Others';
+
+function getFolderNameByExtensionType(extension) {
+  const extensionToLowerCase = extension.toLowerCase();
+
+  for (const [folderName, extensionsList] of Object.entries(RULES_BY_TYPE)) {
+    if (extensionsList.includes(extensionToLowerCase)) {
+      return folderName;
+    }
+  }
+
+  return DEFAULT_FOLDER_NAME;
+}
+
+function getAvailableTypes() {
+  return Object.keys(RULES_BY_TYPE).map(availableType => availableType.toLowerCase());
+}
+
+export { getFolderNameByExtensionType, getAvailableTypes };

package/src/utils/filesFilters.js

@@ -0,0 +1,11 @@
+function shouldSkipFile(folder, cliFlags) {
+  const { only, exclude } = cliFlags;
+  const normalizedFolder = folder.toLowerCase();
+
+  if (only && normalizedFolder !== only.toLowerCase()) return true;
+  if (exclude && normalizedFolder === exclude.toLowerCase()) return true;
+  
+  return false;
+}
+
+export { shouldSkipFile };

package/src/utils/fsHelpers.js

@@ -0,0 +1,33 @@
+import fs from 'fs';
+import path from 'path';
+
+function getFilesFromDirectory(dirPath) {
+  const dirPathList = fs.readdirSync(dirPath);
+
+  return dirPathList
+    .map(dirPathItemName => {
+      const fullPath = path.join(dirPath, dirPathItemName);
+      const stats = fs.statSync(fullPath);
+
+      return {
+        name: dirPathItemName,
+        path: fullPath,
+        isFile: stats.isFile()
+      };
+    })
+    .filter(dirPathItemName => dirPathItemName.isFile);
+}
+
+function ensureDirectoryExists(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath);
+    return true;
+  }
+  return false;
+}
+
+function moveFile(sourcePath, targetPath) {
+  fs.renameSync(sourcePath, targetPath);
+}
+
+export { getFilesFromDirectory, ensureDirectoryExists, moveFile };

package/src/utils/helpMenu.js

@@ -0,0 +1,28 @@
+import chalk from "chalk";
+
+function showHelp(availableTypes) {
+  console.log(`
+    ${chalk.blueBright('Auto Organize CLI Help Menu')}
+
+    Usage:
+      auto-organize [${chalk.green('options')}]
+
+    Options:
+      ${chalk.green('--preview,  -p')}           Show a preview without making changes
+      ${chalk.green('--only,     -o <type>')}    Organize only a specific file type
+      ${chalk.green('--exclude,  -e <type>')}    Exclude a file type from organization
+      ${chalk.green('--help,     -h')}           Show this help message
+
+    Available types:
+      ${chalk.yellow(availableTypes.join(', '))}
+
+    Examples:
+      auto-organize ${chalk.green('--preview')} || auto-organize ${chalk.green('-p')}
+
+      auto-organize ${chalk.green('--only')} ${chalk.yellow('images')} || auto-organize ${chalk.green('-o')} ${chalk.yellow('images')}
+      
+      auto-organize ${chalk.green('--exclude')} ${chalk.yellow('archives')} || auto-organize ${chalk.green('-e')} ${chalk.yellow('archives')}
+  `);
+}
+
+export { showHelp };

package/src/utils/parseArgs.js

@@ -0,0 +1,72 @@
+import chalk from "chalk";
+
+function parseArgs(cliArguments) {
+  const cliFlags = {
+    preview: false,
+    only: null,
+    exclude: null,
+    help: false
+  };
+
+  if (cliArguments.length === 0) {
+    return cliFlags;
+  }
+
+  const allowedFlags = [
+    '--preview', '-p',
+    '--only', '-o',
+    '--exclude', '-e',
+    '--help', '-h'
+  ];
+
+  for (let i = 0; i < cliArguments.length; i++) {
+    const cliArgument = cliArguments[i];
+
+    if (!cliArgument.startsWith('-')) {
+      throw new Error(`\n'${chalk.red(cliArgument)}' is invalid. Run ${chalk.green('auto-organize --help')} to see available options.`);
+    }
+
+    if (!allowedFlags.includes(cliArgument)) {
+      throw new Error(`\nUnknown flag '${chalk.red(cliArgument)}'. Run ${chalk.green('auto-organize --help')} to see available flags.`);
+    }
+
+    if (cliArgument === '--preview' || cliArgument === '-p') {
+      cliFlags.preview = true;
+      continue;
+    }
+
+    if (cliArgument === '--help' || cliArgument === '-h') {
+      cliFlags.help = true;
+      continue;
+    }
+
+
+    if (cliArgument === '--only' || cliArgument === '-o') {
+      const onlyFlagArgument = cliArguments[i + 1];
+
+      if (!onlyFlagArgument || onlyFlagArgument.startsWith('-')) {
+        throw new Error(chalk.red(`\n--only requires a valid type.`));
+      }
+
+      cliFlags.only = onlyFlagArgument.toLowerCase();
+      i++;
+      continue;
+    }
+
+    if (cliArgument === '--exclude' || cliArgument === '-e') {
+      const excludeFlagArgument = cliArguments[i + 1];
+
+      if (!excludeFlagArgument || excludeFlagArgument.startsWith('-')) {
+        throw new Error(chalk.red(`\n--exclude requires a valid type.`));
+      }
+
+      cliFlags.exclude = excludeFlagArgument.toLowerCase();
+      i++;
+      continue;
+    }
+  }
+
+  return cliFlags;
+}
+
+export { parseArgs };

package/src/utils/validators.js

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+
+function validateFlags(cliFlags) {
+  if (!cliFlags || typeof cliFlags !== 'object') {
+    throw new Error("Missing or invalid 'cliFlags'");
+  }
+}
+
+function validateTypes(availableTypes) {
+  if (!Array.isArray(availableTypes) || availableTypes.length === 0) {
+    throw new Error("Missing or invalid 'availableTypes'");
+  }
+}
+
+function validateFlagsAndTypes(cliFlags, availableTypes) {
+  const { only, exclude } = cliFlags;
+
+  if (only && !availableTypes.includes(only)) {
+    throw new Error(
+      `'${chalk.red(only)}' is not a valid type for ${chalk.green('--only')}\n` +
+      `Valid types: ${chalk.yellow(availableTypes.join(', '))}`
+    );
+  }
+
+  if (exclude && !availableTypes.includes(exclude)) {
+    throw new Error(
+      `'${chalk.red(exclude)}' is not a valid type for ${chalk.green('--exclude')}\n` +
+      `Valid types: ${chalk.yellow(availableTypes.join(', '))}`
+    );
+  }
+}
+
+export { validateFlags, validateTypes, validateFlagsAndTypes };