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

evalvault/adapters/outbound/storage/base_sql.py

@@ -249,6 +249,17 @@ class SQLQueries:
     def list_runs_ordering(self) -> str:
         return f" ORDER BY started_at DESC LIMIT {self.placeholder}"
 
+    def upsert_regression_baseline(self) -> str:
+        raise NotImplementedError("Override in subclass")
+
+    def select_regression_baseline(self) -> str:
+        return f"""
+        SELECT baseline_key, run_id, dataset_name, branch, commit_sha, metadata,
+               created_at, updated_at
+        FROM regression_baselines
+        WHERE baseline_key = {self.placeholder}
+        """
+
 
 class BaseSQLStorageAdapter(ABC):
     """Shared serialization and SQL helpers for DB-API based adapters."""
@@ -589,6 +600,54 @@ class BaseSQLStorageAdapter(ABC):
             total_feedback=len(effective),
         )
 
+    def set_regression_baseline(
+        self,
+        baseline_key: str,
+        run_id: str,
+        *,
+        dataset_name: str | None = None,
+        branch: str | None = None,
+        commit_sha: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        now = self._serialize_datetime(datetime.now())
+        with self._get_connection() as conn:
+            self._execute(
+                conn,
+                self.queries.upsert_regression_baseline(),
+                (
+                    baseline_key,
+                    run_id,
+                    dataset_name,
+                    branch,
+                    commit_sha,
+                    self._serialize_json(metadata),
+                    now,
+                    now,
+                ),
+            )
+            conn.commit()
+
+    def get_regression_baseline(self, baseline_key: str) -> dict[str, Any] | None:
+        with self._get_connection() as conn:
+            row = self._execute(
+                conn,
+                self.queries.select_regression_baseline(),
+                (baseline_key,),
+            ).fetchone()
+            if not row:
+                return None
+            return {
+                "baseline_key": self._row_value(row, "baseline_key"),
+                "run_id": str(self._row_value(row, "run_id")),
+                "dataset_name": self._row_value(row, "dataset_name"),
+                "branch": self._row_value(row, "branch"),
+                "commit_sha": self._row_value(row, "commit_sha"),
+                "metadata": self._deserialize_json(self._row_value(row, "metadata")),
+                "created_at": self._row_value(row, "created_at"),
+                "updated_at": self._row_value(row, "updated_at"),
+            }
+
     # Serialization helpers --------------------------------------------
 
     def _run_params(self, run: EvaluationRun) -> Sequence[Any]:
@@ -1302,6 +1361,107 @@ class BaseSQLStorageAdapter(ABC):
         workbook.save(output)
         return output
 
+    def export_analysis_results_to_excel(self, run_id: str, output_path) -> Path:
+        from openpyxl import Workbook
+
+        output = Path(output_path)
+        output.parent.mkdir(parents=True, exist_ok=True)
+        placeholder = self.queries.placeholder
+
+        with self._get_connection() as conn:
+            analysis_rows = self._execute(
+                conn,
+                (
+                    "SELECT analysis_id, run_id, analysis_type, result_data, created_at "
+                    f"FROM analysis_results WHERE run_id = {placeholder} ORDER BY created_at DESC"
+                ),
+                (run_id,),
+            ).fetchall()
+            analysis_payloads = self._normalize_rows(
+                analysis_rows,
+                json_columns={"result_data"},
+            )
+
+            report_rows = self._execute(
+                conn,
+                (
+                    "SELECT report_id, run_id, experiment_id, report_type, format, content, metadata, created_at "
+                    f"FROM analysis_reports WHERE run_id = {placeholder} ORDER BY created_at DESC"
+                ),
+                (run_id,),
+            ).fetchall()
+            report_payloads = self._normalize_rows(report_rows, json_columns={"metadata"})
+
+            pipeline_rows = self._execute(
+                conn,
+                (
+                    "SELECT result_id, intent, query, run_id, pipeline_id, profile, tags, metadata, "
+                    "is_complete, duration_ms, final_output, node_results, started_at, finished_at, created_at "
+                    f"FROM pipeline_results WHERE run_id = {placeholder} ORDER BY created_at DESC"
+                ),
+                (run_id,),
+            ).fetchall()
+            pipeline_payloads = self._normalize_rows(
+                pipeline_rows,
+                json_columns={"tags", "metadata", "final_output", "node_results"},
+            )
+
+        sheet_order: list[tuple[str, list[dict[str, Any]], list[str]]] = [
+            (
+                "AnalysisResults",
+                analysis_payloads,
+                ["analysis_id", "run_id", "analysis_type", "result_data", "created_at"],
+            ),
+            (
+                "AnalysisReports",
+                report_payloads,
+                [
+                    "report_id",
+                    "run_id",
+                    "experiment_id",
+                    "report_type",
+                    "format",
+                    "content",
+                    "metadata",
+                    "created_at",
+                ],
+            ),
+            (
+                "PipelineResults",
+                pipeline_payloads,
+                [
+                    "result_id",
+                    "intent",
+                    "query",
+                    "run_id",
+                    "pipeline_id",
+                    "profile",
+                    "tags",
+                    "metadata",
+                    "is_complete",
+                    "duration_ms",
+                    "final_output",
+                    "node_results",
+                    "started_at",
+                    "finished_at",
+                    "created_at",
+                ],
+            ),
+        ]
+
+        workbook = Workbook()
+        default_sheet = workbook.active
+        if default_sheet is not None:
+            workbook.remove(default_sheet)
+        for sheet_name, rows, columns in sheet_order:
+            worksheet = cast(Any, workbook.create_sheet(title=sheet_name))
+            worksheet.append(columns)
+            for row in rows:
+                worksheet.append([row.get(column) for column in columns])
+
+        workbook.save(output)
+        return output
+
     def export_multiturn_run_to_excel(self, run_id: str, output_path) -> Path:
         from openpyxl import Workbook
 

evalvault/adapters/outbound/storage/postgres_adapter.py

@@ -11,6 +11,7 @@ from typing import Any
 import psycopg
 from psycopg.rows import dict_row
 
+from evalvault.adapters.outbound.analysis.pipeline_helpers import to_serializable
 from evalvault.adapters.outbound.storage.base_sql import BaseSQLStorageAdapter, SQLQueries
 from evalvault.domain.entities.analysis import (
     AnalysisType,
@@ -30,6 +31,31 @@ from evalvault.domain.entities.prompt import Prompt, PromptSet, PromptSetBundle,
 from evalvault.domain.entities.stage import StageEvent, StageMetric
 
 
+class PostgresQueries(SQLQueries):
+    def __init__(self) -> None:
+        super().__init__(
+            placeholder="%s",
+            metric_name_column="name",
+            test_case_returning_clause="RETURNING id",
+            feedback_returning_clause="RETURNING id",
+        )
+
+    def upsert_regression_baseline(self) -> str:
+        return """
+        INSERT INTO regression_baselines (
+            baseline_key, run_id, dataset_name, branch, commit_sha, metadata,
+            created_at, updated_at
+        ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+        ON CONFLICT (baseline_key) DO UPDATE SET
+            run_id = EXCLUDED.run_id,
+            dataset_name = EXCLUDED.dataset_name,
+            branch = EXCLUDED.branch,
+            commit_sha = EXCLUDED.commit_sha,
+            metadata = EXCLUDED.metadata,
+            updated_at = EXCLUDED.updated_at
+        """
+
+
 class PostgreSQLStorageAdapter(BaseSQLStorageAdapter):
     """PostgreSQL 기반 평가 결과 저장 어댑터.
 
@@ -56,14 +82,7 @@ class PostgreSQLStorageAdapter(BaseSQLStorageAdapter):
             password: Database password
             connection_string: Full connection string (overrides other params if provided)
         """
-        super().__init__(
-            SQLQueries(
-                placeholder="%s",
-                metric_name_column="name",
-                test_case_returning_clause="RETURNING id",
-                feedback_returning_clause="RETURNING id",
-            )
-        )
+        super().__init__(PostgresQueries())
         if connection_string:
             self._conn_string = connection_string
         else:
@@ -304,6 +323,29 @@ class PostgreSQLStorageAdapter(BaseSQLStorageAdapter):
         conn.execute(
             "CREATE INDEX IF NOT EXISTS idx_multiturn_scores_metric_name ON multiturn_metric_scores(metric_name)"
         )
+        conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS regression_baselines (
+                baseline_key TEXT PRIMARY KEY,
+                run_id UUID NOT NULL REFERENCES evaluation_runs(run_id) ON DELETE CASCADE,
+                dataset_name VARCHAR(255),
+                branch TEXT,
+                commit_sha VARCHAR(64),
+                metadata JSONB,
+                created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_baselines_run_id ON regression_baselines(run_id)"
+        )
+        conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_baselines_dataset ON regression_baselines(dataset_name)"
+        )
+        conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_baselines_updated_at ON regression_baselines(updated_at DESC)"
+        )
 
     # Prompt set methods
 
