placeholder/benchmarks/plan_model_bench.py

"""ASV benchmarks for Plan domain model validation and serialization.

Measures the performance of:
- Plan model construction (Pydantic validation)
- Plan.as_cli_dict() serialization
- ProjectLink alias validation
- PlanInvariant construction
- Phase transition validation via can_transition()
"""

from __future__ import annotations

import sys
from pathlib import Path

try:
    from cleveragents.domain.models.core.plan import (
        AutomationLevel,
        InvariantScope,
        NamespacedName,
        Plan,
        PlanIdentity,
        PlanInvariant,
        PlanPhase,
        ProcessingState,
        ProjectLink,
        can_transition,
    )
except ModuleNotFoundError:
    sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
    from cleveragents.domain.models.core.plan import (
        AutomationLevel,
        InvariantScope,
        NamespacedName,
        Plan,
        PlanIdentity,
        PlanInvariant,
        PlanPhase,
        ProcessingState,
        ProjectLink,
        can_transition,
    )


def _make_plan() -> Plan:
    """Create a fully-populated Plan for benchmarking."""
    return Plan(
        identity=PlanIdentity(plan_id="01ARZ3NDEKTSV4RRFFQ69G5FAV"),
        namespaced_name=NamespacedName(
            server=None, namespace="local", name="bench-plan"
        ),
        description="Benchmark plan for validation and serialization",
        action_name="local/bench-action",
        definition_of_done="All benchmarks pass",
        phase=PlanPhase.STRATEGIZE,
        state=ProcessingState.QUEUED,
        automation_level=AutomationLevel.REVIEW_BEFORE_APPLY,
        automation_profile_name="org/bench-profile",
        effective_profile_snapshot={
            "max_file_changes": 50,
            "require_tests": True,
        },
        project_links=[
            ProjectLink(project_name="local/project-a", alias="main"),
            ProjectLink(project_name="local/project-b", alias="lib", read_only=True),
        ],
        invariants=[
            PlanInvariant(
                text="Global invariant",
                scope=InvariantScope.GLOBAL,
                source_name="system",
            ),
            PlanInvariant(
                text="Project invariant",
                scope=InvariantScope.PROJECT,
                source_name="my-project",
            ),
            PlanInvariant(
                text="Plan invariant",
                scope=InvariantScope.PLAN,
                source_name=None,
            ),
        ],
        strategy_actor="openai/gpt-4",
        execution_actor="openai/gpt-4",
        created_by="bench-user",
        tags=["benchmark", "test"],
        reusable=True,
        read_only=False,
    )


class PlanValidationSuite:
    """Benchmark Plan model construction (Pydantic validation)."""

    def time_plan_construction(self) -> None:
        """Benchmark creating a fully-populated Plan object."""
        _make_plan()

    def time_plan_minimal_construction(self) -> None:
        """Benchmark creating a minimal Plan object."""
        Plan(
            identity=PlanIdentity(plan_id="01ARZ3NDEKTSV4RRFFQ69G5FAV"),
            namespaced_name=NamespacedName(
                server=None, namespace="local", name="min-plan"
            ),
            description="Minimal plan",
            action_name="local/min-action",
            phase=PlanPhase.STRATEGIZE,
            state=ProcessingState.QUEUED,
        )

    def time_project_link_with_alias(self) -> None:
        """Benchmark ProjectLink construction with alias validation."""
        ProjectLink(
            project_name="local/my-project",
            alias="my-alias",
            read_only=False,
        )

    def time_plan_invariant_construction(self) -> None:
        """Benchmark PlanInvariant construction with text validation."""
        PlanInvariant(
            text="No secrets in code",
            scope=InvariantScope.GLOBAL,
            source_name="system",
        )


class PlanSerializationSuite:
    """Benchmark Plan serialization methods."""

    def setup(self) -> None:
        """Create a plan for serialization benchmarks."""
        self.plan = _make_plan()

    def time_as_cli_dict(self) -> None:
        """Benchmark Plan.as_cli_dict() ordered dict generation."""
        self.plan.as_cli_dict()

    def time_model_dump(self) -> None:
        """Benchmark Pydantic model_dump() serialization."""
        self.plan.model_dump()

    def time_model_dump_json(self) -> None:
        """Benchmark Pydantic model_dump_json() JSON serialization."""
        self.plan.model_dump_json()


class PhaseTransitionSuite:
    """Benchmark phase transition validation."""

    def time_valid_transition(self) -> None:
        """Benchmark checking a valid phase transition."""
        can_transition(PlanPhase.STRATEGIZE, PlanPhase.EXECUTE)

    def time_invalid_transition(self) -> None:
        """Benchmark checking an invalid phase transition."""
        can_transition(PlanPhase.STRATEGIZE, PlanPhase.APPLY)

    def time_all_transitions(self) -> None:
        """Benchmark checking all possible phase transitions."""
        phases = list(PlanPhase)
        for from_phase in phases:
            for to_phase in phases:
                can_transition(from_phase, to_phase)