Function bodies 337 total

function sanitizeForComment(str) {
  if (!str) return '';
  return str
    .replace(/--/g, '—') // Replace double hyphen with em dash
    .replace(/</g, '‹') // Replace angle brackets
    .replace(/>/g, '›')
    .trim();
}

function formatBytes(bytes, decimals = 2) {
  if (bytes === 0) return '0 B';

  const k = 1024;
  const dm = decimals < 0 ? 0 : decimals;
  const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];

  const i = Math.floor(Math.log(bytes) / Math.log(k));

  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
}

function formatDuration(ms) {
  if (ms < 1000) return `${ms}ms`;

  const seconds = Math.floor(ms / 1000);
  const minutes = Math.floor(seconds / 60);
  const hours = Math.floor(minutes / 60);

  if (hours > 0) {
    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
  } else if (minutes > 0) {
    return `${minutes}m ${seconds % 60}s`;
  } else {
    return `${seconds}s`;
  }
}

function parseSize(sizeStr) {
  const units = {
    B: 1,
    KB: 1024,
    MB: 1024 * 1024,
    GB: 1024 * 1024 * 1024,
    TB: 1024 * 1024 * 1024 * 1024,
  };

  const match = sizeStr.toString().match(/^(\d+(?:\.\d+)?)\s*([KMGT]?B)?$/i);
  if (!match) {
    throw new Error(`Invalid size format: ${sizeStr}`);
  }

  const value = parseFloat(match[1]);
  const unit = (match[2] || 'B').toUpperCase();

  return Math.floor(value * (units[unit] || 1));
}

function chunk(array, size) {
  const chunks = [];
  for (let i = 0; i < array.length; i += size) {
    chunks.push(array.slice(i, i + size));
  }
  return chunks;
}

function debounce(fn, delay) {
  let timeoutId;

  return function debounced(...args) {
    clearTimeout(timeoutId);

    return new Promise((resolve) => {
      timeoutId = setTimeout(() => {
        resolve(fn.apply(this, args));
      }, delay);
    });
  };
}

function createCache(ttl = 3600000) {
  const cache = new Map();

  return {
    get(key) {
      const item = cache.get(key);
      if (!item) return null;

      if (Date.now() > item.expiry) {
        cache.delete(key);
        return null;
      }

      return item.value;
    },

    set(key, value) {
      cache.set(key, {
        value,
        expiry: Date.now() + ttl,
      });
    },

    delete(key) {
      cache.delete(key);
    },

    clear() {
      cache.clear();
    },

    size() {
      return cache.size;
    },
  };
}