@@ -720,6 +762,39 @@ class PostgreSQLStorageAdapter(BaseSQLStorageAdapter):
             conn.commit()
         return analysis.analysis_id
 
+    def save_analysis_result(
+        self,
+        *,
+        run_id: str,
+        analysis_type: str,
+        result_data: dict[str, Any],
+        analysis_id: str | None = None,
+    ) -> str:
+        """분석 결과(JSON)를 저장합니다."""
+        analysis_id = analysis_id or f"analysis-{analysis_type}-{run_id}-{uuid.uuid4().hex[:8]}"
+        payload = to_serializable(result_data)
+
+        with self._get_connection() as conn:
+            conn.execute(
+                """
+                INSERT INTO analysis_results (
+                    analysis_id, run_id, analysis_type, result_data, created_at
+                ) VALUES (%s, %s, %s, %s, %s)
+                ON CONFLICT (analysis_id) DO UPDATE SET
+                    result_data = EXCLUDED.result_data,
+                    created_at = EXCLUDED.created_at
+                """,
+                (
+                    analysis_id,
+                    run_id,
+                    analysis_type,
+                    json.dumps(payload, ensure_ascii=False),
+                    datetime.now(UTC),
+                ),
+            )
+            conn.commit()
+        return analysis_id
+
     def get_analysis(self, analysis_id: str) -> StatisticalAnalysis:
         """분석 결과를 조회합니다."""
         with self._get_connection() as conn:
@@ -816,6 +891,55 @@ class PostgreSQLStorageAdapter(BaseSQLStorageAdapter):
             conn.commit()
         return analysis_id
 
+    def save_dataset_feature_analysis(
+        self,
+        *,
+        run_id: str,
+        result_data: dict[str, Any],
+        analysis_id: str | None = None,
+    ) -> str:
+        """데이터셋 특성 분석 결과를 저장합니다."""
+        analysis_id = analysis_id or f"dataset-features-{run_id}-{uuid.uuid4().hex[:8]}"
+
+        with self._get_connection() as conn:
+            conn.execute(
+                """
+                INSERT INTO analysis_results (
+                    analysis_id, run_id, analysis_type, result_data, created_at
+                ) VALUES (%s, %s, %s, %s, %s)
+                ON CONFLICT (analysis_id) DO UPDATE SET
+                    result_data = EXCLUDED.result_data,
+                    created_at = EXCLUDED.created_at
+                """,
+                (
+                    analysis_id,
+                    run_id,
+                    AnalysisType.DATASET_FEATURES.value,
+                    json.dumps(result_data, ensure_ascii=False),
+                    datetime.now(UTC),
+                ),
+            )
+            conn.commit()
+        return analysis_id
+
+    def get_dataset_feature_analysis(self, analysis_id: str) -> dict[str, Any]:
+        """데이터셋 특성 분석 결과를 조회합니다."""
+        with self._get_connection() as conn:
+            cursor = conn.execute(
+                """
+                SELECT result_data
+                FROM analysis_results
+                WHERE analysis_id = %s AND analysis_type = %s
+                """,
+                (analysis_id, AnalysisType.DATASET_FEATURES.value),
+            )
+            row = cursor.fetchone()
+
+            if not row:
+                raise KeyError(f"Dataset feature analysis not found: {analysis_id}")
+
+            return self._ensure_json(row["result_data"])
+
     def get_nlp_analysis(self, analysis_id: str) -> NLPAnalysis:
         """NLP 분석 결과를 조회합니다."""
         with self._get_connection() as conn:

evalvault/adapters/outbound/storage/postgres_schema.sql

