File size: 26,240 Bytes

8c10cf2

#!/usr/bin/env python3

import csv
import re
from pathlib import Path
from typing import Dict, List, Optional, Tuple
from collections import defaultdict


class TraceNode:
    def __init__(
        self,
        node_type: str,
        name: str,
        time: Optional[float] = None,
        tokens: Optional[Dict[str, int]] = None,
        raw_line: str = "",
    ):
        self.type = node_type
        self.name = name
        self.time = time
        self.tokens = tokens or {}
        self.raw_line = raw_line
        self.children: List["TraceNode"] = []
        self.parent: Optional["TraceNode"] = None
        self.depth: int = 0
        self.excluded_by_batch_filter: bool = False

    def add_child(self, child: "TraceNode") -> None:
        child.parent = self
        self.children.append(child)


class ExecutionTreeParser:
    def __init__(self, md_file_path: str):
        self.file_path = Path(md_file_path)
        self.model: Optional[str] = None
        self.project: Optional[str] = None
        self.session_id: str = self.file_path.parent.name
        self.root: Optional[TraceNode] = None

    def _extract_metadata_from_path(self) -> None:
        parts = self.file_path.parts
        if "RESULTS" in parts:
            idx = parts.index("RESULTS")
            if idx + 2 < len(parts):
                self.model = parts[idx + 1]
                self.project = parts[idx + 2]

    @staticmethod
    def _parse_tokens(line: str) -> Optional[Dict[str, int]]:
        agg_pattern = r"\[∑ tokens: \((\d+)→(\d+) \[REASONING:(\d+), OUTPUT:(\d+)\], total: (\d+)\)"
        m = re.search(agg_pattern, line)
        if not m:
            llm_pattern = (
                r"\((\d+)→(\d+) \[REASONING:(\d+), OUTPUT:(\d+)\], total: (\d+)\)"
            )
            m = re.search(llm_pattern, line)
        if not m:
            return None
        return {
            "input": int(m.group(1)),
            "output": int(m.group(2)),
            "reasoning": int(m.group(3)),
            "result": int(m.group(4)),
            "total": int(m.group(5)),
        }

    @staticmethod
    def _parse_time(line: str) -> Optional[float]:
        m = re.search(r"time:\s*([\d.]+)(ms|s)", line)
        if m:
            val = float(m.group(1))
            return val / 1000.0 if m.group(2) == "ms" else val
        m = re.search(r"∑\s*time:\s*([\d.]+)(ms|s)", line)
        if m:
            val = float(m.group(1))
            return val / 1000.0 if m.group(2) == "ms" else val
        m = re.search(r"\[([\d.]+)(ms|s)\]", line)
        if m:
            val = float(m.group(1))
            return val / 1000.0 if m.group(2) == "ms" else val
        return None

    @staticmethod
    def _clean_content_line(line: str) -> str:
        clean = re.sub(r"^[│├└─\s]+", "", line).strip()
        if not clean:
            return ""
        clean = re.sub(r"^❌\s+", "", clean)
        clean = re.sub(r"\s*\(retry\s+\d+\)", "", clean)
        clean = re.sub(r"\s*\[RETRY\d+\]", "", clean)
        clean = re.sub(r"\s*\[[TRUNCATED]\]", "", clean)
        clean = re.sub(r"\s*\[ERROR:[^\]]*\]", "", clean)
        return clean.strip()

    @staticmethod
    def _parse_node_from_content(line: str, raw_line: str) -> Optional[TraceNode]:
        if not line:
            return None
        if line.startswith("[Task Created]"):
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode(
                "Task Created", "Task Created", time=time_val, raw_line=raw_line
            )
        if line.startswith("[Crew Created]"):
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode(
                "Crew Created", "Crew Created", time=time_val, raw_line=raw_line
            )
        if line.startswith("[SPAN]"):
            m = re.match(r"\[SPAN\]\s+([^\[]+)", line)
            name = m.group(1).strip() if m else "SPAN"
            tokens = ExecutionTreeParser._parse_tokens(line)
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode(
                "SPAN", name, time=time_val, tokens=tokens, raw_line=raw_line
            )
        if line.startswith("[Chain]"):
            m = re.match(r"\[Chain\]\s+([^\[]+)", line)
            name = m.group(1).strip() if m else "Chain"
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode("Chain", name, time=time_val, raw_line=raw_line)
        if line.startswith("[AGENT]"):
            m = re.match(r"\[AGENT\]\s+(.+?)(?:\s+\[|$)", line)
            name = m.group(1).strip() if m else "AGENT"
            tokens = ExecutionTreeParser._parse_tokens(line)
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode(
                "AGENT", name, time=time_val, tokens=tokens, raw_line=raw_line
            )
        if line.startswith("[Tool]"):
            m = re.match(r"\[Tool\]\s+([^\[]+?)(?:\s+\[|\s+@@@|$)", line)
            name = m.group(1).strip() if m else "Tool"
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode("Tool", name, time=time_val, raw_line=raw_line)
        if line.startswith("[LLM]"):
            m = re.match(r"\[LLM\]\s+([^\(\[]+)", line)
            name = m.group(1).strip() if m else "LLM"
            tokens = ExecutionTreeParser._parse_tokens(line)
            time_val = ExecutionTreeParser._parse_time(line)
            return TraceNode(
                "LLM", name, time=time_val, tokens=tokens, raw_line=raw_line
            )
        return None

    def parse(self) -> Optional[TraceNode]:
        if not self.file_path.exists():
            return None
        text = self.file_path.read_text(encoding="utf-8")
        m = re.search(r"## Execution Path Tree.*?```\n(.*?)```", text, re.DOTALL)
        if not m:
            return None
        block = m.group(1)
        stack: List[TraceNode] = []
        self.root = None
        for raw in block.splitlines():
            if not raw.strip():
                continue
            pm = re.match(r"^([│├└─\s]*)", raw)
            prefix = pm.group(1) if pm else ""
            depth = len(prefix)
            clean = self._clean_content_line(raw)
            node = self._parse_node_from_content(clean, raw)
            if node is None:
                continue
            node.depth = depth
            while stack and stack[-1].depth >= depth:
                stack.pop()
            if stack:
                stack[-1].add_child(node)
            else:
                if self.root is None:
                    self.root = node
            stack.append(node)
        self._extract_metadata_from_path()
        return self.root


