@andespindola/crow-skills 0.12.1 → 0.13.0

package/skills/crow-behaviour/scripts/lc_fidelity.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+"""Confere se uma versão comprimida de um texto preservou o que muda o sentido.
+
+Uso: lc_fidelity.py ORIGINAL COMPRIMIDO
+Saída: 0 = aprovado; 1 = reprovado (lista o que se perdeu, inverteu ou foi inventado); 2 = erro de uso.
+
+O que reprova:
+- família lógica perdida, inventada ou trocada: negação (inclui "must not", "não deve"), obrigação,
+  recomendação, permissão, "sempre", "só", "exceto", limites máximo/mínimo, ordem (antes/depois).
+  Sinônimos dentro da família são aceitos (must not = never; nunca = jamais).
+- alvo deslocado: o que estava negado, restrito, excetuado ou ordenado mudou ("never npm" → "never pnpm",
+  "run tests before deploy" → "deploy before run tests").
+- papéis trocados: dois termos trocaram de contexto ("enabled in prod, disabled in dev" invertido;
+  "read allowed, write forbidden" invertido; números trocados entre rótulos).
+- números, datas, versões, URLs, caminhos, nomes de arquivo, flags e `código inline` perdidos ou inventados
+  (normaliza 1,000 = 1000 e 5 GB = 5GB);
+- blocos de código (``` , ~~~ ou indentados após linha em branco) alterados;
+- conteúdo removido demais: menos de 35% das palavras de conteúdo (por radical) preservadas.
+  Entre 35% e 60% sai só um AVISO.
+É uma checagem de melhor esforço, determinística e local; aprovar não dispensa ler o resultado.
+"""
+from __future__ import annotations
+
+import collections
+import itertools
+import re
+import sys
+
+FAMILIES = {
+    "negação": ["must not", "mustn't", "must never", "should not", "shouldn't", "shall not", "may not", "do not",
+                "does not", "did not", "is not", "are not", "was not", "cannot", "can't", "won't", "don't", "doesn't",
+                "didn't", "isn't", "aren't", "wasn't", "not", "never", "none", "nor", "without", "avoid", "forbidden",
+                "prohibited", "no",
+                "não deve", "não devem", "não pode", "não podem", "não", "nao", "nunca", "jamais", "nenhum", "nenhuma",
+                "nem", "sem", "evite", "evitar", "proibido", "proibida", "vedado"],
+    "obrigação": ["deve", "devem", "deverá", "precisa", "precisam", "obrigatório", "obrigatória", "obrigatoriamente",
+                  "must", "shall", "required", "require", "requires", "mandatory"],
+    "recomendação": ["deveria", "deveriam", "recomendado", "recomenda-se", "should", "recommended", "ideally"],
+    "permissão": ["pode", "podem", "opcional", "opcionalmente", "permitido", "permitida", "may", "optional",
+                  "optionally", "allowed", "permitted"],
+    "sempre": ["sempre", "toda vez", "always", "every time"],
+    "restrição": ["só", "somente", "apenas", "unicamente", "exclusivamente", "only", "solely", "exclusively"],
+    "exceção": ["a menos que", "a não ser que", "exceto", "salvo", "except", "unless", "excluding"],
+    "limite máximo": ["no máximo", "até no máximo", "at most", "up to", "no more than", "max", "máx", "maximum", "máximo"],
+    "limite mínimo": ["pelo menos", "no mínimo", "at least", "no less than", "min", "mín", "minimum", "mínimo"],
+    "antes": ["antes de", "antes do", "antes da", "antes que", "before", "prior to"],
+    "depois": ["depois de", "depois do", "depois da", "depois que", "após", "after", "afterwards"],
+}
+SCOPED = ("negação", "restrição", "exceção", "antes", "depois")
+STOP = set("""a o os as um uma uns umas de do da dos das em no na nos nas por para com e ou que se ao aos à às é são
+seu sua seus suas você vocês eu nós isso este esta esse essa
+the a an of to in on at for with and or is are be by it this that these those you your we our i me my they them
+their its as so if do does then than also just""".split())
+
+_CODE_FENCE = re.compile(r"^(```|~~~)[^\n]*\n.*?^\1[ \t]*$", re.S | re.M)
+_INLINE = re.compile(r"`[^`\n]+`")
+_URL = re.compile(r"https?://[^\s)>\]\"']+")
+_PATH = re.compile(r"(?<![\w.])(?:~|\.{1,2})?/[\w.@~-]+(?:/[\w.@~-]+)+")
+_FILE = re.compile(r"(?<![\w/.-])(?:\.[A-Za-z][\w-]{1,30}|[\w-]+\.(?:ya?ml|json|toml|ini|env|md|txt|py|js|ts|tsx|jsx|go|rs|rb|java|kt|sh|sql|lock|cfg|conf|xml|html|css|csv|log))(?![\w])")
+_FRAMEWORK = re.compile(r"^[A-Z][a-z]+\.js$")  # Node.js, Vue.js, Next.js são nomes, não arquivos
+_FLAG = re.compile(r"(?<![\w-])--?[A-Za-z][\w-]*(?:=\S+)?")
+_DATE = re.compile(r"\b\d{4}-\d{2}-\d{2}\b|\b\d{1,2}/\d{1,2}/\d{2,4}\b|\b\d{1,2} de [a-zç]+ de \d{4}\b|\b[A-Z][a-z]+ \d{1,2}, \d{4}\b", re.I)
+_VERSION = re.compile(r"\bv?\d+\.\d+\.\d+(?:[-+][\w.]+)?\b|\bv\d+(?:\.\d+)?\b")
+_NUMBER = re.compile(r"(?<![\w.])-?\d{1,3}(?:[.,]\d{3})+(?![\d])|(?<![\w.])-?\d+(?:[.,]\d+)?(?:\s?(?:%|ms|s|min|h|kb|mb|gb|tb|px|rem|em|x|k)\b)?", re.I)
+_WORD = re.compile(r"[A-Za-zÀ-ÿ][\w'-]*")
+_SENT = re.compile(r"[.;:!?]+(?=\s|$)|\n+")
+
+
+def norm_text(t: str) -> str:
+    return t.replace("’", "'").replace("‘", "'").replace("“", '"').replace("”", '"')
+
+
+def norm_number(n: str) -> str:
+    n = n.strip().lower().replace(" ", "")
+    if re.fullmatch(r"-?\d{1,3}(?:[.,]\d{3})+", n):
+        return re.sub(r"[.,]", "", n)
+    return n.replace(",", ".")
+
+
+def stem(w: str) -> str:
+    w = w.lower().strip("'-")
+    for suf in ("ações", "ação", "ções", "ção", "mente", "ing", "ies", "ied", "ed", "es", "s"):
+        if len(w) > len(suf) + 3 and w.endswith(suf):
+            return w[: -len(suf)]
+    return w
+
+
+def is_portuguese(t: str) -> bool:
+    w = [x.lower() for x in _WORD.findall(t)]
+    pt = sum(x in ("de", "que", "não", "para", "com", "uma", "os", "do", "da", "em", "é") for x in w)
+    en = sum(x in ("the", "and", "to", "of", "is", "with", "for", "this", "that", "it") for x in w)
+    return pt > en
+
+
+def indented_blocks(text: str):
+    """Blocos indentados de código: só depois de linha em branco e fora de lista (continuação de bullet não conta)."""
+    lines = text.split("\n")
+    blocks, keep = [], []
+    in_block = False
+    last_nonblank = ""
+    for i, line in enumerate(lines):
+        indented = bool(re.match(r"(?: {4}|\t)\S", line))
+        prev_blank = i > 0 and lines[i - 1].strip() == ""
+        if indented and (in_block or (prev_blank and not re.match(r"\s*([-*+]|\d+[.)])\s", last_nonblank))):
+            in_block = True
+            blocks.append(line.rstrip())
+            keep.append("")
+            continue
+        in_block = False
+        keep.append(line)
+        if line.strip():
+            last_nonblank = line
+    return blocks, "\n".join(keep)
+
+
+def family_hits(prose: str, pt: bool):
+    """(família, início, fim, termo) sem sobreposição, preferindo termos mais longos."""
+    terms = sorted(((t, f) for f, ts in FAMILIES.items() for t in ts), key=lambda x: -len(x[0]))
+    taken = bytearray(len(prose) + 1)
+    hits = []
+    low = prose.lower()
+    for term, fam in terms:
+        if term == "no" and pt:
+            continue  # "no" em português é "em + o"
+        for m in re.finditer(r"(?<![\w'-])" + re.escape(term) + r"(?![\w'-])", low):
+            if any(taken[m.start():m.end()]):
+                continue
+            if term in ("min", "max", "mín", "máx") and re.search(r"\d\s?$", low[:m.start()]):
+                continue  # "5 min" é unidade de tempo
+            if term == "up to" and low[m.end():m.end() + 5] == " date":
+                continue  # "up to date"
+            for i in range(m.start(), m.end()):
+                taken[i] = 1
+            hits.append((fam, m.start(), m.end(), term))
+    return sorted(hits, key=lambda h: h[1])
+
+
+def content(s: str) -> list:
+    return [stem(w) for w in _WORD.findall(s) if w.lower() not in STOP and len(w) > 2]
+
+
+_FAM_STEMS = {stem(w) for ts in FAMILIES.values() for t in ts for w in t.split()}
+
+
+POSTFIX = {"forbidden", "prohibited", "allowed", "permitted", "required", "mandatory", "optional", "proibido",
+           "proibida", "permitido", "permitida", "obrigatório", "obrigatória", "opcional", "vedado"}
+
+
+def scopes(prose: str, hits):
+    """Alvo de cada termo com escopo: até 4 palavras de conteúdo seguintes, na mesma oração.
+    Termos pós-fixados ("write is forbidden") usam as palavras anteriores como alvo."""
+    out = []
+    for fam, s, e, term in hits:
+        if term in POSTFIX:
+            clause = _SENT.split(prose[max(0, s - 120):s])[-1]
+            words = [w for w in content(clause) if w not in _FAM_STEMS][-4:]
+            if words:
+                out.append((fam + "·sujeito", term, words))
+            continue
+        if fam not in SCOPED:
+            continue
+        clause = _SENT.split(prose[e:e + 120])[0]
+        words = [w for w in content(clause) if w not in _FAM_STEMS][:4]
+        if words:
+            out.append((fam, term, words))
+    return out
+
+
+def neighbors(prose: str) -> dict:
+    """Para cada radical que aparece uma vez: as 2 palavras de conteúdo seguintes na mesma oração."""
+    seq = [[w for w in content(c) if w not in _FAM_STEMS] for c in _SENT.split(prose)]
+    counts = collections.Counter(w for ws in seq for w in ws)
+    nb = {}
+    for ws in seq:
+        for i, w in enumerate(ws):
+            if counts[w] == 1:
+                nb[w] = set(ws[i + 1:i + 3])
+    return nb
+
+
+def labeled_numbers(prose: str):
+    """Rótulos de cada número: palavra de conteúdo imediatamente antes e imediatamente depois, na mesma oração."""
+    out = []
+    for m in _NUMBER.finditer(prose):
+        before = re.split(r"[.,;:\n]", prose[max(0, m.start() - 80):m.start()])[-1]
+        after = re.split(r"[.,;:\n]", prose[m.end():m.end() + 80])[0]
+        b, a = content(before), content(after)
+        labels = set(b[-1:]) | set(a[:1]) | set(b[:1])
+        if labels:
+            out.append((norm_number(m.group(0)), labels))
+    return out
+
+
+def extract(text: str):
+    text = norm_text(text)
+    fences = [m.group(0).strip() for m in _CODE_FENCE.finditer(text)]
+    no_fence = _CODE_FENCE.sub("\n", text)
+    indented, prose = indented_blocks(no_fence)
+    inline = _INLINE.findall(prose)
+    prose_ni = _INLINE.sub(" ", prose)
+    urls = _URL.findall(prose_ni)
+    rest = _URL.sub(" ", prose_ni)
+    paths = _PATH.findall(rest)
+    files = [f for f in _FILE.findall(_PATH.sub(" ", rest)) if not _FRAMEWORK.match(f)]
+    flags = _FLAG.findall(rest)
+    dates = _DATE.findall(rest)
+    rest2 = _DATE.sub(" ", rest)
+    versions = _VERSION.findall(rest2)
+    rest3 = _VERSION.sub(" ", _FLAG.sub(" ", rest2))
+    numbers = [norm_number(n) for n in _NUMBER.findall(rest3)]
+    pt = is_portuguese(prose_ni)
+    hits = family_hits(prose_ni, pt)
+    return dict(
+        exact={
+            "blocos de código": collections.Counter(fences + indented),
+            "código inline": collections.Counter(inline),
+            "URLs": collections.Counter(urls),
+            "caminhos": collections.Counter(paths),
+            "arquivos": collections.Counter(f.lower() for f in files),
+            "flags": collections.Counter(flags),
+            "datas": collections.Counter(d.lower() for d in dates),
+            "versões": collections.Counter(versions),
+            "números": collections.Counter(numbers),
+        },
+        families=collections.Counter(h[0] for h in hits),
+        scopes=scopes(prose_ni, hits),
+        neighbors=neighbors(rest),
+        labeled=labeled_numbers(rest3),
+        words=content(prose_ni),
+    )
+
+
+def compare(a: str, b: str):
+    A, B = extract(a), extract(b)
+    problems, warnings = [], []
+    for kind, ca in A["exact"].items():
+        lost = ca - B["exact"][kind]
+        if lost:
+            problems.append(f"PERDIDO [{kind}]: " + ", ".join(repr(k) for k in list(lost)[:12]))
+        if kind != "blocos de código":
+            extra = B["exact"][kind] - ca
+            if extra:
+                problems.append(f"INVENTADO [{kind}]: " + ", ".join(repr(k) for k in list(extra)[:12]))
+    for fam in FAMILIES:
+        na, nb = A["families"][fam], B["families"][fam]
+        if nb < na:
+            problems.append(f"PERDIDO [{fam}]: {na} no original, {nb} na versão comprimida")
+        elif nb > na:
+            problems.append(f"INVENTADO [{fam}]: {na} no original, {nb} na versão comprimida")
+    # alvo deslocado: o alvo ainda existe no texto, mas não está mais sob o mesmo operador
+    bwords = set(B["words"])
+    for fam, term, words in A["scopes"]:
+        key = [w for w in words if w in bwords]
+        if not key:
+            continue
+        need = min(2, len(key))
+        if not any(f == fam and len(set(key) & set(ws)) >= need for f, _, ws in B["scopes"]):
+            problems.append(f"DESLOCADO [{fam}]: o alvo de '{term}' ({' '.join(words)}) mudou")
+    # papéis trocados: x e y trocaram de vizinhos
+    na_, nb_ = A["neighbors"], B["neighbors"]
+    common = [w for w in na_ if w in nb_][:600]
+    for x, y in itertools.combinations(common, 2):
+        ax, ay, bx, by = na_[x], na_[y], nb_[x], nb_[y]
+        ux, uy = ax - ay, ay - ax
+        if ux and uy and (ux & by) and (uy & bx) and not (ux & bx) and not (uy & by):
+            problems.append(f"TROCADO [papéis]: '{x}' e '{y}' trocaram de contexto")
+    # números trocados de rótulo: o rótulo de n agora acompanha outro número que já existia no original
+    nums_a = {n for n, _ in A["labeled"]}
+    for n_a, la in A["labeled"]:
+        others = set().union(*[l for n, l in A["labeled"] if n != n_a]) if len(A["labeled"]) > 1 else set()
+        own = la - others  # rótulos que só este número tem
+        if not own:
+            continue
+        if any(n_b == n_a and (lb & own) for n_b, lb in B["labeled"]):
+            continue
+        for n_b, lb in B["labeled"]:
+            if n_b != n_a and n_b in nums_a and (lb & own):
+                problems.append(f"TROCADO [números]: '{' '.join(sorted(lb & own))}' tinha {n_a}, passou a ter {n_b}")
+    problems = list(dict.fromkeys(problems))
+    wa, wb = set(A["words"]), set(B["words"])
+    recall = len(wa & wb) / len(wa) if wa else 1.0
+    if recall < 0.35:
+        problems.append(f"CONTEÚDO REMOVIDO: só {recall:.0%} das palavras de conteúdo foram preservadas")
+    elif recall < 0.6:
+        warnings.append(f"AVISO: {recall:.0%} das palavras de conteúdo preservadas; confira se nenhuma instrução sumiu")
+    return problems, warnings, recall
+
+
+def read(path: str) -> str:
+    with open(path, "rb") as f:
+        raw = f.read()
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError:
+        return raw.decode("latin-1")
+
+
+def main(argv: list) -> int:
+    if len(argv) != 2:
+        sys.stderr.write(__doc__)
+        return 2
+    try:
+        a, b = read(argv[0]), read(argv[1])
+    except OSError as e:
+        sys.stderr.write(f"lc_fidelity: não consegui ler: {e}\n")
+        return 2
+    problems, warnings, recall = compare(a, b)
+    for p in problems + warnings:
+        print(p)
+    ratio = len(b) / len(a) if a else 1
+    print(f"tamanho: {len(a)} → {len(b)} caracteres ({ratio:.0%} do original); palavras de conteúdo preservadas: {recall:.0%}")
+    if problems:
+        print("resultado: REPROVADO — refaça a compressão preservando os itens acima")
+        return 1
+    print("resultado: aprovado (nada crítico perdido, invertido ou inventado)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))