$ neuler scout --topic "operator splitting SGD" --depth S
→ 12 релевантных статей, Markdown-отчёт, 3 knowledge gaps

neuler/
├── scout.py          # main CLI (80–100 строк) — ПИШЕМ ПЕРВЫМ
├── librarian.py      # обёртка над SDR search (60–80 строк) — ПИШЕМ ВТОРЫМ
├── formatter.py      # Markdown → report (40–50 строк) — ПИШЕМ ТРЕТЬИМ
└── gap_finder.py     # LLM-вызов для knowledge gaps (50–60 строк) — ПИШЕМ ЧЕТВЁРТЫМ

#!/usr/bin/env python3
"""neuler scout: Literature Scout CLI"""
import argparse
import asyncio
from librarian import Librarian
from formatter import format_report

DEPTHS = {"S": 3, "M": 7, "L": 15}  # num search queries

async def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--topic", required=True)
    parser.add_argument("--depth", choices=["S", "M", "L"], default="S")
    parser.add_argument("--output", default=None)  # None = stdout
    args = parser.parse_args()

    lib = Librarian(max_queries=DEPTHS[args.depth])
    papers = await lib.search(args.topic)
    gaps = await lib.find_gaps(args.topic, papers)
    report = format_report(args.topic, papers, gaps)

    if args.output:
        with open(args.output, "w") as f: f.write(report)
        print(f"✅ Отчёт сохранён: {args.output} ({len(papers)} статей, {len(gaps)} gaps)")
    else:
        print(report)

if __name__ == "__main__":
    asyncio.run(main())

"""Librarian: wraps SDR search infrastructure"""
import sys
sys.path.insert(0, "/root/sdr_repo/src")

import asyncio
from open_deep_research.search.openalex_search import OpenAlexSearch
from open_deep_research.coordinator import QueryParser

class Librarian:
    def __init__(self, max_queries: int = 5):
        self.max_queries = max_queries
        self.openalex = OpenAlexSearch()

    async def search(self, topic: str) -> list[dict]:
        clean = QueryParser.clean_query(topic)
        # Параллельный поиск: topic + синонимы
        queries = self._expand_topic(clean)[:self.max_queries]
        tasks = [self.openalex.search(q) for q in queries]
        results = await asyncio.gather(*tasks, return_exceptions=True)

        papers = []
        seen_dois = set()
        for r in results:
            if isinstance(r, Exception): continue
            for p in (r or []):
                doi = p.get("doi", "")
                if doi not in seen_dois:
                    seen_dois.add(doi)
                    papers.append(p)

        # Score by cited_by_count + relevance
        papers.sort(key=lambda p: p.get("cited_by_count", 0), reverse=True)
        return papers[:20]  # top 20

    async def find_gaps(self, topic: str, papers: list) -> list[str]:
        """LLM-вызов: найти knowledge gaps из списка статей"""
        if not papers: return ["Статьи не найдены — тема слишком узкая?"]
        # Реализуется в Day 3 (gap_finder.py)
        return ["[gap_finder.py: TODO Day 3]"]

    def _expand_topic(self, topic: str) -> list[str]:
        """Генерация поисковых запросов из темы"""
        # Простая эвристика: основной запрос + subtopics
        return [
            topic,
            topic + " convergence theory",
            topic + " benchmark comparison",
        ]

"""Format papers list → readable Markdown report"""
from datetime import datetime

def format_report(topic: str, papers: list, gaps: list) -> str:
    lines = [
        f"# Literature Scout: {topic}",
        f"*Создано: {datetime.now().strftime('%Y-%m-%d %H:%M')} MSK*",
        f"*Найдено: {len(papers)} статей, {len(gaps)} knowledge gaps*",
        "",
        "---", "",
        "## Топ статьи", "",
    ]

    for i, p in enumerate(papers[:15], 1):
        title = p.get("title", "Unknown")
        doi = p.get("doi", "")
        year = p.get("publication_year", "?")
        cited = p.get("cited_by_count", 0)
        abstract = (p.get("abstract", "") or "")[:200]

        lines.extend([
            f"### {i}. {title} ({year})",
            f"**DOI**: {doi} | **Cited**: {cited}",
            f"{abstract}...",
            "",
        ])

    lines.extend([
        "---", "",
        "## Knowledge Gaps", "",
        *[f"- {gap}" for gap in gaps],
        "",
    ])
    return "\n".join(lines)

cd /root/neuler
python scout.py --topic "operator splitting SGD" --depth S --output test_report.md

"""gap_finder: LLM-вызов для knowledge gap extraction"""
from openai import AsyncOpenAI  # Groq compatible
import os, json

async def find_gaps_llm(topic: str, papers: list, model: str = "llama-3.1-8b-instant") -> list[str]:
    client = AsyncOpenAI(
        base_url=os.getenv("CLOUD_BASE_URL"),
        api_key=os.getenv("GROQ_API_KEY")
    )
    abstracts = "\n".join([
        f"- {p.get('title','?')} ({p.get('publication_year','?')}): {(p.get('abstract') or '')[:150]}"
        for p in papers[:10]
    ])

    prompt = f"""Тема: {topic}

Найденные статьи:
{abstracts}

Задача: выяви 3–5 knowledge gaps — направлений, которых НЕТ в найденных статьях.
Формат: JSON-список строк. Пример: ["Gap 1", "Gap 2", "Gap 3"]
ТОЛЬКО JSON, без пояснений."""

    resp = await client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3,
        max_tokens=500,
    )
    try:
        return json.loads(resp.choices[0].message.content)
    except Exception:
        return ["LLM вернул не-JSON — проверь промпт"]

# bench/astabench_a.py
KNOWN_PAPERS = [
    "10.1007/978-3-319-91578-4_5",  # Alecsa 2020
    "10.1007/s10107-012-0516-2",     # Beck-Teboulle
]

def coverage_score(found_papers: list, known_papers: list = KNOWN_PAPERS) -> float:
    found_dois = {p.get("doi", "") for p in found_papers}
    return sum(doi in found_dois for doi in known_papers) / len(known_papers)