Skip to content

ThomasMoreAI/legal-skills-open / br/litigation/skills/juriscan-brunobracaioli

juriscan-brunobracaioli

Verified

Aná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.

FileKindSize
.claude/agents/juriscan-advogado-autor.mdmarkdown4.3 KB
.claude/agents/juriscan-advogado-reu.mdmarkdown3.6 KB
.claude/agents/juriscan-auditor-processual.mdmarkdown7.0 KB
.claude/agents/juriscan-echo.mdmarkdown2.0 KB
.claude/agents/juriscan-parser.mdmarkdown4.7 KB
.claude/agents/juriscan-segmenter.mdmarkdown4.9 KB
.claude/agents/juriscan-sintetizador.mdmarkdown3.1 KB
.claude/agents/juriscan-verificador.mdmarkdown4.8 KB
.github/FUNDING.ymlconfig77 B
.github/workflows/ci.ymlconfig1.0 KB
.gitignoreother121 B
CHANGELOG.mdmarkdown20.6 KB
CLAUDE.mdmarkdown10.6 KB
LICENSEother1.0 KB
README.mdmarkdown16.9 KB
SKILL.mdskill md26.3 KB
assets/banner.svgother4.7 KB
docs/architecture.mdmarkdown10.3 KB
docs/index.htmlother4.3 KB
docs/operations.mdmarkdown6.7 KB
docs/subagent_contract.mdmarkdown6.0 KB
docs/subagents.mdmarkdown5.5 KB
install.shscript3.2 KB
pyproject.tomlmanifest272 B
references/agent_schemas/advogado_output.jsonconfig2.7 KB
references/agent_schemas/auditor_output.jsonconfig4.8 KB
references/agent_schemas/echo_output.jsonconfig666 B
references/agent_schemas/parser_output.jsonconfig4.4 KB
references/agent_schemas/recommendations_output.jsonconfig2.5 KB
references/agent_schemas/segmenter_output.jsonconfig2.9 KB
references/agent_schemas/sintetizador_output.jsonconfig2.7 KB
references/agent_schemas/verificador_output.jsonconfig2.3 KB
references/appellate_structure.mdmarkdown2.0 KB
references/binding_precedents.mdmarkdown2.2 KB
references/brazilian_legal_entities.mdmarkdown3.2 KB
references/chunk_analysis_schema.jsonconfig6.7 KB
references/cpc_prazos.jsonconfig4.4 KB
references/feriados_forenses.jsonconfig2.1 KB
references/output_schema.jsonconfig11.0 KB
references/output_schema_v2.jsonconfig11.0 KB
references/output_schema_v3.jsonconfig5.3 KB
references/piece_type_taxonomy.jsonconfig7.5 KB
references/prompt_templates.mdmarkdown11.8 KB
references/risk_scoring_rubric.mdmarkdown2.4 KB
references/whitelist_fontes.jsonconfig1.8 KB
requirements.txtmanifest250 B
scripts/__init__.pyscript0 B
scripts/agent_io.pyscript12.2 KB
scripts/analyzed_init.pyscript3.3 KB
scripts/audit.pyscript4.8 KB
scripts/cleanup_audit.pyscript2.0 KB
scripts/confidence_rules.pyscript6.4 KB
scripts/content_quality_check.pyscript11.1 KB
scripts/enrich_deterministic.pyscript10.3 KB
scripts/extract_and_chunk.pyscript14.3 KB
scripts/finalize.pyscript10.2 KB
scripts/finalize_legacy.pyscript7.4 KB
scripts/generate_report.pyscript29.8 KB
scripts/instance_tracker.pyscript6.7 KB
scripts/integrity_check.pyscript11.0 KB
scripts/integrity_gate.pyscript4.6 KB
scripts/legacy/__init__.pyscript0 B
scripts/legacy/contradiction_report.pyscript11.9 KB
scripts/legacy/risk_scorer.pyscript10.2 KB
scripts/merge_chunk_analysis.pyscript14.8 KB
scripts/migrate_v2_to_v3.pyscript3.1 KB
scripts/obsidian_export.pyscript28.0 KB
scripts/persist_chunks.pyscript6.2 KB
scripts/prazo_calculator.pyscript14.2 KB
scripts/report_metrics.pyscript8.4 KB
scripts/schema_validator.pyscript5.2 KB
scripts/utils/__init__.pyscript0 B
scripts/utils/cnj.pyscript4.4 KB
scripts/utils/dates.pyscript7.8 KB
scripts/utils/filenames.pyscript2.6 KB
scripts/utils/monetary.pyscript5.2 KB
tests/__init__.pyscript0 B
tests/conftest.pyscript1.1 KB
tests/fixtures/agent_io/echo_invalid_missing_field.jsonconfig45 B
tests/fixtures/agent_io/echo_invalid_wrong_const.jsonconfig70 B
tests/fixtures/agent_io/echo_valid.jsonconfig103 B
tests/fixtures/agent_io/segmenter_valid.jsonconfig359 B
tests/fixtures/sample_analyzed.jsonconfig10.0 KB
tests/fixtures/sample_analyzed_with_prazos.jsonconfig470 B
tests/fixtures/sample_chunk_acordao.txtmarkdown3.4 KB
tests/fixtures/sample_chunk_peticao.txtmarkdown3.4 KB
tests/fixtures/sample_chunk_sentenca.txtmarkdown2.9 KB
tests/fixtures/sample_index.jsonconfig1.6 KB
tests/golden/_pdf_builder.pyscript6.1 KB
tests/golden/processo_01_sintetico_simples/expected_invariants.jsonconfig993 B
tests/golden/processo_01_sintetico_simples/source.txtmarkdown3.3 KB
tests/golden/processo_02_sintetico_art942/expected_art_942.jsonconfig898 B
tests/golden/processo_02_sintetico_art942/expected_invariants.jsonconfig1.3 KB
tests/golden/processo_02_sintetico_art942/source.txtmarkdown7.8 KB
tests/test_agent_io.pyscript4.4 KB
tests/test_analyzed_init.pyscript5.6 KB
tests/test_audit.pyscript4.4 KB
tests/test_cnj.pyscript2.9 KB
tests/test_confidence_rules.pyscript4.8 KB
tests/test_content_quality_check.pyscript14.5 KB
tests/test_contradiction_report.pyscript3.5 KB
tests/test_dates.pyscript5.0 KB
tests/test_enrich_deterministic.pyscript6.3 KB
tests/test_filenames.pyscript2.1 KB
tests/test_finalize.pyscript5.8 KB
tests/test_finalize_legacy.pyscript6.5 KB
tests/test_generate_report.pyscript24.0 KB
tests/test_golden_regression.pyscript6.3 KB
tests/test_instance_tracker.pyscript4.2 KB
tests/test_integrity_check.pyscript4.8 KB
tests/test_integrity_gate.pyscript3.6 KB
tests/test_merge_chunk_analysis.pyscript20.9 KB
tests/test_migrate_v2_to_v3.pyscript4.3 KB
tests/test_monetary.pyscript3.4 KB
tests/test_obsidian_export_v3.pyscript6.9 KB
tests/test_persist_chunks.pyscript6.1 KB
tests/test_prazo_calculator.pyscript14.1 KB
tests/test_report_metrics.pyscript5.3 KB
tests/test_risk_scorer.pyscript5.7 KB
tests/test_whitelist_enforcement.pyscript6.1 KB

