qgis-plugin-analyzer 1.4.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

analyzer/cli.py

@@ -19,292 +19,15 @@
 #  ***************************************************************************/
 
 
-import argparse
-import pathlib
 import sys
 
-from .engine import ProjectAnalyzer
-from .utils import logger, setup_logger
-
-
-def _setup_argument_parser() -> argparse.ArgumentParser:
-    """Sets up and returns the argument parser with all subcommands.
-
-    Returns:
-        A configured ArgumentParser instance.
-    """
-    parser = argparse.ArgumentParser(
-        description="QGIS Plugin Analyzer - A guardian for your PyQGIS code"
-    )
-    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
-
-    # Analyze Command
-    analyze_parser = subparsers.add_parser("analyze", help="Analyze an existing QGIS plugin")
-    analyze_parser.add_argument("project_path", help="Path to the QGIS project to analyze")
-    analyze_parser.add_argument(
-        "-o",
-        "--output",
-        help="Output directory for reports",
-        default="./analysis_results",
-    )
-    analyze_parser.add_argument(
-        "-r",
-        "--report",
-        action="store_true",
-        help="Generate detailed HTML/Markdown reports",
-    )
-    analyze_parser.add_argument(
-        "-p",
-        "--profile",
-        help="Configuration profile from pyproject.toml",
-        default="default",
-    )
-
-    # Fix Command
-    fix_parser = subparsers.add_parser("fix", help="Auto-fix common QGIS plugin issues")
-    fix_parser.add_argument("path", type=str, help="Path to the QGIS plugin directory")
-    fix_parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        default=True,
-        help="Show proposed changes without applying (default: True)",
-    )
-    fix_parser.add_argument("--apply", action="store_true", help="Apply fixes (disables dry-run)")
-    fix_parser.add_argument(
-        "--auto-approve",
-        action="store_true",
-        help="Apply all fixes without confirmation",
-    )
-    fix_parser.add_argument(
-        "-p",
-        "--profile",
-        help="Configuration profile from pyproject.toml",
-        default="default",
-    )
-    fix_parser.add_argument(
-        "--rules",
-        type=str,
-        help="Comma-separated list of rule IDs to fix",
-    )
-
-    # List Rules Command
-    subparsers.add_parser("list-rules", help="List all available QGIS audit rules")
-
-    # Init Command
-    subparsers.add_parser("init", help="Initialize a new .analyzerignore with defaults")
-
-    # Summary Command
-    summary_parser = subparsers.add_parser(
-        "summary", help="Show a quick terminal summary of analysis results"
-    )
-    summary_parser.add_argument(
-        "-i",
-        "--input",
-        help="Path to the research JSON file",
-        default="analysis_results/project_context.json",
-    )
-    summary_parser.add_argument(
-        "-b",
-        "--by",
-        choices=["total", "modules", "functions", "classes"],
-        default="total",
-        help="Granularity of the summary (default: total)",
-    )
-
-    return parser
-
-
-def _handle_fix_command(args: argparse.Namespace) -> bool:
-    """Handles the execution of the 'fix' command.
-
-    Args:
-        args: Parsed command line arguments.
-
-    Returns:
-        True if the fix process completed successfully, False otherwise.
-    """
-    import json
-
-    from .fixer import AutoFixer
-
-    project_path = pathlib.Path(args.path).resolve()
-    if not project_path.exists():
-        print(f"❌ Path not found: {project_path}")
-        return False
-
-    # Run analysis first
-    print("🔍 Analyzing project for fixable issues...")
-    analyzer = ProjectAnalyzer(
-        str(project_path),
-        args.output if hasattr(args, "output") else "./analysis_results",
-        args.profile if hasattr(args, "profile") else "default",
-    )
-    analyzer.run()
-
-    # Load issues
-    context_file = analyzer.output_dir / "project_context.json"
-    with open(context_file) as f:
-        context = json.load(f)
-
-    all_issues = []
-    for module in context.get("modules", []):
-        all_issues.extend(module.get("ast_issues", []))
-
-    if args.rules:
-        rule_ids = [r.strip() for r in args.rules.split(",")]
-        all_issues = [i for i in all_issues if i.get("type") in rule_ids]
-
-    fixer = AutoFixer(project_path, dry_run=not args.apply)
-    fixable = fixer.get_fixable_issues(all_issues)
-
-    if not fixable:
-        print("✅ No fixable issues found!")
-        return True
-
-    print(f"\n📋 Found {len(fixable)} fixable issue(s)")
-    if not args.apply:
-        print("\n⚠️  DRY RUN MODE (use --apply to execute changes)\n")
-
-    stats = fixer.apply_fixes(fixable, interactive=not args.auto_approve)
-    print(
-        f"\n📊 Summary: Applied: {stats['applied']}, Skipped: {stats['skipped']}, Failed: {stats['failed']}"
-    )
-    return True
-
-
-def _handle_analyze_command(args: argparse.Namespace) -> None:
-    """Handles the execution of the 'analyze' command.
-
-    Args:
-        args: Parsed command line arguments.
-    """
-    # Force generate_html based on flag, overriding profile if necessary for CLI usage
-    # We pass it via a temporary config override or modify the analyzer init
-    # For now, let's pass it to the analyzer constructor or modify config after init
-
-    analyzer = ProjectAnalyzer(args.project_path, args.output, args.profile)
-
-    # Override config based on CLI flag
-    if hasattr(args, "report") and args.report:
-        analyzer.config["generate_html"] = True
-    else:
-        analyzer.config["generate_html"] = False
-
-    success = analyzer.run()
-
-    # Always show terminal summary
-    from .reporters.summary_reporter import report_summary
-
-    # If we didn't generate reports, we might still want to show the summary
-    # using the in-memory data or the context file if it was saved.
-    # Engine saves json context by default? Let's check engine.py.
-    # Assuming engine saves project_context.json always or we need to access results directly.
-    # To keep it simple, we depend on the engine saving the context or returning it.
-    # Current engine.run retuns bool.
-
-    context_path = analyzer.output_dir / "project_context.json"
-    if context_path.exists():
-        report_summary(context_path)
-
-    if not success:
-        sys.exit(1)
-
-
-def _handle_list_rules_command() -> None:
-    """Handles the 'list-rules' command by displaying available audit rules."""
-    from .rules import get_qgis_audit_rules
-
-    rules = get_qgis_audit_rules()
-    print("\n📋 QGIS Audit Rules Catalog:")
-    print("=" * 30)
-    for r in rules:
-        print(f"- [{r['severity'].upper()}] {r['id']}: {r['message']}")
-    print(f"\nTotal: {len(rules)} rules.\n")
-
-
-def _handle_init_command() -> None:
-    """Handles the 'init' command by creating a default .analyzerignore file."""
-    from .utils import DEFAULT_EXCLUDE
-
-    ignore_file = pathlib.Path(".analyzerignore")
-    if ignore_file.exists():
-        print("⚠️  .analyzerignore already exists. Skipping.")
-    else:
-        with open(ignore_file, "w") as f:
-            f.write("# QGIS Plugin Analyzer Ignore File\n")
-            for p in DEFAULT_EXCLUDE:
-                f.write(f"{p}\n")
-        print("✅ Created .analyzerignore with default excludes.")
-
-
-def _handle_summary_command(args: argparse.Namespace) -> None:
-    """Handles the 'summary' command by displaying a terminal report.
-
-    Args:
-        args: Parsed command line arguments.
-    """
-    from .reporters.summary_reporter import report_summary
-
-    input_path = pathlib.Path(args.input).resolve()
-    report_summary(input_path, by=args.by)
+from .cli import CLIApp
 
 
 def main() -> None:
