Root cause: components_modals (202k, 9 файлов) — GLM-5.3-Flash сжёг 48986 символов в reasoning, content пустой, пак потерян для secondary модели. reasoning_effort=low не спас на таком объёме. - components_modals → components_modals_feed / _admin / _misc - infra (257k) → infra_hooks_i18n / infra_data_types - Логируем явно, если secondary вернул ПУСТО для пака Самый большой пак теперь ~115k (pages_games) — GLM успевает.
794 lines
33 KiB
Python
794 lines
33 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
AI Code Review for Filwords PL Frontend (JSON-контракт + пак-подход)
|
||
|
||
Frontend слишком большой (1M+ символов) для одного запроса — модель уходит
|
||
в reasoning и не успевает выдать JSON. Решение: разбиваем файлы на паки
|
||
по папкам, делаем отдельный запрос на каждый пак, объединяем находки.
|
||
|
||
(21.09.2026) Первая версия для frontend — адаптация backend-скрипта.
|
||
(21.09.2026, вечер) Пак-подход: 4 пака (components, pages, core, admin).
|
||
(25.09.2026) Разбивка паков: 9 паков, MAX_OUTPUT_TOKENS=32000.
|
||
(25.09.2026, вечер) ФИКС root cause: DeepSeek-V4.1-Flash по умолчанию
|
||
думает (reasoning), и на сложных/больших паках весь max_tokens уходит
|
||
в thinking — content пустой, finish=length, находки теряются
|
||
(это видно по 6 из 9 паков в последнем прогоне).
|
||
→ reasoning выключен явно ("reasoning": {"enabled": False}).
|
||
→ fallback на reasoning_content убран (это была причина "Ошибка
|
||
парсинга JSON": туда попадал сырой текст рассуждений, а не JSON).
|
||
→ extract_json теперь спасает отдельные валидные находки, даже если
|
||
ответ всё же обрежется по max_tokens — вместо потери пака целиком.
|
||
(26.09.2026) ФИКС quality-first:
|
||
→ MODEL: DeepSeek-V4.1-Flash → DeepSeek-V4-Pro-0813 (потом откат).
|
||
→ MAX_OUTPUT_TOKENS: 32000 → 8000.
|
||
→ SYSTEM_PROMPT ужесточён: запрет "Ок"/"Не баг"/"Работает корректно",
|
||
confidence >= 0.75, ТОП-10 по severity.
|
||
→ validate_and_filter: overshoot guard — если находок > 15 на пак,
|
||
берём только топ-10 по confidence.
|
||
(26.09.2026, вечер) ФИКС dual-model:
|
||
→ Добавлена ВТОРАЯ модель (GLM 5.3) для пересечения находок:
|
||
DeepSeek V4.1 Flash — основная, GLM 5.3 — вторая.
|
||
Пересечение по (file, snippet) → confidence +0.05.
|
||
→ USE_SECONDARY_MODEL=True включает вторую модель.
|
||
(26.09.2026, ночь) ФИКС reasoning-per-model + бюджет:
|
||
→ MODEL_SECONDARY: zai-org/GLM-5.3 (флагман, $1.40/$4.40) →
|
||
zai-org/GLM-5.3-Flash ($0.15/$0.50). На фронтенде (1M+ символов,
|
||
9 паков × 2 модели) флагман почти упирался в бюджет 80 центов/
|
||
аудит — Flash укладывается с большим запасом.
|
||
→ ROOT CAUSE: "reasoning": {"enabled": False} НЕ работает на
|
||
GLM-5.3 / GLM-5.3-Flash (в доке Together: "Thinking cannot be
|
||
disabled entirely on GLM-5.3"). Это и объясняет "6 из 9 паков
|
||
без ответа" из заметки выше — скорее всего это были именно
|
||
GLM-паки: thinking съедал весь max_tokens, content пустой.
|
||
→ call_together_model строит РАЗНЫЙ payload по семейству модели:
|
||
DeepSeek → reasoning.enabled=False; GLM-5.3* → reasoning_effort
|
||
="low" + увеличенный max_tokens (единственный рычаг для GLM).
|
||
→ Логируем длину reasoning_content для диагностики.
|
||
(27.09.2026) ФИКС split_big_packs:
|
||
→ components_modals (202k, 9 файлов) — GLM-5.3-Flash сжёг 48986
|
||
символов в reasoning, content пустой, весь пак потерян для
|
||
secondary модели. reasoning_effort=low не спас на таком объёме.
|
||
→ Разбит на 3 пака: components_modals_feed / _admin / _misc.
|
||
→ infra (257k, 10 файлов) — тоже на грани (GLM дал всего 3 находки
|
||
при reasoning 3738) → разбит на 2 пака:
|
||
infra_hooks_i18n / infra_data_types.
|
||
→ Логируем явно, если secondary вернул ПУСТО для пака — чтобы
|
||
видеть потери в логах, а не молча терять вклад второй модели.
|
||
"""
|
||
|
||
import json
|
||
import os
|
||
import re
|
||
import sys
|
||
from datetime import datetime, timezone
|
||
from pathlib import Path
|
||
|
||
import httpx
|
||
|
||
|
||
# ============ Настройки ============
|
||
|
||
TOGETHER_API_KEY = os.environ.get("TOGETHER_API_KEY")
|
||
GITEA_BOT_TOKEN = os.environ.get("BOT_TOKEN")
|
||
GITEA_INSTANCE = os.environ.get("GITEA_INSTANCE", "https://git.filwordspl.com")
|
||
GITEA_REPO = os.environ.get("GITEA_REPO", "Drobysh/filwordspl-frontend")
|
||
|
||
# 🔧 ФИКС (26.09.2026, ночь): ai_review_glm_flash —
|
||
# Флагман GLM-5.3 ($1.40 in / $4.40 out) заменён на GLM-5.3-Flash
|
||
# ($0.15 in / $0.50 out), та же линейка Z.ai, но кодинг-версия
|
||
# попроще и в ~9 раз дешевле. На фронтенде (1M+ символов) это главный
|
||
# рычаг, чтобы не упереться в 80 центов на аудит.
|
||
MODEL_PRIMARY = "deepseek-ai/DeepSeek-V4.1-Flash"
|
||
MODEL_SECONDARY = "zai-org/GLM-5.3-Flash"
|
||
MODEL = MODEL_PRIMARY # backward compat
|
||
|
||
# 🔧 ФИКС (26.09.2026, вечер): secondary_model_enabled.
|
||
USE_SECONDARY_MODEL = True
|
||
|
||
# 🔧 ФИКС (26.09.2026): ai_review_overshoot —
|
||
# 32000 токенов = модель пишет "Ок" на каждую функцию.
|
||
# Актуально только для DeepSeek (у GLM свой лимит, см. GLM_MAX_OUTPUT_TOKENS).
|
||
MAX_OUTPUT_TOKENS = 8000
|
||
|
||
# 🔧 ФИКС (26.09.2026, ночь): ai_review_glm_reasoning_budget —
|
||
# GLM-5.3(-Flash) не даёт полностью выключить thinking, трейс мышления
|
||
# делит max_tokens с финальным JSON-ответом. Раньше это обнуляло content
|
||
# именно на GLM-паках. Даём больше запаса.
|
||
GLM_MAX_OUTPUT_TOKENS = 12000
|
||
GLM_REASONING_EFFORT = "low"
|
||
|
||
# Что игнорировать при сборе кода
|
||
IGNORE_DIRS = {
|
||
"node_modules", "dist", "build", ".git", ".gitea",
|
||
"public", "coverage", ".vite", ".cache",
|
||
}
|
||
IGNORE_FILES = {"ai_review.py", "vite-env.d.ts"}
|
||
|
||
# Расширения, которые читаем
|
||
INCLUDE_EXTENSIONS = {".ts", ".tsx", ".js", ".jsx"}
|
||
|
||
# Максимальный размер одного файла (символов)
|
||
MAX_FILE_SIZE = 100_000
|
||
|
||
# Фильтр находок
|
||
MIN_CONFIDENCE = 0.75
|
||
ALLOWED_SEVERITY = {"user_impact", "data_risk", "maintainability"}
|
||
|
||
# 🔧 ФИКС (26.09.2026): overshoot guard.
|
||
OVERSHOOT_LIMIT = 15
|
||
OVERSHOOT_KEEP = 10
|
||
|
||
|
||
# Паки для frontend. Если пак получается > 500K символов — модель может
|
||
# не успеть, тогда дроби ещё мельче (например, по подпапкам components/).
|
||
#
|
||
# 🔧 ФИКС (27.09.2026): split_big_packs —
|
||
# components_modals (202k) и infra (257k) раздроблены: на таких объёмах
|
||
# GLM-5.3-Flash съедает весь max_tokens в reasoning и возвращает пустой
|
||
# content. Теперь самый большой пак ~115k (pages_games) — GLM успевает.
|
||
PACKS = [
|
||
{
|
||
"name": "components_editors",
|
||
"paths": [
|
||
"src/components/ContentEditorMenu.tsx",
|
||
"src/components/LessonEditorModal.tsx",
|
||
"src/components/LessonsEditor.tsx",
|
||
"src/components/TextsEditor.tsx",
|
||
"src/components/WordsEditor.tsx",
|
||
],
|
||
"description": "UI: редакторы контента",
|
||
},
|
||
{
|
||
"name": "components_modals_feed",
|
||
"paths": [
|
||
"src/components/FeedModal.tsx",
|
||
"src/components/FeedPostComposer.tsx",
|
||
],
|
||
"description": "UI: модалки feed (лента, композер постов)",
|
||
},
|
||
{
|
||
"name": "components_modals_admin",
|
||
"paths": [
|
||
"src/components/AdminDashboardModal.tsx",
|
||
"src/components/TeacherMenuModal.tsx",
|
||
],
|
||
"description": "UI: админ-панель, меню учителя",
|
||
},
|
||
{
|
||
"name": "components_modals_misc",
|
||
"paths": [
|
||
"src/components/OnboardingModal.tsx",
|
||
"src/components/PronunciationModal.tsx",
|
||
"src/components/RulesModal.tsx",
|
||
"src/components/SupportChatModal.tsx",
|
||
"src/components/TypingModal.tsx",
|
||
],
|
||
"description": "UI: онбординг, произношение, правила, поддержка, печать",
|
||
},
|
||
{
|
||
"name": "components_misc",
|
||
"paths": [
|
||
"src/components/AnimatedCat.tsx",
|
||
"src/components/HighlightsCarousel.tsx",
|
||
"src/components/HintPanel.tsx",
|
||
"src/components/ImageLightbox.tsx",
|
||
"src/components/LetterGrid.tsx",
|
||
],
|
||
"description": "UI: прочие компоненты (игры, карусель)",
|
||
},
|
||
{
|
||
"name": "pages_lessons",
|
||
"paths": [
|
||
"src/pages/LessonsPage.tsx",
|
||
"src/pages/TopicLessonsPage.tsx",
|
||
"src/pages/LessonViewPage.tsx",
|
||
"src/pages/TestViewPage.tsx",
|
||
"src/pages/PracticeViewPage.tsx",
|
||
],
|
||
"description": "Страницы: уроки и тесты",
|
||
},
|
||
{
|
||
"name": "pages_teacher",
|
||
"paths": [
|
||
"src/pages/TeacherChatPage.tsx",
|
||
"src/pages/PronunciationPage.tsx",
|
||
"src/pages/TypingPage.tsx",
|
||
],
|
||
"description": "Страницы: учитель, произношение, печать",
|
||
},
|
||
{
|
||
"name": "pages_games",
|
||
"paths": [
|
||
"src/pages/WordSearchPage.tsx",
|
||
"src/pages/SentenceBuilderPage.tsx",
|
||
"src/pages/WordQuizPage.tsx",
|
||
"src/pages/BubbleWordsPage.tsx",
|
||
],
|
||
"description": "Страницы: игры",
|
||
},
|
||
{
|
||
"name": "pages_menu",
|
||
"paths": [
|
||
"src/pages/MenuPage.tsx",
|
||
"src/pages/LeaderboardPage.tsx",
|
||
"src/pages/FlashcardsPage.tsx",
|
||
"src/pages/LanguageSelectPage.tsx",
|
||
],
|
||
"description": "Страницы: меню, рейтинг, карточки, язык",
|
||
},
|
||
{
|
||
"name": "core",
|
||
"paths": ["src/App.tsx", "src/api.ts", "src/telegram.ts", "src/main.tsx"],
|
||
"description": "Ядро: App, api, telegram, входная точка",
|
||
},
|
||
{
|
||
"name": "infra_hooks_i18n",
|
||
"paths": ["src/hooks/", "src/i18n/"],
|
||
"description": "Инфраструктура: хуки, локализация",
|
||
},
|
||
{
|
||
"name": "infra_data_types",
|
||
"paths": ["src/styles/", "src/data/", "src/types/"],
|
||
"description": "Инфраструктура: стили, данные, типы",
|
||
},
|
||
]
|
||
|
||
|
||
# ============ Проверка окружения ============
|
||
|
||
def check_env() -> None:
|
||
missing = []
|
||
if not TOGETHER_API_KEY:
|
||
missing.append("TOGETHER_API_KEY")
|
||
if not GITEA_BOT_TOKEN:
|
||
missing.append("BOT_TOKEN")
|
||
if missing:
|
||
print(f"❌ Отсутствуют переменные окружения: {', '.join(missing)}", file=sys.stderr)
|
||
sys.exit(1)
|
||
|
||
|
||
# ============ Сбор кода ============
|
||
|
||
def read_file(path: Path, repo_root: Path) -> tuple[str, str] | None:
|
||
"""Читает один файл. Возвращает (относительный_путь, содержимое) или None."""
|
||
try:
|
||
content = path.read_text(encoding="utf-8")
|
||
except Exception as e:
|
||
print(f"⚠️ Не прочитал {path.relative_to(repo_root)}: {e}", file=sys.stderr)
|
||
return None
|
||
|
||
if len(content) > MAX_FILE_SIZE:
|
||
print(f"⚠️ Пропущен большой файл: {path.relative_to(repo_root)} ({len(content)} символов)", file=sys.stderr)
|
||
return None
|
||
|
||
rel_str = str(path.relative_to(repo_root)).replace("\\", "/")
|
||
return rel_str, content
|
||
|
||
|
||
def collect_pack(repo_root: Path, pack: dict) -> tuple[str, dict[str, str]]:
|
||
"""Собирает файлы одного пака. Возвращает (текст, словарь {путь: содержимое})."""
|
||
chunks: list[str] = []
|
||
files_map: dict[str, str] = {}
|
||
total_size = 0
|
||
|
||
for path_pattern in pack["paths"]:
|
||
target = repo_root / path_pattern
|
||
|
||
if not target.exists():
|
||
continue
|
||
|
||
if target.is_file():
|
||
result = read_file(target, repo_root)
|
||
if result:
|
||
rel_str, content = result
|
||
lang = "typescript" if target.suffix in (".ts", ".tsx") else "javascript"
|
||
chunks.append(f"### FILE: {rel_str}\n```{lang}\n{content}\n```\n")
|
||
files_map[rel_str] = content
|
||
total_size += len(content)
|
||
else:
|
||
for f in sorted(target.rglob("*")):
|
||
if not f.is_file():
|
||
continue
|
||
if f.suffix not in INCLUDE_EXTENSIONS:
|
||
continue
|
||
if f.name in IGNORE_FILES:
|
||
continue
|
||
if f.name.endswith(".d.ts"):
|
||
continue
|
||
if any(part in IGNORE_DIRS for part in f.relative_to(repo_root).parts):
|
||
continue
|
||
|
||
result = read_file(f, repo_root)
|
||
if result:
|
||
rel_str, content = result
|
||
lang = "typescript" if f.suffix in (".ts", ".tsx") else "javascript"
|
||
chunks.append(f"### FILE: {rel_str}\n```{lang}\n{content}\n```\n")
|
||
files_map[rel_str] = content
|
||
total_size += len(content)
|
||
|
||
print(f" 📦 Пак '{pack['name']}': {len(files_map)} файлов, {total_size:,} символов")
|
||
return "\n".join(chunks), files_map
|
||
|
||
|
||
# ============ Промпт для модели ============
|
||
|
||
SYSTEM_PROMPT = """Ты — опытный техлид и ревьюер React + TypeScript кода (Telegram Mini App).
|
||
|
||
Твоя задача — проанализировать код и вернуть СТРОГО JSON-массив находок.
|
||
|
||
ФОРМАТ ОТВЕТА (только JSON, без markdown, без пояснений):
|
||
|
||
[
|
||
{
|
||
"id": "КРАТКОЕ_ИМЯ_БАГА",
|
||
"file": "src/components/FeedModal.tsx",
|
||
"line": 120,
|
||
"snippet": "точное цитирование 1-3 строк из файла",
|
||
"severity": "user_impact",
|
||
"user_effect": "что видит пользователь: модалка не закрывается, картинка обрезается",
|
||
"repro": "открыть Feed → кликнуть по посту → модалка не реагирует на Escape",
|
||
"fix_hint": "добавить обработчик onKeyDown для Escape в useEffect",
|
||
"confidence": 0.86
|
||
}
|
||
]
|
||
|
||
ПРАВИЛА (соблюдай строго):
|
||
1. severity — только одно из: "user_impact", "data_risk", "maintainability".
|
||
2. snippet — ТОЧНАЯ цитата 1-3 строк из файла. Не перефразируй.
|
||
3. confidence — число от 0 до 1. Если меньше 0.75 — НЕ включай.
|
||
4. МАКСИМУМ 10 находок за этот пак. Если находишь больше — выбери ТОП-10 по severity.
|
||
5. НЕ пиши находки типа "Ок", "Не баг", "Работает корректно", "Не влияет на UX", "Не критично". Только РЕАЛЬНЫЕ проблемы.
|
||
6. НЕ комментируй каждую функцию. Только баги, security, UX.
|
||
7. НЕ переписывай код. Только описывай, что не так.
|
||
8. НЕ включай проблемы дизайна/стиля (отступы, цвета) — только функционал, безопасность, UX.
|
||
9. Если проблем нет — верни пустой массив: [].
|
||
|
||
Отвечай ТОЛЬКО JSON, без markdown-обёрток. Не думай вслух — сразу выдавай JSON-массив.
|
||
"""
|
||
|
||
|
||
USER_PROMPT_TEMPLATE = """Проанализируй часть кода frontend проекта Filwords PL (Telegram Mini App).
|
||
|
||
Это React 19 + TypeScript + Vite + React Router.
|
||
|
||
Пак: **{pack_name}** — {pack_description}
|
||
|
||
Ищи ТОЛЬКО реальные проблемы:
|
||
1. Баги и логические ошибки (React hooks, useEffect, state)
|
||
2. Проблемы безопасности (XSS, утечки токенов, невалидные URL)
|
||
3. Проблемы UX (модалки не закрываются, кнопки не работают, скролл)
|
||
4. Утечки памяти (неотписанные слушатели, таймеры)
|
||
5. N+1 запросы к API
|
||
6. Отсутствие обработки ошибок (fetch без catch, loading без finally)
|
||
7. Дублирование кода и компонентов
|
||
8. Мёртвый код (неиспользуемые импорты, старые модалки)
|
||
|
||
НЕ пиши "Ок", "Не баг", "Работает корректно". Если проблем нет — верни [].
|
||
|
||
Верни JSON-массив находок по формату выше.
|
||
|
||
Вот код:
|
||
|
||
{code}
|
||
"""
|
||
|
||
|
||
# ============ Запрос к Together AI ============
|
||
|
||
def _is_glm(model_name: str) -> bool:
|
||
return "GLM-5.3" in model_name or "glm-5.3" in model_name.lower()
|
||
|
||
|
||
def call_together_model(code: str, pack: dict, model_name: str) -> str:
|
||
"""Отправляет код пака в указанную модель.
|
||
|
||
🔧 ФИКС (26.09.2026, ночь): ai_review_reasoning_per_model —
|
||
у DeepSeek reasoning реально выключается через
|
||
"reasoning": {"enabled": False}. У GLM-5.3(-Flash) это НЕ работает
|
||
(thinking у GLM-5.3 нельзя отключить полностью, см. доки Together) —
|
||
там единственный рычаг: reasoning_effort="low" + больший max_tokens.
|
||
"""
|
||
print(f" 🤖 Отправляю пак '{pack['name']}' в {model_name}...")
|
||
|
||
user_prompt = USER_PROMPT_TEMPLATE.format(
|
||
pack_name=pack["name"],
|
||
pack_description=pack["description"],
|
||
code=code,
|
||
)
|
||
|
||
payload = {
|
||
"model": model_name,
|
||
"messages": [
|
||
{"role": "system", "content": SYSTEM_PROMPT},
|
||
{"role": "user", "content": user_prompt},
|
||
],
|
||
"temperature": 0.2,
|
||
}
|
||
|
||
if _is_glm(model_name):
|
||
# GLM-5.3 / GLM-5.3-Flash: thinking нельзя выключить полностью,
|
||
# только снизить через reasoning_effort. Даём больше max_tokens,
|
||
# т.к. трейс мышления делит бюджет с JSON-ответом.
|
||
payload["reasoning_effort"] = GLM_REASONING_EFFORT
|
||
payload["max_tokens"] = GLM_MAX_OUTPUT_TOKENS
|
||
else:
|
||
# DeepSeek: reasoning реально выключается этим флагом.
|
||
payload["reasoning"] = {"enabled": False}
|
||
payload["max_tokens"] = MAX_OUTPUT_TOKENS
|
||
|
||
response = httpx.post(
|
||
"https://api.together.xyz/v1/chat/completions",
|
||
headers={
|
||
"Authorization": f"Bearer {TOGETHER_API_KEY}",
|
||
"Content-Type": "application/json",
|
||
},
|
||
json=payload,
|
||
timeout=300.0,
|
||
)
|
||
|
||
if response.status_code != 200:
|
||
print(f" ❌ {model_name} вернул {response.status_code}", file=sys.stderr)
|
||
print(f" Ответ: {response.text[:500]}", file=sys.stderr)
|
||
return ""
|
||
|
||
data = response.json()
|
||
|
||
try:
|
||
message = data["choices"][0]["message"]
|
||
result = message.get("content")
|
||
if not result:
|
||
raise KeyError("пусто (content отсутствует)")
|
||
except (KeyError, IndexError, TypeError) as e:
|
||
# 🔧 ФИКС (26.09.2026, ночь): логируем длину reasoning-трейса
|
||
# для диагностики, сколько токенов ушло на "мысли" до отказа.
|
||
reasoning_len = 0
|
||
try:
|
||
reasoning_len = len(
|
||
data["choices"][0]["message"].get("reasoning_content") or ""
|
||
)
|
||
except Exception:
|
||
pass
|
||
print(f" ❌ Формат ответа: {e} (reasoning_content: {reasoning_len} символов)", file=sys.stderr)
|
||
return ""
|
||
|
||
usage = data.get("usage", {})
|
||
finish = data["choices"][0].get("finish_reason", "unknown")
|
||
reasoning_len = len(data["choices"][0]["message"].get("reasoning_content") or "")
|
||
print(
|
||
f" ✅ [{model_name.split('/')[-1]}] Пак '{pack['name']}': "
|
||
f"вход={usage.get('prompt_tokens', 0)}, "
|
||
f"выход={usage.get('completion_tokens', 0)}, "
|
||
f"reasoning≈{reasoning_len} симв., finish={finish}"
|
||
)
|
||
if finish == "length":
|
||
print(
|
||
f" ⚠️ Пак '{pack['name']}' обрезан по max_tokens ({model_name})",
|
||
file=sys.stderr,
|
||
)
|
||
|
||
return result
|
||
|
||
|
||
def call_together(code: str, pack: dict) -> str:
|
||
"""Backward-compat."""
|
||
return call_together_model(code, pack, MODEL_PRIMARY)
|
||
|
||
|
||
# ============ Парсинг и фильтрация JSON ============
|
||
|
||
def extract_json(text: str) -> list[dict]:
|
||
"""Извлекает находки из ответа модели."""
|
||
if not text:
|
||
return []
|
||
text = text.strip()
|
||
if text.startswith("```"):
|
||
text = re.sub(r"^```(?:json)?\s*", "", text)
|
||
text = re.sub(r"\s*```$", "", text)
|
||
|
||
start = text.find("[")
|
||
if start == -1:
|
||
print(f" ⚠️ Не найден JSON-массив. Первые 300 символов:\n{text[:300]}", file=sys.stderr)
|
||
return []
|
||
|
||
decoder = json.JSONDecoder()
|
||
idx, n = start + 1, len(text)
|
||
results: list[dict] = []
|
||
|
||
while idx < n:
|
||
while idx < n and text[idx] in " \t\n\r,":
|
||
idx += 1
|
||
if idx >= n or text[idx] == "]":
|
||
break
|
||
try:
|
||
obj, end = decoder.raw_decode(text, idx)
|
||
except json.JSONDecodeError:
|
||
break
|
||
if isinstance(obj, dict):
|
||
results.append(obj)
|
||
idx = end
|
||
|
||
if not results:
|
||
print(" ⚠️ Не удалось извлечь ни одной находки из ответа", file=sys.stderr)
|
||
|
||
return results
|
||
|
||
|
||
def merge_dual_findings(primary_raw: str, secondary_raw: str) -> list[dict]:
|
||
"""Объединяет находки от двух моделей.
|
||
|
||
Пересечение по (file, snippet) → confidence +0.05.
|
||
"""
|
||
p_list = extract_json(primary_raw)
|
||
s_list = extract_json(secondary_raw)
|
||
|
||
def _key(f: dict) -> str:
|
||
return f"{(f.get('file') or '').strip()}::{(f.get('snippet') or '').strip()}"
|
||
|
||
p_map = {_key(f): f for f in p_list if isinstance(f, dict)}
|
||
s_map = {_key(f): f for f in s_list if isinstance(f, dict)}
|
||
|
||
merged: dict[str, dict] = {}
|
||
|
||
for k, f in p_map.items():
|
||
item = dict(f)
|
||
item["_source"] = "primary"
|
||
if k in s_map:
|
||
try:
|
||
conf = float(item.get("confidence", 0) or 0)
|
||
except (TypeError, ValueError):
|
||
conf = 0
|
||
item["confidence"] = min(1.0, round(conf + 0.05, 2))
|
||
item["_source"] = "both"
|
||
merged[k] = item
|
||
|
||
for k, f in s_map.items():
|
||
if k not in merged:
|
||
item = dict(f)
|
||
item["_source"] = "secondary"
|
||
merged[k] = item
|
||
|
||
both_count = sum(1 for v in merged.values() if v.get("_source") == "both")
|
||
print(f" 🔗 Merge: primary={len(p_map)}, secondary={len(s_map)}, "
|
||
f"пересечение={both_count}, всего={len(merged)}")
|
||
|
||
return list(merged.values())
|
||
|
||
|
||
def validate_and_filter(findings: list[dict], files_map: dict[str, str]) -> tuple[list[dict], dict[str, int]]:
|
||
"""Фильтрует находки.
|
||
|
||
Overshoot guard — если находок > 15 на пак, берём только топ-10 по confidence.
|
||
"""
|
||
stats = {
|
||
"total": len(findings),
|
||
"overshoot": 0,
|
||
"no_file": 0, "snippet_mismatch": 0, "bad_severity": 0,
|
||
"low_confidence": 0, "no_effect_or_repro": 0, "passed": 0,
|
||
}
|
||
|
||
if len(findings) > OVERSHOOT_LIMIT:
|
||
print(
|
||
f" ⚠️ Overshoot: {len(findings)} находок (> {OVERSHOOT_LIMIT}), "
|
||
f"берём топ-{OVERSHOOT_KEEP} по confidence",
|
||
file=sys.stderr,
|
||
)
|
||
findings = sorted(
|
||
[f for f in findings if isinstance(f, dict)],
|
||
key=lambda x: float(x.get("confidence", 0) or 0),
|
||
reverse=True,
|
||
)[:OVERSHOOT_KEEP]
|
||
stats["overshoot"] = 1
|
||
|
||
passed: list[dict] = []
|
||
|
||
for f in findings:
|
||
if not isinstance(f, dict):
|
||
continue
|
||
|
||
file_path = (f.get("file") or "").strip().replace("\\", "/")
|
||
snippet = (f.get("snippet") or "").strip()
|
||
severity = (f.get("severity") or "").strip().lower()
|
||
confidence = f.get("confidence", 0)
|
||
|
||
if file_path not in files_map:
|
||
stats["no_file"] += 1
|
||
continue
|
||
|
||
if not snippet or snippet not in files_map[file_path]:
|
||
stats["snippet_mismatch"] += 1
|
||
continue
|
||
|
||
if severity not in ALLOWED_SEVERITY:
|
||
stats["bad_severity"] += 1
|
||
continue
|
||
|
||
try:
|
||
conf_val = float(confidence)
|
||
except (TypeError, ValueError):
|
||
conf_val = 0
|
||
if conf_val < MIN_CONFIDENCE:
|
||
stats["low_confidence"] += 1
|
||
continue
|
||
|
||
if severity in ("user_impact", "data_risk"):
|
||
if not (f.get("user_effect") or "").strip() or not (f.get("repro") or "").strip():
|
||
stats["no_effect_or_repro"] += 1
|
||
continue
|
||
|
||
passed.append(f)
|
||
stats["passed"] += 1
|
||
|
||
return passed, stats
|
||
|
||
|
||
# ============ Форматирование Issue ============
|
||
|
||
SEVERITY_EMOJI = {"user_impact": "🔴", "data_risk": "🟠", "maintainability": "🟡"}
|
||
SEVERITY_LABEL = {
|
||
"user_impact": "Влияет на пользователя",
|
||
"data_risk": "Риск для данных",
|
||
"maintainability": "Качество кода",
|
||
}
|
||
|
||
|
||
def format_issue_body(
|
||
all_findings: list[dict],
|
||
pack_stats: list[dict],
|
||
total_stats: dict[str, int],
|
||
date_str: str,
|
||
) -> str:
|
||
"""Формирует markdown-тело Issue."""
|
||
lines: list[str] = []
|
||
lines.append("# 🤖 AI Code Review (Frontend)")
|
||
lines.append("")
|
||
lines.append(f"**Дата:** {date_str}")
|
||
if USE_SECONDARY_MODEL:
|
||
lines.append(f"**Модели:** `{MODEL_PRIMARY}` + `{MODEL_SECONDARY}`")
|
||
else:
|
||
lines.append(f"**Модель:** `{MODEL_PRIMARY}`")
|
||
lines.append(f"**Репозиторий:** `{GITEA_REPO}`")
|
||
lines.append("")
|
||
lines.append("## 📊 По пакам")
|
||
lines.append("")
|
||
for ps in pack_stats:
|
||
lines.append(f"- **{ps['name']}** — {ps['files']} файлов, "
|
||
f"{ps['symbols']:,} символов, находок={ps['findings']}")
|
||
lines.append("")
|
||
lines.append("---")
|
||
lines.append("")
|
||
|
||
if not all_findings:
|
||
lines.append("✅ **После фильтрации не осталось находок.**")
|
||
else:
|
||
by_severity: dict[str, list[dict]] = {"user_impact": [], "data_risk": [], "maintainability": []}
|
||
for f in all_findings:
|
||
by_severity.setdefault(f.get("severity", "maintainability"), []).append(f)
|
||
|
||
counter = 0
|
||
for sev in ["user_impact", "data_risk", "maintainability"]:
|
||
items = by_severity.get(sev, [])
|
||
if not items:
|
||
continue
|
||
lines.append(f"## {SEVERITY_EMOJI[sev]} {SEVERITY_LABEL[sev]} ({len(items)})")
|
||
lines.append("")
|
||
for f in items:
|
||
counter += 1
|
||
source = f.get("_source", "primary")
|
||
source_mark = "🔗 both" if source == "both" else ("🔵 secondary" if source == "secondary" else "")
|
||
lines.append(f"### {counter}. {f.get('id', 'без имени')} {source_mark}")
|
||
lines.append("")
|
||
lines.append(f"- **Файл:** `{f.get('file')}:{f.get('line', '?')}`")
|
||
lines.append(f"- **Snippet:** `{f.get('snippet', '').strip()[:120]}`")
|
||
lines.append(f"- **Проблема:** {f.get('user_effect', '—')}")
|
||
lines.append(f"- **Как воспроизвести:** {f.get('repro', '—')}")
|
||
lines.append(f"- **Что сделать:** {f.get('fix_hint', '—')}")
|
||
lines.append(f"- **Confidence:** {f.get('confidence', '?')}")
|
||
lines.append("")
|
||
|
||
lines.append("---")
|
||
lines.append("")
|
||
lines.append(f"**Итого:** всего находок={total_stats['total']}, "
|
||
f"overshoot={total_stats.get('overshoot', 0)}, "
|
||
f"snippet не совпал={total_stats['snippet_mismatch']}, "
|
||
f"низкий confidence={total_stats['low_confidence']}, "
|
||
f"прошло={total_stats['passed']}")
|
||
lines.append("")
|
||
lines.append("_Этот Issue создан автоматически. Исправления делаются вручную._")
|
||
|
||
return "\n".join(lines)
|
||
|
||
|
||
# ============ Создание Issue ============
|
||
|
||
def create_issue(title: str, body: str) -> str:
|
||
print("📝 Создаю Issue в Gitea...")
|
||
|
||
response = httpx.post(
|
||
f"{GITEA_INSTANCE}/api/v1/repos/{GITEA_REPO}/issues",
|
||
headers={
|
||
"Authorization": f"token {GITEA_BOT_TOKEN}",
|
||
"Content-Type": "application/json",
|
||
},
|
||
json={"title": title, "body": body},
|
||
timeout=30.0,
|
||
)
|
||
|
||
if response.status_code not in (200, 201):
|
||
print(f"❌ Gitea вернул {response.status_code}: {response.text[:500]}", file=sys.stderr)
|
||
sys.exit(1)
|
||
|
||
data = response.json()
|
||
issue_url = data.get("html_url", "")
|
||
print(f"✅ Issue создан: {issue_url}")
|
||
return issue_url
|
||
|
||
|
||
# ============ Main ============
|
||
|
||
def main() -> None:
|
||
check_env()
|
||
|
||
repo_root = Path(".").resolve()
|
||
print(f"📁 Репозиторий: {repo_root}")
|
||
|
||
all_passed: list[dict] = []
|
||
pack_stats: list[dict] = []
|
||
total_stats = {
|
||
"total": 0, "overshoot": 0, "no_file": 0, "snippet_mismatch": 0,
|
||
"bad_severity": 0, "low_confidence": 0,
|
||
"no_effect_or_repro": 0, "passed": 0,
|
||
}
|
||
|
||
for pack in PACKS:
|
||
print(f"\n📦 Обрабатываю пак: {pack['name']}")
|
||
code, files_map = collect_pack(repo_root, pack)
|
||
|
||
if not code:
|
||
print(f" ⚠️ Пак '{pack['name']}' пуст — пропускаю")
|
||
pack_stats.append({"name": pack["name"], "files": 0, "symbols": 0, "findings": 0})
|
||
continue
|
||
|
||
primary_raw = call_together_model(code, pack, MODEL_PRIMARY)
|
||
|
||
if USE_SECONDARY_MODEL:
|
||
secondary_raw = call_together_model(code, pack, MODEL_SECONDARY)
|
||
# 🔧 ФИКС (27.09.2026): secondary_empty_log —
|
||
# если GLM вернул пусто (весь бюджет ушёл в reasoning),
|
||
# пишем это явно, чтобы видеть потери второй модели в логах.
|
||
if not secondary_raw:
|
||
print(
|
||
f" ⚠️ Secondary ({MODEL_SECONDARY}) вернул ПУСТО для пака "
|
||
f"'{pack['name']}' — пак потерян для второй модели",
|
||
file=sys.stderr,
|
||
)
|
||
findings = merge_dual_findings(primary_raw, secondary_raw)
|
||
else:
|
||
findings = extract_json(primary_raw)
|
||
|
||
filtered, stats = validate_and_filter(findings, files_map)
|
||
|
||
all_passed.extend(filtered)
|
||
for k in total_stats:
|
||
total_stats[k] += stats.get(k, 0)
|
||
|
||
pack_stats.append({
|
||
"name": pack["name"],
|
||
"files": len(files_map),
|
||
"symbols": sum(len(c) for c in files_map.values()),
|
||
"findings": len(filtered),
|
||
})
|
||
|
||
print(f" ✅ Пак '{pack['name']}': прошло фильтр {stats['passed']} из {stats['total']}")
|
||
|
||
print(f"\n📊 ИТОГО: прошло фильтр {total_stats['passed']} из {total_stats['total']}")
|
||
|
||
date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
|
||
title = f"🤖 AI Review (frontend): {total_stats['passed']} задач ({date_str})"
|
||
body = format_issue_body(all_passed, pack_stats, total_stats, date_str)
|
||
|
||
create_issue(title, body)
|
||
print("🎉 Готово!")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main() |