mcp-vector-search 1.0.3__py3-none-any.whl → 1.1.22__py3-none-any.whl

mcp_vector_search/cli/commands/analyze.py

@@ -12,7 +12,16 @@ from ...analysis import (
     FileMetrics,
     ProjectMetrics,
 )
+from ...analysis.baseline import (
+    BaselineComparator,
+    BaselineExistsError,
+    BaselineManager,
+    BaselineNotFoundError,
+)
+from ...analysis.storage.metrics_store import MetricsStore, MetricsStoreError
+from ...analysis.storage.trend_tracker import TrendData, TrendDirection, TrendTracker
 from ...core.exceptions import ProjectNotFoundError
+from ...core.git import GitError, GitManager, GitNotAvailableError, GitNotRepoError
 from ...core.project import ProjectManager
 from ...parsers.registry import ParserRegistry
 from ..output import console, print_error, print_info, print_json
@@ -41,6 +50,12 @@ def main(
         help="Quick mode (cognitive + cyclomatic complexity only)",
         rich_help_panel="⚡ Performance Options",
     ),
+    show_smells: bool = typer.Option(
+        True,
+        "--smells/--no-smells",
+        help="Show detected code smells in output",
+        rich_help_panel="📊 Display Options",
+    ),
     language: str | None = typer.Option(
         None,
         "--language",
@@ -67,6 +82,80 @@ def main(
         help="Output results in JSON format",
         rich_help_panel="📊 Display Options",
     ),
+    include_context: bool = typer.Option(
+        False,
+        "--include-context",
+        help="Include LLM-consumable context in JSON output (enhanced interpretation)",
+        rich_help_panel="📊 Display Options",
+    ),
+    format: str = typer.Option(
+        "console",
+        "--format",
+        "-f",
+        help="Output format: console, json, sarif, markdown",
+        rich_help_panel="📊 Display Options",
+    ),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file path (required for sarif format)",
+        rich_help_panel="📊 Display Options",
+    ),
+    fail_on_smell: bool = typer.Option(
+        False,
+        "--fail-on-smell",
+        help="Exit with code 1 if code smells are detected",
+        rich_help_panel="🚦 Quality Gates",
+    ),
+    severity_threshold: str = typer.Option(
+        "error",
+        "--severity-threshold",
+        help="Minimum severity to trigger failure: info, warning, error, none",
+        rich_help_panel="🚦 Quality Gates",
+    ),
+    changed_only: bool = typer.Option(
+        False,
+        "--changed-only/--no-changed-only",
+        help="Analyze only uncommitted changes (staged + unstaged + untracked)",
+        rich_help_panel="🔍 Filters",
+    ),
+    baseline: str | None = typer.Option(
+        None,
+        "--baseline",
+        help="Compare against baseline branch (e.g., main, master, develop)",
+        rich_help_panel="🔍 Filters",
+    ),
+    save_baseline: str | None = typer.Option(
+        None,
+        "--save-baseline",
+        help="Save current analysis as named baseline",
+        rich_help_panel="📊 Baseline Management",
+    ),
+    compare_baseline: str | None = typer.Option(
+        None,
+        "--compare-baseline",
+        help="Compare current analysis against named baseline",
+        rich_help_panel="📊 Baseline Management",
+    ),
+    list_baselines: bool = typer.Option(
+        False,
+        "--list-baselines",
+        help="List all available baselines (standalone action)",
+        rich_help_panel="📊 Baseline Management",
+    ),
+    delete_baseline: str | None = typer.Option(
+        None,
+        "--delete-baseline",
+        help="Delete a named baseline",
+        rich_help_panel="📊 Baseline Management",
+    ),
+    force_baseline: bool = typer.Option(
+        False,
+        "--force",
+        help="Force overwrite when saving baseline that already exists",
+        rich_help_panel="📊 Baseline Management",
+    ),
 ) -> None:
     """📈 Analyze code complexity and quality.
 
@@ -87,6 +176,12 @@ def main(
     [green]Analyze specific directory:[/green]
         $ mcp-vector-search analyze --path src/core
 
+    [green]Analyze only uncommitted changes:[/green]
+        $ mcp-vector-search analyze --changed-only
+
+    [green]Compare against baseline branch:[/green]
+        $ mcp-vector-search analyze --baseline main
+
     [bold cyan]Output Options:[/bold cyan]
 
     [green]Show top 5 hotspots:[/green]
@@ -95,13 +190,97 @@ def main(
     [green]Export to JSON:[/green]
         $ mcp-vector-search analyze --json > analysis.json
 
+    [green]Export to SARIF format:[/green]
+        $ mcp-vector-search analyze --format sarif --output report.sarif
+
+    [green]Export to Markdown format:[/green]
+        $ mcp-vector-search analyze --format markdown --output .
+
+    [bold cyan]CI/CD Quality Gates:[/bold cyan]
+
+    [green]Fail on ERROR-level smells (default):[/green]
+        $ mcp-vector-search analyze --fail-on-smell
+
+    [green]Fail on WARNING or ERROR smells:[/green]
+        $ mcp-vector-search analyze --fail-on-smell --severity-threshold warning
+
+    [green]CI/CD workflow with SARIF:[/green]
+        $ mcp-vector-search analyze --fail-on-smell --format sarif --output report.sarif
+
     [dim]💡 Tip: Use --quick for faster analysis on large projects.[/dim]
     """
     if ctx.invoked_subcommand is not None:
         # A subcommand was invoked - let it handle the request
         return
 