scripts/prazo_calculator.py

View on GitHub
#!/usr/bin/env python3
"""
prazo_calculator.py — CPC-compliant procedural deadline calculator.

Implements CPC Art. 219-232 rules:
- Business day counting (Art. 219)
- Start/end rules (Art. 224)
- Court holidays (forense) + state holidays
- Recesso forense (Art. 220): Dec 20 - Jan 20
- Suspension ranges

Usage:
    python3 prazo_calculator.py --analysis analyzed.json --output prazos.json
    python3 prazo_calculator.py --date 2025-03-15 --tipo contestação --state SP
"""

from __future__ import annotations

import argparse
import json
import os
import sys
import unicodedata
from datetime import date, timedelta
from typing import Literal


def _strip_accents(s: str) -> str:
    """Remove diacritics from a string while preserving the base characters."""
    return ''.join(
        c for c in unicodedata.normalize('NFD', s)
        if unicodedata.combining(c) == 0
    )

REFERENCES_DIR = os.path.join(os.path.dirname(__file__), '..', 'references')


def _easter(year: int) -> date:
    """Calculate Easter Sunday using Butcher/Meeus algorithm."""
    a = year % 19
    b = year // 100
    c = year % 100
    d = b // 4
    e = b % 4
    f = (b + 8) // 25
    g = (b - f + 1) // 3
    h = (19 * a + b - d - g + 15) % 30
    i = c // 4
    k = c % 4
    l = (32 + 2 * e + 2 * i - h - k) % 7
    m = (a + 11 * h + 22 * l) // 451
    month = (h + l - 7 * m + 114) // 31
    day = ((h + l - 7 * m + 114) % 31) + 1
    return date(year, month, day)