def iter_nodes(root: TraceNode):
    stack = [root]
    while stack:
        node = stack.pop()
        yield node
        for ch in reversed(node.children):
            stack.append(ch)


def iter_subtree(root: TraceNode):
    stack = [root]
    while stack:
        node = stack.pop()
        yield node
        for ch in reversed(node.children):
            stack.append(ch)


def _mark_excluded_subtree(root: TraceNode) -> None:
    stack = [root]
    while stack:
        node = stack.pop()
        node.excluded_by_batch_filter = True
        for ch in node.children:
            stack.append(ch)


def _collect_write_chapter_attempt_nodes(
    root: TraceNode, parser: ExecutionTreeParser
) -> List[Dict[str, object]]:
    attempts: List[Dict[str, object]] = []
    model = parser.model or ""
    session_id = parser.session_id

    for node in iter_nodes(root):
        if node.type == "SPAN" and node.name == "write_chapters":
            write_node = node
            for ch in write_node.children:
                if ch.type == "Chain" and re.match(r"Crew_.*\.kickoff", ch.name):
                    crew = ch
                    raw = crew.raw_line
                    m_batch = re.search(r"📚BATCH(\d+)", raw)
                    batch_id = m_batch.group(1) if m_batch else "1"
                    is_business_retry = "BUSINESS-RETRY" in raw
                    m_title = re.search(r"\(([^()]*)\)\s*$", raw)
                    chapter_title = m_title.group(1).strip() if m_title else crew.name
                    time_s = crew.time if crew.time is not None else 0.0
                    attempts.append(
                        {
                            "model": model,
                            "session_id": session_id,
                            "batch_id": batch_id,
                            "chapter_title": chapter_title,
                            "attempt_time_s": float(time_s or 0.0),
                            "is_business_retry": is_business_retry,
                            "crew_node": crew,
                        }
                    )
    return attempts


