ThomasMoreAI/legal-skills-open / br/criminal/skills/investigacao-policial-diegocamara89
investigacao-policial-diegocamara89
VerifiedSkill 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.
| File | Kind | Size |
|---|---|---|
| LICENSE | other | 1.1 KB |
| SKILL.md | skill md | 29.3 KB |
| agents/extrator.md | markdown | 7.3 KB |
| agents/openai.yaml | config | 383 B |
| agents/validador.md | markdown | 8.2 KB |
| assets/template_pcrn_drcc.docx | binary | 91.1 KB |
| references/analise_vinculos.md | markdown | 7.0 KB |
| references/cadeia_custodia.md | markdown | 4.1 KB |
| references/categorias_prova.md | markdown | 7.8 KB |
| references/estabelecimento_autoria.md | markdown | 7.1 KB |
| references/expansao_rede.md | markdown | 6.7 KB |
| references/metodologia_ip.md | markdown | 8.5 KB |
| references/orquestracao.md | markdown | 14.1 KB |
| references/requisitos_judiciais.md | markdown | 4.2 KB |
| references/schemas_multiagente.md | markdown | 9.6 KB |
| scripts/auditoria.py | script | 10.0 KB |
| scripts/extrator_verificacao.py | script | 17.1 KB |
| scripts/gerar_docx_relatorio.py | script | 22.6 KB |
| scripts/pre_processador.py | script | 11.0 KB |
| templates/checklist_provas_fraude.md | markdown | 3.1 KB |
| templates/relatorio_diligencias.md | markdown | 2.9 KB |
| templates/relatorio_missao_policial.md | markdown | 12.0 KB |
| templates/tabela_ip_cruzamento.md | markdown | 2.6 KB |
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()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| 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: 472k | Updated | Claude CodeCodex | Verified | Install |
| 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: 323k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| 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 available | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |