Item Search

app.py

@@ -1,419 +1,305 @@
+import os
 import re
-from typing import Dict, List, Tuple, Any, Optional
-
 import gradio as gr
-import numpy as np
-
-from sentence_transformers import SentenceTransformer
-from transformers import pipeline, AutoTokenizer
-
-
-# =========================
-# Models (3 transformers)
-# =========================
-EMB_MODEL_NAME = "intfloat/multilingual-e5-small"  # embeddings retrieval
-ZSHOT_MODEL_NAME = "MoritzLaurer/multilingual-MiniLMv2-L6-mnli-xnli"  # zero-shot domain classifier
-QA_MODEL_NAME = "timpal0l/mdeberta-v3-base-squad2"  # extractive QA
-
-
-_emb_model: Optional[SentenceTransformer] = None
-_zshot_pipe = None
-_zshot_tok: Optional[AutoTokenizer] = None
-_qa_pipe = None
-
-
-def get_emb_model() -> SentenceTransformer:
-    global _emb_model
-    if _emb_model is None:
-        _emb_model = SentenceTransformer(EMB_MODEL_NAME)
-    return _emb_model
-
-
-def get_zshot():
-    global _zshot_pipe, _zshot_tok
-    if _zshot_pipe is None:
-        _zshot_pipe = pipeline("zero-shot-classification", model=ZSHOT_MODEL_NAME)
-        _zshot_tok = AutoTokenizer.from_pretrained(ZSHOT_MODEL_NAME)
-    return _zshot_pipe, _zshot_tok
-
-
-def get_qa():
-    global _qa_pipe
-    if _qa_pipe is None:
-        _qa_pipe = pipeline("question-answering", model=QA_MODEL_NAME, tokenizer=QA_MODEL_NAME)
-    return _qa_pipe
-
-
-# =========================
-# Knowledge base (small built-in)
-# Each entry is a "tip card" retrievable by embeddings.
-# =========================
-KB: List[Dict[str, str]] = [
-    # Moving
-    {"domain": "Переезд", "phase": "Подготовка", "title": "Инвентаризация вещей",
-     "text": "Раздели вещи на: оставить / продать / отдать / выбросить. Упаковывай по комнатам, подписывай коробки, сделай список коробок и фото содержимого."},
-    {"domain": "Переезд", "phase": "Подготовка", "title": "Коммуникации и адрес",
-     "text": "Заранее обнови адрес доставки, банков, подписок. Проверь интернет на новом месте и запланируй подключение на день переезда."},
-    {"domain": "Переезд", "phase": "День Х", "title": "Логистика и контроль",
-     "text": "Собери сумку 'первый день': документы, зарядки, лекарства, вода, перекус, ключи, туалетные принадлежности. Сфотографируй состояние квартиры при выезде/въезде."},
-
-    # Buying (electronics/general)
-    {"domain": "Покупка", "phase": "Выбор", "title": "Критерии и сценарии",
-     "text": "Запиши 3–5 сценариев использования (учёба, игры, работа, поездки). На каждый — приоритеты (вес, автономность, экран, производительность, шум)."},
-    {"domain": "Покупка", "phase": "Проверка", "title": "Проверка перед покупкой",
-     "text": "Сверь гарантию и условия возврата. Проверь комплектацию. Для техники — осмотр на дефекты, серийный номер, чек/инвойс."},
-    {"domain": "Покупка", "phase": "После", "title": "Первые 48 часов",
-     "text": "Сразу протестируй ключевые функции, обнови прошивку/ПО, сохрани упаковку до конца периода возврата."},
-
-    # Study
-    {"domain": "Учёба", "phase": "Подготовка", "title": "План на неделю",
-     "text": "Разбей тему на блоки по 25–45 минут. На каждый блок: цель, краткий конспект, 3 вопроса для самопроверки. Запланируй повторение через 1 и 3 дня."},
-    {"domain": "Учёба", "phase": "Во время", "title": "Активное вспоминание",
-     "text": "Вместо перечитывания делай: тест, пересказ, карточки, задачи. Ошибки — отдельным списком, к ним возвращайся чаще."},
-
-    # Event
-    {"domain": "Мероприятие", "phase": "Подготовка", "title": "Список гостей и бюджет",
-     "text": "Определи: формат (дом/кафе/парк), количество гостей, бюджет на человека, ограничения по еде. Сразу выдели 10–15% на непредвиденное."},
-    {"domain": "Мероприятие", "phase": "Подготовка", "title": "Тайминг и роли",
-     "text": "Составь тайминг по слотам (встреча, еда, активность, торт/финал). Назначь ответственных: музыка, фото, закупки, встреча гостей."},
-
-    # Travel
-    {"domain": "Путешествие", "phase": "Подготовка", "title": "Документы и безопасность",
-     "text": "Проверь документы, страховку, резервные копии (сканы). Запиши экстренные контакты. Продумай связь и оплату (карта/наличные)."},
-
-    # Home / Repair
-    {"domain": "Дом/Ремонт", "phase": "Подготовка", "title": "Материалы и замеры",
-     "text": "Сделай точные замеры, фото, и список материалов с запасом 5–10%. Договорись о вывозе мусора и защите мебели/пола."},
-    {"domain": "Дом/Ремонт", "phase": "Контроль", "title": "Контроль работ",
-     "text": "Фиксируй договорённости письменно, согласуй этапы приёмки, снимай фото прогресса. Оплата — по этапам после проверки качества."},
-
-    # Finance (non-med)
-    {"domain": "Финансы", "phase": "Подготовка", "title": "Разбор расходов",
-     "text": "Раздели траты на обязательные и переменные. Найди 3 быстрых оптимизации (подписки, доставка, импульсные покупки). Поставь лимит на категории."},
-]
-
-DOMAIN_LABELS = [
-    "Переезд", "Покупка", "Учёба", "Мероприятие", "Путешествие", "Дом/Ремонт", "Финансы",
-    "Работа/Проекты", "Документы/Бюрократия"
+import torch
+from transformers import pipeline
+
+# ----------------------------
+# Model config (3 Transformers)
+# ----------------------------
+# 1) Intent / zero-shot
+DEFAULT_INTENT_MODEL = os.getenv("INTENT_MODEL", "joeddav/xlm-roberta-large-xnli")
+
+# 2) Checklist generator
+DEFAULT_GEN_MODEL = os.getenv("GEN_MODEL", "google/mt5-small")
+
+# 3) QA over checklist
+DEFAULT_QA_MODEL = os.getenv("QA_MODEL", "deepset/xlm-roberta-base-squad2")
+
+DEVICE = 0 if torch.cuda.is_available() else -1
+
+
+def safe_make_pipeline(task: str, model_name: str, **kwargs):
+    """
+    Tries to load a pipeline; if fails, uses a smaller/safer fallback.
+    This keeps the Space alive even if the preferred model name is unavailable.
+    """
+    try:
+        return pipeline(task, model=model_name, device=DEVICE, **kwargs), model_name
+    except Exception as e:
+        # Fallbacks (kept simple)
+        if task == "zero-shot-classification":
+            fallback = "facebook/bart-large-mnli"
+        elif task == "text2text-generation":
+            fallback = "google/flan-t5-base"
+        elif task == "question-answering":
+            fallback = "distilbert-base-cased-distilled-squad"
+        else:
+            raise e
+
+        pipe = pipeline(task, model=fallback, device=DEVICE, **kwargs)
+        return pipe, fallback
+
+
+# Create 3 pipelines (3 transformers)
+intent_pipe, intent_model_used = safe_make_pipeline(
+    "zero-shot-classification",
+    DEFAULT_INTENT_MODEL,
+)
+gen_pipe, gen_model_used = safe_make_pipeline(
+    "text2text-generation",
+    DEFAULT_GEN_MODEL,
+)
+qa_pipe, qa_model_used = safe_make_pipeline(
+    "question-answering",
+    DEFAULT_QA_MODEL,
+)
+
+
+# ----------------------------
+# App logic
+# ----------------------------
+DEFAULT_LABELS = [
+    "обучение",
+    "переезд",
+    "путешествие",
+    "карьера/поиск работы",
+    "финансы/покупка",
+    "здоровье/фитнес",
+    "ремонт/быт",
+    "личный проект",
 ]
 
+CATEGORY_CHOICES = ["Авто (определить по тексту)"] + DEFAULT_LABELS
 
-# =========================
-# Helpers
-# =========================
-def norm(s: str) -> str:
-    s = (s or "").replace("\x00", "")
-    s = re.sub(r"[ \t]+", " ", s)
-    s = re.sub(r"\n{3,}", "\n\n", s)
-    return s.strip()
 
+def normalize_text(s: str) -> str:
+    s = (s or "").strip()
+    s = re.sub(r"\s+", " ", s)
+    return s
 
-def truncate_for_zshot(text: str, max_tokens: int = 320) -> str:
-    _, tok = get_zshot()
-    assert tok is not None
-    enc = tok(text, truncation=True, max_length=max_tokens, add_special_tokens=False, return_tensors=None)
-    return tok.decode(enc["input_ids"], skip_special_tokens=True)
 
+def infer_intent(user_goal: str, labels: list[str]):
+    """
+    Returns (top_label, score, all_labels_scores_as_text).
+    """
+    if not user_goal:
+        return "не задано", 0.0, "Нет входного текста."
 
-def cosine(a: np.ndarray, b: np.ndarray) -> float:
-    a = a.astype(np.float32)
-    b = b.astype(np.float32)
-    na = float(np.linalg.norm(a) + 1e-9)
-    nb = float(np.linalg.norm(b) + 1e-9)
-    return float(np.dot(a / na, b / nb))
+    # zero-shot expects candidate_labels
+    result = intent_pipe(user_goal, candidate_labels=labels, multi_label=False)
+    # result: {'sequence': ..., 'labels': [...], 'scores': [...]}
+    top_label = result["labels"][0]
+    top_score = float(result["scores"][0])
 
+    lines = ["Распознавание намерения (zero-shot):"]
+    for lab, sc in zip(result["labels"], result["scores"]):
+        lines.append(f"- {lab}: {sc:.3f}")
+    return top_label, top_score, "\n".join(lines)
 
-def classify_domain(task_text: str) -> Tuple[str, float]:
-    zshot, _ = get_zshot()
-    t = truncate_for_zshot(task_text, max_tokens=320)
-    res = zshot(
-        t,
-        candidate_labels=DOMAIN_LABELS,
-        hypothesis_template="Эта задача относится к категории {}.",
-        multi_label=False,
-    )
-    return res["labels"][0], float(res["scores"][0])
-
-
-def build_kb_index() -> Tuple[List[str], np.ndarray]:
-    """Return (kb_texts, kb_embs)."""
-    emb_model = get_emb_model()
-    kb_texts = []
-    for e in KB:
-        kb_texts.append(f"{e['domain']} | {e['phase']} | {e['title']}. {e['text']}")
-    kb_embs = emb_model.encode(["passage: " + t for t in kb_texts], show_progress_bar=False)
-    return kb_texts, kb_embs
-
-
-_KB_TEXTS: Optional[List[str]] = None
-_KB_EMBS: Optional[np.ndarray] = None
-
-
-def get_kb_cache() -> Tuple[List[str], np.ndarray]:
-    global _KB_TEXTS, _KB_EMBS
-    if _KB_TEXTS is None or _KB_EMBS is None:
-        _KB_TEXTS, _KB_EMBS = build_kb_index()
-    return _KB_TEXTS, _KB_EMBS
-
-
-def retrieve_kb(task_text: str, domain_hint: str, topk: int = 10) -> List[Tuple[int, float]]:
-    kb_texts, kb_embs = get_kb_cache()
-    emb_model = get_emb_model()
-    q = f"{domain_hint}. {task_text}".strip()
-    q_emb = emb_model.encode(["query: " + q], show_progress_bar=False)[0]
-    sims = [(i, cosine(q_emb, kb_embs[i])) for i in range(len(kb_texts))]
-    sims.sort(key=lambda x: x[1], reverse=True)
-    return sims[:topk]
-
-
-def missing_info(budget: str, deadline: str, location: str, people: str) -> List[str]:
-    out = []
-    if not norm(budget):
-        out.append("Бюджет (пример: 300€, 15000₽, 'до 1000').")
-    if not norm(deadline):
-        out.append("Сроки/дедлайн (пример: 'за 2 недели', 'до 10 января').")
-    if not norm(location):
-        out.append("Город/контекст (если влияет: доставка, услуги, путешествия).")
-    if not norm(people):
-        out.append("Кто участвует (один/семья/дети/команда) и сколько людей.")
-    return out
-
-
-def format_constraints(budget: str, deadline: str, location: str, people: str) -> str:
-    parts = []
-    if norm(budget): parts.append(f"- **Бюджет:** {norm(budget)}")
-    if norm(deadline): parts.append(f"- **Сроки:** {norm(deadline)}")
-    if norm(location): parts.append(f"- **Локация:** {norm(location)}")
-    if norm(people): parts.append(f"- **Участники:** {norm(people)}")
-    return "\n".join(parts) if parts else "_Ограничения не указаны._"
-
-
-def make_checklist_markdown(
-    task_text: str,
-    domain: str,
-    domain_conf: float,
-    budget: str,
-    deadline: str,
-    location: str,
-    people: str,
-    topk: int,
-) -> Tuple[str, Dict[str, Any]]:
-    task_text = norm(task_text)
-    if not task_text:
-        return "❗ Опишите задачу одним абзацем.", {}
-
-    # retrieve KB tips
-    picks = retrieve_kb(task_text, domain, topk=topk)
-
-    # Group by phase (based on KB entry order/metadata)
-    by_phase: Dict[str, List[Dict[str, str]]] = {}
-    for idx, sim in picks:
-        e = KB[idx]
-        item = {
-            "title": e["title"],
-            "text": e["text"],
-            "domain": e["domain"],
-            "phase": e["phase"],
-            "sim": f"{sim:.3f}",
-        }
-        by_phase.setdefault(e["phase"], []).append(item)
-
-    # Ensure stable phase order
-    phase_order = ["Подготовка", "Выбор", "Проверка", "Контроль", "Во время", "День Х", "После"]
-    phases = sorted(by_phase.keys(), key=lambda p: phase_order.index(p) if p in phase_order else 999)
-
-    miss = missing_info(budget, deadline, location, people)
-
-    md = []
-    md.append("## Умный чек-лист по задаче")
-    md.append(f"**Задача:** {task_text}")
-    md.append("")
-    md.append(f"**Определённый домен:** `{domain}` (conf `{domain_conf:.3f}`)")
-    md.append("")
-    md.append("### Ограничения")
-    md.append(format_constraints(budget, deadline, location, people))
-    md.append("")
-
-    if miss:
-        md.append("### Что уточнить (быстро улучшит план)")
-        for m in miss:
-            md.append(f"- {m}")
-        md.append("")
-
-    md.append("### Чек-лист")
-    if not phases:
-        md.append("_Не удалось подобрать пункты. Попробуйте переформулировать задачу._")
-    else:
-        for ph in phases:
-            md.append(f"#### {ph}")
-            for j, it in enumerate(by_phase[ph], 1):
-                md.append(f"**{j}. {it['title']}**")
-                md.append(f"- {it['text']}")
-                md.append(f"- _(релевантность: {it['sim']})_")
-                md.append("")
-
-    md.append("---")
-    md.append("**Модели:**")
-    md.append(f"- Zero-shot: `{ZSHOT_MODEL_NAME}`")
-    md.append(f"- Embeddings: `{EMB_MODEL_NAME}`")
-    md.append(f"- QA: `{QA_MODEL_NAME}`")
-
-    state = {
-        "task": task_text,
-        "domain": domain,
-        "domain_conf": domain_conf,
-        "constraints": {
-            "budget": norm(budget),
-            "deadline": norm(deadline),
-            "location": norm(location),
-            "people": norm(people),
-        },
-        "kb_picks": picks,  # indices and sims
-        "plan_md": "\n".join(md).strip()
-    }
-    return "\n".join(md).strip(), state
 
+def build_checklist_prompt(user_goal: str, theme: str | None, style: str, constraints: str):
+    """
+    Prompt for generator model.
+    """
+    theme_part = f"Тема (если помогает): {theme}\n" if theme else ""
+    constraints_part = f"Ограничения/контекст: {constraints}\n" if constraints else ""
 
-def qa_on_plan(question: str, plan_state: Dict[str, Any], extra_topk: int = 6) -> str:
-    q = norm(question)
-    if not q:
-        return "❗ Введите вопрос."
-    if not plan_state or not plan_state.get("task"):
-        return "❗ Сначала сгенерируйте чек-лист (вкладка Generate)."
+    # Works for mt5/flan-t5 style models; they respond better to clear structure.
+    return (
+        "Ты — помощник, который делает практичные чек-листы.\n"
+        "Сформируй чек-лист так, чтобы обычный пользователь мог выполнить задачу.\n"
+        "Требования:\n"
+        "- Выведи 8–15 пунктов максимум.\n"
+        "- Каждый пункт в формате: '- [ ] ...'\n"
+        "- Где уместно, добавляй краткие подпункты (через '  - ...').\n"
+        "- Делай пункты измеримыми и конкретными.\n"
+        "- В конце добавь блок 'Проверка готовности' (3–5 вопросов) и блок 'Риски и как снизить'.\n"
+        "- Пиши по-русски.\n\n"
+        f"Стиль: {style}\n"
+        f"{theme_part}"
+        f"{constraints_part}"
+        f"Задача пользователя: {user_goal}\n\n"
+        "Чек-лист:\n"
+    )
 
-    # Build context from: plan markdown + top KB cards (for evidence)
-    domain = plan_state.get("domain", "")
-    task = plan_state.get("task", "")
 
-    # Retrieve a few extra KB items directly for the question
-    picks = retrieve_kb(f"{task}\nВопрос: {q}", domain, topk=extra_topk)
+def generate_checklist(user_goal: str, category: str, style: str, constraints: str):
+    user_goal = normalize_text(user_goal)
+    constraints = normalize_text(constraints)
 
-    context_parts = []
-    context_parts.append("=== PLAN ===\n" + (plan_state.get("plan_md", "")[:3200]))
+    if not user_goal:
+        return (
+            "Введите описание цели (например: 'Хочу переехать в другой город за 2 месяца').",
+            "",
+            "",
+            None,
+            None,
+        )
 
-    context_parts.append("\n=== RELEVANT TIPS ===")
-    for idx, sim in picks:
-        e = KB[idx]
-        context_parts.append(f"[{e['domain']} | {e['phase']} | {e['title']} | sim {sim:.3f}] {e['text']}")
+    # Decide labels for intent detection (we keep it to 8)
+    labels = DEFAULT_LABELS
 
-    context = "\n".join(context_parts)
-    context = context[:5200]
+    inferred_label, inferred_score, intent_debug = infer_intent(user_goal, labels)
 
-    qa = get_qa()
-    res = qa(question=q, context=context, topk=5, handle_impossible_answer=True)
-    cands = res if isinstance(res, list) else [res]
-    cands.sort(key=lambda r: float(r.get("score", 0.0)), reverse=True)
-    best = cands[0]
+    chosen_theme = None
+    if category and category != "Авто (определить по тексту)":
+        chosen_theme = category
+    else:
+        # Use inferred label only if confidence is decent; otherwise keep theme=None
+        chosen_theme = inferred_label if inferred_score >= 0.35 else None
+
+    prompt = build_checklist_prompt(
+        user_goal=user_goal,
+        theme=chosen_theme,
+        style=style,
+        constraints=constraints,
+    )
 
-    ans = (best.get("answer") or "").strip()
-    score = float(best.get("score") or 0.0)
+    # Generation parameters: conservative to avoid rambling
+    out = gen_pipe(
+        prompt,
+        max_new_tokens=450,
+        do_sample=False,
+    )
+    text = out[0]["generated_text"].strip()
+
+    # Store in state: checklist text + theme + original goal
+    meta = {
+        "goal": user_goal,
+        "theme": chosen_theme,
+        "intent_label": inferred_label,
+        "intent_score": inferred_score,
+        "intent_model": intent_model_used,
+        "gen_model": gen_model_used,
+        "qa_model": qa_model_used,
+    }
 
-    if not ans:
-        return (
-            "## Q&A\n"
-            "Ответ не найден в контексте плана/подсказок.\n\n"
-            "Попробуйте переформулировать вопрос или уточнить ограничения (бюджет/сроки/локация)."
-        ).strip()
+    # A small header for UX
+    header = []
+    header.append(f"**Цель:** {user_goal}")
+    if chosen_theme:
+        header.append(f"**Тема:** {chosen_theme}")
+    header.append(f"**Модели:** intent=`{intent_model_used}`, gen=`{gen_model_used}`, qa=`{qa_model_used}`")
+    header.append("")
+    checklist_md = "\n".join(header) + text
+
+    return checklist_md, intent_debug, chosen_theme or "", checklist_md, meta
+
+
+def answer_question(question: str, checklist_state: str, meta_state: dict | None):
+    question = normalize_text(question)
+    if not checklist_state:
+        return "Сначала сгенерируйте чек-лист на первой вкладке.", ""
+
+    if not question:
+        return "Введите вопрос (например: 'Какие документы подготовить?').", ""
+
+    # Use extractive QA first
+    context = checklist_state
+    qa_res = qa_pipe(question=question, context=context)
+    answer = (qa_res.get("answer") or "").strip()
+    score = float(qa_res.get("score") or 0.0)
+
+    evidence = f"QA score: {score:.3f}\n"
+    if answer:
+        evidence += f"Extracted span: {answer}\n"
+
+    # If QA is weak or empty -> fallback to generator (still transformer #2, already loaded)
+    if (not answer) or score < 0.20 or len(answer) < 3:
+        goal = (meta_state or {}).get("goal", "")
+        theme = (meta_state or {}).get("theme", "")
+
+        prompt = (
+            "Ты — помощник по уточняющим вопросам к чек-листу.\n"
+            "Ответь кратко и практично. Ссылайся на пункты чек-листа (если можно).\n"
+            "Если в чек-листе этого нет — предложи, какими 2–5 пунктами его дополнить.\n"
+            "Пиши по-русски.\n\n"
+            f"Цель: {goal}\n"
+            f"Тема: {theme}\n\n"
+            f"Чек-лист:\n{checklist_state}\n\n"
+            f"Вопрос: {question}\n"
+            "Ответ:\n"
+        )
+        gen_out = gen_pipe(prompt, max_new_tokens=220, do_sample=False)[0]["generated_text"].strip()
+        return gen_out, evidence + "Fallback: generator used (QA confidence low)."
 
-    evidence = context.replace("\n", " ")
-    if len(evidence) > 900:
-        evidence = evidence[:900] + "…"
+    # Otherwise return extracted answer with a bit of framing
+    final = f"{answer}\n\n_(Найдено в чек-листе; уверенность: {score:.2f})_"
+    return final, evidence
 
-    return (
-        "## Q&A\n"
-        f"- **Вопрос:** {q}\n"
-        f"- **Уверенность:** `{score:.3f}`\n\n"
-        "### Ответ\n"
-        f"{ans}\n\n"
-        "### Evidence (snippet)\n"
-        f"{evidence}"
-    ).strip()
-
-
-# =========================
-# UI
-# =========================
-TITLE_HTML = """
-<h2>Умный чек-лист по задаче (3 Transformers)</h2>
-<p style="color:#6b7280;margin-top:-6px">
-Zero-shot → определяем категорию · Embeddings → подбираем пункты · QA → отвечаем на вопросы по плану
-</p>
-"""
-
-EXAMPLE_TASK = "Хочу организовать день рождения дома для 8 человек, чтобы было весело и без хаоса."
-EXAMPLE_BUDGET = "до 150€"
-EXAMPLE_DEADLINE = "через 10 дней"
-EXAMPLE_LOCATION = "Амстердам"
-EXAMPLE_PEOPLE = "8 взрослых, без детей"
-
-with gr.Blocks() as demo:
-    gr.HTML(TITLE_HTML)
-
-    plan_state = gr.State({})
-
-    with gr.Tab("Generate"):
-        task_text = gr.Textbox(
-            label="Опишите задачу (1–5 предложений)",
-            lines=4,
-            value=EXAMPLE_TASK,
-            placeholder="Например: Хочу переехать в новую квартиру за 2 недели, бюджет ограничен..."
-        )
 
-        with gr.Row():
-            budget = gr.Textbox(label="Бюджет (опционально)", value=EXAMPLE_BUDGET, placeholder="Например: до 500€")
-            deadline = gr.Textbox(label="Сроки/дедлайн (опционально)", value=EXAMPLE_DEADLINE, placeholder="Например: до 10 января")
+# ----------------------------
+# Gradio UI
+# ----------------------------
+with gr.Blocks(title="Умный чек-лист (3 Transformers)") as demo:
+    gr.Markdown(
+        "# ✅ Умный чек-лист (3 Transformers)\n"
+        "1) Распознаём намерение (zero-shot) → 2) Генерируем чек-лист → 3) Отвечаем на вопросы по чек-листу\n"
+    )
 
-        with gr.Row():
-            location = gr.Textbox(label="Локация (опционально)", value=EXAMPLE_LOCATION, placeholder="Город/страна")
-            people = gr.Textbox(label="Кто участвует (опционально)", value=EXAMPLE_PEOPLE, placeholder="Один/семья/команда...")
+    checklist_state = gr.State(value=None)  # stores checklist markdown
+    meta_state = gr.State(value=None)       # stores dict
 
+    with gr.Tab("1) Создать чек-лист"):
         with gr.Row():
-            topk = gr.Slider(6, 16, value=10, step=1, label="Сколько пунктов подбирать из базы")
-            gen_btn = gr.Button("Сгенерировать чек-лист", variant="primary")
-
-        report = gr.Markdown()
-
-        def generate(task, budget_, deadline_, location_, people_, topk_):
-            t = norm(task)
-            if not t:
-                return "❗ Опишите задачу.", {}
-            domain, conf = classify_domain(t)
-            md, st = make_checklist_markdown(
-                task_text=t,
-                domain=domain,
-                domain_conf=conf,
-                budget=budget_,
-                deadline=deadline_,
-                location=location_,
-                people=people_,
-                topk=int(topk_),
-            )
-            return md, st
+            with gr.Column(scale=2):
+                user_goal = gr.Textbox(
+                    label="Опишите, что вы хотите сделать",
+                    placeholder="Например: 'Хочу переехать в другой город за 2 месяца и не забыть важное'",
+                    lines=3,
+                )
+
+                category = gr.Dropdown(
+                    label="Категория (необязательно)",
+                    choices=CATEGORY_CHOICES,
+                    value="Авто (определить по тексту)",
+                )
+
+                style = gr.Dropdown(
+                    label="Стиль чек-листа",
+                    choices=["кратко", "подробно", "с акцентом на риски", "с акцентом на сроки"],
+                    value="кратко",
+                )
+
+                constraints = gr.Textbox(
+                    label="Контекст/ограничения (необязательно)",
+                    placeholder="Напр.: бюджет, срок, страна/город, семейное положение, уровень опыта...",
+                    lines=2,
+                )
+
+                gen_btn = gr.Button("Сгенерировать чек-лист", variant="primary")
+
+            with gr.Column(scale=3):
+                checklist_out = gr.Markdown(label="Чек-лист")
+                intent_debug = gr.Textbox(label="Диагностика распознавания намерения", lines=10)
+
+        theme_out = gr.Textbox(label="Выбранная/распознанная тема (если определилась)", interactive=False)
 
         gen_btn.click(
-            generate,
-            inputs=[task_text, budget, deadline, location, people, topk],
-            outputs=[report, plan_state],
+            fn=generate_checklist,
+            inputs=[user_goal, category, style, constraints],
+            outputs=[checklist_out, intent_debug, theme_out, checklist_state, meta_state],
         )
 
-    with gr.Tab("Ask (Q&A)"):
-        gr.Markdown(
-            "Задайте вопрос по плану. Примеры:\n"
-            "- «С чего начать прямо сегодня?»\n"
-            "- «Какие риски самые вероятные?»\n"
-            "- «Как уложиться в бюджет?»\n"
-            "- «Что можно упростить, если мало времени?»"
-        )
-        question = gr.Textbox(label="Ваш вопрос", lines=2, placeholder="Например: Как сократить расходы и не потерять качество?")
+    with gr.Tab("2) Уточняющие вопросы по чек-листу"):
+        gr.Markdown("Задайте вопрос по уже сгенерированному чек-листу (например: *'Какие документы подготовить?'*).")
+        question = gr.Textbox(label="Ваш вопрос", placeholder="Введите вопрос...", lines=2)
         ask_btn = gr.Button("Ответить", variant="primary")
-        answer_md = gr.Markdown()
+        answer_out = gr.Markdown(label="Ответ")
+        evidence_out = gr.Textbox(label="Тех. детали (score и режим ответа)", lines=6)
 
-        ask_btn.click(qa_on_plan, inputs=[question, plan_state], outputs=[answer_md])
+        ask_btn.click(
+            fn=answer_question,
+            inputs=[question, checklist_state, meta_state],
+            outputs=[answer_out, evidence_out],
+        )
 
     gr.Markdown(
-        "_Примечание: это инструмент-помощник. Он может ошибаться — используйте как основу и уточняйте детали._"
+        "### Примечания\n"
+        "- Режим **QA** сначала пытается извлечь ответ прямо из чек-листа.\n"
+        "- Если уверенность низкая, включается генератор и предлагает уточнение/дополнение чек-листа.\n"
     )
 
 if __name__ == "__main__":
-    demo.queue()
     demo.launch()

requirements.txt

@@ -1,7 +1,5 @@
-gradio>=4.44.0
-transformers>=4.43.0
-sentence-transformers>=3.0.0
+gradio>=4.0.0
+transformers>=4.40.0
 torch
-numpy
-pandas
-scikit-learn
+accelerate
+sentencepiece