scripts/eqc_qa/chunk_reports.py

#!/usr/bin/env python3
"""
chunk_reports.py — section-aware chunking of parsed EQC QA markdown.

Mirrors marine_rag/chunk_docs.py: ~1000-token section-aware chunks, small
overlap, tiktoken (cl100k_base ≈ Gemini) budget, a metadata prefix per chunk
(dataset + report + aspect + section path). Self-contained (no cmip6 import).

Output: eqc_qa/chunks.jsonl — payload fields:
  chunk_id, report_id, dataset_id, store, doc_type="EQC_QA",
  aspect, aspect_base, category, section, title, text_raw, text_with_prefix, token_count
"""
import hashlib
import json
import re
import sys
from pathlib import Path

import tiktoken

ROOT = Path(__file__).resolve().parent
PARSED = ROOT / "parsed"
MANIFEST = ROOT / "reports.jsonl"
OUT = ROOT / "chunks.jsonl"

MAX_TOKENS = 1000
MIN_QUALITY_TOKENS = 30
MIN_TOKENS = 80
OVERLAP_RATIO = 0.05

_enc = tiktoken.get_encoding("cl100k_base")


def log(*a):
    print(*a, file=sys.stderr, flush=True)


def count_tokens(t: str) -> int:
    return len(_enc.encode(t))


# ── section parsing (markdown heading aware) ─────────────────────────────────
HEADING = re.compile(r"^(#{1,4})\s+(.*)$")


def parse_sections(md: str) -> list[tuple[str, str]]:
    """Return [(section_path, body_text)] splitting on ATX headings, tracking
    the heading breadcrumb. Fenced code blocks are left intact (skip heading
    detection inside ``` fences)."""
    lines = md.splitlines()
    stack: list[tuple[int, str]] = []  # (level, title)
    cur_path = "[intro]"
    buf: list[str] = []
    sections: list[tuple[str, str]] = []
    in_fence = False

    def flush():
        body = "\n".join(buf).strip()
        if body:
            sections.append((cur_path, body))

    for ln in lines:
        if ln.lstrip().startswith("```"):
            in_fence = not in_fence
            buf.append(ln)
            continue
        m = None if in_fence else HEADING.match(ln)
        if m:
            flush()
            buf = []
            level = len(m.group(1))
            title = re.sub(r"[#*`]", "", m.group(2)).strip()
            title = re.sub(r"[\U0001F000-\U0001FAFF☀-➿]", "", title).strip()
            while stack and stack[-1][0] >= level:
                stack.pop()
            stack.append((level, title))
            cur_path = " > ".join(t for _, t in stack) or "[section]"
        else:
            buf.append(ln)
    flush()
    return sections


def strip_noise(t: str) -> str:
    # collapse admonition fences markers but keep content
    t = re.sub(r"```\{[^}]*\}", "", t)
    t = re.sub(r"^:class:.*$", "", t, flags=re.MULTILINE)
    t = re.sub(r"\n{3,}", "\n\n", t)
    return t.strip()


def split_by_tokens(text: str, max_tokens: int) -> list[str]:
    """Greedy paragraph-packing; hard-split any oversized paragraph on tokens."""
    paras = re.split(r"\n\s*\n", text)
    chunks: list[str] = []
    cur: list[str] = []
    cur_tok = 0
    for p in paras:
        p = p.strip()
        if not p:
            continue
        pt = count_tokens(p)
        if pt > max_tokens:
            if cur:
                chunks.append("\n\n".join(cur)); cur, cur_tok = [], 0
            ids = _enc.encode(p)
            for i in range(0, len(ids), max_tokens):
                chunks.append(_enc.decode(ids[i:i + max_tokens]))
            continue
        if cur_tok + pt > max_tokens and cur:
            chunks.append("\n\n".join(cur)); cur, cur_tok = [], 0
        cur.append(p); cur_tok += pt
    if cur:
        chunks.append("\n\n".join(cur))
    return chunks


