Config Manager

A powerful Node.js library for discovering, parsing, and managing configuration files in your project. Automatically discovers config files, categorizes them by type, and provides a clean API for accessing and watching configuration changes. Includes physical file categorization to organize your configuration files into a clean directory structure.

Features

• 🚀 Automatic Discovery: Scans your project for common configuration files
• 📁 Smart Categorization: Organizes configs into logical categories (env, build, lint, etc.) both virtually and physically
• 🔍 Multiple Format Support: Parses JSON, YAML, .env, JavaScript/TypeScript configs
• 👀 Live Watching: Optional file watching for real-time config updates
• 🎯 Clean API: Simple, intuitive API for accessing configurations
• 📦 TypeScript Ready: Full TypeScript support with type definitions

Installation

npm install config-manager

Quick Start

import { loadConfigs, getConfig, watchConfigs } from 'config-manager';

// Load all configurations
const allConfigs = await loadConfigs();
console.log(allConfigs.build.next); // Access Next.js config

// Get specific category
const envConfigs = getConfig('env');
console.log(envConfigs.PORT); // Access environment variables

// Watch for changes
const watcher = watchConfigs((updatedConfigs) => {
  console.log('Config updated:', updatedConfigs);
});

API Reference

loadConfigs(baseDir?: string)

Loads and parses all configuration files from the specified directory.

const configs = await loadConfigs(process.cwd());
// Returns: NormalizedConfigs object with all discovered configurations

getConfig(category?: string)

Retrieves configurations for a specific category or all configurations.

// Get all configurations
const all = getConfig();

// Get specific category
const buildConfigs = getConfig('build');
const lintConfigs = getConfig('lint');

getConfigFile(filename: string)

Gets a specific configuration file by name.

const packageJson = getConfigFile('package.json');
const tsconfig = getConfigFile('tsconfig.json');

getCategoryFiles(category: string)

Gets all configuration files in a specific category.

const buildFiles = getCategoryFiles('build');
// Returns: { webpack: {...}, next: {...}, vite: {...} }

watchConfigs(callback, baseDir?: string)

Watches for configuration file changes and reloads configurations automatically.

const watcher = watchConfigs((configs) => {
  console.log('Configurations updated!');
}, process.cwd());

// Stop watching
watcher.close();

exportConfigTree(format?: 'json' | 'yaml')

Exports the current configuration tree in different formats.

const jsonConfig = exportConfigTree('json');
const yamlConfig = exportConfigTree('yaml');

categorizeFiles(baseDir?: string)

Physically moves configuration files into category-based directories and tracks their original locations.

import { categorizeFiles } from 'config-manager';

// Categorize files in the current directory
const result = await categorizeFiles();
console.log(`Moved ${Object.keys(result).length} files to their category directories`);

decategorizeFiles(baseDir?: string)

Restores previously categorized files to their original locations.

import { decategorizeFiles } from 'config-manager';

// Restore files to their original locations
const result = await decategorizeFiles();
console.log(`Restored ${result.restored} files to their original locations`);

listCategorizedFiles(baseDir?: string)

Lists all currently categorized files and their original locations.

import { listCategorizedFiles } from 'config-manager';

// Get mapping of original paths to categorized paths
const categorized = await listCategorizedFiles();
console.log('Categorized files:', categorized);

Supported File Types

Environment Files

• .env
• .env.local
• .env.development
• .env.production

Build Tools

• webpack.config.js
• vite.config.js
• rollup.config.js
• next.config.js
• babel.config.js

Linting & Formatting

• eslint.config.js
• prettier.config.js
• stylelint.config.js
• .eslintrc.json

TypeScript

• tsconfig.json
• tsconfig.*.json
• jsconfig.json

Package Management

• package.json

Styling

• tailwind.config.js
• postcss.config.js

Testing

• jest.config.js
• vitest.config.js

Categories

Configurations are automatically categorized into:

• env: Environment variables and .env files
• build: Build tool configurations (webpack, vite, etc.)
• lint: Linting and formatting configs (eslint, prettier)
• types: TypeScript/JavaScript project configs
• package: Package.json files
• test: Testing framework configs
• style: Styling and CSS processing configs
• misc: Other configuration files

Physical File Categorization

Config Manager can physically organize your configuration files into a clean directory structure. This is particularly useful for projects with many configuration files.

How It Works

1. Categorization: Files are moved into category-based directories under configs/ (e.g., configs/env/, configs/lint/)
2. Tracking: Original file locations are stored in .vanish/original_paths.json
3. Decategorization: Files can be restored to their original locations when needed

Example Workflow

import { categorizeFiles, listCategorizedFiles, decategorizeFiles } from 'config-manager';

// 1. Categorize files
await categorizeFiles();

// 2. List categorized files
const categorized = await listCategorizedFiles();
console.log('Categorized files:', categorized);

// 3. When you want to restore files
await decategorizeFiles();

Directory Structure After Categorization

project/
├── .vanish/
│   └── original_paths.json  # Tracks original file locations
├── configs/
│   ├── env/
│   │   ├── .env
│   │   └── .env.development
│   ├── lint/
│   │   ├── .eslintrc.json
│   │   └── prettier.config.js
│   ├── build/
│   │   └── webpack.config.js
│   ├── types/
│   │   └── tsconfig.json
│   └── package/
│       └── package.json
└── ...

Important Notes

• Backup First: Always ensure you have a backup or version control before running categorization
• Git Ignore: The .vanish/ directory is automatically added to .gitignore
• Selective Categorization: Only files matching known configuration patterns are moved
• No Data Loss: The system maintains a complete record of original file locations

Advanced Usage

Custom Base Directory

// Load configs from a specific directory
const configs = await loadConfigs('/path/to/project');

Error Handling

try {
  const configs = await loadConfigs();
  // Use configs
} catch (error) {
  console.error('Failed to load configurations:', error);
}

Integration with Build Tools

// In your webpack.config.js
import { getConfig } from 'config-manager';

const buildConfig = getConfig('build');
const webpackConfig = {
  // Use loaded configurations
  ...buildConfig.webpack
};

Building from Source

git clone <repository>
cd config-manager
npm install
npm run build

Development

npm run dev    # Watch mode
npm run build  # Production build
npm run typecheck  # Type checking

License

MIT