def _apply_write_chapters_batch_filter(
    root: TraceNode, parser: ExecutionTreeParser
) -> None:
    attempts = _collect_write_chapter_attempt_nodes(root, parser)
    if not attempts:
        return

    per_chapter: Dict[Tuple[str, str, str, str], Dict[str, object]] = {}
    for att in attempts:
        key = (
            str(att["model"]),
            str(att["session_id"]),
            str(att["batch_id"]),
            str(att["chapter_title"]),
        )
        rec = per_chapter.setdefault(
            key,
            {
                "model": att["model"],
                "session_id": att["session_id"],
                "batch_id": att["batch_id"],
                "chapter_title": att["chapter_title"],
                "total_time_s": 0.0,
                "attempts": [],
            },
        )
        rec["total_time_s"] += float(att["attempt_time_s"])
        rec["attempts"].append(att)

    batches: Dict[Tuple[str, str, str], List[Dict[str, object]]] = defaultdict(list)
    for (_, _, _, _), rec in per_chapter.items():
        key_batch = (
            str(rec["model"]),
            str(rec["session_id"]),
            str(rec["batch_id"]),
        )
        batches[key_batch].append(rec)

    for _, chapters in batches.items():
        if not chapters:
            continue
        max_rec = max(chapters, key=lambda c: c["total_time_s"])
        for rec in chapters:
            if rec is max_rec:
                continue
            for att in rec["attempts"]:
                crew_node = att["crew_node"]
                _mark_excluded_subtree(crew_node)


def compute_retry_time(root: TraceNode) -> float:
    total = 0.0
    retry_pattern = re.compile(r"\(retry\s+\d+\)|\[RETRY\d+\]")
    for node in iter_nodes(root):
        if node.excluded_by_batch_filter:
            continue
        if node.time is None:
            continue
        if retry_pattern.search(node.raw_line):
            total += node.time
    return total


def compute_business_retry_time(root: TraceNode) -> float:
    total = 0.0
    retry_pattern = re.compile(r"\(retry\s+\d+\)|\[RETRY\d+\]")
    for node in iter_nodes(root):
        if node.excluded_by_batch_filter:
            continue
        if node.time is None:
            continue
        if "BUSINESS-RETRY" not in node.raw_line:
            continue
        under_retry = False
        p = node.parent
        while p is not None:
            if retry_pattern.search(p.raw_line):
                under_retry = True
                break
            p = p.parent
        if under_retry:
            continue
        p2 = node.parent
        parent_marked = False
        while p2 is not None:
            if "BUSINESS-RETRY" in p2.raw_line:
                parent_marked = True
                break
            p2 = p2.parent
        if parent_marked:
            continue
        total += node.time
    return total


def compute_llm_overhead_for_subtree(root: TraceNode) -> float:
    total = 0.0
    for node in iter_subtree(root):
        if node.excluded_by_batch_filter:
            continue
        if node.type == "LLM" and node.time is not None:
            total += node.time
    return total


def compute_tool_overhead_for_subtree(root: TraceNode) -> float:
    total = 0.0
    for node in iter_subtree(root):
        if node.excluded_by_batch_filter:
            continue
        if (
            node.type == "Tool"
            and node.time is not None
            and node.name.endswith("._use")
        ):
            total += node.time
    return total


def find_orchestrator(root: TraceNode) -> TraceNode:
    for node in iter_nodes(root):
        if node.type == "SPAN" and "orchestrator" in node.name:
            return node
    return root


def compute_llm_overhead(root: TraceNode) -> float:
    total = 0.0
    for node in iter_nodes(root):
        if node.excluded_by_batch_filter or node.time is None:
            continue
        if node.type == "LLM":
            total += node.time
    return total


def compute_tool_overhead(root: TraceNode) -> float:
    total = 0.0
    for node in iter_nodes(root):
        if node.excluded_by_batch_filter or node.time is None:
            continue
        if node.type == "Tool" and node.name.endswith("._use"):
            total += node.time
    return total


