@boyingliu01/xp-gate 0.7.0 → 0.8.0

package/lib/detect-deps.js

@@ -3,29 +3,73 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-/**
- * Resolve the user's home directory cross-platform.
- * Fallback chain: HOME → USERPROFILE → os.homedir()
- * This covers all known Windows/Linux/macOS/edge cases.
- */
-const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
-
-const SKILLS_DIR = path.join(HOME, '.config', 'opencode', 'skills');
-const OPENCODE_DIR = path.join(HOME, '.config', 'opencode');
+const { HOME_DIR } = require('./shared-paths.js');
 
 const REQUIRED_DEPS = [
-  { name: 'superpowers', minVersion: '1.0.0' },
-  { name: 'gstack', minVersion: '1.0.0' }
+  { name: 'superpowers', repo: 'obra/superpowers', minVersion: '1.0.0' },
+  { name: 'gstack', repo: 'garrytan/gstack', minVersion: '1.0.0' }
 ];
 
-// Platform-specific dependency profiles
-// Qoder has no external skill dependencies (superpowers/gstack not required)
+/**
+ * Platform profiles — each AI agent platform has its own skills directory.
+ * All platforms require the same dependencies (superpowers, gstack).
+ *
+ * @covers Issue #128 Bug 1 — Qoder platform was excluded from dependency checks
+ */
 const PLATFORM_PROFILES = {
-  opencode: { requiredDeps: REQUIRED_DEPS, skillsDirs: [SKILLS_DIR, OPENCODE_DIR] },
-  qoder:    { requiredDeps: [],              skillsDirs: [path.join(HOME, '.qoder', 'skills')] },
-  'claude-code': { requiredDeps: REQUIRED_DEPS, skillsDirs: [SKILLS_DIR, OPENCODE_DIR] },
+  opencode: {
+    skillsDirs: [
+      path.join(HOME_DIR, '.config', 'opencode', 'skills'),
+      path.join(HOME_DIR, '.config', 'opencode'),
+    ],
+    requiredDeps: REQUIRED_DEPS,
+  },
+  'claude-code': {
+    skillsDirs: [
+      path.join(HOME_DIR, '.claude', 'skills'),
+      path.join(HOME_DIR, '.claude'),
+    ],
+    requiredDeps: REQUIRED_DEPS,
+  },
+  qoder: {
+    skillsDirs: [
+      path.join(HOME_DIR, '.qoder', 'skills'),
+      path.join(HOME_DIR, '.qoder'),
+    ],
+    requiredDeps: REQUIRED_DEPS,
+  },
 };
 
