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/utils/dates.py
View on GitHub"""
dates.py — Robust Brazilian date parsing and chronology validation.
Handles DD/MM/YYYY, written Portuguese dates, ISO 8601, and piece-type-aware
primary date extraction.
"""
from __future__ import annotations
import re
from datetime import date, datetime
MONTH_NAMES = {
'janeiro': 1, 'fevereiro': 2, 'março': 3, 'marco': 3, 'abril': 4,
'maio': 5, 'junho': 6, 'julho': 7, 'agosto': 8,
'setembro': 9, 'outubro': 10, 'novembro': 11, 'dezembro': 12,
'jan': 1, 'fev': 2, 'mar': 3, 'abr': 4, 'mai': 5, 'jun': 6,
'jul': 7, 'ago': 8, 'set': 9, 'out': 10, 'nov': 11, 'dez': 12,
}
# Regex patterns ordered by specificity
_WRITTEN_DATE = re.compile(
r'(\d{1,2})\s+de\s+(janeiro|fevereiro|março|marco|abril|maio|junho|'
r'julho|agosto|setembro|outubro|novembro|dezembro)\s+de\s+(\d{4})',
re.IGNORECASE,
)
_NUMERIC_DMY = re.compile(r'(\d{2})[/.-](\d{2})[/.-](\d{4})')
_ISO_DATE = re.compile(r'(\d{4})-(\d{2})-(\d{2})')
# Piece-type-specific date markers (searched in order of priority)
_PRIMARY_DATE_MARKERS: dict[str, list[str]] = {
'SENTENÇA': [
r'(?i)Publique-se[.\s]*(\d{1,2}[/.-]\d{2}[/.-]\d{4})',
r'(?i)(?:São\s+Paulo|.{3,40}),?\s+(\d{1,2})\s+de\s+(\w+)\s+de\s+(\d{4})',
],
'ACÓRDÃO': [
r'(?i)(?:Sessão|Julgamento)\s+(?:de|em|realizada?\s+em)\s+(\d{1,2}[/.-]\d{2}[/.-]\d{4})',
r'(?i)(?:Sessão|Julgamento)\s+(?:de|em)\s+(\d{1,2})\s+de\s+(\w+)\s+de\s+(\d{4})',
],
'PETIÇÃO INICIAL': [
r'(?i)Protocolo[:\s]+.*?(\d{2}[/.-]\d{2}[/.-]\d{4})',
],
}
def parse_brazilian_date(text: str) -> date | None:
"""Parse a single date string in any common Brazilian format.
Supports:
- DD/MM/YYYY, DD.MM.YYYY, DD-MM-YYYY
- 'D de Month de YYYY'
- YYYY-MM-DD (ISO 8601)
Returns None if parsing fails or date is invalid.
"""
text = text.strip()
# Written Portuguese date
m = _WRITTEN_DATE.search(text)
if m:
day, month_name, year = m.groups()
month = MONTH_NAMES.get(month_name.lower())
if month:
try:
return date(int(year), month, int(day))
except ValueError:
pass
# Numeric DD/MM/YYYY
m = _NUMERIC_DMY.search(text)
if m:
day, month, year = m.groups()
try:
d = date(int(year), int(month), int(day))
if 1900 <= d.year <= 2100:
return d
except ValueError:
pass
# ISO 8601
m = _ISO_DATE.search(text)
if m:
year, month, day = m.groups()
try:
d = date(int(year), int(month), int(day))
if 1900 <= d.year <= 2100:
return d
except ValueError:
pass
return None
def extract_all_dates(text: str) -> list[dict]:
"""Extract ALL dates from the entire text.
Returns list of:
{raw: str, parsed: date, char_position: int, context: str}
Context includes 40 chars before and after for grounding.
"""
results = []
seen_positions: set[int] = set()
# Written dates
for m in _WRITTEN_DATE.finditer(text):
day, month_name, year = m.groups()
month = MONTH_NAMES.get(month_name.lower())
if not month:
continue
try:
d = date(int(year), month, int(day))
except ValueError:
continue
if 1900 <= d.year <= 2100 and m.start() not in seen_positions:
seen_positions.add(m.start())
ctx_start = max(0, m.start() - 40)
ctx_end = min(len(text), m.end() + 40)
results.append({
'raw': m.group(),
'parsed': d,
'char_position': m.start(),
'context': text[ctx_start:ctx_end].replace('\n', ' ').strip(),
})
# Numeric DD/MM/YYYY
for m in _NUMERIC_DMY.finditer(text):
if m.start() in seen_positions:
continue
day, month, year = m.groups()
try:
d = date(int(year), int(month), int(day))
except ValueError:
continue
if 1900 <= d.year <= 2100:
seen_positions.add(m.start())
ctx_start = max(0, m.start() - 40)
ctx_end = min(len(text), m.end() + 40)
results.append({
'raw': m.group(),
'parsed': d,
'char_position': m.start(),
'context': text[ctx_start:ctx_end].replace('\n', ' ').strip(),
})
results.sort(key=lambda x: x['char_position'])
return results
def find_primary_date(text: str, piece_type: str) -> dict | None:
"""Extract the most relevant date for a given piece type.
Uses piece-type-specific markers first, then falls back to the first date
found in the text.
"""
# Try type-specific markers
markers = _PRIMARY_DATE_MARKERS.get(piece_type, [])
for pattern in markers:
m = re.search(pattern, text[:5000])
if m:
groups = m.groups()
# Single-group patterns capture a numeric date
if len(groups) == 1:
d = parse_brazilian_date(groups[0])
if d:
return {'parsed': d, 'raw': groups[0], 'source': 'marker'}
# Three-group patterns capture day/month_name/year
elif len(groups) == 3:
raw = f"{groups[0]} de {groups[1]} de {groups[2]}"
d = parse_brazilian_date(raw)
if d:
return {'parsed': d, 'raw': raw, 'source': 'marker'}
# Fallback: first date in the text
all_dates = extract_all_dates(text[:5000])
if all_dates:
first = all_dates[0]
return {'parsed': first['parsed'], 'raw': first['raw'], 'source': 'first_in_text'}
return None
def validate_chronology(chunks: list[dict]) -> list[dict]:
"""Check that piece dates follow logical procedural order.
Returns list of anomalies found.
"""
# Expected order: pieces that should come before others
ORDER_RULES = [
('PETIÇÃO INICIAL', 'CONTESTAÇÃO', 'Contestação datada antes da Petição Inicial'),
('CONTESTAÇÃO', 'RÉPLICA', 'Réplica datada antes da Contestação'),
('RÉPLICA', 'SENTENÇA', 'Sentença datada antes da Réplica'),
('SENTENÇA', 'APELAÇÃO', 'Apelação datada antes da Sentença'),
('APELAÇÃO', 'CONTRARRAZÕES', 'Contrarrazões datadas antes da Apelação'),
('APELAÇÃO', 'ACÓRDÃO', 'Acórdão datado antes da Apelação'),
('SENTENÇA', 'EMBARGOS', 'Embargos datados antes da Sentença'),
('SENTENÇA', 'CUMPRIMENTO DE SENTENÇA', 'Cumprimento datado antes da Sentença'),
]
# Build date map from chunks
chunk_dates: dict[str, date] = {}
for c in chunks:
label = c.get('label', '')
primary = c.get('primary_date')
if primary:
if isinstance(primary, str):
d = parse_brazilian_date(primary)
elif isinstance(primary, date):
d = primary
else:
continue
if d:
chunk_dates[label] = d
anomalies = []
for before_label, after_label, description in ORDER_RULES:
d_before = chunk_dates.get(before_label)
d_after = chunk_dates.get(after_label)
if d_before and d_after and d_after < d_before:
anomalies.append({
'tipo': 'DATA_CONFLITANTE',
'pecas': [before_label, after_label],
'descricao': description,
'data_antes': d_before.isoformat(),
'data_depois': d_after.isoformat(),
})
return anomalies
def format_date_br(d: date) -> str:
"""Format date as DD/MM/YYYY for display."""
return d.strftime('%d/%m/%Y')
def format_date_iso(d: date) -> str:
"""Format date as ISO 8601."""
return d.isoformat()
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 |