10 scripts to film tonight, in your own words.

#!/usr/bin/env python3
"""overlap.py: no line of your script may copy more than 4 words in a row from anything you studied.

    python3 overlap.py my_script.txt studied/            # every .txt and .md in the folder
    python3 overlap.py my_script.txt a.txt b.md --max 4

It prints the longest shared run for each source and the exact words, so you know which line to
rewrite. Exit 0 = PASS, 2 = FAIL. Needs only Python 3.
"""
import argparse, glob, os, re, sys

toks = lambda t: re.findall(r"[a-z0-9']+", t.lower())
grams = lambda w, n: {" ".join(w[i:i + n]) for i in range(len(w) - n + 1)}

ap = argparse.ArgumentParser()
ap.add_argument("script")
ap.add_argument("sources", nargs="+", help="files or folders you studied (transcripts, other scripts)")
ap.add_argument("--max", type=int, default=4, help="longest word run allowed")
a = ap.parse_args()

paths = []
for s in a.sources:
    paths += [p for p in glob.glob(os.path.join(s, "**", "*"), recursive=True)
              if p.endswith((".txt", ".md", ".srt", ".vtt"))] if os.path.isdir(s) else [s]
if not paths:
    sys.exit("overlap: no source files found (.txt .md .srt .vtt). Point it at what you studied.")


def clean(t, name):
    """Subtitle files: drop the WEBVTT header, cue numbers, timing lines and tags so words join across cues."""
    if name.lower().endswith((".srt", ".vtt")):
        keep = []
        for line in t.splitlines():
            l = line.strip()
            if not l or l.isdigit() or "-->" in l or l.startswith(("WEBVTT", "NOTE", "Kind:", "Language:")):
                continue
            keep.append(re.sub(r"<[^>]+>", "", l))
        t = " ".join(keep)
    return re.sub(r"\d+:\d+(?:[:.,]\d+)*", " ", t)


mine = toks(clean(open(a.script, errors="ignore").read(), a.script))
worst, fails, used = 0, [], 0
for p in paths:
    # drop timestamps like 00:12.5 so subtitle files compare cleanly
    src = toks(clean(open(p, errors="ignore").read(), p))
    if not src:
        print(f"skip {os.path.basename(p)}: no usable words")
        continue
    used += 1
    longest, words = 0, ""
    for n in range(a.max + 1, 40):
        g = grams(mine, n) & grams(src, n)
        if not g:
            break
        longest, words = n, sorted(g)[0]
    if longest:
        fails.append((longest, os.path.basename(p), words))
    worst = max(worst, longest)

if fails:
    for n, name, words in sorted(fails, reverse=True):
        print(f"FAIL {n} words in a row shared with {name}: \"{words}\"")
    print(f"overlap: longest run {worst} (max {a.max}) -> FAIL. Rewrite those lines in your own words.")
    sys.exit(2)
if not used:
    sys.exit("overlap: none of the source files had any words to compare. Nothing was checked.")
print(f"overlap: nothing longer than {a.max} words shared with {used} source file(s) -> PASS")

#!/usr/bin/env python3
"""slopcheck.py: flag the lines in a script that sound like AI wrote them.

    python3 slopcheck.py script.txt          # or:  cat script.txt | python3 slopcheck.py
Prints every flagged line with the reason. Exit 1 if anything is flagged, so it can gate a build.

Every word and pattern here is one I (or someone reading my drafts) rejected in a real script.
Add your own the same way: when you rewrite a line because it sounds fake, add the word or shape.
Needs only Python 3.
"""
import re, sys

WORDS = ["delve", "journey", "unlock", "unleash", "elevate", "holistic", "leverage", "game-changer",
         "game changer", "tapestry", "crucial", "seamless", "empower", "transformative", "embark",
         "realm", "testament", "vibrant", "robust", "navigate", "harness", "synergy",
         "dive in", "let's dive", "here's the thing", "the truth is", "nobody talks about",
         "in today's world", "in today's video", "at the end of the day", "it's worth noting",
         "it's important to remember", "great question", "hey guys", "i hope this helps",
         "the secret", "level up", "supercharge", "buckle up", "look no further", "deep dive"]
RULES = [
    (r",\s*not\s+\w+[\w\s']{0,25}[.!]?$", "'X, not Y' ending"),
    (r"\b(isn't|is not|aren't|wasn't)\s+[^.]{1,40}[.,]\s*(it's|it is|they're|that's)\b", "'it isn't X, it's Y' flip"),
    (r"\bnot (just|only|about)\b[^.]{1,40}\b(it's|but)\b", "'not just X, it's Y' construction"),
    (r"[—–]", "em or en dash"),
    (r";", "semicolon, nobody talks with these"),
    (r"[“”‘’]", "curly quotes, use straight ones"),
    (r"\b(\w+), (\w+),? and (\w+)\b[.!]?$", "list of three ending a line"),
    (r"^\s*while\b[^,]{3,60},", "'While X, Y' opener"),
    (r"\bthe (result|answer|catch|kicker)\?(\s|$)", "self-answering question"),
    (r"\bwhen it comes to\b|\bthe key is\b|\bmore than just\b", "filler phrase"),
    (r"\b(experts|studies|people) (say|agree|show)\b", "vague attribution, name the source"),
]
_WORDS = [(w, re.compile(r"(?<!\w)" + re.escape(w) + r"(?!\w)", re.I)) for w in WORDS]
_RULES = [(re.compile(p, re.I), why) for p, why in RULES]


def check(text):
    flags = []
    for n, line in enumerate(text.splitlines(), 1):
        if not line.strip():
            continue
        for w, rx in _WORDS:
            if rx.search(line.replace("’", "'")):
                flags.append((n, line.strip(), f"AI word: '{w}'"))
        for rx, why in _RULES:
            if rx.search(line):
                flags.append((n, line.strip(), why))
    return flags


text = open(sys.argv[1], errors="ignore").read() if len(sys.argv) > 1 else sys.stdin.read()
flags = check(text)
for n, line, why in flags:
    print(f"line {n}: {why}\n   {line[:120]}")
print(f"slopcheck: {len(flags)} flag(s) -> {'FAIL' if flags else 'clean'}")
sys.exit(1 if flags else 0)