Skip to content

ThomasMoreAI/legal-skills-open / br/criminal/skills/investigacao-policial-diegocamara89

investigacao-policial-diegocamara89

Verified

Skill operacional para agentes de policia investigadores focada em producao de provas, estabelecimento de autoria e materialidade, e acompanhamento de diligencias. Use esta skill sempre que o usuario mencionar "o que devo coletar", "como provar autoria", "quais provas tenho", "o que esta pendente", "montar tabela de IPs", "cruzar IPs", "expandir suspeito", "expandir rede", "relatorio de diligencias", "cadeia de custodia", "como requisitar dados ao WhatsApp", "status da investigacao", "materialidade", "autoria", "laranja", "conta laranja", "IMEI", "cruzamento de fontes", "convergencia", "golpe do Pix", "golpe do falso advogado", "estelionato digital", "rastrear autor", "o que falta no IP", "pendencias da investigacao", "processar documentos em lote", "quem fez isso", "de onde veio o dinheiro", ou quando /investigacao for invocado. Aplicavel a qualquer tipo de fraude (estelionato, falso advogado, fraude eletronica, Pix, conta laranja, organizacao criminosa). NAO use esta skill para tipificacao penal, analise de prescricao ou fundamentacao juridica — essas ficam com a skill relatorio-final-ip. NAO use para catalogar quais diligencias existem por tipo penal — isso fica com a skill diligencias-iniciais. Mesmo que o usuario nao use essas palavras exatas, ative esta skill sempre que o contexto envolver acompanhamento ativo de uma investigacao de fraude em andamento.

scripts/extrator_verificacao.py

View on GitHub
#!/usr/bin/env python3
"""
extrator_verificacao.py - Extracao direcionada de trechos de documentos

Usado pelo subagente validador para verificar referencias contra fontes brutas.
Extrai uma pagina/secao especifica de um arquivo, sem processar o documento inteiro.

Uso:
    python extrator_verificacao.py --arquivo documento.pdf --pagina 37
    python extrator_verificacao.py --arquivo planilha.xlsx --aba "Sheet1" --celulas "A1:D10"
    python extrator_verificacao.py --arquivo texto.docx --paragrafo 5
    python extrator_verificacao.py --arquivo imagem.png
    python extrator_verificacao.py --arquivo dados.csv --linhas "10-20"
    python extrator_verificacao.py --arquivo dados.txt --linha-inicial 5205 --linha-final 5215
    python extrator_verificacao.py --arquivo documento.pdf --pagina 37 --buscar "187.34.56.78"
    python extrator_verificacao.py --arquivo planilha.xlsx --aba "Plan1" --excel-row 5

Saida: JSON com {texto_extraido, arquivo, pagina, metodo_extracao, hash_arquivo, busca}
"""

import argparse
import hashlib
import json
import os
import re
import sys
from pathlib import Path


# --- Regex deterministicas para entidades investigativas ---

_RE_IPV4 = re.compile(
    r"\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b"
    r"(?::(\d{1,5}))?"
)
_RE_IPV6 = re.compile(
    r"\b(?:[0-9a-fA-F]{1,4}:){2,7}[0-9a-fA-F]{1,4}\b"
)
_RE_CPF = re.compile(
    r"\b(\d{3}[.\s]?\d{3}[.\s]?\d{3}[-.\s]?\d{2})\b"
)
_RE_TELEFONE = re.compile(
    r"(?:\+55\s?)?(?:\(?\d{2}\)?\s?)?\d{4,5}[-.\s]?\d{4}\b"
)
_RE_IMEI = re.compile(
    r"\b\d{15}\b"
)
_RE_EMAIL = re.compile(
    r"\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b"
)
_RE_PIX_CHAVE = re.compile(
    r"\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b",
    re.IGNORECASE,
)
_RE_VALOR_BRL = re.compile(
    r"R\$\s?[\d.,]+\b"
)


