new

Dockerfile

@@ -18,9 +18,7 @@ RUN python -m spacy download en_core_web_sm && \
     python -m spacy download ru_core_news_sm && \
     python -m spacy download de_core_news_sm && \
     python -m spacy download es_core_news_sm && \
-    python -m spacy download it_core_news_sm && \
-    python -m spacy download pl_core_news_sm && \
-    python -m spacy download pt_core_news_sm
+    python -m spacy download it_core_news_sm
 
 # Копирование приложения
 COPY . .

README.md

@@ -11,18 +11,15 @@ license: mit
 
 # SEO AI Editor
 
-Веб-приложение для анализа и оптимизации SEO-текстов с использованием искусственного интеллекта. Проект использует лингвистический анализ (spaCy), частотный анализ (BM25), BERT-семантику и модульный Semantic Core для сравнения вашего текста с текстами конкурентов.
+Веб-приложение для анализа и оптимизации SEO-текстов с использованием искусственного интеллекта. Проект использует лингвистический анализ (spaCy), частотный анализ (BM25) и семантический анализ (BERT) для сравнения вашего текста с текстами конкурентов.
 
 ## 🚀 Возможности
 
-- **Многоязычный анализ**: Поддержка русского, английского, немецкого, испанского, итальянского, польского и португальского языков
+- **Многоязычный анализ**: Поддержка русского, английского, немецкого, испанского и итальянского языков
 - **N-граммный анализ**: Статистика по униграммам, биграммам, триграммам и квадриграммам
 - **BM25 рекомендации**: Автоматические рекомендации по добавлению/удалению слов и фраз
 - **BERT семантический анализ**: Глубокий анализ релевантности текста ключевым фразам с использованием нейронных сетей
 - **Сравнение с конкурентами**: Детальное сравнение вашего текста с текстами конкурентов
-- **Title Analyzer**: Анализ title-тегов (длина, покрытие ключей, n-граммы, BERT)
-- **Semantic Core (TextAnalyst Web Core)**: Семантический граф, разметка текста, реферат и смысловой поиск
-- **Таблица мощных терминов**: Сравнение слов и фраз с сортировкой по `Мой вес`, `Avg K` и `Freq (X/Y)`
 - **GPU ускорение**: Автоматическое использование GPU для ускорения BERT-анализа
 
 ## 📋 Требования
@@ -65,20 +62,18 @@ python -m spacy download ru_core_news_sm
 python -m spacy download de_core_news_sm
 python -m spacy download es_core_news_sm
 python -m spacy download it_core_news_sm
-python -m spacy download pl_core_news_sm
-python -m spacy download pt_core_news_sm
 ```
 
 ## 🏃 Запуск
 
 Запустите приложение:
 ```bash
-python app.py
+python main.py
 ```
 
 Или используйте uvicorn напрямую:
 ```bash
-uvicorn app:app --host 127.0.0.1 --port 8001 --reload
+uvicorn main:app --host 127.0.0.1 --port 8001 --reload
 ```
 
 Приложение будет доступно по адресу: `http://127.0.0.1:8001`
@@ -94,7 +89,7 @@ uvicorn app:app --host 127.0.0.1 --port 8001 --reload
 
 ### Интерфейс результатов
 
-Приложение предоставляет несколько вкладок с результатами:
+Приложение предоставляет три вкладки с результатами:
 
 #### 🧠 BERT Семантика
 - **Общий рейтинг релевантности**: Сравнение вашего текста и конкурентов по среднему сходству с ключевыми фразами
@@ -118,49 +113,25 @@ uvicorn app:app --host 127.0.0.1 --port 8001 --reload
 - Сравнение с конкурентами
 - Подсветка важных различий
 
-#### 🏷️ Title
-- Длина title (ваш vs конкуренты)
-- Покрытие ключевых фраз и отсутствующие слова
-- N-граммы title и BERT-сходство
-
-#### 🧩 Semantic Core
-- Построение семантического графа (узлы и связи)
-- Разметка значимых понятий в тексте
-- Автоматический реферат (extractive summary)
-- Смысловой поиск по словам и фразам
-- Сравнительная таблица мощных терминов (слова + фразы)
-
 ## 🏗️ Архитектура проекта
 
 ```
 seo_ai_editor/
-├── app.py               # FastAPI приложение (актуальная точка входа)
-├── main.py              # Легаси MVP entrypoint
+├── main.py              # FastAPI приложение и роутинг
 ├── logic.py             # Основная бизнес-логика анализа
 ├── models.py            # Pydantic модели для API
-├── nlp_processor.py      # NLP-предобработка для Semantic Core
-├── semantic_graph.py     # Графовая семантика и веса терминов
-├── highlighter.py        # Гипертекстовая разметка
-├── summarizer.py         # Реферат (сжатие предложений)
-├── search.py             # Смысловой поиск
 ├── requirements.txt     # Зависимости проекта
 ├── templates/
 │   └── index.html       # Frontend интерфейс
 └── README.md            # Документация
 ```
 
-## 📚 Локальная документация
-
-- `docs/FULL_FUNCTIONAL_DOCUMENTATION.md` — полное описание функционала, алгоритмов и API
-- `docs/ARCHITECTURE.md` — архитектура системы и взаимодействие модулей
-- `docs/DEVELOPMENT.md` — практики разработки, процессы и заметки по изменениям
-
 ### Основные компоненты
 
-#### `app.py`
+#### `main.py`
 - FastAPI приложение
-- Роутинг: `/`, `/analyze`, `/api/v1/semantic/analyze`, `/api/v1/semantic/search`
-- Оркестрация BM25/BERT/N-грамм/Title/Semantic Core анализа
+- Роутинг: `/` (главная страница) и `/analyze` (API анализа)
+- Предзагрузка моделей при старте
 
 #### `logic.py`
 Содержит три основных модуля:
@@ -237,25 +208,10 @@ Pydantic модели:
   "bert_analysis": {
     "global_scores": [...],
     "detailed": [...]
-  },
-  "title_analysis": {
-    "...": "..."
   }
 }
 ```
 
-### Endpoint: `/api/v1/semantic/analyze`
-
-**Метод:** POST
-
-**Назначение:** Построение семантического графа, разметки, реферата и сравнения с конкурентами.
-
-### Endpoint: `/api/v1/semantic/search`
-
-**Метод:** POST
-
-**Назначение:** Смысловой поиск по выбранному документу (поддержка слов и фраз).
-
 ## ⚙️ Настройки
 
 ### Языки
@@ -265,8 +221,6 @@ Pydantic модели:
 - `de` - немецкий
 - `es` - испанский
 - `it` - итальянский
-- `pl` - польский
-- `pt` - португальский
 
 ### BERT модель
 По умолчанию используется `paraphrase-multilingual-MiniLM-L12-v2`. Модель можно изменить в функции `get_bert_model()` в файле `logic.py`.

app.py

@@ -1,50 +1,17 @@
 # app.py - Hugging Face Spaces entry point
 
-import json
-import threading
-import uuid
-from queue import Empty, Queue
-
 from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse, StreamingResponse
-from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
 from fastapi.templating import Jinja2Templates
 import uvicorn
 import torch
 import os
 
-from models import (
-    AnalysisRequest,
-    AnalysisResponse,
-    SemanticAnalyzeRequest,
-    SemanticAnalyzeResponse,
-    SemanticSearchRequest,
-    SemanticSearchResponse,
-    UrlFetchRequest,
-    UrlFetchResponse,
-    UserAgentsResponse,
-    OptimizerRequest,
-    OptimizerResponse,
-    OptimizerCancelRequest,
-)
-import logic
-import nlp_processor
-import semantic_graph
-import highlighter
-import summarizer
-import search
-import url_fetcher
-import optimizer
+from models import AnalysisRequest, AnalysisResponse
+import logic 
 
 app = FastAPI(title="SEO AI Editor MVP")
 
-_static_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static")
-if os.path.isdir(_static_dir):
-    app.mount("/static", StaticFiles(directory=_static_dir), name="static")
-
-_OPTIMIZER_JOBS_LOCK = threading.Lock()
-_OPTIMIZER_CANCEL_EVENTS: dict = {}
-
 # Подключаем папку с шаблонами
 templates = Jinja2Templates(directory="templates")
 
@@ -52,13 +19,11 @@ templates = Jinja2Templates(directory="templates")
 async def startup_event():
     device = "cuda" if torch.cuda.is_available() else "cpu"
     print(f"🚀 Application starting. ML Device: {device}")
-    # Важный фикс для HF cpu-basic:
-    # не загружаем все spaCy модели на старте, чтобы не ловить OOM/Restarting.
-    # Модели подгружаются лениво в logic.get_doc() по факту запроса.
+    logic.load_models() # spaCy preload (optional)
 
 @app.get("/", response_class=HTMLResponse)
 async def read_root(request: Request):
-    return templates.TemplateResponse(request, "index.html")
+    return templates.TemplateResponse("index.html", {"request": request})
 
 @app.post("/analyze", response_model=AnalysisResponse)
 async def analyze_text(request: AnalysisRequest):
@@ -126,221 +91,6 @@ async def analyze_text(request: AnalysisRequest):
         title_analysis=title_data
     )
 
-
-@app.post("/api/v1/semantic/analyze", response_model=SemanticAnalyzeResponse)
-async def semantic_analyze(request: SemanticAnalyzeRequest):
-    def _build_doc_semantic(text: str, doc_name: str, doc_id: int):
-        sentences_data = nlp_processor.preprocess_text(text, request.language)
-        graph, word_weights = semantic_graph.build_semantic_graph(
-            sentences_data,
-            lang=request.language,
-        )
-        graph_data = semantic_graph.get_graph_data_for_frontend(graph)
-        markup_text = highlighter.generate_markup_for_frontend(
-            sentences_data, word_weights, threshold=request.threshold
-        )
-        summary_data = summarizer.generate_summary(
-            sentences_data, word_weights, compression_ratio=request.compression_ratio
-        )
-        top_keywords = semantic_graph.get_top_keywords(word_weights, top_n=20)
-        return {
-            "id": doc_id,
-            "name": doc_name,
-            "text": text,
-            "graph": graph_data,
-            "markup_text": markup_text,
-            "summary": summary_data,
-            "top_keywords": top_keywords,
-            "word_weights": word_weights,
-            "stats": {
-                "nodes": len(graph_data.get("nodes", [])),
-                "links": len(graph_data.get("links", [])),
-                "summary_sentences": len(summary_data),
-            },
-        }
-
-    target_doc = _build_doc_semantic(request.text, "Мой текст", 0)
-
-    competitor_docs = []
-    valid_competitors = [c for c in request.competitors if c.strip()]
-    for idx, comp_text in enumerate(valid_competitors):
-        competitor_docs.append(_build_doc_semantic(comp_text, f"Конкурент #{idx + 1}", idx + 1))
-
-    if competitor_docs:
-        avg_nodes = round(sum(c["stats"]["nodes"] for c in competitor_docs) / len(competitor_docs), 2)
-        avg_links = round(sum(c["stats"]["links"] for c in competitor_docs) / len(competitor_docs), 2)
-    else:
-        avg_nodes = 0
-        avg_links = 0
-
-    # Таблица сравнения "мощных терминов" (слова + фразы).
-    num_competitors = len(competitor_docs)
-    target_weights = target_doc.get("word_weights", {})
-    all_terms = set(target_weights.keys())
-    for comp in competitor_docs:
-        all_terms.update(comp.get("word_weights", {}).keys())
-
-    term_power_table = []
-    for term in all_terms:
-        target_weight = int(target_weights.get(term, 0))
-        comp_weights = [int(comp.get("word_weights", {}).get(term, 0)) for comp in competitor_docs]
-        comp_avg_weight = round(sum(comp_weights) / max(num_competitors, 1), 2)
-        comp_occurrence = sum(1 for w in comp_weights if w > 0)
-
-        term_power_table.append(
-            {
-                "term": term,
-                "term_type": "phrase" if " " in term else "word",
-                "target_weight": target_weight,
-                "competitor_avg_weight": comp_avg_weight,
-                "competitor_weights": comp_weights,
-                "comp_occurrence": comp_occurrence,
-                "comp_total": num_competitors,
-            }
-        )
-
-    term_power_table.sort(
-        key=lambda x: (
-            max([x["target_weight"]] + x["competitor_weights"]),
-            x["comp_occurrence"],
-            x["term"],
-        ),
-        reverse=True,
-    )
-
-    comparison = {
-        "target_nodes": target_doc["stats"]["nodes"],
-        "target_links": target_doc["stats"]["links"],
-        "avg_comp_nodes": avg_nodes,
-        "avg_comp_links": avg_links,
-        "num_competitors": num_competitors,
-        "term_power_table": term_power_table,
-    }
-
-    return SemanticAnalyzeResponse(
-        target=target_doc,
-        competitors=competitor_docs,
-        comparison=comparison,
-    )
-
-
-@app.post("/api/v1/semantic/search", response_model=SemanticSearchResponse)
-async def semantic_search_endpoint(request: SemanticSearchRequest):
-    sentences_data = nlp_processor.preprocess_text(request.text, request.language)
-    graph, word_weights = semantic_graph.build_semantic_graph(
-        sentences_data,
-        lang=request.language,
-    )
-    results = search.semantic_search(
-        request.query_text,
-        graph,
-        word_weights,
-        request.language,
-        top_n=request.top_n,
-    )
-    return SemanticSearchResponse(results=results)
-
-
-@app.get("/api/v1/url/user-agents", response_model=UserAgentsResponse)
-async def get_user_agents():
-    return UserAgentsResponse(user_agents=url_fetcher.get_user_agent_presets())
-
-
-@app.post("/api/v1/url/fetch", response_model=UrlFetchResponse)
-async def fetch_url_endpoint(request: UrlFetchRequest):
-    try:
-        parsed = url_fetcher.fetch_url_content(
-            url=request.url,
-            user_agent_key=request.user_agent,
-            timeout_seconds=request.timeout_seconds,
-        )
-        return UrlFetchResponse(**parsed)
-    except Exception as e:
-        return UrlFetchResponse(
-            ok=False,
-            url=request.url or "",
-            user_agent_key=request.user_agent or "",
-            error=str(e),
-        )
-
-
-@app.post("/api/v1/optimizer/run", response_model=OptimizerResponse)
-async def run_optimizer(request: OptimizerRequest):
-    try:
-        result = optimizer.optimize_text(request.model_dump())
-        return OptimizerResponse(**result)
-    except Exception as e:
-        return OptimizerResponse(ok=False, error=str(e))
-
-
-@app.post("/api/v1/optimizer/cancel")
-async def optimizer_cancel(body: OptimizerCancelRequest):
-    with _OPTIMIZER_JOBS_LOCK:
-        ev = _OPTIMIZER_CANCEL_EVENTS.get(body.job_id)
-    if ev is not None:
-        ev.set()
-    return {"ok": True}
-
-
-@app.post("/api/v1/optimizer/run-stream")
-async def run_optimizer_stream(request: OptimizerRequest):
-    """SSE: события прогресса + финальный JSON. Клиент ведёт локальный лог, без глобального лоадера."""
-    job_id = str(uuid.uuid4())
-    cancel_ev = threading.Event()
-    payload = request.model_dump()
-    q: Queue = Queue()
-
-    with _OPTIMIZER_JOBS_LOCK:
-        _OPTIMIZER_CANCEL_EVENTS[job_id] = cancel_ev
-
-    def worker():
-        try:
-            def progress_cb(data):
-                q.put(("progress", data))
-
-            result = optimizer.optimize_text(
-                payload,
-                progress_callback=progress_cb,
-                cancel_event=cancel_ev,
-            )
-            q.put(("done", result))
-        except Exception as e:
-            q.put(("error", str(e)))
-
-    threading.Thread(target=worker, daemon=True).start()
-
-    def gen():
-        try:
-            yield f"data: {json.dumps({'event': 'job', 'job_id': job_id})}\n\n"
-            while True:
-                try:
-                    kind, data = q.get(timeout=0.3)
-                except Empty:
-                    yield ": ping\n\n"
-                    continue
-                if kind == "progress":
-                    yield f"data: {json.dumps(data)}\n\n"
-                elif kind == "done":
-                    yield f"data: {json.dumps({'event': 'complete', 'result': data})}\n\n"
-                    break
-                elif kind == "error":
-                    yield f"data: {json.dumps({'event': 'error', 'error': data})}\n\n"
-                    break
-        finally:
-            with _OPTIMIZER_JOBS_LOCK:
-                _OPTIMIZER_CANCEL_EVENTS.pop(job_id, None)
-
-    return StreamingResponse(
-        gen(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no",
-        },
-    )
-
-
 # Hugging Face Spaces использует порт 7860
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))

docs/FULL_FUNCTIONAL_DOCUMENTATION.md

@@ -1,640 +0,0 @@
-# SEO AI Editor — исчерпывающая документация функционала, логики и алгоритмики
-
-Документ описывает приложение как инженерную спецификацию: что делает каждый модуль, какие данные принимает и возвращает, какие формулы использует, какие ограничения применяет и как воспроизвести поведение системы без чтения исходного кода.
-
----
-
-## 1) Концепция приложения
-
-`SEO AI Editor` объединяет два аналитических контура и один контур улучшения текста:
-
-1. **SEO-контур** (`POST /analyze`)
-   - Word Count (total/significant)
-   - N-gram анализ (1..4)
-   - BM25-рекомендации (`add/remove/ok`)
-   - BERT-семантика по ключам
-   - Title-анализ (length/ngrams/coverage/BERT)
-
-2. **Semantic Core** (`POST /api/v1/semantic/analyze`, `POST /api/v1/semantic/search`)
-   - NLP-разбор и лемматизация
-   - семантический граф (слова + фразы)
-   - веса узлов и связей в шкале `1..100`
-   - гипертекстовая разметка
-   - реферат
-   - смысловой поиск по словам и фразам
-   - сравнение с конкурентами (включая таблицу мощных терминов)
-
-3. **LLM Optimizer** (`POST /api/v1/optimizer/run` или в UI — SSE `run-stream`)
-   - итеративная локальная оптимизация текста
-   - многокритериальный скоринг с защитой от деградации
-   - каскад уровней правок (от минимальных к более широким)
-   - детализированный debug-лог по кандидатам
-
----
-
-## 2) Архитектура и ответственность файлов
-
-- `app.py` — FastAPI оркестратор, endpoint-ы, связывание модулей.
-- `models.py` — Pydantic-модели входов/выходов.
-- `logic.py` — SEO-ядро: токены, n-grams, BM25, BERT, Title.
-- `nlp_processor.py` — NLP-предобработка для semantic-контура.
-- `semantic_graph.py` — построение графа и вычисление смысловых весов.
-- `highlighter.py` — разметка текста по semantic-весам.
-- `summarizer.py` — генерация реферата.
-- `search.py` — смысловой поиск в графе (фразы + слова).
-- `url_fetcher.py` — извлечение текста/title из URL с выбором user-agent.
-- `optimizer.py` — LLM-оптимизация с обратной связью от метрик.
-- `docs/TEXT_OPTIMIZER_PRINCIPLES.md` — живой регламент принципов оптимизатора (stage-пайплайн, допуски, guardrails).
-- `templates/index.html` — разметка UI.
-- `static/js/app.js` — вся клиентская логика (подключается как `/static/js/app.js`; без гигантского inline-скрипта — см. `docs/HF_SES_AND_UI.md`).
-
----
-
-## 3) Поддерживаемые языки
-
-Поддерживаемые языки анализа:
-- `ru`, `en`, `de`, `es`, `it`, `pl`, `pt`
-
-Языки задаются кодом и сопоставляются с spaCy-моделями в `logic.py` (`MODEL_NAMES`).
-
----
-
-## 4) Backend API и контракты
-
-## 4.1 `POST /analyze`
-
-### Назначение
-Комплексный SEO-анализ target-текста относительно конкурентов и ключевых фраз.
-
-### Вход (`AnalysisRequest`)
-- `target_text: str`
-- `competitors: List[str]`
-- `keywords: List[str]`
-- `language: str`
-- `target_title: str`
-- `competitor_titles: List[str]`
-
-### Выход (`AnalysisResponse`)
-- `ngram_stats`
-- `bm25_recommendations`
-- `bert_analysis`
-- `word_counts`
-- `title_analysis`
-
-### Оркестрация в `app.py`
-1. Word counts (`count_words`) для target и каждого competitor.
-2. N-gram статистика (`calculate_ngram_stats`).
-3. Нормализация ключей (`parse_keywords`) и BM25 (`calculate_bm25_recommendations`).
-4. BERT-анализ (`perform_bert_analysis`).
-5. Title-анализ (`analyze_title`) если `target_title` не пустой.
-
----
-
-## 4.2 `POST /api/v1/semantic/analyze`
-
-### Назначение
-Построение semantic-среза по target и конкурентам.
-
-### Вход (`SemanticAnalyzeRequest`)
-- `text: str`
-- `competitors: List[str]`
-- `language: str`
-- `threshold: int` (порог подсветки)
-- `compression_ratio: float` (доля предложений �� реферате)
-
-### Выход (`SemanticAnalyzeResponse`)
-- `target`:
-  - `graph` (`nodes`, `links`)
-  - `markup_text`
-  - `summary`
-  - `top_keywords`
-  - `word_weights`
-  - `stats`
-- `competitors[]`: тот же формат
-- `comparison`:
-  - `target_nodes`, `target_links`
-  - `avg_comp_nodes`, `avg_comp_links`
-  - `num_competitors`
-  - `term_power_table`
-
-### Логика таблицы `term_power_table`
-Для каждого термина из объединения target + competitors:
-- `target_weight`
-- `competitor_avg_weight`
-- `competitor_weights` (`K1..Kn`)
-- `comp_occurrence` (`X` в `X/Y`)
-- `comp_total` (`Y`)
-- `term_type` (`word` или `phrase`)
-
----
-
-## 4.3 `POST /api/v1/semantic/search`
-
-### Назначение
-Смысловой поиск по документу через граф.
-
-### Вход (`SemanticSearchRequest`)
-- `query_text`
-- `text`
-- `language`
-- `top_n`
-
-### Выход (`SemanticSearchResponse`)
-- `results[]`: `lemma`, `score (1..100)`, `type (word|phrase)`
-
----
-
-## 4.4 URL Import API
-
-### `GET /api/v1/url/user-agents`
-Возвращает список пресетов user-agent для выбора в UI.
-
-### `POST /api/v1/url/fetch`
-Извлекает `title` и основной `text` страницы:
-- вход: `url`, `user_agent`, `timeout_seconds`
-- выход: `ok`, `status_code`, `title`, `text`, `error`, `final_url`, agent-метаданные.
-
-Обработка ошибок не ломает UI: endpoint возвращает `ok=false` и `error`.
-
----
-
-## 4.5 `POST /api/v1/optimizer/run`
-
-### Назначение
-Итеративная локальная дооптимизация target-текста через LLM.
-
-### Вход (`OptimizerRequest`)
-- аналитические данные: `target_text`, `competitors`, `keywords`, `language`, `target_title`, `competitor_titles`
-- LLM: `api_key`, `api_base_url`, `model`, `temperature`
-- стратегия: `max_iterations`, `candidates_per_iteration`, `optimization_mode`, `phrase_strategy_mode`, `bert_stage_target`
-  - `phrase_strategy_mode`: `auto | distributed_preferred | exact_preferred | ensemble`
-  - `ensemble`: в пределах итерации циклически пробует несколько phrase-стратегий и ранжирует кандидаты общей utility-функцией.
-  - `bert_stage_target`: пользовательский порог завершения этапа A (BERT), например `0.61` вместо `0.70`.
-
-### Выход (`OptimizerResponse`)
-- `optimized_text` — итоговый body (target)
-- `optimized_title` — итоговая строка для поля **Title**; в ответе она берётся из снимка `title_analysis.target_title` (тот же текст, что учитывался в метрике Title BERT), с запасным вариантом из переменной оптимизатора. В `final_metrics` дополнительно есть `resolved_title` с тем же смыслом (удобно для UI/fallback).
-- `baseline_metrics`, `final_metrics`
-- `iterations[]` (подробный лог шагов)
-- `applied_changes`
-- `optimization_mode`
-- `phrase_strategy_mode`
-- `bert_stage_target`
-- `stopped_early`, `stop_reason` — при ручной остановке (частичный результат)
-- `error` (если есть)
-
-### `POST /api/v1/optimizer/run-stream` (SSE)
-Тело как у `run`. Поток `text/event-stream`, события `job` (с `job_id`), `preparing`, `started`, `step_start`, `llm_call`, затем `complete` с полем `result` или `error`.
-
-### `POST /api/v1/optimizer/cancel`
-Тело: `{"job_id": "..."}`. Только флаг отмены; клиент дочитывает SSE до `complete`.
-
-### UI и HF/SES
-Клиентский код: **`static/js/app.js`** + `GET /static/js/app.js`. Прогресс оптимизатора — **локальная панель с текстовым логом** (и тонкая полоса), **без** `#loader`. Подробности про SES и «мёртвые кнопки»: `docs/HF_SES_AND_UI.md`.
-
----
-
-## 5) Подробная алгоритмика по модулям
-
-## 5.1 `logic.py` — SEO-ядро
-
-### `load_model_if_missing(lang)`
-Ленивая загрузка spaCy-модели конкретного языка. Цель: не загружать все модели на старте (критично для HF ресурсов).
-
-### `load_models()`
-Служебная массовая загрузка моделей (используется ограниченно; основной путь в проде — lazy).
-
-### `get_doc(text, lang)`
-Единая точка получения spaCy `Doc` с предобработкой языка/модели.
-
-### `is_valid_token(t)`
-Фильтр значимых токенов (исключает шумовые категории: punctuation/space/часть stop и др.).
-
-### `get_lemmas_flat(text, lang)`
-Плоский список лемм значимых токенов. Базовый строительный блок для метрик.
-
-### `generate_ngrams_safe(text, lang, n)` — Smart Window
-Ключевой принцип:
-- размер окна задается по **значимым** словам;
-- stop-слова внутри валидного окна могут сохраняться для естественных фраз;
-- символные границы (punct/num/sym) не дают сшивать ложные фразы.
-
-Это гарантирует более естественные n-grams и согласованность между разными подсистемами.
-
-### `count_words(text, lang)`
-Возвращает:
-- `total` — количество словоформ
-- `significant` — количество значимых токенов после фильтра
-
-### `calculate_ngram_stats(target_text, competitor_texts, lang)`
-Строит частотные словари 1..4-грамм, агрегирует:
-- частоты target
-- средние частоты competitors
-- сигналы дефицита/избытка
-- детализацию по каждому конкуренту (для интерфейсных таблиц)
-
-### `parse_keywords(raw_phrases, lang)`
-Нормализует сырые ключи пользователя в:
-- фразовые ключи
-- униграммы
-с учетом текущего языка и лемматизации.
-
-### `calculate_bm25_recommendations(...)` — Mirror Principle
-BM25 использует тот же подход токенизации/фразогенерации, что и n-gram ядро.
-Смысл:
-- сравнить релевантность target и среднего competitor-профиля по тем же термам;
-- выдать действие:
-  - `add` — недобор терма,
-  - `remove` — вероятный переспам,
-  - `ok` — баланс.
-
-### `get_bert_model()`
-Ленивая инициализация sentence-transformers модели.
-
-### `perform_bert_analysis(target_text, competitor_texts, key_phrases, lang)`
-Для каждой ключевой фразы:
-- ищет наиболее близкие чанки текста;
-- считает similarity для target и competitors;
-- формирует детализацию (`my_max_score`, competitor-сравнение, статусы).
-
-### `analyze_title(target_title, competitor_titles, raw_keywords, lang)`
-Оркестратор Title-пайплайна:
-- `_title_length`
-- `_title_ngrams`
-- `_title_keyword_coverage`
-- `_title_bert`
-
-#### `_title_length(...)`
-Сравнивает длину target title с конкурентным диапазоном/средним.
-
-#### `_title_ngrams(...)`
-N-gram сопоставление title-уровня.
-
-#### `_title_keyword_coverage(...)`
-Проверяет покрытие пользовательских ключей в target и competitor title.
-
-#### `_title_bert(...)`
-Оценивает semantic-близость title к ключевому набору.
-
----
-
-## 5.2 `nlp_processor.py`
-
-### `preprocess_text(text, lang)`
-Преобразует текст в структуру предложений:
-- `raw_text`
-- `tokens[]` с полями `text`, `whitespace`, `lemma`, `is_significant`, `is_punct`, `is_space`
-- `lemmas_clean` (очищенный список лемм)
-
-Критично: сохранение `whitespace` и исходных токенов позволяет восстановить текст UI-послойно без потери форматирования.
-
----
-
-## 5.3 `semantic_graph.py` — математическое ядро
-
-### `_normalize_to_1_100(values)`
-Нормализация произвольных весов в целочисленную шкалу `1..100`.
-
-### `_extract_significant_lemmas(sent)`
-Достает значимые леммы из предложения.
-
-### `_is_noise_sentence(text)`
-Отбрасывает шумовые фрагменты (короткие CTA, boilerplate-паттерны).
-
-### `_canonicalize_term(term)`
-Rule-based каноникализация термов (снижение дублей и вариативности).
-
-### `_extract_phrase_candidates(sentence_text, lang)`
-Извлечение кандидатных фраз через `generate_ngrams_safe` и фильтры.
-
-### `_normalize_lemma_sequence(lemmas)`
-Нормализация последовательностей лемм для устранения артефактов.
-
-### `build_semantic_graph(sentences_data, lang)`
-Базовые шаги:
-1. Сформировать множество терминов (слова + фразы).
-2. Подсчитать частоты терминов и совместные появления.
-3. Постр��ить направленный граф.
-4. Рассчитать вес ребра:
-   - `P(B|A) = cooc(A,B) / occ(A) * 100`
-   - затем ограничение в `0..100`.
-5. Рассчитать важность узлов:
-   - PageRank как глобальная связность,
-   - termness/coverage корректировки,
-   - штрафы для слишком общих доменных токенов.
-6. Вернуть граф и карту `word_weights`.
-
-### `get_graph_data_for_frontend(graph, top_edges_per_node=8)`
-Сериализует `networkx` граф в плоский JSON:
-- `nodes[]`
-- `links[]`
-с ограничением числа ребер на узел для управляемого рендера.
-
-### `get_top_keywords(node_weights, top_n=20)`
-Возвращает top-N терминов по весу.
-
----
-
-## 5.4 `highlighter.py`
-
-### `generate_markup_for_frontend(sentences_data, word_weights, threshold=50)`
-Маркирует важные блоки:
-- если вес леммы/фразы >= порога, блок становится `is_link=true`;
-- соседние значимые токены могут объединяться в один кликабельный сегмент;
-- возвращается структура, удобная для реактивного рендера в UI.
-
----
-
-## 5.5 `summarizer.py`
-
-### `generate_summary(sentences_data, word_weights, compression_ratio)`
-Скоринг предложения:
-- `score = sum(weight(unique_lemmas)) / sqrt(token_count)`
-
-Далее:
-1. сортировка по score убыв.
-2. выбор top по `compression_ratio`
-3. восстановление хронологического порядка для читабельности.
-
----
-
-## 5.6 `search.py`
-
-### `_normalize_query_text(text)`
-Нормализует запрос для устойчивого поиска.
-
-### `semantic_search(query_text, G, word_weights, language, top_n)`
-Алгоритм:
-1. Нормализовать и лемматизировать запрос.
-2. Приоритетно проверить фразы (tri/bi) из запроса.
-3. Fallback на слова.
-4. Для найденных точек входа добавить соседей по графу.
-5. Собрать score из силы связи и веса узла.
-6. Нормализовать score в `1..100`.
-7. Вернуть top-N и тип (`phrase`/`word`).
-
----
-
-## 5.7 `url_fetcher.py`
-
-### `get_user_agent_presets()`
-Возвращает список пресетов (Googlebot, Bingbot, ChatGPT user-agent, GPTBot, Chrome Desktop и др.).
-
-### `_normalize_whitespace(text)`
-Схлопывает лишние пробелы/переводы строк.
-
-### `_normalize_url(url)`
-Приводит URL к валидному виду (схема, trimming).
-
-### `_resolve_user_agent(user_agent_key)`
-По ключу выбирает фактическую строку user-agent.
-
-### `_extract_main_text_and_title(html)`
-HTML extraction pipeline:
-- удалить `script/style/noscript/nav/footer/header/form/svg` и прочий boilerplate;
-- приоритетно извлекать `article/main`;
-- fallback на абзацы/списки;
-- final fallback на `body` текст;
-- вернуть очищенный `title` и основной `text`.
-
-### `fetch_url_content(url, user_agent_key, timeout_seconds)`
-Выполняет HTTP-запрос и возвращает структурированный результат для UI/API.
-
----
-
-## 5.8 `optimizer.py` — LLM-оптимизация текста
-
-### Цель модуля
-Итеративно улучшать конкретные проблемные зоны из аналитики, избегая полной перегенерации текста и сохраняя стиль/повествование.
-
-### Служебные функции подготовки
-- `_tokenize` — токенизация строки.
-- `_filter_stopwords` — удаление stop-слов.
-- `_split_sentences` — сегментация на предложения.
-- `_max_sentences_for_level` — лимиты длины кандидата по каскаду.
-- `_validate_candidate_text` — pre-check качества (пустота, дубль слова/сущности, подозрительные токен-склейки, превышение лимита предложений).
-
-### Снимки аналитики
-- `_build_analysis_snapshot` — пересчет `/analyze` локально.
-- `_build_semantic_snapshot` — пересчет semantic среза локально.
-
-### Скоринг и выбор цели
-- `_compute_metrics` — единый набор метрик состояния:
-  - composite score
-  - `bert_low_count`
-  - `bert_phrase_scores`
-  - `bm25_remove_count`
-  - сигналы n-gram/semantic
-  - `title_bert_score`
-  - `semantic_gap_count`, `semantic_gap_sum`, `semantic_gap_terms`
-- `_choose_optimization_goal` — выбирает приоритетную проблему.
-  - для BERT-целей используется порог `BERT_TARGET_THRESHOLD=0.7` (допустимый рабочий минимум может быть снижен до `0.65`), без конкурентного override;
-- `_choose_sentence_idx` — выбирает релевантный чанк для правки.
-
-### Параметры Semantic Gap в оптимизаторе
-- `SEMANTIC_GAP_TOLERANCE_PCT = 0.15` — допускается отклонение до ~15% от target, без штрафа.
-- `SEMANTIC_GAP_MIN_ABS = 3.0` — игнорируются микрошумы с маленькой абсолютной разницей.
-- Gap считается значимым, если одновременно:
-  - `competitor_avg_weight > target_weight * (1 + tolerance)`
-  - `competitor_avg_weight - target_weight >= min_abs`
-
-Это убирает пере-жесткую подгонку к среднему конкуренту и снижает ложные колебания `semantic_gap_count`.
-
-### Генерация кандидатов
-- `_llm_edit_chunk` — отправляет structured prompt в OpenAI-compatible API.
-  - роль модели в prompt: **semantic-vector optimizer for SEO**, а не общий “copy editor”.
-  - учитывает `cascade_level` и тип операции (`rewrite`/`insert`)
-  - явно требует грамматически корректный и естественный текст
-  - ограничивает число предложений по уровню
-  - для BERT динамически выбирает стратегию по длине целевой фразы:
-    - короткие цели: допустим один natural exact match;
-    - длинные multi-word цели: приоритет у distributed semantic coverage (части фразы/леммы/близкие формулировки), без forced exact match.
-  - exact phrase не должен повторяться: при неестественном звучании он запрещается в пользу распределённой формулировки.
-  - для `rewrite` явно требует сохранить исходный смысл `sentence-by-sentence` и не менять субъект/ключевую сущность без необходимости.
-
-### Применение правок
-- `_replace_span` — замена диапазона предложений.
-- `_insert_after` — вставка после диапазона.
-
-### Принятие/отклонение кандидата
-- `_goal_improved`:
-  - для BERT: улучшение score целевой фразы минимум на `BERT_GOAL_DELTA_MIN=0.005` **или** снижение `bert_low_count`;
-  - для других целей: профильные метрики улучшения.
-- `_candidate_utility`:
-  - многоцелевая функция полезности кандидата с динамическими весами;
-  - учитывает одновременно `bert_phrase_delta`, `chunk_goal_delta`, `score_delta`;
-  - добавляет мягкие штрафы за регрессии по BM25/BERT-low/N-gram/SemanticGap/Title;
-  - в BERT-push режиме (когда фраза ниже порога) усиливает вес phrase-level прогресса.
-- `_is_candidate_valid`:
-  - hard constraints (не ухудшать критичные метрики сверх допустимого);
-  - режимы `conservative/balanced/aggressive` задают пороги регрессии;
-  - решение учитывает и `goal_improved`, и общий `delta_score`.
-- `_is_stage_complete` для `bert`:
-  - этап считается завершённым только когда **каждая** отслеживаемая ключевая фраза достигает `bert_stage_target` (проверка по `min(bert_phrase_scores)`);
-  - достижение порога одной «сильной» фразой больше не завершает BERT-этап.
-  - унифицированный цикл по целям: базовые параметры запроса `max_iterations` и `candidates_per_iteration` задают «якорь», но для **каждой** цели вычисляется эффективный бюджет (`_per_goal_budget`): число попыток и ширина пула кандидатов **масштабируются по дефициту** до таргета — для BERT по разрыву score до порога, для semantic по `semantic_gap`, для n-gram по отставанию/перегрузу относительно целевого счётчика, для BM25 по «лишним» вхождениям слова, для title по разрыву `title_bert_score`. После исчерпания лимита по текущей цели оптимизатор переходит к следующей цели той же стадии.
-- `_validate_candidate_text`:
-  - отклоняет некачественные/спамные кандидаты (дубли слов/сущностей, подозрительные склейки токенов);
-  - добавляет anti-stuffing фильтр для цели BERT (повторы exact phrase и чрезмерные повторы focus-термов).
-
-### Главная функция `optimize_text`
-Итерационный цикл:
-1. baseline metrics.
-   - общий бюджет шагов оценивается как **сумма эффективных итераций по всем целям** (`_estimate_total_loop_budget`: для каждой цели — `_per_goal_budget`, затем сумма по стадиям с верхней отсечкой), то есть масштабируется и по числу целей, и по величине отставания от таргета. В SSE-событии `step_start` дополнительно передаются `goal_budget_iter` и `goal_budget_candidates` для текущей цели.
-2. выбрать goal.
-3. выбрать пул чанков и операцию каскада.
-   - **Этап `title`:** если средняя BERT-близость Title к ключам (`title_bert_score`) ниже порога (`TITLE_TARGET_THRESHOLD` ≈ 0.65), цель — **только переписать текст из поля Title** (`target_title`), а не абзац основного текста. LLM получает текущий title, выдержку из body и ключевые слова; метрики пересчитываются с новым title. Пакетные правки по body с title не смешиваются.
-   - **Проверка деплоя:** в debug кандидата для шага `title` в `llm_prompt_debug` должно быть `"operation": "title_rewrite"`, а `chunk_text` — короткая строка текущего Title. Если видите `"operation": "rewrite"` и длинный `chunk_text` из body — на сервере старая версия `optimizer.py` (или не пересобран образ).
-   - на шаг выбирается несколько span-кандидатов (multi-chunk selection), а не один;
-   - ранжирование учитывает `focus_terms/avoid_terms`, chunk-level relevance и шумовые эвристики (menu/CTA/header penalties);
-   - для **n-gram** целей предложения ранжируются через **скользящие перекрывающиеся окна** из 2–4 предложений (шаг 1): каждому предложению присваивается лучший балл среди окон, оценка штрафует локальные повторы фразы и шумовые блоки;
-   - для BERT-целей ранжирование не ограничивается участками с already-present вхождениями: дополнительно приоритизируются релевантные участки с недопредставленными core-термами, где их можно добавить естественно;
-   - используется `attempt_cursor` по цели и `attempted_spans`, чтобы избежать циклов по одному и тому же участку.
-4. сгенерировать `N` кандидатов для каждого выбранного span (`N` зависит от эффективного бюджета кандидатов для цели и каскада, см. `_per_goal_budget` и деление по span).
-5. pre-validation (формат/качество/длины).
-6. chunk-level оценка:
-   - вычисляется `chunk_goal_delta` (релевантность чанка до/после к текущей цели);
-   - кандидат помечается `local_chunk_improved`, если прирост выше порога цели.
-7. document-level оценка:
-   - полный пересчет метрик для всего текста;
-   - проверка глобальных ограничений через `_is_candidate_valid`.
-8. staged acceptance:
-   - если кандидат улучшает цель/общий score и проходит глобальные ограничения — `applied`;
-   - если локально улучшает чанк, но глобально не проходит — кандидат кладется в queue.
-   - для BERT учитывается прямой документный `bert_phrase_delta` по целевой фразе: даже небольшой положительный рост считается полезным шагом при отсутствии регре��сий по guardrails.
-   - если нет `promotable` кандидата, но есть guardrail-valid кандидат с `local_chunk_improved`, применяется режим `applied_local_progress`: правка принимается локально и оптимизация переходит к следующему чанку (накопительная стратегия).
-   - ранжирование и выбор best-кандидата дополнительно учитывают `candidate_utility`, чтобы BERT-оптимизация не вредила следующим этапам по другим метрикам.
-9. batch-логика queue:
-   - optimizer пробует совместно применить комбинации из 2..4 локально сильных не конфликтующих правок;
-   - batch принимается только при прохождении глобальных ограничений и положительном совокупном локальном приросте.
-10. при серии неудач эскалировать каскад (`L1 -> L2 -> L3 -> L4`), при успехе сбрасывать на `L1`.
-   - `L1`: локальный rewrite (обычно 1 предложение),
-   - `L2`: rewrite расширенного окна (2-3 предложения, несколько вариантов радиусов),
-   - `L3`: insert bridge (вставка) с возможным fallback на rewrite,
-   - `L4`: более широкий rewrite окна (до 5 предложений с вариативным охватом).
-11. вести подробный лог по каждому кандидату.
-   - в debug-таблице фиксируются и chunk-level сигналы (`local+`, `chunk Δ`, `rel before->after`) наряду с глобальными (`Δ score`, `valid`, `goal+`);
-   - для каждого кандидата сохраняется `llm_prompt_debug` (операция, цель, фокус-термы, chunk и ближайший контекст), что позволяет анализировать фактический вход в LLM;
-   - LLM возвращает поле `rationale` (1 строка) — краткое объяснение, почему правка должна повысить релевантность цели.
-   - также сохраняется `metrics_delta` (вклад BM25/BERT/Semantic/N-gram/Title в общий сдвиг), включая `semantic_gap_sum` и изменение состава gap-термов (`semantic_gap_terms_added/removed`), чтобы видеть, за счет чего падает или растет `score`.
-
----
-
-## 6) Frontend (`templates/index.html` + `static/js/app.js`)
-
-## 6.1 Ввод данных и URL import
-- `loadUserAgentOptions` — загрузка пресетов UA.
-- `fetchUrlPayload` — запрос к URL API.
-- `fetchTargetFromUrl` — заполнение target text/title из URL.
-- `fetchCompetitorsFromUrls` — массовое заполнение competitors.
-
-Ручной ввод всегда остается рабочим fallback-сценарием.
-
-## 6.2 Локальное сохранение проекта
-- `saveProject` — экспорт JSON.
-- `loadProject` — загрузка JSON.
-- `applyProjectData` — восстановление полей и результатов.
-- `clearProject` — новый проект/сброс.
-
-API-ключ оптимизатора в persist-состояние не сохраняется.
-
-## 6.3 Запуск аналитики и отрисовка
-- `runAnalysis`
-- `runSemanticAnalysis`
-- `runSemanticSearch`
-- `renderResults`
-- `renderSemanticResults`
-- `renderTitleResults`
-- `showNgramTable`
-
-## 6.4 Сводка и оптимизатор
-- `renderActionSummary` — агрегирует рекомендации BERT/BM25/N-grams/Title/Semantic в табличный формат.
-- `runLlmOptimization` — `POST /api/v1/optimizer/run-stream` (SSE); локальная панель **лога** + тонкий progress bar; **без** `#loader`.
-- `requestStopOptimizer` — `POST /api/v1/optimizer/cancel`; поток дочитывается до `complete` (частичный результат).
-- `optimizerLogAppend` / `applyOptimizerStreamEvent` — текстовый ход работы.
-- `renderOptimizerResults` — итог и debug-лог; баннер при `stopped_early`.
-- `applyOptimizedText` — перенос optimized текста в `target_text`.
-- `nv(v, d)` — nullish-fallback без операторов `??` (SES на HF).
-
-## 6.5 Сортировка таблицы мощных терминов
-- `setSemanticTermSortBy`
-- `toggleSemanticTermSortDir`
-
-Поддерживаются сортировки по:
-- `Мой вес`
-- `Avg K`
-- `Freq (X/Y)` (с приоритетом большего `X` при одинаковом `Y`)
-
----
-
-## 7) Данные и модели (`models.py`)
-
-Ключевые модели:
-- `AnalysisRequest`, `AnalysisResponse`
-- `SemanticAnalyzeRequest`, `SemanticAnalyzeResponse`
-- `SemanticSearchRequest`, `SemanticSearchResponse`
-- `UrlFetchRequest`, `UrlFetchResponse`, `UserAgentInfo`, `UserAgentsResponse`
-- `OptimizerRequest`, `OptimizerResponse`
-
-Роль моделей:
-- жестко фиксируют API-контракты;
-- упрощают валидацию;
-- создают стабильный интерфейс между frontend/backend.
-
----
-
-## 8) Практические вычислительные принципы
-
-1. **Согласованная нормализация**  
-   Одни и те же правила токенизации/лемматизации используются в нескольких модулях, чтобы избежать рассинхронизации метрик.
-
-2. **Локальные правки вместо полной перегенерации**  
-   Оптимизатор меняет только локальные участки текста и проверяет эффект после каждой правки.
-
-3. **Многокритериальная защита**  
-   Кандидат не принимается, если улучшение одной метрики достигается ценой неприемлемой деградации других.
-
-4. **Объяснимость**  
-   Подробный лог итераций фиксирует baseline шага, кандидатов, причины отклонения и примененный вариант.
-
----
-
-## 9) Рекомендации по воспроизведению приложения по документации
-
-Минимальный путь воспроизведения:
-1. Поднять FastAPI-приложение с endpoint-ами из раздела 4.
-2. Реализовать `logic.py` и `semantic_*` модули с описанными формулами и пайплайнами.
-3. Сделать frontend с соответствующими сценариями (`runAnalysis`, `runSemanticAnalysis`, `runLlmOptimization`).
-4. Добавить URL extractor и LLM optimizer как отдельные backend сервисы.
-5. Проверить контракты ответов, чтобы UI-таблицы и вкладки заполнялись без адаптеров.
-
----
-
-## 10) Эксплуатация и деплой (Hugging Face)
-
-- Рекомендуемый режим: lazy загрузка моделей.
-- При проблемах типа `Could not resolve host: huggingface.co` рассматривать как внешнюю инфраструктурную проблему DNS/egress.
-- Для диагностики сверять:
-  - `repo_sha` и `runtime_sha`
-  - `runtime_stage`
-- При зависании сборки использовать повторный trigger-build.
-
----
-
-## 11) Smoke-check после любых изменений
-
-1. `python -m py_compile app.py logic.py semantic_graph.py search.py optimizer.py url_fetcher.py`
-2. Проверка endpoint-ов:
-   - `/analyze`
-   - `/api/v1/semantic/analyze`
-   - `/api/v1/semantic/search`
-   - `/api/v1/url/user-agents`
-   - `/api/v1/url/fetch`
-   - `/api/v1/optimizer/run`
-3. Проверка UI:
-   - табы рендерятся;
-   - сортировки и таблицы работают;
-   - URL import заполняет text/title;
-   - save/load/new project работают;
-   - оптимизатор пишет лог и применяет текст.
-

