ballpython 2.0.7__py3-none-any.whl → 2.1.1__py3-none-any.whl

{ballpython-2.0.7.dist-info → ballpython-2.1.1.dist-info}/METADATA

@@ -1,14 +1,12 @@
 Metadata-Version: 2.4
 Name: ballpython
-Version: 2.0.7
+Version: 2.1.1
 Summary: The Ultimate Static Python Intelligence, Healing, Type Verification, and Security Suite
 Author: Developer
 License-Expression: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: ruff>=0.1.0
-Requires-Dist: rich>=13.0.0
-Requires-Dist: tomli>=1.1.0; python_version < "3.11"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: black>=24.0.0; extra == "dev"

ballpython-2.1.1.dist-info/RECORD

@@ -0,0 +1,34 @@
+ballpython/__init__.py,sha256=GSB-LHdou1Un6DS6Zmh8tv_zrwh6HQHO3Py2z8GO39o,304
+ballpython/__main__.py,sha256=aCRr0vnZfKYHDrPHBsYSjX5xTxtFJpTTSPVUSZTBK-I,136
+ballpython/cli.py,sha256=LllCLRAQQ-fRR_lIXwmd2e3Q7DLCIvf-5jHBXsAhJWs,125
+ballpython/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pycleaner/__init__.py,sha256=aDgSTYYMyPj4l6QFHsUm9QvDA0z7g4FTJCiaE2Vsi7Y,3042
+pycleaner/__main__.py,sha256=8QBFrPyxId563F6cipPMNVEBTG8TIZUgxQfp8gk1VSI,135
+pycleaner/baseline.py,sha256=ljED3x3akie0SB3fzhVno_1UHlI2id-9vta0NIGC0mw,3857
+pycleaner/cache.py,sha256=T3JIxYg8ZezRbSpXYXPD-SyMUkjg4nfKsdO0IuNypOY,10774
+pycleaner/cli.py,sha256=p96G9t2EhPThJYOy9UkCxarigLkQE5b-kPTfujPCdPw,80824
+pycleaner/complexity_analyzer.py,sha256=jOLzOCA_rIHerqiN0w9VCdvO9CTqmncef4CUG4uL6kg,15214
+pycleaner/config.py,sha256=XhloyaY_9pdwbQuc3QaAPCerLeXz-i1da4xT50h-pjY,8514
+pycleaner/dead_code_detector.py,sha256=4xu6h0lnsZSiUFykuj7DXUvf9aYpy0y1G_JFUwU0GZg,55452
+pycleaner/dependency_auditor.py,sha256=PTIJhVyVxSDM-YjU1EAMhSx823vYz-7lYs8yPh5l6Tg,24135
+pycleaner/discovery.py,sha256=2P9WU7c_GXROXLDXhh1QrLv8YINWmVQ39VOOMbvrP2g,6717
+pycleaner/explanations.py,sha256=2OOU_l3YL5o_Br_6fP6MF8HlY75-1JRmw3eTYT2lu8M,14219
+pycleaner/import_resolver.py,sha256=Wgrch335AQVsnDv5-7F0l4Zm2oQPkNebPEgTRa7ayAg,32855
+pycleaner/linter_formatter.py,sha256=wdTjwguPWzkJ9KRMcQpFHEirb3ogc9qay69yiphz16Y,21356
+pycleaner/modernizer.py,sha256=kd9_G5EzdW_O-9zm1hA6v33Sb__UbpMZzSvopF-UK5w,16820
+pycleaner/pipeline.py,sha256=EZtlfD8vQOaIm57EWY5h9UHGqiYKcS6B_9Fk9XV6IUY,24751
+pycleaner/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pycleaner/security_scanner.py,sha256=PAOwOfkVxMAYNVBjegmKbeWVJ1J6O8u7TO2JR99JQO4,28523
+pycleaner/syntax_healer.py,sha256=9ycIfUxtX6IunlHpMh-_xW7so-FBwSmsIUTdRGin1sc,34905
+pycleaner/taint_engine.py,sha256=Xp2vKjougug_55jEGrQ16nsG7nfeZdGLB7k07qeiWpk,27075
+pycleaner/test_generator.py,sha256=MM3t0Dx5lyJB5s144IKXq2tXrE8ohKcSvicPR3c9MlU,19680
+pycleaner/type_checker.py,sha256=qNlGccIZzWuBq_iOt3C9AwZe96-KrXwuPDPZ-iIN3nY,41720
+pycleaner/typeshed_resolver.py,sha256=N-kWU_CI5DG59lQMkt7wMW9sHYjNCBdfFS42b4y2Kr4,12742
+pycleaner/verifier.py,sha256=OySQpcBGnHwYfRZHQnKU7qsGao8lCwJ_Uc16Rn0mYS0,19453
+pycleaner/frameworks/__init__.py,sha256=SOuSRl39af86eoQx7Qm8rTJGD4jsnEvgyhhQ6cVmRVA,3462
+pycleaner/frameworks/plugins.py,sha256=qunMzS3q7xp1GEGxqkuhrnm-raiSRhYQMzmDxsEhSUg,11452
+ballpython-2.1.1.dist-info/METADATA,sha256=eAMzWv_heKS0P60R-uABCbTAJeSXFUuTZ2WuglqK7HY,3385
+ballpython-2.1.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ballpython-2.1.1.dist-info/entry_points.txt,sha256=6ux-5UxoVSmlK5p9M-GDVt24sCdwTQq9wgRDkpMIYU8,81
+ballpython-2.1.1.dist-info/top_level.txt,sha256=u6lmy8RWZ_saxCZAQTL7EijB4sunegOiVyk5fHjpwLk,21
+ballpython-2.1.1.dist-info/RECORD,,

