evalvault 1.72.0__py3-none-any.whl → 1.73.0__py3-none-any.whl

evalvault/adapters/inbound/api/routers/pipeline.py

@@ -84,6 +84,12 @@ INTENT_CATALOG = {
         "description": "질문/답변 텍스트를 분석합니다.",
         "sample_query": "텍스트 분석해줘",
     },
+    AnalysisIntent.ANALYZE_DATASET_FEATURES: {
+        "label": "데이터셋 특성 분석",
+        "category": "analysis",
+        "description": "질문/답변/컨텍스트 특성을 추출하고 메트릭 상관을 분석합니다.",
+        "sample_query": "데이터셋 특성 분석해줘",
+    },
     AnalysisIntent.ANALYZE_CAUSAL: {
         "label": "인과 관계 분석",
         "category": "analysis",

evalvault/adapters/inbound/cli/commands/analyze.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
+from typing import Any
 
 import typer
 from rich.console import Console
@@ -21,6 +22,7 @@ from evalvault.adapters.outbound.analysis import (
 from evalvault.adapters.outbound.analysis.pipeline_factory import (
     build_analysis_pipeline_service,
 )
+from evalvault.adapters.outbound.analysis.pipeline_helpers import to_serializable
 from evalvault.adapters.outbound.cache import MemoryCacheAdapter
 from evalvault.adapters.outbound.llm import get_llm_adapter
 from evalvault.adapters.outbound.report import DashboardGenerator, MarkdownReportAdapter
@@ -102,6 +104,9 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
         report: Path | None = typer.Option(
             None, "--report", "-r", help="리포트 출력 파일 (*.md 또는 *.html)"
         ),
+        excel_output: Path | None = typer.Option(
+            None, "--excel-output", help="분석 결과 Excel 출력 경로"
+        ),
         save: bool = typer.Option(False, "--save", "-S", help="분석 결과 DB 저장"),
         db_path: Path | None = db_option(help_text="DB 경로"),
         profile: str | None = profile_option(
@@ -194,8 +199,24 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
                 stage_metrics=stage_metrics,
             )
 
-        if save:
+        def _save_analysis_payload(payload: Any, analysis_type: str) -> None:
+            serialized = to_serializable(payload)
+            if not isinstance(serialized, dict):
+                serialized = {"value": serialized}
+            storage.save_analysis_result(
+                run_id=run_id,
+                analysis_type=analysis_type,
+                result_data=serialized,
+            )
+
+        if save or excel_output:
             storage.save_analysis(analysis)
+            if bundle.nlp is not None:
+                storage.save_nlp_analysis(bundle.nlp)
+            if bundle.causal is not None:
+                _save_analysis_payload(bundle.causal, "causal")
+            if improvement_report is not None:
+                _save_analysis_payload(improvement_report, "playbook")
             _console.print(f"\n[green]분석 결과 DB 저장: {resolved_db_path}[/green]")
 
         if dashboard:
@@ -211,6 +232,8 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
             fig.savefig(output_path, dpi=300, bbox_inches="tight")
             _console.print(f"\n[green]Dashboard saved to: {output_path}[/green]")
 
+        anomaly_result = None
+        forecast_result = None
         if anomaly_detect or forecast:
             ts_analyzer = TimeSeriesAdvancedModule(window_size=window_size)
             run_history = storage.list_runs(limit=50)
@@ -241,6 +264,7 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
                     )
                     _display_forecast_result(forecast_result)
 
+        net_result = None
         if network:
             _console.print("\n[bold cyan]Building metric correlation network...[/bold cyan]")
             net_analyzer = NetworkAnalyzerModule()
@@ -264,6 +288,7 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
                 net_result = net_analyzer.analyze_metric_network(graph)
                 _display_network_analysis(net_result)
 
+        hypotheses = None
         if generate_hypothesis:
             _console.print(
                 f"\n[bold cyan]Generating hypotheses ({hypothesis_method})...[/bold cyan]"
@@ -289,6 +314,16 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
             )
             _display_hypothesis_generation(hypotheses, hypothesis_method)
 
+        if save or excel_output:
+            if anomaly_result is not None:
+                _save_analysis_payload(anomaly_result, "time_series_anomaly")
+            if forecast_result is not None:
+                _save_analysis_payload(forecast_result, "time_series_forecast")
+            if net_result is not None:
+                _save_analysis_payload(net_result, "network")
+            if hypotheses is not None:
+                _save_analysis_payload(hypotheses, "hypotheses")
+
         if output:
             _export_analysis_json(analysis, output, bundle.nlp if nlp else None, improvement_report)
             _console.print(f"\n[green]분석 결과 내보냄: {output}[/green]")
@@ -297,6 +332,10 @@ def register_analyze_commands(app: typer.Typer, console: Console) -> None:
             _generate_report(bundle, report, include_nlp=nlp, improvement_report=improvement_report)
             _console.print(f"\n[green]리포트 생성: {report}[/green]")
 
+        if excel_output:
+            exported = storage.export_analysis_results_to_excel(run_id, excel_output)
+            _console.print(f"\n[green]Excel 생성: {exported}[/green]")
+
     @app.command(name="analyze-compare")
     @app.command(name="compare-analysis")
     def analyze_compare(

evalvault/adapters/inbound/cli/commands/pipeline.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import json
+from datetime import datetime
 from pathlib import Path
+from uuid import uuid4
 
 import typer
 from rich.panel import Panel
@@ -37,6 +39,11 @@ def register_pipeline_commands(app: typer.Typer, console) -> None:
             "-o",
             help="Output file for results (JSON format).",
         ),
+        excel_output: Path | None = typer.Option(
+            None,
+            "--excel-output",
+            help="분석 결과 Excel 출력 경로",
+        ),
         db_path: Path | None = db_option(help_text="Path to database file."),
     ) -> None:
         """Analyze evaluation results using natural language query."""
@@ -73,6 +80,8 @@ def register_pipeline_commands(app: typer.Typer, console) -> None:
             result = service.analyze(query, run_id=run_id)
 
         saved_analysis_id: str | None = None
+        saved_dataset_features_id: str | None = None
+        saved_additional_ids: list[str] = []
         stats_node = result.get_node_result("statistical_analyzer")
         if stats_node and isinstance(stats_node.output, dict):
             analysis_obj = stats_node.output.get("analysis")
@@ -84,12 +93,92 @@ def register_pipeline_commands(app: typer.Typer, console) -> None:
                         f"[yellow]Warning: Failed to store analysis result ({exc})[/yellow]"
                     )
 
+        dataset_node = result.get_node_result("dataset_feature_analysis")
+        if dataset_node and isinstance(dataset_node.output, dict):
+            dataset_run_id = None
+            summary = dataset_node.output.get("summary")
+            if isinstance(summary, dict):
+                dataset_run_id = summary.get("run_id")
+            resolved_run_id = dataset_run_id or run_id
+            if resolved_run_id:
+                try:
+                    saved_dataset_features_id = storage.save_dataset_feature_analysis(
+                        run_id=resolved_run_id,
+                        result_data=dataset_node.output,
+                    )
+                except Exception as exc:  # pragma: no cover - best effort for CLI UX
+                    console.print(
+                        "[yellow]Warning: Failed to store dataset feature analysis "
+                        f"({exc})[/yellow]"
+                    )
+
+        skip_nodes = {
+            "load_data",
+            "load_runs",
+            "load_run",
+            "statistical_analyzer",
+            "dataset_feature_analysis",
+        }
+        for node_id, node_result in result.node_results.items():
+            if node_id in skip_nodes:
+                continue
+            if not isinstance(node_result.output, dict) or not node_result.output:
+                continue
+            resolved_run_id = run_id
+            if resolved_run_id is None:
+                summary = (
+                    node_result.output.get("summary")
+                    if isinstance(node_result.output, dict)
+                    else None
+                )
+                if isinstance(summary, dict) and summary.get("run_id"):
+                    resolved_run_id = summary.get("run_id")
+                elif node_result.output.get("run_id"):
+                    resolved_run_id = node_result.output.get("run_id")
+            if not resolved_run_id:
+                continue
+            try:
+                saved_id = storage.save_analysis_result(
+                    run_id=resolved_run_id,
+                    analysis_type=node_id,
+                    result_data=node_result.output,
+                )
+                saved_additional_ids.append(saved_id)
+            except Exception as exc:  # pragma: no cover - best effort for CLI UX
+                console.print(
+                    f"[yellow]Warning: Failed to store {node_id} analysis ({exc})[/yellow]"
+                )
+
+        try:
+            record = serialize_pipeline_result(result)
+            record.update(
+                {
+                    "result_id": str(uuid4()),
+                    "intent": result.intent.value if result.intent else None,
+                    "query": query,
+                    "run_id": run_id,
+                    "pipeline_id": result.pipeline_id,
+                    "created_at": datetime.now().isoformat(),
+                }
+            )
+            storage.save_pipeline_result(record)
+        except Exception as exc:  # pragma: no cover - best effort for CLI UX
+            console.print(f"[yellow]Warning: Failed to store pipeline result ({exc})[/yellow]")
+
         if result.is_complete:
             console.print("[green]Pipeline completed successfully![/green]")
             console.print(f"Duration: {result.total_duration_ms}ms")
             console.print(f"Nodes executed: {len(result.node_results)}")
             if saved_analysis_id:
                 console.print(f"Analysis saved as [blue]{saved_analysis_id}[/blue]")
+            if saved_dataset_features_id:
+                console.print(
+                    f"Dataset feature analysis saved as [blue]{saved_dataset_features_id}[/blue]"
+                )
+            if saved_additional_ids:
+                console.print(
+                    f"Additional analysis saved: [blue]{len(saved_additional_ids)}[/blue] entries"
+                )
 
             if result.final_output:
                 console.print("\n[bold]Results:[/bold]")
