perplexity-notebooklm 0.2.0__py3-none-any.whl

notebooklm_write/__init__.py

@@ -0,0 +1 @@
+"""Extensão de ESCRITA do NotebookLM (add_source via browser). Fase 3."""

notebooklm_write/add_source.py

@@ -0,0 +1,130 @@
+"""Escrita no NotebookLM: adiciona uma fonte (texto colado) a um notebook.
+
+Anexa a um Chrome REAL já logado (--remote-debugging-port) — ver browser.py.
+Por que não login automatizado: o Google bloqueia o login sob automação com
+loop de challenge. Anexar numa sessão já logada contorna isso.
+
+Ação NÃO-reversível na conta Google → o skill SEMPRE pede checkpoint humano
+antes de chamar isto.
+
+Seletores da UI do NotebookLM (pt-BR/en), validados ao vivo. Se a UI mudar,
+ajuste só SELECTORS aqui.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+NOTEBOOKLM_HOME = "https://notebooklm.google.com"
+
+SELECTORS = {
+    "add_source_button": [
+        "button[aria-label*='Adicionar fonte' i]",
+        "button[aria-label*='Add source' i]",
+    ],
+    # opção "Texto copiado" / "Copied text" / "Paste text".
+    # O rótulo é um <span>; o clicável é o botão/role ancestral. Miramos os dois
+    # (o JS-click no span borbulha pro handler do pai).
+    "paste_text_option": [
+        "//button[.//span[normalize-space()='Texto copiado' or normalize-space()='Copied text' or normalize-space()='Paste text']]",
+        "//*[@role='button'][.//*[normalize-space()='Texto copiado' or normalize-space()='Copied text' or normalize-space()='Paste text']]",
+        "//span[normalize-space()='Texto copiado' or normalize-space()='Copied text' or normalize-space()='Paste text']",
+    ],
+    "text_area": [
+        "textarea[aria-label='Texto colado']",
+        "textarea[placeholder*='Cole o texto' i]",
+        "textarea[placeholder*='Paste' i]",
+    ],
+    "insert_button": [
+        # Escopado ao diálogo p/ não casar um 'Inserir' de outro painel.
+        "//*[@role='dialog']//button[normalize-space()='Inserir' or normalize-space()='Insert']",
+        "//button[normalize-space()='Inserir' or normalize-space()='Insert']",
+    ],
+}
+
+
+@dataclass
+class AddSourceResult:
+    notebook_id: str
+    ok: bool
+    detail: str
+
+
+def add_source(notebook_id: str, text: str, *, debug_port: int = 9222) -> AddSourceResult:
+    """Anexa ao Chrome logado, abre o notebook e injeta ``text`` como fonte.
+
+    Pré-requisito: Chrome aberto com --remote-debugging-port=<debug_port> e logado.
+    """
+    import time
+
+    from selenium.webdriver.common.by import By
+    from selenium.webdriver.support import expected_conditions as EC
+    from selenium.webdriver.support.ui import WebDriverWait
+
+    from .browser import attach_driver, is_authenticated
+
+    try:
+        driver = attach_driver(debug_port)
+        # Sempre recarrega: garante estado limpo (fecha diálogos/painéis abertos).
+        driver.get(f"{NOTEBOOKLM_HOME}/notebook/{notebook_id}")
+        time.sleep(6)
+    except Exception as exc:
+        # Chrome :9222 fechado/inacessível → erro limpo, sem traceback propagado.
+        return AddSourceResult(
+            notebook_id, False, f"Chrome :{debug_port} inacessível (abra o Chrome logado): {type(exc).__name__}"
+        )
+    if not is_authenticated(driver):
+        return AddSourceResult(notebook_id, False, "Sessão não autenticada no NotebookLM.")
+
+    wait = WebDriverWait(driver, 20)
+
+    def click(spec_list):
+        # Tenta clique normal; se o elemento existe mas está animando/coberto,
+        # cai pra clique via JS (robusto a overlays/transições da UI).
+        last = None
+        for sel in spec_list:
+            by = By.XPATH if sel.startswith("//") else By.CSS_SELECTOR
+            try:
+                wait.until(EC.element_to_be_clickable((by, sel))).click()
+                return
+            except Exception as e:
+                last = e
+                try:
+                    el = wait.until(EC.presence_of_element_located((by, sel)))
+                    driver.execute_script("arguments[0].scrollIntoView({block:'center'});", el)
+                    driver.execute_script("arguments[0].click();", el)
+                    return
+                except Exception as e2:
+                    last = e2
+        raise RuntimeError(f"Nenhum seletor clicável: {spec_list} ({last})")
+
+    def find(spec_list):
+        last = None
+        for sel in spec_list:
+            by = By.XPATH if sel.startswith("//") else By.CSS_SELECTOR
+            try:
+                return wait.until(EC.presence_of_element_located((by, sel)))
+            except Exception as e:
+                last = e
+        raise RuntimeError(f"Nenhum seletor presente: {spec_list} ({last})")
+
+    step = "init"
+    try:
+        step = "abrir 'Adicionar fonte'"
+        click(SELECTORS["add_source_button"])
+        time.sleep(3)  # diálogo de opções renderiza
+        step = "escolher 'Texto copiado'"
+        click(SELECTORS["paste_text_option"])
+        time.sleep(2)
+        step = "localizar textarea"
+        area = find(SELECTORS["text_area"])
+        area.click()
+        area.send_keys(text)
+        time.sleep(1)
+        step = "clicar 'Inserir'"
+        click(SELECTORS["insert_button"])
+        time.sleep(4)  # ingestão da fonte
+        return AddSourceResult(notebook_id, True, "Fonte adicionada (confirme visualmente).")
+    except Exception as exc:
+        # devolve o erro pro orquestrador com o passo que falhou; não silencia.
+        return AddSourceResult(notebook_id, False, f"Falha no passo [{step}]: {exc}")

notebooklm_write/browser.py

@@ -0,0 +1,81 @@
+"""Launcher Selenium próprio para o NotebookLM.
+
+Por que não usar o NotebookLMClient: seu fallback de Selenium normal NÃO amarra
+o perfil persistente (--user-data-dir), então o login nunca persiste. Aqui
+amarramos o perfil explicitamente. Selenium Manager resolve o chromedriver certo
+para a versão instalada do Chrome (149+), sem undetected-chromedriver (que não
+conecta nessa versão).
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+NOTEBOOKLM_HOME = "https://notebooklm.google.com"
+DEFAULT_PROFILE_DIR = os.environ.get(
+    "NOTEBOOKLM_PROFILE_DIR",
+    str(Path.home() / ".notebooklm-mcp" / "chrome-profile"),
+)
+
+
+def make_driver(profile_dir: str = DEFAULT_PROFILE_DIR, *, headless: bool = False):
+    """Cria um Chrome Selenium amarrado ao perfil persistente.
+
+    O perfil persistente é o que mantém a sessão Google entre execuções — é o
+    ponto que o fallback do notebooklm-mcp erra.
+    """
+    from selenium import webdriver
+    from selenium.webdriver.chrome.options import Options
+
+    Path(profile_dir).mkdir(parents=True, exist_ok=True)
+    opts = Options()
+    opts.add_argument(f"--user-data-dir={profile_dir}")
+    opts.add_argument("--no-first-run")
+    opts.add_argument("--no-default-browser-check")
+    opts.add_argument("--disable-blink-features=AutomationControlled")
+    opts.add_experimental_option("excludeSwitches", ["enable-automation"])
+    opts.add_experimental_option("useAutomationExtension", False)
+    if headless:
+        opts.add_argument("--headless=new")
+
+    driver = webdriver.Chrome(options=opts)  # Selenium Manager baixa o driver certo
+    driver.execute_script(
+        "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
+    )
+    return driver
+
+
+def attach_driver(debug_port: int = 9222):
+    """Anexa a um Chrome REAL já aberto com --remote-debugging-port.
+
+    Caminho robusto: o login acontece num Chrome normal (sem automação → o Google
+    não dispara o loop de challenge anti-bot). O Selenium só anexa na sessão já
+    logada. Pré-requisito: o usuário abriu o Chrome com a porta de debug e logou.
+    """
+    from selenium import webdriver
+    from selenium.webdriver.chrome.options import Options
+
+    opts = Options()
+    opts.add_experimental_option("debuggerAddress", f"127.0.0.1:{debug_port}")
+    driver = webdriver.Chrome(options=opts)
+    _focus_notebooklm(driver)
+    return driver
+
+
+def _focus_notebooklm(driver) -> None:
+    """Foca a aba já aberta do NotebookLM (a sessão logada), não uma about:blank."""
+    for handle in driver.window_handles:
+        driver.switch_to.window(handle)
+        if "notebooklm.google.com" in driver.current_url:
+            return
+    # nenhuma aba NotebookLM: fica na primeira (será navegada por quem chamou)
+
+
+def is_authenticated(driver) -> bool:
+    """Heurística: estamos no NotebookLM e não numa tela de login Google."""
+    url = driver.current_url
+    signed_out = (
+        "accounts.google.com" in url or "/login" in url or "signin" in url
+    )
+    return (not signed_out) and "notebooklm.google.com" in url