pycleaner/__init__.py

@@ -18,7 +18,7 @@ from pycleaner.discovery import (
     is_protected_file,
 )
 
-__version__ = "2.0.5"
+__version__ = "2.1.1"
 __all__ = [
     "DEFAULT_IGNORED_DIRS",
     "PROTECTED_FILE_PATTERNS",

pycleaner/cache.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 import ast
 import hashlib
 import json
+import logging
 import sqlite3
 import time
 from pathlib import Path
@@ -22,6 +23,7 @@ from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from pycleaner.pipeline import CleanResult
+
 from pycleaner.verifier import VerificationTier
 
 
@@ -46,7 +48,7 @@ def extract_file_dependencies(source: str) -> list[str]:
             elif isinstance(node, ast.ImportFrom) and node.module:
                 deps.append(node.module.split(".")[0])
     except SyntaxError:
-        pass  # Best-effort dependency extraction; syntax errors handled downstream
+        logging.getLogger(__name__).debug("Suppressed exception", exc_info=True)
     return sorted(set(deps))
 
 

pycleaner/cli.py

@@ -157,6 +157,11 @@ def _register_fix_subparsers(subparsers: Any) -> None:
 def _register_analysis_subparsers(subparsers: Any) -> None:
     audit_p = subparsers.add_parser("audit", help="Audit project dependencies")
     _add_common_args(audit_p)
+    audit_p.add_argument(
+        "--fix",
+        action="store_true",
+        help="Auto-fix requirements.txt and pyproject.toml and prune unused packages",
+    )
     audit_p.add_argument(
         "--fix-deps", action="store_true", help="Auto-fix requirements.txt"
     )
@@ -550,7 +555,12 @@ def _create_printer(console: Any) -> Any:
         else:
             import re
 
-            cleaned = re.sub(r"\[/?[a-z ]*\]", "", msg)
+            cleaned = re.sub(
+                r"(?<!\\)\[/?(?:bold|dim|italic|underline|blink|reverse|strike|black|red|green|yellow|blue|magenta|cyan|white)(?: [a-z]+)*\]",
+                "",
+                msg,
+            )
+            cleaned = cleaned.replace("\\[", "[").replace("\\]", "]")
             print(cleaned)
 
     return print_msg
@@ -679,8 +689,13 @@ def main(argv: Sequence[str] | None = None) -> int:
 @dataclass
 class _FixBatchState:
     changed_count: int = 0
+    would_change_count: int = 0
+    actually_written_count: int = 0
+    partially_updated_count: int = 0
+    partially_would_change_count: int = 0
     error_count: int = 0
     diagnostics: list[dict[str, str]] = field(default_factory=list)
+    security_findings: list[Any] = field(default_factory=list)
     proven_count: int = 0
     suggested_count: int = 0
     refused_count: int = 0
@@ -724,6 +739,12 @@ def _report_file_modifications(
         print_msg("  - Lint: fixed errors and pruned unused imports", style="blue")
     if result.format_changed:
         print_msg("  - Format: applied PEP 8 formatting", style="blue")
+    for sf in getattr(result, "security_findings", []):
+        if getattr(sf, "severity", None) in ("CRITICAL", "HIGH"):
+            print_msg(
+                f"  - Unresolved Security [{sf.severity}]: {sf.message} (line {sf.lineno})",
+                style="bold red",
+            )
 
 
 def _accumulate_result(
@@ -736,6 +757,8 @@ def _accumulate_result(
     print_msg, console, is_json = io_ctx
     if result.diagnostics:
         state.diagnostics.extend(result.diagnostics)
+    if getattr(result, "security_findings", None):
+        state.security_findings.extend(result.security_findings)
 
     if result.proof_receipts:
         state.proof_receipts.extend(result.proof_receipts)
@@ -761,12 +784,63 @@ def _accumulate_result(
 
     if result.error:
         state.error_count += 1
+        is_partial = (result.changed or bool(result.syntax_repairs)) and (
+            result.verification_tier != VerificationTier.TIER_C_REFUSED
+        )
+        if is_partial:
+            state.changed_count += 1
+            if opts.apply_changes:
+                state.partially_updated_count += 1
+            else:
+                state.partially_would_change_count += 1
+
+            if not is_json and not opts.in_progress:
+                action = (
+                    "Partially cleaned"
+                    if opts.apply_changes
+                    else "Would partially modify"
+                )
+                print_msg(f"[yellow]{action}:[/yellow] {py_file.name}")
+                for repair in result.syntax_repairs:
+                    print_msg(f"  - Syntax: {repair}", style="cyan")
+                for mod in result.modernize_transforms:
+                    print_msg(f"  - Modernize: {mod}", style="green")
+                for dc in result.dead_code_pruned:
+                    print_msg(f"  - Dead-code: {dc}", style="yellow")
+                for imp in result.resolved_imports:
+                    print_msg(f"  - Import: {imp}", style="magenta")
+                if result.lint_changed:
+                    print_msg(
+                        "  - Lint: fixed errors and pruned unused imports", style="blue"
+                    )
+                if result.format_changed:
+                    print_msg("  - Format: applied PEP 8 formatting", style="blue")
+                for sf in getattr(result, "security_findings", []):
+                    if getattr(sf, "severity", None) in ("CRITICAL", "HIGH"):
+                        print_msg(
+                            f"  - Unresolved Security [{sf.severity}]: {sf.message} (line {sf.lineno})",
+                            style="bold red",
+                        )
+                if opts.show_diff and result.diff:
+                    _render_fix_diff(result.diff, console)
+        else:
+            if not is_json and not opts.in_progress:
+                for sf in getattr(result, "security_findings", []):
+                    if getattr(sf, "severity", None) in ("CRITICAL", "HIGH"):
+                        print_msg(
+                            f"  - Unresolved Security [{sf.severity}]: {sf.message} (line {sf.lineno})",
+                            style="bold red",
+                        )
+
         if not is_json:
             print_msg(f"[red]ERROR in {py_file.name}:[/red] {result.error}")
         return
 
     if result.changed:
         state.changed_count += 1
+        state.would_change_count += 1
+        if opts.apply_changes and not result.error:
+            state.actually_written_count += 1
         if not is_json and not opts.in_progress:
             _report_file_modifications(result, py_file, opts.apply_changes, print_msg)
             if opts.show_diff and result.diff:
@@ -897,15 +971,13 @@ def _render_audit_terminal_output(
             f"  [red]Missing:[/red] {', '.join(sorted(audit_report.missing_packages))}"
         )
         if not should_fix:
-            print_msg(
-                "  [dim]Tip: Run with -a/--all or --fix-deps to append them[/dim]"
-            )
+            print_msg("  [dim]Tip: Run with -a/--all or --fix to append them[/dim]")
     if audit_report.unused_packages:
         print_msg(
             f"  [yellow]Unused:[/yellow] {', '.join(sorted(audit_report.unused_packages))}"
         )
     if audit_report.fixed_requirements:
-        print_msg("  [green]requirements.txt synchronized.[/green]")
+        print_msg("  [green]Project dependencies synchronized on disk.[/green]")
 
 
 def _run_fix_audit(
@@ -918,8 +990,18 @@ def _run_fix_audit(
 ) -> DependencyAuditReport:
     exclude_patterns = config.exclude if config else ()
     auditor = DependencyAuditor(root_dir, exclude_patterns=exclude_patterns)
-    fix_any = getattr(args, "fix_deps", False) or getattr(args, "fix_all", False)
-    prune_any = getattr(args, "prune_deps", False) or getattr(args, "fix_all", False)
+    fix_any = (
+        getattr(args, "fix_deps", False)
+        or getattr(args, "fix_all", False)
+        or getattr(args, "fix", False)
+        or apply_changes
+    )
+    prune_any = (
+        getattr(args, "prune_deps", False)
+        or getattr(args, "fix_all", False)
+        or getattr(args, "fix", False)
+        or apply_changes
+    )
     should_fix = apply_changes and fix_any
     should_prune = apply_changes and prune_any
     audit_report = auditor.audit(
@@ -939,8 +1021,14 @@ def _compute_fix_exit_code(
         return 1
     if is_prove_cmd:
         return 0 if state.error_count == 0 else 1
+    has_unresolved_security = any(
+        getattr(sf, "severity", None) in ("CRITICAL", "HIGH")
+        for sf in state.security_findings
+    )
+    if has_unresolved_security:
+        return 1
     if not apply_changes and (
-        state.changed_count > 0
+        state.would_change_count > 0
         or state.error_count > 0
         or bool(audit_report.missing_packages)
     ):
@@ -999,7 +1087,11 @@ def _cmd_fix(
 
     if is_json:
         print(json.dumps(state.diagnostics, indent=2))
-        return 0 if state.error_count == 0 else 1
+        has_sec_issues = any(
+            getattr(sf, "severity", None) in ("CRITICAL", "HIGH")
+            for sf in state.security_findings
+        )
+        return 1 if (state.error_count > 0 or has_sec_issues) else 0
 
     audit_report = _run_fix_audit(
         root_dir,
@@ -1009,9 +1101,69 @@ def _cmd_fix(
         config=config,
         target_files=py_files,
     )
-    print_msg(
-        f"\n[bold]Summary: {len(py_files)} inspected, {state.changed_count} updated, {state.error_count} errors.[/bold]"
-    )
+    if opts.apply_changes and (
+        audit_report.fixed_requirements
+        or getattr(audit_report, "fixed_pyproject", False)
+    ):
+        state.changed_count += 1
+        state.would_change_count += 1
+        state.actually_written_count += 1
+
+    if not opts.apply_changes:
+        if state.partially_would_change_count > 0:
+            err_label = (
+                "1 remaining error"
+                if state.error_count == 1
+                else f"{state.error_count} remaining errors"
+            )
+            if state.would_change_count > 0:
+                print_msg(
+                    f"\n[bold]Summary: {len(py_files)} inspected, {state.would_change_count} would change, {state.partially_would_change_count} would partially change, 0 written, {err_label}.[/bold]"
+                )
+            else:
+                print_msg(
+                    f"\n[bold]Summary: {len(py_files)} inspected, {state.partially_would_change_count} would partially change, 0 written, {err_label}.[/bold]"
+                )
+        else:
+            print_msg(
+                f"\n[bold]Summary: {len(py_files)} inspected, {state.would_change_count} would change, 0 written, {state.error_count} errors.[/bold]"
+            )
+    else:
+        if state.partially_updated_count > 0:
+            err_label = (
+                "1 remaining error"
+                if state.error_count == 1
+                else f"{state.error_count} remaining errors"
+            )
+            if state.actually_written_count > 0:
+                print_msg(
+                    f"\n[bold]Summary: {len(py_files)} inspected, {state.actually_written_count} updated, {state.partially_updated_count} partially updated, {err_label}.[/bold]"
+                )
+            else:
+                print_msg(
+                    f"\n[bold]Summary: {len(py_files)} inspected, {state.partially_updated_count} partially updated, {err_label}.[/bold]"
+                )
+        else:
+            print_msg(
+                f"\n[bold]Summary: {len(py_files)} inspected, {state.actually_written_count} updated, {state.error_count} errors.[/bold]"
+            )
+
+    critical_or_high_findings = [
+        sf
+        for sf in state.security_findings
+        if getattr(sf, "severity", None) in ("CRITICAL", "HIGH")
+    ]
+    if critical_or_high_findings and not is_json:
+        print_msg(
+            f"\n[bold red]Unresolved Security Findings ({len(critical_or_high_findings)} issue(s)):[/bold red]"
+        )
+        for sf in critical_or_high_findings:
+            f_path = getattr(sf, "filepath", getattr(sf, "file", "<unknown>"))
+            print_msg(
+                f"  [bold red]- [{sf.severity}] {f_path}:{sf.lineno}: {sf.message}[/bold red]"
+            )
+            if getattr(sf, "suggestion", None):
+                print_msg(f"    [dim]Suggestion: {sf.suggestion}[/dim]")
 
     if pipeline.verify_proofs:
         total_proven_callables = sum(
@@ -1168,7 +1320,7 @@ def _cmd_baseline(
     fingerprints: list[BaselineFingerprint] = []
 
     detector = DeadCodeDetector()
-    dead_code_report = detector.scan_project(root_dir)
+    dead_code_report = detector.scan_files(py_files)
     for item in dead_code_report.items:
         if item.kind == "unused-import":
             rule = "DC002"
@@ -1187,7 +1339,7 @@ def _cmd_baseline(
         )
 
     scanner = SecurityScanner()
-    sec_report = scanner.scan_project(root_dir)
+    sec_report = scanner.scan_files(py_files)
     for finding in sec_report.findings:
         fingerprints.append(
             BaselineManager.create_fingerprint(
@@ -1200,7 +1352,7 @@ def _cmd_baseline(
         )
 
     analyzer = ComplexityAnalyzer()
-    comp_report = analyzer.analyze_project(root_dir)
+    comp_report = analyzer.analyze_files(py_files)
     thresholds = (
         getattr(args, "max_cyclomatic", config.max_cyclomatic_complexity),
         getattr(args, "max_cognitive", config.max_cognitive_complexity),
@@ -1354,9 +1506,10 @@ def _cmd_cache(
     console: Any,
 ) -> int:
     """Manage and inspect the content-addressable verification and AST cache."""
-    db_path = getattr(args, "db", None) or getattr(
+    raw_db_path = getattr(args, "db", None) or getattr(
         config, "cache_db_path", ".pycleaner/cache.db"
     )
+    db_path: str = str(raw_db_path) if raw_db_path else ".pycleaner/cache.db"
     cache = ContentAddressableCache(db_path=db_path)
 
     if getattr(args, "clear", False):
@@ -1412,8 +1565,10 @@ def _render_audit_cli_output(
         )
     if not audit_report.missing_packages and not audit_report.unused_packages:
         print_msg("  [green]All dependencies clean.[/green]")
-    if audit_report.fixed_requirements:
-        print_msg("  [green]requirements.txt synchronized.[/green]")
+    if audit_report.fixed_requirements or getattr(
+        audit_report, "fixed_pyproject", False
+    ):
+        print_msg("  [green]Project dependencies synchronized on disk.[/green]")
 
     return (
         1
@@ -1424,13 +1579,27 @@ def _render_audit_cli_output(
 
 def _cmd_audit(args: argparse.Namespace, config: PyCleanerConfig, print_msg) -> int:
     """Dependency audit command."""
-    root_dir = find_project_root(args.paths[0] if args.paths else None)
+    targets = getattr(args, "paths", ["."])
+    target_path = Path(targets[0]).resolve() if targets else Path.cwd()
+    root_dir = find_project_root(target_path)
+    explicit_files = (
+        [
+            Path(p).resolve()
+            for p in targets
+            if Path(p).is_file() and Path(p).suffix == ".py"
+        ]
+        if targets
+        else None
+    )
 
     is_check = getattr(args, "check", False)
+    fix_flag = getattr(args, "fix", False) or getattr(args, "fix_deps", False)
+    prune_flag = getattr(args, "fix", False) or getattr(args, "prune_deps", False)
     auditor = DependencyAuditor(root_dir, exclude_patterns=config.exclude)
     audit_report = auditor.audit(
-        fix=getattr(args, "fix_deps", False) and not is_check,
-        prune_unused=getattr(args, "prune_deps", False) and not is_check,
+        fix=fix_flag and not is_check,
+        prune_unused=prune_flag and not is_check,
+        target_files=explicit_files or None,
     )
 
     if getattr(args, "json", False):
@@ -1452,7 +1621,7 @@ def _render_scan_json(report: Any) -> int:
         for f in report.findings
     ]
     print(json.dumps(findings, indent=2))
-    return 1 if report.critical_count > 0 else 0
+    return 1 if (report.critical_count > 0 or report.high_count > 0) else 0
 
 
 def _render_scan_table(report: Any, console: Any, target_base: str) -> None:
@@ -1503,23 +1672,24 @@ def _render_scan_cli_summary(
         f"\n  Total: {report.count} finding(s) - "
         f"[red]{report.critical_count} critical[/red], [red]{report.high_count} high[/red]"
     )
-    return 1 if report.critical_count > 0 else 0
+    return 1 if (report.critical_count > 0 or report.high_count > 0) else 0
 
 
 def _cmd_scan(
     args: argparse.Namespace, config: PyCleanerConfig, print_msg, console
 ) -> int:
     """Security scan command."""
-    root_dir = Path(args.paths[0]).resolve() if args.paths else Path.cwd()
-    if not root_dir.is_dir():
-        root_dir = root_dir.parent
+    targets = getattr(args, "paths", ["."])
+    target_path = Path(targets[0]).resolve() if targets else Path.cwd()
+    root_dir = find_project_root(target_path)
+    py_files = discover_python_files(args.paths, config=config, root=root_dir)
 
     severity = getattr(args, "severity", config.security_severity_threshold)
     scanner = SecurityScanner(
         severity_threshold=severity,
         ignore_rules=set(config.ignore_security_rules),
     )
-    report = scanner.scan_project(root_dir, exclude_patterns=config.exclude)
+    report = scanner.scan_files(py_files)
 
     target_base = args.paths[0] if args.paths else "."
     if getattr(args, "json", False):
@@ -1613,12 +1783,13 @@ def _cmd_complexity(
     args: argparse.Namespace, config: PyCleanerConfig, print_msg, console
 ) -> int:
     """Complexity analysis command."""
-    root_dir = Path(args.paths[0]).resolve() if args.paths else Path.cwd()
-    if not root_dir.is_dir():
-        root_dir = root_dir.parent
+    targets = getattr(args, "paths", ["."])
+    target_path = Path(targets[0]).resolve() if targets else Path.cwd()
+    root_dir = find_project_root(target_path)
+    py_files = discover_python_files(args.paths, config=config, root=root_dir)
 
     analyzer = ComplexityAnalyzer()
-    report = analyzer.analyze_project(root_dir, exclude_patterns=config.exclude)
+    report = analyzer.analyze_files(py_files)
 
     thresholds = (
         getattr(args, "max_cyclomatic", config.max_cyclomatic_complexity),
@@ -1688,17 +1859,20 @@ def _cmd_dead_code(
     args: argparse.Namespace, config: PyCleanerConfig, print_msg, console
 ) -> int:
     """Dead code detection command."""
-    root_dir = Path(args.paths[0]).resolve() if args.paths else Path.cwd()
-    if not root_dir.is_dir():
-        root_dir = root_dir.parent
+    targets = getattr(args, "paths", ["."])
+    target_path = Path(targets[0]).resolve() if targets else Path.cwd()
+    root_dir = find_project_root(target_path)
+    py_files = discover_python_files(args.paths, config=config, root=root_dir)
 
     detector = DeadCodeDetector(
         ignore_decorators=set(config.ignore_decorators),
         ignore_names=set(config.ignore_names),
     )
     if getattr(args, "fix", False):
-        print_msg(f"[bold green]Pruning dead code across {root_dir}...[/bold green]")
-        fix_results = detector.fix_project(root_dir, exclude_patterns=config.exclude)
+        print_msg(
+            f"[bold green]Pruning dead code across {len(py_files)} file(s)...[/bold green]"
+        )
+        fix_results = detector.fix_files(py_files)
         total_pruned = sum(len(res.pruned_items) for res in fix_results.values())
         print_msg(
             f"[green]Successfully fixed {len(fix_results)} file(s), pruned {total_pruned} dead code item(s).[/green]"
@@ -1711,7 +1885,7 @@ def _cmd_dead_code(
             print_msg(f"  [cyan]{rel_p}[/cyan]: {len(res.pruned_items)} pruned")
         return 0
 
-    report = detector.scan_project(root_dir, exclude_patterns=config.exclude)
+    report = detector.scan_files(py_files)
 
     if getattr(args, "json", False):
         return _render_dead_code_json(report.items)
@@ -1791,12 +1965,13 @@ def _cmd_types(
     args: argparse.Namespace, config: PyCleanerConfig, print_msg, console
 ) -> int:
     """Bidirectional type checking and inference with Typeshed stubs."""
-    root_dir = Path(args.paths[0]).resolve() if args.paths else Path.cwd()
-    if not root_dir.is_dir():
-        root_dir = root_dir.parent
+    targets = getattr(args, "paths", ["."])
+    target_path = Path(targets[0]).resolve() if targets else Path.cwd()
+    root_dir = find_project_root(target_path)
+    py_files = discover_python_files(args.paths, config=config, root=root_dir)
 
     checker = TypeChecker(strict=config.strict_types)
-    report = checker.check_project(root_dir, exclude_patterns=config.exclude)
+    report = checker.check_files(py_files)
 
     target_base = args.paths[0] if args.paths else "."
     if getattr(args, "json", False):
@@ -1885,12 +2060,13 @@ def _cmd_taint(
     args: argparse.Namespace, config: PyCleanerConfig, print_msg, console
 ) -> int:
     """Interprocedural SAST dataflow and taint vulnerability analysis."""
-    root_dir = Path(args.paths[0]).resolve() if args.paths else Path.cwd()
-    if not root_dir.is_dir():
-        root_dir = root_dir.parent
+    targets = getattr(args, "paths", ["."])
+    target_path = Path(targets[0]).resolve() if targets else Path.cwd()
+    root_dir = find_project_root(target_path)
+    py_files = discover_python_files(args.paths, config=config, root=root_dir)
 
     engine = TaintEngine()
-    report = engine.scan_path(root_dir, exclude_patterns=config.exclude)
+    report = engine.scan_files(py_files)
 
     target_base = args.paths[0] if args.paths else "."
     if getattr(args, "json", False):
@@ -1964,6 +2140,8 @@ def _run_ultimate_phases(
     print_msg(
         "\n[bold blue]Phase 2: Project Dependency Audit & Reconciliation[/bold blue]"
     )
+    args.fix = True
+    args.prune_deps = True
     audit_rc = _cmd_audit(args, config, print_msg)
     print_msg(
         "\n[bold blue]Phase 3: Bidirectional Type Verification & Typeshed Resolution[/bold blue]"
@@ -1981,7 +2159,7 @@ def _run_ultimate_phases(
 def _cmd_ultimate(
     args: argparse.Namespace, config: PyCleanerConfig, print_msg: Any, console: Any
 ) -> int:
-    """The Ultimate Python Tool flagship runner: executes full multi-layer analysis."""
+    """The Ultimate Python Tool flagship runner: executes full multi-layer analysis and automated healing."""
     print_msg(
         "[bold magenta]=== PyCleaner Ultimate: Full Spectrum Analysis & Healing ===[/bold magenta]\n"
     )
@@ -1989,14 +2167,15 @@ def _cmd_ultimate(
         args, config, print_msg, console
     )
     print_msg(
-        "\n[bold blue]Phase 6: Structural Complexity & Dead Code Discovery[/bold blue]"
+        "\n[bold blue]Phase 6: Structural Complexity & Dead Code Discovery & Healing[/bold blue]"
     )
     _cmd_complexity(args, config, print_msg, console)
-    _cmd_dead_code(args, config, print_msg, console)
+    args.fix = True
+    dead_rc = _cmd_dead_code(args, config, print_msg, console)
     print_msg(
         "\n[bold magenta]=== Ultimate Python Tool: Analysis Complete ===[/bold magenta]"
     )
-    return max(fix_rc, audit_rc, type_rc, taint_rc, scan_rc)
+    return max(fix_rc, audit_rc, type_rc, taint_rc, scan_rc, dead_rc)
 
 
 def _collect_file_mtimes(files: Sequence[Path]) -> dict[Path, float]:

pycleaner/complexity_analyzer.py

@@ -354,17 +354,12 @@ class ComplexityAnalyzer:
         except OSError:
             return None
 
-    def analyze_project(
-        self, root_dir: Path | str, exclude_patterns: Sequence[str] = ()
-    ) -> ComplexityReport:
-        """Analyze complexity across all Python files in a project."""
-        root = Path(root_dir).resolve()
+    def analyze_files(self, target_files: Sequence[Path]) -> ComplexityReport:
+        """Analyze complexity across a specific sequence of Python files without walking directories."""
         all_functions: list[ComplexityMetrics] = []
         files_scanned = 0
 
-        for fpath in collect_project_python_files(
-            root, exclude_patterns=exclude_patterns
-        ):
+        for fpath in target_files:
             try:
                 content = fpath.read_text(encoding="utf-8", errors="replace")
                 metrics = self.analyze_source(content, filename=str(fpath)).functions
@@ -376,6 +371,14 @@ class ComplexityAnalyzer:
         all_functions.sort(key=lambda f: f.cyclomatic, reverse=True)
         return ComplexityReport(functions=all_functions, files_scanned=files_scanned)
 
+    def analyze_project(
+        self, root_dir: Path | str, exclude_patterns: Sequence[str] = ()
+    ) -> ComplexityReport:
+        """Analyze complexity across all Python files in a project."""
+        root = Path(root_dir).resolve()
+        py_files = collect_project_python_files(root, exclude_patterns=exclude_patterns)
+        return self.analyze_files(py_files)
+
     @staticmethod
     def _count_function_args(node: ast.FunctionDef | ast.AsyncFunctionDef) -> int:
         all_args = node.args.posonlyargs + node.args.args + node.args.kwonlyargs