@mohamed1_1ibrahim/dcli 1.0.0

package/README.md

@@ -0,0 +1,155 @@
+# dcli — Database CLI
+
+**dcli** (short for **D**atabase **CLI**) is a command-line tool for MongoDB data management. Designed for terminal use.
+
+## Features
+
+- **export** — Export a MongoDB database to JSON file(s)
+- **import** — Import a database or specific collection(s) from JSON file(s)
+- **ping** — Ping databases to prevent idle/inactivity pause
+- **info** — Show database collections and document counts
+- **add** — Register a database URI in the auto-ping list (with optional name)
+- **remove** — Remove a database by URI or friendly name
+- **auto-ping** — Schedule `dcli ping` to run automatically on Windows logon
+
+## Installation
+
+```bash
+npm install -g dcli
+```
+
+```bash
+git clone https://github.com/Mohamed-Ibrahim183/dcli
+cd dcli
+npm install
+npm link
+```
+
+## Usage
+
+### export
+
+Export a MongoDB database to JSON file(s). Output is prettified by default.
+
+```bash
+dcli export "mongodb://localhost:27017/mydb"
+```
+
+| Option | Description |
+|--------|-------------|
+| `-o, --output <name>` | Output name (without or with `.json` extension) |
+| `--format <type>` | `file` (single JSON), `split` (per collection), `all` (both) |
+| `--compact` | Minify JSON output (default is prettified) |
+| `--include <collections...>` | Only export these collections |
+| `--exclude <collections...>` | Skip these collections |
+| `--dry-run` | Preview without writing files |
+
+If the output file already exists, it auto-increments — `file.json` → `file (1).json` → `file (2).json`.
+
+```bash
+dcli export "mongodb://..." -o mydata
+dcli export "mongodb://..." --format split
+dcli export "mongodb://..." --format all --compact
+dcli export "mongodb://..." --include users posts
+dcli export "mongodb://..." --exclude logs analytics
+dcli export "mongodb://..." --dry-run
+```
+
+### import
+
+Restore from a full file, single collection file, or directory.
+
+| `-f` path | Behavior |
+|-----------|----------|
+| Full `.json` file | Restore entire DB (backup + confirmation + drop) |
+| Single collection `.json` | Restore that collection only |
+| Directory of `.json` files | Restore each file as a collection |
+
+```bash
+dcli import "mongodb://localhost:27017/mydb" -f backup.json
+dcli import "mongodb://..." -f ./users.json
+dcli import "mongodb://..." -f ./collections/
+```
+
+### ping
+
+Ping databases to prevent inactivity pause.
+
+```bash
+dcli ping                          # ping all from config
+dcli ping "mongodb://..."          # ping a raw URI
+dcli ping dbName                   # ping by friendly name from config
+dcli ping --file my-dbs.json       # ping all from a custom file
+```
+
+### info
+
+Show collections and document counts.
+
+```bash
+dcli info "mongodb://localhost:27017/mydb"
+```
+
+### add / remove
+
+Manage the auto-ping list (`~/.dcli/refresh.json`).
+
+```bash
+dcli add "mongodb://..." -n dbName          # add with friendly name
+dcli add "mongodb://..." -n dbName          # updates name if URI already exists
+dcli remove "mongodb://user:pass@..."       # remove by URI
+dcli remove dbName                          # remove by friendly name
+```
+
+### auto-ping
+
+Schedule `dcli ping` to run automatically 5 minutes after Windows logon.
+Requires administrator privileges to create the task.
+
+```bash
+dcli auto-ping           # create the task (run terminal as Admin)
+dcli auto-ping --remove  # remove the task (run terminal as Admin)
+```
+
+## Config File
+
+`~/.dcli/refresh.json`:
+
+```json
+{
+  "databases": [
+    { "uri": "mongodb://cluster0.example.mongodb.net/mydb", "name": "dbName" },
+    "mongodb://backup.example.mongodb.net/otherdb"
+  ]
+}
+```
+
+Entries can be objects with `uri` and optional `name`, or plain strings (backward compatible).
+
+## Export Format
+
+Single file:
+
+```json
+{
+  "database": "mydb",
+  "exportedAt": "2026-05-25T14:30:00.000Z",
+  "data": {
+    "users": [ { "_id": "...", "name": "Alice" } ],
+    "posts": [ { "_id": "...", "title": "Hello" } ]
+  }
+}
+```
+
+Split (per collection in a folder):
+
+```
+folder/
+├── users.json     [ { "_id": "...", ... }, ... ]
+├── posts.json     [ { "_id": "...", ... }, ... ]
+```
+
+## Dependencies
+
+- [commander](https://github.com/tj/commander.js) — CLI framework
+- [mongodb](https://github.com/mongodb/node-mongodb-native) — MongoDB driver

package/bin/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../src/main.js';

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@mohamed1_1ibrahim/dcli",
+  "version": "1.0.0",
+  "description": "Database CLI - MongoDB data management tool (export, import, ping, info)",
+  "main": "src/main.js",
+  "bin": {
+    "dcli": "bin/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "node bin/index.js"
+  },
+  "keywords": [
+    "mongodb",
+    "cli",
+    "database",
+    "backup",
+    "export",
+    "import",
+    "ping"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Mohamed-Ibrahim183/dcli.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "package.json"
+  ],
+  "dependencies": {
+    "commander": "^12.0.0",
+    "mongodb": "^6.8.0"
+  }
+}

package/src/commands/add.js

@@ -0,0 +1,20 @@
+import { addDatabase } from '../utils/config.js';
+import { success, warn, error } from '../utils/logger.js';
+
+export async function addCommand(uri, options) {
+  try {
+    const name = options.name;
+    const result = await addDatabase(uri, name);
+    const label = name ? `${name} (${uri})` : uri;
+    if (result === 'added') {
+      success(`Database added to ping list: ${label}`);
+    } else if (result === 'updated') {
+      success(`Name updated to "${name}" for ${uri}`);
+    } else {
+      warn(result === 'exists' && name ? `Database already exists${name ? ' with a different name' : ''}.` : `Database is already in the ping list.`);
+    }
+  } catch (err) {
+    error(`Failed to add database: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/autoPing.js

@@ -0,0 +1,34 @@
+import { execSync } from 'node:child_process';
+import { success, error, info } from '../utils/logger.js';
+
+const taskName = 'DCLI-AutoPing';
+
+export async function autoPingCommand(options) {
+  if (options.remove) {
+    try {
+      execSync(`schtasks /delete /tn "${taskName}" /f`, { stdio: 'pipe' });
+      success(`Task "${taskName}" removed.`);
+    } catch {
+      error(`Failed to remove task. It may not exist or you need administrator privileges.`);
+    }
+    return;
+  }
+
+  try {
+    const createCmd = [
+      `schtasks /create`,
+      `/tn "${taskName}"`,
+      `/sc ONLOGON`,
+      `/delay 0000:05`,
+      `/tr "cmd /c dcli ping"`,
+      `/f`,
+    ].join(' ');
+
+    execSync(createCmd, { stdio: 'pipe' });
+    success(`Task "${taskName}" created successfully.`);
+    info(`It will run "dcli ping" 5 minutes after you log on.`);
+  } catch (err) {
+    error(`Failed to create task: ${err.message.includes('Access is denied') ? 'Please run as Administrator (right-click terminal → Run as administrator).' : err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/exportCmd.js

@@ -0,0 +1,109 @@
+import { writeFile, mkdir, access } from 'node:fs/promises';
+import { join, extname, dirname, basename } from 'node:path';
+import { constants } from 'node:fs';
+import { connect, exportDatabase, extractDbName } from '../utils/mongodb.js';
+import { success, error, info, highlight } from '../utils/logger.js';
+
+function ensureJsonExt(name) {
+  return extname(name) ? name : `${name}.json`;
+}
+
+function filterCollections(data, include, exclude) {
+  const entries = Object.entries(data);
+  let filtered = entries;
+
+  if (include && include.length > 0) {
+    const set = new Set(include);
+    filtered = filtered.filter(([name]) => set.has(name));
+  }
+
+  if (exclude && exclude.length > 0) {
+    const set = new Set(exclude);
+    filtered = filtered.filter(([name]) => !set.has(name));
+  }
+
+  return Object.fromEntries(filtered);
+}
+
+async function exists(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function getUniquePath(filePath) {
+  if (!(await exists(filePath))) return filePath;
+
+  const dir = dirname(filePath);
+  const ext = extname(filePath);
+  const base = basename(filePath, ext);
+
+  let counter = 1;
+  while (true) {
+    const candidate = join(dir, `${base} (${counter})${ext}`);
+    if (!(await exists(candidate))) return candidate;
+    counter++;
+  }
+}
+
+export async function exportCommand(uri, options) {
+  const dbName = extractDbName(uri);
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const outputName = options.output || `data-${timestamp}-${dbName}`;
+  const format = options.format || 'file';
+  const compact = options.compact ? 0 : 2;
+  const include = options.include ? (Array.isArray(options.include) ? options.include : [options.include]) : [];
+  const exclude = options.exclude ? (Array.isArray(options.exclude) ? options.exclude : [options.exclude]) : [];
+
+  try {
+    const client = await connect(uri);
+    const rawData = await exportDatabase(client);
+    await client.close();
+
+    const data = filterCollections(rawData, include, exclude);
+
+    if (Object.keys(data).length === 0) {
+      info('No collections matched the given filters.');
+      process.exit(0);
+    }
+
+    if (options.dryRun) {
+      highlight('── Dry Run ──');
+      info(`Database: ${dbName}`);
+      info(`Collections: ${Object.keys(data).length}`);
+      for (const [name, docs] of Object.entries(data)) {
+        info(`  ${name}: ${docs.length} document(s)`);
+      }
+      info(`Format: ${format === 'all' ? 'file + split' : format}`);
+      if (outputName) info(`Output: ${outputName}`);
+      return;
+    }
+
+    if (format === 'file' || format === 'all') {
+      const fileName = await getUniquePath(ensureJsonExt(outputName));
+      const exportData = {
+        database: dbName,
+        exportedAt: new Date().toISOString(),
+        data,
+      };
+      await writeFile(fileName, JSON.stringify(exportData, null, compact), 'utf-8');
+      success(`Exported to ${fileName}`);
+    }
+
+    if (format === 'split' || format === 'all') {
+      const dirName = extname(outputName) ? outputName.replace(/\.[^.]+$/, '') : outputName;
+      await mkdir(dirName, { recursive: true });
+      for (const [name, docs] of Object.entries(data)) {
+        const filePath = await getUniquePath(join(dirName, `${name}.json`));
+        await writeFile(filePath, JSON.stringify(docs, null, compact), 'utf-8');
+      }
+      success(`Exported ${Object.keys(data).length} collection(s) to ${dirName}/`);
+    }
+  } catch (err) {
+    error(`Failed to export database: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/importCmd.js

@@ -0,0 +1,116 @@
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { statSync } from 'node:fs';
+import { join, parse } from 'node:path';
+import { createInterface } from 'node:readline';
+import { stdin as input, stdout as output } from 'node:process';
+import { connect, exportDatabase, dropDatabase, importDatabase, extractDbName } from '../utils/mongodb.js';
+import { info, warn, success, error } from '../utils/logger.js';
+
+function askQuestion(query) {
+  const rl = createInterface({ input, output });
+  return new Promise((resolve) => {
+    rl.question(query, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+function isFullFormat(data) {
+  return data && typeof data === 'object' && 'database' in data && 'data' in data;
+}
+
+async function loadCollectionFile(filePath) {
+  const content = await readFile(filePath, 'utf-8');
+  const data = JSON.parse(content);
+  const name = parse(filePath).name;
+  return { name, data: isFullFormat(data) ? data.data : { [name]: Array.isArray(data) ? data : [] } };
+}
+
+async function loadDirectory(dirPath) {
+  const entries = await readdir(dirPath);
+  const jsonFiles = entries.filter(e => e.endsWith('.json')).sort();
+  const result = {};
+  for (const file of jsonFiles) {
+    const { data } = await loadCollectionFile(join(dirPath, file));
+    Object.assign(result, data);
+  }
+  return result;
+}
+
+export async function importCommand(uri, options) {
+  const filePath = options.file;
+
+  try {
+    const isDir = statSync(filePath).isDirectory();
+    let dataToRestore;
+    let restoreType;
+
+    if (isDir) {
+      dataToRestore = await loadDirectory(filePath);
+      restoreType = 'directory';
+    } else {
+      const content = await readFile(filePath, 'utf-8');
+      const parsed = JSON.parse(content);
+      if (isFullFormat(parsed)) {
+        dataToRestore = parsed.data;
+        restoreType = 'full';
+      } else {
+        const name = parse(filePath).name;
+        dataToRestore = { [name]: Array.isArray(parsed) ? parsed : [] };
+        restoreType = 'collection';
+      }
+    }
+
+    const collectionCount = Object.keys(dataToRestore).length;
+
+    if (restoreType === 'full') {
+      const backupName = `backup-${new Date().toISOString().replace(/[:.]/g, '-')}.json`;
+      warn('This operation will DELETE the current database and restore from file.');
+      info(`Source: ${filePath}`);
+      info(`Backup will be saved to: ${backupName}`);
+      const answer = await askQuestion('Are you sure you want to proceed? (yes/no): ');
+
+      if (answer !== 'yes') {
+        info('Restore cancelled.');
+        return;
+      }
+
+      info('Creating backup of current database...');
+      const client = await connect(uri);
+      const currentData = await exportDatabase(client);
+      await writeFile(backupName, JSON.stringify({
+        database: extractDbName(uri),
+        exportedAt: new Date().toISOString(),
+        data: currentData,
+      }, null, 2), 'utf-8');
+      success(`Backup saved to ${backupName}`);
+
+      info('Dropping current database...');
+      await dropDatabase(client);
+      success('Database dropped.');
+
+      info('Restoring data...');
+      await importDatabase(client, dataToRestore);
+      await client.close();
+      success('Database restored successfully.');
+    } else {
+      info(`This will restore ${collectionCount} collection(s) from: ${filePath}`);
+      const answer = await askQuestion('Are you sure you want to proceed? (yes/no): ');
+
+      if (answer !== 'yes') {
+        info('Restore cancelled.');
+        return;
+      }
+
+      info('Restoring data...');
+      const client = await connect(uri);
+      await importDatabase(client, dataToRestore);
+      await client.close();
+      success(`${collectionCount} collection(s) restored successfully.`);
+    }
+  } catch (err) {
+    error(`Failed to restore data: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/info.js

@@ -0,0 +1,27 @@
+import { connect, extractDbName } from '../utils/mongodb.js';
+import { info, error, highlight } from '../utils/logger.js';
+
+export async function infoCommand(uri) {
+  try {
+    const client = await connect(uri);
+    const db = client.db();
+    const dbName = extractDbName(uri);
+    const collections = await db.listCollections().toArray();
+
+    highlight(`── ${dbName} ──`);
+    info(`Collections: ${collections.length}`);
+
+    let totalDocs = 0;
+    for (const coll of collections) {
+      const count = await db.collection(coll.name).countDocuments();
+      totalDocs += count;
+      info(`  ${coll.name}: ${count} document(s)`);
+    }
+
+    info(`Total documents: ${totalDocs}`);
+    await client.close();
+  } catch (err) {
+    error(`Failed to get database info: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/pingCmd.js

@@ -0,0 +1,58 @@
+import { connect, pingDatabase, extractDbName } from '../utils/mongodb.js';
+import { readConfig, normalizeEntry } from '../utils/config.js';
+import { info, success, warn, error } from '../utils/logger.js';
+
+async function pingUri(uri) {
+  try {
+    const client = await connect(uri);
+    await pingDatabase(client);
+    await client.close();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function displayName(entry) {
+  return entry.name || extractDbName(entry.uri) || entry.uri;
+}
+
+export async function pingCommand(uri, options) {
+  let entries;
+
+  if (uri) {
+    const config = await readConfig();
+    const named = config.databases.find(e => e.name === uri);
+    entries = named ? [named] : [{ uri }];
+  } else if (options.file) {
+    try {
+      const { readFile } = await import('node:fs/promises');
+      const content = await readFile(options.file, 'utf-8');
+      const parsed = JSON.parse(content);
+      entries = (parsed.databases || []).map(normalizeEntry);
+    } catch (err) {
+      error(`Failed to read file ${options.file}: ${err.message}`);
+      process.exit(1);
+    }
+  } else {
+    const config = await readConfig();
+    entries = config.databases;
+  }
+
+  if (entries.length === 0) {
+    warn('No databases configured for ping. Use "dcli add <uri>" to add one.');
+    process.exit(0);
+  }
+
+  info(`Pinging ${entries.length} database(s)...`);
+
+  for (const entry of entries) {
+    const label = displayName(entry);
+    const ok = await pingUri(entry.uri);
+    if (ok) {
+      success(`Pinged ${label} successfully`);
+    } else {
+      error(`Failed to ping ${label}`);
+    }
+  }
+}

package/src/commands/remove.js

@@ -0,0 +1,16 @@
+import { removeDatabase } from '../utils/config.js';
+import { success, warn, error } from '../utils/logger.js';
+
+export async function removeCommand(target) {
+  try {
+    const removed = await removeDatabase(target);
+    if (removed) {
+      success(`Database removed from ping list.`);
+    } else {
+      warn(`No database found matching "${target}" in the ping list.`);
+    }
+  } catch (err) {
+    error(`Failed to remove database: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/main.js

@@ -0,0 +1,86 @@
+import { Command } from 'commander';
+import { exportCommand } from './commands/exportCmd.js';
+import { importCommand } from './commands/importCmd.js';
+import { pingCommand } from './commands/pingCmd.js';
+import { infoCommand } from './commands/info.js';
+import { addCommand } from './commands/add.js';
+import { removeCommand } from './commands/remove.js';
+import { autoPingCommand } from './commands/autoPing.js';
+import { generateHelp, colorizeDefaultHelp } from './utils/help.js';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(
+  readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')
+);
+
+const program = new Command();
+
+program
+  .name('dcli')
+  .description('Database CLI — MongoDB data management tool')
+  .version(packageJson.version);
+
+program
+  .command('export')
+  .description('Export a MongoDB database to JSON file(s)')
+  .argument('<uri>', 'MongoDB connection URI')
+  .option('-o, --output <name>', 'Output name (default: data-<timestamp>-<db>)')
+  .option('--format <type>', 'Output format: file, split, all (default: file)', 'file')
+  .option('--compact', 'Minify JSON output (default is prettified)')
+  .option('--include <collections...>', 'Only export these collections')
+  .option('--exclude <collections...>', 'Skip these collections')
+  .option('--dry-run', 'Preview export without writing files')
+  .action(exportCommand);
+
+program
+  .command('import')
+  .description('Import a database or collection(s) from JSON file(s)')
+  .argument('<uri>', 'MongoDB connection URI')
+  .requiredOption('-f, --file <path>', 'File (.json), collection file, or directory of .json files')
+  .action(importCommand);
+
+program
+  .command('ping')
+  .description('Ping databases to prevent idle/inactivity pause')
+  .argument('[uri]', 'URI or friendly name from config (optional, uses config if omitted)')
+  .option('--file <path>', 'Path to a JSON file with database URIs (default: ~/.dcli/refresh.json)')
+  .action(pingCommand);
+
+program
+  .command('info')
+  .description('Show database collections and document counts')
+  .argument('<uri>', 'MongoDB connection URI')
+  .action(infoCommand);
+
+program
+  .command('add')
+  .description('Add a database URI to the auto-ping list')
+  .argument('<uri>', 'MongoDB connection URI')
+  .option('-n, --name <name>', 'Friendly name for this database')
+  .action(addCommand);
+
+program
+  .command('remove')
+  .description('Remove a database by URI or friendly name from the ping list')
+  .argument('<uri>', 'URI or friendly name of the database')
+  .action(removeCommand);
+
+program
+  .command('auto-ping')
+  .description('Schedule "dcli ping" to run automatically on startup')
+  .option('--remove', 'Remove the scheduled task')
+  .action(autoPingCommand);
+
+program.helpInformation = generateHelp;
+
+const origHelpInfo = Command.prototype.helpInformation;
+for (const cmd of program.commands) {
+  const orig = origHelpInfo.bind(cmd);
+  cmd.helpInformation = () => colorizeDefaultHelp(orig());
+}
+
+program.parse();

package/src/utils/config.js

@@ -0,0 +1,60 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const CONFIG_DIR = join(homedir(), '.dcli');
+const CONFIG_PATH = join(CONFIG_DIR, 'refresh.json');
+
+const DEFAULT_CONFIG = { databases: [] };
+
+async function ensureConfigDir() {
+  await mkdir(CONFIG_DIR, { recursive: true });
+}
+
+export function normalizeEntry(entry) {
+  if (typeof entry === 'string') return { uri: entry };
+  return entry;
+}
+
+export async function readConfig() {
+  try {
+    const data = await readFile(CONFIG_PATH, 'utf-8');
+    const config = JSON.parse(data);
+    config.databases = (config.databases || []).map(normalizeEntry);
+    return config;
+  } catch {
+    return { databases: [] };
+  }
+}
+
+export async function writeConfig(config) {
+  ensureConfigDir();
+  await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+export async function addDatabase(uri, name) {
+  const config = await readConfig();
+  const existing = config.databases.find(e => e.uri === uri);
+  if (existing) {
+    if (name && existing.name !== name) {
+      existing.name = name;
+      await writeConfig(config);
+      return 'updated';
+    }
+    return 'exists';
+  }
+  config.databases.push(name ? { uri, name } : { uri });
+  await writeConfig(config);
+  return 'added';
+}
+
+export async function removeDatabase(uri) {
+  const config = await readConfig();
+  const index = config.databases.findIndex(e => e.uri === uri || e.name === uri);
+  if (index === -1) {
+    return false;
+  }
+  config.databases.splice(index, 1);
+  await writeConfig(config);
+  return true;
+}

package/src/utils/help.js

@@ -0,0 +1,217 @@
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const BLUE = '\x1b[34m';
+const GRAY = '\x1b[90m';
+
+const COMMANDS = [
+  {
+    name: 'export',
+    args: '<uri>',
+    desc: 'Export a MongoDB database to JSON file(s)',
+    options: [
+      ['-o, --output <name>', 'Output name (default: data-<timestamp>-<db>)'],
+      ['--format <type>', 'Output format: file, split, all (default: file)'],
+      ['--compact', 'Minify JSON output (default is prettified)'],
+      ['--include <col...>', 'Only export these collections'],
+      ['--exclude <col...>', 'Skip these collections'],
+      ['--dry-run', 'Preview export without writing files'],
+    ],
+    examples: [
+      '$ dcli export "mongodb://localhost:27017/mydb"',
+      '$ dcli export "mongodb://localhost:27017/mydb" -o mydata',
+      '$ dcli export "mongodb://localhost:27017/mydb" --format split',
+      '$ dcli export "mongodb://localhost:27017/mydb" --format all',
+      '$ dcli export "mongodb://localhost:27017/mydb" --include users posts',
+      '$ dcli export "mongodb://localhost:27017/mydb" --exclude logs analytics',
+      '$ dcli export "mongodb://localhost:27017/mydb" --dry-run',
+    ],
+  },
+  {
+    name: 'import',
+    args: '<uri>',
+    desc: 'Import a database or collection(s) from JSON file(s)',
+    options: [
+      ['-f, --file <path>', 'File (.json), collection file, or directory of .json files (required)'],
+    ],
+    examples: [
+      '$ dcli import "mongodb://localhost:27017/mydb" -f backup.json',
+      '$ dcli import "mongodb://localhost:27017/mydb" -f ./users.json',
+      '$ dcli import "mongodb://localhost:27017/mydb" -f ./collections/',
+    ],
+  },
+  {
+    name: 'ping',
+    args: '[uri]',
+    desc: 'Ping databases to prevent idle/inactivity pause',
+    options: [
+      ['--file <path>', 'Path to a JSON file with database URIs (default: ~/.dcli/refresh.json)'],
+    ],
+    examples: [
+      '$ dcli ping',
+      '$ dcli ping "mongodb://localhost:27017/mydb"',
+      '$ dcli ping --file my-dbs.json',
+    ],
+  },
+  {
+    name: 'info',
+    args: '<uri>',
+    desc: 'Show database collections and document counts',
+    options: [],
+    examples: [
+      '$ dcli info "mongodb://localhost:27017/mydb"',
+    ],
+  },
+  {
+    name: 'add',
+    args: '<uri>',
+    desc: 'Add a database URI to the auto-ping list',
+    options: [
+      ['-n, --name <name>', 'Friendly name for this database'],
+    ],
+    examples: [
+      '$ dcli add "mongodb://user:pass@cluster.mongodb.net/mydb"',
+      '$ dcli add "mongodb://..." -n dbName',
+    ],
+  },
+  {
+    name: 'remove',
+    args: '<uri|name>',
+    desc: 'Remove a database by URI or friendly name from the ping list',
+    options: [],
+    examples: [
+      '$ dcli remove "mongodb://user:pass@cluster.mongodb.net/mydb"',
+      '$ dcli remove dbName',
+    ],
+  },
+  {
+    name: 'auto-ping',
+    args: '',
+    desc: 'Schedule "dcli ping" to run on logon (may need admin)',
+    options: [
+      ['--remove', 'Remove the scheduled task'],
+    ],
+    examples: [
+      '$ dcli auto-ping',
+      '$ dcli auto-ping --remove',
+    ],
+  },
+  {
+    name: 'help',
+    args: '[command]',
+    desc: 'Display help for a specific command',
+    options: [],
+    examples: [],
+  },
+];
+
+function label(text) {
+  return `${BOLD}${text}${RESET}`;
+}
+
+function cmdName(text) {
+  return `${YELLOW}${BOLD}${text}${RESET}`;
+}
+
+function optFlag(text) {
+  return `${GREEN}${text}${RESET}`;
+}
+
+function exText(text) {
+  return `${GRAY}${text}${RESET}`;
+}
+
+function highlight(text) {
+  return `${CYAN}${text}${RESET}`;
+}
+
+function dimmed(text) {
+  return `${DIM}${BLUE}${text}${RESET}`;
+}
+
+export function colorizeDefaultHelp(text) {
+  const lines = text.split('\n');
+  const result = [];
+
+  for (const line of lines) {
+    const trimmed = line.trimEnd();
+
+    if (/^Usage:/.test(trimmed)) {
+      result.push(`${BOLD}${trimmed}${RESET}`);
+    } else if (/^(Arguments|Options):$/.test(trimmed)) {
+      result.push(`${BOLD}${trimmed}${RESET}`);
+    } else if (/^\s{2}-h, --help\s/.test(trimmed)) {
+      result.push(`${DIM}${trimmed}${RESET}`);
+    } else if (/^\s{2}(-\S, )?--/.test(trimmed) && !/^Usage/.test(trimmed)) {
+      const sep = trimmed.slice(2).search(/\s{2,}/);
+      if (sep > -1) {
+        const flag = trimmed.slice(0, sep + 2);
+        const desc = trimmed.slice(sep + 2);
+        result.push(`  ${GREEN}${flag.trim()}${RESET}  ${desc}`);
+      } else {
+        result.push(`  ${GREEN}${trimmed.trim()}${RESET}`);
+      }
+    } else {
+      result.push(trimmed);
+    }
+  }
+
+  return result.join('\n');
+}
+
+export function generateHelp() {
+  const lines = [];
+  lines.push('');
+  lines.push(`  ${highlight('dcli')} ${DIM}— Database CLI / MongoDB data management tool${RESET}`);
+  lines.push('');
+  lines.push(`  ${label('Usage:')} dcli <command> [options]`);
+  lines.push('');
+  lines.push(`  ${label('Commands:')}`);
+  lines.push('');
+
+  for (const cmd of COMMANDS) {
+    const hasOpts = cmd.options.length > 0;
+    let display;
+    if (hasOpts) {
+      const a = cmd.args ? ` ${cmd.args}` : '';
+      display = `${cmdName(cmd.name)}${a} [options]`;
+    } else if (cmd.args) {
+      display = `${cmdName(cmd.name)} ${cmd.args}`;
+    } else {
+      display = cmdName(cmd.name);
+    }
+
+    const prefix = `    ${display}`;
+    const strippedLen = prefix.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const visualPad = strippedLen < 34 ? 34 - strippedLen : 2;
+    lines.push(`${prefix}${' '.repeat(visualPad)}${cmd.desc}`);
+
+    if (hasOpts) {
+      lines.push(`      ${label('Options:')}`);
+      for (const [flag, desc] of cmd.options) {
+        const f = optFlag(`      ${flag}`);
+        const fLen = `      ${flag}`.replace(/\x1b\[[0-9;]*m/g, '').length;
+        const pad = fLen < 32 ? 32 - fLen : 2;
+        lines.push(`${f}${' '.repeat(pad)}${desc}`);
+      }
+    }
+
+    if (cmd.examples.length) {
+      lines.push(`      ${label('Examples:')}`);
+      for (const ex of cmd.examples) {
+        lines.push(`        ${exText(ex)}`);
+      }
+    }
+
+    lines.push('');
+  }
+
+  lines.push(`  ${dimmed('Config file: ~/.dcli/refresh.json')}`);
+  lines.push(`  ${dimmed('Repository: https://github.com/Mohamed-Ibrahim183/dcli')}`);
+  lines.push('');
+
+  return lines.join('\n');
+}

package/src/utils/logger.js

@@ -0,0 +1,26 @@
+const RESET = '\x1b[0m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const BLUE = '\x1b[34m';
+const CYAN = '\x1b[36m';
+
+export function info(message) {
+  console.log(`${BLUE}ℹ${RESET} ${message}`);
+}
+
+export function success(message) {
+  console.log(`${GREEN}✔${RESET} ${message}`);
+}
+
+export function warn(message) {
+  console.log(`${YELLOW}⚠${RESET} ${message}`);
+}
+
+export function error(message) {
+  console.log(`${RED}✖${RESET} ${message}`);
+}
+
+export function highlight(message) {
+  console.log(`${CYAN}${message}${RESET}`);
+}

package/src/utils/mongodb.js

@@ -0,0 +1,53 @@
+import { MongoClient } from 'mongodb';
+
+export async function connect(uri) {
+  const client = new MongoClient(uri);
+  await client.connect();
+  return client;
+}
+
+export function extractDbName(uri) {
+  try {
+    const url = new URL(uri);
+    const db = url.pathname.replace(/^\//, '');
+    return db || 'test';
+  } catch {
+    return 'test';
+  }
+}
+
+export async function exportDatabase(client) {
+  const db = client.db();
+  const collections = await db.listCollections().toArray();
+  const data = {};
+
+  for (const collection of collections) {
+    const name = collection.name;
+    const docs = await db.collection(name).find({}).toArray();
+    data[name] = docs;
+  }
+
+  return data;
+}
+
+export async function importDatabase(client, data) {
+  const db = client.db();
+  const collections = Object.keys(data);
+
+  for (const name of collections) {
+    const docs = data[name];
+    if (docs.length > 0) {
+      await db.collection(name).insertMany(docs);
+    }
+  }
+}
+
+export async function dropDatabase(client) {
+  const db = client.db();
+  await db.dropDatabase();
+}
+
+export async function pingDatabase(client) {
+  const db = client.db();
+  await db.command({ ping: 1 });
+}