@@ -111,6 +200,16 @@ def register_pipeline_commands(app: typer.Typer, console) -> None:
                 json.dump(payload, f, ensure_ascii=False, indent=2)
             console.print(f"\n[green]Results saved to {output}[/green]")
 
+        if excel_output:
+            if not run_id:
+                console.print("[yellow]Warning: run_id is required for Excel export.[/yellow]")
+            else:
+                try:
+                    exported = storage.export_analysis_results_to_excel(run_id, excel_output)
+                    console.print(f"\n[green]Excel saved to {exported}[/green]")
+                except Exception as exc:  # pragma: no cover - best effort for CLI UX
+                    console.print(f"[yellow]Warning: Excel export failed ({exc})[/yellow]")
+
         console.print()
 
     @pipeline_app.command("intents")
@@ -139,6 +238,7 @@ def register_pipeline_commands(app: typer.Typer, console) -> None:
             AnalysisIntent.ANALYZE_PATTERNS: ("Analysis", "패턴 분석"),
             AnalysisIntent.ANALYZE_TRENDS: ("Analysis", "추세 분석"),
             AnalysisIntent.BENCHMARK_RETRIEVAL: ("Benchmark", "검색 벤치마크"),
+            AnalysisIntent.ANALYZE_DATASET_FEATURES: ("Analysis", "데이터셋 특성 분석"),
             AnalysisIntent.GENERATE_SUMMARY: ("Report", "요약 보고서 생성"),
             AnalysisIntent.GENERATE_DETAILED: ("Report", "상세 보고서 생성"),
             AnalysisIntent.GENERATE_COMPARISON: ("Report", "비교 보고서 생성"),

evalvault/adapters/inbound/cli/commands/regress.py

@@ -368,6 +368,102 @@ def register_regress_commands(app: typer.Typer, console: Console) -> None:
         if not gate_passed and fail_on_regression:
             raise typer.Exit(2)
 
+    @app.command(name="regress-baseline")
+    def regress_baseline(
+        action: str = typer.Argument(
+            ...,
+            help="Action: 'set' to save baseline, 'get' to retrieve baseline run_id.",
+        ),
+        baseline_key: str = typer.Option(
+            "default",
+            "--key",
+            "-k",
+            help="Baseline key identifier (default: 'default').",
+        ),
+        run_id: str | None = typer.Option(
+            None,
+            "--run-id",
+            "-r",
+            help="Run ID to set as baseline (required for 'set').",
+        ),
+        dataset_name: str | None = typer.Option(
+            None,
+            "--dataset",
+            help="Dataset name for the baseline.",
+        ),
+        branch: str | None = typer.Option(
+            None,
+            "--branch",
+            help="Git branch name.",
+        ),
+        commit_sha: str | None = typer.Option(
+            None,
+            "--commit",
+            help="Git commit SHA.",
+        ),
+        output_format: str = typer.Option(
+            "text",
+            "--format",
+            "-f",
+            help="Output format: text, json.",
+        ),
+        db_path: Path | None = db_option(default=None, help_text="Database path"),
+    ) -> None:
+        """Manage regression baselines for CI/CD integration."""
+        if db_path is None:
+            console.print("[red]Error:[/red] Database path is not configured.")
+            raise typer.Exit(1)
+
+        storage = SQLiteStorageAdapter(db_path=db_path)
+
+        if action == "set":
+            if not run_id:
+                console.print("[red]Error:[/red] --run-id is required for 'set' action.")
+                raise typer.Exit(1)
+            try:
+                storage.get_run(run_id)
+            except KeyError:
+                console.print(f"[red]Error:[/red] Run not found: {run_id}")
+                raise typer.Exit(1)
+
+            storage.set_regression_baseline(
+                baseline_key,
+                run_id,
+                dataset_name=dataset_name,
+                branch=branch,
+                commit_sha=commit_sha,
+            )
+            if output_format == "json":
+                console.print(
+                    json.dumps(
+                        {"status": "ok", "baseline_key": baseline_key, "run_id": run_id},
+                        ensure_ascii=False,
+                    )
+                )
+            else:
+                console.print(f"[green]Baseline '{baseline_key}' set to run_id: {run_id}[/green]")
+        elif action == "get":
+            baseline = storage.get_regression_baseline(baseline_key)
+            if not baseline:
+                if output_format == "json":
+                    console.print(
+                        json.dumps(
+                            {"status": "not_found", "baseline_key": baseline_key},
+                            ensure_ascii=False,
+                        )
+                    )
+                else:
+                    console.print(f"[yellow]Baseline '{baseline_key}' not found.[/yellow]")
+                raise typer.Exit(1)
+
+            if output_format == "json":
+                console.print(json.dumps(baseline, ensure_ascii=False, indent=2, default=str))
+            else:
+                console.print(baseline["run_id"])
+        else:
+            console.print(f"[red]Error:[/red] Unknown action: {action}. Use 'set' or 'get'.")
+            raise typer.Exit(1)
+
 
 def _render_table(report: RegressionGateReport, console: Console) -> None:
     console.print(f"\n[bold]Regression Gate Check: {report.candidate_run_id}[/bold]\n")