@@ -304,3 +304,18 @@ CREATE TABLE IF NOT EXISTS stage_metrics (
 
 CREATE INDEX IF NOT EXISTS idx_stage_metrics_run_id ON stage_metrics(run_id);
 CREATE INDEX IF NOT EXISTS idx_stage_metrics_stage_id ON stage_metrics(stage_id);
+
+CREATE TABLE IF NOT EXISTS regression_baselines (
+    baseline_key TEXT PRIMARY KEY,
+    run_id UUID NOT NULL REFERENCES evaluation_runs(run_id) ON DELETE CASCADE,
+    dataset_name VARCHAR(255),
+    branch TEXT,
+    commit_sha VARCHAR(64),
+    metadata JSONB,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_baselines_run_id ON regression_baselines(run_id);
+CREATE INDEX IF NOT EXISTS idx_baselines_dataset ON regression_baselines(dataset_name);
+CREATE INDEX IF NOT EXISTS idx_baselines_updated_at ON regression_baselines(updated_at DESC);

evalvault/adapters/outbound/storage/schema.sql

@@ -245,7 +245,7 @@ CREATE INDEX IF NOT EXISTS idx_group_runs_group_id ON experiment_group_runs(grou
 CREATE TABLE IF NOT EXISTS analysis_results (
     analysis_id TEXT PRIMARY KEY,
     run_id TEXT NOT NULL,
-    analysis_type TEXT NOT NULL,  -- 'statistical', 'nlp', 'causal', 'data_quality'
+    analysis_type TEXT NOT NULL,  -- 'statistical', 'nlp', 'causal', 'data_quality', 'dataset_features'
     result_data TEXT NOT NULL,  -- JSON serialized analysis result
     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
     FOREIGN KEY (run_id) REFERENCES evaluation_runs(run_id) ON DELETE CASCADE
@@ -360,3 +360,20 @@ CREATE TABLE IF NOT EXISTS benchmark_runs (
 CREATE INDEX IF NOT EXISTS idx_benchmark_runs_type ON benchmark_runs(benchmark_type);
 CREATE INDEX IF NOT EXISTS idx_benchmark_runs_model ON benchmark_runs(model_name);
 CREATE INDEX IF NOT EXISTS idx_benchmark_runs_created_at ON benchmark_runs(created_at DESC);
+
+-- Regression baselines table for CI/CD integration
+CREATE TABLE IF NOT EXISTS regression_baselines (
+    baseline_key TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL,
+    dataset_name TEXT,
+    branch TEXT,
+    commit_sha TEXT,
+    metadata TEXT,  -- JSON metadata
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (run_id) REFERENCES evaluation_runs(run_id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_baselines_run_id ON regression_baselines(run_id);
+CREATE INDEX IF NOT EXISTS idx_baselines_dataset ON regression_baselines(dataset_name);
+CREATE INDEX IF NOT EXISTS idx_baselines_updated_at ON regression_baselines(updated_at DESC);

evalvault/adapters/outbound/storage/sqlite_adapter.py

@@ -11,6 +11,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 
+from evalvault.adapters.outbound.analysis.pipeline_helpers import to_serializable
 from evalvault.adapters.outbound.storage.base_sql import BaseSQLStorageAdapter, SQLQueries
 from evalvault.domain.entities.analysis import (
     AnalysisType,
@@ -33,6 +34,16 @@ if TYPE_CHECKING:
     from evalvault.domain.entities.benchmark_run import BenchmarkRun
 
 
+class SQLiteQueries(SQLQueries):
+    def upsert_regression_baseline(self) -> str:
+        return """
+        INSERT OR REPLACE INTO regression_baselines (
+            baseline_key, run_id, dataset_name, branch, commit_sha, metadata,
+            created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """
+
+
 class SQLiteStorageAdapter(BaseSQLStorageAdapter):
     """SQLite 기반 평가 결과 저장 어댑터.
 
@@ -45,7 +56,7 @@ class SQLiteStorageAdapter(BaseSQLStorageAdapter):
         Args:
             db_path: Path to SQLite database file (default: data/db/evalvault.db)
         """
-        super().__init__(SQLQueries())
+        super().__init__(SQLiteQueries())
         self.db_path = Path(db_path)
         self.db_path.parent.mkdir(parents=True, exist_ok=True)
         self._init_db()
@@ -247,6 +258,28 @@ class SQLiteStorageAdapter(BaseSQLStorageAdapter):
                 """
             )
 
+        baseline_cursor = conn.execute("PRAGMA table_info(regression_baselines)")
+        baseline_columns = {row[1] for row in baseline_cursor.fetchall()}
+        if not baseline_columns:
+            conn.executescript(
+                """
+                CREATE TABLE IF NOT EXISTS regression_baselines (
+                    baseline_key TEXT PRIMARY KEY,
+                    run_id TEXT NOT NULL,
+                    dataset_name TEXT,
+                    branch TEXT,
+                    commit_sha TEXT,
+                    metadata TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (run_id) REFERENCES evaluation_runs(run_id) ON DELETE CASCADE
+                );
+                CREATE INDEX IF NOT EXISTS idx_baselines_run_id ON regression_baselines(run_id);
+                CREATE INDEX IF NOT EXISTS idx_baselines_dataset ON regression_baselines(dataset_name);
+                CREATE INDEX IF NOT EXISTS idx_baselines_updated_at ON regression_baselines(updated_at DESC);
+                """
+            )
+
     # Prompt set methods
 
     def save_prompt_set(self, bundle: PromptSetBundle) -> None:
@@ -651,6 +684,38 @@ class SQLiteStorageAdapter(BaseSQLStorageAdapter):
             conn.commit()
             return analysis.analysis_id
 
+    def save_analysis_result(
+        self,
+        *,
+        run_id: str,
+        analysis_type: str,
+        result_data: dict[str, Any],
+        analysis_id: str | None = None,
+    ) -> str:
+        """분석 결과(JSON)를 저장합니다."""
+        analysis_id = analysis_id or f"analysis-{analysis_type}-{run_id}-{uuid.uuid4().hex[:8]}"
+        payload = to_serializable(result_data)
+
+        with self._get_connection() as conn:
+            conn = cast(Any, conn)
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                INSERT OR REPLACE INTO analysis_results (
+                    analysis_id, run_id, analysis_type, result_data, created_at
+                ) VALUES (?, ?, ?, ?, ?)
+                """,
+                (
+                    analysis_id,
+                    run_id,
+                    analysis_type,
+                    json.dumps(payload, ensure_ascii=False),
+                    datetime.now().isoformat(),
+                ),
+            )
+            conn.commit()
+            return analysis_id
+
     def get_analysis(self, analysis_id: str) -> StatisticalAnalysis:
         """분석 결과를 조회합니다.
 
@@ -842,6 +907,55 @@ class SQLiteStorageAdapter(BaseSQLStorageAdapter):
             conn.commit()
             return analysis_id
 
+    def save_dataset_feature_analysis(
+        self,
+        *,
+        run_id: str,
+        result_data: dict[str, Any],
+        analysis_id: str | None = None,
+    ) -> str:
+        """데이터셋 특성 분석 결과를 저장합니다."""
+        analysis_id = analysis_id or f"dataset-features-{run_id}-{uuid.uuid4().hex[:8]}"
+        with self._get_connection() as conn:
+            conn = cast(Any, conn)
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                INSERT OR REPLACE INTO analysis_results (
+                    analysis_id, run_id, analysis_type, result_data, created_at
+                ) VALUES (?, ?, ?, ?, ?)
+                """,
+                (
+                    analysis_id,
+                    run_id,
+                    AnalysisType.DATASET_FEATURES.value,
+                    json.dumps(result_data, ensure_ascii=False),
+                    datetime.now().isoformat(),
+                ),
+            )
+            conn.commit()
+            return analysis_id
+
+    def get_dataset_feature_analysis(self, analysis_id: str) -> dict[str, Any]:
+        """데이터셋 특성 분석 결과를 조회합니다."""
+        with self._get_connection() as conn:
+            conn = cast(Any, conn)
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                SELECT analysis_id, result_data
+                FROM analysis_results
+                WHERE analysis_id = ? AND analysis_type = ?
+                """,
+                (analysis_id, AnalysisType.DATASET_FEATURES.value),
+            )
+            row = cursor.fetchone()
+
+            if not row:
+                raise KeyError(f"Dataset feature analysis not found: {analysis_id}")
+
+            return json.loads(row[1])
+
     def get_nlp_analysis(self, analysis_id: str) -> NLPAnalysis:
         """NLP 분석 결과를 조회합니다.
 

evalvault/adapters/outbound/tracer/open_rag_trace_adapter.py

@@ -21,6 +21,18 @@ class OpenRagTraceConfig:
     spec_version: str = "0.1"
     module_attribute: str = "rag.module"
     custom_prefix: str = "custom."
+    allowed_modules: tuple[str, ...] = (
+        "ingest",
+        "chunk",
+        "embed",
+        "retrieve",
+        "rerank",
+        "prompt",
+        "llm",
+        "postprocess",
+        "eval",
+        "cache",
+    )
 
 
 class _NoOpSpan:
@@ -126,10 +138,20 @@ class OpenRagTraceAdapter:
         attributes: Mapping[str, Any] | None,
     ) -> None:
         span.set_attribute("spec.version", self._config.spec_version)
-        span.set_attribute(self._config.module_attribute, str(module))
+        span.set_attribute(self._config.module_attribute, self._normalize_module(module))
         if attributes:
             self.set_span_attributes(span, attributes)
 
+    def _normalize_module(self, module: str) -> str:
+        normalized = str(module).strip().lower()
+        if not normalized:
+            return f"{self._config.custom_prefix}unknown"
+        if normalized in self._config.allowed_modules:
+            return normalized
+        if normalized.startswith(self._config.custom_prefix):
+            return normalized
+        return f"{self._config.custom_prefix}{normalized}"
+
 
 def _coerce_attribute_value(value: Any) -> Any:
     if value is None:

evalvault/config/settings.py

@@ -428,6 +428,7 @@ def apply_profile(settings: Settings, profile_name: str) -> Settings:
     if not normalized:
         return settings
 
+    model_config = None
     try:
         model_config = get_model_config()
         profile = model_config.get_profile(normalized)
@@ -459,7 +460,7 @@ def apply_profile(settings: Settings, profile_name: str) -> Settings:
             f"to use profile '{normalized}'."
         ) from exc
     except KeyError as exc:
-        available = ", ".join(sorted(model_config.profiles.keys()))
+        available = ", ".join(sorted(model_config.profiles.keys())) if model_config else ""
         raise ValueError(
             f"Unknown profile '{normalized}'. Available profiles: {available}"
         ) from exc

evalvault/domain/entities/analysis.py

@@ -14,6 +14,7 @@ class AnalysisType(str, Enum):
     NLP = "nlp"
     CAUSAL = "causal"
     DATA_QUALITY = "data_quality"
+    DATASET_FEATURES = "dataset_features"
 
 
 class QuestionType(str, Enum):

evalvault/domain/entities/analysis_pipeline.py

@@ -41,6 +41,7 @@ class AnalysisIntent(str, Enum):
     ANALYZE_TRENDS = "analyze_trends"
     ANALYZE_STATISTICAL = "analyze_statistical"
     ANALYZE_NLP = "analyze_nlp"
+    ANALYZE_DATASET_FEATURES = "analyze_dataset_features"
     ANALYZE_CAUSAL = "analyze_causal"
     ANALYZE_NETWORK = "analyze_network"
     ANALYZE_PLAYBOOK = "analyze_playbook"

evalvault/domain/entities/stage.py

@@ -54,6 +54,19 @@ class StageEvent:
     span_id: str | None = None
 
     def __post_init__(self) -> None:
+        if not isinstance(self.attributes, dict):
+            raise ValueError("StageEvent requires attributes dict")
+        if not isinstance(self.metadata, dict):
+            raise ValueError("StageEvent requires metadata dict")
+        self.stage_type = str(self.stage_type).strip().lower()
+        if not self.stage_type:
+            raise ValueError("StageEvent requires non-empty 'stage_type'")
+        if self.attempt < 1:
+            raise ValueError("StageEvent requires attempt >= 1")
+        if self.duration_ms is not None and self.duration_ms < 0:
+            raise ValueError("StageEvent requires non-negative duration_ms")
+        if self.started_at and self.finished_at and self.finished_at < self.started_at:
+            raise ValueError("StageEvent requires finished_at >= started_at")
         if self.duration_ms is None and self.started_at and self.finished_at:
             delta = self.finished_at - self.started_at
             self.duration_ms = delta.total_seconds() * 1000

evalvault/domain/services/intent_classifier.py

@@ -181,6 +181,19 @@ class IntentKeywordRegistry:
             "토픽",
             "topic",
         }
+        self._keywords[AnalysisIntent.ANALYZE_DATASET_FEATURES] = {
+            "데이터셋",
+            "dataset",
+            "특성",
+            "feature",
+            "features",
+            "분포",
+            "distribution",
+            "상관",
+            "correlation",
+            "중요도",
+            "importance",
+        }
         self._keywords[AnalysisIntent.ANALYZE_CAUSAL] = {
             "인과",
             "causal",