+    # Handle standalone baseline operations first
+    baseline_manager = BaselineManager()
+
+    # List baselines (standalone action)
+    if list_baselines:
+        baselines = baseline_manager.list_baselines()
+        if not baselines:
+            console.print("[yellow]No baselines found[/yellow]")
+            console.print(
+                f"\nBaselines are stored in: {baseline_manager.storage_dir}\n"
+            )
+            console.print(
+                "Create a baseline with: [cyan]mcp-vector-search analyze --save-baseline <name>[/cyan]"
+            )
+        else:
+            console.print(f"\n[bold]Available Baselines[/bold] ({len(baselines)})")
+            console.print("━" * 80)
+            for baseline in baselines:
+                console.print(f"\n[cyan]• {baseline.baseline_name}[/cyan]")
+                console.print(f"  Created: {baseline.created_at}")
+                console.print(f"  Project: {baseline.project_path}")
+                console.print(
+                    f"  Files: {baseline.file_count} | Functions: {baseline.function_count}"
+                )
+                console.print(f"  Tool Version: {baseline.tool_version}")
+                if baseline.git_info.commit:
+                    console.print(
+                        f"  Git: {baseline.git_info.branch or 'detached'} @ {baseline.git_info.commit[:8]}"
+                    )
+            console.print()
+        raise typer.Exit(0)
+
+    # Delete baseline (standalone action)
+    if delete_baseline:
+        try:
+            baseline_manager.delete_baseline(delete_baseline)
+            console.print(
+                f"[green]✓[/green] Deleted baseline: [cyan]{delete_baseline}[/cyan]"
+            )
+            raise typer.Exit(0)
+        except BaselineNotFoundError as e:
+            print_error(str(e))
+            console.print("\nAvailable baselines:")
+            baselines = baseline_manager.list_baselines()
+            for baseline in baselines[:5]:
+                console.print(f"  • {baseline.baseline_name}")
+            raise typer.Exit(1)
+
     try:
+        # Validate format and output options
+        valid_formats = ["console", "json", "sarif", "markdown"]
+        format_lower = format.lower()
+
+        if format_lower not in valid_formats:
+            print_error(
+                f"Invalid format: {format}. Must be one of: {', '.join(valid_formats)}"
+            )
+            raise typer.Exit(1)
+
+        # SARIF and markdown formats should have output path (defaults to current dir)
+        if format_lower == "sarif" and output is None:
+            print_error("--output is required when using --format sarif")
+            raise typer.Exit(1)
+
+        # JSON flag overrides format for backward compatibility
+        if json_output:
+            format_lower = "json"
+
         # Use provided project_root or current working directory
         if project_root is None:
             project_root = Path.cwd()