-    """Main entry point for the QGIS Plugin Analyzer CLI.
-
-    Orchestrates the command execution based on parsed arguments and
-    sets up the global logging environment.
-    """
-    parser = _setup_argument_parser()
-
-    # Legacy support / default to analyze if no command provided
-    if len(sys.argv) > 1 and sys.argv[1] not in [
-        "analyze",
-        "fix",
-        "list-rules",
-        "init",
-        "summary",
-        "-h",
-        "--help",
-    ]:
-        # If the first argument is a path (doesn't start with -), assume 'analyze'
-        if not sys.argv[1].startswith("-"):
-            sys.argv.insert(1, "analyze")
-
-    args = parser.parse_args()
-
-    # Initialize logger (default to analysis_results if not specified)
-    output_dir = pathlib.Path(getattr(args, "output", "./analysis_results")).resolve()
-    output_dir.mkdir(parents=True, exist_ok=True)
-    setup_logger(output_dir)
-
-    try:
-        if args.command == "fix":
-            _handle_fix_command(args)
-        elif args.command == "analyze":
-            _handle_analyze_command(args)
-        elif args.command == "list-rules":
-            _handle_list_rules_command()
-        elif args.command == "init":
-            _handle_init_command()
-        elif args.command == "summary":
-            _handle_summary_command(args)
-        else:
-            parser.print_help()
-
-    except KeyboardInterrupt:
-        logger.info("\n⏹️ Analysis interrupted.")
-        sys.exit(1)
-    except FileNotFoundError as e:
-        logger.error(f"Error: File not found: {e}")
-        sys.exit(1)
-    except ValueError as e:
-        # This handles path traversal or other validation errors
-        logger.error(f"Error: {e}")
-        sys.exit(1)
-    except Exception as e:
-        logger.critical(f"Critical Error: {e}", exc_info=True)
-        sys.exit(1)
+    """Main entry point for the QGIS Plugin Analyzer CLI."""
+    app = CLIApp()
+    sys.exit(app.run())
 
 
 if __name__ == "__main__":

analyzer/commands.py