def detectar_entidades(texto):
    """Detecta entidades investigativas via regex no texto extraido.

    Retorna dict com listas de entidades encontradas por tipo.
    Essa camada e deterministica (nao depende da IA) e serve como
    cross-check para o extrator subagente.
    """
    if not texto:
        return {}

    entidades = {}

    ipv4 = [m.group(0).rstrip(":") for m in _RE_IPV4.finditer(texto)]
    if ipv4:
        entidades["ipv4"] = sorted(set(ipv4))

    ipv6 = _RE_IPV6.findall(texto)
    if ipv6:
        entidades["ipv6"] = sorted(set(ipv6))

    cpfs = _RE_CPF.findall(texto)
    if cpfs:
        entidades["cpf"] = sorted(set(cpfs))

    telefones = [m.group(0) for m in _RE_TELEFONE.finditer(texto)]
    if telefones:
        entidades["telefone"] = sorted(set(telefones))

    imeis = _RE_IMEI.findall(texto)
    if imeis:
        entidades["imei"] = sorted(set(imeis))

    emails = _RE_EMAIL.findall(texto)
    if emails:
        entidades["email"] = sorted(set(emails))

    pix = _RE_PIX_CHAVE.findall(texto)
    if pix:
        entidades["chave_pix_uuid"] = sorted(set(pix))

    valores = _RE_VALOR_BRL.findall(texto)
    if valores:
        entidades["valor_brl"] = sorted(set(valores))

    return entidades


def calcular_hash(filepath):
    """Calcula SHA256 do arquivo para integridade."""
    sha256 = hashlib.sha256()
    with open(filepath, "rb") as f:
        for bloco in iter(lambda: f.read(8192), b""):
            sha256.update(bloco)
    return sha256.hexdigest()


def extrair_pdf_pagina(filepath, pagina):
    """Extrai texto de uma pagina especifica de PDF."""
    try:
        import pdfplumber

        with pdfplumber.open(filepath) as pdf:
            if pagina < 1 or pagina > len(pdf.pages):
                return {
                    "texto_extraido": None,
                    "erro": f"Pagina {pagina} nao existe. PDF tem {len(pdf.pages)} paginas.",
                    "metodo_extracao": "erro",
                }
            page = pdf.pages[pagina - 1]
            texto = page.extract_text()

            # Tentar extrair tabelas tambem
            tabelas = page.extract_tables()
            texto_tabelas = ""
            for i, tab in enumerate(tabelas):
                if tab:
                    texto_tabelas += f"\n[TABELA {i+1}]\n"
                    for row in tab:
                        texto_tabelas += " | ".join(
                            [str(c) if c else "" for c in row]
                        ) + "\n"

            if texto and len(texto.strip()) > 20:
                resultado = texto
                if texto_tabelas:
                    resultado += "\n" + texto_tabelas
                return {
                    "texto_extraido": resultado,
                    "metodo_extracao": "pdfplumber",
                }
            else:
                # Fallback para OCR
                return extrair_pdf_ocr_pagina(filepath, pagina)

    except ImportError:
        return extrair_pdf_ocr_pagina(filepath, pagina)
    except Exception as e:
        return {
            "texto_extraido": None,
            "erro": str(e),
            "metodo_extracao": "erro",
        }


def extrair_pdf_ocr_pagina(filepath, pagina):
    """Fallback OCR para pagina de PDF."""
    try:
        from pdf2image import convert_from_path
        import pytesseract

        images = convert_from_path(
            filepath, first_page=pagina, last_page=pagina, dpi=300
        )
        if images:
            texto = pytesseract.image_to_string(images[0], lang="por")
            if texto and texto.strip():
                return {
                    "texto_extraido": texto,
                    "metodo_extracao": "OCR_pytesseract_300dpi",
                }
        return {
            "texto_extraido": None,
            "erro": "OCR nao extraiu texto legivel",
            "metodo_extracao": "OCR_falha",
        }
    except ImportError as e:
        return {
            "texto_extraido": None,
            "erro": f"Dependencia OCR nao instalada: {e}",
            "metodo_extracao": "OCR_indisponivel",
        }
    except Exception as e:
        return {
            "texto_extraido": None,
            "erro": str(e),
            "metodo_extracao": "erro",
        }


