import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

const __dirname: string = path.dirname(fileURLToPath(import.meta.url));

console.log('1: Starting file read');

// Блокуюче читання файлу
const data: string = fs.readFileSync(path.join(__dirname, 'config.json'), 'utf8');
console.log('2: File content:', data);

console.log('3: Continuing execution');

import fs from 'node:fs';

console.log('1: Starting async read');

fs.readFile('large-file.txt', 'utf8', (err: NodeJS.ErrnoException | null, data: string) => {
  if (err) {
    console.error('Error reading file:', err.message);
    return;
  }
  console.log('3: File read complete, size:', data.length, 'bytes');
});

console.log('2: Continuing immediately without waiting');

// ❌ Callback Hell: важко читати та підтримувати
fs.readFile('config.json', 'utf8', (err, configData) => {
  if (err) return console.error(err);
  
  const config = JSON.parse(configData);
  
  fs.readFile(config.dataFile, 'utf8', (err, data) => {
    if (err) return console.error(err);
    
    const processedData = processData(data);
    
    fs.writeFile('output.txt', processedData, (err) => {
      if (err) return console.error(err);
      
      console.log('All operations completed');
    });
  });
});

import fs from 'node:fs/promises';

async function processFiles() {
  try {
    // Послідовні операції виглядають як синхронний код
    const configData = await fs.readFile('config.json', 'utf8');
    const config = JSON.parse(configData);
    
    const data = await fs.readFile(config.dataFile, 'utf8');
    const processedData = processData(data);
    
    await fs.writeFile('output.txt', processedData);
    
    console.log('All operations completed');
  } catch (error) {
    console.error('Error:', error.message);
  }
}

processFiles();

import fs from 'node:fs/promises';
import path from 'node:path';

async function readTextFile() {
  try {
    // Читання з явним кодуванням UTF-8
    const content = await fs.readFile('example.txt', 'utf8');
    console.log('File content:', content);
    console.log('Content type:', typeof content); // string
    
  } catch (error) {
    if (error.code === 'ENOENT') {
      console.error('File not found');
    } else if (error.code === 'EACCES') {
      console.error('Permission denied');
    } else {
      console.error('Unknown error:', error.message);
    }
  }
}

readTextFile();

import fs from 'node:fs/promises';

async function readImageFile() {
  // Без кодування — повертається Buffer
  const imageBuffer = await fs.readFile('photo.jpg');
  
  console.log('Buffer size:', imageBuffer.length, 'bytes');
  console.log('First 8 bytes:', imageBuffer.slice(0, 8));
  // <Buffer ff d8 ff e0 00 10 4a 46>
  
  // Перевірка сигнатури JPEG (Magic Number)
  if (imageBuffer[0] === 0xFF && imageBuffer[1] === 0xD8) {
    console.log('✓ Valid JPEG image');
  }
  
  // Конвертація у Base64 для передачі через JSON
  const base64Image = imageBuffer.toString('base64');
  console.log('Base64 preview:', base64Image.substring(0, 50) + '...');
}

readImageFile();

import fs from 'node:fs/promises';

async function readFileInChunks(filePath, chunkSize = 1024 * 1024) {
  let fileHandle;
  
  try {
    // Відкриття файлу для читання
    fileHandle = await fs.open(filePath, 'r');
    
    const buffer = Buffer.alloc(chunkSize);
    let bytesRead;
    let position = 0;
    
    // Читання файлу частинами
    while ((bytesRead = (await fileHandle.read(buffer, 0, chunkSize, position)).bytesRead) > 0) {
      const chunk = buffer.slice(0, bytesRead);
      console.log(`Read ${bytesRead} bytes at position ${position}`);
      
      // Обробка частини даних
      processChunk(chunk);
      
      position += bytesRead;
    }
    
    console.log('File reading completed');
    
  } finally {
    // Обов'язково закрити файл
    if (fileHandle) {
      await fileHandle.close();
    }
  }
}

function processChunk(chunk) {
  // Обробка частини файлу
  // Наприклад, підрахунок рядків або парсинг
}

readFileInChunks('large-log-file.txt', 64 * 1024); // Читати по 64 КБ

import fs from 'node:fs/promises';

