gitsearch.py

#!/usr/bin/env python3
"""
File search tool: git history + filesystem with pattern matching.
Searches for files matching patterns (e.g., *.env, secrets, apikey) in:
  1. Git commit history (to find accidentally committed files)
  2. Current filesystem
"""

import subprocess
import re
import sys
import os
from pathlib import Path
from typing import List, Dict
import argparse
import json


def search_git_history(pattern: str, repo_path: str = ".", timeout: int = 15) -> List[str]:
    """Search for files in git history matching the pattern.

    This uses a single `git log --all --name-only --pretty=format:` call
    to avoid iterating commits one-by-one which is slow on large repos.
    """
    results: Dict[str, None] = {}

    try:
        output = subprocess.check_output(
            ["git", "log", "--all", "--name-only", "--pretty=format:"],
            cwd=repo_path,
            text=True,
            stderr=subprocess.DEVNULL,
            timeout=timeout,
        )
    except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
        return []

    for line in output.splitlines():
        fn = line.strip()
        if not fn:
            continue
        if _matches_pattern(fn, pattern):
            results[fn] = None

    return sorted(results.keys())


def search_filesystem(pattern: str, root_path: str = ".") -> List[str]:
    """Search filesystem for files matching the pattern.

    Hidden directories (starting with `.`) and `.git` are skipped.
    """
    results = []

    try:
        root = Path(root_path).resolve()

        for item in root.rglob("*"):
            # Skip .git and hidden directories
            if ".git" in item.parts or any(p.startswith(".") for p in item.parts[len(root.parts):]):
                continue

            try:
                name = item.name
            except OSError:
                continue

            if _matches_pattern(name, pattern):
                try:
                    results.append(str(item.relative_to(root)))
                except Exception:
                    results.append(str(item))
    except (OSError, PermissionError):
        pass

    return sorted(results)


def _matches_pattern(filename: str, pattern: str) -> bool:
    """Return True if `filename` matches `pattern`.

    Pattern forms supported:
      - Regex: /pattern/ or /pattern/flags (e.g. /secret/i)
      - Glob: contains `*` or `?`
      - Substring: case-insensitive containment
    """
    # Regex pattern with optional flags: /pattern/flags
    if pattern.startswith("/") and pattern.count("/") >= 2:
        # find last slash
        last = pattern.rfind("/")
        pat = pattern[1:last]
        flags = pattern[last+1:]
        re_flags = 0
        if "i" in flags:
            re_flags |= re.IGNORECASE
        try:
            return bool(re.search(pat, filename, flags=re_flags))
        except re.error:
            return False

    # Glob pattern
    if "*" in pattern or "?" in pattern:
        from fnmatch import fnmatch
        return fnmatch(filename, pattern)

    # Substring (case-insensitive)
    return pattern.lower() in filename.lower()


def print_results(git_files: List[str], fs_files: List[str], pattern: str, *, max_results: int = 20, json_out: bool = False):
    """Pretty print or JSON-serialize results."""
    if json_out:
        payload = {
            "pattern": pattern,
            "git": git_files,
            "filesystem": fs_files,
        }
        print(json.dumps(payload, indent=2))
        return

    print(f"\n🔍 Search Results for: {pattern}\n")

    if git_files:
        print(f"📦 Found in git history ({len(git_files)}):")
        for f in git_files[:max_results]:
            print(f"   git: {f}")
        if len(git_files) > max_results:
            print(f"   ... and {len(git_files) - max_results} more")

    if fs_files:
        print(f"\n📁 Found in filesystem ({len(fs_files)}):")
        for f in fs_files[:max_results]:
            print(f"   fs:  {f}")
        if len(fs_files) > max_results:
            print(f"   ... and {len(fs_files) - max_results} more")

    if not git_files and not fs_files:
        print("✅ No matches found")

    print()


def main():
    parser = argparse.ArgumentParser(
        description="Search for files in git history and filesystem",
        epilog="""
Examples:
  python search.py "*.env"           # Find .env files
  python search.py "*apikey*"        # Find files with 'apikey'
  python search.py "secrets"         # Find files containing 'secrets'
    python search.py "/^\\.env\\..*$/"   # Regex: .env.* files
  python search.py "*.pem" --git-only
  python search.py "*password*" --fs-only /path/to/search
        """,
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    
    parser.add_argument("pattern", help="Pattern to search (glob, substring, or /regex/)")
    parser.add_argument("--git-only", action="store_true", help="Search git history only")
    parser.add_argument("--fs-only", action="store_true", help="Search filesystem only")
    parser.add_argument("--path", "-p", default=".", help="Root path to search (default: current dir)")
    parser.add_argument("--repo", "-r", default=".", help="Git repo path (default: current dir)")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument("--max-results", type=int, default=20, help="Max results to show per section (default: 20)")
    parser.add_argument("--timeout", type=int, default=15, help="Timeout seconds for git operations (default: 15)")
    parser.add_argument("--verbose", action="store_true", help="Verbose logging")
    
    args = parser.parse_args()
    
    git_files = []
    fs_files = []
    
    if not args.fs_only:
        if args.verbose:
            print(f"Searching git history in: {args.repo}")
        git_files = search_git_history(args.pattern, args.repo, timeout=args.timeout)
    
    if not args.git_only:
        if args.verbose:
            print(f"Searching filesystem in: {args.path}")
        fs_files = search_filesystem(args.pattern, args.path)
    print_results(git_files, fs_files, args.pattern, max_results=args.max_results, json_out=args.json)

    # Exit codes: 0 = no matches, 2 = matches found (non-zero to signal CI failures)
    if git_files or fs_files:
        sys.exit(2)
    else:
        sys.exit(0)


if __name__ == "__main__":
    main()