notebooklm_write/embed.py

@@ -0,0 +1,49 @@
+"""Embeddings locais (model2vec, estático, SEM API key/torch) p/ dedup semântico.
+
+Lazy + GRACIOSO: se model2vec/o modelo não estiverem disponíveis, `embed` retorna
+None e o chamador cai no MinHash. O modelo (~30MB) baixa no primeiro uso.
+"""
+
+from __future__ import annotations
+
+import math
+
+_MODEL_NAME = "minishlab/potion-base-8M"
+_model = None
+_failed = False
+
+
+def _get_model():
+    global _model, _failed
+    if _model is None and not _failed:
+        try:
+            from model2vec import StaticModel
+
+            _model = StaticModel.from_pretrained(_MODEL_NAME)
+        except Exception:
+            _failed = True  # sem lib/modelo/rede → degrada p/ MinHash
+    return _model
+
+
+def available() -> bool:
+    return _get_model() is not None
+
+
+def embed(text: str) -> list[float] | None:
+    """Vetor do texto (lista de floats) ou None se embedder indisponível."""
+    if not (text and text.strip()):
+        return None  # texto vazio → vetor degenerado; não armazena
+    m = _get_model()
+    if m is None:
+        return None
+    vec = m.encode([text])[0]
+    return [round(float(x), 5) for x in vec]
+
+
+def cosine(a: list[float] | None, b: list[float] | None) -> float:
+    if not a or not b or len(a) != len(b):
+        return 0.0
+    dot = sum(x * y for x, y in zip(a, b))
+    na = math.sqrt(sum(x * x for x in a))
+    nb = math.sqrt(sum(y * y for y in b))
+    return dot / (na * nb) if na and nb else 0.0