async function loadConfig(configPath) {
  try {
    const jsonString = await fs.readFile(configPath, 'utf8');
    const config = JSON.parse(jsonString);
    
    // Валідація структури конфігурації
    if (!config.port || !config.host) {
      throw new Error('Invalid config: missing required fields');
    }
    
    return config;
    
  } catch (error) {
    if (error.code === 'ENOENT') {
      console.log('Config not found, using defaults');
      return getDefaultConfig();
    }
    
    if (error instanceof SyntaxError) {
      console.error('Invalid JSON syntax in config file');
      throw error;
    }
    
    throw error;
  }
}

function getDefaultConfig() {
  return {
    port: 3000,
    host: 'localhost',
    database: {
      url: 'postgresql://localhost:5432/mydb'
    }
  };
}

const config = await loadConfig('./config.json');
console.log('Server config:', config);

import fs from 'node:fs/promises';

async function saveUserData(user) {
  try {
    const userData = JSON.stringify(user, null, 2); // Форматований JSON з відступами
    
    await fs.writeFile('user-data.json', userData, 'utf8');
    console.log('✓ User data saved successfully');
    
  } catch (error) {
    console.error('Failed to save user data:', error.message);
    throw error;
  }
}

const user = {
  id: 1,
  name: 'Alice Johnson',
  email: 'alice@example.com',
  createdAt: new Date().toISOString()
};

await saveUserData(user);

{
  "id": 1,
  "name": "Alice Johnson",
  "email": "alice@example.com",
  "createdAt": "2026-09-02T15:30:00.000Z"
}

import fs from 'node:fs/promises';

async function logError(errorMessage) {
  const timestamp = new Date().toISOString();
  const logEntry = `[${timestamp}] ERROR: ${errorMessage}\n`;
  
  try {
    await fs.appendFile('error.log', logEntry, 'utf8');
  } catch (error) {
    console.error('Failed to write log:', error.message);
  }
}

// Додавання кількох записів
await logError('Database connection timeout');
await logError('Invalid user credentials');
await logError('Payment gateway unreachable');

import fs from 'node:fs/promises';
import crypto from 'node:crypto';

async function generateAndSaveRandomData() {
  // Генерація 1 МБ випадкових даних
  const randomData = crypto.randomBytes(1024 * 1024);
  
  await fs.writeFile('random.bin', randomData);
  
  console.log('✓ Binary file created:', randomData.length, 'bytes');
  
  // Перевірка: читання назад
  const readBack = await fs.readFile('random.bin');
  console.log('✓ Verification:', readBack.equals(randomData) ? 'PASS' : 'FAIL');
}

await generateAndSaveRandomData();

import fs from 'node:fs/promises';
import path from 'node:path';
import crypto from 'node:crypto';

async function atomicWrite(filePath, data, encoding = 'utf8') {
  // Генерація унікального імені тимчасового файлу
  const tempPath = `${filePath}.tmp.${crypto.randomBytes(6).toString('hex')}`;
  
  try {
    // 1. Запис у тимчасовий файл
    await fs.writeFile(tempPath, data, encoding);
    
    // 2. Атомарне перейменування (операція на рівні ОС)
    await fs.rename(tempPath, filePath);
    
    console.log('✓ Atomic write completed');
    
  } catch (error) {
    // Видалення тимчасового файлу у разі помилки
    try {
      await fs.unlink(tempPath);
    } catch {}
    
    throw error;
  }
}

// Використання
const criticalData = JSON.stringify({ balance: 1000000, currency: 'USD' });
await atomicWrite('./financial-data.json', criticalData);

import fs from 'node:fs/promises';

async function createSecretFile(content) {
  // 0o600 = rw------- (читання/запис лише для власника)
  await fs.writeFile('secret.key', content, { 
    encoding: 'utf8',
    mode: 0o600
  });
  
  console.log('✓ Secret file created with restricted permissions');
}

await createSecretFile('super-secret-api-key-12345');

import fs from 'node:fs/promises';

async function deleteFile(filePath) {
  try {
    await fs.unlink(filePath);
    console.log(`✓ File deleted: ${filePath}`);
  } catch (error) {
    if (error.code === 'ENOENT') {
      console.log(`File not found: ${filePath}`);
    } else {
      throw error;
    }
  }
}

await deleteFile('temp-file.txt');

// Альтернатива з rm() (Node.js 14.14+)
await fs.rm('temp-file.txt', { force: true }); // force: true ігнорує відсутність файлу

import fs from 'node:fs/promises';

