wuptracker 0.1.0__py3-none-any.whl

wuptracker/generate.py

@@ -0,0 +1,282 @@
+"""Gera o writeup final em Markdown a partir de uma sessão capturada.
+
+Uso:
+    python generate.py sessions/2026-09-10_14-32_skynet/
+    python generate.py sessions/... --profile generico
+    python generate.py sessions/... --style corrido
+    python generate.py sessions/... --style tecnico,linkedin,resumo
+    python generate.py          # lista sessões disponíveis e pede escolha
+
+--profile (thm|generico): domínio; padrão vem de meta.json.
+--style (tecnico|corrido|resumo|blog|linkedin, separados por vírgula): formato;
+        padrão em config.DEFAULT_STYLE.
+"""
+
+import datetime as dt
+import json
+import os
+import sys
+
+from . import common
+from . import config
+from . import llm
+from . import profiles
+
+
+def pick_session():
+    base = config.SESSIONS_DIR
+    if not os.path.isdir(base):
+        sys.exit(f"[!] Pasta '{base}' não existe. Rode capture.py primeiro.")
+    dirs = sorted(d for d in os.listdir(base)
+                  if os.path.isdir(os.path.join(base, d)))
+    if not dirs:
+        sys.exit(f"[!] Nenhuma sessão em '{base}'.")
+    print("Sessões disponíveis:")
+    for i, d in enumerate(dirs, 1):
+        print(f"  {i}. {d}")
+    choice = input("Escolha o número: ").strip()
+    try:
+        return os.path.join(base, dirs[int(choice) - 1])
+    except (ValueError, IndexError):
+        sys.exit("[!] Escolha inválida.")
+
+
+def load_analysis(captures_dir, filename):
+    path = os.path.join(captures_dir, f"{filename}.json")
+    try:
+        with open(path, encoding="utf-8") as f:
+            return json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def build_context(session_dir):
+    captures_dir = os.path.join(session_dir, "captures")
+
+    with open(os.path.join(session_dir, "meta.json"), encoding="utf-8") as f:
+        meta = json.load(f)
+
+    session_path = os.path.join(session_dir, "session.json")
+    if os.path.exists(session_path):
+        with open(session_path, encoding="utf-8") as f:
+            entries = json.load(f).get("captures", [])
+    else:
+        entries = []
+
+    entries = sorted(entries, key=lambda c: c.get("filename", ""))
+    embed = getattr(config, "EMBED_IMAGES", True)
+
+    blocks, tools, phases, images = [], set(), set(), []
+    for e in entries:
+        a = load_analysis(captures_dir, e["filename"])
+        phase = a.get("phase") or e.get("phase") or "misc"
+        phases.add(phase)
+        tool = a.get("tool")
+        if tool:
+            tools.add(str(tool).lower())
+        # commands (thm) / actions (generico)
+        cmds = (a.get("commands") or []) + (a.get("actions") or [])
+        finds = a.get("findings") or []
+        app = a.get("tool") or a.get("app")
+        km = a.get("is_key_moment")
+        reason = a.get("key_moment_reason")
+
+        img_line = ""
+        img_file = a.get("image") or e.get("image")
+        if img_file and not os.path.exists(os.path.join(captures_dir, img_file)):
+            img_file = e["filename"] + ".png"  # fallback p/ sessões antigas
+        if embed and img_file and os.path.exists(os.path.join(captures_dir, img_file)):
+            stem = os.path.splitext(img_file)[0]
+            ext = ".webp" if getattr(config, "WEBP_IMAGES", True) else \
+                os.path.splitext(img_file)[1]
+            out_name = stem + ext
+            images.append((img_file, out_name))       # (origem, nome no assets/)
+            img_line = f"\nImagem: assets/{out_name}"
+
+        blocks.append(
+            f"[{e.get('timestamp','??:??:??')}] {str(phase).upper()}: "
+            f"{a.get('title') or e.get('title','(sem título)')}\n"
+            f"Descrição: {a.get('description','')}\n"
+            f"App/ferramenta: {app or '—'}\n"
+            f"Ações/comandos: {'; '.join(cmds) if cmds else '—'}\n"
+            f"Findings: {'; '.join(finds) if finds else '—'}\n"
+            f"Momento-chave: {'sim' if km else 'não'}"
+            f"{' — ' + reason if km and reason else ''}"
+            f"{img_line}"
+        )
+
+    return (meta, entries, "\n\n".join(blocks),
+            sorted(tools), sorted(phases), images)
+
+
+def _strip_fence(md):
+    if md.startswith("```"):
+        lines = md.split("\n")
+        md = "\n".join(lines[1:-1] if lines[-1].strip() == "```" else lines[1:])
+    return md.strip()
+
+
+def generate(session_dir, styles=None, profile_override=None, export_dir=None,
+             open_after=None):
+    """Gera um ou mais writeups para a sessão. Retorna a lista de arquivos .md."""
+    session_dir = session_dir.rstrip("/")
+    if not os.path.isdir(session_dir):
+        sys.exit(f"[!] Sessão não encontrada: {session_dir}")
+
+    meta, entries, ctx, tools, phases, images = build_context(session_dir)
+    if not entries:
+        sys.exit("[!] Sessão sem capturas.")
+
+    profile = profiles.resolve_domain(
+        profile_override or meta.get("profile") or "thm")
+    if isinstance(styles, str):
+        styles = styles.split(",")
+    styles = [profiles.resolve_style(s) for s in
+              (styles or getattr(config, "DEFAULT_STYLE", "tecnico").split(","))]
+
+    room = meta.get("room", os.path.basename(session_dir))
+    duration = meta.get("duration", "desconhecida")
+    base = os.path.basename(session_dir)
+
+    common_fields = dict(
+        room_name=room, duration=duration, total_captures=len(entries),
+        tools_list=", ".join(tools) if tools else "não identificadas",
+        captures_context=ctx, fase_tags=", ".join(phases),
+        data_hoje=dt.date.today().isoformat(),
+    )
+
+    llm.preflight()
+    outputs, dirs_with_assets = [], set()
+    for style in styles:
+        prompt = profiles.build_writeup_prompt(profile, style, **common_fields)
+        embed = bool(style in profiles.STYLES_WITH_IMAGES and images)
+
+        print(common.c_cyan(
+            f"Gerando writeup [{profile}/{style}] de '{room}' "
+            f"({len(entries)} capturas)…"))
+        markdown = _strip_fence(llm.generate_text(prompt))
+
+        out_dir = os.path.join(config.WRITEUPS_DIR, base) if embed \
+            else config.WRITEUPS_DIR
+        os.makedirs(out_dir, exist_ok=True)
+
+        stem = "writeup" if style == "tecnico" else f"writeup-{style}"
+        fname = f"{stem}.md" if embed else \
+            (f"{base}.md" if style == "tecnico" else f"{base}-{style}.md")
+        out = os.path.join(out_dir, fname)
+
+        if embed:
+            markdown = _embed_images(markdown, images, entries, session_dir, out_dir)
+            dirs_with_assets.add(out_dir)
+
+        with open(out, "w", encoding="utf-8") as f:
+            f.write(markdown + "\n")
+        outputs.append(out)
+        print(common.c_green(f"✓ {out}"))
+        if embed:
+            print(f"  {len(set(images))} imagem(ns) em "
+                  f"{os.path.join(out_dir, 'assets')}/")
+
+    if export_dir:
+        _export(outputs, dirs_with_assets, export_dir)
+
+    if open_after if open_after is not None else config.OPEN_AFTER_GENERATE:
+        if outputs:
+            common.open_in_editor(outputs[0])
+    return outputs
+
+
+def _export(outputs, dirs_with_assets, export_dir):
+    import shutil
+
+    export_dir = os.path.expanduser(export_dir)
+    os.makedirs(export_dir, exist_ok=True)
+    for md in outputs:
+        shutil.copy2(md, os.path.join(export_dir, os.path.basename(md)))
+    for d in dirs_with_assets:
+        src = os.path.join(d, "assets")
+        if os.path.isdir(src):
+            shutil.copytree(src, os.path.join(export_dir, "assets"),
+                            dirs_exist_ok=True)
+    print(common.c_green(f"↗ exportado para {export_dir}"))
+
+
+def main():
+    args = sys.argv[1:]
+    prof_override = _take_opt(args, "--profile")
+    style_arg = _take_opt(args, "--style")
+    export_dir = _take_opt(args, "--export")
+    open_after = True if "--open" in args else None
+    args = [a for a in args if a != "--open"]
+
+    session_dir = args[0] if args else pick_session()
+    generate(session_dir, style_arg, prof_override, export_dir, open_after)
+
+
+def _take_opt(args, flag):
+    if flag in args:
+        i = args.index(flag)
+        try:
+            val = args[i + 1]
+        except IndexError:
+            sys.exit(f"[!] {flag} requer um valor.")
+        del args[i:i + 2]
+        return val
+    return None
+
+
+def _embed_images(markdown, images, entries, session_dir, out_dir):
+    """images: lista de (arquivo_origem, nome_no_assets). Otimiza cada imagem
+    (WebP/resize) para writeups/<sessão>/assets/ e injeta as que o modelo não
+    referenciou numa galeria no fim."""
+    import shutil
+
+    assets_dir = os.path.join(out_dir, "assets")
+    os.makedirs(assets_dir, exist_ok=True)
+    captures_dir = os.path.join(session_dir, "captures")
+
+    saved_bytes = orig_bytes = 0
+    for src_name, out_name in dict.fromkeys(images):
+        src = os.path.join(captures_dir, src_name)
+        if not os.path.exists(src):
+            continue
+        stem = os.path.join(assets_dir, os.path.splitext(out_name)[0])
+        written = common.optimize_image(src, stem)
+        if not written:                       # otimização falhou -> cópia crua
+            written = os.path.join(assets_dir, src_name)
+            shutil.copy2(src, written)
+        orig_bytes += os.path.getsize(src)
+        saved_bytes += os.path.getsize(written)
+
+    if orig_bytes:
+        pct = round(100 * saved_bytes / orig_bytes)
+        print(common.c_dim(
+            f"  imagens: {_hsize(orig_bytes)} → {_hsize(saved_bytes)} ({pct}%)"))
+
+    out_names = [o for _, o in dict.fromkeys(images)]
+    used = {o for o in out_names if f"assets/{o}" in markdown}
+    missing = [o for o in out_names if o not in used]
+    if missing:
+        gallery = ["", "## Capturas", ""]
+        # mapeia nome-no-assets -> entrada, via stem do arquivo de origem
+        stem_to_entry = {os.path.splitext(e.get("image", ""))[0]: e for e in entries}
+        for o in missing:
+            e = stem_to_entry.get(os.path.splitext(o)[0], {})
+            cap = e.get("title", o)
+            ts = e.get("timestamp", "")
+            gallery += [f"**[{ts}]** {cap}" if ts else f"**{cap}**", "",
+                        f"![{cap}](assets/{o})", ""]
+        markdown = markdown.rstrip() + "\n" + "\n".join(gallery)
+    return markdown
+
+
+def _hsize(n):
+    for unit in ("B", "KB", "MB"):
+        if n < 1024:
+            return f"{n:.0f}{unit}" if unit == "B" else f"{n:.1f}{unit}"
+        n /= 1024
+    return f"{n:.1f}GB"
+
+
+if __name__ == "__main__":
+    main()