def add_overlap(chunks: list[str], ratio: float) -> list[str]:
    if len(chunks) < 2 or ratio <= 0:
        return chunks
    out = [chunks[0]]
    for i in range(1, len(chunks)):
        prev = chunks[i - 1]
        ptoks = _enc.encode(prev)
        n = max(1, int(len(ptoks) * ratio))
        tail = _enc.decode(ptoks[-n:])
        out.append(tail + "\n\n" + chunks[i])
    return out


def make_prefix(rec: dict, section: str) -> str:
    ds = rec["matched_dataset_id"] or rec["dataset_id"] or "(unmapped)"
    return (f'EQC Quality Assessment: "{rec["title"]}"\n'
            f'Dataset: {ds} [{rec["store"] or "CDS"}]\n'
            f'Aspect: {rec["aspect"]}  |  Category: {rec["category"]}\n'
            f'Section: {section}\n---\n')


def chunk_report(rec: dict) -> list[dict]:
    md = (PARSED / Path(rec["md_path"]).name).read_text(encoding="utf-8", errors="replace")
    sections = parse_sections(md)
    out: list[dict] = []
    seen: set[str] = set()
    counter = 0
    for section, body in sections:
        body = strip_noise(body)
        if not body:
            continue
        raw = split_by_tokens(body, MAX_TOKENS)
        if len(raw) > 1:
            raw = add_overlap(raw, OVERLAP_RATIO)
        for ct in raw:
            ct = ct.strip()
            if count_tokens(ct) < MIN_QUALITY_TOKENS:
                continue
            h = hashlib.md5(ct.encode()).hexdigest()
            if h in seen:
                continue
            seen.add(h)
            twp = make_prefix(rec, section) + ct
            out.append({
                "chunk_id": f"{rec['report_id']}__{h[:12]}",
                "report_id": rec["report_id"],
                "dataset_id": rec["matched_dataset_id"] or rec["dataset_id"],
                "store": rec["store"] or "CDS",
                "doc_type": "EQC_QA",
                "aspect": rec["aspect"],
                "aspect_base": rec["aspect_base"],
                "category": rec["category"],
                "match_confidence": rec["match_confidence"],
                "section": section,
                "title": rec["title"],
                "chunk_index": counter,
                "token_count": count_tokens(twp),
                "text_raw": ct,
                "text_with_prefix": twp,
            })
            counter += 1

    # merge tiny adjacent chunks within a section
    merged: list[dict] = []
    i = 0
    while i < len(out):
        c = out[i]
        if (c["token_count"] < MIN_TOKENS and i + 1 < len(out)
                and out[i + 1]["section"] == c["section"]):
            nxt = out[i + 1]
            mt = c["text_raw"] + "\n\n" + nxt["text_raw"]
            nxt["text_raw"] = mt
            nxt["text_with_prefix"] = nxt["text_with_prefix"].split("---\n", 1)[0] + "---\n" + mt
            nxt["token_count"] = count_tokens(nxt["text_with_prefix"])
            i += 1
        else:
            merged.append(c); i += 1
    for j, c in enumerate(merged):
        c["chunk_index"] = j
    return merged


def main() -> None:
    recs = [json.loads(l) for l in open(MANIFEST)]
    recs = [r for r in recs if not r["is_template"]]  # skip scaffold
    log(f"chunking {len(recs)} reports")
    n_docs = n_chunks = 0
    with open(OUT, "w", encoding="utf-8") as f:
        for r in recs:
            chunks = chunk_report(r)
            for c in chunks:
                f.write(json.dumps(c, ensure_ascii=False) + "\n")
            n_docs += 1
            n_chunks += len(chunks)
    toks = 0
    for l in open(OUT):
        toks += json.loads(l)["token_count"]
    log(f"DONE: {n_docs} reports -> {n_chunks} chunks ({toks:,} tokens) -> {OUT}")
    log(f"avg {n_chunks/n_docs:.1f} chunks/report; est realtime ${toks/1e6*0.25:.2f}")


if __name__ == "__main__":
    main()