def load_feriados(state: str | None = None, year: int | None = None) -> set[date]:
    """Load court holidays for a given year (defaults to current year).

    Includes: national fixed + mobile (Easter-based) + optional state holidays.
    """
    if year is None:
        year = date.today().year

    feriados_path = os.path.join(REFERENCES_DIR, 'feriados_forenses.json')
    with open(feriados_path, 'r', encoding='utf-8') as f:
        data = json.load(f)

    holidays: set[date] = set()

    # National fixed holidays
    for h in data.get('nacionais_fixos', []):
        try:
            holidays.add(date(year, h['mes'], h['dia']))
        except ValueError:
            continue

    # Mobile holidays (Easter-based)
    easter = _easter(year)
    offsets = data.get('moveis', {}).get('offsets_from_easter', {})
    for name, offset in offsets.items():
        holidays.add(easter + timedelta(days=offset))

    # State holidays
    if state:
        state_holidays = data.get('estaduais', {}).get(state.upper(), [])
        for h in state_holidays:
            try:
                holidays.add(date(year, h['mes'], h['dia']))
            except ValueError:
                continue

    return holidays


def is_recesso(d: date) -> bool:
    """Check if a date falls within the recesso forense (CPC Art. 220).

    Recesso: Dec 20 to Jan 20 (inclusive).
    """
    if d.month == 12 and d.day >= 20:
        return True
    if d.month == 1 and d.day <= 20:
        return True
    return False


def is_business_day(d: date, feriados: set[date]) -> bool:
    """Check if a date is a business day (dia útil forense)."""
    if d.weekday() >= 5:  # Saturday or Sunday
        return False
    if d in feriados:
        return False
    if is_recesso(d):
        return False
    return True


def next_business_day(d: date, feriados: set[date]) -> date:
    """Find the next business day on or after the given date.

    CPC Art. 224 §1: if deadline falls on non-business day, extends to next business day.
    """
    while not is_business_day(d, feriados):
        d += timedelta(days=1)
    return d


def calculate_prazo(
    start_date: date,
    days: int,
    unit: Literal['úteis', 'corridos'] = 'úteis',
    feriados: set[date] | None = None,
    suspended_ranges: list[tuple[date, date]] | None = None,
) -> date:
    """Calculate procedural deadline per CPC rules.

    CPC Art. 224: Exclude start day, include end day.
    CPC Art. 219: Count only business days (for 'úteis').
    CPC Art. 224 §1: If deadline falls on non-business day, extend to next business day.

    Args:
        start_date: Date of intimation/publication (dia do começo — excluded).
        days: Number of days for the deadline.
        unit: 'úteis' (business days) or 'corridos' (calendar days).
        feriados: Set of holiday dates.
        suspended_ranges: List of (start, end) suspension periods.
    """
    if feriados is None:
        feriados = set()

    def is_suspended(d: date) -> bool:
        if suspended_ranges:
            return any(start <= d <= end for start, end in suspended_ranges)
        return False

    current = start_date
    counted = 0

    if unit == 'úteis':
        while counted < days:
            current += timedelta(days=1)
            if is_suspended(current):
                continue
            if is_business_day(current, feriados):
                counted += 1
    else:  # corridos
        while counted < days:
            current += timedelta(days=1)
            if is_suspended(current):
                continue
            counted += 1
        # Even for corridos, deadline must end on business day
        current = next_business_day(current, feriados)

    return current


