xp-gate 0.5.1

package/lib/init.js

@@ -0,0 +1,367 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { checkDeps } = require('./detect-deps.js');
+const { checkBash } = require('./detect-deps.js');
+
+// Cross-platform home directory resolution with os.homedir() fallback
+const HOME_DIR = process.env.HOME || process.env.USERPROFILE || os.homedir();
+
+const CONFIG_DIR = path.join(HOME_DIR, '.config', 'xp-gate');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'xp-gate.json');
+const TEMPLATE_DIR = path.join(HOME_DIR, '.config', 'opencode', 'git-hooks-template');
+const GLOBAL_HOOKS_DIR = path.join(CONFIG_DIR, 'hooks');
+const GLOBAL_ADAPTERS_DIR = path.join(CONFIG_DIR, 'adapters');
+
+function copyHooks(srcDir, destDir) {
+  ['pre-commit', 'pre-push'].forEach(hook => {
+    const src = path.join(srcDir, 'hooks', hook);
+    const dest = path.join(destDir, hook);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, dest);
+      fs.chmodSync(dest, 0o755);
+    }
+  });
+}
+
+function copyAdapters(srcDir, destDir) {
+  const adapterSrc = path.join(srcDir, 'adapter-common.sh');
+  if (fs.existsSync(adapterSrc)) {
+    fs.copyFileSync(adapterSrc, path.join(destDir, 'adapter-common.sh'));
+  }
+  const adaptersDir = path.join(srcDir, 'adapters');
+  if (fs.existsSync(adaptersDir)) {
+    fs.readdirSync(adaptersDir).forEach(f => {
+      if (f.endsWith('.sh')) {
+        fs.copyFileSync(path.join(adaptersDir, f), path.join(destDir, f));
+      }
+    });
+  }
+}
+
+function logDeps(depCheck) {
+  if (!depCheck.ok) {
+    console.warn('Warning: Missing dependencies');
+    if (depCheck.missing) console.warn(`  - ${depCheck.missing} (required)`);
+    if (depCheck.versionMismatch) {
+      console.warn(`  - ${depCheck.versionMismatch.name}: need ${depCheck.versionMismatch.required}, found ${depCheck.versionMismatch.found}`);
+    }
+    console.warn('Skills may not work without these dependencies');
+    console.warn('Install from: https://github.com/boyingliu01/superpowers\n');
+  } else {
+    console.log('Dependencies: OK\n');
+  }
+}
+
+function printUsage() {
+  console.log('Choose installation mode:');
+  console.log('  1) Global  — all git projects use the same hooks (recommended)');
+  console.log('  2) Local   — install hooks into current project only\n');
+  console.log('Usage:');
+  console.log('  xp-gate init --global     # all projects');
+  console.log('  xp-gate init              # current project');
+  console.log('  xp-gate setup-global      # all projects (alias)\n');
+}
+
+function getGitDir() {
+  try {
+    const { execSync } = require('child_process');
+    return execSync('git rev-parse --git-dir', { encoding: 'utf8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function ensureConfigDir() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+function updateConfig(updates) {
+  let config = {};
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    } catch {}
+  }
+  config = { ...config, ...updates };
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function sha256File(filePath) {
+  try {
+    const content = fs.readFileSync(filePath);
+    return crypto.createHash('sha256').update(content).digest('hex');
+  } catch {
+    return null;
+  }
+}
+
+function generateManifest(srcDir, projectRoot) {
+  const manifest = {
+    version: 1,
+    files: {},
+    injectedSections: {}
+  };
+
+  const gitDir = path.join(projectRoot, '.git');
+  const hooksDir = path.join(gitDir, 'hooks');
+  const githooksDir = path.join(projectRoot, 'githooks');
+
+  // Hooks
+  ['pre-commit', 'pre-push'].forEach(hook => {
+    const hookPath = path.join(hooksDir, hook);
+    if (fs.existsSync(hookPath)) {
+      const stat = fs.statSync(hookPath);
+      manifest.files[`.git/hooks/${hook}`] = {
+        sha256: sha256File(hookPath),
+        size: stat.size
+      };
+    }
+  });
+
+  // adapter-common.sh
+  const adapterCommonPath = path.join(githooksDir, 'adapter-common.sh');
+  if (fs.existsSync(adapterCommonPath)) {
+    const stat = fs.statSync(adapterCommonPath);
+    manifest.files['githooks/adapter-common.sh'] = {
+      sha256: sha256File(adapterCommonPath),
+      size: stat.size
+    };
+  }
+
+  // Adapter scripts
+  const adaptersDir = path.join(githooksDir, 'adapters');
+  if (fs.existsSync(adaptersDir)) {
+    fs.readdirSync(adaptersDir).forEach(f => {
+      const fPath = path.join(adaptersDir, f);
+      if (fs.statSync(fPath).isFile()) {
+        const stat = fs.statSync(fPath);
+        manifest.files[`githooks/adapters/${f}`] = {
+          sha256: sha256File(fPath),
+          size: stat.size
+        };
+      }
+    });
+  }
+
+  // Template dir note
+  manifest.templateDir = TEMPLATE_DIR;
+
+  // Injected sections
+  const agentsPath = path.join(projectRoot, 'AGENTS.md');
+  if (fs.existsSync(agentsPath)) {
+    try {
+      const content = fs.readFileSync(agentsPath, 'utf8');
+      if (content.includes('## AI CODING DISCIPLINE (Karpathy Principles)')) {
+        manifest.injectedSections['AGENTS.md'] = '## AI CODING DISCIPLINE (Karpathy Principles)';
+      }
+    } catch {}
+  }
+
+  return manifest;
+}
+
+function generateGlobalManifest(srcDir) {
+  const manifest = {
+    version: 1,
+    files: {},
+    gitConfig: {}
+  };
+
+  // Global hooks
+  ['pre-commit', 'pre-push'].forEach(hook => {
+    const hookPath = path.join(GLOBAL_HOOKS_DIR, hook);
+    if (fs.existsSync(hookPath)) {
+      const stat = fs.statSync(hookPath);
+      manifest.files[`hooks/${hook}`] = {
+        sha256: sha256File(hookPath),
+        size: stat.size
+      };
+    }
+  });
+
+  // adapter-common.sh
+  const adapterCommonPath = path.join(GLOBAL_ADAPTERS_DIR, 'adapter-common.sh');
+  if (fs.existsSync(adapterCommonPath)) {
+    const stat = fs.statSync(adapterCommonPath);
+    manifest.files['adapters/adapter-common.sh'] = {
+      sha256: sha256File(adapterCommonPath),
+      size: stat.size
+    };
+  }
+
+  // Adapter scripts
+  if (fs.existsSync(GLOBAL_ADAPTERS_DIR)) {
+    fs.readdirSync(GLOBAL_ADAPTERS_DIR).forEach(f => {
+      const fPath = path.join(GLOBAL_ADAPTERS_DIR, f);
+      if (fs.statSync(fPath).isFile() && f !== 'adapter-common.sh') {
+        const stat = fs.statSync(fPath);
+        manifest.files[`adapters/${f}`] = {
+          sha256: sha256File(fPath),
+          size: stat.size
+        };
+      }
+    });
+  }
+
+  // git config
+  manifest.gitConfig = {
+    'core.hooksPath': GLOBAL_HOOKS_DIR
+  };
+
+  manifest.templateDir = TEMPLATE_DIR;
+
+  return manifest;
+}
+
+async function init(args) {
+  console.log('XP-Gate Initialization');
+  console.log('====================\n');
+
+  // Check bash availability (required for shell hooks)
+  const bashCheck = checkBash();
+  if (bashCheck.ok) {
+    console.log(`Bash: ✓ ${bashCheck.path} (v${bashCheck.version})\n`);
+  } else {
+    console.warn(`Bash: ✗ NOT FOUND`);
+    console.warn(`  ${bashCheck.message}\n`);
+  }
+
+  logDeps(await checkDeps());
+
+  const installMode = args.includes('--global') ? 'global' :
+                      args.includes('--core-only') ? 'local' :
+                      args.includes('--full') ? 'local' : null;
+
+  if (!installMode) { printUsage(); return 0; }
+  if (installMode === 'global') return setupGlobal(args);
+  return installLocal(args);
+}
+
+async function installLocal(args) {
+  const gitDir = getGitDir();
+  if (!gitDir) {
+    console.error('Error: Not a git repository');
+    console.error('Run xp-gate init from inside a git repository');
+    return 1;
+  }
+
+  const projectRoot = path.dirname(gitDir);
+  const hooksDir = path.join(projectRoot, '.git', 'hooks');
+  const srcDir = path.dirname(__dirname);
+
+  console.log(`Mode: Local (per-project)`);
+  console.log(`Project: ${projectRoot}`);
+  console.log(`Git hooks: ${hooksDir}\n`);
+  console.log('Installing hooks...');
+
+  copyHooks(srcDir, hooksDir);
+  console.log('  pre-commit -> .git/hooks/');
+  console.log('  pre-push -> .git/hooks/');
+
+  fs.mkdirSync(path.join(projectRoot, 'githooks', 'adapters'), { recursive: true });
+  copyAdapters(srcDir, path.join(projectRoot, 'githooks'));
+  console.log(`  adapter-common.sh + adapters -> ${projectRoot}/githooks/`);
+
+  fs.mkdirSync(TEMPLATE_DIR, { recursive: true });
+  copyHooks(srcDir, TEMPLATE_DIR);
+  fs.mkdirSync(path.join(TEMPLATE_DIR, 'adapters'), { recursive: true });
+
+  ensureConfigDir();
+
+  const manifest = generateManifest(srcDir, projectRoot);
+  updateConfig({ lastInit: new Date().toISOString(), mode: 'local', manifest });
+
+  injectKarpathyPrinciples(projectRoot);
+
+  console.log('\nInstallation complete!');
+  console.log('Run git commit to trigger quality gates');
+  return 0;
+}
+
+async function setupGlobal(args) {
+  const srcDir = path.dirname(__dirname);
+
+  console.log('XP-Gate Global Setup');
+  console.log('====================\n');
+  console.log('Mode: Global (all git projects)');
+  console.log(`Global hooks: ${GLOBAL_HOOKS_DIR}`);
+  console.log(`Global adapters: ${GLOBAL_ADAPTERS_DIR}\n`);
+
+  fs.mkdirSync(GLOBAL_HOOKS_DIR, { recursive: true });
+  fs.mkdirSync(GLOBAL_ADAPTERS_DIR, { recursive: true });
+
+  copyHooks(srcDir, GLOBAL_HOOKS_DIR);
+  console.log('Installing hooks...');
+  console.log(`  pre-commit -> ${GLOBAL_HOOKS_DIR}`);
+  console.log(`  pre-push -> ${GLOBAL_HOOKS_DIR}`);
+
+  copyAdapters(srcDir, GLOBAL_ADAPTERS_DIR);
+  console.log(`  adapter-common.sh + adapters -> ${GLOBAL_ADAPTERS_DIR}`);
+
+  const { execSync } = require('child_process');
+  try {
+    execSync(`git config --global core.hooksPath "${GLOBAL_HOOKS_DIR}"`);
+    console.log(`\n  git config --global core.hooksPath "${GLOBAL_HOOKS_DIR}"`);
+  } catch (e) {
+    console.warn('Warning: Could not set git core.hooksPath config');
+  }
+
+  ensureConfigDir();
+
+  const manifest = generateGlobalManifest(srcDir);
+  updateConfig({ lastInit: new Date().toISOString(), mode: 'global', manifest });
+
+  console.log('\nGlobal setup complete!');
+  console.log('All git repositories will now use xp-gate quality gates.');
+  console.log('Per-project adapters can still override by creating <repo>/githooks/');
+  return 0;
+}
+
+function injectKarpathyPrinciples(projectRoot) {
+  const agentsPath = path.join(projectRoot, 'AGENTS.md');
+  if (!fs.existsSync(agentsPath)) return;
+
+  let content;
+  try {
+    content = fs.readFileSync(agentsPath, 'utf8');
+  } catch (e) {
+    console.warn(`  Warning: could not read AGENTS.md: ${e.message}`);
+    return;
+  }
+
+  if (content.includes('## AI CODING DISCIPLINE (Karpathy Principles)')) return;
+
+  const section = `
+## AI CODING DISCIPLINE (Karpathy Principles)
+
+**原则 3: Surgical Changes（外科手术式改动）**
+- 只碰必须碰的代码。只清理自己制造的混乱。
+- 编辑现有代码时，不"优化"相邻代码、注释或 formatting
+- 不重构没坏的东西
+- 匹配现有代码风格，即使 AI 更喜欢另一种
+- 发现无关的死代码 → 提及但不要删除（除非用户明确要求）
+- 自己的改动产生的 orphaned import/variable/function → 必须清理
+- 判定标准: 每一行改动都应能直接追溯到用户的请求
+
+**原则 4: Goal-Driven Execution（目标驱动执行）**
+- 定义成功标准。循环直到验证。
+- 把指令转化为可验证目标：
+  - "加验证" → "写测试 → 让测试通过"
+  - "修 bug" → "写复现测试 → 让测试通过"
+  - "重构 X" → "确保重构前后测试都通过"
+- 多步骤任务列出验证点
+- 改完任何代码后必须运行测试确认无 regression
+
+`;
+
+  try {
+    fs.appendFileSync(agentsPath, section, 'utf8');
+    console.log('  Karpathy Principles injected into AGENTS.md');
+  } catch (e) {
+    console.warn(`  Warning: could not write to AGENTS.md: ${e.message}`);
+  }
+}
+
+module.exports = { init };

package/lib/install-skill.js

@@ -0,0 +1,184 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const http = require('http');
+const { execSync } = require('child_process');
+const { checkDeps } = require('./detect-deps.js');
+const { downloadFromGitHub } = require('./download-skill.js');
+const { rollback } = require('./rollback.js');
+
+// Cross-platform home directory resolution
+const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
+
+const CONFIG_DIR = path.join(HOME, '.config', 'xp-gate');
+const SKILLS_DIR = path.join(HOME, '.config', 'opencode', 'skills');
+
+const SKILLS_REGISTRY = {
+  'sprint-flow': { repo: 'boyingliu01/xp-gate', path: 'skills/sprint-flow' },
+  'delphi-review': { repo: 'boyingliu01/xp-gate', path: 'skills/delphi-review' },
+  'test-spec': { repo: 'boyingliu01/xp-gate', path: 'skills/test-spec' },
+  'ralph-loop': { repo: 'boyingliu01/xp-gate', path: 'skills/ralph-loop' }
+};
+
+async function installSkill(name, options = {}) {
+  const { offline = false, verbose = false, force = false } = options;
+  
+  const depCheck = await checkDeps();
+  if (!depCheck.ok) {
+    if (depCheck.missing) {
+      console.error(`Error: ${depCheck.missing} is required but not installed`);
+      console.error('Please install superpowers and gstack first');
+      console.error('See: https://github.com/boyingliu01/superpowers');
+      return 1;
+    }
+    if (depCheck.versionMismatch) {
+      console.error(`Error: ${depCheck.versionMismatch.name} version too old`);
+      console.error(`Need: ${depCheck.versionMismatch.required}, Found: ${depCheck.versionMismatch.found}`);
+      return 1;
+    }
+  }
+  
+  const skillInfo = SKILLS_REGISTRY[name];
+  if (!skillInfo) {
+    console.error(`Error: Unknown skill: ${name}`);
+    console.error('Available skills: ' + Object.keys(SKILLS_REGISTRY).join(', '));
+    return 1;
+  }
+  
+  const targetDir = path.join(SKILLS_DIR, name);
+  if (fs.existsSync(targetDir) && !force) {
+    console.error(`Error: ${name} is already installed`);
+    console.error('Use --force to overwrite');
+    return 1;
+  }
+  
+  const installId = `${name}-${Date.now()}`;
+  const backupDir = path.join(CONFIG_DIR, 'backup', installId);
+  
+  if (fs.existsSync(targetDir)) {
+    fs.mkdirSync(backupDir, { recursive: true });
+    copyDirRecursive(targetDir, backupDir);
+  }
+  
+  try {
+    console.log(`Installing ${name}...`);
+    
+    const skillUrl = `https://raw.githubusercontent.com/${skillInfo.repo}/main/${skillInfo.path}/SKILL.md`;
+    const targetFile = path.join(targetDir, 'SKILL.md');
+    
+    fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+    
+    let downloaded = false;
+    if (!offline) {
+      try {
+        await downloadFile(skillUrl, targetFile, verbose);
+        downloaded = true;
+      } catch (err) {
+        if (verbose) console.warn(`Download failed: ${err.message}`);
+      }
+    }
+    
+    if (!downloaded) {
+      if (offline) {
+        console.error(`Error: --offline specified but ${name} not in cache`);
+        return 2;
+      }
+      console.error(`Error: Failed to download ${name}`);
+      console.error('Check network connection');
+      return 1;
+    }
+    
+    ensureConfigDir();
+    updateConfig({
+      installedSkills: {
+        ...(getConfig().installedSkills || {}),
+        [name]: { version: '1.0.0', installedAt: new Date().toISOString() }
+      }
+    });
+    
+    if (verbose) console.log(`Installed to ${targetDir}`);
+    console.log(`✓ ${name} installed`);
+    
+    return 0;
+  } catch (err) {
+    console.error(`Error: Install failed - ${err.message}`);
+    await rollback(installId);
+    return 1;
+  }
+}
+
+async function downloadFile(url, dest, verbose) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    
+    const protocol = url.startsWith('https') ? https : http;
+    
+    if (verbose) console.log(`Downloading ${url}...`);
+    
+    protocol.get(url, { timeout: 30000 }, (response) => {
+      if (response.statusCode === 301 || response.statusCode === 302) {
+        const redirectUrl = response.headers.location;
+        file.close();
+        fs.unlinkSync(dest);
+        downloadFile(redirectUrl, dest, verbose).then(resolve).catch(reject);
+        return;
+      }
+      
+      if (response.statusCode !== 200) {
+        file.close();
+        reject(new Error(`HTTP ${response.statusCode}`));
+        return;
+      }
+      
+      response.pipe(file);
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+    }).on('error', (err) => {
+      file.close();
+      if (fs.existsSync(dest)) fs.unlinkSync(dest);
+      reject(err);
+    });
+  });
+}
+
+function copyDirRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(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()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function ensureConfigDir() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+function getConfig() {
+  const configFile = path.join(CONFIG_DIR, 'xp-gate.json');
+  if (fs.existsSync(configFile)) {
+    try {
+      return JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    } catch {}
+  }
+  return {};
+}
+
+function updateConfig(updates) {
+  const configFile = path.join(CONFIG_DIR, 'xp-gate.json');
+  const config = getConfig();
+  Object.assign(config, updates);
+  fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+}
+
+module.exports = { installSkill };

package/lib/migrate.js

@@ -0,0 +1,120 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Cross-platform home directory resolution (matches other modules pattern)
+const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
+
+/**
+ * Migration helper for v0.4.x → v0.5.x.
+ * - Cleans GitHub Packages PAT lines from ~/.npmrc
+ * - Checks ~/.config/xp-gate/cache/ for old cached downloads
+ *
+ * Safety: Only removes lines that contain 'npm.pkg.github.com'.
+ * Generic PAT lines (other registries) are never touched.
+ *
+ * @param {string[]} args - CLI arguments (--dry-run supported)
+ * @returns {Promise<number>} exit code (0 = success)
+ */
+async function migrate(args = []) {
+  const options = { dryRun: args.includes('--dry-run') };
+
+  const npmrcPath = path.join(HOME, '.npmrc');
+  const cacheDir = path.join(HOME, '.config', 'xp-gate', 'cache');
+
+  let npmrcChanged = false;
+  let npmrcRemovedCount = 0;
+
+  // === Phase 1: ~/.npmrc cleanup ===
+  console.log('Checking ~/.npmrc for GitHub Packages residue...');
+
+  if (!fs.existsSync(npmrcPath)) {
+    console.log('  No ~/.npmrc found — nothing to clean.');
+  } else {
+    const content = fs.readFileSync(npmrcPath, 'utf8');
+    const lines = content.split('\n');
+
+    // Find lines that reference npm.pkg.github.com
+    const linesToRemove = [];
+    const keptLines = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.includes('npm.pkg.github.com')) {
+        linesToRemove.push(line);
+      } else {
+        keptLines.push(line);
+      }
+    }
+
+    npmrcRemovedCount = linesToRemove.length;
+
+    if (npmrcRemovedCount === 0) {
+      console.log('  No GitHub Packages lines found — ~/.npmrc is clean.');
+    } else {
+      console.log(`  Found ${npmrcRemovedCount} npm.pkg.github.com line(s):`);
+
+      for (const line of linesToRemove) {
+        // Mask auth tokens in output for safety
+        const masked = line.replace(/(:_authToken=).+/, '$1***');
+        console.log(`    - ${masked}`);
+      }
+
+      if (options.dryRun) {
+        console.log('');
+        console.log('  [Dry-run] No changes made. Would remove the above line(s).');
+      } else {
+        // Write back without GitHub Packages lines
+        const newContent = keptLines.join('\n');
+        fs.writeFileSync(npmrcPath, newContent, 'utf8');
+        console.log('  Cleaned successfully.');
+        npmrcChanged = true;
+      }
+    }
+  }
+
+  // === Phase 2: Cache check ===
+  console.log('');
+  console.log('Checking ~/.config/xp-gate/cache/ for old downloads...');
+
+  if (!fs.existsSync(cacheDir)) {
+    console.log('  No old cache directory found.');
+  } else {
+    const items = fs.readdirSync(cacheDir);
+
+    if (items.length === 0) {
+      console.log('  Cache directory exists but is empty.');
+    } else {
+      console.log(`  Found ${items.length} cached file(s) from old installation.`);
+      for (const item of items) {
+        const itemPath = path.join(cacheDir, item);
+        const stat = fs.statSync(itemPath);
+        const size = stat.isFile() ? `(${formatSize(stat.size)})` : '(directory)';
+        console.log(`    - ${item} ${size}`);
+      }
+
+      if (!options.dryRun) {
+        console.log('  Note: These files are harmless but no longer needed.');
+        console.log('  You can safely remove them with: rm -rf ' + cacheDir);
+      }
+    }
+  }
+
+  // === Phase 3: Summary ===
+  console.log('');
+  console.log('Migration Summary:');
+  console.log(`  ~/.npmrc: ${npmrcRemovedCount > 0 ? `${npmrcRemovedCount} GitHub Packages line(s) ${options.dryRun ? 'would be' : ''}removed` : 'No changes needed'}`);
+  console.log(`  Cache:    ${fs.existsSync(cacheDir) && fs.readdirSync(cacheDir).length > 0 ? 'Old files found (can be cleaned manually)' : 'No old cache found'}`);
+  console.log('');
+  console.log('Migration complete. xp-gate v0.5.x no longer requires GitHub Packages or PAT tokens.');
+
+  return 0;
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return bytes + ' B';
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+  return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+}
+
+module.exports = { migrate };