async function backupFile(sourcePath, backupPath) {
  try {
    await fs.copyFile(sourcePath, backupPath);
    console.log(`✓ Backup created: ${sourcePath} → ${backupPath}`);
  } catch (error) {
    console.error('Backup failed:', error.message);
    throw error;
  }
}

await backupFile('database.sqlite', 'database.sqlite.backup');

// Копіювання з прапорцями
await fs.copyFile('source.txt', 'destination.txt', fs.constants.COPYFILE_EXCL);
// COPYFILE_EXCL: помилка, якщо destination.txt вже існує

import fs from 'node:fs/promises';

// Перейменування у тій самій директорії
await fs.rename('old-name.txt', 'new-name.txt');

// Переміщення у іншу директорію
await fs.rename('temp/file.txt', 'archive/file.txt');

// Переміщення + перейменування
await fs.rename('downloads/report.pdf', 'documents/2026-report.pdf');

import fs from 'node:fs/promises';

// Створення одної директорії
await fs.mkdir('new-folder');

// Створення вкладеної структури (рекурсивно)
await fs.mkdir('path/to/nested/folder', { recursive: true });

// Директорія з кастомними дозволами
await fs.mkdir('secure-data', { mode: 0o700 }); // rwx------

import fs from 'node:fs/promises';
import path from 'node:path';

async function listFiles(dirPath) {
  try {
    const entries = await fs.readdir(dirPath);
    
    console.log(`Contents of ${dirPath}:`);
    for (const entry of entries) {
      console.log(`  - ${entry}`);
    }
    
    return entries;
  } catch (error) {
    console.error('Error reading directory:', error.message);
    throw error;
  }
}

await listFiles('./my-project');

async function listFilesDetailed(dirPath) {
  const entries = await fs.readdir(dirPath, { withFileTypes: true });
  
  const files = [];
  const directories = [];
  
  for (const entry of entries) {
    const fullPath = path.join(dirPath, entry.name);
    
    if (entry.isDirectory()) {
      directories.push(entry.name);
    } else if (entry.isFile()) {
      files.push(entry.name);
    } else if (entry.isSymbolicLink()) {
      console.log(`Symlink: ${entry.name}`);
    }
  }
  
  console.log('Directories:', directories);
  console.log('Files:', files);
  
  return { files, directories };
}

await listFilesDetailed('./project');

import fs from 'node:fs/promises';
import path from 'node:path';

async function* walkDirectory(dirPath) {
  const entries = await fs.readdir(dirPath, { withFileTypes: true });
  
  for (const entry of entries) {
    const fullPath = path.join(dirPath, entry.name);
    
    if (entry.isDirectory()) {
      // Рекурсивний обхід піддиректорій
      yield* walkDirectory(fullPath);
    } else if (entry.isFile()) {
      yield fullPath;
    }
  }
}

// Використання генератора
console.log('All files in project:');
for await (const filePath of walkDirectory('./my-project')) {
  console.log(filePath);
}

async function findFilesByExtension(dirPath, extension) {
  const results = [];
  
  for await (const filePath of walkDirectory(dirPath)) {
    if (filePath.endsWith(extension)) {
      results.push(filePath);
    }
  }
  
  return results;
}

// Знайти всі JavaScript файли
const jsFiles = await findFilesByExtension('./src', '.js');
console.log(`Found ${jsFiles.length} JavaScript files`);
jsFiles.forEach(file => console.log(`  - ${file}`));

import fs from 'node:fs/promises';

// Видалення порожньої директорії
await fs.rmdir('empty-folder');

// Рекурсивне видалення директорії з усім вмістом
await fs.rm('folder-with-files', { recursive: true, force: true });

// Більш безпечна версія з перевіркою
async function removeDirectorySafe(dirPath) {
  try {
    const stats = await fs.stat(dirPath);
    
    if (!stats.isDirectory()) {
      throw new Error(`${dirPath} is not a directory`);
    }
    
    await fs.rm(dirPath, { recursive: true, force: true });
    console.log(`✓ Directory removed: ${dirPath}`);
    
  } catch (error) {
    if (error.code === 'ENOENT') {
      console.log(`Directory not found: ${dirPath}`);
    } else {
      throw error;
    }
  }
}

await removeDirectorySafe('./old-cache');

import fs from 'node:fs/promises';

