data/processed/RQ1/RecruitmentAssistant-MCP/evaluate_trajectory.py

#!/usr/bin/env python3
"""
Trajectory evaluation script - EmailResponder project.

Evaluates 6 trajectory metrics:
1. Exact match
2. In-order match
3. Any-order match
4. Precision
5. Recall
6. Single-tool use
"""

import os
import re
import yaml
from pathlib import Path
from typing import List, Dict, Tuple, Set
from collections import defaultdict
import pandas as pd
import math
from itertools import permutations, product


class TrajectoryParser:
    """Parse execution_path.md and extract the complete execution trajectory."""

    def __init__(self, md_file_path: str, extract_types: List[str] = None):
        """
        Args:
            md_file_path: execution_path.md file path
            extract_types: Node types to extract. Default is ['Tool'].
                          Optional types: 'SPAN', 'Chain', 'Tool', 'AGENT', 'LLM', 'Task Created', 'Crew Created'
        """
        self.md_file_path = md_file_path
        self.extract_types = extract_types or ["Tool"]
        self.trajectory = []

    def parse(self) -> List[str]:
        """Parse the file and return the execution trajectory sequence."""
        if not os.path.exists(self.md_file_path):
            return []

        with open(self.md_file_path, "r", encoding="utf-8") as f:
            content = f.read()

        # Extract the Execution Path Tree section (inside a code block)
        tree_match = re.search(
            r"## Execution Path Tree.*?```\n(.*?)```", content, re.DOTALL
        )
        if not tree_match:
            return []

        tree_content = tree_match.group(1)
        trajectory = []

        for line in tree_content.split("\n"):
            # Remove tree structure characters and keep node content
            clean_line = re.sub(r"^[│├└─\s]+", "", line).strip()
            if not clean_line:
                continue

            # Remove error marker
            clean_line = re.sub(r"^❌\s+", "", clean_line)

            # Remove RETRY markers: (retry N) and [RETRYN]
            clean_line = re.sub(r"\s*\(retry\s+\d+\)", "", clean_line)
            clean_line = re.sub(r"\s*\[RETRY\d+\]", "", clean_line)

            # Remove ERROR info (keep node type/name and remove the [ERROR:...] part)
            clean_line = re.sub(r"\s*\[ERROR:[^\]]*\]", "", clean_line)

            # Extract node information
            node_info = self._extract_node_info(clean_line)

            if node_info and node_info["type"] in self.extract_types:
                trajectory.append(node_info["action"])

        self.trajectory = trajectory
        return trajectory

    def _extract_node_info(self, line: str) -> dict:
        """Extract node information from a single line.

        Note: The input line should have already had the error marker (❌),
        RETRY markers, and ERROR info removed.

        Returns:
            {'type': str, 'action': str} or None
        """
        # SPAN node: [SPAN] span_name [statistics]
        # Use a more permissive match to handle possible leftover special characters
        span_match = re.match(r"\[SPAN\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line)
        if span_match:
            span_name = span_match.group(1).strip()
            return {"type": "SPAN", "action": f"SPAN: {span_name}"}

        # Chain node: [Chain] chain_name [statistics]
        # For Crew_xxx.kickoff, use wildcard Crew***.kickoff
        chain_match = re.match(r"\[Chain\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line)
        if chain_match:
            chain_name = chain_match.group(1).strip()
            # Wildcard handling: Crew_UUID.kickoff -> Crew***.kickoff
            chain_name = re.sub(
                r"Crew_[a-f0-9\-]+\.kickoff", "Crew***.kickoff", chain_name
            )
            return {"type": "Chain", "action": f"Chain: {chain_name}"}

        # AGENT node: [AGENT] agent_name._execute_core [statistics]
        agent_match = re.match(r"\[AGENT\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line)
        if agent_match:
            agent_name = agent_match.group(1).strip()
            # Remove ._execute_core suffix
            agent_name = re.sub(r"\._execute_core$", "", agent_name)
            return {"type": "AGENT", "action": f"Agent: {agent_name}"}

        # Tool node: [Tool] tool_name._use [time]
        tool_match = re.match(
            r"\[Tool\]\s+([^\[\]]+?)(?:\s+\[[\d.]+(?:ms|s)\])?(?:\s*@@@)?\s*$", line
        )
        if tool_match:
            tool_name = tool_match.group(1).strip()
            # Remove ._use suffix
            tool_name = re.sub(r"\._use$", "", tool_name)
            return {"type": "Tool", "action": f"Tool: {tool_name}"}

        # LLM node: [LLM] model_name (tokens) [time]
        llm_match = re.match(r"\[LLM\]\s+([^\(\[]+)", line)
        if llm_match:
            model_name = llm_match.group(1).strip()
            return {"type": "LLM", "action": f"LLM: {model_name}"}

        # Task Created node: [Task Created] [time]
        task_match = re.match(r"\[Task Created\]", line)
        if task_match:
            return {"type": "Task Created", "action": "Task Created"}

        # Crew Created node: [Crew Created] [time]
        crew_match = re.match(r"\[Crew Created\]", line)
        if crew_match:
            return {"type": "Crew Created", "action": "Crew Created"}

        return None


class TrajectoryEvaluator:
    """Trajectory evaluator - implements 6 evaluation metrics."""

    def __init__(self, reference_trajectory: List[str]):
        """
        Args:
            reference_trajectory: Reference trajectory (ground truth)
        """
        self.reference = reference_trajectory

    def _match_action(self, predicted_action: str, reference_action: str) -> bool:
        """
        Match two actions, supports wildcards.

        Args:
            predicted_action: Action actually executed
            reference_action: Reference action (may contain wildcards)

        Returns:
            True if match, False otherwise
        """
        # Exact match
        if predicted_action == reference_action:
            return True

        # Wildcard match: LLM: * matches any LLM: <model_name>
        if reference_action == "LLM: *" and predicted_action.startswith("LLM: "):
            return True

        return False

    def exact_match(self, predicted: List[str]) -> int:
        """
        Exact match: predicted trajectory must be identical to the reference trajectory (supports wildcards)

        Returns:
            1 if exact match, 0 otherwise
        """
        if len(predicted) != len(self.reference):
            return 0

        for i in range(len(predicted)):
            if not self._match_action(predicted[i], self.reference[i]):
                return 0

        return 1

    def in_order_match(self, predicted: List[str]) -> int:
        """
        In-order match: reference trajectory must be a subsequence of predicted trajectory (supports wildcards)
        Extra actions are allowed, but core steps must appear in order.

        Returns:
            1 if in-order match, 0 otherwise
        """
        if not self.reference:
            return 1  # Empty reference trajectory always matches

        ref_idx = 0
        for pred_action in predicted:
            if ref_idx < len(self.reference) and self._match_action(
                pred_action, self.reference[ref_idx]
            ):
                ref_idx += 1

        # Check whether all reference steps were found in order
        return 1 if ref_idx == len(self.reference) else 0

    def any_order_match(self, predicted: List[str]) -> int:
        """
        Any-order match: predicted trajectory must contain all required actions (supports wildcards)
        Order does not matter, extra actions are allowed.

        Returns:
            1 if any-order match, 0 otherwise
        """
        if not self.reference:
            return 1

        # Create a copy of predicted actions for matching
        pred_remaining = predicted.copy()

        # For each reference action, try to find a match in the prediction
        for ref_action in self.reference:
            matched = False
            for i, pred_action in enumerate(pred_remaining):
                if self._match_action(pred_action, ref_action):
                    pred_remaining.pop(i)  # Remove matched item
                    matched = True
                    break

            if not matched:
                return 0  # A reference action was not matched

        return 1

    def precision(self, predicted: List[str]) -> float:
        """
        Precision: how much of the predicted trajectory is considered correct by the reference (supports wildcards)

        Precision = TP / (TP + FP)
        TP: number of correctly predicted tool calls
        FP: number of incorrect/extra predicted tool calls

        Returns:
            precision value (0.0 - 1.0)
        """
        if not predicted:
            return 1.0  # No prediction, no incorrect prediction

        if not self.reference:
            return 0.0  # Empty reference with non-empty prediction => all incorrect

        # Create a copy of reference actions for matching
        ref_remaining = self.reference.copy()

        tp = 0  # True Positives
        for pred_action in predicted:
            # Try to find a match in reference
            for i, ref_action in enumerate(ref_remaining):
                if self._match_action(pred_action, ref_action):
                    tp += 1
                    ref_remaining.pop(i)  # Remove matched item
                    break

        fp = len(predicted) - tp  # False Positives

        return tp / (tp + fp) if (tp + fp) > 0 else 0.0

    def recall(self, predicted: List[str]) -> float:
        """
        Recall: how much of the reference trajectory is covered by the predicted trajectory (supports wildcards)

        Recall = TP / (TP + FN)
        TP: number of required calls covered by prediction
        FN: number of missed required calls

        Returns:
            recall value (0.0 - 1.0)
        """
        if not self.reference:
            return 1.0  # Empty reference: nothing to recall

        if not predicted:
            return 0.0  # No prediction => recall is 0

        # Create a copy of predicted actions for matching
        pred_remaining = predicted.copy()

        tp = 0  # True Positives
        for ref_action in self.reference:
            # Try to find a match in prediction
            for i, pred_action in enumerate(pred_remaining):
                if self._match_action(pred_action, ref_action):
                    tp += 1
                    pred_remaining.pop(i)  # Remove matched item
                    break

        fn = len(self.reference) - tp  # False Negatives

        return tp / (tp + fn) if (tp + fn) > 0 else 0.0

    def single_tool_use(self, predicted: List[str], tool_name: str) -> int:
        """
        Single-tool use: check whether a specific tool appears in the trajectory (supports wildcards)

        Args:
            predicted: Predicted trajectory
            tool_name: Target tool name

        Returns:
            1 if tool is used, 0 otherwise
        """
        # Check whether any action in the predicted trajectory matches the target tool
        for pred_action in predicted:
            if self._match_action(pred_action, tool_name):
                return 1
        return 0

    def evaluate_all(
        self, predicted: List[str], target_tools: List[str] = None
    ) -> Dict[str, float]:
        """
        Evaluate all metrics.

        Args:
            predicted: Predicted trajectory
            target_tools: List of tools to detect usage for (for single-tool use)

        Returns:
            Dictionary of metric results
        """
        results = {
            "exact_match": self.exact_match(predicted),
            "in_order_match": self.in_order_match(predicted),
            "any_order_match": self.any_order_match(predicted),
            "precision": self.precision(predicted),
            "recall": self.recall(predicted),
        }

        # Single-tool use metric: overall usage rate (average across tools)
        if target_tools:
            tool_usage_count = sum(
                self.single_tool_use(predicted, tool) for tool in target_tools
            )
            results["single_tool_use"] = (
                tool_usage_count / len(target_tools) if target_tools else 0.0
            )

        return results


class DatasetEvaluator:
    """Dataset-level evaluator."""

    def __init__(self, config_file: str):
        """
        Args:
            config_file: YAML configuration file path containing reference trajectory definitions
        """
        self.config_file = config_file
        self.config = self._load_config()
        self.reference_trajectory = self.config.get("reference_trajectory", [])
        # Dynamic reference trajectory: choose based on unified_web_search count
        self.reference_trajectory_3x = self.config.get("reference_trajectory_3x", None)
        self.reference_trajectory_4x = self.config.get("reference_trajectory_4x", None)
        self.use_dynamic_reference = (
            self.reference_trajectory_3x is not None
            and self.reference_trajectory_4x is not None
        )
        self.target_tools = self.config.get("target_tools", [])
        self.models = self.config.get("models", [])
        self.project_name = self.config.get("project_name", "EmailResponder")
        # Trajectory extraction types: default is ['Tool'], can be configured to ['Tool', 'AGENT', 'Task Created'] etc.
        self.extract_types = self.config.get("extract_types", ["Tool"])
        # Permutable tool group configuration
        self.permutable_tool_groups = self.config.get("permutable_tool_groups", {})

    def _load_config(self) -> Dict:
        """Load YAML configuration file."""
        if not os.path.exists(self.config_file):
            print(f"⚠️  Configuration file does not exist: {self.config_file}")
            return {}

        with open(self.config_file, "r", encoding="utf-8") as f:
            return yaml.safe_load(f)

    def _count_unified_web_search_in_analyze_job(self, exec_path_file: str) -> int:
        """
        Count unified_web_search occurrences under the analyze_job SPAN.

        Args:
            exec_path_file: execution_path.md file path

        Returns:
            Number of unified_web_search calls
        """
        if not os.path.exists(exec_path_file):
            return 0

        with open(exec_path_file, "r", encoding="utf-8") as f:
            content = f.read()

        # Extract Execution Path Tree
        tree_match = re.search(
            r"## Execution Path Tree.*?```\n(.*?)```", content, re.DOTALL
        )
        if not tree_match:
            return 0

        tree_content = tree_match.group(1)
        lines = tree_content.split("\n")

        # Determine the range of the analyze_job SPAN
        in_analyze_job = False
        analyze_job_level = -1
        count = 0

        for line in lines:
            # Compute nesting level via leading tree characters
            level = len(re.match(r"^([│├└─\s]*)", line).group(1))

            # Clean line content
            clean_line = re.sub(r"^[│├└─\s]+", "", line).strip()
            clean_line = re.sub(r"^❌\s+", "", clean_line)

            # Enter analyze_job SPAN
            if "[SPAN] analyze_job" in clean_line:
                in_analyze_job = True
                analyze_job_level = level
                continue

            # If inside analyze_job SPAN
            if in_analyze_job:
                # If we hit a SPAN at the same or higher level, we have left analyze_job
                if "[SPAN]" in clean_line and level <= analyze_job_level:
                    break

                # Count unified_web_search
                if "[Tool] unified_web_search" in clean_line:
                    count += 1

        return count

    def _generate_permuted_trajectories(
        self, base_trajectory: List[str]
    ) -> List[List[str]]:
        """
        Generate all possible permuted tool-order reference trajectories based on permutable_tool_groups.

        Args:
            base_trajectory: Base reference trajectory

        Returns:
            List of all possible permuted trajectories (including the original)
        """
        if not self.permutable_tool_groups:
            # No permutable tool group configured; return the original trajectory.
            return [base_trajectory]

        # Collect all permutable tool groups and their positions in the trajectory
        tool_groups_positions = []

        for group_name, tools in self.permutable_tool_groups.items():
            # Locate positions of this tool group in the trajectory
            positions = []
            tool_indices = {}

            for i, action in enumerate(base_trajectory):
                for tool in tools:
                    if action == tool:
                        positions.append(i)
                        tool_indices[i] = tool
                        break

            # Only permute if all tools in the group are present
            if len(positions) == len(tools):
                # Record positions and tool names at those positions
                tools_at_positions = [tool_indices[pos] for pos in positions]
                tool_groups_positions.append((positions, tools_at_positions))

        if not tool_groups_positions:
            # No complete permutable tool group found
            return [base_trajectory]

        # Generate all possible permutations
        all_trajectories = []

        # Generate permutations for each tool group
        group_permutations = []
        for positions, tools in tool_groups_positions:
            # Generate all permutations for this group
            perms = list(permutations(tools))
            group_permutations.append([(positions, perm) for perm in perms])

        # Cartesian product: combine permutations across tool groups
        all_group_combinations = list(product(*group_permutations))

        # Build a new trajectory for each combination
        for combination in all_group_combinations:
            new_trajectory = base_trajectory.copy()

            # Apply tool permutations of this combination
            for positions, perm in combination:
                for pos, tool in zip(positions, perm):
                    new_trajectory[pos] = tool

            all_trajectories.append(new_trajectory)

        return all_trajectories

    def _find_best_reference_trajectory(
        self, predicted: List[str], candidate_references: List[List[str]]
    ) -> Tuple[List[str], Dict[str, float]]:
        """
        Choose the best reference trajectory from multiple candidates.

        Args:
            predicted: Predicted trajectory
            candidate_references: Candidate reference trajectories

        Returns:
            (best reference trajectory, corresponding matching score dict)
        """
        best_reference = candidate_references[0]
        best_score = -1
        best_metrics = {}

        for ref_trajectory in candidate_references:
            evaluator = TrajectoryEvaluator(ref_trajectory)

            # Compute three key matching metrics
            exact = evaluator.exact_match(predicted)
            in_order = evaluator.in_order_match(predicted)
            any_order = evaluator.any_order_match(predicted)

            # Composite score: exact_match has the highest weight, then in_order_match.
            # Weighted sum: exact*3 + in_order*2 + any_order*1
            score = exact * 3 + in_order * 2 + any_order * 1

            if score > best_score:
                best_score = score
                best_reference = ref_trajectory
                best_metrics = {
                    "exact_match": exact,
                    "in_order_match": in_order,
                    "any_order_match": any_order,
                }

        return best_reference, best_metrics

    def collect_execution_paths(
        self, model_name: str, base_dir: str
    ) -> List[Tuple[str, List[str]]]:
        """
        Collect and parse all execution_path.md files for the specified model.

        Args:
            model_name: Model name
            base_dir: RESULTS directory path

        Returns:
            List of (session_id, trajectory)
        """
        model_dir = Path(base_dir) / model_name / self.project_name / "test_results"

        if not model_dir.exists():
            print(f"⚠️  Model directory does not exist: {model_dir}")
            return []

        results = []

        # Iterate through session subdirectories
        for session_dir in sorted(model_dir.iterdir()):
            if not session_dir.is_dir():
                continue

            exec_path_file = session_dir / "execution_path.md"
            if not exec_path_file.exists():
                continue

            # Parse trajectory (using configured extraction types)
            parser = TrajectoryParser(
                str(exec_path_file), extract_types=self.extract_types
            )
            trajectory = parser.parse()

            results.append((session_dir.name, trajectory))

        return results

    def evaluate_model(self, model_name: str, base_dir: str) -> Dict[str, float]:
        """
        Evaluate a single model across all samples.

        Args:
            model_name: Model name
            base_dir: RESULTS directory path

        Returns:
            Average metric dict
        """
        model_dir = Path(base_dir) / model_name / self.project_name / "test_results"

        if not model_dir.exists():
            print(f"⚠️  Model {model_name} has no trajectory data")
            return {}

        # Accumulate metrics across samples
        all_metrics = defaultdict(list)
        trajectories = []

        # Iterate through sessions
        for session_dir in sorted(model_dir.iterdir()):
            if not session_dir.is_dir():
                continue

            exec_path_file = session_dir / "execution_path.md"
            if not exec_path_file.exists():
                continue

            # Parse trajectory
            parser = TrajectoryParser(
                str(exec_path_file), extract_types=self.extract_types
            )
            predicted = parser.parse()

            # Dynamically choose reference trajectory
            if self.use_dynamic_reference:
                # Count unified_web_search occurrences in analyze_job
                search_count = self._count_unified_web_search_in_analyze_job(
                    str(exec_path_file)
                )

                # Choose reference based on count
                if search_count <= 3:
                    base_reference = self.reference_trajectory_3x
                else:
                    base_reference = self.reference_trajectory_4x
            else:
                # Use default reference
                base_reference = self.reference_trajectory

            # Generate all possible permuted reference trajectories
            candidate_references = self._generate_permuted_trajectories(base_reference)

            # Choose the best reference from candidates
            if len(candidate_references) > 1:
                reference, _ = self._find_best_reference_trajectory(
                    predicted, candidate_references
                )
            else:
                reference = base_reference

            # Evaluate using the chosen reference trajectory
            evaluator = TrajectoryEvaluator(reference)
            metrics = evaluator.evaluate_all(predicted, self.target_tools)

            for key, value in metrics.items():
                all_metrics[key].append(value)

            trajectories.append((session_dir.name, predicted))

        # Compute averages
        avg_metrics = {}
        for key, values in all_metrics.items():
            avg_metrics[key] = sum(values) / len(values) if values else 0.0

        num_samples = len(trajectories)

        # Compute unique path ratio and path entropy
        path_counter = defaultdict(int)
        for session_id, predicted in trajectories:
            path_key = tuple(predicted)
            path_counter[path_key] += 1

        unique_paths = len(path_counter)
        unique_path_ratio = unique_paths / num_samples if num_samples > 0 else 0.0

        probs = [count / num_samples for count in path_counter.values()]
        H = -sum(p * math.log(p) for p in probs if p > 0)
        if len(probs) > 1:
            path_entropy = H / math.log(len(probs))
        else:
            path_entropy = 0.0

        avg_metrics["unique_path_ratio"] = unique_path_ratio
        avg_metrics["path_entropy"] = path_entropy

        # Add sample count
        avg_metrics["num_samples"] = num_samples

        return avg_metrics

    def evaluate_all_models(self, base_dir: str = None) -> pd.DataFrame:
        """
        Evaluate all models and build a summary table.

        Args:
            base_dir: RESULTS directory path. Defaults to two levels above this script.

        Returns:
            DataFrame containing evaluation results for all models
        """
        if base_dir is None:
            # Default path: two levels above this script
            base_dir = Path(__file__).parent.parent.parent

        results = []

        for model_name in self.models:
            print(f"\n📊 Evaluating model: {model_name}")
            metrics = self.evaluate_model(model_name, str(base_dir))

            if metrics:
                metrics["model"] = model_name
                results.append(metrics)
                print(f"  ✅ Completed, sample count: {metrics['num_samples']}")
            else:
                print("  ❌ Skipped (no data)")

        if not results:
            print("\n❌ No model data")
            return pd.DataFrame()

        # Create DataFrame
        df = pd.DataFrame(results)

        # Reorder columns: model name first
        cols = [
            "model",
            "num_samples",
            "exact_match",
            "in_order_match",
            "any_order_match",
            "precision",
            "recall",
            "single_tool_use",
            "unique_path_ratio",
            "path_entropy",
        ]

        # Keep only columns that exist
        cols = [col for col in cols if col in df.columns]

        df = df[cols]

        return df


def main():
    """Main entry point."""
    import argparse

    parser = argparse.ArgumentParser(
        description="Evaluate trajectory metrics for the EmailResponder project"
    )
    parser.add_argument(
        "--config",
        type=str,
        default="reference_trajectory.yaml",
        help="Reference trajectory config file path (YAML)",
    )
    parser.add_argument(
        "--base-dir",
        type=str,
        default=None,
        help="RESULTS directory path (defaults to two levels above this script)",
    )
    parser.add_argument(
        "--output",
        type=str,
        default="evaluation_results.csv",
        help="OUTPUT CSV file path",
    )
    parser.add_argument(
        "--format",
        type=str,
        choices=["csv", "markdown", "both"],
        default="both",
        help="Output format: csv, markdown, or both (markdown output is disabled)",
    )

    args = parser.parse_args()

    # If config is relative, resolve it relative to this script
    config_path = args.config
    if not os.path.isabs(config_path):
        config_path = os.path.join(os.path.dirname(__file__), config_path)

    print("=" * 80)
    print("Trajectory Evaluation Tool - EmailResponder")
    print("=" * 80)
    print(f"\n📁 Config file: {config_path}")

    # Create evaluator
    evaluator = DatasetEvaluator(config_path)

    print(f"📋 Project: {evaluator.project_name}")

    # Display reference trajectory information
    if evaluator.use_dynamic_reference:
        print("🎯 Reference trajectory: dynamic selection")
        print(
            f"   - 3x version (unified_web_search<=3): {len(evaluator.reference_trajectory_3x)} steps"
        )
        print(
            f"   - 4x version (unified_web_search>=4): {len(evaluator.reference_trajectory_4x)} steps"
        )
    else:
        print(f"🎯 Reference trajectory: {evaluator.reference_trajectory}")

    print(f"🔧 Target tools: {evaluator.target_tools}")
    print(f"🤖 Models: {evaluator.models}")

    # Display tool permutation configuration
    if evaluator.permutable_tool_groups:
        print("\n🔀 Dynamic tool permutation: enabled")
        total_permutations = 1
        for group_name, tools in evaluator.permutable_tool_groups.items():
            num_perms = math.factorial(len(tools))
            total_permutations *= num_perms
            print(f"   - {group_name}: {len(tools)} tools, {num_perms} permutations")
        print(f"   - Total permutations: {total_permutations}")
        print("   - Strategy: choose the best-matching permutation per sample")
    else:
        print("\n🔀 Dynamic tool permutation: disabled")

    # Evaluate all models
    df = evaluator.evaluate_all_models(args.base_dir)

    if df.empty:
        print("\n❌ Evaluation failed: no data")
        return

    print("\n" + "=" * 80)
    print("📊 Evaluation Summary")
    print("=" * 80)

    # Format display
    pd.set_option("display.max_columns", None)
    pd.set_option("display.width", None)
    pd.set_option("display.float_format", lambda x: f"{x:.4f}")

    print("\n" + df.to_string(index=False))

    # Save results
    output_dir = os.path.dirname(args.output) or "."
    os.makedirs(output_dir, exist_ok=True)

    if args.format in ["csv", "both"]:
        csv_file = args.output
        df.to_csv(csv_file, index=False)
        print(f"\n✅ CSV saved: {csv_file}")

    if args.format in ["markdown", "both"]:
        print("ℹ️  Markdown output is disabled; only CSV will be produced.")

    print("\n" + "=" * 80)
    print("✅ Done")
    print("=" * 80)


if __name__ == "__main__":
    main()