docs/HF_SES_AND_UI.md

@@ -1,28 +0,0 @@
-# Почему на Hugging Face «умирали» все кнопки (версии с прогресс-баром)
-
-По **фактам из консоли** (не гипотезы):
-
-## 1. `SES_UNCAUGHT_EXCEPTION: SyntaxError: missing : in conditional expression`
-
-На странице Space подключается **SES lockdown** (`lockdown-install.js`). Его парсер/конвейер для кода страницы **не эквивалентен** последнему движку Firefox/Chrome в части синтаксиса ES2020+.
-
-- Операторы **`??` (nullish coalescing)** и **`?.` (optional chaining)** в **одном исходнике** с большим inline-`<script>` давали ошибку разбора, интерпретируемую как **сломанный тернарный `? … :`** → *missing ':'*.
-- После этой ошибки **весь** клиентский скрипт приложения **не выполняется** → не регистрируются **ни** `onclick`, **ни** делегирование `data-app-action` → кажется, что «сломались все кнопки».
-
-**Исправление:** не использовать `??` / `?.` в коде приложения; вместо них — функция `nv(v, d)` и проверки `obj && obj.prop`.
-
-## 2. Глобальный `#loader`
-
-Если на время оптимизатора включать полноэкранный оверлей и по какой-то причине не снять `display` в `finally`, **все клики** уходят в оверлей. Это уже не SES, а логика UI.
-
-**Исправление:** во время LLM-оптимизации **не** трогать `#loader`; прогресс только в **локальной панели** под кнопками.
-
-## 3. Строки CSP про `inpage.js`, Stripe, `content.js`
-
-В логе часто идут **расширения браузера** и iframe HF, а не ваш `index.html`. На диагностику кнопок приложения они обычно не влияют.
-
-## Текущая схема (после правок)
-
-- Логика UI в **`/static/js/app.js`** (отдельный файл, не гигантский inline).
-- Прогресс оптимизатора: **панель с `<pre>`-логом** + тонкая полоса; **без** блокировки всего экрана.
-- Поток **`/api/v1/optimizer/run-stream`** (SSE) + **`/api/v1/optimizer/cancel`** для остановки с частичным результатом.