notebooklm_write/ledger.py

@@ -0,0 +1,184 @@
+"""Ledger de fontes ingeridas + dedup near-duplicate (sem embeddings/API).
+
+Evita re-injetar a mesma pesquisa (ou quase-igual) num notebook. Dois sinais:
+- hash exato do conteúdo normalizado (dup idêntica).
+- MinHash sobre shingles de 3 tokens → estimativa de Jaccard (near-dup reescrito).
+
+Dependency-free e determinístico (coeficientes derivados do índice, não aleatórios).
+Persistido em ~/.notebooklm/ledger.json. NÃO é dedup semântico real (isso exigiria
+embeddings) — é near-dup lexical, honesto sobre o que detecta.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+_LEDGER = Path.home() / ".notebooklm" / "ledger.json"
+_WORD = re.compile(r"[a-z0-9áàâãéêíóôõúüç]+", re.IGNORECASE)
+_NUM_PERM = 64  # tamanho da assinatura MinHash
+_PRIME = (1 << 61) - 1
+_SHINGLE = 3  # n-gram de tokens
+
+
+def _norm_tokens(text: str) -> list[str]:
+    return _WORD.findall((text or "").lower())
+
+
+def _content_hash(text: str) -> str:
+    return hashlib.sha256(" ".join(_norm_tokens(text)).encode("utf-8")).hexdigest()
+
+
+def _query_key(query: str) -> str:
+    """Chave de query normalizada (case/espaço), preservando a ORDEM dos tokens.
+
+    Só casa re-runs da MESMA query (ex.: 'Fusão 2026' == 'fusao  2026'). NÃO funde
+    reordenações nem queries diferentes que reusam as mesmas palavras — evita
+    falso-skip (pular pesquisa nova) antes do Pro call. Precisão > recall aqui."""
+    return " ".join(_norm_tokens(query))
+
+
+def _shingles(tokens: list[str]) -> set[int]:
+    if len(tokens) < _SHINGLE:
+        joined = " ".join(tokens)
+        return {int(hashlib.md5(joined.encode()).hexdigest(), 16)} if joined else set()
+    out = set()
+    for i in range(len(tokens) - _SHINGLE + 1):
+        s = " ".join(tokens[i : i + _SHINGLE])
+        out.add(int(hashlib.md5(s.encode()).hexdigest(), 16))
+    return out
+
+
+def _minhash(text: str) -> list[int]:
+    """Assinatura MinHash determinística (coeficientes por índice)."""
+    sh = _shingles(_norm_tokens(text))
+    if not sh:
+        return [0] * _NUM_PERM
+    sig = []
+    for i in range(_NUM_PERM):
+        a = 2 * i + 1
+        b = i * i + 1
+        sig.append(min(((a * (x % _PRIME) + b) % _PRIME) for x in sh))
+    return sig
+
+
+def _similarity(sig_a: list[int], sig_b: list[int]) -> float:
+    if not sig_a or not sig_b or len(sig_a) != len(sig_b):
+        return 0.0
+    return sum(1 for x, y in zip(sig_a, sig_b) if x == y) / len(sig_a)
+
+
+@dataclass
+class DupCheck:
+    is_dup: bool
+    similarity: float
+    matched_source_id: str | None
+    reason: str
+
+
+def _load(path: Path) -> dict:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def _save(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+
+
+def check_duplicate(
+    notebook_id: str,
+    content: str,
+    *,
+    threshold: float = 0.8,
+    semantic: bool = False,
+    semantic_threshold: float = 0.85,
+    path: Path = _LEDGER,
+) -> DupCheck:
+    """Verifica se `content` já foi ingerido (idêntico, near-verbatim, ou semântico).
+
+    Camadas: hash exato → MinHash (near-verbatim) → embeddings (semântico, se
+    `semantic=True` e o embedder local estiver disponível; senão ignora gracioso).
+    """
+    entries = _load(path).get(notebook_id, [])
+    chash = _content_hash(content)
+    sig = _minhash(content)
+
+    # Embedding do conteúdo (só se pedido e disponível) — caminho semântico.
+    cvec = None
+    if semantic:
+        try:
+            from .embed import embed
+
+            cvec = embed(content)
+        except Exception:
+            cvec = None
+
+    best = 0.0
+    best_id = None
+    best_sem = 0.0
+    best_sem_id = None
+    for e in entries:
+        if e.get("hash") == chash:
+            return DupCheck(True, 1.0, e.get("source_id"), "hash idêntico")
+        sim = _similarity(sig, e.get("minhash", []))
+        if sim > best:
+            best, best_id = sim, e.get("source_id")
+        if cvec is not None and e.get("embedding"):
+            from .embed import cosine
+
+            csim = cosine(cvec, e["embedding"])
+            if csim > best_sem:
+                best_sem, best_sem_id = csim, e.get("source_id")
+
+    if best_sem >= semantic_threshold:
+        return DupCheck(True, round(best_sem, 3), best_sem_id, f"semântico (cos={best_sem:.2f})")
+    if best >= threshold:
+        return DupCheck(True, round(best, 3), best_id, f"near-dup (sim={best:.2f})")
+    return DupCheck(False, round(max(best, best_sem), 3), None, "novo")
+
+
+def query_seen(notebook_id: str, query: str, *, path: Path = _LEDGER) -> str | None:
+    """Retorna o source_id se a MESMA query já foi ingerida nesse notebook, senão None.
+
+    Pula re-pesquisa do mesmo tema ANTES de gastar a chamada Pro. Só casa queries
+    com a mesma chave (tokens únicos ordenados); query nova/diferente → None."""
+    qk = _query_key(query)
+    if not qk:
+        return None
+    for e in _load(path).get(notebook_id, []):
+        if e.get("query_key") == qk:
+            return e.get("source_id") or "(sem id)"
+    return None
+
+
+def record(
+    notebook_id: str, content: str, title: str, source_id: str | None, *, query: str | None = None, path: Path = _LEDGER
+) -> None:
+    """Registra uma fonte ingerida (hash + minhash + query_key + metadados)."""
+    # Embedding semântico (gracioso: None se o embedder local não estiver disponível).
+    emb = None
+    try:
+        from .embed import embed as _embed
+
+        emb = _embed(content)
+    except Exception:
+        emb = None
+
+    data = _load(path)
+    entry = {
+        "hash": _content_hash(content),
+        "minhash": _minhash(content),
+        "query_key": _query_key(query) if query else "",
+        "title": title,
+        "source_id": source_id,
+    }
+    if emb is not None:
+        entry["embedding"] = emb
+    data.setdefault(notebook_id, []).append(entry)
+    _save(path, data)