novacode-cli 1.2.0__py3-none-any.whl

novacode_cli/context/strategies.py

@@ -0,0 +1,279 @@
+"""The two cheap context strategies that run before an automatic compaction.
+
+Nova shrinks a long conversation in three steps, cheapest first:
+
+1. **Snip** (:func:`snip_history`) drops zombie messages and stale markers:
+   empty assistant turns, repeated copies of the same internal-context note, file
+   reads superseded by a later read of the same range, and to-do lists replaced
+   by a later one. Nothing the model still needs is lost: the newer copy stays.
+2. **Collapse** (:func:`collapse_turns`) restructures completed turns before a
+   boundary: each keeps the user's message and the turn's final answer verbatim,
+   and its tool loop becomes one digest line per call, with every large result
+   saved to ``/cleared/`` so ``read_file`` can bring it back.
+3. **Auto-compact** (``agents/context_compaction.py``) summarizes with a model
+   call, only if the first two were not enough.
+
+Both are request-local views, never edits to state: checkpoints, ``/rewind``,
+``/tree`` and resume see the full history. Both leave the current turn alone
+(everything from the latest user message on), so a running agent's working set
+is never edited mid-run, and they only change at a turn boundary, which keeps
+the provider's prompt cache stable within a run.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+
+from novacode_cli.core.streaming import is_internal_context_text
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+    from langchain_core.messages import AnyMessage
+
+#: Completed turns kept verbatim at the end (the current one is always kept).
+KEEP_TURNS = 3
+#: Collapse once the request reaches this share of the window (auto-compact is ~0.82).
+COLLAPSE_AT = 0.6
+#: Results at least this long are saved to /cleared/ when collapsed.
+OFFLOAD_CHARS = 400
+#: Digest lines per collapsed turn before "… N more".
+DIGEST_LINES = 40
+
+SUMMARY_SOURCE = "summarization"
+
+
+@dataclass
+class StrategyReport:
+    """What a strategy removed from the request, for /context."""
+
+    messages: int = 0
+    chars: int = 0
+    turns: int = 0
+    kinds: dict[str, int] = field(default_factory=dict)
+
+    def add(self, kind: str, chars: int, messages: int = 0) -> None:
+        """Count one snip or collapse."""
+        self.kinds[kind] = self.kinds.get(kind, 0) + 1
+        self.chars += max(0, chars)
+        self.messages += messages
+
+
+def _text(message: AnyMessage) -> str:
+    content = message.content
+    if isinstance(content, str):
+        return content
+    parts = []
+    for block in content or []:
+        if isinstance(block, str):
+            parts.append(block)
+        elif isinstance(block, dict) and block.get("type") == "text":
+            parts.append(str(block.get("text", "")))
+    return "\n".join(parts)
+
+
+def is_user_turn(message: AnyMessage) -> bool:
+    """A message the user typed, not an injected note or a summary."""
+    if not isinstance(message, HumanMessage):
+        return False
+    if (message.additional_kwargs or {}).get("lc_source"):
+        return False
+    return not is_internal_context_text(_text(message))
+
+
+def current_turn_start(messages: Sequence[AnyMessage]) -> int:
+    """Index of the latest user message; everything from here is the live turn."""
+    for index in range(len(messages) - 1, -1, -1):
+        if is_user_turn(messages[index]):
+            return index
+    return len(messages)
+
+
+def _read_key(call: dict[str, Any]) -> str:
+    args = call.get("args") or {}
+    path = args.get("file_path") or args.get("path") or ""
+    return json.dumps([path, args.get("offset"), args.get("limit")])
+
+
+def snip_history(  # noqa: PLR0912 - one branch per kind of zombie
+    messages: Sequence[AnyMessage],
+) -> tuple[list[AnyMessage], StrategyReport]:
+    """Drop zombies and stale markers from the history before the current turn."""
+    report = StrategyReport()
+    end = current_turn_start(messages)
+    calls: dict[str, dict[str, Any]] = {}
+    for message in messages:
+        if isinstance(message, AIMessage):
+            for call in message.tool_calls or []:
+                calls[call.get("id") or ""] = call
+
+    # Newest occurrence of each read range / internal note / to-do list wins.
+    latest_read: dict[str, int] = {}
+    latest_note: dict[str, int] = {}
+    latest_todos = -1
+    for index, message in enumerate(messages):
+        if isinstance(message, ToolMessage) and message.status != "error":
+            call = calls.get(message.tool_call_id) or {}
+            if message.name == "read_file":
+                latest_read[_read_key(call)] = index
+            elif message.name == "write_todos":
+                latest_todos = index
+        elif isinstance(message, HumanMessage) and not is_user_turn(message):
+            if (message.additional_kwargs or {}).get("lc_source") != SUMMARY_SOURCE:
+                latest_note[_text(message)] = index
+
+    out: list[AnyMessage] = []
+    for index, message in enumerate(messages):
+        if index >= end:
+            out.append(message)
+            continue
+        if isinstance(message, AIMessage) and not message.tool_calls and not _text(message).strip():
+            report.add("empty assistant message", 0, messages=1)
+            continue
+        if isinstance(message, HumanMessage) and not is_user_turn(message):
+            text = _text(message)
+            if latest_note.get(text, index) != index:
+                report.add("repeated internal note", len(text), messages=1)
+                continue
+        if isinstance(message, ToolMessage) and message.status != "error":
+            call = calls.get(message.tool_call_id) or {}
+            if message.name == "read_file" and latest_read.get(_read_key(call), index) != index:
+                path = (call.get("args") or {}).get("file_path") or "this file"
+                stub = (
+                    f"[Superseded read of {path}: a later read in this conversation "
+                    "has the current contents.]"
+                )
+                report.add("superseded file read", len(_text(message)) - len(stub))
+                out.append(message.model_copy(update={"content": stub}))
+                continue
+            if message.name == "write_todos" and index != latest_todos:
+                stub = "[Superseded to-do list: a later write_todos holds the current one.]"
+                report.add("superseded to-do list", len(_text(message)) - len(stub))
+                out.append(message.model_copy(update={"content": stub}))
+                continue
+        out.append(message)
+    return out, report
+
+
+def _one_line(text: str, limit: int = 100) -> str:
+    line = " ".join(text.split())
+    return line if len(line) <= limit else line[: limit - 1] + "…"
+
+
+def _call_label(call: dict[str, Any]) -> str:
+    args = call.get("args") or {}
+    target = (
+        args.get("file_path")
+        or args.get("path")
+        or args.get("command")
+        or args.get("pattern")
+        or args.get("query")
+        or next((v for v in args.values() if isinstance(v, str)), "")
+    )
+    return f"{call.get('name', 'tool')} {_one_line(str(target), 80)}".strip()
+
+
+def collapse_boundary(messages: Sequence[AnyMessage], keep_turns: int = KEEP_TURNS) -> str | None:
+    """Id of the user message that starts the oldest kept turn, or None."""
+    starts = [i for i, m in enumerate(messages) if is_user_turn(m)]
+    if len(starts) <= keep_turns:
+        return None
+    return messages[starts[-keep_turns]].id
+
+
+def collapse_turns(
+    messages: Sequence[AnyMessage],
+    boundary_id: str | None,
+    save: Callable[[str, str | None, str], str | None] | None = None,
+) -> tuple[list[AnyMessage], StrategyReport]:
+    """Restructure the completed turns before ``boundary_id`` into digests.
+
+    ``save(call_id, tool_name, text)`` stores a large result and returns the
+    placeholder naming where it went (``None`` when it could not be saved).
+    """
+    report = StrategyReport()
+    end = next((i for i, m in enumerate(messages) if boundary_id and m.id == boundary_id), None)
+    if end is None:  # no boundary, or it was summarized away
+        return list(messages), report
+    end = min(end, current_turn_start(messages))
+
+    out: list[AnyMessage] = []
+    index = 0
+    while index < end:
+        message = messages[index]
+        if not is_user_turn(message):
+            out.append(message)
+            index += 1
+            continue
+        stop = next((j for j in range(index + 1, end) if is_user_turn(messages[j])), end)
+        out.extend(_collapse_turn(list(messages[index:stop]), save, report))
+        index = stop
+    out.extend(messages[end:])
+    return out, report
+
+
+def _collapse_turn(
+    turn: list[AnyMessage],
+    save: Callable[[str, str | None, str], str | None] | None,
+    report: StrategyReport,
+) -> list[AnyMessage]:
+    """One completed turn: its user messages, one digest, its final answer."""
+    loop = [
+        m for m in turn if isinstance(m, ToolMessage) or (isinstance(m, AIMessage) and m.tool_calls)
+    ]
+    if not loop:
+        return turn
+    calls: dict[str, dict[str, Any]] = {}
+    for message in loop:
+        if isinstance(message, AIMessage):
+            for call in message.tool_calls or []:
+                calls[call.get("id") or ""] = call
+    lines: list[str] = []
+    for message in loop:
+        if isinstance(message, AIMessage):
+            note = _text(message).strip()
+            if note:
+                lines.append(f"- note: {_one_line(note, 160)}")
+            continue
+        call = calls.get(message.tool_call_id) or {"name": message.name}
+        text = _text(message)
+        outcome = "failed" if message.status == "error" else f"{len(text.splitlines())} lines"
+        where = (
+            save(message.tool_call_id, message.name, text)
+            if save and len(text) >= OFFLOAD_CHARS
+            else None
+        )
+        tail = (
+            f" (saved: {where})" if where else f": {_one_line(text, 120)}" if text.strip() else ""
+        )
+        lines.append(f"- {_call_label(call)} → {outcome}{tail}")
+    shown = lines[:DIGEST_LINES]
+    if len(lines) > DIGEST_LINES:
+        shown.append(f"- … {len(lines) - DIGEST_LINES} more steps")
+    digest = (
+        f"[Collapsed earlier work: {sum(isinstance(m, ToolMessage) for m in loop)} tool calls. "
+        "Saved results can be read back with read_file.]\n" + "\n".join(shown)
+    )
+
+    in_loop = {id(m) for m in loop}
+    kept = [m for m in turn if id(m) not in in_loop]
+    before = sum(
+        len(_text(m)) + len(json.dumps(getattr(m, "tool_calls", None) or [])) for m in loop
+    )
+    answer = next((m for m in reversed(kept) if isinstance(m, AIMessage)), None)
+    out: list[AnyMessage] = []
+    for message in kept:
+        if message is answer:
+            # One assistant message: digest first, then the turn's answer.
+            out.append(AIMessage(content=f"{digest}\n\n{_text(answer)}", id=answer.id))
+        else:
+            out.append(message)
+    if answer is None:
+        out.insert(1 if out else 0, AIMessage(content=digest))
+    report.turns += 1
+    report.add("collapsed turn", before - len(digest), messages=len(loop))
+    return out

novacode_cli/context/task_progress.py

@@ -0,0 +1,122 @@
+"""Evidence-backed task progress carried by both compaction paths."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, ToolMessage
+
+from novacode_cli.core.streaming import is_internal_context_text
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+MAX_ACTIONS = 4
+MAX_TEXT = 120
+
+
+def _short(value: Any) -> str:  # noqa: ANN401 - tool arguments have arbitrary schemas
+    text = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, default=str)
+    return " ".join(text.split())[:MAX_TEXT]
+
+
+def _prior(messages: Sequence[BaseMessage]) -> dict[str, Any]:
+    for message in reversed(messages):
+        if isinstance(message, HumanMessage):
+            record = message.additional_kwargs.get("nova_task_progress")
+            if isinstance(record, dict) and record.get("version") == 1:
+                return record
+    return {}
+
+
+def task_progress(
+    messages: Sequence[BaseMessage],
+    todos: object = None,
+    *,
+    completed_head: int | None = None,
+) -> dict[str, Any]:
+    """Record observed actions and agent-reported todo state for the latest request.
+
+    ``completed_head`` limits tool evidence to messages included in the summary.
+    A verbatim tail remains authoritative and needs no duplicate action record.
+    """
+    prior = _prior(messages)
+    latest_request = -1
+    task = prior.get("task", "unknown")
+    for index, message in enumerate(messages):
+        if isinstance(message, HumanMessage) and not message.additional_kwargs.get("lc_source"):
+            content = message.content
+            value = content if isinstance(content, str) else str(content)
+            if value and not is_internal_context_text(value):
+                latest_request, task = index, _short(value)
+
+    same_task = latest_request < 0
+    actions = list(prior.get("completed_actions", [])) if same_task else []
+    prior_action_count = len(actions)
+    seen = {item.get("id") for item in actions if isinstance(item, dict)}
+    end = len(messages) if completed_head is None else completed_head
+    results = {
+        message.tool_call_id: message
+        for message in messages[:end]
+        if isinstance(message, ToolMessage)
+    }
+    todo_written = False
+    for message in messages[max(0, latest_request + 1) : end]:
+        if not isinstance(message, AIMessage):
+            continue
+        for call in message.tool_calls or []:
+            if call.get("name") == "write_todos":
+                todo_written = True
+            call_id = call.get("id")
+            result = results.get(call_id)
+            if result is None or call_id in seen or call.get("name") == "write_todos":
+                continue
+            actions.append(
+                {
+                    "id": _short(call_id),
+                    "tool": _short(call.get("name", "unknown")),
+                    "args": _short(call.get("args") or {}),
+                    "outcome": "error" if result.status == "error" else "returned",
+                    "result": _short(result.content),
+                }
+            )
+            seen.add(call_id)
+
+    new_action = len(actions) > prior_action_count
+    valid_todos = isinstance(todos, list) and (todo_written or (same_task and not new_action))
+    if valid_todos:
+        reported = [
+            _short(item.get("content", ""))
+            for item in todos
+            if isinstance(item, dict) and item.get("status") == "completed"
+        ]
+        pending = next(
+            (
+                _short(item.get("content", ""))
+                for item in todos
+                if isinstance(item, dict) and item.get("status") in {"pending", "in_progress"}
+            ),
+            "unknown",
+        )
+    elif same_task:
+        reported = list(prior.get("reported_completed_todos", []))
+        pending = "unknown" if new_action else prior.get("next_action", "unknown")
+    else:
+        reported, pending = [], "unknown"
+
+    return {
+        "version": 1,
+        "task": task,
+        "completed_actions": actions[-MAX_ACTIONS:],
+        "reported_completed_todos": reported[-MAX_ACTIONS:],
+        "next_action": pending,
+    }
+
+
+def render_task_progress(record: dict[str, Any]) -> str:
+    """Expose the structured record to the model without upgrading claims."""
+    return "## Task progress (observed tool results; todos are agent-reported)\n" + json.dumps(
+        record, ensure_ascii=False, separators=(",", ":")
+    )