def get_standard_prazo(tipo: str) -> dict | None:
    """Look up the standard CPC deadline for a procedural act."""
    prazos_path = os.path.join(REFERENCES_DIR, 'cpc_prazos.json')
    with open(prazos_path, 'r', encoding='utf-8') as f:
        data = json.load(f)

    tipo_normalized = _strip_accents(tipo.lower().strip().replace(' ', '_'))

    for prazo in data.get('prazos_legais', []):
        if _strip_accents(prazo['ato']) == tipo_normalized:
            return prazo

    # Fuzzy match
    for prazo in data.get('prazos_legais', []):
        ato_normalized = _strip_accents(prazo['ato'])
        if tipo_normalized in ato_normalized or ato_normalized in tipo_normalized:
            return prazo

    return None


VALID_PROCESS_STATES = {
    "ativo",
    "transito_em_julgado",
    "suspenso",
    "arquivado",
    "desconhecido",
}

# Phase 5 Step 5.2 — state-aware behaviour
# When the process has already transited in rem judicatam, recursal deadlines
# are meaningless; only the voluntary compliance deadline (CPC art. 523) is
# relevant. When the process is suspended, all deadlines are frozen. When it
# is archived, nothing is computed.

_CUMPRIMENTO_VOLUNTARIO = {
    "dias": 15,
    "unidade": "dias úteis",
    "fundamento": "CPC art. 523 — cumprimento voluntário da sentença",
    "tipo": "cumprimento voluntário",
}


def check_prazo_status(
    intimation_date: date,
    prazo_type: str,
    current_date: date | None = None,
    state: str | None = None,
    process_state: str | None = None,
) -> dict | None:
    """Check the status of a procedural deadline.

    Returns dict with deadline, days_remaining, and status.

    Phase 5 Step 5.2: when ``process_state`` is provided, recursal deadlines
    are computed only when the process is 'ativo' or 'desconhecido'. For
    'transito_em_julgado', only the voluntary compliance deadline (CPC
    art. 523) is computed regardless of ``prazo_type``. For 'suspenso' all
    deadlines are marked suspended. For 'arquivado' nothing is returned.
    """
    if current_date is None:
        current_date = date.today()

    # --- Phase 5.2 gate ---
    if process_state is not None:
        if process_state not in VALID_PROCESS_STATES:
            raise ValueError(
                f"invalid process_state: {process_state!r} "
                f"(expected one of {sorted(VALID_PROCESS_STATES)})"
            )
        if process_state == "arquivado":
            return None
        if process_state == "suspenso":
            return {
                "tipo": prazo_type,
                "status": "suspenso",
                "data_intimacao": intimation_date.isoformat(),
                "fundamento_legal": "processo suspenso — prazos paralisados",
                "process_state": process_state,
            }
        if process_state == "transito_em_julgado":
            # Recursal deadlines are no longer valid; switch to CPC 523.
            feriados = load_feriados(state, intimation_date.year)
            if intimation_date.year != current_date.year:
                feriados |= load_feriados(state, current_date.year)
            deadline = calculate_prazo(
                start_date=intimation_date,
                days=_CUMPRIMENTO_VOLUNTARIO["dias"],
                unit=_CUMPRIMENTO_VOLUNTARIO["unidade"],
                feriados=feriados,
            )
            if current_date > deadline:
                status = "vencido"
            elif current_date == deadline:
                status = "ultimo_dia"
            else:
                status = "em_prazo"
            return {
                "tipo": _CUMPRIMENTO_VOLUNTARIO["tipo"],
                "fundamento_legal": _CUMPRIMENTO_VOLUNTARIO["fundamento"],
                "data_intimacao": intimation_date.isoformat(),
                "data_limite": deadline.isoformat(),
                "dias": _CUMPRIMENTO_VOLUNTARIO["dias"],
                "unidade": _CUMPRIMENTO_VOLUNTARIO["unidade"],
                "status": status,
                "process_state": process_state,
                "note": (
                    f"prazo recursal {prazo_type!r} ignorado porque o processo "
                    f"já transitou em julgado; computado apenas o prazo de "
                    f"cumprimento voluntário (CPC art. 523)."
                ),
            }
        # "ativo" or "desconhecido" -> fall through to normal calculation

    prazo_info = get_standard_prazo(prazo_type)
    if not prazo_info:
        return None

    # Load holidays for both the intimation year and deadline year
    feriados = load_feriados(state, intimation_date.year)
    if intimation_date.year != current_date.year:
        feriados |= load_feriados(state, current_date.year)

    deadline = calculate_prazo(
        start_date=intimation_date,
        days=prazo_info['dias'],
        unit=prazo_info['unidade'],
        feriados=feriados,
    )

    days_remaining = None
    if current_date <= deadline:
        # Count business days remaining
        d = current_date
        count = 0
        while d < deadline:
            d += timedelta(days=1)
            if is_business_day(d, feriados):
                count += 1
        days_remaining = count

    if current_date > deadline:
        status = 'vencido'
    elif current_date == deadline:
        status = 'ultimo_dia'
    else:
        status = 'em_prazo'

    result = {
        'tipo': prazo_type,
        'fundamento_legal': prazo_info['fundamento'],
        'data_intimacao': intimation_date.isoformat(),
        'data_limite': deadline.isoformat(),
        'dias': prazo_info['dias'],
        'unidade': prazo_info['unidade'],
        'status': status,
        'dias_restantes': days_remaining,
    }
    if process_state is not None:
        result['process_state'] = process_state
    return result