+/**
+ * Detect which AI agent platform is currently in use.
+ * Checks for platform-specific directories in the user's home.
+ * Falls back to 'opencode' if no platform is detected.
+ *
+ * @returns {'opencode' | 'claude-code' | 'qoder'}
+ */
+function detectPlatform() {
+  // Check for Qoder-specific marker
+  if (fs.existsSync(path.join(HOME_DIR, '.qoder', 'skills'))) {
+    return 'qoder';
+  }
+  // Check for Claude Code-specific marker
+  if (fs.existsSync(path.join(HOME_DIR, '.claude', 'skills'))) {
+    return 'claude-code';
+  }
+  // Default to opencode (most common, backward compatible)
+  return 'opencode';
+}
+
+/**
+ * Get the skills directories for a given platform.
+ * @param {string} platform - 'opencode' | 'claude-code' | 'qoder'
+ * @returns {string[]}
+ */
+function getSkillsDirs(platform) {
+  const profile = PLATFORM_PROFILES[platform] || PLATFORM_PROFILES.opencode;
+  return profile.skillsDirs;
+}
+
 /**
  * Check if bash is available on the system.
  * XP-Gate hooks are bash scripts — Windows users need Git Bash installed.
@@ -92,30 +136,28 @@ function checkBash() {
   }
 }
 
+/**
+ * Check if required dependencies are installed for the given platform.
+ * @param {string} [platform='opencode'] - AI agent platform
+ * @returns {Promise<{ok: boolean, missing?: string, versionMismatch?: object}>}
+ */
 async function checkDeps(platform = 'opencode') {
-  const profile = PLATFORM_PROFILES[platform] || PLATFORM_PROFILES.opencode;
-  const { requiredDeps, skillsDirs } = profile;
-
-  // Qoder and other platforms with no hard dependencies pass immediately
-  if (requiredDeps.length === 0) {
-    return { ok: true, platform };
-  }
+  const skillsDirs = getSkillsDirs(platform);
 
-  for (const dep of requiredDeps) {
-    const possiblePaths = skillsDirs.map(dir => path.join(dir, dep.name));
-    
+  for (const dep of REQUIRED_DEPS) {
     let depDir = null;
-    for (const p of possiblePaths) {
-      if (fs.existsSync(p)) {
-        depDir = p;
+    for (const baseDir of skillsDirs) {
+      const candidate = path.join(baseDir, dep.name);
+      if (fs.existsSync(candidate)) {
+        depDir = candidate;
         break;
       }
     }
-    
+
     if (!depDir) {
       return { ok: false, missing: dep.name };
     }
-    
+
     const version = await getSkillVersion(depDir);
     if (version && compareVersions(version, dep.minVersion) < 0) {
       return {
@@ -128,10 +170,103 @@ async function checkDeps(platform = 'opencode') {
       };
     }
   }
-  
+
   return { ok: true };
 }
 
+/**
+ * Auto-install missing dependencies by cloning from GitHub.
+ * @param {string} [platform='opencode'] - AI agent platform
+ * @returns {Promise<{ok: boolean, installed?: string[], errors?: Array<{name: string, message: string}>}>}
+ */
+function runGitClone(repoUrl, destPath) {
+  const cp = require('child_process');
+  const result = cp.spawnSync(
+    'git',
+    ['clone', '--depth', '1', repoUrl, destPath],
+    { stdio: ['ignore', 'pipe', 'pipe'], timeout: 120000, shell: false }
+  );
+  if (result.status === 0) return;
+  const stderr = String(result.stderr ?? '').trim();
+  throw new Error(stderr || `git clone exited with status ${result.status}`);
+}
+
+function ensureTargetDir(targetDir) {
+  if (fs.existsSync(targetDir)) return null;
+  try {
+    fs.mkdirSync(targetDir, { recursive: true });
+    return null;
+  } catch (e) {
+    return { name: 'mkdir', message: `Cannot create skills directory: ${e.message}` };
+  }
+}
+
+function versionMismatchError(versionMismatch) {
+  return {
+    name: versionMismatch.name,
+    message: `version mismatch: need ${versionMismatch.required}, found ${versionMismatch.found} (auto-install cannot upgrade)`,
+  };
+}
+
+function depExistsIn(skillsDirs, depName) {
+  for (const baseDir of skillsDirs) {
+    if (fs.existsSync(path.join(baseDir, depName))) return true;
+  }
+  return false;
+}
+
+function safeRemove(destPath) {
+  try {
+    if (fs.existsSync(destPath)) {
+      fs.rmSync(destPath, { recursive: true, force: true });
+    }
+  } catch {
+    // best-effort cleanup of partial clone
+  }
+}
+
+function installOneDep(dep, targetDir) {
+  const destPath = path.join(targetDir, dep.name);
+  const repoUrl = `https://github.com/${dep.repo}.git`;
+  try {
+    console.log(`  ${dep.name}: not found → installing from ${repoUrl} ...`);
+    runGitClone(repoUrl, destPath);
+    console.log(`  ${dep.name}: OK`);
+    return { ok: true };
+  } catch (e) {
+    const message = e.message || 'git clone failed';
+    console.warn(`  ${dep.name}: FAILED (${message})`);
+    safeRemove(destPath);
+    return { ok: false, error: { name: dep.name, message } };
+  }
+}
+
+async function autoInstallDeps(platform = 'opencode') {
+  const skillsDirs = getSkillsDirs(platform);
+  const targetDir = skillsDirs[0];
+
+  const mkdirErr = ensureTargetDir(targetDir);
+  if (mkdirErr) return { ok: false, errors: [mkdirErr] };
+
+  const depCheck = await checkDeps(platform);
+  if (depCheck.ok) return { ok: true, installed: [] };
+  if (depCheck.versionMismatch) {
+    return { ok: false, installed: [], errors: [versionMismatchError(depCheck.versionMismatch)] };
+  }
+
+  const errors = [];
+  const installed = [];
+  for (const dep of REQUIRED_DEPS) {
+    if (depExistsIn(skillsDirs, dep.name)) continue;
+    const result = installOneDep(dep, targetDir);
+    if (result.ok) installed.push(dep.name);
+    else errors.push(result.error);
+  }
+
+  if (errors.length > 0) return { ok: false, installed, errors };
+  return { ok: true, installed };
+}
+
 async function getSkillVersion(skillDir) {
   const pkgFile = path.join(skillDir, 'package.json');
   if (fs.existsSync(pkgFile)) {
@@ -140,7 +275,7 @@ async function getSkillVersion(skillDir) {
       return pkg.version;
     } catch {}
   }
-  
+
   const skillFile = path.join(skillDir, 'SKILL.md');
   if (fs.existsSync(skillFile)) {
     const content = fs.readFileSync(skillFile, 'utf8');
@@ -149,22 +284,30 @@ async function getSkillVersion(skillDir) {
       return versionMatch[1];
     }
   }
-  
+
   return null;
 }
 
 function compareVersions(a, b) {
   const partsA = a.split('.').map(Number);
   const partsB = b.split('.').map(Number);
-  
+
   for (let i = 0; i < 3; i++) {
     const partA = partsA[i] || 0;
     const partB = partsB[i] || 0;
     if (partA > partB) return 1;
     if (partA < partB) return -1;
   }
-  
+
   return 0;
 }
 
-module.exports = { checkDeps, checkBash };
+module.exports = {
+  checkDeps,
+  checkBash,
+  autoInstallDeps,
+  detectPlatform,
+  getSkillsDirs,
+  PLATFORM_PROFILES,
+  REQUIRED_DEPS,
+};

package/lib/doctor.js

@@ -1,15 +1,13 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 const { execSync } = require('child_process');
-
-// Cross-platform home directory resolution
-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 GLOBAL_HOOKS_DIR = path.join(CONFIG_DIR, 'hooks');
-const GLOBAL_ADAPTERS_DIR = path.join(CONFIG_DIR, 'adapters');
+const {
+  HOME_DIR,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  GLOBAL_HOOKS_DIR,
+  GLOBAL_ADAPTERS_DIR,
+} = require('./shared-paths.js');
 
 // npm package source dir (template hooks/adapters)
 const PKG_DIR = path.dirname(__dirname);

package/lib/gate-audit.ts

@@ -177,64 +177,44 @@ export function computeStats(
  * Renames current file to .1, shifts existing archives.
  * Keeps at most MAX_ARCHIVES archived files.
  */
-export function rotateIfNeeded(logPath: string): void {
-  if (!existsSync(logPath)) {
-    return;
-  }
-
-  let stats;
+function shouldRotate(logPath: string): boolean {
+  if (!existsSync(logPath)) return false;
   try {
-    stats = statSync(logPath);
+    return statSync(logPath).size >= MAX_FILE_BYTES;
   } catch {
-    return;
-  }
-
-  if (stats.size < MAX_FILE_BYTES) {
-    return;
+    return false;
   }
+}
 
-  // Shift archives: .2 -> .3, .1 -> .2
+function shiftOldArchives(logPath: string): void {
   for (let i = MAX_ARCHIVES; i >= 2; i--) {
     const from = `${logPath}.${i - 1}`;
     const to = `${logPath}.${i}`;
     if (existsSync(from)) {
-      try {
-        renameSync(from, to);
-      } catch {
-        // Race condition or permission issue — skip
-      }
+      try { renameSync(from, to); } catch { /* skip */ }
     }
   }
+}
 
-  // Current -> .1
-  const firstArchive = `${logPath}.1`;
-  if (existsSync(firstArchive)) {
-    try {
-      renameSync(firstArchive, `${logPath}.2`);
-    } catch {
-      // Skip on error
-    }
+function archiveCurrent(logPath: string): void {
+  const first = `${logPath}.1`;
+  if (existsSync(first)) {
+    try { renameSync(first, `${logPath}.2`); } catch { /* skip */ }
   }
-
   try {
-    renameSync(logPath, firstArchive);
+    renameSync(logPath, first);
   } catch {
-    // If rename fails, truncate the current file instead
-    try {
-      writeFileSync(logPath, '', 'utf8');
-    } catch {
-      console.error('[xp-gate audit] Failed to rotate or truncate log:', logPath);
-    }
+    try { writeFileSync(logPath, '', 'utf8'); } catch { /* skip */ }
   }
 }
 
-// ── CLI entry point (direct invocation from hooks) ───────────────────────────
+export function rotateIfNeeded(logPath: string): void {
+  if (!shouldRotate(logPath)) return;
+  shiftOldArchives(logPath);
+  archiveCurrent(logPath);
+}
 
-/**
- * When called directly via `npx tsx gate-audit.ts record --gate-id ...`,
- * this block handles CLI argument parsing and appends the entry.
- */
-if (require.main === module) {
+function runCli(): void {
   const args = process.argv.slice(2);
   const command = args[0];
 
@@ -258,7 +238,11 @@ if (require.main === module) {
   }
 }
 
-function parseCliOptions(args: string[]): Record<string, string> {
+if (require.main === module) {
+  runCli();
+}
+
+export function parseCliOptions(args: string[]): Record<string, string> {
   const opts: Record<string, string> = {};
   for (let i = 0; i < args.length; i++) {
     if (args[i].startsWith('--') && i + 1 < args.length) {
@@ -269,7 +253,7 @@ function parseCliOptions(args: string[]): Record<string, string> {
   return opts;
 }
 
-function getCommitHash(): string {
+export function getCommitHash(): string {
   try {
     const { execSync } = require('child_process');
     return execSync('git rev-parse HEAD', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();

package/lib/init.js

@@ -1,18 +1,15 @@
 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');
+const { checkDeps, checkBash, autoInstallDeps, detectPlatform } = require('./detect-deps.js');
+const {
+  HOME_DIR,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  TEMPLATE_DIR,
+  GLOBAL_HOOKS_DIR,
+  GLOBAL_ADAPTERS_DIR,
+} = require('./shared-paths.js');
 
 function copyHooks(srcDir, destDir) {
   ['pre-commit', 'pre-push'].forEach(hook => {
@@ -54,6 +51,35 @@ function logDeps(depCheck) {
   }
 }
 
+/**
+ * Detect which AI agent platform is in use and check/auto-install deps.
+ * @param {string} platform - 'opencode' | 'claude-code' | 'qoder'
+ */
+async function checkAndInstallDeps(platform) {
+  const depCheck = await checkDeps(platform);
+  if (depCheck.ok) {
+    logDeps(depCheck);
+    return depCheck;
+  }
+
+  // Auto-install missing deps
+  console.log(`Checking dependencies (platform: ${platform})...`);
+  const installResult = await autoInstallDeps(platform);
+  if (installResult.ok) {
+    console.log('Dependencies: OK (auto-installed)\n');
+    return { ok: true };
+  }
+
+  // Auto-install failed — report and continue with warning
+  logDeps(depCheck);
+  if (installResult.errors) {
+    for (const err of installResult.errors) {
+      console.warn(`  Auto-install failed for ${err.name}: ${err.message}`);
+    }
+  }
+  return depCheck;
+}
+
 function printUsage() {
   console.log('Choose installation mode:');
   console.log('  1) Global  — all git projects use the same hooks (recommended)');
@@ -228,7 +254,10 @@ async function init(args) {
     console.warn(`  ${bashCheck.message}\n`);
   }
 
-  logDeps(await checkDeps());
+  // Detect platform and check/auto-install dependencies
+  const platform = detectPlatform();
+  console.log(`Platform: ${platform}\n`);
+  await checkAndInstallDeps(platform);
 
   const installMode = args.includes('--global') ? 'global' :
                       args.includes('--core-only') ? 'local' :

package/lib/install-skill.js

@@ -1,25 +1,14 @@
 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 { checkDeps, detectPlatform } = require('./detect-deps.js');
 const { downloadFromGitHub } = require('./download-skill.js');
 const { rollback } = require('./rollback.js');
+const { HOME_DIR, CONFIG_DIR } = require('./shared-paths.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 QODER_SKILLS_DIR = path.join(HOME, '.qoder', 'skills');
-
-// Platform-specific skill directories
-const PLATFORM_SKILLS_DIRS = {
-  opencode: SKILLS_DIR,
-  qoder: QODER_SKILLS_DIR,
-};
+const SKILLS_DIR = path.join(HOME_DIR, '.config', 'opencode', 'skills');
 
 const SKILLS_REGISTRY = {
   'sprint-flow': { repo: 'boyingliu01/xp-gate', path: 'skills/sprint-flow' },
@@ -29,23 +18,21 @@ const SKILLS_REGISTRY = {
 };
 
 async function installSkill(name, options = {}) {
-  const { offline = false, verbose = false, force = false, platform = 'opencode' } = options;
-
-  // Qoder platform has no superpowers/gstack dependency
-  if (platform !== 'qoder') {
-    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 { offline = false, verbose = false, force = false } = options;
+  
+  const platform = detectPlatform();
+  const depCheck = await checkDeps(platform);
+  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;
     }
   }
   
@@ -56,8 +43,7 @@ async function installSkill(name, options = {}) {
     return 1;
   }
   
-  const targetSkillsDir = PLATFORM_SKILLS_DIRS[platform] || SKILLS_DIR;
-  const targetDir = path.join(targetSkillsDir, name);
+  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');
@@ -155,21 +141,7 @@ async function downloadFile(url, dest, verbose) {
   });
 }
 
-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);
-    }
-  }
-}
+const { copyDirRecursive } = require('./shared-utils');
 
 function ensureConfigDir() {
   fs.mkdirSync(CONFIG_DIR, { recursive: true });

package/lib/rollback.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { copyDirRecursive } = require('./shared-utils');
 
 // Cross-platform home directory resolution
 const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
@@ -51,22 +52,6 @@ async function createBackup(installId, skillName) {
   return backupDir;
 }
 
-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 cleanupBackup(installId) {
   const backupDir = path.join(BACKUP_DIR, installId);
   

package/lib/shared-paths.js

@@ -0,0 +1,30 @@
+/**
+ * Shared filesystem path constants used across CLI modules.
+ * Cross-platform home directory resolution with os.homedir() fallback.
+ *
+ * @intent Eliminate duplicate path constants in init.js / uninstall.js / detect-deps.js
+ * @covers Issue #107 — duplicate code between init.js and uninstall.js
+ */
+const path = require('path');
+const os = require('os');
+
+/**
+ * Resolve the user's home directory cross-platform.
+ * Fallback chain: HOME → USERPROFILE → os.homedir()
+ */
+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');
+
+module.exports = {
+  HOME_DIR,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  TEMPLATE_DIR,
+  GLOBAL_HOOKS_DIR,
+  GLOBAL_ADAPTERS_DIR,
+};

package/lib/shared-utils.js

@@ -0,0 +1,25 @@
+/**
+ * Pure utility functions shared by CLI modules.
+ * No module-level state — safe for tests that mock fs/path/os.
+ */
+const fs = require('fs');
+
+/**
+ * Recursively copy a directory.
+ * Pure function: only uses fs/path params, no global config.
+ */
+function copyDirRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = require('path').join(src, entry.name);
+    const destPath = require('path').join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+module.exports = { copyDirRecursive };