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/integrity_gate.py
View on GitHub"""Chunk integrity gate — Phase 1 Step 1.2.
Blocks `analyzed.json` (or `index.json`) outputs whose `chunks[]` entries do
not have a 1:1 correspondence with physical files under `chunks/`. This
prevents the class of bug where a downstream analyzer (Claude or a future
subagent) fabricates chunks that never existed on disk.
Checks performed, in order:
1. Every chunk in the JSON has an existing physical file.
2. Every physical `.txt` file under `chunks/` has a JSON entry.
3. `char_count` on the JSON entry matches `len(file_text)` (±2 for trailing
newline tolerance), when `char_count` is present.
Usage:
from integrity_gate import assert_chunks_consistent
assert_chunks_consistent(Path("analyzed.json"), Path("chunks"))
CLI:
python3 scripts/integrity_gate.py --input analyzed.json [--chunks-dir chunks]
"""
from __future__ import annotations
import argparse
import json
import sys
from pathlib import Path
class ChunkIntegrityError(Exception):
"""Raised when chunks in JSON do not match files on disk."""
def _load_index(path: Path) -> dict:
return json.loads(path.read_text(encoding="utf-8"))
def _resolve_chunk_path(base_dir: Path, chunk_file: str) -> Path:
p = Path(chunk_file)
if p.is_absolute():
return p
return base_dir / p
def check_chunks(
index_data: dict,
base_dir: Path,
chunks_dir: Path | None = None,
) -> list[str]:
"""Return a list of integrity errors. Empty list means consistent."""
errors: list[str] = []
chunks = index_data.get("chunks") or []
# Resolve the chunks directory.
if chunks_dir is None:
chunks_dir = base_dir / "chunks"
if not chunks_dir.exists():
errors.append(f"chunks directory does not exist: {chunks_dir}")
return errors
physical_files: set[Path] = {
p.resolve() for p in chunks_dir.iterdir() if p.suffix == ".txt"
}
claimed_files: set[Path] = set()
for i, chunk in enumerate(chunks):
idx = chunk.get("index", i)
chunk_file = chunk.get("chunk_file") or chunk.get("source_file") or chunk.get("file")
if not chunk_file:
errors.append(f"chunk #{idx}: missing chunk_file/source_file reference")
continue
resolved = _resolve_chunk_path(base_dir, chunk_file).resolve()
if not resolved.exists():
errors.append(
f"chunk #{idx}: file not found on disk: {chunk_file}"
)
continue
claimed_files.add(resolved)
declared_count = chunk.get("char_count")
if declared_count is not None:
try:
actual = len(resolved.read_text(encoding="utf-8"))
except Exception as e:
errors.append(f"chunk #{idx}: could not read {chunk_file}: {e}")
continue
if abs(actual - int(declared_count)) > 2:
errors.append(
f"chunk #{idx}: char_count mismatch for {chunk_file} "
f"(declared={declared_count}, actual={actual})"
)
orphans = physical_files - claimed_files
for orphan in sorted(orphans):
errors.append(
f"orphan chunk file on disk has no JSON entry: "
f"{orphan.relative_to(chunks_dir.parent) if chunks_dir.parent in orphan.parents else orphan}"
)
return errors
def assert_chunks_consistent(
index_path: Path,
chunks_dir: Path | None = None,
) -> None:
"""Raise ChunkIntegrityError if chunks in `index_path` are inconsistent with disk."""
data = _load_index(index_path)
base_dir = index_path.parent
errors = check_chunks(data, base_dir, chunks_dir)
if errors:
joined = "\n - ".join(errors)
raise ChunkIntegrityError(
f"chunk integrity check failed for {index_path}:\n - {joined}"
)
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(description="Chunk integrity gate")
parser.add_argument("--input", "-i", required=True,
help="Path to analyzed.json or index.json")
parser.add_argument("--chunks-dir", default=None,
help="Path to chunks/ dir (default: alongside --input)")
args = parser.parse_args(argv)
index_path = Path(args.input)
chunks_dir = Path(args.chunks_dir) if args.chunks_dir else None
try:
assert_chunks_consistent(index_path, chunks_dir)
except ChunkIntegrityError as e:
print(str(e), file=sys.stderr)
return 1
print(f"[OK] chunk integrity verified: {index_path}")
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 |