apipatch 0.3.0__py3-none-any.whl

apipatch/__init__.py

@@ -0,0 +1,22 @@
+"""
+ApiPatch - Autonomous AI Agent for API Breaking Changes & Self-Maintaining Codebases
+Detects and fixes deprecated third-party API calls in Python, JavaScript, TypeScript,
+JSX, TSX, and any other language — powered by LLM reasoning.
+"""
+
+__version__ = "0.3.0"
+__author__ = "Morad Moqbel"
+__license__ = "MIT"
+
+from apipatch.engine import ApiPatchEngine
+from apipatch.validator import CodeValidator
+from apipatch.auto_detector import AutoDeprecationDetector
+from apipatch.proactive_hunter import GitHubPRHunter
+
+__all__ = [
+    "ApiPatchEngine",
+    "CodeValidator",
+    "AutoDeprecationDetector",
+    "GitHubPRHunter",
+    "__version__",
+]

apipatch/auto_detector.py

@@ -0,0 +1,223 @@
+"""
+ApiPatch Autonomous Dependency & Import Detector
+Discovers all third-party libraries used in a project (Python, JavaScript, TypeScript)
+without any hardcoded rules — enabling the LLM engine to reason about ANY library.
+"""
+
+import os
+import ast
+import json
+import re
+from typing import List, Set, Dict, Any, Optional
+from apipatch.providers.factory import ProviderFactory
+
+# Python standard library module names (excluded from "third-party" list)
+STANDARD_LIB_MODULES = {
+    "abc", "argparse", "array", "ast", "asyncio", "base64", "binascii", "bisect",
+    "builtins", "calendar", "cmath", "collections", "concurrent", "contextlib",
+    "copy", "csv", "ctypes", "dataclasses", "datetime", "decimal", "difflib",
+    "dis", "doctest", "email", "enum", "errno", "faulthandler", "fcntl", "filecmp",
+    "fileinput", "fnmatch", "fractions", "functools", "gc", "getopt", "getpass",
+    "gettext", "glob", "graphlib", "gzip", "hashlib", "heapq", "hmac", "html",
+    "http", "idlelib", "imaplib", "imghdr", "importlib", "inspect", "io",
+    "ipaddress", "itertools", "json", "keyword", "linecache", "locale", "logging",
+    "lzma", "mailbox", "mailcap", "marshal", "math", "mimetypes", "mmap",
+    "modulefinder", "multiprocessing", "netrc", "nntplib", "numbers", "operator",
+    "os", "pathlib", "pdb", "pickle", "pipes", "pkgutil", "platform", "plistlib",
+    "poplib", "posix", "pprint", "profile", "pstats", "pty", "pwd", "py_compile",
+    "pyclbr", "pydoc", "queue", "quopri", "random", "re", "readline", "reprlib",
+    "resource", "rlcompleter", "runpy", "sched", "secrets", "select", "selectors",
+    "shelve", "shlex", "shutil", "signal", "site", "smtpd", "smtplib", "sndhdr",
+    "socket", "socketserver", "spwd", "sqlite3", "ssl", "stat", "statistics",
+    "string", "stringprep", "struct", "subprocess", "sunau", "symtable", "sys",
+    "sysconfig", "syslog", "tabnanny", "tarfile", "telnetlib", "tempfile", "termios",
+    "test", "textwrap", "threading", "time", "timeit", "tkinter", "token",
+    "tokenize", "tomllib", "trace", "traceback", "tracemalloc", "tty", "turtle",
+    "turtledemo", "types", "typing", "unicodedata", "unittest", "urllib", "uu",
+    "uuid", "venv", "warnings", "wave", "weakref", "webbrowser", "winreg", "winsound",
+    "wsgiref", "xdrlib", "xml", "xmlrpc", "zipapp", "zipfile", "zipimport", "zlib",
+    "zoneinfo"
+}
+
+# Node.js built-in modules (excluded from third-party list for JS/TS projects)
+NODE_BUILTIN_MODULES = {
+    "fs", "path", "http", "https", "os", "crypto", "stream", "util", "events",
+    "child_process", "cluster", "dgram", "dns", "domain", "net", "querystring",
+    "readline", "repl", "string_decoder", "timers", "tls", "tty", "url",
+    "v8", "vm", "worker_threads", "zlib", "buffer", "assert", "console",
+    "module", "process", "inspector", "perf_hooks", "async_hooks"
+}
+
+
+class AutoDeprecationDetector:
+    def __init__(
+        self,
+        target_dir: str = ".",
+        provider_name: Optional[str] = None,
+        api_key: Optional[str] = None
+    ):
+        self.target_dir = os.path.abspath(target_dir)
+        self.provider = ProviderFactory.get_provider(
+            provider_name=provider_name, api_key=api_key
+        )
+
+    # ─── Python Import Extraction ─────────────────────────────────────────────
+
+    def extract_imports_from_file(self, file_path: str) -> Set[str]:
+        """
+        Uses Python AST to extract all third-party imported module names
+        from a .py or .pyw source file.
+        """
+        imports: Set[str] = set()
+        if not file_path.endswith((".py", ".pyw")):
+            return imports
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+            tree = ast.parse(content)
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        top_pkg = alias.name.split('.')[0]
+                        if top_pkg not in STANDARD_LIB_MODULES:
+                            imports.add(top_pkg)
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module:
+                        top_pkg = node.module.split('.')[0]
+                        if top_pkg not in STANDARD_LIB_MODULES:
+                            imports.add(top_pkg)
+        except Exception:
+            pass
+        return imports
+
+    # ─── JS/TS Import Extraction ──────────────────────────────────────────────
+
+    def extract_imports_from_js_file(self, file_path: str) -> Set[str]:
+        """
+        Uses regex to extract third-party package names from
+        JS / TS / JSX / TSX / MJS / CJS source files.
+        """
+        imports: Set[str] = set()
+        ext = os.path.splitext(file_path)[1].lower()
+        if ext not in {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}:
+            return imports
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+
+            # ESM: import ... from 'pkg'  /  import 'pkg'
+            esm_patterns = re.findall(
+                r"""(?:^|\n)\s*import\s+(?:[^'"]*?from\s+)?['"]([@\w][\w/.-]*)['"]""",
+                content
+            )
+            # CJS: require('pkg')
+            cjs_patterns = re.findall(r"""require\s*\(\s*['"]([@\w][\w/.-]*)['"]\s*\)""", content)
+
+            for raw in esm_patterns + cjs_patterns:
+                # Normalise scoped packages: @org/pkg -> @org/pkg
+                # Strip sub-paths: lodash/merge -> lodash
+                if raw.startswith('@'):
+                    parts = raw.split('/')
+                    pkg = '/'.join(parts[:2]) if len(parts) >= 2 else raw
+                else:
+                    pkg = raw.split('/')[0]
+
+                if pkg and pkg not in NODE_BUILTIN_MODULES and not pkg.startswith('.'):
+                    imports.add(pkg)
+        except Exception:
+            pass
+        return imports
+
+    # ─── Manifest-based Dependency Discovery ─────────────────────────────────
+
+    def _parse_requirements_txt(self) -> Set[str]:
+        deps: Set[str] = set()
+        req_path = os.path.join(self.target_dir, "requirements.txt")
+        if os.path.exists(req_path):
+            with open(req_path, "r", encoding="utf-8", errors="ignore") as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#") and not line.startswith("-"):
+                        pkg = re.split(r"[><=~;!@\[]", line)[0].strip().lower()
+                        if pkg:
+                            deps.add(pkg)
+        return deps
+
+    def _parse_package_json(self) -> Set[str]:
+        deps: Set[str] = set()
+        pkg_json = os.path.join(self.target_dir, "package.json")
+        if os.path.exists(pkg_json):
+            try:
+                with open(pkg_json, "r", encoding="utf-8", errors="ignore") as f:
+                    data = json.load(f)
+                for key in ("dependencies", "devDependencies", "peerDependencies"):
+                    if key in data and isinstance(data[key], dict):
+                        deps.update(p.lower() for p in data[key].keys())
+            except Exception:
+                pass
+        return deps
+
+    def _parse_pyproject_toml(self) -> Set[str]:
+        deps: Set[str] = set()
+        pyproject = os.path.join(self.target_dir, "pyproject.toml")
+        if os.path.exists(pyproject):
+            try:
+                with open(pyproject, "r", encoding="utf-8", errors="ignore") as f:
+                    content = f.read()
+                # Extract quoted package names from dependency lists
+                for match in re.findall(r'"([a-zA-Z0-9_\-]+)(?:[><=~;].*)?[">\s]', content):
+                    m = match.strip().lower()
+                    if m and m not in {"apipatch", "setuptools", "wheel", "pytest", "python"}:
+                        deps.add(m)
+            except Exception:
+                pass
+        return deps
+
+    # ─── Main Detection API ───────────────────────────────────────────────────
+
+    def detect_dependencies(self) -> List[str]:
+        """
+        Discovers all third-party packages from:
+        1. requirements.txt
+        2. package.json
+        3. pyproject.toml
+        4. Recursive AST inspection of Python source files
+        5. Regex inspection of JS/TS source files
+        """
+        dependencies: Set[str] = set()
+
+        dependencies.update(self._parse_requirements_txt())
+        dependencies.update(self._parse_package_json())
+        dependencies.update(self._parse_pyproject_toml())
+
+        ignore_dirs = {
+            ".git", "node_modules", "venv", ".venv", "__pycache__",
+            ".gemini", "dist", "build", ".next", ".nuxt", "out", "coverage"
+        }
+
+        for root, dirs, files in os.walk(self.target_dir):
+            dirs[:] = [d for d in dirs if d not in ignore_dirs]
+            for file in files:
+                full_path = os.path.join(root, file)
+                ext = os.path.splitext(file)[1].lower()
+                if ext in {".py", ".pyw"}:
+                    dependencies.update(self.extract_imports_from_file(full_path))
+                elif ext in {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}:
+                    dependencies.update(self.extract_imports_from_js_file(full_path))
+
+        return sorted(dependencies)
+
+    def run_autonomous_discovery(self) -> Dict[str, Any]:
+        """Runs end-to-end autonomous dependency discovery and prints a summary."""
+        deps = self.detect_dependencies()
+        print(f"\n[ApiPatch] Detected {len(deps)} third-party package(s) in '{self.target_dir}':")
+        for dep in deps:
+            print(f"  - {dep}")
+        print(
+            "\nAll detected packages will be passed to the AI engine "
+            "for dynamic deprecation analysis when you run `apipatch scan` or `apipatch fix`.\n"
+        )
+        return {
+            "target_directory": self.target_dir,
+            "detected_packages": deps,
+        }

