#!/usr/bin/env python3 """ AI Code Review for Filwords PL Backend (JSON-контракт + пак-подход) Backend слишком большой (~440K символов) для одного запроса — модель уходит в reasoning и не успевает выдать JSON. Решение: разбиваем файлы на паки по папкам, делаем отдельный запрос на каждый пак, объединяем находки. (20.09.2026) Первая версия — конвейер без tool-calling, предсказуемо по токенам. (20.09.2026, вечер) Фикс: max_tokens=16000, fallback на reasoning_content. (21.09.2026, вечер) JSON-контракт + snippet-проверка + фильтр confidence. (22.09.2026, вечер) Пак-подход: 3 пака (routers, core, services+scripts). (25.09.2026) Разбивка routers на 4 пака, MAX_OUTPUT_TOKENS=32000. (25.09.2026, вечер) ФИКС root cause: DeepSeek-V4.1-Flash по умолчанию думает (reasoning), и на сложных паках весь max_tokens уходит в thinking — content пустой, finish=length, находки теряются. → 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 + split routers_learning: → routers_learning (100k) разбит на 3 пака: routers_learning_core, routers_learning_teacher, routers_learning_orch. Это устраняет finish=length — модель успевает выдать JSON. → Добавлена ВТОРАЯ модель (GLM 5.3) для пересечения находок: DeepSeek V4.1 Flash — основная, GLM 5.3 — вторая. Пересечение по (file, snippet) → confidence +0.05. → Только primary → normal. Только secondary → normal. → 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). Флагман почти не нужен для point-by-point code review, а стоит в ~9 раз дороже; на 2 репо (backend+frontend) дуал-модель с флагманом упирается в бюджет 80 центов/аудит, с Flash — укладывается с большим запасом. → ROOT CAUSE найден: "reasoning": {"enabled": False} НЕ работает на GLM-5.3 / GLM-5.3-Flash (документация Together: "Thinking cannot be disabled entirely on GLM-5.3"). Флаг тихо игнорировался, GLM продолжал думать, весь max_tokens уходил в reasoning_content, content оставался пустым → "Формат ответа: пусто" именно на GLM-паках. Это и была причина "не работает" у secondary модели. → call_together_model теперь строит РАЗНЫЙ payload по семейству модели: DeepSeek → reasoning.enabled=False (это работает); GLM-5.3* → reasoning_effort="low" + увеличенный max_tokens (единственный доступный рычаг для GLM-5.3, thinking трейс частично остаётся, но сильно короче). → Логируем длину reasoning_content (если есть) — видно, сколько токенов модель тратит на мысли до JSON-ответа. """ 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-backend") # 🔧 ФИКС (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 раз дешевле. Для point-by-point ревью одного пака # флагманская "глубина" не нужна, а бюджет 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 — # если True — гоняем обе модели, объединяем по пересечению. USE_SECONDARY_MODEL = True # 🔧 ФИКС (26.09.2026): ai_review_overshoot — # 32000 токенов = модель пишет "Ок" на каждую функцию. # 10 находок × ~500 токенов = 5000. 8000 — с запасом. # Актуально только для DeepSeek (у GLM свой лимит, см. GLM_MAX_OUTPUT_TOKENS). MAX_OUTPUT_TOKENS = 8000 # 🔧 ФИКС (26.09.2026, ночь): ai_review_glm_reasoning_budget — # У GLM-5.3(-Flash) thinking НЕЛЬЗЯ выключить полностью (только # reasoning_effort="low"/"medium"/"high"/"max"), и трейс мышления # делит один и тот же max_tokens с финальным JSON-ответом. # Раньше при max_tokens=8000 весь бюджет у GLM уходил в reasoning, # content оставался пустым. Даём больше запаса именно для GLM. GLM_MAX_OUTPUT_TOKENS = 12000 GLM_REASONING_EFFORT = "low" # Что игнорировать при сборе кода IGNORE_DIRS = { "venv", ".venv", "__pycache__", ".git", ".gitea", "tests", "archive", "uploads", "tts_cache", "node_modules", "dist", "learning_data", } IGNORE_FILES = { "ai_review.py", "conftest.py", "code_summary.py", "add_levels.py", "generate_levels_v2.py", "__init__.py", } # Расширения, которые читаем INCLUDE_EXTENSIONS = {".py"} # Максимальный размер одного файла (символов) MAX_FILE_SIZE = 100_000 # Фильтр находок # 🔧 ФИКС (26.09.2026): MIN_CONFIDENCE 0.7 → 0.75. MIN_CONFIDENCE = 0.75 ALLOWED_SEVERITY = {"user_impact", "data_risk", "maintainability"} # 🔧 ФИКС (26.09.2026): overshoot guard. OVERSHOOT_LIMIT = 15 OVERSHOOT_KEEP = 10 # Паки для backend. Пути проверены по факту (`ls routers/`). PACKS = [ { "name": "routers_games", "paths": [ "routers/game.py", "routers/hints.py", "routers/wordquiz.py", "routers/bubblewords.py", "routers/sentences.py", "routers/typing.py", "routers/pronunciation.py", ], "description": "Игры: wordsearch, hints, quiz, bubbles, sentences, typing, pronunciation", }, { "name": "routers_learning_core", "paths": ["routers/learning.py"], "description": "Уроки: learning.py (эндпоинты + update_*)", }, { "name": "routers_learning_teacher", "paths": ["routers/teacher.py"], "description": "Учитель: teacher.py", }, { "name": "routers_learning_orch", "paths": [ "routers/orchestrator.py", "routers/learning_profile.py", "routers/learning_data/", ], "description": "Orchestrator + profile + learning_data", }, { "name": "routers_admin", "paths": [ "routers/admin.py", "routers/admin_content.py", "routers/feed.py", "routers/support.py", ], "description": "Админ: dashboard, content editor, feed, support", }, { "name": "routers_misc", "paths": [ "routers/achievements.py", "routers/users.py", "routers/leaderboard.py", "routers/assistant.py", "routers/tts.py", ], "description": "Прочее: achievements, users, leaderboard, assistant, tts", }, { "name": "core", "paths": ["main.py", "database.py", "auth.py", "config.py", "bot.py"], "description": "Ядро: main (rate limiter, CORS), database (схема), auth (HMAC), config", }, { "name": "services", "paths": ["scripts/"], "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 chunks.append(f"### FILE: {rel_str}\n```python\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 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 chunks.append(f"### FILE: {rel_str}\n```python\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 = """Ты — опытный техлид и ревьюер Python-кода (FastAPI, asyncpg, PostgreSQL). Твоя задача — проанализировать код и вернуть СТРОГО JSON-массив находок. ФОРМАТ ОТВЕТА (только JSON, без markdown, без пояснений): [ { "id": "КРАТКОЕ_ИМЯ_БАГА", "file": "routers/hints.py", "line": 20, "snippet": "точное цитирование 1-3 строк из файла", "severity": "user_impact", "user_effect": "что видит ученик: подсказка не списывается, очки завышены", "repro": "открыть игру → взять подсказку → hints_used в БД не растёт", "fix_hint": "UPDATE ... hints_used = hints_used + 1 в той же транзакции", "confidence": 0.86 } ] ПРАВИЛА (соблюдай строго): 1. severity — только одно из: "user_impact", "data_risk", "maintainability". - user_impact: ученик видит баг, теряет прогресс, очки, доступ - data_risk: порча БД, утечка, неверный auth/rate-limit - maintainability: запах, дубль, устаревший API 2. snippet — ТОЧНАЯ цитата 1-3 строк из файла. Не перефразируй. Если не уверен — не включай находку. 3. confidence — число от 0 до 1. Если меньше 0.75 — НЕ включай. 4. МАКСИМУМ 10 находок за этот пак. Если находишь больше — выбери ТОП-10 по severity (user_impact > data_risk > maintainability). 5. НЕ пиши находки типа "Ок", "Не баг", "Работает корректно", "Не влияет на UX", "Не критично". Только РЕАЛЬНЫЕ проблемы. 6. НЕ комментируй каждую функцию. Только баги, security, UX. 7. НЕ переписывай код. Только описывай, что не так и что сделать. 8. Без воды. Без общих слов. 9. Если проблем нет — верни пустой массив: []. Отвечай ТОЛЬКО JSON, без markdown-обёрток. Не думай вслух — сразу выдавай JSON-массив. """ USER_PROMPT_TEMPLATE = """Проанализируй часть кода проекта Filwords PL (backend). Это FastAPI + PostgreSQL + asyncpg. Пак: **{pack_name}** — {pack_description} Ищи ТОЛЬКО реальные проблемы: 1. Баги и логические ошибки (не "Ок", а "тут падает") 2. Проблемы безопасности (утечки, инъекции, неправильная валидация) 3. N+1 запросы к БД 4. Отсутствие обработки ошибок (где РЕАЛЬНО упадёт) 5. Дублирование кода 6. Мёртвый код 7. Слабые места архитектуры НЕ пиши "Ок", "Не баг", "Работает корректно". Если проблем нет — верни []. Верни 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, т.к. reasoning-трейс делит бюджет токенов с финальным ответом. Раньше общий "reasoning": {"enabled": False} для GLM тихо игнорировался → весь max_tokens=8000 уходил в мышление → content пустой → "Формат ответа: пусто" на всех GLM-паках. """ 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: одна модель (primary).""" return call_together_model(code, pack, MODEL_PRIMARY) # ============ Парсинг и фильтрация JSON ============ def extract_json(text: str) -> list[dict]: """Извлекает находки из ответа модели. Парсим объекты по одному (json.JSONDecoder.raw_decode) и останавливаемся на первом, который не удалось распарсить — то есть спасаем всё, что модель успела сгенерить до обрезки. """ 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. Только primary → normal. Только secondary → normal. """ 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] = {} # Primary — base for k, f in p_map.items(): item = dict(f) item["_source"] = "primary" if k in s_map: # Пересечение — повышаем confidence 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 # Secondary — только то, чего нет в primary 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]]: """Фильтрует находки: файл существует, snippet совпал, confidence ≥ 0.75, severity валидна. 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 (Backend)") 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 в Gitea ============ def create_issue(title: str, body: str) -> str: """Создаёт Issue в Gitea, возвращает URL.""" 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) 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 (backend): {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()