Function collectFiles

src/scanner.ts:122–216

(
  root: string,
  maxDepth = 10,
  ignorePatterns: string[] = []
)

}

export async function collectFiles(
  root: string,
  maxDepth = 10,
  ignorePatterns: string[] = []
): Promise<string[]> {
  const files: string[] = [];

  // Split positive ignores from gitignore-style negations (`!pattern`). A
  // negation explicitly re-includes an entry that would otherwise be skipped
  // — including dot-folders, which are skipped by default.
  const positivePatterns: string[] = [];
  const negationPatterns: string[] = [];
  for (const raw of ignorePatterns) {
    if (raw.startsWith("!")) {
      negationPatterns.push(raw.slice(1));
    } else {
      positivePatterns.push(raw);
    }
  }

  const normalize = (p: string) => p.replace(/\/\*\*?$/, "").replace(/^\//, "");
  const extraIgnore = new Set(positivePatterns.map(normalize));
  const negationNames = new Set(negationPatterns.map(normalize));

  function isExplicitlyIncluded(name: string, fullPath: string): boolean {
    if (negationNames.has(name)) return true;
    const rel = fullPath.replace(root, "").replace(/^[/\\]/, "");
    for (const pattern of negationPatterns) {
      const clean = normalize(pattern);
      // Exact match by name or relative path only. A negation like `!.source`
      // re-includes the `.source` entry itself; it does NOT auto-re-include
      // arbitrary descendants. Otherwise nested dot-folders (.source/.git)
      // and explicit positive ignores (.source/testfolder) would be silently
      // overridden by any parent-level negation. (gitignore semantics: a
      // child can only be re-included by an explicit `!child` pattern.)
      if (rel === clean) return true;
      // Explicit recursive negation `!path/**` re-includes path and descendants.
      if (pattern.endsWith("/**") || pattern.endsWith("/*")) {
        if (rel.startsWith(clean + "/") || rel.startsWith(clean + "\\")) return true;
      }
    }
    return false;
  }

  function shouldIgnoreDir(name: string, fullPath: string): boolean {
    if (isExplicitlyIncluded(name, fullPath)) return false;
    if (IGNORE_DIRS.has(name)) return true;
    if (extraIgnore.has(name)) return true;
    // Check if any pattern matches a path segment
    const rel = fullPath.replace(root, "").replace(/^[/\\]/, "");
    for (const pattern of positivePatterns) {
      const clean = normalize(pattern);
      if (rel === clean || rel.startsWith(clean + "/") || rel.startsWith(clean + "\\")) return true;
    }
    return false;
  }

  async function walk(dir: string, depth: number) {