Function bodies 337 total

  canTransform(file) {
    // Check if file is marked as binary
    if (file.isBinary) return true;

    // Check extension
    const ext = (file.path || '').toLowerCase().match(/\.[^.]+$/);
    return ext && this.supportedExtensions.includes(ext[0]);
  }

  validateInput(file) {
    super.validateInput(file);

    if (!file.absolutePath && this.config.get('copytree.binaryFileAction') === 'base64') {
      throw new Error('File absolute path is required for base64 encoding');
    }
  }

  async doTransform(file) {
    // If content is already loaded, return as-is
    if (file.content !== undefined) {
      return file;
    }

    // Load content from disk
    try {
      let content;

      if (file.isBinary) {
        // For binary files, return placeholder or base64 based on config
        const binaryAction = this.config.get('copytree.binaryFileAction', 'placeholder');

        switch (binaryAction) {
          case 'base64': {
            const buffer = await fs.readFile(file.absolutePath);
            content = buffer.toString('base64');
            break;
          }
          case 'skip':
            return null;
          case 'placeholder':
          default:
            content = this.config.get(
              'copytree.binaryPlaceholderText',
              '[Binary file not included]',
            );
        }
      } else {
        // Load text content
        content = await fs.readFile(file.absolutePath, this.encoding);
      }

      return {
        ..

  validateInput(file) {
    super.validateInput(file);

    if (!file.absolutePath) {
      throw new Error('File absolute path is required');
    }
  }

  constructor(options = {}) {
    super(options);
    this.description = 'Loads file content using streams for memory efficiency';
    this.bufferSize = options.bufferSize || 64 * 1024; // 64KB chunks
    this.maxSize = options.maxSize || this.config.get('copytree.maxFileSize', 10 * 1024 * 1024);
    this.encoding = options.encoding || 'utf8';
  }

  async doTransform(file) {
    try {
      // Skip if already has content
      if (file.content !== undefined) {
        return file;
      }

      // Check file size
      const stats = file.stats || (await fs.stat(file.absolutePath));
      if (stats.size > this.maxSize) {
        return {
          ...file,
          content: `[File too large: ${this.formatBytes(stats.size)}]`,
          isBinary: false,
          transformed: true,
          transformedBy: this.constructor.name,
          streamingSkipped: true,
        };
      }

      // Check if binary
      const isBinary = await this.isBinaryFile(file.absolutePath, stats.size);

      if (isBinary) {
        const binaryAction = this.config.get('copytree.binaryFileAction', 'placeholder');

        if (binaryAction === 'skip') {
          return null;
        } else if (binaryAction === 'base64') {
          // Use streaming for base64 encoding
          const content = await this.streamToBase64(file.absolutePath);
        

  async streamTextFile(filePath) {
    return new Promise((resolve, reject) => {
      const chunks = [];
      const stream = fs.createReadStream(filePath, {
        encoding: this.encoding,
        highWaterMark: this.bufferSize,
      });

      stream.on('data', (chunk) => chunks.push(chunk));
      stream.on('end', () => resolve(chunks.join('')));
      stream.on('error', reject);
    });
  }

  async streamToBase64(filePath) {
    return new Promise((resolve, reject) => {
      const chunks = [];
      const stream = fs.createReadStream(filePath, {
        highWaterMark: this.bufferSize,
      });

      stream.on('data', (chunk) => chunks.push(chunk));
      stream.on('end', () => {
        const buffer = Buffer.concat(chunks);
        resolve(buffer.toString('base64'));
      });
      stream.on('error', reject);
    });
  }

  async isBinaryFile(filePath, size) {
    if (size === 0) return false;

    // Common binary file extensions
    const binaryExtensions = [
      '.exe',
      '.dll',
      '.so',
      '.dylib',
      '.zip',
      '.tar',
      '.gz',
      '.7z',
      '.rar',
      '.pdf',
      '.doc',
      '.docx',
      '.xls',
      '.xlsx',
      '.ppt',
      '.pptx',
      '.odt',
      '.ods',
      '.odp',
      '.jpg',
      '.jpeg',
      '.png',
      '.gif',
      '.bmp',
      '.ico',
      '.svg',
      '.webp',
      '.mp3',
      '.mp4',
      '.avi',
      '.mov',
      '.wmv',
      '.flv',
      '.webm',
      '.mkv',
      '.wav',
      '.flac',
      '.aac',
      '.ogg',
      '.wma',
      '.ttf',
      '.otf',
      '.woff',
      '.woff2',
      '.eot',
      '.pyc',
      '.pyo',
      '.class',
      '.o',
      '.obj',
      '.a',
      '.lib',
      '.pdb',
      '.idb',
      '.jar',
      '.war',
      '.ear',
      '.db',
      '.sqlite',
      '.sqlite3',
    ]

function categorizeByExt(ext) {
  const lower = (ext || '').toLowerCase();
  for (const [cat, list] of Object.entries(CATEGORIES)) {
    if (list.includes(lower)) return cat;
  }
  return null;
}

export async function detect(filePath, opts = {}) {
  const sampleBytes = opts.sampleBytes ?? 8192;
  const nonPrintableThreshold = opts.nonPrintableThreshold ?? 0.3;

  const ext = path.extname(filePath);
  let category = categorizeByExt(ext);

  // Allocate buffer only for the sample size to avoid loading large files into memory
  const buf = Buffer.alloc(sampleBytes);
  let bytesRead = 0;
  let fd = null;

  try {
    fd = await fs.open(filePath, 'r');
    const result = await fs.read(fd, buf, 0, sampleBytes, 0);
    bytesRead = result.bytesRead;
  } catch (error) {
    // File doesn't exist or can't be read
    return {
      isBinary: false,
      category: 'text',
      reason: 'error',
      ext,
      error: error.message,
    };
  } finally {
    if (fd !== null) {
      await fs.close(fd);
    }
  }

  const sample = buf.subarray(0, bytesRead);

  // Magic number match
  for (const m of MAGIC) {
    const sig = Buffer.from(m.sig);
    if (sample.length >= sig.length && sample

export function isConvertibleDocument(category, ext) {
  if (category !== 'document') return false;
  return ['.pdf', '.doc', '.docx', '.odt', '.rtf', '.epub', '.html', '.htm'].includes(
    (ext || '').toLowerCase(),
  );
}

  static async copyFileReference(filePath) {
    if (process.platform === 'win32') {
      try {
        // Use Windows Forms SetFileDropList via Base64-encoded PowerShell command.
        // This bypasses all shell quoting (Base64 encoding) and path glob expansion
        // (StringCollection is passed to SetFileDropList without any wildcard interpretation).
        // Single quotes are doubled for the PS single-quoted string literal.
        const psPath = filePath.replace(/'/g, "''");
        const psCommand = [
          'Add-Type -AssemblyName System.Windows.Forms',
          '$fc = New-Object System.Collections.Specialized.StringCollection',
          `[void]$fc.Add('${psPath}')`,
          '[System.Windows.Forms.Clipboard]::SetFileDropList($fc)',
        ].join('; ');
        const encoded = Buffer.from(psCommand, 'utf16le').toString('base64');
        execSync(`powershell -NoProfile -NonInteractive -EncodedCommand ${encoded}`, {
          stdio: 'pipe',
        });
      } catc

  static async revealInFinder(filePath) {
    if (process.platform === 'win32') {
      try {
        // Use spawnSync with array args to avoid cmd.exe interpreting &, |, <, >, ^ in paths
        spawnSync('explorer', [`/select,${filePath}`], { stdio: 'pipe' });
      } catch (error) {
        logger.debug('Failed to reveal file in Explorer:', error.message);
      }
    } else if (process.platform === 'linux') {
      try {
        // Use spawnSync with array args to avoid shell interpreting $, ", ` in paths
        const dir = path.dirname(filePath);
        spawnSync('xdg-open', [dir], { stdio: 'pipe' });
      } catch (error) {
        logger.debug('Failed to reveal file with xdg-open:', error.message);
      }
    } else if (process.platform === 'darwin') {
      try {
        // Use AppleScript to reveal file. spawnSync passes the script as a direct
        // argument (no shell), so single quotes in filePath are safe.
        const escapedFilePath = filePath.replace(/\\/g, '\\\\

  constructor(message, code = 'UNKNOWN_ERROR', details = {}) {
    super(message);
    this.name = 'CopyTreeError';
    this.code = code;
    this.details = details;
    this.timestamp = new Date().toISOString();

    // Capture stack trace
    Error.captureStackTrace(this, this.constructor);
  }

  toJSON() {
    return {
      name: this.name,
      message: this.message,
      code: this.code,
      details: this.details,
      timestamp: this.timestamp,
      stack: this.stack,
    };
  }

  constructor(message, path, operation, details = {}) {
    super(message, 'FILESYSTEM_ERROR', { path, operation, ...details });
    this.name = 'FileSystemError';
    this.path = path;
    this.operation = operation;
  }

  constructor(message, field, value, details = {}) {
    super(message, 'VALIDATION_ERROR', { field, value, ...details });
    this.name = 'ValidationError';
    this.field = field;
    this.value = value;
  }

  constructor(message, transformer, file, details = {}) {
    super(message, 'TRANSFORM_ERROR', { transformer, file, ...details });
    this.name = 'TransformError';
    this.transformer = transformer;
    this.file = file;
  }

  constructor(secretsCount, findings = [], details = {}) {
    const message = `Secrets detected: ${secretsCount} secret(s) found`;
    super(message, 'SECRETS_DETECTED', { secretsCount, findings, ...details });
    this.name = 'SecretsDetectedError';
    this.secretsCount = secretsCount;
    this.findings = findings;
  }

function handleError(error, options = {}) {
  const { exit = true, verbose = false, logger = console.error } = options;

  // Convert to CopyTreeError if not already
  if (!(error instanceof CopyTreeError)) {
    error = new CopyTreeError(error.message, 'UNKNOWN_ERROR', {
      originalError: error.name,
      originalStack: error.stack,
    });
  }

  // Log error
  if (verbose) {
    logger(error.toJSON());
  } else {
    logger(`Error: ${error.message}`);
    if (error.code) {
      logger(`Code: ${error.code}`);
    }
  }

  // Exit if requested
  if (exit && process.env.NODE_ENV !== 'test') {
    process.exit(1);
  }

  return error;
}

export function isRetryableFsError(error) {
  const code = error?.code || error;
  // Filesystem-specific retryable codes
  const fsRetryableCodes = ['EBUSY', 'EPERM', 'EACCES', 'EMFILE', 'ENFILE', 'EAGAIN', 'EIO'];
  return fsRetryableCodes.includes(code);
}

export function categorizeError(error) {
  if (isRetryableError(error)) {
    return 'retryable';
  }

  const errorCode = error.code || error.name || '';
  if (NON_RETRYABLE_ERROR_CODES.includes(errorCode)) {
    return 'non-retryable';
  }

  return 'unknown';
}

async function hashFile(filePath, algorithm = 'sha256') {
  const hash = crypto.createHash(algorithm);
  const stream = fs.createReadStream(filePath);

  return new Promise((resolve, reject) => {
    stream.on('data', (data) => hash.update(data));
    stream.on('end', () => resolve(hash.digest('hex')));
    stream.on('error', reject);
  });
}

function generateTransformCacheKey(file, transformerName, options = {}) {
  const components = {
    path: file.path,
    size: file.stats?.size || 0,
    mtime: file.stats?.mtime?.getTime() || 0,
    transformer: transformerName,
    options: JSON.stringify(options, Object.keys(options).sort()),
  };

  return hashContent(JSON.stringify(components));
}

  constructor(options = {}) {
    this.basePath = options.basePath || process.cwd();
    this.includeHidden = options.includeHidden || false;
    this.followSymlinks = options.followSymlinks || false;
    this.maxFileSize = options.maxFileSize || 10 * 1024 * 1024; // 10MB default
    this.config = options.config || {};

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

  async loadFiles(patterns = {}) {
    const { include = ['**/*'], exclude = [] } = patterns;

    try {
      // Get file paths using fast-glob
      const filePaths = await fastGlob(include, {
        cwd: this.basePath,
        ignore: exclude,
        dot: this.includeHidden,
        followSymbolicLinks: this.followSymlinks,
        onlyFiles: true,
      });

      // Load file contents
      const files = [];
      for (const filePath of filePaths) {
        const file = await this.loadFile(filePath);
        if (file) {
          files.push(file);
        }
      }

      return files;
    } catch (error) {
      logger.error('Failed to load files', {
        basePath: this.basePath,
        error: error.message,
      });
      throw error;
    }
  }

  async loadFile(relativePath) {
    const fullPath = path.join(this.basePath, relativePath);

    try {
      // Stat file with retry logic
      const stats = await withFsRetry(() => fs.stat(fullPath), {
        ...this.retryConfig,
        onRetry: ({ code }) => recordRetry(fullPath, code),
      });

      // Skip files that are too large
      if (stats.size > this.maxFileSize) {
        // Record success for stat operation even though we're skipping the file
        recordSuccessAfterRetry(fullPath);
        logger.warn('Skipping large file', {
          path: relativePath,
          size: stats.size,
          maxSize: this.maxFileSize,
        });
        return null;
      }

      // Read file content with retry logic
      const raw = await withFsRetry(() => fs.readFile(fullPath, 'utf8'), {
        ...this.retryConfig,
        onRetry: ({ code }) => recordRetry(fullPath, code),
      });

      // Normalize CRLF to LF for cross-platform consistency
      const content = raw.

  detectFileType(filePath, content) {
    const ext = path.extname(filePath).toLowerCase();

    // Code files
    const codeExtensions = {
      '.js': 'javascript',
      '.jsx': 'javascript',
      '.ts': 'typescript',
      '.tsx': 'typescript',
      '.py': 'python',
      '.rb': 'ruby',
      '.php': 'php',
      '.java': 'java',
      '.c': 'c',
      '.cpp': 'cpp',
      '.cs': 'csharp',
      '.go': 'go',
      '.rs': 'rust',
      '.swift': 'swift',
      '.kt': 'kotlin',
    };

    if (codeExtensions[ext]) {
      return codeExtensions[ext];
    }

    // Data files
    const dataExtensions = {
      '.json': 'json',
      '.xml': 'xml',
      '.yaml': 'yaml',
      '.yml': 'yaml',
      '.toml': 'toml',
      '.ini': 'ini',
      '.csv': 'csv',
    };

    if (dataExtensions[ext]) {
      return dataExtensions[ext];
    }

    // Document files
    const docExtensions = {
      '.md': 'markdown',
      '.mdx': 'markdown',
      '.txt': 'text',
      '.rst': 'restructuredte

  isTextContent(content) {
    if (typeof content !== 'string') return false;

    // Check for null bytes or other binary indicators
    for (let i = 0; i < Math.min(content.length, 1000); i++) {
      const charCode = content.charCodeAt(i);
      if (
        charCode === 0 ||
        (charCode < 32 && charCode !== 9 && charCode !== 10 && charCode !== 13)
      ) {
        return false;
      }
    }

    return true;
  }

export function recordRetry(path, code) {
  stats.totalRetries++;
  const entry = stats.byPath.get(path) ?? { retries: 0, lastCode: null, status: 'pending' };
  entry.retries++;
  entry.lastCode = code;
  stats.byPath.set(path, entry);
}

export function recordGiveUp(path, code) {
  stats.failed++;
  const entry = stats.byPath.get(path) ?? { retries: 0, lastCode: null, status: 'pending' };
  entry.lastCode = code;
  entry.status = 'failed';
  stats.byPath.set(path, entry);
}

export function recordPermanent(path, code) {
  stats.permanent++;
  const entry = stats.byPath.get(path) ?? { retries: 0, lastCode: null, status: 'pending' };
  entry.lastCode = code;
  entry.status = 'permanent';
  stats.byPath.set(path, entry);
}

export function recordSuccessAfterRetry(path) {
  const entry = stats.byPath.get(path);
  if (entry && entry.retries > 0 && entry.status === 'pending') {
    stats.succeededAfterRetry++;
    entry.status = 'ok';
    stats.byPath.set(path, entry);
  }
}

export function summarize() {
  return {
    totalRetries: stats.totalRetries,
    succeededAfterRetry: stats.succeededAfterRetry,
    failed: stats.failed,
    permanent: stats.permanent,
  };
}

export function getFailedPaths() {
  const failed = [];
  for (const [path, entry] of stats.byPath.entries()) {
    if (entry.status === 'failed') {
      failed.push({ path, code: entry.lastCode, retries: entry.retries });
    }
  }
  return failed;
}

export function getPermanentErrorPaths() {
  const permanent = [];
  for (const [path, entry] of stats.byPath.entries()) {
    if (entry.status === 'permanent') {
      permanent.push({ path, code: entry.lastCode });
    }
  }
  return permanent;
}

export function reset() {
  stats.totalRetries = 0;
  stats.succeededAfterRetry = 0;
  stats.failed = 0;
  stats.permanent = 0;
  stats.byPath.clear();
}

  async isGitRepository() {
    if (this._isRepo !== null) {
      return this._isRepo;
    }

    try {
      await this.git.revparse(['--git-dir']);
      this._isRepo = true;
      return true;
    } catch (error) {
      this._isRepo = false;
      return false;
    }
  }

  async getModifiedFiles() {
    const cacheKey = 'modified-files';
    const cached = this.cache.get(cacheKey);
    if (cached) return cached;

    try {
      if (!(await this.isGitRepository())) {
        throw new GitError('Not a git repository', 'getModifiedFiles');
      }

      // Get status
      const status = await this.git.status();

      // Combine all modified files
      const modifiedFiles = [
        ...status.modified,
        ...status.staged,
        ...status.not_added,
        ...status.created,
      ];

      // Remove duplicates and normalize paths
      const uniqueFiles = [...new Set(modifiedFiles)].map((file) => toPosix(file));

      this.cache.set(cacheKey, uniqueFiles);
      this.logger.logDebug(`Found ${uniqueFiles.length} modified files`);

      return uniqueFiles;
    } catch (error) {
      throw new GitError(`Failed to get modified files: ${error.message}`, 'getModifiedFiles', {
        originalError: error,
      });
    }
  }

  async getChangedFiles(fromRef = 'HEAD', toRef = null) {
    const cacheKey = `changed-files:${fromRef}:${toRef || 'working'}`;
    const cached = this.cache.get(cacheKey);
    if (cached) return cached;

    try {
      if (!(await this.isGitRepository())) {
        throw new GitError('Not a git repository', 'getChangedFiles');
      }

      let diffSummary;

      if (toRef) {
        // Diff between two refs
        diffSummary = await this.git.diffSummary([fromRef, toRef]);
      } else {
        // Diff from ref to working directory
        diffSummary = await this.git.diffSummary([fromRef]);
      }

      const changedFiles = diffSummary.files
        .filter((file) => file.file && !file.binary)
        .map((file) => toPosix(file.file));

      this.cache.set(cacheKey, changedFiles);
      this.logger.logDebug(
        `Found ${changedFiles.length} changed files between ${fromRef} and ${toRef || 'working directory'}`,
      );

      return changedFiles;
    } catch (error) {

  async getFileStatuses(files) {
    if (!files || files.length === 0) {
      return {};
    }

    try {
      if (!(await this.isGitRepository())) {
        return {};
      }

      const status = await this.git.status();
      const statusMap = {};

      // Build status map — simple-git returns renamed as {from, to} objects,
      // so flatten those into their destination paths (strings) for matching.
      const renamedPaths = (status.renamed || []).map((r) => r.to || r);
      const allStatuses = {
        modified: status.modified,
        staged: status.staged,
        not_added: status.not_added,
        created: status.created,
        deleted: status.deleted,
        renamed: renamedPaths,
        conflicted: status.conflicted,
      };

      files.forEach((file) => {
        const posixPath = toPosix(file);

        for (const [statusType, fileList] of Object.entries(allStatuses)) {
          const posixList = fileList.map((f) => toPosix(String(f)));
          if (posix

  async getCurrentBranch() {
    const cacheKey = 'current-branch';
    const cached = this.cache.get(cacheKey);
    if (cached) return cached;

    try {
      if (!(await this.isGitRepository())) {
        return null;
      }

      const branch = await this.git.revparse(['--abbrev-ref', 'HEAD']);
      this.cache.set(cacheKey, branch);

      return branch;
    } catch (error) {
      this.logger.warn(`Failed to get current branch: ${error.message}`);
      return null;
    }
  }

  async getLastCommit() {
    const cacheKey = 'last-commit';
    const cached = this.cache.get(cacheKey);
    if (cached) return cached;

    try {
      if (!(await this.isGitRepository())) {
        return null;
      }

      const log = await this.git.log({ n: 1 });
      const commit = log.latest;

      if (commit) {
        const commitInfo = {
          hash: commit.hash,
          message: commit.message,
          author: commit.author_name,
          date: commit.date,
        };

        this.cache.set(cacheKey, commitInfo);
        return commitInfo;
      }

      return null;
    } catch (error) {
      this.logger.warn(`Failed to get last commit: ${error.message}`);
      return null;
    }
  }

  async hasUncommittedChanges() {
    try {
      if (!(await this.isGitRepository())) {
        return false;
      }

      const status = await this.git.status();
      return !status.isClean();
    } catch (error) {
      this.logger.warn(`Failed to check uncommitted changes: ${error.message}`);
      return false;
    }
  }

async function retry(fn, options = {}) {
  const {
    maxAttempts = 3,
    initialDelay = 1000,
    maxDelay = 10000,
    backoffMultiplier = 2,
    shouldRetry = (error) => true,
  } = options;

  let lastError;
  let delay = initialDelay;

  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn(attempt);
    } catch (error) {
      lastError = error;

      if (attempt === maxAttempts || !shouldRetry(error)) {
        throw error;
      }

      await sleep(Math.min(delay, maxDelay));
      delay *= backoffMultiplier;
    }
  }

  throw lastError;
}

async function getTempDir(prefix = 'copytree') {
  const tempBase = os.tmpdir();
  const tempDir = path.join(
    tempBase,
    `${prefix}-${Date.now()}-${shortHash(Math.random().toString())}`,
  );
  await ensureDir(tempDir);
  return tempDir;
}

async function cleanupTempDir(tempDir) {
  try {
    await fs.remove(tempDir);
  } catch (error) {
    // Ignore cleanup errors
  }
}

function isBinaryExtension(filePath) {
  const binaryExtensions = new Set([
    'exe',
    'dll',
    'so',
    'dylib',
    'bin',
    'jpg',
    'jpeg',
    'png',
    'gif',
    'bmp',
    'ico',
    'webp',
    'svg',
    'mp3',
    'mp4',
    'avi',
    'mov',
    'wmv',
    'flv',
    'webm',
    'zip',
    'tar',
    'gz',
    'rar',
    '7z',
    'bz2',
    'pdf',
    'doc',
    'docx',
    'xls',
    'xlsx',
    'ppt',
    'pptx',
    'ttf',
    'otf',
    'woff',
    'woff2',
    'eot',
    'db',
    'sqlite',
    'sqlite3',
  ]);

  const ext = getExtension(filePath).toLowerCase();
  return binaryExtensions.has(ext);
}

function isImageExtension(filePath) {
  const imageExtensions = new Set([
    'jpg',
    'jpeg',
    'png',
    'gif',
    'bmp',
    'ico',
    'webp',
    'svg',
    'tiff',
    'tif',
  ]);

  const ext = getExtension(filePath).toLowerCase();
  return imageExtensions.has(ext);
}