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/obsidian_export.py
View on GitHub#!/usr/bin/env python3
"""
obsidian_export.py — Gera vault Obsidian a partir da análise de processo jurídico.
Recebe o diretório de análise (com index.json + chunks analisados) e gera
uma estrutura de vault Obsidian com:
- _INDEX.md (resumo executivo)
- _TIMELINE.md (cronologia completa)
- _CONTRADIÇÕES.md (mapa de contradições)
- _ENTIDADES.md (partes, advogados, juízes)
- peças/ (uma nota por peça processual)
- legislação/ (uma nota por artigo citado)
- jurisprudência/ (uma nota por precedente)
- diagramas/ (Mermaid files)
Usage:
python3 obsidian_export.py --input ./analysis/ --analysis ./analysis/analyzed.json --output ./vault/
"""
import argparse
import json
import os
import re
import sys
from datetime import datetime
from pathlib import Path
def sanitize_filename(name: str) -> str:
"""Make a string safe for filenames."""
name = re.sub(r'[<>:"/\\|?*]', '', name)
name = re.sub(r'\s+', '-', name.strip())
return name.lower()[:80]
def generate_frontmatter(data: dict) -> str:
"""Generate YAML frontmatter block."""
lines = ['---']
for key, value in data.items():
if isinstance(value, list):
lines.append(f'{key}:')
for item in value:
lines.append(f' - "{item}"')
elif value is not None:
if isinstance(value, str) and (':' in value or '"' in value):
lines.append(f'{key}: "{value}"')
else:
lines.append(f'{key}: {value}')
lines.append('---')
return '\n'.join(lines)
def generate_index(analysis: dict, processo_number: str) -> str:
"""Generate _INDEX.md — executive summary of the case."""
fm = generate_frontmatter({
'tipo': 'índice-processo',
'processo': processo_number or 'N/A',
'gerado_em': datetime.now().strftime('%Y-%m-%d %H:%M'),
'total_pecas': len(analysis.get('chunks', [])),
'tags': ['processo', 'índice', 'mapa'],
})
chunks = analysis.get('chunks', [])
md = f"""{fm}
# 📋 Processo {processo_number or 'N/A'}
## Resumo Executivo
> [!summary] Visão Geral
> Processo com **{len(chunks)} peças** analisadas.
> Veja [[_TIMELINE|Timeline Completa]] | [[_CONTRADIÇÕES|Mapa de Contradições]] | [[_ENTIDADES|Entidades]]
## Mapa de Peças
| # | Peça | Data | Chars | Link |
|---|------|------|-------|------|
"""
for i, chunk in enumerate(chunks):
label = chunk.get('label', f'Peça {i}')
date = chunk.get('primary_date', '—')
chars = chunk.get('char_count', 0)
filename = f"{i:02d}-{sanitize_filename(label)}"
md += f"| {i:02d} | {label} | {date} | {chars:,} | [[peças/{filename}\\|Ver]] |\n"
md += """
## Links Rápidos
- [[_TIMELINE|📅 Timeline Cronológica]]
- [[_CONTRADIÇÕES|⚠️ Contradições Detectadas]]
- [[_ENTIDADES|👥 Partes e Entidades]]
## Análise Detalhada por Peça
"""
for i, chunk in enumerate(chunks):
label = chunk.get('label', f'Peça {i}')
filename = f"{i:02d}-{sanitize_filename(label)}"
resumo = chunk.get('resumo', 'Resumo não disponível.')
md += f"### {i:02d}. [[peças/{filename}|{label}]]\n\n{resumo}\n\n"
return md
def generate_timeline(analysis: dict, processo_number: str) -> str:
"""Generate _TIMELINE.md with chronological events."""
fm = generate_frontmatter({
'tipo': 'timeline',
'processo': processo_number or 'N/A',
'tags': ['processo', 'timeline', 'cronologia'],
})
events = []
for chunk in analysis.get('chunks', []):
if chunk.get('primary_date'):
events.append({
'date': chunk['primary_date'],
'label': chunk.get('label', 'N/A'),
'resumo': chunk.get('resumo', ''),
'decisao': chunk.get('decisao'),
})
for prazo in chunk.get('prazos', []):
if prazo.get('data_inicio') or prazo.get('data_fim'):
events.append({
'date': prazo.get('data_inicio') or prazo.get('data_fim'),
'label': f"⏰ PRAZO: {prazo.get('tipo', 'N/A')}",
'resumo': f"Prazo de {prazo.get('tipo', 'N/A')}",
})
# Sort by date (best effort)
def parse_date_sort(d):
try:
parts = d.split('/')
if len(parts) == 3:
return f"{parts[2]}{parts[1]}{parts[0]}"
except:
pass
return d
events.sort(key=lambda x: parse_date_sort(x.get('date', '')))
md = f"""{fm}
# 📅 Timeline — Processo {processo_number or 'N/A'}
⬅️ [[_INDEX|Voltar ao Índice]]
"""
for evt in events:
decisao = f"\n> **Decisão:** {evt['decisao']}" if evt.get('decisao') else ""
md += f"""### {evt['date']} — {evt['label']}
{evt.get('resumo', '')}{decisao}
---
"""
# Mermaid gantt
md += """## Diagrama Visual
```mermaid
gantt
title Timeline do Processo
dateFormat DD/MM/YYYY
"""
for evt in events:
safe_label = evt['label'].replace('"', "'")[:40]
md += f" {safe_label} : {evt['date']}, 1d\n"
md += "```\n"
return md
def generate_contradictions(analysis: dict, processo_number: str) -> str:
"""Generate _CONTRADIÇÕES.md."""
fm = generate_frontmatter({
'tipo': 'contradições',
'processo': processo_number or 'N/A',
'tags': ['processo', 'contradições', 'análise-forense'],
})
contradictions = analysis.get('contradictions', [])
md = f"""{fm}
# ⚠️ Contradições — Processo {processo_number or 'N/A'}
⬅️ [[_INDEX|Voltar ao Índice]]
> [!warning] Contradições Detectadas
> Total de **{len(contradictions)}** contradições/inconsistências identificadas.
"""
if not contradictions:
md += "> Nenhuma contradição registrada. Execute a análise de contradições para popular esta seção.\n"
return md
for i, c in enumerate(contradictions):
impact_icon = {'ALTO': '🔴', 'MÉDIO': '🟡', 'BAIXO': '🟢'}.get(c.get('impacto', ''), '⚪')
md += f"""## {i+1}. {c.get('tipo', 'N/A')} {impact_icon}
**Impacto:** {c.get('impacto', 'N/A')}
**Peças envolvidas:** {', '.join(c.get('pecas', []))}
### Divergência
{c.get('descricao', 'N/A')}
### Exploração Processual
{c.get('sugestao', 'N/A')}
---
"""
return md
def generate_entities(analysis: dict, processo_number: str) -> str:
"""Generate _ENTIDADES.md with all parties and entities."""
fm = generate_frontmatter({
'tipo': 'entidades',
'processo': processo_number or 'N/A',
'tags': ['processo', 'entidades', 'partes'],
})
# Aggregate entities from all chunks
all_autores = set()
all_reus = set()
all_advogados = set()
all_juizes = set()
all_peritos = set()
varas = set()
for chunk in analysis.get('chunks', []):
partes = chunk.get('partes', {})
for a in partes.get('autor', []):
all_autores.add(a)
for r in partes.get('reu', []):
all_reus.add(r)
for adv in partes.get('advogados_autor', []) + partes.get('advogados_reu', []):
all_advogados.add(adv)
if partes.get('juiz'):
all_juizes.add(partes['juiz'])
if partes.get('perito'):
all_peritos.add(partes['perito'])
if partes.get('vara'):
varas.add(partes['vara'])
md = f"""{fm}
# 👥 Entidades — Processo {processo_number or 'N/A'}
⬅️ [[_INDEX|Voltar ao Índice]]
## Polo Ativo (Autor/Requerente)
"""
for a in sorted(all_autores):
md += f"- **{a}**\n"
md += "\n## Polo Passivo (Réu/Requerido)\n\n"
for r in sorted(all_reus):
md += f"- **{r}**\n"
md += "\n## Advogados\n\n"
for adv in sorted(all_advogados):
md += f"- {adv}\n"
md += "\n## Magistrados\n\n"
for j in sorted(all_juizes):
md += f"- **{j}**\n"
if all_peritos:
md += "\n## Peritos\n\n"
for p in sorted(all_peritos):
md += f"- {p}\n"
if varas:
md += "\n## Varas / Câmaras\n\n"
for v in sorted(varas):
md += f"- {v}\n"
return md
def generate_piece_note(chunk: dict, index: int, processo_number: str) -> str:
"""Generate a note for a single legal piece."""
label = chunk.get('label', f'Peça {index}')
fm_data = {
'tipo': sanitize_filename(label),
'processo': processo_number or 'N/A',
'data': chunk.get('primary_date') or chunk.get('data'),
}
partes = chunk.get('partes', {})
if partes.get('autor'):
fm_data['partes_autor'] = partes['autor']
if partes.get('reu'):
fm_data['partes_reu'] = partes['reu']
if partes.get('juiz'):
fm_data['juiz'] = partes['juiz']
if partes.get('vara'):
fm_data['vara'] = partes['vara']
valores = chunk.get('valores', {})
if valores.get('causa'):
fm_data['valor_causa'] = valores['causa']
if valores.get('condenacao'):
fm_data['valor_condenacao'] = valores['condenacao']
fm_data['tags'] = ['processo', 'peça', sanitize_filename(label)]
fm = generate_frontmatter(fm_data)
md = f"""{fm}
# {label}
⬅️ [[../_INDEX|Voltar ao Índice]] | [[../_TIMELINE|Timeline]]
"""
if chunk.get('resumo'):
md += f"> [!abstract] Resumo\n> {chunk['resumo']}\n\n"
if chunk.get('assunto'):
md += f"**Assunto:** {chunk['assunto']}\n\n"
# Pedidos
if chunk.get('pedidos'):
md += "## Pedidos\n\n"
for p in chunk['pedidos']:
md += f"- {p}\n"
md += "\n"
# Argumentos
if chunk.get('argumentos_chave'):
md += "## Argumentos-Chave\n\n"
for a in chunk['argumentos_chave']:
md += f"- {a}\n"
md += "\n"
# Decisão
if chunk.get('decisao'):
md += f"## Decisão\n\n> [!verdict] Dispositivo\n> {chunk['decisao']}\n\n"
# Fatos relevantes
if chunk.get('fatos_relevantes'):
md += "## Fatos Relevantes\n\n"
for f in chunk['fatos_relevantes']:
md += f"- {f}\n"
md += "\n"
# Valores
if valores and any(valores.values()):
md += "## Valores\n\n"
if valores.get('causa'):
md += f"- **Valor da causa:** {valores['causa']}\n"
if valores.get('condenacao'):
md += f"- **Condenação:** {valores['condenacao']}\n"
if valores.get('honorarios'):
md += f"- **Honorários:** {valores['honorarios']}\n"
for outro in valores.get('outros', []):
md += f"- **{outro.get('descricao', 'Outro')}:** {outro.get('valor', 'N/A')}\n"
md += "\n"
# Legislação
if chunk.get('artigos_lei'):
md += "## Legislação Citada\n\n"
for art in chunk['artigos_lei']:
# Create wikilink
safe = sanitize_filename(art[:50])
md += f"- [[legislação/{safe}|{art}]]\n"
md += "\n"
# Jurisprudência
if chunk.get('jurisprudencia'):
md += "## Jurisprudência\n\n"
for j in chunk['jurisprudencia']:
safe = sanitize_filename(j[:50])
md += f"- [[jurisprudência/{safe}|{j}]]\n"
md += "\n"
# Prazos
if chunk.get('prazos'):
md += "## Prazos\n\n"
for p in chunk['prazos']:
md += f"- **{p.get('tipo', 'N/A')}**: {p.get('data_inicio', '?')} → {p.get('data_fim', '?')}\n"
md += "\n"
return md
def generate_legislation_note(article: str) -> str:
"""Generate a stub note for a cited law article."""
fm = generate_frontmatter({
'tipo': 'legislação',
'artigo': article,
'tags': ['legislação'],
})
return f"""{fm}
# {article}
> [!info] Artigo de Lei
> Referenciado no processo. Adicione aqui o texto integral e anotações.
## Texto do Artigo
_Insira o texto do artigo aqui._
## Notas
## Peças que Citam
_Links automáticos via backlinks do Obsidian._
"""
def generate_jurisprudence_note(reference: str) -> str:
"""Generate a stub note for cited jurisprudence."""
fm = generate_frontmatter({
'tipo': 'jurisprudência',
'referencia': reference,
'tags': ['jurisprudência'],
})
return f"""{fm}
# {reference}
> [!scales] Precedente Judicial
> Jurisprudência citada no processo.
## Ementa
_Insira a ementa aqui._
## Tese Firmada
_Insira a tese aqui._
## Peças que Citam
_Links automáticos via backlinks do Obsidian._
"""
def generate_risk_view(analysis: dict, processo_number: str) -> str:
"""Generate _RISCO.md — risk assessment dashboard."""
fm = generate_frontmatter({
'tipo': 'risco',
'processo': processo_number or 'N/A',
'tags': ['processo', 'risco', 'análise-forense'],
})
risk = analysis.get('risk_assessment', {})
level = risk.get('risk_level', 'N/A')
score = risk.get('overall_score', 'N/A')
icon = {'ALTO': '🔴', 'MÉDIO': '🟡', 'BAIXO': '🟢'}.get(level, '⚪')
md = f"""{fm}
# {icon} Avaliação de Risco — Processo {processo_number or 'N/A'}
⬅️ [[_INDEX|Voltar ao Índice]]
> [!warning] Risco: {level} ({score}/10)
## Risco Processual
"""
proc = risk.get('procedural_risk', {})
md += f"**Score:** {proc.get('score', 'N/A')}/10\n\n"
for f in proc.get('factors', []):
md += f"- {f.get('fator', '')} (impacto: {f.get('impacto', '')})\n"
md += "\n## Indicadores de Mérito\n\n"
merit = risk.get('merit_indicators', {})
md += f"**Score:** {merit.get('score', 'N/A')}/10\n\n"
if merit.get('favorable_factors'):
md += "### Fatores Favoráveis\n\n"
for f in merit['favorable_factors']:
md += f"- ✅ {f.get('fator', '')}\n"
if merit.get('unfavorable_factors'):
md += "\n### Fatores Desfavoráveis\n\n"
for f in merit['unfavorable_factors']:
md += f"- ❌ {f.get('fator', '')}\n"
md += "\n## Exposição Monetária\n\n"
monetary = risk.get('monetary_exposure', {})
if monetary.get('max_exposure'):
md += f"- **Exposição máxima:** {monetary['max_exposure']}\n"
likely = monetary.get('likely_range', {})
if likely.get('min') or likely.get('max'):
md += f"- **Faixa provável:** {likely.get('min', '?')} — {likely.get('max', '?')}\n"
costs = monetary.get('costs', {})
if costs.get('honorarios_sucumbencia'):
md += f"- **Honorários sucumbência:** {costs['honorarios_sucumbencia']}\n"
recs = risk.get('strategic_recommendations', [])
if recs:
md += "\n## Recomendações Estratégicas\n\n"
for r in recs:
md += f"1. {r}\n"
return md
def generate_instance_view(analysis: dict, processo_number: str) -> str:
"""Generate _INSTÂNCIAS.md — argument evolution across instances."""
fm = generate_frontmatter({
'tipo': 'instâncias',
'processo': processo_number or 'N/A',
'tags': ['processo', 'instâncias', 'argumentos'],
})
tracking = analysis.get('instance_tracking', {})
instances = tracking.get('instances', {})
tracks = tracking.get('argument_tracks', [])
md = f"""{fm}
# 🏛️ Rastreamento por Instância — Processo {processo_number or 'N/A'}
⬅️ [[_INDEX|Voltar ao Índice]]
## Fluxo entre Instâncias
"""
order = ['1a_instancia', 'tj', 'stj', 'stf']
labels = {'1a_instancia': '1ª Instância', 'tj': 'Tribunal de Justiça', 'stj': 'STJ', 'stf': 'STF'}
for inst in order:
data = instances.get(inst)
if not data:
continue
md += f"### {labels.get(inst, inst)}\n\n"
for p in data.get('pieces', []):
md += f"- **{p.get('label', '?')}** ({p.get('data', '?')})\n"
if data.get('decisao_final'):
md += f"\n> **Decisão:** {data['decisao_final'][:200]}\n"
if data.get('resultado'):
md += f"> **Resultado:** {data['resultado']}\n"
md += "\n---\n\n"
if tracks:
md += "## Evolução de Argumentos\n\n"
md += "| Argumento | Instâncias | Status |\n|---|---|---|\n"
for t in tracks[:20]:
insts = ', '.join(t.get('instancias_presentes', []))
status = t.get('status_final', '—')
arg = t.get('argumento', '?')[:80]
md += f"| {arg} | {insts} | {status} |\n"
return md
def generate_prazo_view(analysis: dict, processo_number: str) -> str:
"""Generate _PRAZOS.md — deadline dashboard."""
fm = generate_frontmatter({
'tipo': 'prazos',
'processo': processo_number or 'N/A',
'tags': ['processo', 'prazos', 'deadlines'],
})
prazos = analysis.get('prazos_calculados', [])
md = f"""{fm}
# ⏰ Prazos Processuais — Processo {processo_number or 'N/A'}
⬅️ [[_INDEX|Voltar ao Índice]]
"""
if not prazos:
md += "> Nenhum prazo calculado. Execute `prazo_calculator.py` para popular esta seção.\n"
return md
vencidos = [p for p in prazos if p.get('status') == 'vencido']
em_prazo = [p for p in prazos if p.get('status') == 'em_prazo']
ultimo = [p for p in prazos if p.get('status') == 'ultimo_dia']
md += f"> **Total:** {len(prazos)} prazo(s) | "
md += f"🟢 Em prazo: {len(em_prazo)} | "
md += f"🟡 Último dia: {len(ultimo)} | "
md += f"🔴 Vencidos: {len(vencidos)}\n\n"
md += "| Tipo | Fundamento | Intimação | Limite | Status | Restante |\n"
md += "|---|---|---|---|---|---|\n"
for p in prazos:
icon = {'em_prazo': '🟢', 'ultimo_dia': '🟡', 'vencido': '🔴'}.get(p.get('status', ''), '⚪')
rest = f"{p.get('dias_restantes', '—')} dias" if p.get('dias_restantes') is not None else '—'
md += (
f"| {p.get('tipo', '?')} | {p.get('fundamento_legal', '?')} | "
f"{p.get('data_intimacao', '?')} | {p.get('data_limite', '?')} | "
f"{icon} {p.get('status', '?')} | {rest} |\n"
)
return md
def generate_auditoria_view(analysis: dict, processo_number: str) -> str:
"""v3 — Render auditor_findings grouped by impact. Phase 6 Step 6.3."""
findings = analysis.get('auditor_findings') or []
if not findings:
return ""
impact_order = {'ALTO': 0, 'MÉDIO': 1, 'BAIXO': 2}
findings_sorted = sorted(findings, key=lambda f: impact_order.get(f.get('impacto', 'BAIXO'), 3))
lines = [
"---",
f"processo: \"{processo_number}\"",
"tipo: auditoria",
"---",
"",
"# Auditoria Processual",
"",
"Findings do `juriscan-auditor-processual` — análise imparcial de vícios,",
"nulidades, omissões e gatilhos processuais que nenhum dos advogados",
"tem incentivo de apontar.",
"",
f"**Total de findings:** {len(findings_sorted)}",
"",
]
for i, f in enumerate(findings_sorted, 1):
tipo = f.get('tipo', 'OUTRO')
impacto = f.get('impacto', '?')
fundamento = f.get('fundamento', '')
peca_ref = f.get('peca_ref', '')
lines += [
f"## {i}. {tipo} — impacto {impacto}",
"",
f"**Fundamento:** {fundamento}",
]
if peca_ref:
lines.append(f"**Peça:** {peca_ref}")
lines += [
"",
f"**Descrição:** {f.get('descricao', '')}",
"",
f"**Ação sugerida:** {f.get('acao_sugerida', '')}",
"",
"---",
"",
]
lines += ["", "⬅️ [[_INDEX|Voltar ao Índice]]", ""]
return "\n".join(lines)
def generate_verificacoes_view(analysis: dict, processo_number: str) -> str:
"""v3 — Render verifications as a status table. Phase 6 Step 6.3."""
verifications = analysis.get('verifications') or []
if not verifications:
return ""
summary = analysis.get('verification_summary') or {}
status_emoji = {
'CONFIRMADO': '✅',
'DIVERGENTE': '⚠️',
'NAO_ENCONTRADO': '❌',
}
lines = [
"---",
f"processo: \"{processo_number}\"",
"tipo: verificações",
"---",
"",
"# Verificações de Jurisprudência",
"",
"Citações verificadas pelo `juriscan-verificador` contra fontes oficiais",
"(whitelist em `references/whitelist_fontes.json`).",
"",
]
if summary:
lines += [
f"**Total:** {summary.get('total_verifications', len(verifications))} | "
f"✅ {summary.get('confirmed', 0)} | "
f"⚠️ {summary.get('divergent', 0)} | "
f"❌ {summary.get('unverified', 0)}",
"",
]
lines += [
"| Status | Tipo | Citação | Fonte | Data de acesso |",
"|---|---|---|---|---|",
]
for v in verifications:
status = v.get('status', '?')
emoji = status_emoji.get(status, '?')
tipo = v.get('tipo', '')
citacao = (v.get('citacao_original') or '').replace('|', '\\|')
url = v.get('source_url') or ''
fonte_link = f"[link]({url})" if url else '—'
data = v.get('access_date') or ''
lines.append(f"| {emoji} {status} | {tipo} | {citacao} | {fonte_link} | {data} |")
# Detailed divergences
divergents = [v for v in verifications if v.get('status') == 'DIVERGENTE']
if divergents:
lines += ["", "## Divergências", ""]
for v in divergents:
lines += [
f"### {v.get('citacao_original', '')}",
"",
f"**Divergência:** {v.get('divergencia') or '(não explicitada)'}",
"",
f"**Trecho oficial:** > {v.get('trecho_oficial') or '—'}",
"",
]
lines += ["", "⬅️ [[_INDEX|Voltar ao Índice]]", ""]
return "\n".join(lines)
def generate_perspectives_view(analysis: dict, processo_number: str) -> str:
"""v3 — Two-column perspectives (autor vs. réu). Phase 6 Step 6.3."""
perspectives = analysis.get('perspectives') or {}
autor = perspectives.get('autor')
reu = perspectives.get('reu')
if not (autor or reu):
return ""
def _section(label: str, persp: dict | None) -> list[str]:
if not persp:
return [f"## {label}", "", "_sem dados_", ""]
out = [
f"## {label}",
"",
f"**Risco:** {persp.get('risk_level', '?')} (score {persp.get('risk_score', '?')}/10)",
"",
"### Forças",
]
for f in (persp.get('forcas') or []):
out.append(f"- **{f.get('titulo', '')}** — {f.get('descricao', '')}")
out += ["", "### Fraquezas"]
for f in (persp.get('fraquezas') or []):
out.append(f"- **{f.get('titulo', '')}** — {f.get('descricao', '')}")
out += ["", "### Recursos cabíveis"]
for r in (persp.get('recursos_cabiveis') or []):
out.append(
f"- **{r.get('recurso', '')}** — {r.get('cabimento', '')} "
f"(prazo {r.get('prazo_dias', '?')}d)"
)
out.append("")
return out
lines = [
"---",
f"processo: \"{processo_number}\"",
"tipo: perspectivas",
"---",
"",
"# Perspectivas (Polos Ativo × Passivo)",
"",
"Análise dialética do `juriscan-advogado-autor` e `juriscan-advogado-reu`.",
"Os dois scores medem coisas diferentes — risco é sempre relativo ao polo.",
"",
]
lines += _section("⚖️ Autor (polo ativo)", autor)
lines += _section("🛡️ Réu (polo passivo)", reu)
lines += ["", "⬅️ [[_INDEX|Voltar ao Índice]]", ""]
return "\n".join(lines)
def export_vault(analysis: dict, output_dir: str):
"""Export full Obsidian vault structure."""
processo_number = analysis.get('processo_number', 'N/A')
# Create directories
dirs = ['peças', 'legislação', 'jurisprudência', 'diagramas']
for d in dirs:
os.makedirs(os.path.join(output_dir, d), exist_ok=True)
# Generate main files
files = {
'_INDEX.md': generate_index(analysis, processo_number),
'_TIMELINE.md': generate_timeline(analysis, processo_number),
'_CONTRADIÇÕES.md': generate_contradictions(analysis, processo_number),
'_ENTIDADES.md': generate_entities(analysis, processo_number),
'_RISCO.md': generate_risk_view(analysis, processo_number),
'_INSTÂNCIAS.md': generate_instance_view(analysis, processo_number),
'_PRAZOS.md': generate_prazo_view(analysis, processo_number),
}
# Phase 6 Step 6.3 — v3 views, only generated when the corresponding fields
# are present. Backwards compat: legacy v2 outputs produce the same file set
# as before.
auditoria = generate_auditoria_view(analysis, processo_number)
if auditoria:
files['_AUDITORIA.md'] = auditoria
verificacoes = generate_verificacoes_view(analysis, processo_number)
if verificacoes:
files['_VERIFICAÇÕES.md'] = verificacoes
perspectivas = generate_perspectives_view(analysis, processo_number)
if perspectivas:
files['_PERSPECTIVAS.md'] = perspectivas
for filename, content in files.items():
with open(os.path.join(output_dir, filename), 'w', encoding='utf-8') as f:
f.write(content)
# Generate piece notes
all_articles = set()
all_jurisprudence = set()
for i, chunk in enumerate(analysis.get('chunks', [])):
label = chunk.get('label', f'peça-{i}')
filename = f"{i:02d}-{sanitize_filename(label)}.md"
content = generate_piece_note(chunk, i, processo_number)
with open(os.path.join(output_dir, 'peças', filename), 'w', encoding='utf-8') as f:
f.write(content)
for art in chunk.get('artigos_lei', []):
all_articles.add(art)
for jur in chunk.get('jurisprudencia', []):
all_jurisprudence.add(jur)
# Generate legislation stubs
for art in all_articles:
filename = f"{sanitize_filename(art[:50])}.md"
content = generate_legislation_note(art)
with open(os.path.join(output_dir, 'legislação', filename), 'w', encoding='utf-8') as f:
f.write(content)
# Generate jurisprudence stubs
for jur in all_jurisprudence:
filename = f"{sanitize_filename(jur[:50])}.md"
content = generate_jurisprudence_note(jur)
with open(os.path.join(output_dir, 'jurisprudência', filename), 'w', encoding='utf-8') as f:
f.write(content)
# Generate reference graph mermaid
mermaid = "graph LR\n"
for i, chunk in enumerate(analysis.get('chunks', [])):
label = chunk.get('label', f'P{i}')
node_id = f"P{i}"
mermaid += f' {node_id}["{label}"]\n'
for art in chunk.get('artigos_lei', [])[:8]: # Top 8 per piece
art_id = f"L_{sanitize_filename(art[:20]).replace('-', '_')}"
mermaid += f' {node_id} --> {art_id}["{art[:30]}"]\n'
with open(os.path.join(output_dir, 'diagramas', 'reference-graph.mermaid'), 'w', encoding='utf-8') as f:
f.write(mermaid)
return {
'output_dir': output_dir,
'files_created': sum(len(files) for _, _, files in os.walk(output_dir)),
'pieces': len(analysis.get('chunks', [])),
'legislation_stubs': len(all_articles),
'jurisprudence_stubs': len(all_jurisprudence),
}
def main():
parser = argparse.ArgumentParser(description='Export legal analysis to Obsidian vault')
parser.add_argument('--analysis', '-a', required=True, help='Path to analyzed.json')
parser.add_argument('--output', '-o', required=True, help='Output vault directory')
args = parser.parse_args()
with open(args.analysis, 'r', encoding='utf-8') as f:
analysis = json.load(f)
result = export_vault(analysis, args.output)
print(f"\n✅ Obsidian vault exported!")
print(f" Output: {result['output_dir']}")
print(f" Pieces: {result['pieces']}")
print(f" Legislation stubs: {result['legislation_stubs']}")
print(f" Jurisprudence stubs: {result['jurisprudence_stubs']}")
print(f"\n Abra a pasta no Obsidian como vault e aproveite os backlinks automáticos!")
if __name__ == '__main__':
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 |