def extrair_xlsx(filepath, aba=None, celulas=None):
    """Extrai dados de planilha XLSX/XLS."""
    try:
        import pandas as pd

        if aba:
            df = pd.read_excel(filepath, sheet_name=aba, header=None)
        else:
            df = pd.read_excel(filepath, header=None)

        if celulas:
            # Formato "A1:D10" ou "B7"
            import re
            match = re.match(r"([A-Z]+)(\d+)(?::([A-Z]+)(\d+))?", celulas.upper())
            if match:
                col_start = _col_to_idx(match.group(1))
                row_start = int(match.group(2)) - 1
                if match.group(3):
                    col_end = _col_to_idx(match.group(3)) + 1
                    row_end = int(match.group(4))
                else:
                    col_end = col_start + 1
                    row_end = row_start + 1
                df = df.iloc[row_start:row_end, col_start:col_end]

        texto = df.to_string(index=True, header=True)
        return {
            "texto_extraido": texto,
            "metodo_extracao": "pandas_openpyxl",
        }
    except Exception as e:
        return {
            "texto_extraido": None,
            "erro": str(e),
            "metodo_extracao": "erro",
        }


def _col_to_idx(col_letter):
    """Converte letra de coluna para indice (A=0, B=1, ..., Z=25, AA=26)."""
    result = 0
    for char in col_letter.upper():
        result = result * 26 + (ord(char) - ord("A") + 1)
    return result - 1


def extrair_docx(filepath, paragrafo=None):
    """Extrai texto de DOCX."""
    try:
        from docx import Document

        doc = Document(filepath)
        paragrafos = [p.text for p in doc.paragraphs if p.text.strip()]

        if paragrafo is not None:
            if paragrafo < 1 or paragrafo > len(paragrafos):
                return {
                    "texto_extraido": None,
                    "erro": f"Paragrafo {paragrafo} nao existe. DOCX tem {len(paragrafos)} paragrafos com texto.",
                    "metodo_extracao": "erro",
                }
            # Retornar o paragrafo + contexto (2 antes, 2 depois)
            inicio = max(0, paragrafo - 3)
            fim = min(len(paragrafos), paragrafo + 2)
            texto = "\n".join(
                [f"[par {i+1}] {paragrafos[i]}" for i in range(inicio, fim)]
            )
            return {
                "texto_extraido": texto,
                "metodo_extracao": "python-docx",
            }
        else:
            texto = "\n".join(paragrafos)
            return {
                "texto_extraido": texto,
                "metodo_extracao": "python-docx",
            }
    except ImportError:
        # Fallback para pandoc
        try:
            import subprocess

            result = subprocess.run(
                ["pandoc", filepath, "-t", "plain"],
                capture_output=True,
                text=True,
                timeout=30,
            )
            return {
                "texto_extraido": result.stdout,
                "metodo_extracao": "pandoc",
            }
        except Exception as e:
            return {
                "texto_extraido": None,
                "erro": str(e),
                "metodo_extracao": "erro",
            }
    except Exception as e:
        return {
            "texto_extraido": None,
            "erro": str(e),
            "metodo_extracao": "erro",
        }


def extrair_imagem(filepath):
    """Extrai texto de imagem via OCR."""
    try:
        import pytesseract
        from PIL import Image

        img = Image.open(filepath)
        texto = pytesseract.image_to_string(img, lang="por")
        if texto and texto.strip():
            return {
                "texto_extraido": texto,
                "metodo_extracao": "OCR_pytesseract",
            }
        return {
            "texto_extraido": None,
            "erro": "OCR nao extraiu texto legivel da imagem",
            "metodo_extracao": "OCR_falha",
        }
    except Exception as e:
        return {
            "texto_extraido": None,
            "erro": str(e),
            "metodo_extracao": "erro",
        }