def compute_framework_overhead(root: TraceNode) -> float:
    total = 0.0

    orch = find_orchestrator(root)
    if orch.time is None:
        return 0.0

    crew_exec_nodes: List[TraceNode] = [
        ch
        for ch in orch.children
        if ch.type == "SPAN" and "crew_execution" in ch.name and ch.time is not None
    ]

    if crew_exec_nodes:
        sum_ce = sum(ch.time or 0.0 for ch in crew_exec_nodes)
        diff_orch = orch.time - sum_ce
        if diff_orch > 0:
            total += diff_orch

    for ce in crew_exec_nodes:
        children_time = sum(ch.time or 0.0 for ch in ce.children if ch.time is not None)
        diff = (ce.time or 0.0) - children_time
        if diff > 0:
            total += diff

    for node in iter_nodes(root):
        if node.excluded_by_batch_filter or node.time is None:
            continue
        if node.type == "Chain" and re.match(r"Crew_.*\.kickoff", node.name):
            children_time = sum(
                ch.time or 0.0 for ch in node.children if ch.time is not None
            )
            diff = node.time - children_time
            if diff > 0:
                total += diff

    return total


def analyze_file(path: Path) -> Optional[Dict[str, float]]:
    parser = ExecutionTreeParser(str(path))
    root = parser.parse()
    if root is None:
        return None

    _apply_write_chapters_batch_filter(root, parser)

    orch = find_orchestrator(root)
    total_time_s = orch.time if orch.time is not None else None
    if total_time_s is None or total_time_s <= 0:
        return None

    llm_s = compute_llm_overhead(root)
    tool_s = compute_tool_overhead(root)
    framework_s = compute_framework_overhead(root)
    retry_s = compute_retry_time(root)
    business_retry_s = compute_business_retry_time(root)

    classified_s = llm_s + tool_s + framework_s
    residual_s = total_time_s - classified_s

    llm_ratio = llm_s / total_time_s
    tool_ratio = tool_s / total_time_s
    framework_ratio = framework_s / total_time_s
    residual_ratio = residual_s / total_time_s
    retry_ratio = retry_s / total_time_s if total_time_s > 0 else 0.0
    business_retry_ratio = business_retry_s / total_time_s if total_time_s > 0 else 0.0

    def to_ms(x: float) -> int:
        return int(round(x * 1000.0))

    total_time = to_ms(total_time_s)
    llm = to_ms(llm_s)
    tool = to_ms(tool_s)
    framework = to_ms(framework_s)
    retry_time = to_ms(retry_s)
    business_retry_time = to_ms(business_retry_s)
    classified = llm + tool + framework
    residual = total_time - classified

    result: Dict[str, float] = {
        "model": parser.model or "",
        "project": parser.project or "",
        "session_id": parser.session_id,
        "orchestrator_time": total_time,
        "LLM_OVERHEAD": llm,
        "Tool_OVERHEAD": tool,
        "Framework_OVERHEAD": framework,
        "retry_time_ms": retry_time,
        "business_retry_time_ms": business_retry_time,
        "total_classified": classified,
        "residual": residual,
    }

    result.update(
        {
            "LLM_ratio": llm_ratio,
            "Tool_ratio": tool_ratio,
            "Framework_ratio": framework_ratio,
            "residual_ratio": residual_ratio,
            "retry_ratio_vs_orch": retry_ratio,
            "business_retry_ratio_vs_orch": business_retry_ratio,
        }
    )

    return result


def find_results_root() -> Path:
    p = Path(__file__).resolve()
    for parent in p.parents:
        if parent.name == "RESULTS":
            return parent
    return p.parent.parent.parent


def collect_execution_paths(results_dir: Path, project_name: str) -> List[Path]:
    paths: List[Path] = []
    for model_dir in results_dir.iterdir():
        if not model_dir.is_dir():
            continue
        proj_dir = model_dir / project_name / "test_results"
        if not proj_dir.exists():
            continue
        for session_dir in proj_dir.iterdir():
            if not session_dir.is_dir():
                continue
            ep = session_dir / "execution_path.md"
            if ep.exists():
                paths.append(ep)
    paths.sort()
    return paths