function escapeXml(str) {
  const xmlEscapes = {
    '&': '&',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&apos;',
  };

  return str.replace(/[&<>"']/g, (char) => xmlEscapes[char]);
}

function sanitizeForXml(content) {
  // Handle non-string input by converting to empty string
  if (content === null || content === undefined || typeof content !== 'string') {
    return '';
  }

  // Handle empty strings
  if (!content) {
    return '';
  }

  // Remove invalid XML control characters (0x00-0x1F except 0x09, 0x0A, 0x0D)
  // Also remove 0x7F (DEL) which is technically invalid in XML 1.0
  // eslint-disable-next-line no-control-regex
  return content.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
}

async function readRules(filePath, useCache = false) {
  if (useCache) {
    const cached = ruleCache.get(filePath);
    if (cached) {
      return cached;
    }
  }

  try {
    const content = await fs.readFile(filePath, 'utf8');
    // Strip UTF-8 BOM if present
    const cleaned = content.charCodeAt(0) === 0xfeff ? content.slice(1) : content;
    const rules = cleaned.split('\n');
    if (useCache) {
      ruleCache.set(filePath, rules);
    }
    return rules;
  } catch (error) {
    // Only cache "file not found" — transient errors (EMFILE, EACCES) should not
    // be cached because they may resolve on the next call.
    if (useCache && error.code === 'ENOENT') {
      ruleCache.set(filePath, []);
    }
    return [];
  }
}

function isIgnored(absPath, root, layers, isDirectory = false) {
  const relToRoot = toPosix(path.relative(root, absPath));
  let ignored = false;
  let matchedRule = null;
  let matchedLayer = null;

  for (const { base, ig } of layers) {
    const relToLayer = toPosix(path.relative(base, absPath));

    // Skip if path isn't under this layer's base
    if (relToLayer.startsWith('..')) continue;

    // Test with directory trailing slash if it's a directory
    const testPath = isDirectory && !relToLayer.endsWith('/') ? relToLayer + '/' : relToLayer;

    // Use .test() if available (returns {ignored, unignored}), otherwise fallback to .ignores()
    const result = ig.test?.(testPath) ?? {
      ignored: ig.ignores(testPath),
      unignored: false,
    };

    if (result.ignored !== undefined) {
      if (result.ignored) {
        ignored = true;
        matchedRule = 'exclude';
        matchedLayer = base;
      }
      if (result.unignored) {
        ignored = false;
        matche

export async function* walkWithIgnore(root, options = {}) {
  const {
    ignoreFileName = '.copytreeignore',
    includeDirectories = false,
    followSymlinks = false,
    explain = false,
    initialLayers = [],
    config = {},
    cache = false,
    maxDepth = undefined,
  } = options;

  // Extract retry configuration with defaults
  const retryConfig = {
    maxAttempts: config?.copytree?.fs?.retryAttempts ?? 3,
    initialDelay: config?.copytree?.fs?.retryDelay ?? 100,
    maxDelay: config?.copytree?.fs?.maxDelay ?? 2000,
  };

  const stats = {};
  stats.filesScanned = 0;
  stats.directoriesScanned = 0;
  stats.directoriesPruned = 0;
  stats.filesExcluded = 0;

  async function* walk(dir, layers, depth = 0) {
    stats.directoriesScanned++;

    // Load ignore rules at this level
    const ignoreFilePath = path.join(dir, ignoreFileName);
    const localRules = await readRules(ignoreFilePath, cache);
    const localIg = ignore().add(localRules);
    const nextLayers = [...layer

  async function* walk(dir, layers, depth = 0) {
    stats.directoriesScanned++;

    // Load ignore rules at this level
    const ignoreFilePath = path.join(dir, ignoreFileName);
    const localRules = await readRules(ignoreFilePath, cache);
    const localIg = ignore().add(localRules);
    const nextLayers = [...layers, { base: dir, ig: localIg }];

    let entries;
    try {
      entries = await withFsRetry(() => fs.readdir(dir, { withFileTypes: true }), {
        ...retryConfig,
        onRetry: ({ code }) => recordRetry(dir, code),
      });
      // Record success if there were retries
      recordSuccessAfterRetry(dir);
    } catch (error) {
      // Record failure type based on error category
      if (isRetryableFsError(error)) {
        recordGiveUp(dir, error.code);
      } else {
        recordPermanent(dir, error.code);
      }
      // Can't read directory - skip it
      return;
    }

    // Filter out ignore files themselves to prevent them from appearing in output
  

export async function getAllFiles(root, options = {}) {
  const files = [];
  for await (const file of walkWithIgnore(root, options)) {
    files.push(file);
  }
  return files;
}

export async function testPath(testPath, root, options = {}) {
  const { ignoreFileName = '.copytreeignore', config = {}, cache = false } = options;

  // Build layers by walking up from root to the file's directory
  const absPath = path.resolve(root, testPath);
  const relPath = path.relative(root, absPath);
  const dirPath = path.dirname(absPath);

  const layers = [];
  let currentDir = root;

  // Walk down the directory tree, collecting ignore rules
  const parts = relPath.split(path.sep);
  for (let i = 0; i < parts.length; i++) {
    const ignoreFilePath = path.join(currentDir, ignoreFileName);
    const rules = await readRules(ignoreFilePath, cache);
    if (rules.length > 0) {
      const ig = ignore().add(rules);
      layers.push({ base: currentDir, ig });
    }

    if (i < parts.length - 1) {
      currentDir = path.join(currentDir, parts[i]);
    }
  }

  // Determine if it's a directory
  let isDirectory = false;
  try {
    // Use retry for stat in testPath with config

  constructor(options = {}) {
    super();
    this.options = {
      // Structured logging options (new)
      level: options.level, // lazy-loaded from config / env when undefined
      format: options.format, // lazy-loaded from config / env when undefined
      colorize: options.colorize, // lazy-loaded from config / env when undefined
      timestamp: options.timestamp, // lazy-loaded from config when undefined
      destination: options.destination, // lazy-loaded from config when undefined

      // Legacy compatibility options
      debug: options.debug, // will be lazy-loaded from config if not provided
      silent: options.silent || false,
      prefix: options.prefix || 'CopyTree',
      useInkEvents: options.useInkEvents || false,
      ...options,
    };

    this.spinner = null;
  }

  _shouldLog(level) {
    const format = this._effectiveFormat;
    if (format === 'silent') {
      // Silent mode: only errors pass through
      return level === 'error';
    }
    const messagePriority = LOG_LEVELS[level] ?? LOG_LEVELS.info;
    const currentPriority = LOG_LEVELS[this._effectiveLevel] ?? LOG_LEVELS.info;
    return messagePriority <= currentPriority;
  }

  _shouldColorize() {
    if (this._effectiveFormat === 'json') return false;
    const colorize = this._effectiveColorize;
    if (colorize === 'always') return true;
    if (colorize === 'never') return false;
    // 'auto': colorize only when writing to a real TTY
    return this._getOutputStream().isTTY === true;
  }

  _formatJsonLine(level, message, ...args) {
    let messageStr;
    if (typeof message === 'string') {
      messageStr = message;
    } else {
      try {
        messageStr = JSON.stringify(message);
      } catch {
        messageStr = String(message);
      }
    }

    const entry = { level, message: messageStr };
    if (this._effectiveTimestamp) {
      entry.timestamp = new Date().toISOString();
    }
    if (args.length > 0) {
      entry.context = args.length === 1 ? args[0] : args;
    }

    try {
      return JSON.stringify(entry);
    } catch {
      // Fallback for circular references, BigInt, or other non-serializable context
      const safeEntry = { level, message: messageStr };
      if (entry.timestamp) safeEntry.timestamp = entry.timestamp;
      try {
        return JSON.stringify(safeEntry);
      } catch {
        return `{"level":"${level}","message":"[unserializable]"}`;
      }
    }
  }

  _writeLog(level, coloredText, rawMessage, args = []) {
    if (!this._shouldLog(level)) return;

    const stream = this._getOutputStream();
    const format = this._effectiveFormat;

    if (format === 'json') {
      stream.write(this._formatJsonLine(level, rawMessage, ...args) + '\n');
    } else {
      const text = this._shouldColorize()
        ? (coloredText ?? '')
        : stripAnsi(typeof coloredText === 'string' ? coloredText : String(coloredText ?? ''));
      stream.write(text + '\n');
    }
  }

  configure(newOptions) {
    if (newOptions.level !== undefined) this.options.level = newOptions.level;
    if (newOptions.format !== undefined) this.options.format = newOptions.format;
    if (newOptions.colorize !== undefined) this.options.colorize = newOptions.colorize;
    if (newOptions.timestamp !== undefined) this.options.timestamp = newOptions.timestamp;
    if (newOptions.destination !== undefined) this.options.destination = newOptions.destination;
    // Legacy options
    if (newOptions.silent !== undefined) this.options.silent = newOptions.silent;
    if (newOptions.debug !== undefined) this.options.debug = newOptions.debug;
  }

  info(message, ...args) {
    if (this.options.useInkEvents) {
      this.emit('log', {
        type: 'info',
        message: typeof message === 'string' ? message : JSON.stringify(message),
        timestamp: Date.now(),
      });
      return;
    }
    this._writeLog('info', `${chalk.blue(`[${this.options.prefix}]`)} ${message}`, message, args);
  }

  success(message, ...args) {
    if (this.options.useInkEvents) {
      this.emit('log', {
        type: 'success',
        message: typeof message === 'string' ? message : JSON.stringify(message),
        timestamp: Date.now(),
      });
      return;
    }
    this._writeLog('success', chalk.green(`✓ ${message}`), message, args);
  }

  warn(message, ...args) {
    if (this.options.useInkEvents) {
      this.emit('log', {
        type: 'warning',
        message: typeof message === 'string' ? message : JSON.stringify(message),
        timestamp: Date.now(),
      });
      return;
    }
    this._writeLog('warn', chalk.yellow(`⚠ ${message}`), message, args);
  }

  error(message, ...args) {
    if (this.options.useInkEvents) {
      this.emit('log', {
        type: 'error',
        message: typeof message === 'string' ? message : JSON.stringify(message),
        timestamp: Date.now(),
      });
      return;
    }
    this._writeLog('error', chalk.red(`✗ ${message}`), message, args);
  }

  logDebug(message, ...args) {
    if (this.options.useInkEvents) {
      this.emit('log', {
        type: 'debug',
        message: typeof message === 'string' ? message : JSON.stringify(message),
        timestamp: Date.now(),
      });
      return;
    }
    this._writeLog('debug', chalk.gray(`[DEBUG] ${message}`), message, args);
  }

  startSpinner(message) {
    if (this.options.useInkEvents) {
      this.emit('progress', { type: 'start', message, timestamp: Date.now() });
      return;
    }

    // Suppress spinner when format is json, silent, or when the stream is not a TTY
    if (
      this._effectiveFormat !== 'text' ||
      !this._shouldLog('info') ||
      !this._getOutputStream().isTTY
    ) {
      return;
    }

    this.stopSpinner();
    this.spinner = ora({ text: message, color: 'blue' }).start();
  }

  updateSpinner(message) {
    if (this.options.useInkEvents) {
      this.emit('progress', { type: 'update', message, timestamp: Date.now() });
      return;
    }

    if (this.spinner && this._getOutputStream().isTTY) {
      this.spinner.text = message;
    }
  }

  succeedSpinner(message) {
    if (this.options.useInkEvents) {
      this.emit('progress', { type: 'success', message, timestamp: Date.now() });
      return;
    }

    if (this.spinner) {
      this.spinner.succeed(message || this.spinner.text);
      this.spinner = null;
    }
  }

  failSpinner(message) {
    if (this.options.useInkEvents) {
      this.emit('progress', { type: 'error', message, timestamp: Date.now() });
      return;
    }

    if (this.spinner) {
      this.spinner.fail(message || this.spinner.text);
      this.spinner = null;
    }
  }

  stopSpinner() {
    if (this.options.useInkEvents) {
      this.emit('progress', { type: 'stop', timestamp: Date.now() });
      return;
    }

    if (this.spinner) {
      this.spinner.stop();
      const stream = this._getOutputStream();
      if (stream.isTTY) {
        stream.write('\r\x1b[2K');
      }
      this.spinner = null;
    }
  }

  styled(style, message, ...args) {
    if (!this._shouldLog('info')) return;

    const styles = {
      bold: chalk.bold,
      dim: chalk.dim,
      italic: chalk.italic,
      underline: chalk.underline,
      inverse: chalk.inverse,
      strikethrough: chalk.strikethrough,
    };

    const styleFunc = styles[style] || chalk.white;
    const formatted = styleFunc(message);
    this._getOutputStream().write(
      (this._shouldColorize()
        ? formatted
        : stripAnsi(typeof formatted === 'string' ? formatted : String(formatted ?? ''))) + '\n',
    );
    if (args.length > 0) {
      this._getOutputStream().write(args.join(' ') + '\n');
    }
  }

  tree(path, isLast = false, indent = '') {
    if (!this._shouldLog('info')) return;

    const connector = isLast ? '└── ' : '├── ';
    const line = chalk.gray(indent + connector) + path;
    this._getOutputStream().write(
      (this._shouldColorize()
        ? line
        : stripAnsi(typeof line === 'string' ? line : String(line ?? ''))) + '\n',
    );
  }

  child(prefix) {
    return new Logger({
      ...this.options,
      prefix: `${this.options.prefix}:${prefix}`,
    });
  }

  progress(current, total, message = '') {
    if (!this._shouldLog('info')) return;

    const percentage = Math.round((current / total) * 100);
    const progressMsg = `${percentage}% ${message}`;
    const stream = this._getOutputStream();

    if (stream.isTTY && this._effectiveFormat === 'text') {
      const bar = this.createProgressBar(percentage);
      stream.clearLine(0);
      stream.cursorTo(0);
      stream.write(`${bar} ${progressMsg}`);

      if (current >= total) {
        stream.write('\n');
      }
    } else {
      if (current >= total) {
        this.info(progressMsg);
      }
    }
  }

  createProgressBar(percentage, width = 30) {
    const filled = Math.round((percentage / 100) * width);
    const empty = width - filled;

    return '[' + chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty)) + ']';
  }

function detectFenceLanguage(filePathOrExt = '') {
  const ext = filePathOrExt.startsWith('.')
    ? filePathOrExt.toLowerCase()
    : path.extname(filePathOrExt).toLowerCase();
  return EXT_LANG_MAP.get(ext) || '';
}

function chooseFence(content) {
  if (!content || typeof content !== 'string') return '```';
  const matches = content.match(/`{3,}/g);
  if (!matches) return '```';
  const maxRun = matches.reduce((max, m) => Math.max(max, m.length), 3);
  // Use a fence longer than any run found inside content
  return '`'.repeat(Math.max(4, maxRun + 1));
}

function formatSmallMeta({ size, modified, git, binaryLabel, truncatedAt }) {
  const parts = [];
  if (typeof size === 'number') parts.push(`Size: ${size.toLocaleString()} bytes`);
  if (modified) parts.push(`Modified: ${modified}`);
  if (git) parts.push(`Git: ${git}`);
  if (binaryLabel) parts.push(`Binary: ${binaryLabel}`);
  if (typeof truncatedAt === 'number')
    parts.push(`Truncated at ${truncatedAt.toLocaleString()} chars`);
  return `<small>${parts.join(' • ')}</small>`;
}

function formatBeginMarker(attrs) {
  const kv = [];
  for (const [key, val] of Object.entries(attrs)) {
    if (val === undefined || val === null || val === '') continue;
    if (typeof val === 'boolean' || typeof val === 'number') {
      kv.push(`${key}=${val}`);
    } else {
      kv.push(`${key}=${quoteAttrValue(val)}`);
    }
  }
  return `<!-- copytree:file-begin ${kv.join(' ')} -->`;
}

async function readRules(filePath) {
  try {
    const content = await fs.readFile(filePath, 'utf8');
    // Strip UTF-8 BOM if present
    const cleaned = content.charCodeAt(0) === 0xfeff ? content.slice(1) : content;
    return cleaned.split('\n');
  } catch {
    // File doesn't exist or can't be read - treat as no rules
    return [];
  }
}

function isIgnored(absPath, root, layers, isDirectory = false) {
  const relToRoot = toPosix(path.relative(root, absPath));
  let ignored = false;
  let matchedRule = null;
  let matchedLayer = null;

  for (const { base, ig } of layers) {
    const relToLayer = toPosix(path.relative(base, absPath));

    // Skip if path isn't under this layer's base
    if (relToLayer.startsWith('..')) continue;

    // Test with directory trailing slash if it's a directory
    const testPath = isDirectory && !relToLayer.endsWith('/') ? relToLayer + '/' : relToLayer;

    // Use .test() if available (returns {ignored, unignored}), otherwise fallback to .ignores()
    const result = ig.test?.(testPath) ?? {
      ignored: ig.ignores(testPath),
      unignored: false,
    };

    if (result.ignored !== undefined) {
      if (result.ignored) {
        ignored = true;
        matchedRule = 'exclude';
        matchedLayer = base;
      }
      if (result.unignored) {
        ignored = false;
        matche

  async function enqueueResult(result) {
    if (!result) return;

    if (throttleEnabled) {
      while (buffer.length >= maxBuffer) {
        if (signal?.aborted) {
          throw new Error('Traversal aborted');
        }
        if (!drainWaitPromise) {
          drainWaitPromise = new Promise((resolve) => {
            resolveDrainWait = resolve;
          });
        }
        await drainWaitPromise;
      }
    }

    buffer.push(result);
  }

  function notifyDrain() {
    if (!throttleEnabled) return;
    if (buffer.length < maxBuffer && resolveDrainWait) {
      const resolve = resolveDrainWait;
      resolveDrainWait = null;
      drainWaitPromise = null;
      resolve();
    }
  }

  function shouldFollowSymlink(stat, absPath) {
    if (!followSymlinks) return false;

    const key = `${stat.dev}:${stat.ino}`;
    if (visited.has(key)) {
      // Cycle detected - skip
      return false;
    }
    visited.add(key);
    return true;
  }

  async function processEntry(dir, entry, layers, depth) {
    if (signal?.aborted) {
      throw new Error('Traversal aborted');
    }

    const absPath = path.join(dir, entry.name);

    // Handle symlinks
    let isDir = entry.isDirectory();
    let stat = null;

    if (entry.isSymbolicLink()) {
      if (!followSymlinks) {
        return; // Skip symlinks by default
      }
      try {
        stat = await withFsRetry(() => fs.stat(absPath), {
          ...retryConfig,
          onRetry: ({ code }) => recordRetry(absPath, code),
        });
        recordSuccessAfterRetry(absPath);

        // Check for cycles
        if (!shouldFollowSymlink(stat, absPath)) {
          return; // Cycle detected or already visited
        }

        isDir = stat.isDirectory();
      } catch (error) {
        // Record failure and skip broken symlink
        if (isRetryableFsError(error)) {
          recordGiveUp(absPath, error.code);
        } else {
          recordPermanent(absPath, error.code)

  async function processDirectory(dir, layers, depth) {
    stats.directoriesScanned++;

    // Load ignore rules at this level
    const ignoreFilePath = path.join(dir, ignoreFileName);
    const localRules = await readRules(ignoreFilePath);
    const localIg = ignore().add(localRules);
    const nextLayers = [...layers, { base: dir, ig: localIg }];

    let entries;
    const readdirStart = Date.now();
    try {
      entries = await withFsRetry(() => fs.readdir(dir, { withFileTypes: true }), {
        ...retryConfig,
        onRetry: ({ code }) => recordRetry(dir, code),
      });
      recordSuccessAfterRetry(dir);
    } catch (error) {
      // Record failure type based on error category
      if (isRetryableFsError(error)) {
        recordGiveUp(dir, error.code);
      } else {
        recordPermanent(dir, error.code);
      }
      // Can't read directory - skip it (return empty array for proper handling)
      return [];
    }

    // Filter out ignore files themselves to preve

export async function getAllFilesParallel(root, options = {}) {
  const files = [];
  for await (const file of walkParallel(root, options)) {
    files.push(file);
  }
  return files;
}

  constructor(options = {}) {
    this.options = {
      enabled: options.enabled ?? process.env.NODE_ENV !== 'production',
      logThreshold: options.logThreshold ?? 1000, // Log operations over 1s
      memoryThreshold: options.memoryThreshold ?? 50 * 1024 * 1024, // 50MB
      ...options,
    };

    this.timers = new Map();
    this.metrics = new Map();
    this.logger = logger.child('Performance');
  }

  startTimer(name) {
    if (!this.options.enabled) return;

    this.timers.set(name, {
      startTime: performance.now(),
      startMemory: process.memoryUsage(),
    });
  }