def _ler_arquivo_texto(filepath):
    """Le arquivo texto tentando multiplos encodings. Retorna lista de linhas ou None."""
    for enc in ["utf-8", "latin-1", "cp1252"]:
        try:
            with open(filepath, "r", encoding=enc) as f:
                return f.readlines()
        except UnicodeDecodeError:
            continue
    return None


def extrair_csv_txt(filepath, linhas=None, linha_inicial=None, linha_final=None,
                    contexto_extra=2):
    """Extrai texto de CSV ou TXT.

    Parametros:
        linhas: range no formato "10-20" ou numero unico "15" (legacy)
        linha_inicial: linha de inicio (1-indexed), alternativa a linhas
        linha_final: linha de fim (1-indexed, inclusivo), alternativa a linhas
        contexto_extra: linhas adicionais antes/apos a faixa (default 2)
    """
    try:
        todas_linhas = _ler_arquivo_texto(filepath)
        if todas_linhas is None:
            return {
                "texto_extraido": None,
                "erro": "Nao foi possivel decodificar o arquivo (tentado utf-8, latin-1, cp1252)",
                "metodo_extracao": "erro",
            }

        total = len(todas_linhas)

        # Resolver faixa de linhas
        if linha_inicial is not None:
            ini = max(1, linha_inicial - contexto_extra)
            fim = min(total, (linha_final if linha_final is not None else linha_inicial) + contexto_extra)
            offset = ini
            trecho = todas_linhas[ini - 1:fim]
        elif linhas:
            parts = str(linhas).split("-")
            ini = int(parts[0])
            fim = int(parts[1]) if len(parts) > 1 else ini
            offset = ini
            trecho = todas_linhas[ini - 1:fim]
        else:
            offset = 1
            trecho = todas_linhas

        texto = "".join(f"[L{offset + i}] {linha}" for i, linha in enumerate(trecho))

        return {
            "texto_extraido": texto,
            "metodo_extracao": "leitura_direta",
            "total_linhas_arquivo": total,
            "faixa_extraida": f"L{offset}-L{offset + len(trecho) - 1}",
        }
    except Exception as e:
        return {
            "texto_extraido": None,
            "erro": str(e),
            "metodo_extracao": "erro",
        }


def buscar_no_texto(texto, termo):
    """Busca um termo no texto e retorna as linhas que contem o termo com contexto."""
    if not texto or not termo:
        return None

    linhas = texto.split("\n")
    resultados = []
    for i, linha in enumerate(linhas):
        if termo.lower() in linha.lower():
            # Contexto: 2 linhas antes e depois
            inicio = max(0, i - 2)
            fim = min(len(linhas), i + 3)
            contexto = "\n".join(linhas[inicio:fim])
            resultados.append({
                "linha": i + 1,
                "texto_linha": linha.strip(),
                "contexto": contexto,
            })

    return resultados if resultados else None