async function getFileInfo(filePath) {
  try {
    const stats = await fs.stat(filePath);
    
    console.log('File Information:');
    console.log('  Size:', stats.size, 'bytes');
    console.log('  Created:', stats.birthtime.toISOString());
    console.log('  Modified:', stats.mtime.toISOString());
    console.log('  Accessed:', stats.atime.toISOString());
    console.log('  Is File:', stats.isFile());
    console.log('  Is Directory:', stats.isDirectory());
    console.log('  Is Symbolic Link:', stats.isSymbolicLink());
    console.log('  Permissions:', stats.mode.toString(8));
    
    // Розмір у зручному форматі
    const sizeKB = (stats.size / 1024).toFixed(2);
    const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
    console.log(`  Human-readable: ${sizeKB} KB (${sizeMB} MB)`);
    
    return stats;
    
  } catch (error) {
    console.error('Error getting file info:', error.message);
    throw error;
  }
}

await getFileInfo('./package.json');

import fs from 'node:fs/promises';

async function checkPermissions(filePath) {
  const permissions = {
    exists: false,
    readable: false,
    writable: false,
    executable: false
  };
  
  try {
    // Перевірка існування
    await fs.access(filePath, fs.constants.F_OK);
    permissions.exists = true;
    
    // Перевірка читання
    try {
      await fs.access(filePath, fs.constants.R_OK);
      permissions.readable = true;
    } catch {}
    
    // Перевірка запису
    try {
      await fs.access(filePath, fs.constants.W_OK);
      permissions.writable = true;
    } catch {}
    
    // Перевірка виконання
    try {
      await fs.access(filePath, fs.constants.X_OK);
      permissions.executable = true;
    } catch {}
    
  } catch (error) {
    if (error.code !== 'ENOENT') {
      throw error;
    }
  }
  
  return permissions;
}

const perms = await checkPermissions('./script.sh');
console.log('File permissions:', perms);
// { exists: true, readable: true, writable: true, executable: false }

import fs from 'node:fs/promises';

async function watchConfigFile(filePath) {
  console.log(`Watching for changes: ${filePath}`);
  
  try {
    const watcher = fs.watch(filePath);
    
    for await (const event of watcher) {
      console.log(`File ${event.eventType}: ${event.filename}`);
      
      if (event.eventType === 'change') {
        // Перезавантаження конфігурації
        const newConfig = await fs.readFile(filePath, 'utf8');
        console.log('Config reloaded:', JSON.parse(newConfig));
      }
    }
  } catch (error) {
    console.error('Watch error:', error.message);
  }
}

// Запуск моніторингу (працює доки не зупинити процес)
watchConfigFile('./config.json');

import fs from 'node:fs/promises';

// Створення символічного посилання
await fs.symlink('original-file.txt', 'link-to-file.txt');
console.log('✓ Symlink created');

// Читання, куди вказує посилання
const target = await fs.readlink('link-to-file.txt');
console.log('Link points to:', target); // "original-file.txt"

// Зміна вмісту через посилання працює
await fs.writeFile('link-to-file.txt', 'Updated content');
// original-file.txt тепер також містить "Updated content"

// 'file' — посилання на файл (за замовчуванням)
await fs.symlink('target.txt', 'link.txt', 'file');

// 'dir' — посилання на директорію
await fs.symlink('target-folder', 'link-folder', 'dir');

// 'junction' — тільки для Windows (directory junction)
await fs.symlink('C:\\Users\\Data', 'C:\\Links\\Data', 'junction');

import fs from 'node:fs/promises';

// Створення жорсткого посилання
await fs.link('original.txt', 'hardlink.txt');

// Обидва файли ідентичні на рівні файлової системи
const stats1 = await fs.stat('original.txt');
const stats2 = await fs.stat('hardlink.txt');

console.log('Same inode:', stats1.ino === stats2.ino); // true
console.log('Link count:', stats1.nlink); // 2 (кількість посилань на дані)

// Видалення одного посилання не видаляє дані
await fs.unlink('original.txt');
// hardlink.txt все ще доступний з тими самими даними

import fs from 'node:fs/promises';

// Створюємо файл та символічне посилання
await fs.writeFile('real-file.txt', 'Content');
await fs.symlink('real-file.txt', 'symlink.txt');

// stat() — статистика ЦІЛЬОВОГО файлу (через посилання)
const stats = await fs.stat('symlink.txt');
console.log('Is file:', stats.isFile());           // true
console.log('Is symlink:', stats.isSymbolicLink()); // false ❗