docs/TEXT_OPTIMIZER_PRINCIPLES.md

@@ -1,99 +0,0 @@
-# Text Optimizer Principles
-
-This document is a living spec for iterative text optimization behavior.
-Update it whenever optimization policy changes.
-
-## 1) Multi-objective optimization model
-
-- **Primary objective (by stage):**
-  - Stage A: BERT phrase relevance
-  - Stage B: BM25 remove cleanup
-  - Stage C: N-gram balancing
-  - Stage D: Semantic gap balancing
-  - Stage E: Title alignment
-- **Guardrails (always active):**
-  - Do not allow critical metric regressions beyond mode tolerances.
-  - Keep grammar, coherence, and non-spam writing.
-
-## 2) Stage order and skipping
-
-- Stage order:
-  - `bert -> bm25 -> ngram -> semantic -> title`
-- A stage is skipped if no actionable goal exists.
-- Plateau rule:
-  - If no primary progress for 3 steps, move to next stage.
-
-## 3) BERT stage policy
-
-- Default Stage A threshold: `0.70`.
-- User may set custom threshold via UI (`BERT target A-stage`), e.g. `0.61`.
-- Stage A is complete when max target phrase score reaches configured threshold.
-
-## 4) BM25 stage policy
-
-- Main target: reduce/remove over-optimization signals.
-- A stage is considered healthy when `bm25_remove_count <= 3`.
-
-## 5) N-gram stage policy (quantitative)
-
-- Goal: bring target counts closer to competitor average, not force exact equality.
-- Tolerance bands:
-  - if `avg >= 4`: acceptable range is `avg +/- 20%`
-  - if `avg < 4`: acceptable range is `avg +/- 50%`
-- N-gram signal is counted only when term is outside tolerance and present in enough competitors.
-- Selection rules (multi-competitor mode, `competitors > 1`):
-  - bi-grams and tri-grams are eligible when present in `>= 2` competitors;
-  - unigrams are eligible only if they are part of user keyword phrases and present in `>= 2` competitors.
-- Target ranking (which n-gram to work on next):
-  - sort eligible **underrepresented** rows by **Freq(K)** (`comp_occurrence`) descending,
-    then **Avg(K)** (`competitor_avg`) descending,
-    then **deviation** from competitor average descending (larger gap first).
-- Iteration behavior:
-  - optimizer works on one n-gram target at a time per step;
-  - per eligible n-gram target it allocates `3` attempts, then moves to the next target;
-  - if target list ends, stage advances to the next optimization stage.
-- **Global step budget:** the UI `max_iterations` cap still limits total loop iterations, but the
-  optimizer **adds** extra steps reserved for the n-gram stage (`targets × 3`, capped) so a low
-  `max_iterations` value does not stop the run after only three n-gram rows while many targets remain.
-- **Chunk selection (n-gram stage):** candidate sentences are ranked using **overlapping multi-sentence
-  windows** (stride 1). Each sentence receives the best window score; windows favor low local phrase
-  duplication, topical overlap with phrase tokens, and non-noisy prose. Document-level phrase count
-  remains the primary acceptance signal.
-
-## 5.1 Summary logic memory (current)
-
-- Summary recommendation triggers:
-  - BERT warning when phrase score `< 0.70`;
-  - BM25 warning when `REMOVE >= 4`;
-  - N-gram warning when term is underrepresented among competitors;
-  - Title warning when Title BERT `< 0.65`;
-  - Semantic warning when keyword terms are weaker than competitor average.
-- For N-grams in summary:
-  - summary renders top rows for readability, but optimizer runs against the full eligible candidate set.
-
-## 6) Local acceptance and batch accumulation
-
-- First evaluate candidate locally (chunk-level), then globally (document-level).
-- Locally improved candidates may be queued when global score does not move yet.
-- Non-conflicting queued edits can be applied as a batch (2-4 edits) if guardrails pass.
-
-## 7) Text quality constraints
-
-- Reject candidates with:
-  - duplicated entities/words,
-  - suspicious token joins,
-  - excessive sentence count for current cascade level,
-  - obvious stuffing/redundancy.
-- Keep narrative continuity and original subject/entity focus.
-
-## 8) Diagnostics requirements
-
-- For every iteration, store:
-  - stage, goal, cascade level,
-  - candidate validity, local improvement, metric deltas,
-  - selected strategy and prompt debug payload.
-- UI must show:
-  - stage progression,
-  - stage transitions,
-  - candidate strategy and reason for rejection.
-

highlighter.py

@@ -1,63 +0,0 @@
-from typing import Dict, List, Any
-
-
-def generate_markup_for_frontend(
-    sentences_data: List[Dict[str, Any]],
-    word_weights: Dict[str, int],
-    threshold: int = 50,
-) -> List[Dict[str, Any]]:
-    """
-    Генерирует разметку текста для фронтенда.
-    Возвращает массив предложений, где каждое предложение состоит из блоков:
-    - обычный текст
-    - кликабельное понятие (is_link = True)
-    """
-    output: List[Dict[str, Any]] = []
-
-    for sent in sentences_data:
-        blocks: List[Dict[str, Any]] = []
-        buffer_text = ""
-
-        for tok in sent.get("tokens", []):
-            text_piece = f"{tok.get('text', '')}{tok.get('whitespace', '')}"
-            lemma = tok.get("lemma", "")
-            is_link = bool(tok.get("is_significant")) and word_weights.get(lemma, 0) >= threshold
-
-            if is_link:
-                if buffer_text:
-                    blocks.append({"text": buffer_text, "is_link": False})
-                    buffer_text = ""
-                # Склеиваем подряд идущие значимые токены в одну "понятийную" фразу,
-                # чтобы подсветка выглядела как словосочетание, а не набор одиночных слов.
-                if blocks and blocks[-1].get("is_link"):
-                    blocks[-1]["text"] += text_piece
-                    blocks[-1]["lemmas"].append(lemma)
-                    blocks[-1]["weight"] = max(
-                        int(blocks[-1].get("weight", 0)),
-                        int(word_weights.get(lemma, 0)),
-                    )
-                else:
-                    blocks.append(
-                        {
-                            "text": text_piece,
-                            "is_link": True,
-                            "lemmas": [lemma],
-                            "weight": int(word_weights.get(lemma, 0)),
-                        }
-                    )
-            else:
-                buffer_text += text_piece
-
-        if buffer_text:
-            blocks.append({"text": buffer_text, "is_link": False})
-
-        output.append(
-            {
-                "index": sent.get("index", 0),
-                "raw_text": sent.get("raw_text", ""),
-                "blocks": blocks,
-                "lemmas_clean": sent.get("lemmas_clean", []),
-            }
-        )
-
-    return output

logic.py

@@ -18,9 +18,7 @@ MODEL_NAMES = {
     "ru": "ru_core_news_sm",
     "de": "de_core_news_sm",
     "es": "es_core_news_sm",
-    "it": "it_core_news_sm",
-    "pl": "pl_core_news_sm",
-    "pt": "pt_core_news_sm",
+    "it": "it_core_news_sm"
 }
 
 # --- SPACY (Лингвистика) ---

main.py

@@ -25,7 +25,7 @@ async def startup_event():
 @app.get("/", response_class=HTMLResponse)
 async def read_root(request: Request):
     # Рендерим файл index.html
-    return templates.TemplateResponse(request, "index.html")
+    return templates.TemplateResponse("index.html", {"request": request})
 
 @app.post("/analyze", response_model=AnalysisResponse)
 async def analyze_text(request: AnalysisRequest):

models.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from typing import List, Dict, Optional, Any
 
 
@@ -10,128 +10,13 @@ class AnalysisRequest(BaseModel):
     target_text: str                # Текст пользователя
     competitors: List[str]          # Список текстов конкурентов
     keywords: List[str]             # Список ключевых фраз (сырых)
-    language: str = "en"            # en, ru, de, es, it, pl, pt
+    language: str = "en"            # en, ru, de, es, it
     target_title: str = ""          # Title пользователя
-    competitor_titles: List[str] = Field(default_factory=list)  # Title конкурентов
+    competitor_titles: List[str] = []  # Title конкурентов
 
 class AnalysisResponse(BaseModel):
     ngram_stats: dict               # Статистика униграм/биграм
     bm25_recommendations: List[dict] # Рекомендации "добавить/убрать"
     bert_analysis: Dict[str, Any]   # Векторный анализ
     word_counts: Dict[str, Any]     # {'target': 500, 'competitors': [600, 450], 'avg': 525}
-    title_analysis: Dict[str, Any] = Field(default_factory=dict)  # Анализ Title
-
-
-class SemanticAnalyzeRequest(BaseModel):
-    text: str
-    competitors: List[str] = Field(default_factory=list)
-    language: str = "ru"
-    threshold: int = 50
-    compression_ratio: float = 0.1
-
-
-class SemanticAnalyzeResponse(BaseModel):
-    target: Dict[str, Any]
-    competitors: List[Dict[str, Any]]
-    comparison: Dict[str, Any]
-
-
-class SemanticSearchRequest(BaseModel):
-    query_text: str
-    text: str
-    language: str = "ru"
-    top_n: int = 20
-
-
-class SemanticSearchResponse(BaseModel):
-    results: List[Dict[str, Any]]
-
-
-class UrlFetchRequest(BaseModel):
-    url: str
-    user_agent: str = "chrome_desktop"
-    timeout_seconds: int = 15
-
-
-class UrlFetchResponse(BaseModel):
-    ok: bool = False
-    url: str = ""
-    final_url: str = ""
-    status_code: int = 0
-    user_agent_key: str = ""
-    user_agent_value: str = ""
-    title: str = ""
-    text: str = ""
-    error: str = ""
-
-
-class UserAgentInfo(BaseModel):
-    key: str
-    name: str
-    value: str
-
-
-class UserAgentsResponse(BaseModel):
-    user_agents: List[UserAgentInfo] = Field(default_factory=list)
-
-
-class OptimizerRequest(BaseModel):
-    target_text: str
-    competitors: List[str] = Field(default_factory=list)
-    keywords: List[str] = Field(default_factory=list)
-    language: str = "en"
-    target_title: str = ""
-    competitor_titles: List[str] = Field(default_factory=list)
-    # Base for highlighting what changed in this optimization run.
-    # - diff_from_input: compare with `target_text` passed in this request (snapshot before optimization)
-    # - diff_from_original: compare with `original_target_text` from the first snapshot in session
-    diff_mode: str = "diff_from_input"  # diff_from_input | diff_from_original
-    original_target_text: Optional[str] = None
-    original_target_title: Optional[str] = None
-
-    api_key: str
-    api_base_url: str = "https://api.deepseek.com/v1"
-    model: str = "deepseek-chat"
-
-    max_iterations: int = 2
-    candidates_per_iteration: int = 2
-    temperature: float = 0.25
-    optimization_mode: str = "balanced"
-    phrase_strategy_mode: str = "auto"  # auto | exact_preferred | distributed_preferred | ensemble
-    bert_stage_target: float = 0.70
-    # Optional stage control. If empty -> default full pipeline order.
-    enabled_stages: List[str] = Field(default_factory=list)  # bert|bm25|ngram|semantic|title
-    # Per-stage manual goal selection and custom additions.
-    # Example:
-    # {
-    #   "bm25": {"mode":"mixed","selected":["canadian online casino"],"custom_add":["online casinos canada"]},
-    #   "bert": {"mode":"manual","selected":["best payout casinos"],"custom_add":[]}
-    # }
-    stage_goal_overrides: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
-
-
-class OptimizerResponse(BaseModel):
-    ok: bool = True
-    optimized_text: str = ""
-    optimized_title: str = ""
-    baseline_metrics: Dict[str, Any] = Field(default_factory=dict)
-    final_metrics: Dict[str, Any] = Field(default_factory=dict)
-    iterations: List[Dict[str, Any]] = Field(default_factory=list)
-    applied_changes: int = 0
-    optimization_mode: str = "balanced"
-    phrase_strategy_mode: str = "auto"
-    bert_stage_target: float = 0.70
-    diff_mode: str = ""
-    # HTML with <mark class="diff-changed"> around changed parts.
-    diff_body_html: str = ""
-    diff_title_html: str = ""
-    # List of (type/from/to) blocks for "что именно поменять".
-    diff_changes: List[Dict[str, str]] = Field(default_factory=list)
-    diff_title_changes: List[Dict[str, str]] = Field(default_factory=list)
-    error: str = ""
-    stopped_early: bool = False
-    stop_reason: str = ""
-
-
-class OptimizerCancelRequest(BaseModel):
-    job_id: str = Field(..., min_length=8)
+    title_analysis: Dict[str, Any] = {}  # Анализ Title

