gigacrew 0.5.0__tar.gz

gigacrew-0.5.0/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 FolkiDevv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

gigacrew-0.5.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: gigacrew
+Version: 0.5.0
+Summary: Консольный помощник для работы с кодом проекта
+Keywords: cli,agent,llm,code,assistant,tree-sitter,lsp
+Author: FolkiDevv
+Author-email: FolkiDevv <hi@folki.dev>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.5
+Requires-Dist: rich>=13.0
+Requires-Dist: prompt-toolkit>=3.0.43
+Requires-Dist: ty==0.0.86
+Requires-Dist: tree-sitter~=0.26.0
+Requires-Dist: tree-sitter-python>=0.25
+Requires-Dist: tree-sitter-javascript>=0.25
+Requires-Dist: tree-sitter-typescript>=0.23.2
+Requires-Dist: tree-sitter-go>=0.25
+Requires-Dist: tree-sitter-rust>=0.24
+Requires-Dist: tree-sitter-java>=0.23.5
+Requires-Dist: tree-sitter-kotlin>=1.1
+Requires-Dist: tree-sitter-c-sharp>=0.23.5
+Requires-Dist: tree-sitter-ruby>=0.23.1
+Requires-Dist: tree-sitter-php>=0.25
+Requires-Dist: tree-sitter-c>=0.24
+Requires-Dist: tree-sitter-cpp>=0.23.4
+Requires-Dist: tree-sitter-bash>=0.25
+Requires-Dist: tree-sitter-scala>=0.26
+Requires-Dist: tree-sitter-swift>=0.7
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/FolkiDevv/gigacrew
+Project-URL: Repository, https://github.com/FolkiDevv/gigacrew
+Project-URL: Issues, https://github.com/FolkiDevv/gigacrew/issues
+Description-Content-Type: text/markdown
+
+# gigacrew
+
+Консольная утилита для работы с кодом локального проекта: навигация по исходникам, поиск, правка файлов и запуск команд в терминале.
+Перед запуском скопируйте `.env.example` в `.env` и укажите в нём адрес API, модель и реквизиты доступа — значений по умолчанию нет.
+
+## Установка
+
+```sh
+uv tool install gigacrew
+# или
+pipx install gigacrew
+```
+
+## Лицензия
+
+MIT, см. [LICENSE](LICENSE).

gigacrew-0.5.0/README.md

@@ -0,0 +1,16 @@
+# gigacrew
+
+Консольная утилита для работы с кодом локального проекта: навигация по исходникам, поиск, правка файлов и запуск команд в терминале.
+Перед запуском скопируйте `.env.example` в `.env` и укажите в нём адрес API, модель и реквизиты доступа — значений по умолчанию нет.
+
+## Установка
+
+```sh
+uv tool install gigacrew
+# или
+pipx install gigacrew
+```
+
+## Лицензия
+
+MIT, см. [LICENSE](LICENSE).

gigacrew-0.5.0/gigacrew/__init__.py

@@ -0,0 +1,3 @@
+"""gigacrew — консольный помощник для работы с кодом проекта."""
+
+__version__ = "0.5.0"

gigacrew-0.5.0/gigacrew/__main__.py

@@ -0,0 +1,4 @@
+from gigacrew.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gigacrew-0.5.0/gigacrew/agent/__init__.py

@@ -0,0 +1,7 @@
+"""Агентное ядро: цикл, история диалога, ограничители, события, промпты."""
+
+from gigacrew.agent.conversation import Conversation
+from gigacrew.agent.events import AgentEvents, ToolCallInfo, TurnStats
+from gigacrew.agent.loop import Agent
+
+__all__ = ["Agent", "AgentEvents", "Conversation", "ToolCallInfo", "TurnStats"]

gigacrew-0.5.0/gigacrew/agent/chat_store.py

