ThomasMoreAI/legal-skills-open / br/litigation/skills/juriscan-brunobracaioli
juriscan-brunobracaioli
VerifiedAnálise forense de processos judiciais brasileiros. Extrai, classifica e cruza peças processuais, detecta contradições, calcula prazos CPC e gera relatórios de risco com exportação para Obsidian. Use quando mencionar: processo judicial, petição, sentença, acórdão, contradições, prazos, timeline, análise forense, Obsidian.
scripts/generate_report.py
View on GitHub"""Generate executive markdown report consolidating all pipeline outputs — Phase A.4.3.
This is the "uau" centerpiece of v3.1.0-legacy. It takes all the structured
JSON outputs of the pipeline and produces a single rich markdown document
(REPORT.md) that becomes the final deliverable of /juriscan.
Inputs (all optional — sections degrade gracefully when JSON missing):
--analyzed analyzed.json (required)
--contradictions contradictions.json
--instances instances.json
--prazos prazos.json
--risk risk.json
--recommendations recommendations.json
Output:
--output REPORT.md
The resulting markdown is designed to be:
- Terminal-renderable as Claude's final response to the user
- Copy-pasteable into email, Obsidian, or any markdown viewer
- Self-contained: has executive summary, alerts, pieces, contradictions
with verbatim citations, risk assessment, strategic recommendations per
polo, Mermaid timeline, prazos dashboard, and file listing
"""
from __future__ import annotations
import argparse
import json
import sys
from pathlib import Path
from typing import Any
REPO_ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO_ROOT / "scripts"))
try:
from utils.monetary import format_brl, normalize_brl # noqa: E402
except ImportError:
def format_brl(v: float) -> str:
return f"R$ {v:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
def normalize_brl(s: str) -> float | None:
if not s:
return None
try:
return float(s.replace("R$", "").replace(".", "").replace(",", ".").strip())
except (ValueError, AttributeError):
return None
# ---------- loaders ----------
def _load_json(path: Path | None) -> dict | None:
if path is None or not path.exists():
return None
try:
return json.loads(path.read_text(encoding="utf-8"))
except (json.JSONDecodeError, OSError):
return None
# ---------- helpers ----------
def _escape_md(text: Any) -> str:
"""Escape markdown special chars in user content (minimal, preserves readability)."""
if text is None:
return ""
s = str(text)
# Escape pipes in table cells (caller already decides if inside table)
return s.replace("\n", " ").strip()
def _escape_table_cell(text: Any) -> str:
"""Escape content for safe placement inside a markdown table cell."""
if text is None:
return ""
s = str(text).replace("\n", " ").replace("|", "\\|").strip()
# Truncate very long cells
if len(s) > 200:
s = s[:197] + "..."
return s
def _blockquote(text: str) -> str:
"""Render a multi-line string as a markdown blockquote."""
if not text:
return ""
lines = str(text).splitlines()
return "\n".join(f"> {line}" if line.strip() else ">" for line in lines)
def _pick_first(*values: Any) -> Any:
for v in values:
if v is not None and v != "" and v != [] and v != {}:
return v
return None
def _truncate_words(text: Any, max_chars: int, ellipsis: str = "…") -> str:
"""Truncate text at the last word boundary before max_chars.
Avoids the v3.1.1 bug where `text[:200]` cut words in half like
'Vencido o Des. Henrique Almeida Ne' (truncated 'Neto').
"""
if text is None:
return ""
s = str(text).strip()
if len(s) <= max_chars:
return s.rstrip(" ,.;:")
cut = s[:max_chars]
last_space = cut.rfind(" ")
if last_space > max_chars * 0.6: # only use word boundary if reasonably close
cut = cut[:last_space]
return cut.rstrip(" ,.;:") + ellipsis
_INSTANCE_LABELS = {
"1a_instancia": "1ª instância",
"primeira_instancia": "1ª instância",
"tj": "2ª instância (TJ)",
"trf": "2ª instância (TRF)",
"trt": "2ª instância (TRT)",
"stj": "STJ",
"stf": "STF",
"tst": "TST",
}
def _infer_current_instance(chunks: list[dict]) -> str | None:
"""v3.1.4: infer current instance from the last chronological piece.
generate_report already sorts pieces chronologically for rendering, but
the header is built before that. We do a mini-sort here by primary_date
and pick the instancia of the latest piece.
"""
if not chunks:
return None
dated = [c for c in chunks if c.get("primary_date") and c.get("instancia")]
if not dated:
for c in reversed(chunks):
inst = c.get("instancia")
if inst:
return _INSTANCE_LABELS.get(inst, inst)
return None
def _iso_key(c: dict) -> str:
d = c.get("primary_date") or ""
# Accept DD/MM/YYYY or YYYY-MM-DD
if "/" in d and len(d) == 10:
dd, mm, yy = d.split("/")
return f"{yy}-{mm}-{dd}"
return d
dated.sort(key=_iso_key)
inst = dated[-1].get("instancia")
return _INSTANCE_LABELS.get(inst, inst) if inst else None
def _factor_to_text(factor: Any) -> str:
"""Render a risk factor, which may be a string or a dict, as plain text.
Handles the v3.1.2 bug where risk_scorer.py emits dicts like
{'fator': '...', 'fundamentacao': '...'} but the report generator
was rendering them as raw str(dict) output.
"""
if factor is None:
return ""
if isinstance(factor, str):
return factor
if isinstance(factor, dict):
for key in ("fator", "descricao", "description", "factor", "text", "label"):
val = factor.get(key)
if val:
return str(val)
return ""
return str(factor)
def _find_valor_causa(chunks: list) -> str | None:
"""Look for the 'valor da causa' across chunks, with fallback chain:
1. valores.causa (direct)
2. valores.outros[] with descricao containing 'causa' or 'contrato'
3. valores.condenacao (last resort)
"""
for ch in chunks:
valores = ch.get("valores") or {}
if valores.get("causa"):
return valores["causa"]
for ch in chunks:
valores = ch.get("valores") or {}
outros = valores.get("outros") or []
for entry in outros:
if not isinstance(entry, dict):
continue
desc = (entry.get("descricao") or "").lower()
if any(tok in desc for tok in ("causa", "contrato", "valor original", "original")):
valor = entry.get("valor")
if valor:
return valor
for ch in chunks:
valores = ch.get("valores") or {}
if valores.get("condenacao"):
return valores["condenacao"]
return None
def _date_sort_key(date_str: Any) -> str:
"""Parse DD/MM/YYYY and return an ISO-sortable string. Missing or
unparseable dates sort last."""
if not date_str:
return "9999-99-99"
s = str(date_str).strip()
try:
parts = s.split("/")
if len(parts) == 3:
dd, mm, yyyy = parts
return f"{yyyy}-{mm.zfill(2)}-{dd.zfill(2)}"
except (AttributeError, ValueError):
pass
# Maybe already ISO
if len(s) >= 10 and s[4] == "-" and s[7] == "-":
return s[:10]
return "9999-99-99"
# ---------- section renderers ----------
def render_header(analyzed: dict, risk: dict | None) -> str:
"""Cabeçalho com metadados do processo."""
processo = analyzed.get("processo_number") or "(não identificado)"
metadata = analyzed.get("processo_metadata") or {}
chunks = analyzed.get("chunks") or []
# Extract parties from first chunk that has them
autor_list: list[str] = []
reu_list: list[str] = []
vara: str | None = metadata.get("vara")
for ch in chunks:
partes = ch.get("partes") or {}
if not autor_list and partes.get("autor"):
autor_list = partes["autor"] if isinstance(partes["autor"], list) else [partes["autor"]]
if not reu_list and partes.get("reu"):
reu_list = partes["reu"] if isinstance(partes["reu"], list) else [partes["reu"]]
if not vara and partes.get("vara"):
vara = partes["vara"]
autor_str = ", ".join(autor_list) if autor_list else "(não identificado)"
reu_str = ", ".join(reu_list) if reu_list else "(não identificado)"
# Valor da causa — tries valores.causa, then valores.outros[], then condenacao
valor_causa = _find_valor_causa(chunks) or "(não identificado)"
# Status
status = _pick_first(
metadata.get("fase_atual"),
analyzed.get("process_state"),
"(em andamento)",
)
instance = metadata.get("instancia_atual") or _infer_current_instance(chunks) or "(não identificada)"
risk_badge = ""
if risk:
level = risk.get("risk_level", "")
score = risk.get("overall_score")
if level:
emoji = {"ALTO": "🔴", "MÉDIO": "🟡", "BAIXO": "🟢"}.get(level, "⚪")
risk_badge = f" · **Risco:** {emoji} {level}"
if score is not None:
risk_badge += f" ({score}/10)"
return f"""# 📋 Análise Forense — Processo nº {_escape_md(processo)}
> **Partes:** {_escape_md(autor_str)} × {_escape_md(reu_str)}
> **Vara/Órgão:** {_escape_md(vara) or "(não identificado)"}
> **Valor da causa:** {_escape_md(valor_causa)}
> **Fase:** {_escape_md(status)} · **Instância atual:** {_escape_md(instance)}{risk_badge}
> **Pipeline:** legacy v3.1.0 — análise assistida por IA, requer revisão profissional"""
def render_executive_summary(
analyzed: dict,
contradictions: dict | None,
risk: dict | None,
) -> str:
"""Resumo executivo gerado a partir dos campos estruturados."""
chunks = analyzed.get("chunks") or []
n_pieces = len(chunks)
# Find sentença + acórdão
sentenca = next((c for c in chunks if (c.get("tipo_peca") or "").upper() == "SENTENÇA"), None)
acordao = next((c for c in chunks if (c.get("tipo_peca") or "").upper() == "ACÓRDÃO"), None)
parts = []
parts.append(f"O processo contém **{n_pieces} peça(s) processual(is)** analisada(s).")
if sentenca:
dec = sentenca.get("decisao")
if dec:
parts.append(f"A sentença de primeiro grau decidiu: *{_truncate_words(_escape_md(dec), 220)}*.")
if acordao:
dec = acordao.get("decisao")
ac_struct = acordao.get("acordao_structure") or {}
votacao = ac_struct.get("votacao")
resultado = ac_struct.get("resultado")
if dec or resultado:
txt = "Em segunda instância, o acórdão"
if resultado:
txt += f" resultou em **{resultado.replace('_', ' ').lower()}**"
if votacao:
txt += f" por **{votacao.lower()}**"
if dec:
txt += f": *{_truncate_words(_escape_md(dec), 220)}*."
else:
txt += "."
parts.append(txt)
if contradictions:
n_contr = len(contradictions.get("contradictions", []))
if n_contr:
parts.append(f"A análise detectou **{n_contr} contradição(ões)** entre as peças.")
if risk:
level = risk.get("risk_level")
score = risk.get("overall_score")
if level:
parts.append(f"Avaliação global de risco: **{level}** ({score}/10).")
return "## 📋 Resumo Executivo\n\n" + " ".join(parts)
def render_alerts(analyzed: dict, prazos: dict | None, contradictions: dict | None) -> str:
"""Caixas de alerta críticos — art. 942, Lei 14.905, prazos urgentes."""
alerts: list[str] = []
chunks = analyzed.get("chunks") or []
# Art. 942 detection
for ch in chunks:
if (ch.get("tipo_peca") or "").upper() != "ACÓRDÃO":
continue
ac = ch.get("acordao_structure") or {}
if ac.get("votacao") == "MAIORIA":
# Check if it's a reform (not just desprovimento)
resultado = ac.get("resultado") or ""
if resultado in ("PROVIDO", "PARCIALMENTE_PROVIDO"):
quote = None
for cit in ch.get("citation_spans") or []:
src = cit.get("source_text", "")
if "maioria" in src.lower() or "vencido" in src.lower():
quote = src
break
alerts.append(
"> 🚨 **ALERTA CRÍTICO — Art. 942 CPC (possível nulidade)**\n"
f"> O acórdão (peça #{ch.get('index')}) foi proferido por **maioria** e "
f"reformou a sentença em {resultado.replace('_', ' ').lower()}. "
"Em apelação com reforma por maioria, o art. 942 do CPC impõe a "
"**técnica de ampliação do colegiado**. Se não aplicada, há nulidade "
"arguível via embargos de declaração e/ou Recurso Especial.\n"
+ (f">\n> *Trecho fonte:* {_escape_md(quote)[:300]}" if quote else "")
)
# Lei 14.905/2024 — monetary_recalculations (supports both shapes:
# finalize.py legacy {periodo_1, periodo_2} and finalize_legacy.py {periods: [...]})
for recalc in analyzed.get("monetary_recalculations") or []:
tipo = recalc.get("tipo", "")
if "14905" not in tipo and "LEI_14905" not in tipo:
continue
base = recalc.get("base") or recalc.get("base_original") or ""
periods = recalc.get("periods")
if not periods:
p1 = recalc.get("periodo_1") or {}
p2 = recalc.get("periodo_2") or {}
periods = [p for p in [p1, p2] if p]
lines = [
"> 💰 **Lei 14.905/2024 — Recálculo de juros obrigatório**",
f"> Base: {_escape_md(base)}",
]
for i, p in enumerate(periods, 1):
de = p.get("de") or ""
ate = p.get("ate") or ""
taxa = p.get("taxa") or ""
valor = p.get("valor_com_juros") or p.get("valor") or "—"
lines.append(
f"> Período {i} ({_escape_md(de)} → {_escape_md(ate)}): "
f"{_escape_md(taxa)} → {_escape_md(valor)}"
)
alerts.append("\n".join(lines))
# Prazos urgentes (< 10 dias)
if prazos:
prazo_list = prazos if isinstance(prazos, list) else prazos.get("prazos") or prazos.get("prazos_calculados") or []
for p in prazo_list:
dias = p.get("dias_restantes")
status = p.get("status", "")
if status in ("ultimo_dia", "vencido") or (isinstance(dias, int) and dias <= 10):
emoji = "🔴" if status == "vencido" else "⏰"
alerts.append(
f"> {emoji} **Prazo {'VENCIDO' if status == 'vencido' else 'URGENTE'}** — "
f"{_escape_md(p.get('tipo'))} "
f"(limite: {_escape_md(p.get('data_limite'))}, "
f"dias restantes: {dias if dias is not None else 'N/A'})\n"
f"> Fundamento: {_escape_md(p.get('fundamento_legal'))}"
)
# High-impact contradictions
if contradictions:
high = [c for c in (contradictions.get("contradictions") or []) if c.get("impacto") == "ALTO"]
if len(high) >= 3:
alerts.append(
f"> ⚠️ **{len(high)} contradições de ALTO impacto detectadas** — "
f"ver seção Contradições abaixo."
)
if not alerts:
return ""
return "## ⚠️ Alertas Críticos\n\n" + "\n>\n".join(alerts).replace(">\n>\n>", ">\n>\n> ")
def render_pieces_table(analyzed: dict) -> str:
"""Tabela de peças processuais ordenada cronologicamente (v3.1.1 fix).
Chunks are sorted by primary_date ascending. When date is missing or
unparseable, entries fall to the end preserving their original index
as secondary sort key.
"""
chunks = analyzed.get("chunks") or []
if not chunks:
return ""
def sort_key(ch: dict) -> tuple:
date = ch.get("primary_date") or ch.get("data")
idx_raw = ch.get("index", 9999)
# Normalize index to int for secondary sort (suffixed keys become inf)
try:
idx_num = int(idx_raw)
except (TypeError, ValueError):
idx_num = 9999
return (_date_sort_key(date), idx_num)
sorted_chunks = sorted(chunks, key=sort_key)
rows = ["## 📑 Peças do Processo\n"]
rows.append(f"**Total:** {len(sorted_chunks)} peça(s) (ordenadas cronologicamente)\n")
rows.append("| # | Peça | Data | Instância | Decisão/Resumo |")
rows.append("|---|---|---|---|---|")
for ch in sorted_chunks:
idx = ch.get("index", "")
tipo = ch.get("tipo_peca") or ch.get("label") or "(desconhecido)"
data = ch.get("primary_date") or ch.get("data") or "—"
instancia = ch.get("instancia") or "—"
summary = ch.get("decisao") or ch.get("resumo") or ""
rows.append(
f"| {idx} | {_escape_table_cell(tipo)} | {_escape_table_cell(data)} | "
f"{_escape_table_cell(instancia)} | {_escape_table_cell(summary)} |"
)
return "\n".join(rows)
def render_contradictions(contradictions: dict | None) -> str:
"""Contradições agrupadas por impacto com citações verbatim."""
if not contradictions:
return ""
items = contradictions.get("contradictions") or []
if not items:
return "## 🔍 Contradições\n\nNenhuma contradição estrutural detectada."
out = [f"## 🔍 Contradições Detectadas ({len(items)})\n"]
# Group by impact
groups: dict[str, list[dict]] = {"ALTO": [], "MÉDIO": [], "BAIXO": []}
for c in items:
impact = (c.get("impacto") or "BAIXO").upper()
if impact not in groups:
impact = "BAIXO"
groups[impact].append(c)
impact_emoji = {"ALTO": "🔴", "MÉDIO": "🟡", "BAIXO": "🟢"}
for impact in ["ALTO", "MÉDIO", "BAIXO"]:
if not groups[impact]:
continue
out.append(f"\n### {impact_emoji[impact]} Impacto {impact.title()} ({len(groups[impact])})\n")
for c in groups[impact]:
tipo = c.get("tipo", "CONTRADIÇÃO")
desc = c.get("descricao") or c.get("descriçao") or ""
out.append(f"#### {_escape_md(tipo)}\n")
if desc:
out.append(f"{_escape_md(desc)}\n")
# Verbatim evidence from citation_spans or evidence[]
evidence = c.get("evidence") or c.get("citation_spans") or []
for i, ev in enumerate(evidence[:3]):
# chunk_ref=0 is falsy but valid — use explicit None check
chunk_ref = ev.get("chunk_ref")
if chunk_ref is None:
chunk_ref = ev.get("peca_ref")
if chunk_ref is None:
chunk_ref = "?"
quote = ev.get("quote") or ev.get("source_text") or ev.get("trecho") or ""
if quote:
label = f"**Fonte {chr(65 + i)} (peça #{chunk_ref}):**"
out.append(f"{label}")
out.append(_blockquote(quote[:500]))
out.append("")
resolucao = c.get("resolucao") or c.get("resolution")
if resolucao:
out.append(f"**Resolução:** {_escape_md(resolucao)}\n")
return "\n".join(out)
def render_risk_assessment(risk: dict | None) -> str:
"""Avaliação de risco com breakdown por dimensão."""
if not risk:
return ""
level = risk.get("risk_level", "—")
score = risk.get("overall_score")
emoji = {"ALTO": "🔴", "MÉDIO": "🟡", "BAIXO": "🟢"}.get(level, "⚪")
out = [f"## 📊 Avaliação de Risco\n"]
out.append(f"### Risco Global: {emoji} **{level}** ({score}/10)\n")
procedural = risk.get("procedural_risk") or {}
merit = risk.get("merit_indicators") or {}
monetary = risk.get("monetary_exposure") or {}
out.append("| Dimensão | Score | Fatores |")
out.append("|---|---|---|")
p_score = procedural.get("score", "—")
p_factors_raw = procedural.get("factors") or procedural.get("fatores") or []
p_factors = [_factor_to_text(f) for f in p_factors_raw[:5]]
p_factors = [t for t in p_factors if t]
p_factors_str = ", ".join(p_factors) if p_factors else "—"
out.append(
f"| Processual | {p_score}/10 | {_escape_table_cell(p_factors_str)} |"
)
m_score = merit.get("score", "—")
m_fav_raw = merit.get("favorable_factors") or merit.get("fatores_favoraveis") or []
m_unf_raw = merit.get("unfavorable_factors") or merit.get("fatores_desfavoraveis") or []
m_fav = [_factor_to_text(f) for f in m_fav_raw[:3]]
m_unf = [_factor_to_text(f) for f in m_unf_raw[:3]]
m_fav = [t for t in m_fav if t]
m_unf = [t for t in m_unf if t]
fav_str = "✅ " + ", ".join(m_fav) if m_fav else ""
unf_str = "❌ " + ", ".join(m_unf) if m_unf else ""
factors = " / ".join(x for x in [fav_str, unf_str] if x) or "—"
out.append(f"| Mérito | {m_score}/10 | {_escape_table_cell(factors)} |")
max_v = monetary.get("max_exposure") or monetary.get("max")
likely = monetary.get("likely_range") or {}
likely_min = likely.get("min")
likely_likely = likely.get("likely")
likely_max = likely.get("max")
mon_str = ""
if likely_min is not None and likely_max is not None:
try:
mon_str = f"R$ {float(likely_min):,.0f}–{float(likely_max):,.0f}"
if likely_likely is not None:
mon_str += f" (provável: R$ {float(likely_likely):,.0f})"
except (TypeError, ValueError):
mon_str = f"{likely_min}–{likely_max}"
out.append(f"| Monetário | — | {_escape_table_cell(mon_str)} |")
return "\n".join(out)
def render_recommendations(recommendations: dict | None) -> str:
"""Recomendações estratégicas por polo, com fundamentação e citação."""
if not recommendations:
return ""
items = recommendations.get("recommendations") or []
if not items:
return ""
out = ["## 🎯 Recomendações Estratégicas\n"]
# Group by polo
groups: dict[str, list[dict]] = {"autor": [], "reu": []}
for r in items:
polo = (r.get("polo") or "").lower()
if polo in groups:
groups[polo].append(r)
polo_labels = {
"autor": "### 👤 Polo Ativo",
"reu": "### 🛡️ Polo Passivo",
}
for polo, label in polo_labels.items():
if not groups[polo]:
continue
out.append(f"\n{label}\n")
# Sort by priority
priority_order = {"ALTA": 0, "MÉDIA": 1, "BAIXA": 2}
sorted_items = sorted(
groups[polo],
key=lambda r: priority_order.get((r.get("priority") or "BAIXA").upper(), 3),
)
for i, r in enumerate(sorted_items, 1):
action = r.get("action") or r.get("acao") or "(ação não especificada)"
priority = r.get("priority") or "—"
deadline = r.get("deadline_days")
deadline_str = f" (prazo: {deadline} dias úteis)" if deadline else ""
fundamentacao = r.get("fundamentacao") or r.get("fundamentation") or ""
evidence = r.get("evidence_quote") or ""
chunk_ref = r.get("evidence_chunk_ref")
deadline_basis = r.get("deadline_basis") or ""
impact = r.get("impact") or ""
out.append(f"**{i}. [{priority}] {_escape_md(action)}{deadline_str}**")
if deadline_basis:
out.append(f"*Fundamento processual:* {_escape_md(deadline_basis)}")
if fundamentacao:
out.append(f"\n{_escape_md(fundamentacao)}")
if evidence:
label_ref = f"*Trecho fonte (peça #{chunk_ref}):*" if chunk_ref is not None else "*Trecho fonte:*"
out.append(f"\n{label_ref}")
out.append(_blockquote(evidence[:400]))
if impact:
out.append(f"*Impacto esperado:* {_escape_md(impact)}")
out.append("")
return "\n".join(out)
def render_timeline(analyzed: dict) -> str:
"""Cronograma Mermaid gantt (só se >= 3 peças com datas).
Sorted chronologically by primary_date (v3.1.1 fix).
"""
chunks = analyzed.get("chunks") or []
dated = [
(c.get("primary_date"), c.get("tipo_peca") or c.get("label"))
for c in chunks
]
dated = [(d, t) for d, t in dated if d and t]
if len(dated) < 3:
return ""
iso_dated: list[tuple[str, str]] = []
for d, t in dated:
iso = _date_sort_key(d)
if iso != "9999-99-99":
iso_dated.append((iso, t))
if len(iso_dated) < 3:
return ""
iso_dated.sort(key=lambda x: x[0])
lines = [
"## 📅 Cronologia",
"",
"```mermaid",
"gantt",
" title Cronologia do Processo",
" dateFormat YYYY-MM-DD",
" axisFormat %d/%m/%y",
]
for i, (d, t) in enumerate(iso_dated):
safe_name = str(t).replace(":", " -").replace(",", " ")[:40]
lines.append(f" {safe_name} :p{i}, {d}, 1d")
lines.append("```")
return "\n".join(lines)
def render_prazos_table(prazos: dict | None) -> str:
"""Dashboard de prazos."""
if not prazos:
return ""
prazo_list = prazos if isinstance(prazos, list) else prazos.get("prazos") or prazos.get("prazos_calculados") or []
if not prazo_list:
return ""
out = ["## ⏰ Prazos\n"]
out.append("| Tipo | Intimação | Limite | Status | Dias restantes |")
out.append("|---|---|---|---|---|")
for p in prazo_list:
status = (p.get("status") or "").lower()
status_emoji = {"em_prazo": "🟢", "ultimo_dia": "🟡", "vencido": "🔴", "suspenso": "⏸️"}.get(status, "⚪")
dias = p.get("dias_restantes")
out.append(
f"| {_escape_table_cell(p.get('tipo'))} | "
f"{_escape_table_cell(p.get('data_intimacao'))} | "
f"{_escape_table_cell(p.get('data_limite'))} | "
f"{status_emoji} {status or '—'} | "
f"{dias if dias is not None else '—'} |"
)
return "\n".join(out)
def render_file_listing(output_dir: Path) -> str:
"""Lista de arquivos de saída."""
files = [
("analyzed.json", "Análise estruturada consolidada"),
("contradictions.json", "Contradições detectadas"),
("instances.json", "Rastreamento por instância"),
("prazos.json", "Prazos CPC calculados"),
("risk.json", "Avaliação de risco"),
("recommendations.json", "Recomendações estratégicas"),
("REPORT.md", "Este relatório executivo"),
("obsidian/", "Vault Obsidian navegável"),
]
lines = ["## 📂 Arquivos de Saída\n"]
for fname, desc in files:
p = output_dir / fname
if p.exists():
lines.append(f"- `{fname}` — {desc}")
return "\n".join(lines) if len(lines) > 1 else ""
def render_footer() -> str:
return (
"---\n\n"
"*Análise gerada por [JuriScan](https://github.com/brunobracaioli/juriscan) v3.1.0 "
"(pipeline legacy). Análise assistida por IA, requer revisão profissional. "
"Não substitui parecer jurídico nem produz peça vinculante.*"
)
# ---------- main ----------
def build_report(
analyzed: dict,
contradictions: dict | None,
instances: dict | None,
prazos: dict | None,
risk: dict | None,
recommendations: dict | None,
output_dir: Path,
) -> str:
"""Build the full markdown report."""
sections = [
render_header(analyzed, risk),
"",
render_executive_summary(analyzed, contradictions, risk),
"",
render_alerts(analyzed, prazos, contradictions),
"",
render_pieces_table(analyzed),
"",
render_contradictions(contradictions),
"",
render_risk_assessment(risk),
"",
render_recommendations(recommendations),
"",
render_timeline(analyzed),
"",
render_prazos_table(prazos),
"",
render_file_listing(output_dir),
"",
render_footer(),
]
# Filter empty sections
non_empty = [s for s in sections if s is not None and s != ""]
return "\n\n".join(non_empty) + "\n"
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(
description="Generate executive markdown report from pipeline outputs",
)
parser.add_argument("--analyzed", "-a", required=True, help="Path to analyzed.json")
parser.add_argument("--contradictions", help="Path to contradictions.json")
parser.add_argument("--instances", help="Path to instances.json")
parser.add_argument("--prazos", help="Path to prazos.json")
parser.add_argument("--risk", help="Path to risk.json")
parser.add_argument("--recommendations", help="Path to recommendations.json")
parser.add_argument("--output", "-o", required=True, help="Output path for REPORT.md")
args = parser.parse_args(argv)
analyzed_path = Path(args.analyzed)
if not analyzed_path.exists():
print(f"ERROR: analyzed.json not found: {analyzed_path}", file=sys.stderr)
return 2
analyzed = _load_json(analyzed_path)
if analyzed is None:
print(f"ERROR: could not load {analyzed_path}", file=sys.stderr)
return 2
contradictions = _load_json(Path(args.contradictions)) if args.contradictions else None
instances = _load_json(Path(args.instances)) if args.instances else None
prazos = _load_json(Path(args.prazos)) if args.prazos else None
risk = _load_json(Path(args.risk)) if args.risk else None
recommendations = _load_json(Path(args.recommendations)) if args.recommendations else None
output_path = Path(args.output)
output_path.parent.mkdir(parents=True, exist_ok=True)
report = build_report(
analyzed=analyzed,
contradictions=contradictions,
instances=instances,
prazos=prazos,
risk=risk,
recommendations=recommendations,
output_dir=output_path.parent,
)
output_path.write_text(report, encoding="utf-8")
print(f"[generate_report] REPORT.md written → {output_path}")
print(f" {len(report.splitlines())} lines · {len(report)} chars")
return 0
if __name__ == "__main__":
raise SystemExit(main())
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |