# 冲刺契约示例
sprint_contract = {
    "sprint_id": "sprint-3",
    "scope": "关卡编辑器核心功能",
    "definition_of_done": [
        "矩形填充工具允许通过点击拖动填充矩形区域",
        "用户可以选择并删除已放置的实体生成点",
        "用户可以通过 API 重新排序动画帧",
        # ... 共 27 项验收标准
    ],
    "test_method": "Playwright 自动化交互测试",
    "pass_threshold": "所有标准必须通过"
}

class PreCompletionChecklistMiddleware:
    """在智能体退出前强制执行验证检查清单"""

    def __init__(self, checklist: list[str]):
        self.checklist = checklist

    def on_before_exit(self, agent_state: AgentState) -> AgentState:
        """拦截退出，注入验证提醒"""
        if not agent_state.all_checks_passed:
            reminder = self._build_reminder(agent_state)
            agent_state.inject_context(reminder)
            agent_state.prevent_exit()  # 阻止退出
        return agent_state

    def _build_reminder(self, state: AgentState) -> str:
        unchecked = [
            item for item in self.checklist 
            if not state.is_verified(item)
        ]
        return (
            f"⚠️ 在退出前，请确保完成以下验证：\n"
            + "\n".join(f"  - [ ] {item}" for item in unchecked)
        )

class LoopDetectionMiddleware:
    """检测并打破智能体的死循环"""

    def __init__(self, max_edits_per_file: int = 5):
        self.max_edits = max_edits_per_file
        self.edit_counts: dict[str, int] = {}

    def on_tool_call(self, tool_name: str, params: dict) -> str | None:
        if tool_name in ("write_file", "edit_file"):
            filepath = params.get("path", "")
            self.edit_counts[filepath] = self.edit_counts.get(filepath, 0) + 1

            if self.edit_counts[filepath] >= self.max_edits:
                return (
                    f"⚠️ 你已经对 {filepath} 编辑了 {self.edit_counts[filepath]} 次。"
                    f"请考虑重新审视你的方法，尝试完全不同的解决方案。"
                )
        return None  # 不注入额外上下文

@dataclass
class HandoffPacket:
    """智能体间结构化交接包"""
    # 任务信息
    current_subproblem: str       # 当前要解决的子问题
    boundary: str                 # 子问题的边界和非目标

    # 输入材料
    input_materials: list[str]    # 可用输入材料
    reference_only: list[str]     # 仅参考的材料

    # 输出要求
    expected_output: str          # 输出应该长什么样
    stop_condition: str           # 什么时候停止

    # 引用方式
    result_format: str            # 返回原文片段、链接还是 artifact ID

class WorkingMemory:
    """动态工作记忆管理"""

    def __init__(
        self, 
        keep_latest_n: int = 3,
        max_chars: int = 8000
    ):
        self.memories: list[MemoryEntry] = []
        self.keep_latest_n = keep_latest_n
        self.max_chars = max_chars
        self.summary = ""

    def add_memory(
        self, 
        step: int, 
        tool_name: str, 
        parameters: dict, 
        result: Any
    ):
        """添加执行记录（写入前先压缩）"""
        self.memories.append(MemoryEntry(
            step=step,
            tool_call=MemoryToolCall(
                tool_name=tool_name,
                parameters=compact_for_memory(parameters),
            ),
            result=prepare_memory_result(tool_name, parameters, result),
        ))

    def get_prompt_context(
        self, 
        view: str = "generator"
    ) -> str:
        """为不同角色渲染不同视图"""
        if view == "planner":
            return self._render_planner_view()
        elif view == "generator":
            return self._render_generator_view()
        elif view == "validation":
            return self._render_validation_view()

    def compact_old_memories(self) -> bool:
        """超过阈值时将较早记录压成摘要"""
        if self.total_chars() > self.max_chars:
            old = self.memories[:-self.keep_latest_n]
            self.summary = summarize(old)
            self.memories = self.memories[-self.keep_latest_n:]
            return True
        return False