@@ -0,0 +1,293 @@
+"""Сохранённые чаты: ``.gigacrew/chats/<id>.json``.
+
+Один файл на чат: метаданные (заголовок, время, модель) и диалог в формате
+:meth:`Conversation.to_dict`. Запись атомарная (временный файл + ``os.replace``),
+файл доступен только владельцу — в диалоге бывают секреты из вывода команд.
+
+:class:`ChatStore` — хранилище, :class:`ChatRecorder` — текущий чат сессии
+(автосохранение после хода, переключение по ``/resume``, новый чат по ``/clear``).
+Модуль не знает о UI: ошибки возвращаются текстом или исключением :class:`ChatStoreError`.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import secrets
+import tempfile
+from collections.abc import Iterable
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from gigacrew.agent.conversation import Conversation
+from gigacrew.llm.types import Message
+from gigacrew.project.workspace import Workspace
+
+TITLE_LIMIT = 60
+PREVIEW_LIMIT = 160
+_ID_RE = re.compile(r"^[0-9A-Za-z][0-9A-Za-z_-]*$")
+
+
+class ChatStoreError(Exception):
+    """Чат не найден, ссылка неоднозначна или файл повреждён."""
+
+
+@dataclass(frozen=True)
+class ChatInfo:
+    """Метаданные сохранённого чата (без самого диалога)."""
+
+    id: str
+    title: str
+    created_at: datetime
+    updated_at: datetime
+    model: str = ""
+    requests: int = 0  # запросов пользователя
+    preview: str = ""  # начало последнего ответа модели
+
+
+@dataclass(frozen=True)
+class SavedChat:
+    info: ChatInfo
+    conversation: Conversation
+
+
+def _now() -> datetime:
+    return datetime.now().astimezone().replace(microsecond=0)
+
+
+def _parse_time(value: str) -> datetime:
+    """Время из файла; без часового пояса (файл правили вручную) — считается местным.
+
+    Иначе наивное и aware-время нельзя было бы сравнить при сортировке списка чатов.
+    """
+    when = datetime.fromisoformat(value)
+    return when if when.tzinfo is not None else when.astimezone()
+
+
+def _one_line(text: str, limit: int) -> str:
+    line = " ".join(text.split())
+    return line if len(line) <= limit else line[: limit - 1].rstrip() + "…"
+
+
+def chat_title(messages: Iterable[Message]) -> str:
+    """Заголовок чата — первый запрос пользователя в одну строку."""
+    for m in messages:
+        if m.role == "user" and m.content.strip():
+            return _one_line(m.content, TITLE_LIMIT)
+    return "(без названия)"
+
+
+def _preview(messages: tuple[Message, ...]) -> str:
+    for m in reversed(messages):
+        if m.role == "assistant" and m.function_call is None and m.content.strip():
+            return _one_line(m.content, PREVIEW_LIMIT)
+    return ""
+
+
+class ChatStore:
+    FORMAT_VERSION = 1
+
+    def __init__(self, workspace: Workspace):
+        """Конструктор не трогает файловую систему."""
+        self._workspace = workspace
+
+    @property
+    def directory(self) -> Path:
+        return self._workspace.chats_dir
+
+    # ------------------------------------------------------------------ #
+    @staticmethod
+    def new_id(now: datetime | None = None) -> str:
+        """Id сортируется по времени создания; суффикс — от коллизий чатов одной секунды."""
+        return f"{(now or _now()):%Y%m%d-%H%M%S}-{secrets.token_hex(4)}"
+
+    def exists(self, chat_id: str) -> bool:
+        return self._path(chat_id).exists()
+
+    def _path(self, chat_id: str) -> Path:
+        if not _ID_RE.match(chat_id):
+            raise ChatStoreError(f"некорректный id чата: {chat_id!r}")
+        return self.directory / f"{chat_id}.json"
+
+    def save(
+        self,
+        chat_id: str,
+        conversation: Conversation,
+        *,
+        model: str = "",
+        created_at: datetime | None = None,
+    ) -> ChatInfo:
+        """Записывает чат (атомарно). Ошибки записи — ``OSError``."""
+        messages = conversation.messages
+        now = _now()
+        info = ChatInfo(
+            id=chat_id,
+            title=chat_title(messages),
+            created_at=created_at or now,
+            updated_at=now,
+            model=model,
+            requests=sum(1 for m in messages if m.role == "user"),
+            preview=_preview(messages),
+        )
+        data = {
+            "version": self.FORMAT_VERSION,
+            "id": info.id,
+            "title": info.title,
+            "created_at": info.created_at.isoformat(),
+            "updated_at": info.updated_at.isoformat(),
+            "model": info.model,
+            "requests": info.requests,
+            "preview": info.preview,
+            "conversation": conversation.to_dict(),
+        }
+        path = self._path(chat_id)
+        self._workspace.ensure_data_dir()
+        self.directory.mkdir(exist_ok=True)
+        # mkstemp создаёт файл с правами 0600 в том же каталоге — os.replace атомарен.
+        fd, tmp = tempfile.mkstemp(prefix=f".{chat_id}.", suffix=".tmp", dir=self.directory)
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                json.dump(data, f, ensure_ascii=False)
+            os.replace(tmp, path)
+        except BaseException:
+            Path(tmp).unlink(missing_ok=True)
+            raise
+        return info
+
+    # ------------------------------------------------------------------ #
+    def load(self, chat_id: str) -> SavedChat:
+        path = self._path(chat_id)
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except FileNotFoundError:
+            raise ChatStoreError(f"чат {chat_id} не найден") from None
+        except (OSError, ValueError) as e:
+            raise ChatStoreError(f"не удалось прочитать чат {chat_id}: {e}") from None
+        try:
+            info = self._info(data, chat_id)
+            raw = data["conversation"]
+            if not isinstance(raw, dict):
+                raise ValueError("поле conversation — не объект")
+            conversation = Conversation.from_dict(raw)
+        except (KeyError, TypeError, ValueError) as e:
+            raise ChatStoreError(f"файл чата {chat_id} повреждён: {e}") from None
+        conversation.repair()  # на случай файла, записанного посреди вызова инструмента
+        return SavedChat(info, conversation)
+
+    def _info(self, data: Any, chat_id: str) -> ChatInfo:
+        if not isinstance(data, dict) or data.get("version") != self.FORMAT_VERSION:
+            raise ValueError("неподдерживаемая версия формата")
+        return ChatInfo(
+            id=chat_id,
+            title=str(data.get("title") or "(без названия)"),
+            created_at=_parse_time(data["created_at"]),
+            updated_at=_parse_time(data["updated_at"]),
+            model=str(data.get("model") or ""),
+            requests=int(data.get("requests") or 0),
+            preview=str(data.get("preview") or ""),
+        )
+
+    def _files(self) -> list[Path]:
+        """Файлы чатов, свежие первыми (по времени изменения)."""
+        try:
+            files = [p for p in self.directory.glob("*.json") if _ID_RE.match(p.stem)]
+        except OSError:
+            return []
+        stamped = []
+        for p in files:
+            try:
+                stamped.append((p.stat().st_mtime, p))
+            except OSError:
+                continue
+        return [p for _, p in sorted(stamped, key=lambda x: (x[0], x[1].name), reverse=True)]
+
+    def recent(self, limit: int | None = 20) -> list[ChatInfo]:
+        """Последние чаты, свежие первыми. Битые файлы и чужие версии пропускаются."""
+        result: list[ChatInfo] = []
+        for path in self._files():
+            if limit is not None and len(result) >= limit:
+                break
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+                result.append(self._info(data, path.stem))
+            except (OSError, ValueError, KeyError, TypeError):
+                continue
+        result.sort(key=lambda info: info.updated_at, reverse=True)
+        return result
+
+    def latest(self) -> SavedChat | None:
+        """Последний чат, который удаётся прочитать (битые файлы пропускаются)."""
+        for path in self._files():
+            try:
+                return self.load(path.stem)
+            except ChatStoreError:
+                continue
+        return None
+
+    def find(self, ref: str) -> ChatInfo:
+        """Чат по точному id или однозначному началу id."""
+        ref = ref.strip()
+        if not ref:
+            raise ChatStoreError("не указан id чата")
+        ids = [p.stem for p in self._files()]
+        if ref in ids:
+            return self.load(ref).info
+        matches = [i for i in ids if i.startswith(ref)]
+        if not matches:
+            raise ChatStoreError(f"чат {ref} не найден")
+        if len(matches) > 1:
+            shown = ", ".join(matches[:5])
+            raise ChatStoreError(f"под «{ref}» подходит несколько чатов: {shown}")
+        return self.load(matches[0]).info
+
+
+class ChatRecorder:
+    """Текущий чат сессии: куда сохранять диалог после каждого хода.
+
+    Если записать не удалось (проект только для чтения), сохранение отключается до
+    конца сессии, а :meth:`save` один раз возвращает текст предупреждения.
+    """
+
+    def __init__(self, store: ChatStore, *, enabled: bool = True):
+        self.store = store
+        self.enabled = enabled
+        self._chat_id = store.new_id()
+        self._created_at: datetime | None = None
+        self.title = ""  # заголовок продолженного чата (пусто — новый)
+
+    @property
+    def chat_id(self) -> str:
+        return self._chat_id
+
+    def start_new(self) -> None:
+        self._chat_id = self.store.new_id()
+        self._created_at = None
+        self.title = ""
+
+    def switch_to(self, info: ChatInfo) -> None:
+        """Дальнейшие сохранения идут в этот (продолженный) чат."""
+        self._chat_id = info.id
+        self._created_at = info.created_at
+        self.title = info.title
+
+    def save(self, conversation: Conversation, *, model: str = "") -> str | None:
+        """Сохраняет диалог; возвращает предупреждение, если запись не удалась."""
+        if not self.enabled or not any(m.role == "user" for m in conversation.messages):
+            return None
+        try:
+            if self._created_at is None:
+                # Первая запись нового чата: id не должен затереть чужой чат
+                # (другое окно gigacrew, начатое в ту же секунду).
+                while self.store.exists(self._chat_id):
+                    self._chat_id = self.store.new_id()
+            info = self.store.save(
+                self._chat_id, conversation, model=model, created_at=self._created_at
+            )
+        except OSError as e:
+            self.enabled = False
+            return f"чат не сохранён, автосохранение отключено: {e}"
+        self._created_at = info.created_at
+        return None

gigacrew-0.5.0/gigacrew/agent/compaction.py

@@ -0,0 +1,268 @@
+"""Сжатие контекста: начало диалога заменяется кратким содержанием.
+
+Модель пересказывает старую часть истории (вызов без инструментов), резюме
+становится :class:`~gigacrew.agent.conversation.Summary` диалога и уходит в
+системном сообщении вместо самих сообщений. Журнал при этом не переписывается.
+
+* :func:`plan_compaction` — что сворачивать: граница проходит по блокам «сообщение +
+  результаты его вызова», свежие блоки в пределах ``keep_tokens`` остаются как есть;
+* :func:`render_transcript` / :func:`chunk_entries` — переписка плоским текстом,
+  нарезанная так, чтобы каждый запрос суммаризации уместился в окно;
+* :func:`summarize` — итеративное резюме: прежнее краткое содержание + очередной
+  кусок → новое краткое содержание.
+
+Порог автозапуска и объёмы выбирает агент (:mod:`gigacrew.agent.loop`).
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+
+from gigacrew.agent.context_window import CHARS_PER_TOKEN, estimate_text_tokens, estimate_tokens
+from gigacrew.agent.conversation import Conversation
+from gigacrew.agent.prompts import COMPACT_PROMPT
+from gigacrew.llm.base import LLMError, LLMProvider
+from gigacrew.llm.types import Message, Usage
+
+# Сколько текста каждого сообщения попадает к суммаризатору (символов).
+USER_CLIP = 6_000
+ASSISTANT_CLIP = 4_000
+RESULT_CLIP = 2_000
+ARGS_CLIP = 300
+# Суммаризатор читает не больше стольких кусков (самых свежих): более старое модель
+# всё равно уже не видела — его отбрасывало окно истории.
+MAX_INPUT_CHUNKS = 3
+MIN_CHUNK_TOKENS = 500
+REQUEST_OVERHEAD_TOKENS = 200  # обвязка запроса суммаризации
+MAX_INSTRUCTIONS_CHARS = 2_000  # пожелания пользователя (/compact …)
+
+
+class CompactionError(LLMError):
+    """Сжать не удалось: модель не дала пригодного краткого содержания."""
+
+
+@dataclass(frozen=True)
+class CompactionPlan:
+    """Что сворачивать: сообщения вида до новой границы ``upto`` (индекс в журнале)."""
+
+    upto: int
+    messages: list[Message]
+
+
+def plan_compaction(
+    conversation: Conversation, *, keep_tokens: int, min_tokens: int = 1
+) -> CompactionPlan | None:
+    """План сжатия или None, если сворачивать нечего.
+
+    Блоки после прежней границы перебираются с конца: остаются свежие блоки в
+    пределах ``keep_tokens`` (при ``keep_tokens > 0`` последний — всегда). ``0`` —
+    свернуть всё (``/compact``). Если сворачивать меньше ``min_tokens`` (по оценке),
+    сжатие не стоит запроса к модели.
+    """
+    messages = conversation.messages
+    start = conversation.summary.upto if conversation.summary is not None else 0
+    starts = [
+        i for i in range(start, len(messages)) if i == start or messages[i].role != "function"
+    ]
+
+    upto = len(messages)
+    if keep_tokens > 0:
+        kept = 0
+        for k in range(len(starts) - 1, -1, -1):
+            end = starts[k + 1] if k + 1 < len(starts) else len(messages)
+            size = estimate_tokens(messages[starts[k] : end])
+            if upto < len(messages) and kept + size > keep_tokens:
+                break
+            kept += size
+            upto = starts[k]
+    if upto <= start:
+        return None
+
+    view = conversation.context_messages()
+    # Вид = [закреплённый запрос] + messages[start:]; сворачивается всё до upto.
+    head = view[: len(view) - (len(messages) - upto)]
+    if not head or estimate_tokens(head) < min_tokens:
+        return None
+    return CompactionPlan(upto=upto, messages=head)
+
+
+def clip_middle(text: str, limit: int) -> str:
+    """Обрезка с вырезом середины: в начале — суть, в конце — итог (вывод тестов)."""
+    if len(text) <= limit:
+        return text
+    head = limit * 2 // 3
+    tail = limit - head
+    cut = len(text) - head - tail
+    return f"{text[:head]}\n…[вырезано {cut} симв.]…\n{text[len(text) - tail :]}"
+
+
+def render_message(message: Message) -> str:
+    """Сообщение диалога плоским текстом (вызовы инструментов — тоже текстом)."""
+    if message.role == "user":
+        return f"## Пользователь\n{clip_middle(message.content, USER_CLIP)}"
+    if message.role == "function":
+        return f"## Результат {message.name or ''}\n{clip_middle(message.content, RESULT_CLIP)}"
+    parts = []
+    if message.content.strip():
+        parts.append(clip_middle(message.content, ASSISTANT_CLIP))
+    call = message.function_call
+    if call is not None:
+        args = json.dumps(call.arguments, ensure_ascii=False, default=str)
+        parts.append(f"→ вызов {call.name}({clip_middle(args, ARGS_CLIP)})")
+    title = "Ассистент" if message.role == "assistant" else message.role
+    return f"## {title}\n" + "\n".join(parts)
+
+
+def render_transcript(messages: Sequence[Message]) -> list[str]:
+    return [render_message(m) for m in messages]
+
+
+def chunk_entries(entries: Sequence[str], budget_tokens: int) -> list[list[str]]:
+    """Делит записи на куски не больше ``budget_tokens`` (по оценке).
+
+    В каждом куске минимум одна запись; запись крупнее бюджета обрезается.
+    """
+    budget_tokens = max(budget_tokens, MIN_CHUNK_TOKENS)
+    chunks: list[list[str]] = []
+    current: list[str] = []
+    size = 0
+    for entry in entries:
+        tokens = estimate_text_tokens(entry)
+        if tokens > budget_tokens:
+            entry = clip_middle(entry, budget_tokens * CHARS_PER_TOKEN - 100)
+            tokens = estimate_text_tokens(entry)
+        if current and size + tokens > budget_tokens:
+            chunks.append(current)
+            current, size = [], 0
+        current.append(entry)
+        size += tokens
+    if current:
+        chunks.append(current)
+    return chunks
+
+
+def _recent_chunks(messages: Sequence[Message], budget_tokens: int) -> list[list[str]]:
+    """Последние :data:`MAX_INPUT_CHUNKS` кусков переписки для суммаризатора.
+
+    Последний запрос пользователя (текущая задача) попадает на вход всегда, даже
+    если его кусок старше последних: окно истории его тоже никогда не отбрасывало.
+    """
+    entries = render_transcript(messages)
+    chunks = chunk_entries(entries, budget_tokens)
+    kept = chunks[-MAX_INPUT_CHUNKS:]
+    last_user = max((i for i, m in enumerate(messages) if m.role == "user"), default=None)
+    if len(chunks) <= MAX_INPUT_CHUNKS or last_user is None:
+        return kept
+    first_kept = len(entries) - sum(len(c) for c in kept)
+    if last_user >= first_kept:
+        return kept
+    # Запрос — в отброшенном куске: он идёт первым, переписка после него — следом,
+    # в пределах тех же кусков.
+    budget_tokens = max(budget_tokens, MIN_CHUNK_TOKENS)
+    task = clip_middle(entries[last_user], budget_tokens * CHARS_PER_TOKEN // 2)
+    after = entries[last_user + 1 :]
+    kept = chunk_entries(after, budget_tokens - estimate_text_tokens(task))[-MAX_INPUT_CHUNKS:]
+    kept[0] = [task, *kept[0]]
+    return kept
+
+
+def _request_text(
+    previous: str | None, chunk: str, instructions: str, omitted: bool, max_chars: int
+) -> str:
+    parts = []
+    if previous:
+        parts.append(
+            "Краткое содержание более ранней части диалога (обнови его, ничего важного "
+            f"не теряя):\n{previous}"
+        )
+    if omitted:
+        parts.append("(Самая ранняя часть диалога не поместилась и опущена.)")
+    parts.append(f"Фрагмент диалога для сжатия:\n{chunk}")
+    if instructions.strip():
+        parts.append(f"Пожелания пользователя к краткому содержанию: {instructions.strip()}")
+    parts.append(
+        f"Составь краткое содержание по правилам. Объём — не больше {max_chars} символов "
+        f"(~{max(max_chars // CHARS_PER_WORD, 1)} слов)."
+    )
+    return "\n\n".join(parts)
+
+
+CHARS_PER_WORD = 7  # русский текст с пробелами — для подсказки модели об объёме
+CLIPPED_MARK = "\n…(краткое содержание обрезано)"
+
+
+def _clip_summary(text: str, max_chars: int) -> str:
+    """Резюме не длиннее ``max_chars``: режется с конца, по границе строки.
+
+    Модель кладёт важное первым (текущее состояние, следующий шаг), поэтому
+    теряется хвост, а не начало, и строка не обрывается на полуслове.
+    """
+    if len(text) <= max_chars:
+        return text
+    head = text[:max_chars]
+    cut = head.rfind("\n")
+    if cut >= max_chars // 2:
+        head = head[:cut]
+    return head.rstrip() + CLIPPED_MARK
+
+
+def summarize(
+    provider: LLMProvider,
+    messages: Sequence[Message],
+    *,
+    model: str,
+    temperature: float,
+    input_budget: int,
+    max_chars: int,
+    previous: str | None = None,
+    instructions: str = "",
+    on_usage: Callable[[Usage], None] | None = None,
+) -> str:
+    """Краткое содержание ``messages`` (с учётом прежнего ``previous``).
+
+    ``input_budget`` — бюджет одного запроса (оценка в токенах); ``max_chars`` —
+    предел длины резюме. ``on_usage`` получает расход каждого обращения — и при
+    сбое на следующем куске (оплаченное не теряется). Ошибки — :class:`LLMError`.
+
+    Пожелания и прежнее резюме обрезаются, чтобы запрос с ними и куском переписки
+    укладывался в ``input_budget``.
+    """
+    instructions = clip_middle(instructions.strip(), MAX_INSTRUCTIONS_CHARS)
+    if previous is not None:
+        previous = _clip_summary(previous, max_chars)  # могло остаться от модели с большим окном
+    reserve = (
+        estimate_text_tokens(COMPACT_PROMPT)
+        + max_chars // CHARS_PER_TOKEN  # прежнее резюме
+        + estimate_text_tokens(instructions)
+        + REQUEST_OVERHEAD_TOKENS
+    )
+    chunks = _recent_chunks(messages, input_budget - reserve)
+    omitted = sum(len(c) for c in chunks) < len(messages)
+
+    summary = previous
+    for i, chunk in enumerate(chunks):
+        request = [
+            Message(role="system", content=COMPACT_PROMPT),
+            Message(
+                role="user",
+                content=_request_text(
+                    summary, "\n\n".join(chunk), instructions, omitted and i == 0, max_chars
+                ),
+            ),
+        ]
+        turn = provider.complete(request, tools=None, model=model, temperature=temperature)
+        if on_usage is not None:
+            on_usage(turn.usage)
+        if turn.finish_reason != "stop":
+            raise CompactionError(
+                f"модель не закончила краткое содержание (finish_reason={turn.finish_reason})"
+            )
+        text = turn.message.content.strip()
+        if not text:
+            raise CompactionError("модель вернула пустое краткое содержание")
+        summary = _clip_summary(text, max_chars)
+    if summary is None:
+        raise CompactionError("нечего сжимать")
+    return summary