@@ -0,0 +1,163 @@
+"""Command handlers for the QGIS Plugin Analyzer CLI.
+
+This module contains the implementation of individual CLI commands to separate
+interface definition (cli.py) from execution logic.
+"""
+
+import argparse
+import dataclasses
+import json
+import pathlib
+import sys
+
+from .engine import ProjectAnalyzer
+from .fixer import AutoFixer
+from .reporters.summary_reporter import report_summary
+from .rules import get_qgis_audit_rules
+from .utils import DEFAULT_EXCLUDE
+
+
+def handle_fix(args: argparse.Namespace) -> bool:
+    """Handles the execution of the 'fix' command.
+
+    Args:
+        args: Parsed command line arguments.
+
+    Returns:
+        True if the fix process completed successfully, False otherwise.
+    """
+    project_path = pathlib.Path(args.path).resolve()
+    if not project_path.exists():
+        print(f"❌ Path not found: {project_path}")
+        return False
+
+    # Run analysis first
+    print("🔍 Analyzing project for fixable issues...")
+    analyzer = ProjectAnalyzer(
+        str(project_path),
+        args.output if hasattr(args, "output") else "./analysis_results",
+        args.profile if hasattr(args, "profile") else "default",
+    )
+    analyzer.run()
+
+    # Load issues
+    context_file = analyzer.output_dir / "project_context.json"
+    if not context_file.exists():
+        print("❌ Analysis failed to generate context file.")
+        return False
+
+    with open(context_file) as f:
+        context = json.load(f)
+
+    all_issues = []
+    for module in context.get("modules", []):
+        all_issues.extend(module.get("ast_issues", []))
+
+    if args.rules:
+        rule_ids = [r.strip() for r in args.rules.split(",")]
+        all_issues = [i for i in all_issues if i.get("type") in rule_ids]
+
+    fixer = AutoFixer(project_path, dry_run=not args.apply)
+    fixable = fixer.get_fixable_issues(all_issues)
+
+    if not fixable:
+        print("✅ No fixable issues found!")
+        return True
+
+    print(f"\n📋 Found {len(fixable)} fixable issue(s)")
+    if not args.apply:
+        print("\n⚠️  DRY RUN MODE (use --apply to execute changes)\n")
+
+    stats = fixer.apply_fixes(fixable, interactive=not args.auto_approve)
+    print(
+        f"\n📊 Summary: Applied: {stats['applied']}, Skipped: {stats['skipped']}, Failed: {stats['failed']}"
+    )
+    return True
+
+
+def handle_analyze(args: argparse.Namespace) -> None:
+    """Handles the execution of the 'analyze' command.
+
+    Args:
+        args: Parsed command line arguments.
+    """
+    analyzer = ProjectAnalyzer(args.project_path, args.output, args.profile)
+
+    # Override config based on CLI flag using dataclasses.replace since it's frozen
+    report_enabled = bool(hasattr(args, "report") and args.report)
+    analyzer.config = dataclasses.replace(analyzer.config, generate_html=report_enabled)
+
+    success = analyzer.run()
+
+    context_path = analyzer.output_dir / "project_context.json"
+    if context_path.exists():
+        report_summary(context_path)
+
+    if not success:
+        sys.exit(1)
+
+
+def handle_list_rules() -> None:
+    """Handles the 'list-rules' command by displaying available audit rules."""
+    rules = get_qgis_audit_rules()
+    print("\n📋 QGIS Audit Rules Catalog:")
+    print("=" * 30)
+    for r in rules:
+        print(f"- [{r['severity'].upper()}] {r['id']}: {r['message']}")
+    print(f"\nTotal: {len(rules)} rules.\n")
+
+
+def handle_init() -> None:
+    """Handles the 'init' command by creating a default .analyzerignore file."""
+    ignore_file = pathlib.Path(".analyzerignore")
+    if ignore_file.exists():
+        print("⚠️  .analyzerignore already exists. Skipping.")
+    else:
+        with open(ignore_file, "w") as f:
+            f.write("# QGIS Plugin Analyzer Ignore File\n")
+            for p in DEFAULT_EXCLUDE:
+                f.write(f"{p}\n")
+        print("✅ Created .analyzerignore with default excludes.")
+
+
+def handle_summary(args: argparse.Namespace) -> None:
+    """Handles the 'summary' command by displaying a terminal report.
+
+    Args:
+        args: Parsed command line arguments.
+    """
+    input_path = pathlib.Path(args.input).resolve()
+    report_summary(input_path, by=args.by)
+
+
+def handle_security(args: argparse.Namespace) -> None:
+    """Handles the execution of the 'security' command.
+
+    Args:
+        args: Parsed command line arguments.
+    """
+    project_path = pathlib.Path(args.project_path).resolve()
+    if not project_path.exists():
+        print(f"❌ Path not found: {project_path}")
+        sys.exit(1)
+
+    print(f"🛡️  Starting focused security scan for: {project_path.name}...")
+
+    # Run analyzer with current profile
+    analyzer = ProjectAnalyzer(str(project_path), args.output, args.profile)
+
+    # We could potentially add high-level flags here
+    if args.deep:
+        # Note: ProjectConfig currently doesn't have security_deep_scan,
+        # but if it did, we would use dataclasses.replace here too.
+        print("🔍 Deep scan enabled (Entropy analysis and full secret detection)")
+
+    success = analyzer.run()
+
+    context_path = analyzer.output_dir / "project_context.json"
+    if context_path.exists():
+        # Use the specialized security reporter
+        report_summary(context_path, by="security")
+
+    if not success:
+        sys.exit(1)