def main():
    parser = argparse.ArgumentParser(description='CPC Prazo Calculator')
    parser.add_argument('--date', '-d', help='Intimation date (YYYY-MM-DD)')
    parser.add_argument('--tipo', '-t', help='Prazo type (e.g., contestação, apelação)')
    parser.add_argument('--state', '-s', help='State for holidays (e.g., SP, RJ)')
    parser.add_argument('--analysis', '-a', help='Path to analyzed.json for batch calculation')
    parser.add_argument('--output', '-o', help='Output path for prazos.json')
    args = parser.parse_args()

    if args.date and args.tipo:
        # Single calculation mode
        intimation = date.fromisoformat(args.date)
        result = check_prazo_status(intimation, args.tipo, state=args.state)
        if result:
            print(json.dumps(result, ensure_ascii=False, indent=2))
        else:
            print(f"[ERROR] Unknown prazo type: {args.tipo}", file=sys.stderr)
            sys.exit(1)
    elif args.analysis:
        # Batch mode from analyzed.json
        with open(args.analysis, 'r', encoding='utf-8') as f:
            analysis = json.load(f)

        from utils.dates import parse_brazilian_date

        prazos = []
        unknown_tipo = 0
        unparseable_date = 0
        missing_start = 0
        seen_any = False
        for ci, chunk in enumerate(analysis.get('chunks', [])):
            for pj, prazo in enumerate(chunk.get('prazos', [])):
                seen_any = True
                tipo = prazo.get('tipo', '')
                start = prazo.get('data_inicio')
                if not start:
                    missing_start += 1
                    print(
                        f"WARN: chunk[{ci}].prazos[{pj}] tipo={tipo!r} sem data_inicio — pulando",
                        file=sys.stderr,
                    )
                    continue
                d = parse_brazilian_date(start)
                if not d:
                    unparseable_date += 1
                    print(
                        f"WARN: chunk[{ci}].prazos[{pj}] data_inicio={start!r} não parseável — pulando",
                        file=sys.stderr,
                    )
                    continue
                result = check_prazo_status(d, tipo, state=args.state)
                if result is None:
                    unknown_tipo += 1
                    print(
                        f"WARN: chunk[{ci}].prazos[{pj}] tipo={tipo!r} não reconhecido — pulando",
                        file=sys.stderr,
                    )
                    continue
                prazos.append(result)

        output_path = args.output or os.path.join(os.path.dirname(args.analysis), 'prazos.json')
        with open(output_path, 'w', encoding='utf-8') as f:
            json.dump(prazos, f, ensure_ascii=False, indent=2)

        dropped = unknown_tipo + unparseable_date + missing_start
        if dropped > 0:
            print(
                f"WARN: {dropped} prazo(s) descartado(s) "
                f"(tipo desconhecido: {unknown_tipo}, "
                f"data não parseável: {unparseable_date}, "
                f"sem data_inicio: {missing_start})",
                file=sys.stderr,
            )
        print(f"Calculated {len(prazos)} deadline(s). Output: {output_path}")

        if seen_any and len(prazos) == 0:
            # Input had prazos but everything was dropped — likely upstream bug
            sys.exit(1)
    else:
        parser.print_help()


if __name__ == '__main__':
    main()
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: 198kUpdated Claude CodeCodexVerifiedInstall
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: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
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: 196kUpdated Claude CodeCodexVerifiedInstall