nlp_processor.py

@@ -1,51 +0,0 @@
-from typing import Dict, List, Any
-
-import logic
-
-
-def preprocess_text(text: str, lang: str) -> List[Dict[str, Any]]:
-    """
-    Разбирает текст на предложения и токены.
-    Сохраняет:
-    - исходный текст токена (text)
-    - пробел после токена (whitespace)
-    - лемму (lemma)
-    - флаг значимости (is_significant)
-    """
-    if not text or not text.strip():
-        return []
-
-    doc = logic.get_doc(text, lang)
-    result: List[Dict[str, Any]] = []
-
-    for idx, sent in enumerate(doc.sents):
-        tokens: List[Dict[str, Any]] = []
-        lemmas_clean: List[str] = []
-
-        for t in sent:
-            lemma = t.lemma_.lower().strip() if t.lemma_ else t.text.lower().strip()
-            is_significant = bool(logic.is_valid_token(t))
-
-            token_data = {
-                "text": t.text,
-                "whitespace": t.whitespace_,
-                "lemma": lemma,
-                "is_significant": is_significant,
-                "is_punct": bool(t.is_punct),
-                "is_space": bool(t.is_space),
-            }
-            tokens.append(token_data)
-
-            if is_significant and lemma:
-                lemmas_clean.append(lemma)
-
-        result.append(
-            {
-                "index": idx,
-                "raw_text": sent.text,
-                "tokens": tokens,
-                "lemmas_clean": lemmas_clean,
-            }
-        )
-
-    return result

requirements.txt

@@ -8,7 +8,4 @@ sentence-transformers>=2.2.0
 spacy>=3.7.0
 python-multipart>=0.0.6
 jinja2>=3.1.0
-torch>=2.0.0
-networkx>=3.2.0
-requests>=2.31.0
-beautifulsoup4>=4.12.0
+torch>=2.0.0

search.py

@@ -1,96 +0,0 @@
-from typing import Dict, List, Any
-
-import logic
-import networkx as nx
-
-
-def _normalize_query_text(text: str) -> str:
-    return " ".join((text or "").lower().replace("ё", "е").replace("-", " ").split())
-
-
-def semantic_search(
-    query_text: str,
-    graph: nx.DiGraph,
-    word_weights: Dict[str, int],
-    lang: str,
-    top_n: int = 20,
-) -> List[Dict[str, Any]]:
-    """
-    Смысловой поиск по графу:
-    - лемматизация запроса
-    - добавление соседей (successors)
-    - score = сила связи + вес узла
-    """
-    if not query_text.strip() or graph.number_of_nodes() == 0:
-        return []
-
-    query_text_norm = _normalize_query_text(query_text)
-    query_lemmas = logic.get_lemmas_flat(query_text, lang)
-    # Фразовые кандидаты для точного phrase-match в графе.
-    phrase_terms: List[str] = []
-    for n in (3, 2):
-        phrase_terms.extend(logic.generate_ngrams_safe(query_text_norm, lang, n))
-
-    # Удаляем дубли с сохранением порядка.
-    phrase_terms = list(dict.fromkeys([_normalize_query_text(p) for p in phrase_terms if p.strip()]))
-    query_lemmas = list(dict.fromkeys([_normalize_query_text(q) for q in query_lemmas if q.strip()]))
-
-    if not query_lemmas and not phrase_terms:
-        return []
-
-    candidates: Dict[str, float] = {}
-    candidate_type: Dict[str, str] = {}
-
-    # 1) Сначала фразовый поиск.
-    for p in phrase_terms:
-        if p not in graph:
-            continue
-        base = float(word_weights.get(p, 0))
-        candidates[p] = max(candidates.get(p, 0.0), base)
-        candidate_type[p] = "phrase"
-
-        for neigh in graph.successors(p):
-            edge_data = graph.get_edge_data(p, neigh) or {}
-            edge_weight = float(edge_data.get("weight", 0.0))
-            node_weight = float(word_weights.get(neigh, 0))
-            score = edge_weight * 0.65 + node_weight * 0.35
-            if score > candidates.get(neigh, 0.0):
-                candidates[neigh] = score
-                candidate_type[neigh] = "phrase" if " " in neigh else "word"
-
-    # 2) Потом словный fallback/расширение.
-    for q in query_lemmas:
-        if q not in graph:
-            continue
-
-        # Само понятие запроса.
-        candidates[q] = max(candidates.get(q, 0.0), float(word_weights.get(q, 0)))
-        if q not in candidate_type:
-            candidate_type[q] = "word"
-
-        for neigh in graph.successors(q):
-            edge_data = graph.get_edge_data(q, neigh) or {}
-            edge_weight = float(edge_data.get("weight", 0.0))
-            node_weight = float(word_weights.get(neigh, 0))
-            score = edge_weight * 0.6 + node_weight * 0.4
-            if score > candidates.get(neigh, 0.0):
-                candidates[neigh] = score
-                candidate_type[neigh] = "phrase" if " " in neigh else "word"
-
-    ranked = sorted(candidates.items(), key=lambda x: x[1], reverse=True)[:top_n]
-
-    if not ranked:
-        return []
-
-    max_score = ranked[0][1]
-    min_score = ranked[-1][1]
-    denom = max(1e-9, max_score - min_score)
-
-    return [
-        {
-            "lemma": lemma,
-            "score": int(round(1 + ((score - min_score) / denom) * 99)),
-            "type": candidate_type.get(lemma, "phrase" if " " in lemma else "word"),
-        }
-        for lemma, score in ranked
-    ]

semantic_graph.py

@@ -1,304 +0,0 @@
-from collections import Counter, defaultdict
-from typing import Dict, List, Any, Tuple
-import math
-
-import networkx as nx
-import logic
-
-
-def _normalize_to_1_100(values: Dict[str, float]) -> Dict[str, int]:
-    if not values:
-        return {}
-    v_min = min(values.values())
-    v_max = max(values.values())
-    if v_max == v_min:
-        return {k: 50 for k in values.keys()}
-    return {
-        k: int(round(1 + ((v - v_min) / (v_max - v_min)) * 99))
-        for k, v in values.items()
-    }
-
-
-def _extract_significant_lemmas(sent: Dict[str, Any]) -> List[str]:
-    lemmas: List[str] = []
-    for tok in sent.get("tokens", []):
-        if tok.get("is_significant") and tok.get("lemma"):
-            lemmas.append(str(tok["lemma"]))
-    return lemmas
-
-
-NOISE_PATTERNS = (
-    "contact us",
-    "responsible gaming",
-    "play responsibly",
-    "copyright",
-    "terms of use",
-    "new customers only",
-    "t&c apply",
-    "18+",
-    "info@",
-)
-
-
-GENERIC_TERMS = {
-    "игра", "играть", "казино", "ставка", "деньга", "деньги",
-    "демо", "режим", "уровень", "шаг", "выигрыш", "риск",
-    "game", "play", "casino", "bet", "demo", "mode", "level", "risk", "win",
-}
-
-
-def _is_noise_sentence(text: str) -> bool:
-    t = " ".join((text or "").lower().split())
-    if not t:
-        return True
-    if any(p in t for p in NOISE_PATTERNS):
-        return True
-    # Частые CTA/служебные короткие строки.
-    if len(t.split()) <= 3 and t in {"играть", "play", "chicken road", "chicken road game"}:
-        return True
-    return False
-
-
-def _canonicalize_term(term: str) -> str:
-    t = " ".join((term or "").lower().replace("ё", "е").replace("-", " ").split())
-    if not t:
-        return t
-
-    # Бренд/наименование игры.
-    if t in {"чикен роад", "chicken road", "chickenroad", "chiken road"}:
-        return "chicken road"
-    if t in {"игры inout", "inout games", "inout game", "inout"}:
-        return "inout games"
-
-    # Полезная нормализация русской фразы под один термин.
-    if t in {"реальные деньги", "реальный деньги"}:
-        return "реальные деньги"
-    return t
-
-
-def _extract_phrase_candidates(sentence_text: str, lang: str) -> List[str]:
-    """
-    Извлекает фразовые кандидаты через существующую n-gram логику проекта,
-    чтобы сохранить естественные сочетания со стоп-словами внутри.
-    """
-    candidates: List[str] = []
-    for n in (2, 3):
-        candidates.extend(logic.generate_ngrams_safe(sentence_text, lang, n))
-    return candidates
-
-
-def _normalize_lemma_sequence(lemmas: List[str]) -> List[str]:
-    """
-    Убирает подряд идущие дубликаты, чтобы не рождать шумные
-    термины вроде "дорожка дорожка" из технических повторов.
-    """
-    if not lemmas:
-        return []
-    normalized = [lemmas[0]]
-    for item in lemmas[1:]:
-        if item != normalized[-1]:
-            normalized.append(item)
-    return normalized
-
-
-def build_semantic_graph(
-    sentences_data: List[Dict[str, Any]],
-    window_size: int = 5,
-    min_phrase_freq: int = 2,
-    lang: str = "ru",
-) -> Tuple[nx.DiGraph, Dict[str, int]]:
-    """
-    Строит направленный граф из лемм и считает веса:
-    - edge_weight: условная вероятность P(B|A) * 100
-    - node_weight: нормализованный PageRank 1..100
-
-    Версия v5:
-    - связи считаются в локальном скользящем окне (а не "все со всеми")
-    - условная вероятность считается строго как cooc(a,b)/occ(a), поэтому <= 100
-    - узлы графа: слова + устойчивые словосочетания (bi/tri-grams)
-    - словосочетания извлекаются через Smart Window (как в основной логике n-gram)
-    - повышаем вклад устойчивых фраз в итоговый смысловой вес понятия
-    """
-    term_occ = Counter()
-    pair_cooc = defaultdict(int)
-    phrase_occ = Counter()
-    phrase_sent_ids = defaultdict(set)
-    term_sent_ids = defaultdict(set)
-    sentence_words: List[List[str]] = []
-    sentence_phrases: List[List[str]] = []
-
-    for sent_id, sent in enumerate(sentences_data):
-        raw_text = sent.get("raw_text", "")
-        if _is_noise_sentence(raw_text):
-            sentence_words.append([])
-            sentence_phrases.append([])
-            continue
-
-        lemmas_raw = _extract_significant_lemmas(sent)
-        lemmas = [_canonicalize_term(x) for x in _normalize_lemma_sequence(lemmas_raw)]
-        lemmas = [x for x in lemmas if x]
-        sentence_words.append(lemmas)
-
-        phrase_candidates = _extract_phrase_candidates(raw_text, lang)
-        # Фильтр мусора фраз: минимум 2 слова, без дублирующегося подряд слова.
-        clean_phrases = []
-        for p in phrase_candidates:
-            parts = [x.strip() for x in p.split() if x.strip()]
-            if len(parts) < 2:
-                continue
-            bad_repeat = any(parts[i] == parts[i + 1] for i in range(len(parts) - 1))
-            if bad_repeat:
-                continue
-            clean_phrases.append(_canonicalize_term(" ".join(parts)))
-        sentence_phrases.append(clean_phrases)
-
-        if not lemmas:
-            continue
-
-        # Для каждого вхождения a считаем его локальный контекст в окне.
-        # cooc(a,b) увеличивается максимум на 1 на одно вхождение a,
-        # что гарантирует cooc(a,b) <= occ(a) и P(B|A) <= 100.
-        for i, a in enumerate(lemmas):
-            term_occ[a] += 1
-            left = max(0, i - max(1, window_size))
-            right = min(len(lemmas), i + max(1, window_size) + 1)
-            neighbors = set()
-            for j in range(left, right):
-                if j == i:
-                    continue
-                b = lemmas[j]
-                if not b or a == b:
-                    continue
-                neighbors.add(b)
-            for b in neighbors:
-                pair_cooc[(a, b)] += 1
-        for w in set(lemmas):
-            term_sent_ids[w].add(sent_id)
-
-    # Частоты/охват фраз по предложениям.
-    for sent_id, phrases in enumerate(sentence_phrases):
-        for phrase in phrases:
-            phrase_occ[phrase] += 1
-            phrase_sent_ids[phrase].add(sent_id)
-
-    # Оставляем только устойчивые фразы.
-    allowed_phrases = {
-        p for p, c in phrase_occ.items()
-        if c >= max(1, min_phrase_freq) and len(phrase_sent_ids[p]) >= max(1, min_phrase_freq)
-    }
-
-    # Добавляем связи phrase <-> word на уровне предложения.
-    for sent_id, words in enumerate(sentence_words):
-        if not words:
-            continue
-        phrases = [p for p in sentence_phrases[sent_id] if p in allowed_phrases]
-        if not phrases:
-            continue
-        uniq_words = set(words)
-        uniq_phrases = set(phrases)
-
-        for phrase in uniq_phrases:
-            term_occ[phrase] += 1
-            term_sent_ids[phrase].add(sent_id)
-            parts = set(phrase.split())
-            # Связываем фразу с ее компонентами всегда (ядро термина).
-            for w in parts:
-                pair_cooc[(phrase, w)] += 1
-                pair_cooc[(w, phrase)] += 1
-            # И с остальными словами предложения (контекст термина).
-            for w in uniq_words:
-                if w in parts:
-                    continue
-                pair_cooc[(phrase, w)] += 1
-                pair_cooc[(w, phrase)] += 1
-
-    graph = nx.DiGraph()
-
-    for term, freq in term_occ.items():
-        term_type = "phrase" if " " in term else "word"
-        graph.add_node(term, frequency=int(freq), term_type=term_type)
-
-    for (a, b), cooc in pair_cooc.items():
-        base = term_occ.get(a, 0)
-        if base <= 0:
-            continue
-        weight = (cooc / base) * 100.0
-        weight = max(0.0, min(100.0, weight))
-        if weight > 0:
-            graph.add_edge(a, b, weight=round(weight, 3))
-
-    if graph.number_of_nodes() == 0:
-        return graph, {}
-
-    try:
-        pr = nx.pagerank(graph, weight="weight")
-    except Exception:
-        pr = {node: 1.0 for node in graph.nodes()}
-
-    # Комбинируем centrality с termness-фактором.
-    # Для слов: умеренный буст по контекстной связанности.
-    # Для фраз: более сильный буст по частоте/охвату, чтобы устойчивые термины поднимались в топ.
-    combined_scores = {}
-    total_sent = max(1, len(sentence_words))
-    for node, score in pr.items():
-        out_deg = graph.out_degree(node)
-        in_deg = graph.in_degree(node)
-        connectivity_factor = 1.0 + 0.025 * (out_deg + in_deg)
-        sent_df = len(term_sent_ids.get(node, set()))
-        idf_factor = 1.0 + 0.35 * math.log((1.0 + total_sent) / (1.0 + max(1, sent_df)))
-
-        if graph.nodes[node].get("term_type") == "phrase":
-            freq = max(1, int(graph.nodes[node].get("frequency", 1)))
-            sent_cover = len(phrase_sent_ids.get(node, set()))
-            termness = (1.0 + 0.22 * math.log1p(freq)) * (1.0 + 0.12 * math.log1p(sent_cover))
-            contains_generic = any(part in GENERIC_TERMS for part in node.split())
-            generic_penalty = 0.85 if contains_generic else 1.0
-            combined_scores[node] = score * connectivity_factor * termness * idf_factor * generic_penalty
-        else:
-            generic_penalty = 0.58 if node in GENERIC_TERMS else 1.0
-            combined_scores[node] = score * connectivity_factor * idf_factor * generic_penalty
-
-    node_weights = _normalize_to_1_100(combined_scores)
-
-    for node, w in node_weights.items():
-        graph.nodes[node]["weight"] = int(w)
-
-    return graph, node_weights
-
-
-def get_graph_data_for_frontend(graph: nx.DiGraph, top_edges_per_node: int = 8) -> Dict[str, List[Dict[str, Any]]]:
-    nodes = []
-    links = []
-
-    for node, attrs in graph.nodes(data=True):
-        nodes.append(
-            {
-                "id": node,
-                "label": node,
-                "weight": int(attrs.get("weight", 1)),
-                "frequency": int(attrs.get("frequency", 0)),
-            }
-        )
-
-    for source in graph.nodes():
-        out_edges = sorted(
-            graph.out_edges(source, data=True),
-            key=lambda e: e[2].get("weight", 0),
-            reverse=True,
-        )[:top_edges_per_node]
-
-        for s, t, attrs in out_edges:
-            links.append(
-                {
-                    "source": s,
-                    "target": t,
-                    "weight": float(attrs.get("weight", 0)),
-                }
-            )
-
-    return {"nodes": nodes, "links": links}
-
-
-def get_top_keywords(node_weights: Dict[str, int], top_n: int = 20) -> List[Dict[str, Any]]:
-    items = sorted(node_weights.items(), key=lambda x: x[1], reverse=True)[:top_n]
-    return [{"lemma": lemma, "weight": int(weight)} for lemma, weight in items]