wuptracker/llm.py

@@ -0,0 +1,315 @@
+"""Camada de backend do LLM — abstrai qual IA analisa as imagens e escreve o writeup.
+
+Backends (config.BACKEND):
+
+  claude_cli  CLI do Claude Code (`claude -p`). Usa a cota da sua assinatura
+              Pro/Max — sem cobrança por token, sem API key. Requer `claude` no PATH.
+  anthropic   API da Anthropic (ANTHROPIC_API_KEY). Cobra por token.
+  ollama      Modelo local via Ollama (http://localhost:11434). Grátis, offline,
+              privado. Requer um modelo com visão baixado (llava, llama3.2-vision,
+              qwen2.5vl, moondream, minicpm-v...).
+  openai      Qualquer endpoint compatível com a API OpenAI (OpenAI, Groq,
+              OpenRouter, LM Studio, llama.cpp server...). Config: OPENAI_BASE_URL,
+              OPENAI_MODEL, OPENAI_API_KEY.
+  gemini      API do Google Gemini (GEMINI_API_KEY). Tem um tier gratuito
+              generoso. Config: GEMINI_MODEL.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+
+from . import config
+from . import paths
+
+try:
+    from dotenv import load_dotenv
+
+    load_dotenv(paths.ENV_FILE)
+    load_dotenv()  # também o .env do diretório atual, se houver (dev/legado)
+except Exception:
+    pass
+
+BACKENDS = ("claude_cli", "anthropic", "ollama", "openai", "gemini")
+_ALIASES = {
+    "api": "anthropic", "claude": "claude_cli", "cli": "claude_cli",
+    "openai_compat": "openai", "compat": "openai", "local": "ollama",
+    "google": "gemini",
+}
+
+
+def resolve_backend(name):
+    name = (name or "claude_cli").strip().lower()
+    return _ALIASES.get(name, name)
+
+
+def _backend():
+    return resolve_backend(getattr(config, "BACKEND", "claude_cli"))
+
+
+# ==========================================================================
+# API pública
+# ==========================================================================
+def preflight():
+    """Valida que o backend escolhido está utilizável; encerra com msg clara."""
+    b = _backend()
+    if b not in BACKENDS:
+        sys.exit(f"[!] BACKEND inválido: {b!r}. Use: {', '.join(BACKENDS)}")
+
+    if b == "claude_cli":
+        if not shutil.which("claude"):
+            sys.exit("[!] comando 'claude' não encontrado no PATH. Instale o "
+                     "Claude Code ou troque o backend:\n"
+                     "    wuptracker config backend ollama")
+    elif b == "anthropic":
+        _anthropic_client()
+    elif b == "ollama":
+        host = _ollama_host()
+        try:
+            tags = _http_json("GET", f"{host}/api/tags", timeout=5)
+        except Exception as e:
+            sys.exit(f"[!] Ollama inacessível em {host} ({e}).\n"
+                     "    Rode 'ollama serve' ou ajuste 'wuptracker config set "
+                     "ollama-host ...'")
+        model = _ollama_model()
+        have = {m.get("name", "").split(":")[0] for m in tags.get("models", [])}
+        if model.split(":")[0] not in have:
+            print(f"[i] modelo Ollama '{model}' não está baixado — rode: "
+                  f"ollama pull {model}", file=sys.stderr)
+    elif b == "openai":
+        base = _openai_base()
+        local = "localhost" in base or "127.0.0.1" in base
+        if not _openai_key() and not local:
+            sys.exit("[!] OPENAI_API_KEY ausente.\n"
+                     "    wuptracker config api-key <sua-chave>\n"
+                     "    (ou aponte OPENAI_BASE_URL para um servidor local)")
+    elif b == "gemini":
+        if not _gemini_key():
+            sys.exit("[!] GEMINI_API_KEY ausente. Pegue uma (com tier grátis) em "
+                     "https://aistudio.google.com/apikey e rode:\n"
+                     "    wuptracker config api-key <sua-chave>")
+
+
+def analyze_image(png_path, prompt, timeout=180):
+    """Analisa um screenshot. Retorna o texto bruto da resposta do modelo."""
+    b = _backend()
+    if b == "claude_cli":
+        return _cli_analyze_image(png_path, prompt, timeout)
+    img = _jpeg_b64(png_path)
+    if b == "anthropic":
+        return _anthropic_msg(prompt, img)
+    if b == "ollama":
+        return _ollama_chat(prompt, images=[img], timeout=timeout)
+    if b == "openai":
+        return _openai_chat(prompt, img_b64=img, timeout=timeout)
+    if b == "gemini":
+        return _gemini_generate(prompt, img_b64=img, timeout=timeout)
+    raise RuntimeError(f"backend não suportado: {b}")
+
+
+def generate_text(prompt, timeout=600):
+    """Gera texto a partir de um prompt puro. Retorna o texto bruto."""
+    b = _backend()
+    if b == "claude_cli":
+        return _cli_generate_text(prompt, timeout)
+    if b == "anthropic":
+        return _anthropic_msg(prompt, None)
+    if b == "ollama":
+        return _ollama_chat(prompt, images=None, timeout=timeout)
+    if b == "openai":
+        return _openai_chat(prompt, img_b64=None, timeout=timeout)
+    if b == "gemini":
+        return _gemini_generate(prompt, img_b64=None, timeout=timeout)
+    raise RuntimeError(f"backend não suportado: {b}")
+
+
+# ==========================================================================
+# Helpers HTTP / imagem
+# ==========================================================================
+def _jpeg_b64(png_path):
+    from . import common
+
+    return common.png_to_jpeg_b64(png_path)
+
+
+def _http_json(method, url, body=None, headers=None, timeout=120):
+    data = json.dumps(body).encode() if body is not None else None
+    req = urllib.request.Request(
+        url, data=data, method=method,
+        headers={"Content-Type": "application/json", **(headers or {})})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            return json.loads(r.read().decode())
+    except urllib.error.HTTPError as e:
+        detail = e.read().decode(errors="replace")[:400]
+        raise RuntimeError(f"HTTP {e.code}: {detail}")
+
+
+# ==========================================================================
+# Backend: claude CLI
+# ==========================================================================
+def _cli_base_cmd():
+    cmd = ["claude", "-p", "--output-format", "text"]
+    model = getattr(config, "CLAUDE_CLI_MODEL", None)
+    if model:
+        cmd += ["--model", model]
+    return cmd
+
+
+def _cli_run(cmd, stdin_text, timeout):
+    proc = subprocess.run(cmd, input=stdin_text, capture_output=True,
+                          text=True, timeout=timeout)
+    if proc.returncode != 0:
+        raise RuntimeError(f"claude CLI saiu com código {proc.returncode}: "
+                           f"{(proc.stderr or proc.stdout).strip()[:500]}")
+    out = proc.stdout.strip()
+    if not out:
+        raise RuntimeError("claude CLI não retornou saída.")
+    return out
+
+
+def _cli_analyze_image(png_path, prompt, timeout):
+    abs_png = os.path.abspath(png_path)
+    cmd = _cli_base_cmd() + ["--add-dir", os.path.dirname(abs_png)]
+    return _cli_run(cmd, f"{prompt}\n\nAnalise o screenshot no arquivo: {abs_png}",
+                    timeout)
+
+
+def _cli_generate_text(prompt, timeout):
+    return _cli_run(_cli_base_cmd(), prompt, timeout)
+
+
+# ==========================================================================
+# Backend: Anthropic API
+# ==========================================================================
+_client = None
+
+
+def _anthropic_client():
+    global _client
+    if _client is not None:
+        return _client
+    try:
+        from anthropic import Anthropic
+    except ImportError:
+        sys.exit("[!] pacote 'anthropic' não instalado (backend 'anthropic'). "
+                 "pip install anthropic")
+    key = os.environ.get("ANTHROPIC_API_KEY")
+    if not key:
+        sys.exit("[!] ANTHROPIC_API_KEY ausente. wuptracker config api-key <chave>")
+    _client = Anthropic(api_key=key)
+    return _client
+
+
+def _anthropic_msg(prompt, img_b64):
+    content = []
+    if img_b64:
+        content.append({"type": "image", "source": {
+            "type": "base64", "media_type": "image/jpeg", "data": img_b64}})
+    content.append({"type": "text", "text": prompt})
+    max_tokens = (config.ANALYZE_MAX_TOKENS if img_b64
+                  else config.GENERATE_MAX_TOKENS)
+    resp = _anthropic_client().messages.create(
+        model=config.CLAUDE_MODEL, max_tokens=max_tokens,
+        messages=[{"role": "user", "content": content}])
+    return "".join(b.text for b in resp.content if b.type == "text").strip()
+
+
+# ==========================================================================
+# Backend: Ollama (local)
+# ==========================================================================
+def _ollama_host():
+    return getattr(config, "OLLAMA_HOST", "http://localhost:11434").rstrip("/")
+
+
+def _ollama_model():
+    return getattr(config, "OLLAMA_MODEL", "llava")
+
+
+def _ollama_chat(prompt, images, timeout):
+    msg = {"role": "user", "content": prompt}
+    if images:
+        msg["images"] = images
+    body = {"model": _ollama_model(), "messages": [msg], "stream": False,
+            "options": {"temperature": 0.2}}
+    out = _http_json("POST", f"{_ollama_host()}/api/chat", body, timeout=timeout)
+    text = (out.get("message") or {}).get("content", "").strip()
+    if not text:
+        raise RuntimeError(f"Ollama não retornou conteúdo: {str(out)[:300]}")
+    return text
+
+
+# ==========================================================================
+# Backend: OpenAI-compatible (OpenAI, Groq, OpenRouter, LM Studio, llama.cpp…)
+# ==========================================================================
+def _openai_base():
+    return getattr(config, "OPENAI_BASE_URL",
+                   "https://api.openai.com/v1").rstrip("/")
+
+
+def _openai_model():
+    return getattr(config, "OPENAI_MODEL", "gpt-4o-mini")
+
+
+def _openai_key():
+    return os.environ.get("OPENAI_API_KEY", "")
+
+
+def _openai_chat(prompt, img_b64, timeout):
+    if img_b64:
+        content = [
+            {"type": "text", "text": prompt},
+            {"type": "image_url",
+             "image_url": {"url": f"data:image/jpeg;base64,{img_b64}"}},
+        ]
+    else:
+        content = prompt
+    body = {"model": _openai_model(),
+            "messages": [{"role": "user", "content": content}],
+            "temperature": 0.2}
+    headers = {}
+    if _openai_key():
+        headers["Authorization"] = f"Bearer {_openai_key()}"
+    out = _http_json("POST", f"{_openai_base()}/chat/completions",
+                     body, headers, timeout)
+    try:
+        return out["choices"][0]["message"]["content"].strip()
+    except (KeyError, IndexError, TypeError):
+        raise RuntimeError(f"resposta inesperada do endpoint: {str(out)[:300]}")
+
+
+# ==========================================================================
+# Backend: Google Gemini
+# ==========================================================================
+def _gemini_key():
+    return os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY", "")
+
+
+def _gemini_model():
+    return getattr(config, "GEMINI_MODEL", "gemini-2.0-flash")
+
+
+def _gemini_generate(prompt, img_b64, timeout):
+    parts = [{"text": prompt}]
+    if img_b64:
+        parts.append({"inline_data": {"mime_type": "image/jpeg", "data": img_b64}})
+    body = {"contents": [{"parts": parts}],
+            "generationConfig": {"temperature": 0.2}}
+    url = ("https://generativelanguage.googleapis.com/v1beta/models/"
+           f"{_gemini_model()}:generateContent")
+    out = _http_json("POST", url, body,
+                     headers={"x-goog-api-key": _gemini_key()}, timeout=timeout)
+    try:
+        cand = out["candidates"][0]
+        text = "".join(p.get("text", "") for p in cand["content"]["parts"])
+        if not text.strip():
+            raise RuntimeError(
+                f"Gemini retornou vazio (finishReason="
+                f"{cand.get('finishReason')}): {str(out)[:300]}")
+        return text.strip()
+    except (KeyError, IndexError, TypeError):
+        raise RuntimeError(f"resposta inesperada do Gemini: {str(out)[:300]}")

wuptracker/paths.py

@@ -0,0 +1,25 @@
+"""Caminhos padrão do sistema (XDG Base Directory), com fallback sensato.
+
+- Config (config.json, .env): $XDG_CONFIG_HOME/wuptracker  (~/.config/wuptracker)
+- Dados (sessions/):          $XDG_DATA_HOME/wuptracker    (~/.local/share/wuptracker)
+- Writeups:                   ./writeups no diretório onde o comando é chamado
+  (o writeup é um artefato do seu trabalho ali, não um dado global da ferramenta)
+"""
+
+import os
+
+CONFIG_DIR = os.path.join(
+    os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config"),
+    "wuptracker")
+DATA_DIR = os.path.join(
+    os.environ.get("XDG_DATA_HOME") or os.path.expanduser("~/.local/share"),
+    "wuptracker")
+
+CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")
+ENV_FILE = os.path.join(CONFIG_DIR, ".env")
+SESSIONS_DIR = os.path.join(DATA_DIR, "sessions")
+
+
+def ensure_dirs():
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    os.makedirs(DATA_DIR, exist_ok=True)