.gitignore Support

DEFAULT_IGNORED_DIRS = {
    "__pycache__",
    ".git",
    ".venv",
    "venv",
    ".mypy_cache",
    ".pytest_cache",
    "build",
    "dist",
}

@dataclass(frozen=True)
class GitIgnoreRule:
    pattern: str        # The glob pattern to match
    negated: bool       # True if pattern starts with !
    directory_only: bool  # True if pattern ends with /
    anchored: bool      # True if pattern starts with /

def _load_gitignore_rules(root: Path) -> list[GitIgnoreRule]:
    gitignore_path = root / ".gitignore"
    if not gitignore_path.exists():
        return []

    rules: list[GitIgnoreRule] = []
    for raw_line in gitignore_path.read_text(encoding="utf-8", errors="ignore").splitlines():
        line = raw_line.strip()
        if not line or line.startswith("#"):
            continue

        negated = line.startswith("!")
        if negated:
            line = line[1:]

        directory_only = line.endswith("/")
        if directory_only:
            line = line[:-1]

        anchored = line.startswith("/")
        if anchored:
            line = line[1:]

        if line:
            rules.append(
                GitIgnoreRule(
                    pattern=line,
                    negated=negated,
                    directory_only=directory_only,
                    anchored=anchored,
                )
            )

    return rules

def _match_rule(relative_path: str, is_dir: bool, rule: GitIgnoreRule) -> bool:
    normalized = relative_path.replace("\\", "/")

    if rule.anchored:
        path_matches = fnmatch.fnmatch(normalized, rule.pattern)
        subtree_matches = normalized.startswith(rule.pattern + "/")
    elif "/" in rule.pattern:
        path_matches = fnmatch.fnmatch(normalized, rule.pattern)
        subtree_matches = normalized.startswith(rule.pattern + "/")
    else:
        parts = normalized.split("/")
        path_matches = any(fnmatch.fnmatch(part, rule.pattern) for part in parts)
        subtree_matches = any(part == rule.pattern for part in parts)

    matched = path_matches or subtree_matches

    if rule.directory_only:
        return matched and is_dir

    return matched

def _is_ignored(relative_path: str, is_dir: bool, rules: list[GitIgnoreRule]) -> bool:
    ignored = False
    for rule in rules:
        if _match_rule(relative_path, is_dir, rule):
            ignored = not rule.negated
    return ignored

*.log          # Ignore all .log files
!important.log # Re-include important.log
logs/          # Ignore logs directory
!logs/keep/    # Re-include logs/keep directory

from docugen.core.scanner import scan_python_files, DEFAULT_IGNORED_DIRS

# Remove a default exclusion
DEFAULT_IGNORED_DIRS.discard(".venv")

# Scan with modified defaults
files = scan_python_files("/path/to/project")

def scan_python_files(root_path: str | Path) -> list[Path]:
    root = Path(root_path).expanduser().resolve()

    if not root.exists():
        raise FileNotFoundError(f"Path does not exist: {root}")

    if root.is_file():
        return [root] if root.suffix == ".py" else []

    rules = _load_gitignore_rules(root)
    discovered: list[Path] = []

    for current_dir, dirnames, filenames in os.walk(root, topdown=True):
        current = Path(current_dir)

        # Filter directories
        filtered_dirs: list[str] = []
        for dirname in dirnames:
            if dirname in DEFAULT_IGNORED_DIRS:
                continue

            directory_path = current / dirname
            relative_dir = directory_path.relative_to(root).as_posix()
            if _is_ignored(relative_dir, is_dir=True, rules=rules):
                continue

            filtered_dirs.append(dirname)

        dirnames[:] = filtered_dirs  # Modify in-place to prune walk

        # Filter files
        for filename in filenames:
            if not filename.endswith(".py"):
                continue

            file_path = current / filename
            relative_file = file_path.relative_to(root).as_posix()
            if _is_ignored(relative_file, is_dir=False, rules=rules):
                continue

            discovered.append(file_path.resolve())

    return sorted(discovered)

from docugen.core.scanner import scan_python_files
from pathlib import Path

root = Path("/path/to/project")
found = scan_python_files(root)

print(f"Found {len(found)} Python files:")
for file in found:
    print(f"  {file.relative_to(root)}")

from docugen.core.scanner import _load_gitignore_rules, _is_ignored
from pathlib import Path

root = Path("/path/to/project")
rules = _load_gitignore_rules(root)

test_paths = [
    ("tests/test_api.py", False),
    ("build", True),
    (".venv/lib/site.py", False),
]

for path, is_dir in test_paths:
    ignored = _is_ignored(path, is_dir, rules)
    status = "IGNORED" if ignored else "INCLUDED"
    print(f"{status}: {path}")