def main():
    parser = argparse.ArgumentParser(
        description="Extracao direcionada de trechos de documentos para verificacao"
    )
    parser.add_argument("--arquivo", required=True, help="Caminho do arquivo")
    parser.add_argument("--pagina", type=int, help="Numero da pagina (PDF, 1-indexed)")
    parser.add_argument("--aba", help="Nome da aba (XLSX)")
    parser.add_argument("--celulas", help="Range de celulas (XLSX, formato A1:D10)")
    parser.add_argument("--paragrafo", type=int, help="Numero do paragrafo (DOCX)")
    parser.add_argument("--linhas", help="Range de linhas (CSV/TXT, formato 10-20)")
    parser.add_argument("--linha-inicial", type=int, dest="linha_inicial",
                        help="Linha inicial para extracao de TXT (1-indexed)")
    parser.add_argument("--linha-final", type=int, dest="linha_final",
                        help="Linha final para extracao de TXT (1-indexed, inclusivo)")
    parser.add_argument("--contexto", type=int, default=2, dest="contexto",
                        help="Linhas de contexto extra antes/apos a faixa (default 2)")
    parser.add_argument("--excel-row", type=int, dest="excel_row",
                        help="Numero da linha Excel real (XLSX, 1-indexed com cabecalho)")
    parser.add_argument("--buscar", help="Termo para buscar no texto extraido")
    parser.add_argument(
        "--formato", default="json", choices=["json", "texto"],
        help="Formato de saida"
    )

    args = parser.parse_args()

    if not os.path.exists(args.arquivo):
        resultado = {
            "texto_extraido": None,
            "arquivo": args.arquivo,
            "pagina": args.pagina,
            "metodo_extracao": "erro",
            "hash_arquivo": None,
            "erro": f"Arquivo nao encontrado: {args.arquivo}",
        }
        print(json.dumps(resultado, ensure_ascii=False, indent=2))
        sys.exit(1)

    ext = Path(args.arquivo).suffix.lower()
    hash_arquivo = calcular_hash(args.arquivo)

    # Roteamento por tipo de arquivo
    if ext == ".pdf":
        pagina = args.pagina or 1
        resultado = extrair_pdf_pagina(args.arquivo, pagina)
        resultado["pagina"] = pagina

    elif ext in [".xlsx", ".xls"]:
        resultado = extrair_xlsx(args.arquivo, aba=args.aba, celulas=args.celulas)
        resultado["pagina"] = None
        resultado["aba"] = args.aba
        resultado["celulas"] = args.celulas

    elif ext == ".docx":
        resultado = extrair_docx(args.arquivo, paragrafo=args.paragrafo)
        resultado["pagina"] = None
        resultado["paragrafo"] = args.paragrafo

    elif ext in [".jpg", ".jpeg", ".png", ".tiff", ".bmp", ".webp"]:
        resultado = extrair_imagem(args.arquivo)
        resultado["pagina"] = None

    elif ext in [".csv", ".txt", ".tsv", ".log"]:
        resultado = extrair_csv_txt(
            args.arquivo,
            linhas=args.linhas,
            linha_inicial=args.linha_inicial,
            linha_final=args.linha_final,
            contexto_extra=args.contexto,
        )
        resultado["pagina"] = None
        resultado["linhas"] = args.linhas

    else:
        resultado = {
            "texto_extraido": None,
            "metodo_extracao": "nao_suportado",
            "erro": f"Formato {ext} nao suportado. Suportados: PDF, XLSX, XLS, DOCX, PNG, JPG, TIFF, BMP, CSV, TXT",
        }

    # Adicionar metadados comuns
    resultado["arquivo"] = args.arquivo
    resultado["hash_arquivo"] = hash_arquivo

    # Detectar entidades via regex (camada deterministica)
    if resultado.get("texto_extraido"):
        entidades = detectar_entidades(resultado["texto_extraido"])
        if entidades:
            resultado["entidades_detectadas"] = entidades

    # Buscar termo no texto extraido (se solicitado)
    if args.buscar and resultado.get("texto_extraido"):
        resultado["busca"] = {
            "termo": args.buscar,
            "resultados": buscar_no_texto(resultado["texto_extraido"], args.buscar),
        }

    # Saida
    if args.formato == "json":
        print(json.dumps(resultado, ensure_ascii=False, indent=2))
    else:
        if resultado.get("texto_extraido"):
            print(resultado["texto_extraido"])
        else:
            print(f"ERRO: {resultado.get('erro', 'Falha na extracao')}")
            sys.exit(1)


if __name__ == "__main__":
    main()
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 323kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 323kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 323kUpdated Claude CodeCodexVerifiedInstall