@@ -113,14 +292,54 @@ def main(
                 language_filter=language,
                 path_filter=path,
                 top_n=top,
-                json_output=json_output,
+                json_output=(format_lower == "json"),
+                show_smells=show_smells,
+                output_format=format_lower,
+                output_file=output,
+                fail_on_smell=fail_on_smell,
+                severity_threshold=severity_threshold,
+                changed_only=changed_only,
+                baseline=baseline,
+                save_baseline=save_baseline,
+                compare_baseline=compare_baseline,
+                force_baseline=force_baseline,
+                baseline_manager=baseline_manager,
+                include_context=include_context,
             )
         )
 
+    except typer.Exit:
+        # Re-raise typer.Exit to preserve exit codes from run_analysis
+        raise
     except Exception as e:
         logger.error(f"Analysis failed: {e}")
         print_error(f"Analysis failed: {e}")
-        raise typer.Exit(1)
+        raise typer.Exit(2)  # Exit code 2 for analysis errors
+
+
+def filter_smells_by_severity(smells: list, severity_threshold: str) -> list:
+    """Filter smells by minimum severity threshold.
+
+    Args:
+        smells: List of CodeSmell objects to filter
+        severity_threshold: Minimum severity level - "info", "warning", "error", or "none"
+
+    Returns:
+        Filtered list of smells matching or exceeding the severity threshold
+    """
+    from ...analysis.collectors.smells import SmellSeverity
+
+    if severity_threshold.lower() == "none":
+        return []
+
+    severity_levels = {
+        "info": [SmellSeverity.INFO, SmellSeverity.WARNING, SmellSeverity.ERROR],
+        "warning": [SmellSeverity.WARNING, SmellSeverity.ERROR],
+        "error": [SmellSeverity.ERROR],
+    }
+
+    allowed = severity_levels.get(severity_threshold.lower(), [SmellSeverity.ERROR])
+    return [s for s in smells if s.severity in allowed]
 
 
 async def run_analysis(
@@ -130,6 +349,18 @@ async def run_analysis(
     path_filter: Path | None = None,
     top_n: int = 10,
     json_output: bool = False,
+    show_smells: bool = True,
+    output_format: str = "console",
+    output_file: Path | None = None,
+    fail_on_smell: bool = False,
+    severity_threshold: str = "error",
+    changed_only: bool = False,
+    baseline: str | None = None,
+    save_baseline: str | None = None,
+    compare_baseline: str | None = None,
+    force_baseline: bool = False,
+    baseline_manager: BaselineManager | None = None,
+    include_context: bool = False,
 ) -> None:
     """Run code complexity analysis.
 
@@ -139,7 +370,18 @@ async def run_analysis(
         language_filter: Filter files by language
         path_filter: Analyze specific file or directory
         top_n: Number of top hotspots to show
-        json_output: Output results as JSON
+        json_output: Output results as JSON (deprecated, use output_format)
+        show_smells: Show detected code smells in output
+        output_format: Output format (console, json, sarif)
+        output_file: Output file path (for sarif format)
+        fail_on_smell: Exit with code 1 if smells are detected
+        severity_threshold: Minimum severity to trigger failure
+        changed_only: Analyze only uncommitted changes
+        baseline: Compare against baseline branch
+        save_baseline: Save analysis as named baseline
+        compare_baseline: Compare against named baseline
+        force_baseline: Force overwrite existing baseline
+        baseline_manager: BaselineManager instance
     """
     try:
         # Check if project is initialized (optional - we can analyze any directory)
@@ -178,9 +420,74 @@ async def run_analysis(
             ]
             mode_label = "Full Mode (5 collectors)"
 
+        # Initialize git manager if needed for changed/baseline filtering
+        git_manager = None
+        git_changed_files = None
+
+        if changed_only or baseline:
+            try:
+                git_manager = GitManager(project_root)
+
+                # Get changed files based on mode
+                if changed_only:
+                    git_changed_files = git_manager.get_changed_files(
+                        include_untracked=True
+                    )
+                    if not git_changed_files:
+                        if json_output:
+                            print_json(
+                                {"error": "No changed files found. Nothing to analyze."}
+                            )
+                        else:
+                            print_info("No changed files found. Nothing to analyze.")
+                        return
+                elif baseline:
+                    git_changed_files = git_manager.get_diff_files(baseline)
+                    if not git_changed_files:
+                        if json_output:
+                            print_json(
+                                {"error": f"No files changed vs baseline '{baseline}'."}
+                            )
+                        else:
+                            print_info(f"No files changed vs baseline '{baseline}'.")
+                        return
+
+            except GitNotAvailableError as e:
+                if json_output:
+                    print_json({"warning": str(e), "fallback": "full analysis"})
+                else:
+                    console.print(f"[yellow]⚠️  {e}[/yellow]")
+                    print_info("Proceeding with full codebase analysis...")
+                git_manager = None
+                git_changed_files = None
+
+            except GitNotRepoError as e:
+                if json_output:
+                    print_json({"warning": str(e), "fallback": "full analysis"})
+                else:
+                    console.print(f"[yellow]⚠️  {e}[/yellow]")
+                    print_info("Proceeding with full codebase analysis...")
+                git_manager = None
+                git_changed_files = None
+
+            except GitError as e:
+                if json_output:
+                    print_json(
+                        {"warning": f"Git error: {e}", "fallback": "full analysis"}
+                    )
+                else:
+                    console.print(f"[yellow]⚠️  Git error: {e}[/yellow]")
+                    print_info("Proceeding with full codebase analysis...")
+                git_manager = None
+                git_changed_files = None
+
         # Find files to analyze
         files_to_analyze = _find_analyzable_files(
-            project_root, language_filter, path_filter, parser_registry
+            project_root,
+            language_filter,
+            path_filter,
+            parser_registry,
+            git_changed_files,
         )
 
         if not files_to_analyze:
@@ -190,11 +497,31 @@ async def run_analysis(
                 print_error("No files found to analyze")
             return
 
+        # Display analysis info
         if not json_output:
             console.print(
                 f"\n[bold blue]Starting Code Analysis[/bold blue] - {mode_label}"
             )
-            console.print(f"Files to analyze: {len(files_to_analyze)}\n")
+
+            # Show file count information with git filtering context
+            if git_changed_files is not None:
+                # Get total files for context
+                total_files = len(
+                    _find_analyzable_files(
+                        project_root,
+                        language_filter,
+                        path_filter,
+                        parser_registry,
+                        None,
+                    )
+                )
+                filter_type = "changed" if changed_only else f"vs {baseline}"
+                console.print(
+                    f"Analyzing {len(files_to_analyze)} {filter_type} files "
+                    f"({total_files} total in project)\n"
+                )
+            else:
+                console.print(f"Files to analyze: {len(files_to_analyze)}\n")
 
         # Analyze files
         project_metrics = ProjectMetrics(project_root=str(project_root))
@@ -213,11 +540,123 @@ async def run_analysis(
         # Compute aggregates
         project_metrics.compute_aggregates()
 
-        # Output results
-        if json_output:
-            output = project_metrics.to_summary()
-            print_json(output)
+        # Save snapshot to metrics store for historical tracking
+        trend_data: TrendData | None = None
+        try:
+            metrics_db_path = project_root / ".mcp-vector-search" / "metrics.db"
+            metrics_store = MetricsStore(metrics_db_path)
+            snapshot_id = metrics_store.save_project_snapshot(project_metrics)
+            logger.debug(f"Saved metrics snapshot {snapshot_id}")
+
+            # Check for historical data and compute trends if available
+            trend_tracker = TrendTracker(metrics_store)
+            trend_data = trend_tracker.get_trends(project_root, days=30)
+
+            # Only show trends if we have at least 2 snapshots
+            if len(trend_data.snapshots) >= 2 and not json_output:
+                _print_trends(trend_data)
+
+        except MetricsStoreError as e:
+            logger.debug(f"Could not save metrics snapshot: {e}")
+        except Exception as e:
+            logger.debug(f"Trend tracking unavailable: {e}")
+
+        # Detect code smells if requested
+        all_smells = []
+        if show_smells:
+            from ...analysis.collectors.smells import SmellDetector
+            from ...config.thresholds import ThresholdConfig
+
+            # Load threshold config (optional - defaults will be used)
+            threshold_config = ThresholdConfig()
+            smell_detector = SmellDetector(thresholds=threshold_config)
+
+            # Detect smells across all analyzed files
+            for file_path, file_metrics in project_metrics.files.items():
+                file_smells = smell_detector.detect_all(file_metrics, file_path)
+                all_smells.extend(file_smells)
+
+        # Output results based on format
+        if output_format == "markdown":
+            # Markdown format - write two files
+            from ...analysis.reporters.markdown import MarkdownReporter
+
+            reporter = MarkdownReporter()
+
+            # Generate full analysis report
+            analysis_file = reporter.generate_analysis_report(
+                project_metrics, all_smells, output_file
+            )
+            console.print(
+                f"[green]✓[/green] Analysis report written to: {analysis_file}"
+            )
+
+            # Generate fixes report if smells were detected
+            if all_smells:
+                fixes_file = reporter.generate_fixes_report(
+                    project_metrics, all_smells, output_file
+                )
+                console.print(f"[green]✓[/green] Fixes report written to: {fixes_file}")
+
+        elif output_format == "sarif":
+            # SARIF format - write to file
+            from ...analysis.reporters.sarif import SARIFReporter
+
+            if not all_smells:
+                print_error(
+                    "No code smells detected - SARIF report requires smells to report"
+                )
+                return
+
+            reporter = SARIFReporter()
+            reporter.write_sarif(all_smells, output_file, base_path=project_root)
+            console.print(f"[green]✓[/green] SARIF report written to: {output_file}")
+
+        elif json_output or output_format == "json":
+            # JSON format - with optional LLM context
+            if include_context:
+                # Enhanced JSON export with LLM-consumable context
+                from ...analysis.interpretation import EnhancedJSONExporter
+                from ...config.thresholds import ThresholdConfig
+
+                threshold_config = ThresholdConfig()
+                exporter = EnhancedJSONExporter(
+                    project_root=project_root, threshold_config=threshold_config
+                )
+                enhanced_export = exporter.export_with_context(
+                    project_metrics, include_smells=show_smells
+                )
+                # Output as JSON
+                import json
+
+                print_json(json.loads(enhanced_export.model_dump_json()))
+            else:
+                # Standard JSON format
+                output = project_metrics.to_summary()
+                # Add smell data to JSON output if available
+                if show_smells and all_smells:
+                    from ...analysis.collectors.smells import SmellDetector
+
+                    detector = SmellDetector()
+                    smell_summary = detector.get_smell_summary(all_smells)
+                    output["smells"] = {
+                        "summary": smell_summary,
+                        "details": [
+                            {
+                                "name": smell.name,
+                                "severity": smell.severity.value,
+                                "location": smell.location,
+                                "description": smell.description,
+                                "metric_value": smell.metric_value,
+                                "threshold": smell.threshold,
+                                "suggestion": smell.suggestion,
+                            }
+                            for smell in all_smells
+                        ],
+                    }
+                print_json(output)
         else:
+            # Console format (default)
             # Import console reporter
             from ...analysis.reporters.console import ConsoleReporter
 
@@ -225,21 +664,93 @@ async def run_analysis(
             reporter.print_summary(project_metrics)
             reporter.print_distribution(project_metrics)
             reporter.print_hotspots(project_metrics, top=top_n)
+
+            # Print code smells if requested
+            if show_smells and all_smells:
+                reporter.print_smells(all_smells, top=top_n)
+
             reporter.print_recommendations(project_metrics)
 
+        # Handle baseline operations after analysis
+        if baseline_manager:
+            # Save baseline if requested
+            if save_baseline:
+                try:
+                    baseline_path = baseline_manager.save_baseline(
+                        baseline_name=save_baseline,
+                        metrics=project_metrics,
+                        overwrite=force_baseline,
+                    )
+                    if not json_output:
+                        console.print(
+                            f"\n[green]✓[/green] Saved baseline: [cyan]{save_baseline}[/cyan]"
+                        )
+                        console.print(f"  Location: {baseline_path}")
+                except BaselineExistsError as e:
+                    if json_output:
+                        print_json({"error": str(e)})
+                    else:
+                        print_error(str(e))
+                        console.print(
+                            "\nUse [cyan]--force[/cyan] to overwrite the existing baseline"
+                        )
+                    raise typer.Exit(1)
+
+            # Compare against baseline if requested
+            if compare_baseline:
+                try:
+                    baseline_metrics = baseline_manager.load_baseline(compare_baseline)
+                    comparator = BaselineComparator()
+                    comparison_result = comparator.compare(
+                        current=project_metrics,
+                        baseline=baseline_metrics,
+                        baseline_name=compare_baseline,
+                    )
+
+                    # Print comparison results (console only)
+                    if not json_output and output_format == "console":
+                        from ...analysis.reporters.console import ConsoleReporter
+
+                        reporter = ConsoleReporter()
+                        reporter.print_baseline_comparison(comparison_result)
+
+                except BaselineNotFoundError as e:
+                    if json_output:
+                        print_json({"error": str(e)})
+                    else:
+                        print_error(str(e))
+                        console.print("\nAvailable baselines:")
+                        baselines = baseline_manager.list_baselines()
+                        for baseline_meta in baselines[:5]:
+                            console.print(f"  • {baseline_meta.baseline_name}")
+                    raise typer.Exit(1)
+
+        # Quality gate: check if we should fail on smells
+        if fail_on_smell and all_smells:
+            failing_smells = filter_smells_by_severity(all_smells, severity_threshold)
+            if failing_smells:
+                console.print(
+                    f"\n[red]❌ Quality gate failed: {len(failing_smells)} "
+                    f"{severity_threshold}+ severity smell(s) detected[/red]"
+                )
+                raise typer.Exit(1)
+
     except ProjectNotFoundError as e:
         if json_output:
             print_json({"error": str(e)})
         else:
             print_error(str(e))
         raise typer.Exit(1)
+    except typer.Exit:
+        # Let typer.Exit propagate for quality gate failures
+        raise
     except Exception as e:
         logger.error(f"Analysis failed: {e}", exc_info=True)
         if json_output:
             print_json({"error": str(e)})
         else:
             print_error(f"Analysis failed: {e}")
-        raise
+        raise typer.Exit(2)  # Exit code 2 for analysis errors
 
 
 def _find_analyzable_files(
@@ -247,6 +758,7 @@ def _find_analyzable_files(
     language_filter: str | None,
     path_filter: Path | None,
     parser_registry: ParserRegistry,
+    git_changed_files: list[Path] | None = None,
 ) -> list[Path]:
     """Find files that can be analyzed.
 
@@ -255,12 +767,63 @@ def _find_analyzable_files(
         language_filter: Optional language filter
         path_filter: Optional path filter
         parser_registry: Parser registry for checking supported files
+        git_changed_files: Optional list of git changed files to filter by
 
     Returns:
         List of file paths to analyze
     """
     import fnmatch
 
+    # If git_changed_files is provided, use it as the primary filter
+    if git_changed_files is not None:
+        # Filter based on supported extensions and language
+        files: list[Path] = []
+        supported_extensions = parser_registry.get_supported_extensions()
+
+        for file_path in git_changed_files:
+            # Check if file extension is supported
+            if file_path.suffix.lower() not in supported_extensions:
+                logger.debug(f"Skipping unsupported file type: {file_path}")
+                continue
+
+            # Apply language filter
+            if language_filter:
+                try:
+                    parser = parser_registry.get_parser_for_file(file_path)
+                    if parser.language.lower() != language_filter.lower():
+                        logger.debug(
+                            f"Skipping file (language mismatch): {file_path} "
+                            f"({parser.language} != {language_filter})"
+                        )
+                        continue
+                except Exception as e:
+                    logger.debug(f"Skipping file (parser error): {file_path}: {e}")
+                    continue
+
+            # Apply path filter if specified
+            if path_filter:
+                path_filter_resolved = path_filter.resolve()
+                file_path_resolved = file_path.resolve()
+
+                # Check if file is within path_filter scope
+                try:
+                    # If path_filter is a file, only include that specific file
+                    if path_filter_resolved.is_file():
+                        if file_path_resolved != path_filter_resolved:
+                            continue
+                    # If path_filter is a directory, check if file is within it
+                    elif path_filter_resolved.is_dir():
+                        file_path_resolved.relative_to(path_filter_resolved)
+                except ValueError:
+                    # File is not within path_filter scope
+                    logger.debug(f"Skipping file (outside path filter): {file_path}")
+                    continue
+
+            files.append(file_path)
+
+        return sorted(files)
+
+    # No git filtering - fall back to standard directory traversal
     # Determine base path to search
     base_path = path_filter if path_filter and path_filter.exists() else project_root
 
@@ -272,7 +835,7 @@ def _find_analyzable_files(
         return []
 
     # Find all supported files
-    files: list[Path] = []
+    files = []
     supported_extensions = parser_registry.get_supported_extensions()
 
     # Common ignore patterns
@@ -404,5 +967,96 @@ async def _analyze_file(
         return None
 
 
+def _print_trends(trend_data: TrendData) -> None:
+    """Print trend analysis to console.
+
+    Args:
+        trend_data: TrendData from TrendTracker
+    """
+    from rich.panel import Panel
+    from rich.table import Table
+
+    # Build trend display
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Metric", style="bold")
+    table.add_column("Direction")
+    table.add_column("Change")
+
+    def trend_icon(direction: TrendDirection) -> str:
+        """Get icon for trend direction."""
+        if direction == TrendDirection.IMPROVING:
+            return "[green]↓ improving[/green]"
+        elif direction == TrendDirection.WORSENING:
+            return "[red]↑ worsening[/red]"
+        else:
+            return "[dim]→ stable[/dim]"
+
+    def format_change(change: float, invert: bool = False) -> str:
+        """Format percentage change with color."""
+        if abs(change) < 0.1:
+            return "[dim]—[/dim]"
+        # For complexity/smells, negative is good; for health, positive is good
+        is_good = (change < 0) if not invert else (change > 0)
+        color = "green" if is_good else "red"
+        sign = "+" if change > 0 else ""
+        return f"[{color}]{sign}{change:.1f}%[/{color}]"
+
+    # Complexity trend
+    table.add_row(
+        "Complexity",
+        trend_icon(trend_data.complexity_direction),
+        format_change(trend_data.avg_complexity_change),
+    )
+
+    # Smell trend
+    table.add_row(
+        "Code Smells",
+        trend_icon(trend_data.smell_direction),
+        format_change(trend_data.smell_count_change),
+    )
+
+    # Health trend
+    table.add_row(
+        "Health Score",
+        trend_icon(trend_data.health_direction),
+        format_change(
+            (
+                trend_data.health_trend[-1][1] - trend_data.health_trend[0][1]
+                if len(trend_data.health_trend) >= 2
+                else 0
+            ),
+            invert=True,
+        ),
+    )
+
+    # Show panel with snapshot count
+    snapshot_count = len(trend_data.snapshots)
+    panel = Panel(
+        table,
+        title=f"[bold cyan]Trends[/bold cyan] (last 30 days, {snapshot_count} snapshots)",
+        border_style="cyan",
+        padding=(0, 1),
+    )
+    console.print(panel)
+
+    # Show critical regressions if any
+    if trend_data.critical_regressions:
+        console.print("\n[bold red]⚠ Regressions Detected:[/bold red]")
+        for regression in trend_data.critical_regressions[:3]:
+            console.print(
+                f"  • [red]{regression.file_path}[/red]: "
+                f"complexity {regression.change_percentage:+.1f}%"
+            )
+
+    # Show significant improvements if any
+    if trend_data.significant_improvements:
+        console.print("\n[bold green]✓ Improvements:[/bold green]")
+        for improvement in trend_data.significant_improvements[:3]:
+            console.print(
+                f"  • [green]{improvement.file_path}[/green]: "
+                f"complexity {improvement.change_percentage:+.1f}%"
+            )
+
+
 if __name__ == "__main__":
     analyze_app()