# 简化的三层循环伪代码
class MiniMasterLoop:
    def run(self, user_input: str):
        # 第一层：Planner-Agent（全局调度）
        plan_action = self.planner.decide(user_input)

        if plan_action.type == "respond_to_user":
            return plan_action.response
        elif plan_action.type == "init_tasks":
            tasks = self.planner.create_tasks(plan_action)
        elif plan_action.type == "subagent_tool":
            # 第二层：Executor-Agent（执行者）
            for task in tasks.pending:
                conclusion = self.executor.execute(task)

                # 第三层：Validator-Agent（评估者）
                validation = self.validator.validate(
                    task=task,
                    conclusion=conclusion,
                    checklist=task.done_when
                )

                if validation.result == "有效":
                    task.mark_done()
                else:
                    task.mark_failed(validation.feedback)

# 各角色的工具权限
PLANNER_TOOLS = ["read", "glob", "grep"]  # 只能侦察
PLANNER_ACTIONS = [
    "init_tasks", "add_task", "split_task", 
    "retry_task", "subagent_tool", "respond_to_user"
]

EXECUTOR_TOOLS = ["bash", "read", "write", "edit", "glob", "grep"]
EXECUTOR_ACTIONS = ["update_task_conclusion"]

VALIDATOR_TOOLS = ["bash", "read", "glob", "grep"]  # 只能核查
VALIDATOR_ACTIONS = ["validate_tool"]  # 必须通过此工具输出结论

# 任务状态迁移的受控约束
VALID_TRANSITIONS = {
    "PENDING": ["RUNNING"],
    "RUNNING": ["DONE", "FAILED", "BLOCKED"],
    "FAILED": ["PENDING"],   # 只能通过 retry_task 恢复
    "BLOCKED": ["PENDING"],  # 只能通过 retry_task 恢复
    "DONE": [],              # 终态
}

class StateMachine:
    def transition(self, task: Task, new_state: str, actor: str):
        """受控状态迁移"""
        if new_state not in VALID_TRANSITIONS[task.state]:
            raise InvalidTransition(
                f"{actor} 不能将任务从 {task.state} 转为 {new_state}"
            )
        task.state = new_state

import anthropic

client = anthropic.Anthropic()

def generator(task: str, feedback: str = "") -> str:
    """生成器：根据任务和反馈生成代码"""
    prompt = f"请完成以下任务：{task}"
    if feedback:
        prompt += f"\n\n之前的尝试收到以下反馈，请改进：\n{feedback}"

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.content[0].text

def validator(task: str, code: str) -> tuple[bool, str]:
    """验证器：独立评估生成的代码"""
    prompt = f"""你是一个严格的代码审查员。
任务要求：{task}

请审查以下代码，判断是否满足任务要求。
必须指出具体的问题，不要笼统地说"看起来不错"。

代码：

from dataclasses import dataclass, field
from typing import Any

@dataclass
class MemoryEntry:
    step: int
    tool_name: str
    action: str
    result: str
    chars: int = 0

class SimpleWorkingMemory:
    def __init__(self, max_chars: int = 4000, keep_latest: int = 3):
        self.entries: list[MemoryEntry] = []
        self.max_chars = max_chars
        self.keep_latest = keep_latest
        self.summary = ""

    def add(self, step: int, tool_name: str, action: str, result: str):
        """添加记录"""
        # TODO: 实现添加逻辑
        pass

    def get_planner_view(self) -> str:
        """规划者视图：只看结论和状态"""
        # TODO: 实现规划者视图
        pass

    def get_executor_view(self) -> str:
        """执行者视图：看最近几步的完整记录"""
        # TODO: 实现执行者视图
        pass

    def compact(self) -> bool:
        """压缩旧记录为摘要"""
        # TODO: 实现压缩逻辑
        pass