summarizer.py

@@ -1,41 +0,0 @@
-import math
-from typing import Dict, List, Any
-
-
-def generate_summary(
-    sentences_data: List[Dict[str, Any]],
-    word_weights: Dict[str, int],
-    compression_ratio: float = 0.1,
-) -> List[Dict[str, Any]]:
-    """
-    Реферат: отбирает самые значимые предложения.
-    score = сумма весов уникальных лемм / sqrt(длина_предложения)
-    """
-    if not sentences_data:
-        return []
-
-    compression_ratio = max(0.05, min(0.8, compression_ratio))
-    ranked: List[Dict[str, Any]] = []
-
-    for sent in sentences_data:
-        uniq = set(sent.get("lemmas_clean", []))
-        if not uniq:
-            score = 0.0
-        else:
-            numerator = float(sum(word_weights.get(l, 0) for l in uniq))
-            penalty = math.sqrt(max(1, len(sent.get("tokens", []))))
-            score = numerator / penalty
-
-        ranked.append(
-            {
-                "index": sent.get("index", 0),
-                "text": sent.get("raw_text", ""),
-                "score": round(score, 3),
-            }
-        )
-
-    ranked.sort(key=lambda x: x["score"], reverse=True)
-    take_n = max(1, int(round(len(ranked) * compression_ratio)))
-    chosen = ranked[:take_n]
-    chosen.sort(key=lambda x: x["index"])
-    return chosen

templates/index.html

@@ -9,8 +9,6 @@
         body { background-color: #f8f9fa; }
         .editor-box { min-height: 300px; font-family: 'Georgia', serif; font-size: 1.1rem; }
         .stat-card { background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.05); padding: 20px; margin-bottom: 20px; }