apipatch/cli.py

@@ -0,0 +1,101 @@
+"""
+ApiPatch Command Line Interface (CLI)
+Provides modern terminal commands for autonomous API code audits and automated refactoring.
+"""
+
+import sys
+import argparse
+from typing import Optional
+from apipatch import __version__
+from apipatch.engine import ApiPatchEngine, Colors
+from apipatch.auto_detector import AutoDeprecationDetector
+from apipatch.proactive_hunter import GitHubPRHunter
+
+# Ensure UTF-8 console output on Windows
+if sys.stdout and hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="apipatch",
+        description=f"{Colors.HEADER}⚡ ApiPatch v{__version__} - Autonomous AI Agent for API Breaking Changes{Colors.ENDC}",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument("-v", "--version", action="version", version=f"apipatch {__version__}")
+
+    subparsers = parser.add_subparsers(dest="command", help="Available subcommands")
+
+    # Command: scan
+    scan_parser = subparsers.add_parser("scan", help="Scan a codebase for deprecated API signatures")
+    scan_parser.add_argument("path", nargs="?", default=".", help="File or directory path to scan (default: current dir)")
+    scan_parser.add_argument("--provider", choices=["openai", "anthropic", "gemini"], help="AI provider for dynamic reasoning")
+    scan_parser.add_argument("--api-key", help="API key for chosen provider")
+    scan_parser.add_argument("--model", help="Specific model name (e.g., gpt-4o, claude-3-7-sonnet)")
+
+    # Command: fix
+    fix_parser = subparsers.add_parser("fix", help="Audit and generate modernized code refactors")
+    fix_parser.add_argument("path", nargs="?", default=".", help="File or directory path to refactor")
+    fix_parser.add_argument("-w", "--write", action="store_true", help="Apply fixes in-place to files on disk")
+    fix_parser.add_argument("--no-backup", action="store_true", help="Disable automatic .bak file creation when writing")
+    fix_parser.add_argument("--provider", choices=["openai", "anthropic", "gemini"], help="AI provider for dynamic reasoning")
+    fix_parser.add_argument("--api-key", help="API key for chosen provider")
+    fix_parser.add_argument("--model", help="Specific model name")
+
+    # Command: detect
+    detect_parser = subparsers.add_parser("detect", help="Auto-discover project dependencies and deprecation rules")
+    detect_parser.add_argument("path", nargs="?", default=".", help="Project directory path (default: current dir)")
+
+    # Command: hunt
+    hunt_parser = subparsers.add_parser("hunt", help="Proactively search GitHub for deprecated code and prepare PRs")
+    hunt_parser.add_argument("query", nargs="?", default="openai.ChatCompletion.create language:python", help="GitHub Code Search query")
+    hunt_parser.add_argument("--max", type=int, default=3, help="Max candidate repositories to inspect")
+    hunt_parser.add_argument("--token", help="GitHub Personal Access Token")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        # Default behavior if no subcommand passed: interactive help or scan
+        parser.print_help()
+        sys.exit(0)
+
+    if args.command == "scan":
+        engine = ApiPatchEngine(
+            provider_name=args.provider,
+            api_key=args.api_key,
+            model=args.model,
+            create_backup=False
+        )
+        if os_is_file(args.path):
+            engine.process_file(args.path, write_in_place=False)
+        else:
+            engine.process_directory(args.path, write_in_place=False)
+
+    elif args.command == "fix":
+        engine = ApiPatchEngine(
+            provider_name=args.provider,
+            api_key=args.api_key,
+            model=args.model,
+            create_backup=not args.no_backup
+        )
+        if os_is_file(args.path):
+            engine.process_file(args.path, write_in_place=args.write)
+        else:
+            engine.process_directory(args.path, write_in_place=args.write)
+
+    elif args.command == "detect":
+        detector = AutoDeprecationDetector(target_dir=args.path)
+        detector.run_autonomous_discovery()
+
+    elif args.command == "hunt":
+        hunter = GitHubPRHunter(github_token=args.token)
+        hunter.hunt_and_preview(query=args.query, max_results=args.max)
+
+
+def os_is_file(path: str) -> bool:
+    import os
+    return os.path.isfile(path)
+
+
+if __name__ == "__main__":
+    main()