def write_model_summary(rows: List[Dict[str, float]], out_path: Path) -> None:
    agg = defaultdict(
        lambda: {
            "count": 0,
            "total_orchestrator_time": 0.0,
            "total_LLM_OVERHEAD": 0.0,
            "total_Tool_OVERHEAD": 0.0,
            "total_Framework_OVERHEAD": 0.0,
            "total_retry_time_ms": 0.0,
            "total_business_retry_time_ms": 0.0,
            "total_classified": 0.0,
            "total_residual": 0.0,
        }
    )

    for row in rows:
        model = str(row.get("model", ""))
        m = agg[model]
        m["count"] += 1
        m["total_orchestrator_time"] += float(row.get("orchestrator_time", 0.0))
        m["total_LLM_OVERHEAD"] += float(row.get("LLM_OVERHEAD", 0.0))
        m["total_Tool_OVERHEAD"] += float(row.get("Tool_OVERHEAD", 0.0))
        m["total_Framework_OVERHEAD"] += float(row.get("Framework_OVERHEAD", 0.0))
        m["total_retry_time_ms"] += float(row.get("retry_time_ms", 0.0))
        m["total_business_retry_time_ms"] += float(
            row.get("business_retry_time_ms", 0.0)
        )
        m["total_classified"] += float(row.get("total_classified", 0.0))
        m["total_residual"] += float(row.get("residual", 0.0))

    summary_rows: List[Dict[str, float]] = []

    for model, m in sorted(agg.items(), key=lambda kv: kv[0]):
        total_time = m["total_orchestrator_time"] or 1e-9

        llm = m["total_LLM_OVERHEAD"]
        tool = m["total_Tool_OVERHEAD"]
        framework = m["total_Framework_OVERHEAD"]
        residual = m["total_residual"]

        components_time = llm + tool + framework + residual
        denom = components_time or 1e-9

        llm_share = llm / denom
        tool_share = tool / denom
        framework_share = framework / denom
        residual_share = residual / denom

        sum_component_shares = llm_share + tool_share + framework_share + residual_share

        summary_rows.append(
            {
                "model": model,
                "count": m["count"],
                "total_orchestrator_time": total_time,
                "total_LLM_OVERHEAD": llm,
                "total_Tool_OVERHEAD": tool,
                "total_Framework_OVERHEAD": framework,
                "total_classified": m["total_classified"],
                "total_residual": residual,
                "total_components_time": components_time,
                "LLM_share": llm_share,
                "Tool_share": tool_share,
                "Framework_share": framework_share,
                "residual_share": residual_share,
                "sum_component_shares": sum_component_shares,
            }
        )

    if not summary_rows:
        return

    fieldnames = list(summary_rows[0].keys())
    with out_path.open("w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(summary_rows)


def write_retry_breakdown_summary_by_model(
    rows: List[Dict[str, float]], out_path: Path
) -> None:
    agg = defaultdict(
        lambda: {
            "count": 0,
            "total_orchestrator_time": 0.0,
            "total_retry_time_ms": 0.0,
            "total_business_retry_time_ms": 0.0,
        }
    )

    for row in rows:
        model = str(row.get("model", ""))
        m = agg[model]
        m["count"] += 1
        m["total_orchestrator_time"] += float(row.get("orchestrator_time", 0.0))
        m["total_retry_time_ms"] += float(row.get("retry_time_ms", 0.0))
        m["total_business_retry_time_ms"] += float(
            row.get("business_retry_time_ms", 0.0)
        )

    summary_rows: List[Dict[str, float]] = []
    for model, m in sorted(agg.items(), key=lambda kv: kv[0]):
        total_time = m["total_orchestrator_time"] or 1e-9
        retry_total = m["total_retry_time_ms"]
        business_retry_total = m["total_business_retry_time_ms"]
        retry_all_total = retry_total + business_retry_total
        retry_share_vs_orch = retry_total / total_time
        business_retry_share_vs_orch = business_retry_total / total_time
        retry_all_share_vs_orch = retry_all_total / total_time

        summary_rows.append(
            {
                "model": model,
                "count": m["count"],
                "total_orchestrator_time": total_time,
                "total_retry_time_ms": retry_total,
                "total_business_retry_time_ms": business_retry_total,
                "total_retry_all_ms": retry_all_total,
                "retry_share_vs_orch": retry_share_vs_orch,
                "business_retry_share_vs_orch": business_retry_share_vs_orch,
                "retry_all_share_vs_orch": retry_all_share_vs_orch,
            }
        )

    if not summary_rows:
        return

    fieldnames = list(summary_rows[0].keys())
    with out_path.open("w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(summary_rows)


def _normalize_crewai_agent_name(name: str) -> str:
    name = re.sub(r"\._execute_core\]?$", "", name)
    return name.strip()


def collect_agent_llm_tool_breakdown(exec_paths: List[Path]) -> List[Dict[str, float]]:
    agg = defaultdict(
        lambda: {
            "llm_s": 0.0,
            "tool_s": 0.0,
            "occurrences": 0,
        }
    )

    for ep in exec_paths:
        parser = ExecutionTreeParser(str(ep))
        root = parser.parse()
        if root is None:
            continue
        model = parser.model or ""

        for node in iter_nodes(root):
            if node.excluded_by_batch_filter:
                continue
            if node.type == "Chain" and re.match(r"Crew_.*\.kickoff", node.name):
                for ch in node.children:
                    if ch.type != "AGENT":
                        continue
                    framework = "CrewAI"
                    agent_name = _normalize_crewai_agent_name(ch.name)
                    llm_s = compute_llm_overhead_for_subtree(ch)
                    tool_s = compute_tool_overhead_for_subtree(ch)
                    if llm_s == 0.0 and tool_s == 0.0:
                        continue
                    key = (model, framework, agent_name)
                    m = agg[key]
                    m["llm_s"] += llm_s
                    m["tool_s"] += tool_s
                    m["occurrences"] += 1

    rows: List[Dict[str, float]] = []
    for (model, framework, agent_name), st in sorted(
        agg.items(), key=lambda kv: (kv[0][0], kv[0][1], kv[0][2])
    ):
        llm_ms = int(round(st["llm_s"] * 1000.0))
        tool_ms = int(round(st["tool_s"] * 1000.0))
        total_ms = llm_ms + tool_ms
        denom = total_ms or 1e-9
        rows.append(
            {
                "model": model,
                "framework": framework,
                "agent_name": agent_name,
                "occurrences": st["occurrences"],
                "total_llm_time_ms": llm_ms,
                "total_tool_time_ms": tool_ms,
                "total_agent_llm_tool_time_ms": total_ms,
                "llm_share_in_agent": llm_ms / denom,
                "tool_share_in_agent": tool_ms / denom,
            }
        )

    return rows


def main() -> None:
    results_dir = find_results_root()
    project_name = "BookWriter-MCP"
    exec_paths = collect_execution_paths(results_dir, project_name)
    rows: List[Dict[str, float]] = []

    for ep in exec_paths:
        metrics = analyze_file(ep)
        if metrics is not None:
            rows.append(metrics)

    out_dir = Path(__file__).resolve().parent
    per_run_path = out_dir / "performance_breakdown_summary.csv"
    per_model_path = out_dir / "performance_breakdown_summary_by_model.csv"
    agent_path = out_dir / "agent_llm_tool_breakdown_by_model.csv"
    retry_model_path = out_dir / "retry_breakdown_summary_by_model.csv"

    if rows:
        exclude_keys = {
            "retry_time_ms",
            "business_retry_time_ms",
            "retry_ratio_vs_orch",
            "business_retry_ratio_vs_orch",
        }
        fieldnames = [k for k in rows[0].keys() if k not in exclude_keys]
        with per_run_path.open("w", newline="", encoding="utf-8") as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames, extrasaction="ignore")
            writer.writeheader()
            writer.writerows(rows)

        write_model_summary(rows, per_model_path)

        write_retry_breakdown_summary_by_model(rows, retry_model_path)

        agent_rows = collect_agent_llm_tool_breakdown(exec_paths)
        if agent_rows:
            agent_fieldnames = list(agent_rows[0].keys())
            with agent_path.open("w", newline="", encoding="utf-8") as f:
                writer = csv.DictWriter(f, fieldnames=agent_fieldnames)
                writer.writeheader()
                writer.writerows(agent_rows)


if __name__ == "__main__":
    main()