yycode 0.3.2__py3-none-any.whl

agent/task_memory.py

@@ -0,0 +1,340 @@
+"""Deterministic task summary memory for long-running sessions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+
+from langchain_core.messages import BaseMessage, HumanMessage
+
+
+SUMMARY_MARKER = "[Task Summary Memory]"
+SUMMARY_CONTEXT_POLICY = "summary_memory"
+MERGED_SUMMARY_SOURCE = "automatic_merge"
+MAX_MERGED_ITEMS_PER_SECTION = 24
+
+
+@dataclass(frozen=True)
+class TaskSummaryMemory:
+    """A structured summary message for completed task context."""
+
+    content: str
+    covered_start_index: int
+    covered_end_index: int
+    source: str = "automatic"
+
+    def to_message(self) -> HumanMessage:
+        """Return a provider-safe message containing the summary memory."""
+        message = HumanMessage(content=self.content)
+        message.additional_kwargs.update(
+            {
+                "context_policy": SUMMARY_CONTEXT_POLICY,
+                "summary_memory": True,
+                "covered_start_index": self.covered_start_index,
+                "covered_end_index": self.covered_end_index,
+                "source": self.source,
+            }
+        )
+        return message
+
+
+class TaskSummaryMemoryBuilder:
+    """Build deterministic task summary memory from Task State facts."""
+
+    def __init__(self, *, min_messages: int = 8) -> None:
+        self.min_messages = min_messages
+
+    def should_summarize(
+        self,
+        messages: list[BaseMessage],
+        *,
+        start_index: int,
+        task_state: dict[str, Any],
+    ) -> bool:
+        """Return whether a completed task range is worth summarizing."""
+        if start_index >= len(messages):
+            return False
+        if _latest_summary_index(messages, start_index) is not None:
+            return False
+        if len(messages) - start_index >= self.min_messages:
+            return True
+        return _task_state_has_facts(task_state)
+
+    def build(
+        self,
+        messages: list[BaseMessage],
+        *,
+        start_index: int,
+        task_state: dict[str, Any],
+        source: str = "automatic",
+    ) -> TaskSummaryMemory:
+        """Build summary memory for a completed task range."""
+        end_index = max(len(messages) - 1, start_index)
+        memory = task_state.get("memory") or {}
+        items = task_state.get("items") or []
+        lines = [
+            SUMMARY_MARKER,
+            "scope: current_session",
+            f"source: {source}",
+            f"created_at: {_utc_now()}",
+            f"covered_messages: {start_index}-{end_index}",
+            "",
+        ]
+        _append_section(lines, "User Goal", _scalar_or_none(memory.get("user_goal")))
+        _append_list_section(lines, "Constraints", memory.get("constraints"))
+        _append_plan_section(lines, items)
+        _append_list_section(lines, "Decisions", memory.get("decisions"))
+        _append_files_section(
+            lines,
+            inspected=memory.get("files_inspected"),
+            modified=memory.get("files_modified"),
+        )
+        _append_list_section(lines, "Verification", memory.get("test_results"))
+        _append_list_section(lines, "Open Risks", memory.get("open_risks"))
+        _append_list_section(lines, "Next Steps", memory.get("next_steps"))
+        return TaskSummaryMemory(
+            content="\n".join(lines).rstrip() + "\n",
+            covered_start_index=start_index,
+            covered_end_index=end_index,
+            source=source,
+        )
+
+
+def is_task_summary_memory(message: BaseMessage) -> bool:
+    """Return whether a message is a task summary memory marker."""
+    additional_kwargs = getattr(message, "additional_kwargs", {}) or {}
+    if additional_kwargs.get("summary_memory") is True:
+        return True
+    content = getattr(message, "content", "")
+    return isinstance(content, str) and content.startswith(SUMMARY_MARKER)
+
+
+def build_merged_task_summary_memory(
+    messages: list[BaseMessage],
+    *,
+    covered_start_index: int = 0,
+    covered_end_index: int | None = None,
+    source: str = MERGED_SUMMARY_SOURCE,
+) -> TaskSummaryMemory:
+    """Merge old completed task summaries and requests into one compact memory."""
+    end_index = covered_end_index if covered_end_index is not None else max(len(messages) - 1, 0)
+    facts: dict[str, list[str]] = {
+        "previous_requests": [],
+        "constraints": [],
+        "current_plan": [],
+        "decisions": [],
+        "files_inspected": [],
+        "files_modified": [],
+        "verification": [],
+        "open_risks": [],
+        "next_steps": [],
+    }
+    for message in messages:
+        if is_task_summary_memory(message):
+            _merge_summary_sections(facts, _message_text(message))
+        elif isinstance(message, HumanMessage):
+            _append_unique(facts["previous_requests"], _preview(_message_text(message), 180))
+
+    lines = [
+        SUMMARY_MARKER,
+        "scope: current_session",
+        f"source: {source}",
+        f"created_at: {_utc_now()}",
+        f"covered_messages: {covered_start_index}-{end_index}",
+        "",
+        "## User Goal",
+        "Merged completed task history from earlier conversation.",
+        "",
+    ]
+    _append_list_section(lines, "Previous Requests", facts["previous_requests"])
+    _append_list_section(lines, "Constraints", facts["constraints"])
+    _append_list_section(lines, "Current Plan", facts["current_plan"])
+    _append_list_section(lines, "Decisions", facts["decisions"])
+    _append_files_section(
+        lines,
+        inspected=facts["files_inspected"],
+        modified=facts["files_modified"],
+    )
+    _append_list_section(lines, "Verification", facts["verification"])
+    _append_list_section(lines, "Open Risks", facts["open_risks"])
+    _append_list_section(lines, "Next Steps", facts["next_steps"])
+    return TaskSummaryMemory(
+        content="\n".join(lines).rstrip() + "\n",
+        covered_start_index=covered_start_index,
+        covered_end_index=end_index,
+        source=source,
+    )
+
+
+def _latest_summary_index(messages: list[BaseMessage], start_index: int) -> int | None:
+    for index, message in enumerate(messages[start_index:], start=start_index):
+        if is_task_summary_memory(message):
+            return index
+    return None
+
+
+def _merge_summary_sections(facts: dict[str, list[str]], content: str) -> None:
+    current = ""
+    file_mode = ""
+    for raw_line in content.splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        if line.startswith("## "):
+            current = line[3:].strip().lower()
+            file_mode = ""
+            continue
+        if line in {SUMMARY_MARKER} or ":" in line and current == "":
+            continue
+        if current == "user goal":
+            if line != "none recorded":
+                _append_unique(facts["previous_requests"], _preview(_strip_bullet(line), 180))
+        elif current == "constraints":
+            _append_fact(facts["constraints"], line)
+        elif current == "current plan":
+            _append_fact(facts["current_plan"], line)
+        elif current == "decisions":
+            _append_fact(facts["decisions"], line)
+        elif current == "files":
+            normalized = line.rstrip(":").lower()
+            if normalized == "inspected":
+                file_mode = "files_inspected"
+            elif normalized == "modified":
+                file_mode = "files_modified"
+            elif file_mode:
+                _append_fact(facts[file_mode], line)
+        elif current == "verification":
+            _append_fact(facts["verification"], line)
+        elif current == "open risks":
+            _append_fact(facts["open_risks"], line)
+        elif current == "next steps":
+            _append_fact(facts["next_steps"], line)
+
+
+def _append_fact(values: list[str], line: str) -> None:
+    value = _strip_bullet(line)
+    if value and value != "none recorded":
+        _append_unique(values, _preview(value, 220))
+
+
+def _append_unique(values: list[str], value: str) -> None:
+    normalized = " ".join(str(value or "").split())
+    if not normalized or normalized in values:
+        return
+    if len(values) >= MAX_MERGED_ITEMS_PER_SECTION:
+        return
+    values.append(normalized)
+
+
+def _strip_bullet(line: str) -> str:
+    text = line.strip()
+    return text[2:].strip() if text.startswith("- ") else text
+
+
+def _message_text(message: BaseMessage) -> str:
+    content = getattr(message, "content", "")
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "\n".join(str(item) for item in content)
+    return str(content)
+
+
+def _preview(text: str, limit: int) -> str:
+    value = " ".join(str(text or "").split())
+    if len(value) <= limit:
+        return value
+    return value[: max(0, limit - 3)] + "..."
+
+
+def _task_state_has_facts(task_state: dict[str, Any]) -> bool:
+    items = task_state.get("items")
+    if isinstance(items, list) and any(isinstance(item, dict) for item in items):
+        return True
+    memory = task_state.get("memory") or {}
+    if not isinstance(memory, dict):
+        return False
+    if _scalar_or_none(memory.get("user_goal")):
+        return True
+    for value in memory.values():
+        if isinstance(value, list) and any(str(item).strip() for item in value):
+            return True
+    return False
+
+
+def _append_section(lines: list[str], title: str, value: str | None) -> None:
+    lines.extend([f"## {title}", value or "none recorded", ""])
+
+
+def _append_list_section(lines: list[str], title: str, values: Any) -> None:
+    lines.append(f"## {title}")
+    normalized = _normalize_list(values)
+    if normalized:
+        lines.extend(f"- {value}" for value in normalized)
+    else:
+        lines.append("none recorded")
+    lines.append("")
+
+
+def _append_plan_section(lines: list[str], items: Any) -> None:
+    lines.append("## Current Plan")
+    if not isinstance(items, list) or not items:
+        lines.append("none recorded")
+        lines.append("")
+        return
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        status = str(item.get("status") or "pending").strip()
+        text = str(item.get("text") or "").strip()
+        item_id = str(item.get("id") or "").strip()
+        label = f"{status}: {text}" if text else status
+        if item_id:
+            label = f"[{item_id}] {label}"
+        lines.append(f"- {label}")
+    lines.append("")
+
+
+def _append_files_section(lines: list[str], *, inspected: Any, modified: Any) -> None:
+    lines.append("## Files")
+    inspected_values = _normalize_list(inspected)
+    modified_values = _normalize_list(modified)
+    lines.append("Inspected:")
+    if inspected_values:
+        lines.extend(f"- {value}" for value in inspected_values)
+    else:
+        lines.append("- none recorded")
+    lines.append("")
+    lines.append("Modified:")
+    if modified_values:
+        lines.extend(f"- {value}" for value in modified_values)
+    else:
+        lines.append("- none recorded")
+    lines.append("")
+
+
+def _normalize_list(values: Any) -> list[str]:
+    if values is None:
+        return []
+    if isinstance(values, str):
+        values = [values]
+    if not isinstance(values, list):
+        return []
+    normalized = []
+    for value in values:
+        text = str(value).strip()
+        if text:
+            normalized.append(text)
+    return normalized
+
+
+def _scalar_or_none(value: Any) -> str | None:
+    if not isinstance(value, str):
+        return None
+    normalized = value.strip()
+    return normalized or None
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")

agent/todo_manager.py

@@ -0,0 +1,304 @@
+"""TodoManager - Manages task state and tracking logic."""
+
+import logging
+from typing import List, Dict, Any, Optional, Callable
+
+logger = logging.getLogger(__name__)
+
+
+class TodoManager:
+    """Manages task state and provides the todo tool handler."""
+
+    MAX_ITEMS = 20  # Maximum allowed todo items
+    MEMORY_LIST_FIELDS = (
+        "constraints",
+        "files_inspected",
+        "files_modified",
+        "decisions",
+        "test_results",
+        "open_risks",
+        "next_steps",
+    )
+
+    def __init__(self):
+        self.todo_items: List[Dict[str, Any]] = []
+        self.memory: Dict[str, Any] = self._empty_memory()
+        self.consecutive_non_todo_rounds: int = 0
+        self.task_state_started: bool = False
+        self.task_completed: bool = False
+        self.completed_items: List[Dict[str, Any]] = []
+        self.last_incomplete_signature: Optional[tuple] = None
+        self.repeated_incomplete_updates: int = 0
+
+    def _empty_memory(self) -> Dict[str, Any]:
+        """Return an empty task memory shape."""
+        memory = {"user_goal": ""}
+        for field in self.MEMORY_LIST_FIELDS:
+            memory[field] = []
+        return memory
+
+    def get_items(self) -> List[Dict[str, Any]]:
+        """Get current todo items."""
+        return self.todo_items
+
+    def get_memory(self) -> Dict[str, Any]:
+        """Get current compact task memory."""
+        return {
+            key: list(value) if isinstance(value, list) else value
+            for key, value in self.memory.items()
+        }
+
+    def get_task_state(self) -> Dict[str, Any]:
+        """Get the complete task state."""
+        return {
+            "items": list(self.todo_items or self.completed_items),
+            "memory": self.get_memory(),
+        }
+
+    def set_items(self, items: List[Dict[str, Any]]) -> None:
+        """Set todo items and check if all are completed or over limit."""
+        # Check for maximum items limit
+        if len(items) > self.MAX_ITEMS:
+            logger.warning(f"Todo list exceeds maximum of {self.MAX_ITEMS} items. Truncated.")
+            items = items[:self.MAX_ITEMS]
+
+        signature = self._items_signature(items)
+        is_incomplete = bool(items) and not self._items_all_completed(items)
+        if is_incomplete and signature == self.last_incomplete_signature:
+            self.repeated_incomplete_updates += 1
+        else:
+            self.repeated_incomplete_updates = 0
+        self.last_incomplete_signature = signature if is_incomplete else None
+
+        self.todo_items = items
+        if items:
+            self.task_state_started = True
+            self.task_completed = False
+        # Check if all items are completed - if yes, clear the list
+        if items and self._all_completed():
+            self._clear_on_completion()
+
+    def set_memory(self, memory: Optional[Dict[str, Any]]) -> None:
+        """Merge compact task memory into the current state."""
+        if not memory:
+            return
+
+        user_goal = memory.get("user_goal")
+        if isinstance(user_goal, str) and user_goal.strip():
+            self.memory["user_goal"] = user_goal.strip()
+
+        for field in self.MEMORY_LIST_FIELDS:
+            values = memory.get(field)
+            if values is None:
+                continue
+            if isinstance(values, str):
+                values = [values]
+            if not isinstance(values, list):
+                continue
+            current = self.memory.setdefault(field, [])
+            for value in values:
+                if not isinstance(value, str):
+                    continue
+                normalized = value.strip()
+                if normalized and normalized not in current:
+                    current.append(normalized)
+
+    def _all_completed(self) -> bool:
+        """Check if all todo items are completed."""
+        return self._items_all_completed(self.todo_items)
+
+    def _items_all_completed(self, items: List[Dict[str, Any]]) -> bool:
+        """Check if all provided todo items are completed."""
+        if not items:
+            return False
+        return all(item.get("status") == "completed" for item in items)
+
+    def _items_signature(self, items: List[Dict[str, Any]]) -> tuple:
+        """Return a stable signature for detecting repeated incomplete updates."""
+        return tuple(
+            (
+                str(item.get("id", "")),
+                str(item.get("text", "")),
+                str(item.get("status", "")),
+            )
+            for item in items
+        )
+
+    def _clear_on_completion(self) -> None:
+        """Clear todo list when all items are completed."""
+        logger.info("All tasks completed! Todo list has been cleared.")
+        self.completed_items = list(self.todo_items)
+        self.todo_items = []
+        self.task_completed = True
+        self.consecutive_non_todo_rounds = 0
+
+    def reset(self) -> None:
+        """Reset todo state."""
+        self.todo_items = []
+        self.memory = self._empty_memory()
+        self.consecutive_non_todo_rounds = 0
+        self.task_state_started = False
+        self.task_completed = False
+        self.completed_items = []
+        self.last_incomplete_signature = None
+        self.repeated_incomplete_updates = 0
+
+    def clear(self) -> None:
+        """Explicitly clear todo list."""
+        self.todo_items = []
+        self.memory = self._empty_memory()
+        self.consecutive_non_todo_rounds = 0
+        self.task_state_started = False
+        self.task_completed = False
+        self.completed_items = []
+        self.last_incomplete_signature = None
+        self.repeated_incomplete_updates = 0
+
+    def prepare_for_new_input(self) -> None:
+        """Prepare for a new user input - clear previous tasks for new planning."""
+        if self.todo_items and not self._all_completed():
+            logger.info("Starting new task, previous todo list cleared.")
+        self.todo_items = []
+        self.memory = self._empty_memory()
+        self.consecutive_non_todo_rounds = 0
+        self.task_state_started = False
+        self.task_completed = False
+        self.completed_items = []
+        self.last_incomplete_signature = None
+        self.repeated_incomplete_updates = 0
+
+    def can_finish_task(self) -> bool:
+        """Return whether the current task may finish normally."""
+        return self.task_state_started and self.task_completed
+
+    def has_incomplete_task_state(self) -> bool:
+        """Return whether task state is missing or has unfinished items."""
+        return not self.can_finish_task()
+
+    def get_finish_blocker_message(self) -> str:
+        """Return a message that forces task state creation/completion before exit."""
+        if not self.task_state_started:
+            return (
+                "Task State is required before you can finish this user request. "
+                "Call todo now, even if the task only decomposes into one item. "
+                "Create a concise checklist and set exactly one item in_progress."
+            )
+        return (
+            "You cannot finish yet because Task State still has unfinished work. "
+            "Continue executing the remaining todo items. When all work and verification "
+            "are complete, call todo with every item marked completed so the task can exit."
+        )
+
+    def record_tool_call(self, tool_name: str) -> None:
+        """Record a tool call for tracking."""
+        if tool_name == "todo":
+            self.consecutive_non_todo_rounds = 0
+        else:
+            self.consecutive_non_todo_rounds += 1
+
+    def needs_reminder(self) -> bool:
+        """Check if todo reminder is needed (3 rounds without todo)."""
+        return self.consecutive_non_todo_rounds >= 3 and len(self.todo_items) > 0
+
+    def get_reminder_message(self) -> str:
+        """Get the reminder message with current task status."""
+        if not self.todo_items:
+            return ""
+
+        status_list = []
+        for item in self.todo_items:
+            status_icon = {
+                "pending": "[ ]",
+                "in_progress": "[~]",
+                "completed": "[X]",
+            }.get(item["status"], "[ ]")
+            status_list.append(f"{status_icon} [{item['id']}] {item['text']}")
+
+        task_status = "\n".join(status_list)
+        memory_status = self._format_memory()
+
+        return (f"\n\n[Reminder: You haven't updated your task list in "
+                f"{self.consecutive_non_todo_rounds} rounds. Current task state:\n"
+                f"{task_status}\n"
+                f"{memory_status}\n"
+                f"Consider using the todo tool to update progress and memory.]")
+
+    def consume_reminder_message(self) -> str:
+        """Return one reminder and reset the reminder counter."""
+        reminder = self.get_reminder_message()
+        if reminder:
+            self.consecutive_non_todo_rounds = 0
+        return reminder
+
+    def has_repeated_incomplete_update(self) -> bool:
+        """Return whether the same incomplete todo state was repeated."""
+        return self.repeated_incomplete_updates >= 1 and bool(self.todo_items)
+
+    def consume_repeated_incomplete_message(self) -> str:
+        """Return a no-progress warning and reset the repeated update counter."""
+        if not self.has_repeated_incomplete_update():
+            return ""
+        self.repeated_incomplete_updates = 0
+        return (
+            "Task State did not change: you repeated the same incomplete todo list. "
+            "Do not call todo again with the same in_progress item. Take the next concrete "
+            "action now, such as running a verification tool or inspecting the relevant "
+            "file. If the work is already verified or no further automated verification is "
+            "possible, call todo with all items marked completed and then provide the final answer."
+        )
+
+    def create_todo_handler(self) -> Callable:
+        """Create a todo handler bound to this manager."""
+        def todo(items, memory=None):
+            """Update task state and display current progress."""
+            submitted_items = list(items or [])
+            self.set_items(items)
+            self.set_memory(memory)
+
+            display_items = self.todo_items or submitted_items
+
+            result = []
+            result.append("Task State:")
+            result.append("-" * 40)
+
+            for item in display_items:
+                status_icon = {
+                    "pending": "[ ]",
+                    "in_progress": "[~]",
+                    "completed": "[X]",
+                }.get(item["status"], "[ ]")
+                result.append(f"{status_icon} [{item['id']}] {item['text']}")
+
+            if not self.todo_items and submitted_items:
+                result.append("All tasks completed! Todo list has been cleared.")
+
+            result.append("-" * 40)
+            memory_text = self._format_memory()
+            if memory_text:
+                result.append(memory_text)
+            output = "\n".join(result)
+            logger.info(f"Task state updated:\n{output}")
+            print(f"\n{output}\n")  # Keep for user interface
+            return output
+        return todo
+
+    def _format_memory(self) -> str:
+        """Format compact memory for reminders and tool output."""
+        lines = []
+        user_goal = self.memory.get("user_goal", "")
+        if user_goal:
+            lines.append(f"Goal: {user_goal}")
+        labels = {
+            "constraints": "Constraints",
+            "files_inspected": "Files inspected",
+            "files_modified": "Files modified",
+            "decisions": "Decisions",
+            "test_results": "Test results",
+            "open_risks": "Open risks",
+            "next_steps": "Next steps",
+        }
+        for field, label in labels.items():
+            values = self.memory.get(field, [])
+            if values:
+                lines.append(f"{label}: " + "; ".join(values))
+        return "\n".join(lines)