// lstat() — статистика САМОГО ПОСИЛАННЯ
const lstats = await fs.lstat('symlink.txt');
console.log('Is file:', lstats.isFile());           // false
console.log('Is symlink:', lstats.isSymbolicLink()); // true ✓

import fs from 'node:fs/promises';
import path from 'node:path';

async function resolveSymlinks(filePath, maxDepth = 10) {
  let currentPath = filePath;
  let depth = 0;
  const chain = [currentPath];
  
  while (depth < maxDepth) {
    try {
      const stats = await fs.lstat(currentPath);
      
      if (!stats.isSymbolicLink()) {
        // Досягли реального файлу
        return { resolved: currentPath, chain };
      }
      
      // Читаємо куди вказує посилання
      const target = await fs.readlink(currentPath);
      
      // Обробка відносних посилань
      if (!path.isAbsolute(target)) {
        currentPath = path.join(path.dirname(currentPath), target);
      } else {
        currentPath = target;
      }
      
      chain.push(currentPath);
      depth++;
      
    } catch (error) {
      if (error.code === 'ENOENT') {
        return { resolved: null, chain, error: 'Broken symlink' };
      }
      throw error;
    }
  }
  
  return { resolved: null, chain, error: 'Max depth exceeded (circular link?)' };
}

// Використання
const result = await resolveSymlinks('./my-link.txt');
console.log('Symlink chain:', result.chain);
console.log('Final target:', result.resolved);

import fs from 'node:fs/promises';

// Зміна прав доступу (octal нотація)
await fs.chmod('script.sh', 0o755);
// rwxr-xr-x: власник може все, інші - читання та виконання

// Зробити файл доступним лише власнику
await fs.chmod('secret.key', 0o600);
// rw-------: лише власник може читати/писати

// Символічна нотація через побітові операції
const stats = await fs.stat('file.txt');
const currentMode = stats.mode;

// Додати біт виконання для власника
await fs.chmod('file.txt', currentMode | 0o100);

// Забрати біт запису для групи та інших
await fs.chmod('file.txt', currentMode & ~0o022);

// Структура: 0o[спеціальні][власник][група][інші]
// Кожна цифра — сума прав: 4 (read) + 2 (write) + 1 (execute)

const permissions = {
  '0o644': 'rw-r--r--', // Стандарт для файлів: власник r/w, інші тільки r
  '0o755': 'rwxr-xr-x', // Стандарт для скриптів: всі x, тільки власник w
  '0o600': 'rw-------', // Приватні файли: тільки власник
  '0o700': 'rwx------', // Приватні директорії
  '0o777': 'rwxrwxrwx', // ❌ Небезпечно! Всі права для всіх
};

// Приклад обчислення
const ownerRWX = 4 + 2 + 1; // 7 (повні права)
const groupRX  = 4 + 0 + 1; // 5 (читання + виконання)
const othersRX = 4 + 0 + 1; // 5 (читання + виконання)

const mode = parseInt(`${ownerRWX}${groupRX}${othersRX}`, 8); // 0o755
await fs.chmod('app.sh', mode);

import fs from 'node:fs/promises';

// Зміна власника та групи (потрібні root-права)
try {
  await fs.chown('important-file.txt', 1000, 1000);
  // uid: 1000, gid: 1000
  console.log('✓ Owner changed');
} catch (error) {
  if (error.code === 'EPERM') {
    console.error('Permission denied: need root privileges');
  }
}

// Зміна лише власника (група залишається)
const stats = await fs.stat('file.txt');
await fs.chown('file.txt', 1001, stats.gid);

// Рекурсивна зміна власника директорії
async function chownRecursive(dirPath, uid, gid) {
  await fs.chown(dirPath, uid, gid);
  
  const entries = await fs.readdir(dirPath, { withFileTypes: true });
  
  for (const entry of entries) {
    const fullPath = path.join(dirPath, entry.name);
    
    if (entry.isDirectory()) {
      await chownRecursive(fullPath, uid, gid);
    } else {
      await fs.chown(fullPath, uid, gid);
    }
  }
}

await chownRecursive('./project', 1000, 1000);

import fs from 'node:fs/promises';

// Встановлення конкретного часу
const accessTime = new Date('2026-01-01T00:00:00Z');
const modifyTime = new Date('2026-01-01T12:00:00Z');