-        .diff-changed { background-color: #fff3cd; padding: 0 2px; border-radius: 4px; }
-        .diff-unchanged { }
         .loading-overlay { 
             display: none; position: fixed; top: 0; left: 0; width: 100%; height: 100%; 
             background: rgba(255,255,255,0.8); z-index: 9999; text-align: center; padding-top: 20%; 
@@ -47,29 +45,9 @@
                         <option value="de">🇩🇪 Deutsch</option>
                         <option value="it">🇮🇹 Italiano</option>
                         <option value="es">🇪🇸 Español</option>
-                        <option value="pl">🇵🇱 Polski</option>
-                        <option value="pt">🇵🇹 Português</option>
                     </select>
                 </div>
 
-                <div class="mb-3 border rounded p-3 bg-light">
-                    <label class="form-label fw-bold mb-2">Импорт по URL (Title + текст)</label>
-                    <div class="mb-2">
-                        <label class="form-label small text-muted mb-1">User-Agent</label>
-                        <select class="form-select form-select-sm" id="urlUserAgentSelect">
-                            <option value="chrome_desktop">Chrome (Desktop)</option>
-                        </select>
-                    </div>
-                    <div class="input-group input-group-sm mb-2">
-                        <span class="input-group-text">Target URL</span>
-                        <input type="text" id="targetUrlInput" class="form-control" placeholder="https://example.com/page">
-                        <button class="btn btn-outline-primary" onclick="fetchTargetFromUrl()">Забрать</button>
-                    </div>
-                    <label class="form-label small text-muted mb-1">URL конкурентов (по одному в строке)</label>
-                    <textarea class="form-control form-control-sm mb-2" id="competitorUrlsInput" rows="3" placeholder="https://example.com/competitor-1&#10;https://example.com/competitor-2"></textarea>
-                    <button class="btn btn-sm btn-outline-primary" onclick="fetchCompetitorsFromUrls()">Забрать конкурентов</button>
-                </div>
-
                 <div class="mb-3">
                     <label class="form-label fw-bold">Ваш текст (Target)</label>
                     <textarea class="form-control editor-box" id="targetText" placeholder="Пишите текст здесь..."></textarea>
@@ -111,11 +89,6 @@
 
                 <div class="d-grid gap-2">
                     <button class="btn btn-primary btn-lg" onclick="runAnalysis()">⚡ Анализировать (GPU)</button>
-                    <div class="btn-group" role="group">
-                        <button class="btn btn-outline-success" onclick="saveProject()">💾 Сохранить проект</button>
-                        <button class="btn btn-outline-secondary" onclick="loadProject()">📂 Загрузить проект</button>
-                        <button class="btn btn-outline-danger" onclick="clearProject()">🗑 Новый проект</button>
-                    </div>
                 </div>
             </div>
         </div>
@@ -142,15 +115,6 @@
                 <li class="nav-item">
                     <button class="nav-link" id="title-tab" data-bs-toggle="tab" data-bs-target="#titlePane" type="button">🏷️ Title</button>
                 </li>
-                <li class="nav-item">
-                    <button class="nav-link" id="semantic-tab" data-bs-toggle="tab" data-bs-target="#semanticPane" type="button">🧩 Semantic Core</button>
-                </li>
-                <li class="nav-item">
-                    <button class="nav-link" id="summary-tab" data-bs-toggle="tab" data-bs-target="#summaryPane" type="button">✅ Сводка</button>
-                </li>
-                <li class="nav-item">
-                    <button class="nav-link" id="optimizer-tab" data-bs-toggle="tab" data-bs-target="#optimizerPane" type="button">🤖 LLM Optimizer</button>
-                </li>
             </ul>
 
             <div class="tab-content" id="resultsContent">
@@ -223,177 +187,585 @@
                     </div>
                 </div>
 
-                <!-- SEMANTIC CORE TAB -->
-                <div class="tab-pane fade" id="semanticPane" role="tabpanel">
-                    <div class="stat-card">
-                        <h5 class="card-title mb-3">TextAnalyst Web Core</h5>
-                        <div class="row g-2 align-items-end mb-3">
-                            <div class="col-md-4">
-                                <label class="form-label small text-muted mb-1">Порог значимости понятий (1-100)</label>
-                                <input type="number" id="semanticThreshold" class="form-control" min="1" max="100" value="50">
-                            </div>
-                            <div class="col-md-4">
-                                <label class="form-label small text-muted mb-1">Доля предложений в реферате (0.05-0.8)</label>
-                                <input type="number" id="semanticCompression" class="form-control" min="0.05" max="0.8" step="0.05" value="0.1">
+            </div>
+        </div>
+    </div>
+</div>
+
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
+<script>
+    let currentData = null;
+
+    // --- ФУНКЦИИ ИНТЕРФЕЙСА ---
+
+    document.getElementById('targetTitle').addEventListener('input', function() {
+        const len = this.value.length;
+        const counter = document.getElementById('titleCharCount');
+        counter.textContent = len;
+        counter.className = len > 60 ? 'text-danger fw-bold' : (len > 50 ? 'text-warning' : 'text-muted');
+    });
+
+    function addCompetitorTitleField() {
+        const div = document.createElement('div');
+        div.innerHTML = '<input type="text" class="form-control mb-2" placeholder="Ещё Title конкурента..." maxlength="200">';
+        document.getElementById('competitorTitlesList').appendChild(div);
+    }
+
+    function addCompetitorField() {
+        const div = document.createElement('div');
+        div.innerHTML = '<textarea class="form-control mb-2 competitor-input" rows="3" placeholder="Ещё конкурент..."></textarea>';
+        document.getElementById('competitorsList').appendChild(div);
+    }
+
+    async function runAnalysis() {
+        // Сбор данных
+        const targetText = document.getElementById('targetText').value;
+        const lang = document.getElementById('languageSelect').value;
+        const keywordsRaw = document.getElementById('keywordsInput').value.split('\n').filter(k => k.trim() !== '');
+        
+        // Сбор конкурентов
+        const compInputs = document.querySelectorAll('#competitorsList textarea');
+        const competitors = [];
+        compInputs.forEach(input => {
+            if(input.value.trim() !== '') competitors.push(input.value);
+        });
+
+        if(!targetText) { alert("Введите ваш текст!"); return; }
+
+        // Title fields
+        const targetTitle = document.getElementById('targetTitle').value;
+        const compTitleInputs = document.querySelectorAll('#competitorTitlesList input');
+        const competitorTitles = [];
+        compTitleInputs.forEach(input => {
+            if(input.value.trim() !== '') competitorTitles.push(input.value);
+        });
+
+        // UI Loading
+        document.getElementById('loader').style.display = 'block';
+
+        const payload = {
+            target_text: targetText,
+            competitors: competitors,
+            keywords: keywordsRaw,
+            language: lang,
+            target_title: targetTitle,
+            competitor_titles: competitorTitles
+        };
+
+        try {
+            const response = await fetch('/analyze', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+
+            if (!response.ok) throw new Error("Ошибка сервера: " + response.statusText);
+
+            const data = await response.json();
+            currentData = data;
+            renderResults(data);
+
+        } catch (error) {
+            alert("Ошибка: " + error.message);
+            console.error(error);
+        } finally {
+            document.getElementById('loader').style.display = 'none';
+        }
+    }
+
+    function renderResults(data) {
+        // 0. General Stats Render (Word Count Dual Mode)
+        const statsContainer = document.getElementById('generalStats');
+        statsContainer.innerHTML = '';
+        
+        if (data.word_counts) {
+            const myTotal = data.word_counts.target.total;
+            const mySig = data.word_counts.target.significant;
+            
+            const avgTotal = data.word_counts.avg.total;
+            const avgSig = data.word_counts.avg.significant;
+            
+            // Цвет зависит от ОБЩЕГО количества
+            let totalColor = 'text-dark';
+            if (avgTotal > 0) {
+                if (myTotal < avgTotal * 0.8) totalColor = 'text-danger';
+                else if (myTotal > avgTotal * 1.2) totalColor = 'text-success';
+            }
+
+            // HTML для конкурентов
+            let compsHtml = '';
+            data.word_counts.competitors.forEach((c, idx) => {
+                compsHtml += `
+                <div class="px-3 border-end text-center">
+                    <small class="text-muted d-block mb-1">K${idx+1}</small>
+                    <div class="fw-bold">${c.total}</div>
+                    <div class="text-muted small" style="font-size: 0.75em;">(${c.significant})</div>
+                </div>`;
+            });
+
+            const html = `
+            <div class="card border-0 shadow-sm mb-4">
+                <div class="card-body py-3">
+                    <div class="row align-items-center">
+                        
+                        <!-- Мой результат -->
+                        <div class="col-md-4 border-end">
+                            <h6 class="text-uppercase text-muted small fw-bold mb-2">Мой текст</h6>
+                            <div class="d-flex align-items-baseline">
+                                <span class="display-6 fw-bold ${totalColor} me-2">${myTotal}</span>
+                                <span class="text-muted">слов</span>
                             </div>
-                            <div class="col-md-4 d-grid">
-                                <button class="btn btn-dark" onclick="runSemanticAnalysis()">Запустить Semantic Core</button>
+                            <div class="text-muted small">
+                                Значимых: <strong>${mySig}</strong>
                             </div>
                         </div>
-                        <p class="small text-muted mb-3">
-                            50 = подсветка только наиболее значимых понятий. 0.1 = реферат из ~10% самых информативных предложений.
-                        </p>
 
-                        <div class="mb-3">
-                            <label class="form-label small text-muted mb-1">Документ для просмотра</label>
-                            <select id="semanticDocSelect" class="form-select" onchange="renderSemanticResults(semanticData)">
-                                <option value="target">Мой текст</option>
-                            </select>
+                        <!-- Среднее -->
+                        <div class="col-md-3 border-end text-center">
+                            <h6 class="text-uppercase text-muted small fw-bold mb-2">Среднее (Рынок)</h6>
+                            <div class="h3 fw-bold mb-0">${avgTotal}</div>
+                            <div class="text-muted small">Значимых: ${avgSig}</div>
                         </div>
 
-                        <div class="mb-3">
-                            <label class="form-label small text-muted mb-1">Смысловой поиск</label>
-                            <div class="input-group">
-                                <input type="text" id="semanticQueryInput" class="form-control" placeholder="Введите запрос для ассоциативного поиска...">
-                                <button class="btn btn-outline-primary" onclick="runSemanticSearch()">Искать</button>
-                            </div>
-                            <div id="semanticSearchResults" class="border rounded p-2 text-break mt-2">
-                                <span class="text-muted small">Введите запрос и нажмите "Искать".</span>
+                        <!-- Конкуренты -->
+                        <div class="col-md-5">
+                            <h6 class="text-uppercase text-muted small fw-bold mb-2 text-center">Детализация</h6>
+                            <div class="d-flex justify-content-center align-items-center">
+                                 ${compsHtml}
                             </div>
                         </div>
-                    </div>
 
-                    <div id="semanticResultsContainer">
-                        <div class="text-center text-muted py-5">Нажмите "Запустить Semantic Core", чтобы построить граф и разметку.</div>
                     </div>
                 </div>
+            </div>`;
+            statsContainer.innerHTML = html;
+        }
 
-                <!-- SUMMARY TAB -->
-                <div class="tab-pane fade" id="summaryPane" role="tabpanel">
-                    <div id="summaryResultsContainer">
-                        <div class="text-center text-muted py-5">Запустите анализ, чтобы увидеть итоговые рекомендации.</div>
-                    </div>
-                </div>
+        // 1. BERT Render (ИСПРАВЛЕННЫЙ ПОД НОВУЮ СТРУКТУРУ)
+        const bertContainer = document.getElementById('bertResultsContainer');
+        bertContainer.innerHTML = '';
+        
+        // Получаем объект данных. Теперь это объект, а не массив!
+        const bertData = data.bert_analysis;
+        
+        // Проверяем, есть ли поле detailed (список фраз)
+        if (!bertData || !bertData.detailed || bertData.detailed.length === 0) {
+            bertContainer.innerHTML = '<div class="alert alert-warning">Добавьте ключе��ые фразы для анализа.</div>';
+        } else {
+            
+            // А. Рендерим ГЛОБАЛЬНЫЙ СЧЕТ (Global Score)
+            if (bertData.global_scores && bertData.global_scores.length > 0) {
+                let globalHtml = '<div class="card mb-4 border-primary"><div class="card-body">';
+                globalHtml += '<h6 class="card-title text-primary fw-bold mb-3">🏆 Общий рейтинг релевантности (Global Score)</h6>';
+                
+                bertData.global_scores.forEach(gs => {
+                    const scorePct = Math.round(gs.score * 100);
+                    const isMe = gs.is_me;
+                    const barColor = isMe ? 'bg-primary' : 'bg-secondary';
+                    const rowBg = isMe ? 'bg-light border-start border-primary border-3' : '';
+                    const nameLabel = isMe ? `<strong>${gs.name} (Вы)</strong>` : gs.name;
 
-                <!-- OPTIMIZER TAB -->
-                <div class="tab-pane fade" id="optimizerPane" role="tabpanel">
-                    <div class="stat-card">
-                        <h5 class="card-title mb-3">LLM Optimizer (итеративная доработка текста)</h5>
-                        <div class="row g-2">
-                            <div class="col-md-6">
-                                <label class="form-label small text-muted mb-1">API Key (пользовательский)</label>
-                                <input type="password" id="optimizerApiKey" class="form-control" placeholder="sk-...">
-                            </div>
-                            <div class="col-md-6">
-                                <label class="form-label small text-muted mb-1">Base URL (OpenAI-compatible)</label>
-                                <input type="text" id="optimizerBaseUrl" class="form-control" value="https://api.deepseek.com/v1">
-                            </div>
-                            <div class="col-md-4">
-                                <label class="form-label small text-muted mb-1">Model</label>
-                                <input type="text" id="optimizerModel" class="form-control" value="deepseek-chat">
-                            </div>
-                            <div class="col-md-3">
-                                <label class="form-label small text-muted mb-1">Итерации</label>
-                                <input type="number" id="optimizerIterations" class="form-control" min="1" max="8" value="2">
-                            </div>
-                            <div class="col-md-3">
-                                <label class="form-label small text-muted mb-1">Кандидатов/шаг</label>
-                                <input type="number" id="optimizerCandidates" class="form-control" min="1" max="5" value="2">
-                            </div>
-                            <div class="col-md-2">
-                                <label class="form-label small text-muted mb-1">Temp</label>
-                                <input type="number" id="optimizerTemp" class="form-control" min="0" max="1.2" step="0.05" value="0.25">
-                            </div>
-                            <div class="col-md-2">
-                                <label class="form-label small text-muted mb-1">BERT target A-stage</label>
-                                <input type="number" id="optimizerBertStageTarget" class="form-control" min="0" max="1" step="0.01" value="0.70">
+                    globalHtml += `
+                    <div class="d-flex align-items-center mb-2 p-2 rounded ${rowBg}">
+                        <div style="width: 150px;">${nameLabel}</div>
+                        <div class="flex-grow-1 mx-3">
+                            <div class="progress" style="height: 20px;">
+                                <div class="progress-bar ${barColor}" role="progressbar" style="width: ${scorePct}%">${scorePct}%</div>
                             </div>
-                            <div class="col-md-3">
-                                <label class="form-label small text-muted mb-1">Режим оптимизации</label>
-                                <select id="optimizerMode" class="form-select">
-                                    <option value="conservative">Conservative</option>
-                                    <option value="balanced" selected>Balanced</option>
-                                    <option value="aggressive">Aggressive</option>
-                                </select>
+                        </div>
+                        <div class="fw-bold">${gs.score}</div>
+                    </div>`;
+                });
+                globalHtml += '</div></div>';
+                bertContainer.insertAdjacentHTML('beforeend', globalHtml);
+            }
+
+            // Б. Рендерим ДЕТАЛИЗАЦИЮ (Аккордеоны)
+            // Итерируемся именно по .detailed, так как это массив
+            bertData.detailed.forEach((item, index) => {
+                let badgeClass = 'bg-secondary';
+                if(item.status === 'good') badgeClass = 'bg-success';
+                if(item.status === 'warning') badgeClass = 'bg-warning text-dark';
+                if(item.status === 'bad') badgeClass = 'bg-danger';
+
+                const collapseId = `collapseBert${index}`;
+
+                // Мои чанки
+                const myChunksHtml = item.my_top_chunks.map(c => 
+                    `<li class="list-group-item d-flex justify-content-between align-items-start border-0 border-bottom">
+                        <div class="small me-2">"${c.text}"</div>
+                        <span class="badge bg-primary rounded-pill opacity-75">${c.score}</span>
+                    </li>`
+                ).join('');
+
+                // Чанки конкурентов (С АТРИБУЦИЕЙ ИСТОЧНИКА)
+                const compChunksHtml = (item.comp_top_chunks && item.comp_top_chunks.length > 0) 
+                    ? item.comp_top_chunks.map(c => 
+                        `<li class="list-group-item d-flex justify-content-between align-items-start border-0 border-bottom list-group-item-light">
+                            <div class="me-2">
+                                <span class="badge bg-secondary mb-1" style="font-size: 0.7em;">${c.source}</span>
+                                <div class="small text-muted">"${c.text}"</div>
                             </div>
-                            <div class="col-md-3">
-                                <label class="form-label small text-muted mb-1">
-                                    Phrase Strategy
-                                    <span class="text-secondary" title="Вы управляете стратегией вручную. Ensemble — опциональный режим, который циклически тестирует несколько стратегий и выбирает лучший кандидат.">ⓘ</span>
-                                </label>
-                                <select id="optimizerPhraseStrategy" class="form-select">
-                                    <option value="auto" selected>Auto</option>
-                                    <option value="distributed_preferred">Distributed preferred</option>
-                                    <option value="exact_preferred">Exact phrase preferred</option>
-                                    <option value="ensemble">Ensemble (cycle all)</option>
-                                </select>
-                                <div class="form-text">Выбор стратегии остается у пользователя.</div>
+                            <span class="badge bg-dark rounded-pill opacity-50">${c.score}</span>
+                        </li>`
+                    ).join('')
+                    : '<li class="list-group-item text-muted small border-0">Нет данных</li>';
+
+                const html = `
+                <div class="card mb-3 border">
+                    <div class="card-header bg-white d-flex justify-content-between align-items-center" style="cursor: pointer;" data-bs-toggle="collapse" data-bs-target="#${collapseId}">
+                        <div>
+                            <div class="fw-bold text-dark">${item.phrase}</div>
+                            <div class="text-muted small">
+                                My: <b>${item.my_max_score}</b> vs Best Comp: <b>${item.comp_max_score}</b>
                             </div>
                         </div>
-                        <div class="row g-2 mt-1">
-                            <div class="col-12">
-                                <div class="border rounded p-2 bg-light">
-                                    <div class="d-flex flex-wrap align-items-center gap-2 mb-2">
-                                        <span class="small fw-semibold text-secondary">Стадии и цели оптимизатора</span>
-                                        <button type="button" class="btn btn-sm btn-outline-secondary" onclick="optimizerSelectAllStages(true)">Все</button>
-                                        <button type="button" class="btn btn-sm btn-outline-secondary" onclick="optimizerSelectAllStages(false)">Снять</button>
-                                        <button type="button" class="btn btn-sm btn-outline-primary" onclick="refreshOptimizerStageGoalConfig()">Обновить авто-цели</button>
-                                    </div>
-                                    <div class="row g-2 mb-2">
-                                        <div class="col-md-2"><div class="form-check"><input class="form-check-input optimizer-stage-enabled" type="checkbox" id="optStageBert" data-stage="bert" checked><label class="form-check-label small" for="optStageBert">BERT</label></div></div>
-                                        <div class="col-md-2"><div class="form-check"><input class="form-check-input optimizer-stage-enabled" type="checkbox" id="optStageBm25" data-stage="bm25" checked><label class="form-check-label small" for="optStageBm25">BM25</label></div></div>
-                                        <div class="col-md-2"><div class="form-check"><input class="form-check-input optimizer-stage-enabled" type="checkbox" id="optStageNgram" data-stage="ngram" checked><label class="form-check-label small" for="optStageNgram">N-gram</label></div></div>
-                                        <div class="col-md-3"><div class="form-check"><input class="form-check-input optimizer-stage-enabled" type="checkbox" id="optStageSemantic" data-stage="semantic" checked><label class="form-check-label small" for="optStageSemantic">Semantic</label></div></div>
-                                        <div class="col-md-3"><div class="form-check"><input class="form-check-input optimizer-stage-enabled" type="checkbox" id="optStageTitle" data-stage="title" checked><label class="form-check-label small" for="optStageTitle">Title</label></div></div>
-                                    </div>
-                                    <div id="optimizerStageGoalConfigContainer"></div>
+                        <span class="badge ${badgeClass}">${item.status.toUpperCase()}</span>
+                    </div>
+                    
+                    <div id="${collapseId}" class="collapse">
+                        <div class="card-body bg-light">
+                            <p class="small mb-3"><strong>Совет:</strong> ${item.recommendation}</p>
+                            <div class="row">
+                                <div class="col-md-6">
+                                    <h6 class="small fw-bold text-primary">Мой текст</h6>
+                                    <ul class="list-group shadow-sm mb-3">${myChunksHtml || '<li class="list-group-item small">Нет вхождений</li>'}</ul>
                                 </div>
-                            </div>
-                            <div class="col-md-6">
-                                <label class="form-label small text-muted mb-1">Подсветка изменений (Target)</label>
-                                <select id="optimizerDiffMode" class="form-select">
-                                    <option value="diff_from_input" selected>Относительно текста перед запуском</option>
-                                    <option value="diff_from_original">Относительно оригинала (снимок)</option>
-                                </select>
-                                <div class="form-text">
-                                    Если выбран режим «оригинал», при первом запуске автоматически сохраняется снимок текущего `Target`.
+                                <div class="col-md-6 border-start">
+                                    <h6 class="small fw-bold text-secondary">Лучшее у конкурентов</h6>
+                                    <ul class="list-group shadow-sm">${compChunksHtml}</ul>
                                 </div>
                             </div>
-                            <div class="col-md-3 d-grid align-items-end">
-                                <button type="button" class="btn btn-outline-secondary" onclick="resetOptimizerDiffOriginal()">Сбросить оригинал</button>
-                            </div>
-                        </div>
-                        <div class="d-flex gap-2 mt-3 flex-wrap align-items-center">
-                            <button type="button" class="btn btn-dark" id="btnRunLlmOpt" onclick="runLlmOptimization()">Запустить оптимизацию</button>
-                            <button type="button" class="btn btn-outline-danger" id="btnStopLlmOpt" disabled onclick="requestStopOptimizer()">Остановить</button>
-                            <button type="button" class="btn btn-outline-secondary" onclick="applyOptimizedText()">Применить в Target</button>
-                        </div>
-                        <div id="optimizerProgressPanel" class="mt-3 d-none border rounded bg-white p-3">
-                            <div class="d-flex justify-content-between align-items-center mb-2">
-                                <span class="small fw-semibold text-secondary">Ход оптимизации (лог)</span>
-                                <span id="optimizerElapsed" class="small text-muted"></span>
-                            </div>
-                            <div class="progress mb-2" style="height:6px;">
-                                <div id="optimizerProgressBar" class="progress-bar bg-dark" style="width:0%;" role="progressbar" aria-valuenow="0" aria-valuemin="0" aria-valuemax="100"></div>
-                            </div>
-                            <pre id="optimizerRunLog" class="small mb-0 text-body" style="max-height:240px;overflow:auto;white-space:pre-wrap;word-break:break-word;background:#f8f9fa;border:1px solid #dee2e6;padding:8px;font-family:ui-monospace,monospace;"></pre>
-                            <p class="small text-muted mb-0 mt-2">Экран целиком не перекрывается. «Остановить» — частичный результат после завершения потока.</p>
                         </div>
-                        <p class="small text-muted mt-2 mb-0">API key не сохраняется в проект и используется только для текущего запроса.</p>
                     </div>
-                    <div id="optimizerResultsContainer">
-                        <div class="text-center text-muted py-5">Запустите основной анализ и затем оптимизацию.</div>
-                    </div>
-                </div>
+                </div>`;
+                bertContainer.insertAdjacentHTML('beforeend', html);
+            });
+        }
+
+        // 2. BM25 Render (ОБНОВЛЕННЫЙ v2 - Полный список)
+        const bm25Body = document.getElementById('bm25TableBody');
+        bm25Body.innerHTML = '';
+        const bm25Msg = document.getElementById('bm25EmptyMsg');
+        
+        // Теперь мы ожидаем, что список не пуст, если были введены ключи
+        if (data.bm25_recommendations && data.bm25_recommendations.length > 0) {
+            bm25Msg.style.display = 'none';
+            
+            data.bm25_recommendations.forEach(item => {
+                let colorClass = '';
+                let actionText = '';
+                let countText = '';
+                let rowBg = '';
+                
+                // Определяем стили в зависимости от действия
+                if (item.action === 'add') {
+                    colorClass = 'text-success';
+                    actionText = 'ДОБАВИТЬ';
+                    countText = `+${item.count}`;
+                    rowBg = 'table-success'; // Легкая зеленая подсветка всей строки (Bootstrap класс)
+                    // Но лучше не красить всю строку, чтобы не рябило, покрасим только текст действия
+                    rowBg = ''; 
+                } else if (item.action === 'remove') {
+                    colorClass = 'text-danger';
+                    actionText = 'УБРАТЬ';
+                    countText = `-${item.count}`;
+                } else {
+                    colorClass = 'text-muted'; // Серый цвет
+                    actionText = 'НОРМА'; // Или OK
+                    countText = '<span class="text-muted">-</span>';
+                }
+                
+                // Жирный шрифт для важных действий
+                const weight = item.action === 'ok' ? 'fw-normal' : 'fw-bold';
+
+                const row = `
+                <tr>
+                    <td class="fw-bold text-dark">${item.word}</td>
+                    <td class="${colorClass} ${weight}">${actionText}</td>
+                    <td class="${colorClass} ${weight}">${countText}</td>
+                    <td>${item.my_score}</td>
+                    <td>${item.avg_comp_score}</td>
+                </tr>`;
+                bm25Body.insertAdjacentHTML('beforeend', row);
+            });
+        } else {
+            // Если список пуст (например, не ввели ключевые слова)
+            bm25Msg.style.display = 'block';
+            bm25Msg.textContent = "Введите ключевые фразы для расчета BM25.";
+        }
+
+        // 3. N-grams
+        showNgramTable('unigrams');
+
+        // 4. Title
+        renderTitleResults(data);
+    }
+
+    function showNgramTable(type) {
+        if(!currentData) return;
+        
+        document.querySelectorAll('#ngrams .btn').forEach(b => {
+            if(type === 'unigrams' && b.innerText.includes('1')) b.classList.add('active');
+            else if(type === 'bigrams' && b.innerText.includes('2')) b.classList.add('active');
+            else if(type === 'trigrams' && b.innerText.includes('3')) b.classList.add('active');
+            else b.classList.remove('active');
+        });
+        
+        const table = document.querySelector('#ngrams table');
+        const thead = table.querySelector('thead');
+        const tbody = document.getElementById('ngramTableBody');
+        
+        tbody.innerHTML = '';
+        thead.innerHTML = '';
+
+        const list = currentData.ngram_stats[type];
+        
+        let numCompetitors = 0;
+        if (list && list.length > 0 && list[0].competitor_detailed) {
+            numCompetitors = list[0].competitor_detailed.length;
+        }
+
+        // ЗАГОЛОВОК
+        let headerRow = '<tr>';
+        headerRow += '<th style="width: 35%;">Фраза</th>';
+        headerRow += '<th>Target</th>';
+        headerRow += '<th class="table-light">AVG</th>';
+        // НОВАЯ КОЛОНКА
+        headerRow += '<th class="table-secondary" title="Встречаемость у конкурентов">Freq</th>';
+        
+        for (let i = 0; i < numCompetitors; i++) {
+            headerRow += `<th>K${i + 1}</th>`;
+        }
+        headerRow += '</tr>';
+        thead.innerHTML = headerRow;
+
+        // ТЕЛО
+        if(list && list.length > 0) {
+            list.forEach(item => {
+                let rowClass = "";
+                let countClass = "";
+                let icon = "";
+
+                if (item.target_count === 0 && item.competitor_avg > 0) {
+                    rowClass = "table-warning";
+                    countClass = "text-danger fw-bold";
+                    icon = "⚠️"; 
+                } else if (item.target_count > 0 && item.competitor_avg === 0) {
+                    countClass = "text-success";
+                }
+
+                let compCells = "";
+                if (item.competitor_detailed) {
+                    item.competitor_detailed.forEach(count => {
+                        const style = count > 0 ? 'fw-bold text-dark' : 'text-muted text-opacity-25';
+                        compCells += `<td class="${style}">${count}</td>`;
+                    });
+                }
+                
+                // ЗНАЧЕНИЕ ДЛЯ НОВОЙ КОЛОНКИ (Например: "3/5")
+                const freqText = numCompetitors > 0 ? `${item.comp_occurrence}<span class="text-muted small">/${numCompetitors}</span>` : '-';
+
+                const row = `
+                <tr class="${rowClass}">
+                    <td>${item.ngram} ${icon}</td>
+                    <td class="fw-bold ${countClass} border-end">${item.target_count}</td>
+                    <td class="table-light fw-bold border-end">${item.competitor_avg}</td>
+                    <!-- НОВАЯ ЯЧЕЙКА -->
+                    <td class="table-secondary fw-bold text-center border-end">${freqText}</td>
+                    ${compCells}
+                </tr>`;
+                tbody.insertAdjacentHTML('beforeend', row);
+            });
+        } else {
+             tbody.innerHTML = `<tr><td colspan="${4 + numCompetitors}" class="text-center text-muted">Нет данных</td></tr>`;
+        }
+    }
+
+    function renderTitleResults(data) {
+        const container = document.getElementById('titleResultsContainer');
+        if (!data.title_analysis || !data.title_analysis.target_title) {
+            container.innerHTML = '<div class="text-center text-muted py-5">Заполните поле "Ваш Title" и нажмите "Анализировать".</div>';
+            return;
+        }
+
+        const ta = data.title_analysis;
+        let html = '';
 
+        // === BLOCK 1: Length ===
+        const len = ta.length;
+        let charBadge = 'bg-success';
+        let charHint = 'Оптимально';
+        if (len.status === 'too_long') { charBadge = 'bg-danger'; charHint = 'Слишком длинный (>60)'; }
+        else if (len.status === 'too_short') { charBadge = 'bg-warning text-dark'; charHint = 'Слишком короткий (<30)'; }
+
+        let compLenRows = '';
+        if (ta.competitor_titles && ta.competitor_titles.length > 0) {
+            ta.competitor_titles.forEach((ct, idx) => {
+                const cd = len.comp_data[idx];
+                compLenRows += `
+                <tr>
+                    <td class="text-truncate" style="max-width: 300px;" title="${ct}">K${idx+1}: ${ct}</td>
+                    <td class="text-center">${cd.chars}</td>
+                    <td class="text-center">${cd.words.total}</td>
+                </tr>`;
+            });
+        }
+
+        html += `
+        <div class="stat-card">
+            <h5 class="card-title mb-3">Длина Title</h5>
+            <div class="d-flex align-items-center mb-3">
+                <span class="display-6 fw-bold me-3">${len.target_chars}</span>
+                <div>
+                    <span class="badge ${charBadge}">${charHint}</span>
+                    <div class="text-muted small mt-1">Слов: ${len.target_words.total} (значимых: ${len.target_words.significant})</div>
+                </div>
             </div>
-        </div>
-    </div>
-</div>
+            ${compLenRows ? `
+            <table class="table table-sm table-bordered">
+                <thead><tr><th>Title</th><th class="text-center">Символы</th><th class="text-center">Слова</th></tr></thead>
+                <tbody>${compLenRows}</tbody>
+                <tfoot><tr class="table-light fw-bold"><td>Среднее</td><td class="text-center">${len.avg_chars}</td><td class="text-center">${len.avg_words_total}</td></tr></tfoot>
+            </table>` : ''}
+        </div>`;
 
-<input type="file" id="projectFileInput" accept=".json,application/json" style="display:none;">
+        // === BLOCK 2: Keyword Coverage ===
+        if (ta.keyword_coverage && ta.keyword_coverage.length > 0) {
+            let coverageRows = '';
+            ta.keyword_coverage.forEach(kw => {
+                let badge = 'bg-danger';
+                let label = 'Нет';
+                if (kw.exact_match) { badge = 'bg-success'; label = 'Точное'; }
+                else if (kw.word_coverage >= 50) { badge = 'bg-warning text-dark'; label = 'Частично'; }
 
-<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
-<script src="/static/js/app.js"></script>
+                const missingHtml = kw.words_missing.length > 0
+                    ? `<span class="text-danger small">${kw.words_missing.join(', ')}</span>`
+                    : '<span class="text-success small">-</span>';
+
+                const compPresence = kw.comp_total > 0 ? `${kw.comp_presence}/${kw.comp_total}` : '-';
+
+                coverageRows += `
+                <tr>
+                    <td class="fw-bold">${kw.phrase}</td>
+                    <td class="text-center"><span class="badge ${badge}">${label}</span></td>
+                    <td class="text-center">${kw.word_coverage}%</td>
+                    <td>${missingHtml}</td>
+                    <td class="text-center">${compPresence}</td>
+                </tr>`;
+            });
+
+            html += `
+            <div class="stat-card">
+                <h5 class="card-title mb-3">Покрытие ключевых фраз</h5>
+                <table class="table table-sm table-hover">
+                    <thead>
+                        <tr>
+                            <th>Фраза</th>
+                            <th class="text-center">Вхождение</th>
+                            <th class="text-center">Покрытие</th>
+                            <th>Отсутствуют</th>
+                            <th class="text-center">У конк.</th>
+                        </tr>
+                    </thead>
+                    <tbody>${coverageRows}</tbody>
+                </table>
+            </div>`;
+        }
+
+        // === BLOCK 3: Title N-grams ===
+        if (ta.ngrams) {
+            ['unigrams', 'bigrams'].forEach(type => {
+                const list = ta.ngrams[type];
+                if (!list || list.length === 0) return;
+
+                const typeName = type === 'unigrams' ? '1 слово' : '2 слова';
+                let numComp = 0;
+                if (list[0].competitor_detailed) numComp = list[0].competitor_detailed.length;
+
+                let tHead = '<tr><th>Слово</th><th>Target</th><th class="table-light">AVG</th><th class="table-secondary">Freq</th>';
+                for (let i = 0; i < numComp; i++) tHead += `<th>K${i+1}</th>`;
+                tHead += '</tr>';
+
+                let tBody = '';
+                list.forEach(item => {
+                    let rc = '';
+                    let cc = '';
+                    if (item.target_count === 0 && item.competitor_avg > 0) { rc = 'table-warning'; cc = 'text-danger fw-bold'; }
+                    else if (item.target_count > 0 && item.competitor_avg === 0) { cc = 'text-success'; }
+
+                    let cells = '';
+                    if (item.competitor_detailed) {
+                        item.competitor_detailed.forEach(cnt => {
+                            const s = cnt > 0 ? 'fw-bold text-dark' : 'text-muted text-opacity-25';
+                            cells += `<td class="${s}">${cnt}</td>`;
+                        });
+                    }
+                    const freq = numComp > 0 ? `${item.comp_occurrence}<span class="text-muted small">/${numComp}</span>` : '-';
+
+                    tBody += `
+                    <tr class="${rc}">
+                        <td>${item.ngram}</td>
+                        <td class="fw-bold ${cc} border-end">${item.target_count}</td>
+                        <td class="table-light fw-bold border-end">${item.competitor_avg}</td>
+                        <td class="table-secondary fw-bold text-center border-end">${freq}</td>
+                        ${cells}
+                    </tr>`;
+                });
+
+                html += `
+                <div class="stat-card">
+                    <h6 class="card-title">N-граммы Title (${typeName})</h6>
+                    <div class="scrollable-table">
+                        <table class="table table-sm">
+                            <thead>${tHead}</thead>
+                            <tbody>${tBody}</tbody>
+                        </table>
+                    </div>
+                </div>`;
+            });
+        }
+
+        // === BLOCK 4: BERT Semantic ===
+        if (ta.bert && ta.bert.per_keyword && ta.bert.per_keyword.length > 0) {
+            let bertRows = '';
+            ta.bert.per_keyword.forEach(kw => {
+                const compScores = kw.comp_scores.map((s, i) => `<td>${s}</td>`).join('');
+                const best = Math.max(...kw.comp_scores, 0);
+                let cls = '';
+                if (kw.target_score >= best - 0.05) cls = 'text-success';
+                else if (kw.target_score < best - 0.15) cls = 'text-danger';
+                else cls = 'text-warning';
+
+                bertRows += `
+                <tr>
+                    <td class="fw-bold">${kw.keyword}</td>
+                    <td class="fw-bold ${cls} border-end">${kw.target_score}</td>
+                    ${compScores}
+                </tr>`;
+            });
+
+            let compHeaders = '';
+            if (ta.bert.comp_scores) {
+                ta.bert.comp_scores.forEach((s, i) => { compHeaders += `<th>K${i+1}</th>`; });
+            }
+
+            html += `
+            <div class="stat-card">
+                <h5 class="card-title mb-3">Семантика Title (BERT)</h5>
+                <div class="d-flex align-items-baseline mb-3">
+                    <span class="h4 fw-bold me-2">Мой: ${ta.bert.target_score}</span>
+                    ${ta.bert.comp_scores ? ta.bert.comp_scores.map((s,i) => `<span class="badge bg-secondary me-1">K${i+1}: ${s}</span>`).join('') : ''}
+                </div>
+                <table class="table table-sm table-hover">
+                    <thead><tr><th>Ключ</th><th class="border-end">Target</th>${compHeaders}</tr></thead>
+                    <tbody>${bertRows}</tbody>
+                </table>
+            </div>`;
+        }
+
+        container.innerHTML = html;
+    }
+</script>
 </body>
 </html>

url_fetcher.py

@@ -1,143 +0,0 @@
-from typing import Dict, List
-from urllib.parse import urlparse
-import re
-
-import requests
-from bs4 import BeautifulSoup
-
-
-USER_AGENT_PRESETS: List[Dict[str, str]] = [
-    {
-        "key": "googlebot",
-        "name": "Googlebot",
-        "value": "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)",
-    },
-    {
-        "key": "bingbot",
-        "name": "Bingbot",
-        "value": "Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)",
-    },
-    {
-        "key": "chatgpt_user",
-        "name": "ChatGPT-User",
-        "value": "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; ChatGPT-User/1.0; +https://openai.com/bot",
-    },
-    {
-        "key": "gptbot",
-        "name": "GPTBot",
-        "value": "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko); compatible; GPTBot/1.0; +https://openai.com/gptbot",
-    },
-    {
-        "key": "chrome_desktop",
-        "name": "Chrome (Desktop)",
-        "value": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
-    },
-]
-
-
-def get_user_agent_presets() -> List[Dict[str, str]]:
-    return USER_AGENT_PRESETS
-
-
-def _normalize_whitespace(text: str) -> str:
-    text = re.sub(r"[ \t]+", " ", text)
-    text = re.sub(r"\n{3,}", "\n\n", text)
-    return text.strip()
-
-
-def _normalize_url(url: str) -> str:
-    raw = (url or "").strip()
-    if not raw:
-        raise ValueError("URL пустой.")
-
-    if not raw.startswith(("http://", "https://")):
-        raw = "https://" + raw
-
-    parsed = urlparse(raw)
-    if not parsed.scheme or not parsed.netloc:
-        raise ValueError("Некорректный URL.")
-    return raw
-
-
-def _resolve_user_agent(user_agent_key: str) -> Dict[str, str]:
-    key = (user_agent_key or "").strip()
-    for ua in USER_AGENT_PRESETS:
-        if ua["key"] == key:
-            return ua
-    for ua in USER_AGENT_PRESETS:
-        if ua["key"] == "chrome_desktop":
-            return ua
-    return USER_AGENT_PRESETS[0]
-
-
-def _extract_main_text_and_title(html: str) -> Dict[str, str]:
-    soup = BeautifulSoup(html or "", "html.parser")
-
-    for bad in soup(["script", "style", "noscript", "svg", "nav", "footer", "header", "aside", "form", "iframe"]):
-        bad.decompose()
-
-    title = ""
-    if soup.title:
-        title = _normalize_whitespace(soup.title.get_text(" ", strip=True))
-
-    best_text = ""
-
-    # Priority 1: semantic containers usually containing article text.
-    candidates = []
-    for selector, boost in (("article", 1.2), ("main", 1.1)):
-        for node in soup.select(selector):
-            t = _normalize_whitespace(node.get_text("\n", strip=True))
-            if len(t) >= 200:
-                candidates.append((len(t) * boost, t))
-
-    if candidates:
-        best_text = max(candidates, key=lambda x: x[0])[1]
-    else:
-        # Priority 2: collect meaningful paragraphs and list content.
-        paragraphs: List[str] = []
-        for p in soup.find_all(["p", "li"]):
-            txt = _normalize_whitespace(p.get_text(" ", strip=True))
-            if len(txt) >= 40:
-                paragraphs.append(txt)
-        if len(paragraphs) >= 3:
-            best_text = "\n\n".join(paragraphs)
-
-    # Priority 3: fallback to body text.
-    if not best_text:
-        body = soup.body if soup.body else soup
-        best_text = _normalize_whitespace(body.get_text("\n", strip=True))
-
-    return {
-        "title": title,
-        "text": best_text,
-    }
-
-
-def fetch_url_content(url: str, user_agent_key: str = "chrome_desktop", timeout_seconds: int = 15) -> Dict[str, str]:
-    normalized_url = _normalize_url(url)
-    ua = _resolve_user_agent(user_agent_key)
-
-    headers = {
-        "User-Agent": ua["value"],
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-    }
-    response = requests.get(
-        normalized_url,
-        headers=headers,
-        timeout=max(5, min(int(timeout_seconds or 15), 40)),
-        allow_redirects=True,
-    )
-    response.raise_for_status()
-
-    extracted = _extract_main_text_and_title(response.text or "")
-    return {
-        "ok": True,
-        "url": normalized_url,
-        "final_url": response.url,
-        "status_code": response.status_code,
-        "user_agent_key": ua["key"],
-        "user_agent_value": ua["value"],
-        "title": extracted["title"],
-        "text": extracted["text"],
-        "error": "",
-    }