apipatch/engine.py

@@ -0,0 +1,260 @@
+"""
+ApiPatch Core Orchestration Engine
+Pure LLM-powered autonomous agent for detecting and fixing deprecated API calls
+across ANY third-party library in Python, JavaScript, TypeScript, JSX, TSX, and more.
+"""
+
+import os
+import sys
+import shutil
+import difflib
+from typing import Dict, Any, List, Optional, Set
+from apipatch.validator import CodeValidator, ValidationResult
+from apipatch.providers.factory import ProviderFactory
+from apipatch.auto_detector import AutoDeprecationDetector
+
+# Reconfigure stdout/stderr for safe Unicode / Windows encoding
+if sys.stdout and hasattr(sys.stdout, "reconfigure"):
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+if sys.stderr and hasattr(sys.stderr, "reconfigure"):
+    try:
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+
+class Colors:
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKCYAN = '\033[96m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+
+
+def safe_print(text: str):
+    """Safely prints to stdout without dying on encoding mismatches."""
+    try:
+        print(text)
+    except UnicodeEncodeError:
+        try:
+            print(text.encode("ascii", errors="replace").decode("ascii"))
+        except Exception:
+            pass
+
+
+class ApiPatchEngine:
+    def __init__(
+        self,
+        provider_name: Optional[str] = None,
+        api_key: Optional[str] = None,
+        model: Optional[str] = None,
+        create_backup: bool = True
+    ):
+        self.provider = ProviderFactory.get_provider(
+            provider_name=provider_name,
+            api_key=api_key,
+            model=model
+        )
+        self.create_backup = create_backup
+        self.detector = AutoDeprecationDetector()
+
+    def audit_code(
+        self,
+        file_path: str,
+        code: str,
+        detected_libraries: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Fully LLM-driven audit:
+        Detects and fixes deprecated/breaking API calls across ANY library,
+        in Python, JavaScript, TypeScript, JSX, TSX, etc.
+        Falls back gracefully if no provider is configured.
+        """
+        file_name = os.path.basename(file_path)
+        _, ext = os.path.splitext(file_path)
+
+        empty_result = {
+            "has_breaking_changes": False,
+            "detected_issues": [],
+            "refactored_code": code
+        }
+
+        if not self.provider:
+            safe_print(
+                f"  {Colors.WARNING}[!] No AI provider configured. "
+                f"Set GEMINI_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY "
+                f"to enable full analysis.{Colors.ENDC}"
+            )
+            return empty_result
+
+        try:
+            libs = detected_libraries or list(
+                self.detector.extract_imports_from_file(file_path)
+            )
+            llm_res = self.provider.audit_code(file_name, code, detected_libraries=libs)
+
+            if llm_res.get("has_breaking_changes") and llm_res.get("refactored_code"):
+                refactored = llm_res["refactored_code"]
+                val = CodeValidator.validate(code, refactored, file_extension=ext)
+                if val.is_valid:
+                    return llm_res
+                else:
+                    safe_print(
+                        f"  {Colors.WARNING}[!] LLM output failed safety validation "
+                        f"({val.error_message}). Keeping original.{Colors.ENDC}"
+                    )
+                    return empty_result
+
+            return llm_res if llm_res else empty_result
+
+        except Exception as e:
+            safe_print(f"  {Colors.WARNING}[!] Provider error: {e}{Colors.ENDC}")
+            return empty_result
+
+    def generate_diff(self, old_code: str, new_code: str, file_name: str) -> List[str]:
+        """Generates unified diff lines between old and new code."""
+        old_lines = old_code.splitlines(keepends=True)
+        new_lines = new_code.splitlines(keepends=True)
+        return list(difflib.unified_diff(
+            old_lines,
+            new_lines,
+            fromfile=f"a/{file_name}",
+            tofile=f"b/{file_name}"
+        ))
+
+    def print_diff(self, diff: List[str]):
+        """Prints colorized unified diff to stdout."""
+        if not diff:
+            safe_print("  (No changes needed)")
+            return
+
+        for line in diff:
+            if line.startswith('+') and not line.startswith('+++'):
+                safe_print(f"{Colors.OKGREEN}{line.rstrip()}{Colors.ENDC}")
+            elif line.startswith('-') and not line.startswith('---'):
+                safe_print(f"{Colors.FAIL}{line.rstrip()}{Colors.ENDC}")
+            elif line.startswith('@'):
+                safe_print(f"{Colors.OKCYAN}{line.rstrip()}{Colors.ENDC}")
+            else:
+                safe_print(f" {line.rstrip()}")
+
+    def process_file(
+        self,
+        file_path: str,
+        write_in_place: bool = False,
+        detected_libraries: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """Audits, refactors, previews diff, and optionally writes fixed code to disk."""
+        file_path = os.path.abspath(file_path)
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                original_code = f.read()
+        except Exception as e:
+            safe_print(f"{Colors.FAIL}[!] Cannot read {file_path}: {e}{Colors.ENDC}")
+            return {"file": file_path, "status": "error", "issues": []}
+
+        audit = self.audit_code(file_path, original_code, detected_libraries=detected_libraries)
+        file_name = os.path.basename(file_path)
+
+        if not audit["has_breaking_changes"]:
+            safe_print(f"{Colors.OKGREEN}[✓] {file_name}: Clean — no breaking changes detected.{Colors.ENDC}")
+            return {"file": file_path, "status": "clean", "issues": []}
+
+        issues = audit["detected_issues"]
+        safe_print(f"\n{Colors.FAIL}[!] [{len(issues)} DEPRECATION(S)] {file_path}{Colors.ENDC}")
+        for idx, issue in enumerate(issues, 1):
+            safe_print(f"  {Colors.BOLD}#{idx} [{issue['library']}]:{Colors.ENDC} {issue['description']}")
+            safe_print(f"     Deprecated : {Colors.FAIL}{issue['deprecated_symbol']}{Colors.ENDC}")
+            safe_print(f"     Replacement: {Colors.OKGREEN}{issue['replacement_symbol']}{Colors.ENDC}")
+
+        refactored = audit.get("refactored_code", original_code)
+        diff = self.generate_diff(original_code, refactored, file_name)
+
+        safe_print(f"\n{Colors.OKBLUE}>> Refactored Diff Preview:{Colors.ENDC}")
+        self.print_diff(diff)
+
+        if write_in_place and refactored != original_code:
+            if self.create_backup:
+                backup_path = f"{file_path}.bak"
+                shutil.copy2(file_path, backup_path)
+                safe_print(f"  {Colors.OKCYAN}[*] Backup saved → {backup_path}{Colors.ENDC}")
+
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(refactored)
+            safe_print(f"  {Colors.OKGREEN}[✓] Updated {file_name} in place.{Colors.ENDC}")
+
+        first_lib = issues[0]['library'] if issues else "API"
+        safe_print(
+            f"\n{Colors.HEADER}[PR Ready]:{Colors.ENDC} "
+            f"[ApiPatch] Migrate deprecated {first_lib} calls in {file_name}"
+        )
+
+        return {
+            "file": file_path,
+            "status": "refactored" if write_in_place else "detected",
+            "issues": issues,
+            "refactored_code": refactored
+        }
+
+    def process_directory(
+        self,
+        target_dir: str,
+        write_in_place: bool = False
+    ) -> Dict[str, Any]:
+        """Recursively audits all supported source files in target directory."""
+        target_dir = os.path.abspath(target_dir)
+        safe_print(f"{Colors.HEADER}{Colors.BOLD}=== ApiPatch: Autonomous AI Codebase Auditor ==={Colors.ENDC}")
+        safe_print(f"Target Directory : {Colors.OKCYAN}{target_dir}{Colors.ENDC}")
+        provider_name = self.provider.__class__.__name__ if self.provider else "No Provider (Offline)"
+        safe_print(f"Active AI Engine : {Colors.OKGREEN}{provider_name}{Colors.ENDC}\n")
+
+        # Discover project-wide dependencies
+        detector = AutoDeprecationDetector(target_dir)
+        deps = detector.detect_dependencies()
+        if deps:
+            listed = ', '.join(deps[:12])
+            extra = f'... (+{len(deps) - 12} more)' if len(deps) > 12 else ''
+            safe_print(f"[*] Detected {len(deps)} dependencies: {listed}{extra}\n")
+
+        total_scanned = 0
+        affected_files = 0
+        results = []
+
+        ignore_dirs = {
+            ".git", "node_modules", "venv", ".venv", "__pycache__",
+            ".gemini", "dist", "build", ".next", ".nuxt", "out", "coverage"
+        }
+        supported_exts = {".py", ".pyw", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}
+
+        for root, dirs, files in os.walk(target_dir):
+            dirs[:] = [d for d in dirs if d not in ignore_dirs]
+            for file in files:
+                _, ext = os.path.splitext(file)
+                if ext in supported_exts:
+                    total_scanned += 1
+                    full_path = os.path.join(root, file)
+                    res = self.process_file(
+                        full_path,
+                        write_in_place=write_in_place,
+                        detected_libraries=deps
+                    )
+                    if res["status"] in {"detected", "refactored"}:
+                        affected_files += 1
+                    results.append(res)
+
+        safe_print(
+            f"\n[Audit Summary]: {total_scanned} file(s) inspected, "
+            f"{affected_files} file(s) with deprecated APIs found."
+        )
+        return {
+            "total_scanned": total_scanned,
+            "affected_files": affected_files,
+            "results": results
+        }