await fs.utimes('file.txt', accessTime, modifyTime);

// Встановлення поточного часу
await fs.utimes('file.txt', new Date(), new Date());

// Часто використовується для "touch" команди (оновлення часу)
async function touch(filePath) {
  try {
    const now = new Date();
    await fs.utimes(filePath, now, now);
  } catch (error) {
    if (error.code === 'ENOENT') {
      // Файл не існує — створити порожній
      await fs.writeFile(filePath, '');
    } else {
      throw error;
    }
  }
}

await touch('timestamp.txt');

import fs from 'node:fs/promises';
import path from 'node:path';

async function deployWithPermissions(sourceDir, targetDir, config) {
  console.log(`Deploying ${sourceDir} → ${targetDir}`);
  
  const { fileMode = 0o644, dirMode = 0o755, owner = null } = config;
  
  async function copyWithPermissions(src, dest) {
    const entries = await fs.readdir(src, { withFileTypes: true });
    
    for (const entry of entries) {
      const srcPath = path.join(src, entry.name);
      const destPath = path.join(dest, entry.name);
      
      if (entry.isDirectory()) {
        // Створити директорію з правильними правами
        await fs.mkdir(destPath, { recursive: true, mode: dirMode });
        
        // Рекурсивне копіювання
        await copyWithPermissions(srcPath, destPath);
        
      } else if (entry.isFile()) {
        // Копіювати файл
        await fs.copyFile(srcPath, destPath);
        
        // Встановити права
        await fs.chmod(destPath, fileMode);
        
        // Змінити власника (якщо вказано і є права)
        if (owner) {
          try {
            await fs.chown(destPath, owner.uid, owner.gid);
          } catch (error) {
            if (error.code !== 'EPERM') throw error;
            console.warn(`Cannot change owner: ${destPath}`);
          }
        }
        
        console.log(`  ✓ ${destPath} [mode: ${fileMode.toString(8)}]`);
      }
    }
  }
  
  // Створити цільову директорію
  await fs.mkdir(targetDir, { recursive: true, mode: dirMode });
  
  // Копіювання з правами
  await copyWithPermissions(sourceDir, targetDir);
  
  console.log('✓ Deployment completed');
}

// Використання
await deployWithPermissions('./dist', '/var/www/app', {
  fileMode: 0o644,  // rw-r--r--
  dirMode: 0o755,   // rwxr-xr-x
  owner: { uid: 1000, gid: 1000 } // www-data
});

import fs from 'node:fs/promises';
import path from 'node:path';
import { createWriteStream, createReadStream } from 'node:fs';
import { pipeline } from 'node:stream/promises';

async function backupDirectory(sourceDir, backupDir) {
  const startTime = Date.now();
  
  console.log(`Starting backup: ${sourceDir} → ${backupDir}`);
  
  // Створення директорії для бекапу
  await fs.mkdir(backupDir, { recursive: true });
  
  let fileCount = 0;
  let totalSize = 0;
  
  // Рекурсивна функція копіювання
  async function copyRecursive(src, dest) {
    const entries = await fs.readdir(src, { withFileTypes: true });
    
    for (const entry of entries) {
      const srcPath = path.join(src, entry.name);
      const destPath = path.join(dest, entry.name);
      
      if (entry.isDirectory()) {
        // Створити піддиректорію та обробити рекурсивно
        await fs.mkdir(destPath, { recursive: true });
        await copyRecursive(srcPath, destPath);
        
      } else if (entry.isFile()) {
        // Копіювати файл
        await fs.copyFile(srcPath, destPath);
        
        // Статистика
        const stats = await fs.stat(srcPath);
        fileCount++;
        totalSize += stats.size;
        
        console.log(`  ✓ ${srcPath}`);
      }
    }
  }
  
  try {
    await copyRecursive(sourceDir, backupDir);
    
    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
    const sizeMB = (totalSize / 1024 / 1024).toFixed(2);
    
    console.log(`\n✓ Backup completed in ${duration}s`);
    console.log(`  Files: ${fileCount}`);
    console.log(`  Total size: ${sizeMB} MB`);
    
  } catch (error) {
    console.error('Backup failed:', error.message);
    throw error;
  }
}

// Використання
const timestamp = new Date().toISOString().replace(/:/g, '-').split('.')[0];
await backupDirectory(
  './my-project',
  `./backups/my-project-${timestamp}`
);