aidetect 0.1.0__py3-none-any.whl

aidetect/__init__.py

@@ -0,0 +1 @@
+"""Local, offline AI-writing checks and IB word counts for my own drafts."""

aidetect/binoculars.py

@@ -0,0 +1,243 @@
+"""
+Binoculars AI-text detector — a second-opinion scorer for my drafts.
+
+Binoculars (Hans et al. 2024, https://arxiv.org/abs/2401.12070) needs no
+training. It runs the text through TWO causal language models that share a
+tokenizer — an "observer" (base) and a "performer" (instruct) — and compares
+how surprised each is:
+
+    score = perplexity(performer) / cross_perplexity(observer, performer)
+
+Human text tends to score HIGHER, machine text LOWER. It's the ratio that
+matters: LLM text is unsurprising to a model (low perplexity) but the two
+models also agree closely on it (low cross-perplexity), and dividing cancels
+out the "this topic is just easy/hard" effect that fools plain perplexity.
+
+The paper used a Falcon-7B pair (~28GB, won't fit an 18GB Mac). Small Qwen2.5
+pairs fit but barely separate human from AI text (~63%, near chance) — which is
+why this was shelved as a negative result. A Gemma 4 pair fixes that: it hits
+~96% on the calibration set. Gemma 4 ships as a multimodal checkpoint, so the
+--mlx path loads it 4-bit via mlx-vlm and runs it text-only.
+
+    aidetect bino path/to/draft.docx
+    aidetect bino notes.txt --text "some sentence to score"
+    aidetect bino notes.txt --pair big         # bigger Qwen pair
+    aidetect bino notes.txt --mlx --pair gemma # Gemma 4 E2B on a Mac
+
+Threshold: the AI/human boundary is PER MODEL PAIR. If `aidetect calibrate` has saved a
+threshold for the active pair it's loaded automatically; otherwise it falls back
+to Falcon's 0.90 placeholder. Lower score = more AI-like.
+"""
+
+import argparse
+import os
+
+import torch
+import torch.nn.functional as F
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+from .detect import pick_device
+from .paths import threshold_path, user_threshold_path
+from .text import MIN_WORDS, bar, read_paragraphs
+
+# Same-tokenizer pairs. base = observer, instruct = performer.
+# Gemma 4 is Apache-2 (no HF gate). E2B is the smallest but ~5B raw params each,
+# so the fp16 pair is ~20GB — over an 18GB Mac. Use these on a CUDA box; on a Mac
+# use --mlx (4-bit quantized, fits in ~6GB).
+PAIRS = {
+    "small":  ("Qwen/Qwen2.5-0.5B", "Qwen/Qwen2.5-0.5B-Instruct"),
+    "big":    ("Qwen/Qwen2.5-1.5B", "Qwen/Qwen2.5-1.5B-Instruct"),
+    "gemma":  ("google/gemma-4-E2B", "google/gemma-4-E2B-it"),
+    "gemma+": ("google/gemma-4-E4B", "google/gemma-4-E4B-it"),
+}
+
+# --mlx pairs. observer = google base repo (no pre-quant exists, so we quantize it
+# locally on first run); performer = mlx-community's pre-quantized instruct repo.
+MLX_PAIRS = {
+    "gemma":  ("google/gemma-4-E2B", "mlx-community/gemma-4-e2b-it-qat-OptiQ-4bit"),
+    "gemma+": ("google/gemma-4-E4B", "mlx-community/gemma-4-e4b-it-qat-OptiQ-4bit"),
+}
+MLX_CACHE = os.path.expanduser("~/.cache/ai-detect-mlx")
+MAX_LEN = 1024        # token window; longer paragraphs get truncated
+# ponytail: Falcon's tuned boundary as a placeholder. Wrong for our pair —
+# recalibrate on known-human text. Lower score = more AI-like.
+DEFAULT_THRESHOLD = 0.90
+
+
+def pair_tag(pair_key, backend):
+    return f"{pair_key}-mlx" if backend == "mlx" else pair_key
+
+
+def load_saved_threshold(pair_key, backend):
+    """Return the saved threshold for this pair, or None if never calibrated.
+
+    A threshold you fitted yourself (~/.config/aidetect) wins over the one
+    shipped in the wheel, so recalibrating survives an upgrade.
+    """
+    import json
+    tag = pair_tag(pair_key, backend)
+    for path in (user_threshold_path(tag), threshold_path(tag)):
+        if path and os.path.exists(path):
+            return json.load(open(path)).get("threshold")
+    return None
+
+
+def load_pair(pair_key, device):
+    obs_id, perf_id = PAIRS[pair_key]
+    tokenizer = AutoTokenizer.from_pretrained(obs_id)
+    dtype = torch.float16 if device.type == "mps" else torch.float32
+    observer = AutoModelForCausalLM.from_pretrained(obs_id, torch_dtype=dtype).to(device).eval()
+    performer = AutoModelForCausalLM.from_pretrained(perf_id, torch_dtype=dtype).to(device).eval()
+    return tokenizer, observer, performer
+
+
+def _mlx_quantized(repo):
+    """Return a local 4-bit MLX copy of an fp16 HF repo, converting once and reusing.
+    Gemma 4 ships as a VLM checkpoint, so this goes through mlx-vlm, not mlx-lm."""
+    from mlx_vlm import convert
+    out = os.path.join(MLX_CACHE, repo.replace("/", "_") + "-4bit")
+    if not os.path.isdir(out):
+        print(f"converting {repo} to 4-bit MLX (one-time, downloads fp16 weights)...")
+        convert(repo, mlx_path=out, quantize=True)
+    return out
+
+
+def load_pair_mlx(pair_key):
+    """MLX backend for Macs. observer is quantized locally; performer is pre-quantized.
+    Returns (tokenizer, observer, performer) — models are mlx-vlm VLMs run text-only."""
+    from mlx_vlm import load
+    obs_src, perf_repo = MLX_PAIRS[pair_key]
+    observer, processor = load(_mlx_quantized(obs_src))   # base tokenizer drives encoding
+    performer, _ = load(perf_repo)
+    tokenizer = getattr(processor, "tokenizer", processor)
+    return tokenizer, observer, performer
+
+
+def add_backend_args(ap):
+    """The --pair/--mlx flags, shared by binoculars.py and calibrate.py."""
+    ap.add_argument("--pair", choices=list(PAIRS), default="small",
+                    help="model pair to use (default %(default)s)")
+    ap.add_argument("--mlx", action="store_true",
+                    help="use the 4-bit MLX gemma pair (Apple Silicon; needs mlx-vlm)")
+
+
+def load_backend(args):
+    """Turn parsed CLI args into a loaded model pair.
+    Returns (pair_key, backend, device, tokenizer, observer, performer)."""
+    pair_key = args.pair
+    if args.mlx:
+        if pair_key not in MLX_PAIRS:
+            raise SystemExit(f"--mlx only supports {list(MLX_PAIRS)}; pass e.g. --pair gemma")
+        print(f"loading MLX pair {' + '.join(MLX_PAIRS[pair_key])}...")
+        tokenizer, observer, performer = load_pair_mlx(pair_key)
+        return pair_key, "mlx", None, tokenizer, observer, performer
+    device = pick_device()
+    print(f"loading {' + '.join(PAIRS[pair_key])} on {device}... (first run downloads the models)")
+    tokenizer, observer, performer = load_pair(pair_key, device)
+    return pair_key, "torch", device, tokenizer, observer, performer
+
+
+def _mlx_logits(model, ids):
+    """Run an mlx-vlm model text-only (no pixel_values) and return logits as torch."""
+    import mlx.core as mx
+    import numpy as np
+    out = model(mx.array([ids]))             # text-only path; returns LanguageModelOutput
+    logits = out.logits if hasattr(out, "logits") else out   # (1, seq, vocab)
+    logits = logits.astype(mx.float32)       # numpy can't read mlx bfloat16 buffers
+    return torch.from_numpy(np.array(logits)).float()
+
+
+def perplexity(input_ids, logits):
+    """Mean next-token cross-entropy: how surprised the performer is by the text."""
+    # predict token t+1 from position t, so line the logits up one step ahead
+    shift_logits = logits[..., :-1, :]
+    shift_labels = input_ids[..., 1:]
+    ce = F.cross_entropy(
+        shift_logits.reshape(-1, shift_logits.size(-1)),
+        shift_labels.reshape(-1),
+        reduction="mean",
+    )
+    return ce.item()
+
+
+def cross_perplexity(observer_logits, performer_logits):
+    """Mean cross-entropy of the performer's predictions against the observer's
+    full distribution — how much the two models DISAGREE per token."""
+    # observer's probabilities are the soft targets; score the performer against them
+    p = F.softmax(observer_logits, dim=-1)
+    log_q = F.log_softmax(performer_logits, dim=-1)
+    ce = -(p * log_q).sum(dim=-1)      # per-token cross-entropy
+    return ce.mean().item()
+
+
+def score_text(text, tokenizer, observer, performer, device, backend="torch"):
+    """Return the Binoculars score for one chunk. Lower = more AI-like.
+    Both backends end up feeding torch logits into the same perplexity math."""
+    if backend == "mlx":
+        ids = tokenizer.encode(text)[:MAX_LEN]     # base+instruct share this vocab
+        obs_logits = _mlx_logits(observer, ids)
+        perf_logits = _mlx_logits(performer, ids)
+        input_ids = torch.tensor([ids])
+    else:
+        enc = tokenizer(text, truncation=True, max_length=MAX_LEN, return_tensors="pt")
+        input_ids = enc["input_ids"].to(device)
+        attention_mask = enc["attention_mask"].to(device)
+        with torch.no_grad():
+            obs_logits = observer(input_ids=input_ids, attention_mask=attention_mask).logits.float()
+            perf_logits = performer(input_ids=input_ids, attention_mask=attention_mask).logits.float()
+    ppl = perplexity(input_ids, perf_logits)
+    x_ppl = cross_perplexity(obs_logits, perf_logits)
+    return ppl / x_ppl
+
+
+def report(paragraphs, threshold, tokenizer, observer, performer, device, backend="torch"):
+    if not paragraphs:
+        print("No paragraphs with >= %d words found." % MIN_WORDS)
+        return
+    scores = []
+    for i, para in enumerate(paragraphs, 1):
+        s = score_text(para, tokenizer, observer, performer, device, backend)
+        scores.append(s)
+        flag = "  <-- AI-ish" if s < threshold else ""
+        # bar: lower score = more AI, so invert for a "how AI-ish" bar
+        aiish = max(0.0, min(1.0, (threshold * 1.3 - s) / (threshold * 1.3)))
+        print(f"P{i:>3}  {s:5.2f}  [{bar(aiish)}]{flag}")
+        print(f"      {para[:70].strip()}...")
+    avg = sum(scores) / len(scores)
+    low = sum(1 for s in scores if s < threshold)
+    print("-" * 60)
+    print(f"average Binoculars score: {avg:.2f}   |   {low}/{len(scores)} paragraphs flagged (< {threshold})")
+    print("reminder: directional only. Lower = more AI-like. Recalibrate with `aidetect calibrate`.")
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="aidetect bino",
+                                 description="Binoculars AI-text detector (second opinion).")
+    ap.add_argument("path", nargs="?", help=".docx or .txt file to score")
+    ap.add_argument("--text", help="score a single string instead of a file")
+    add_backend_args(ap)
+    ap.add_argument("--threshold", type=float, default=None,
+                    help="flag paragraphs below this (default: calibrated pair threshold, else %s)"
+                         % DEFAULT_THRESHOLD)
+    args = ap.parse_args(argv)
+
+    if not args.path and not args.text:
+        ap.error("give a file path or --text")
+
+    pair_key, backend, device, tokenizer, observer, performer = load_backend(args)
+
+    # explicit --threshold wins; else use the calibrated one; else Falcon's placeholder
+    threshold = args.threshold
+    if threshold is None:
+        threshold = load_saved_threshold(pair_key, backend)
+        if threshold is not None:
+            print(f"using calibrated threshold {threshold}")
+    if threshold is None:
+        threshold = DEFAULT_THRESHOLD
+
+    if args.text:
+        s = score_text(args.text, tokenizer, observer, performer, device, backend)
+        verdict = "AI-ish" if s < threshold else "human-ish"
+        print(f"Binoculars score: {s:.2f}  ({verdict}, threshold {threshold})")
+    else:
+        report(read_paragraphs(args.path), threshold, tokenizer, observer, performer, device, backend)

aidetect/calibrate.py

@@ -0,0 +1,123 @@
+"""
+Calibrate the Binoculars threshold for a model pair, then optionally check a draft.
+
+Binoculars outputs a raw score, not a probability, and the AI/human boundary is
+specific to the model pair. This scores a labelled set (a folder of known-human
+prose against a folder of known-LLM prose on the same topics), finds the cutoff
+that best separates them, and saves it to ~/.config/aidetect.
+
+My own calibration set is not shipped with the package: it is 12 real pre-2020 IB
+Extended Essays and 12 LLM-written imitations, and it lives in corpora/ in the
+repo. Point --human-dir and --ai-dir at your own.
+
+    aidetect calibrate --human-dir corpora/human --ai-dir corpora/ai
+    aidetect calibrate --human-dir corpora/human --ai-dir corpora/ai --mlx --pair gemma
+    aidetect calibrate --human-dir h --ai-dir a --check draft.docx
+
+The human class has to be provably human or the threshold is meaningless. Do not
+point --human-dir at anything written after ChatGPT that you cannot certify.
+"""
+
+import argparse
+import glob
+import json
+import os
+
+from .binoculars import (MLX_PAIRS, PAIRS, add_backend_args, load_backend,
+                         pair_tag, report, score_text)
+from .paths import ensure_user_dir, user_threshold_path
+from .text import read_paragraphs
+
+
+def score_folder(folder, tokenizer, observer, performer, device, backend="torch"):
+    """Score every .txt in a folder. Returns list of (id, score)."""
+    out = []
+    for path in sorted(glob.glob(os.path.join(folder, "*.txt"))):
+        text = open(path, encoding="utf-8").read().strip()
+        if not text:
+            continue
+        sid = os.path.splitext(os.path.basename(path))[0]
+        out.append((sid, score_text(text, tokenizer, observer, performer, device, backend)))
+    return out
+
+
+def pick_threshold(human_scores, ai_scores):
+    """Cutoff that best separates the clusters (predict AI if score < cutoff).
+    Human text scores higher, AI lower. Ties broken toward the most centered
+    cutoff (largest gap to the nearest sample) so it generalizes better."""
+    everything = sorted(set(human_scores + ai_scores))
+    candidates = [everything[0] - 0.01]
+    for a, b in zip(everything, everything[1:]):
+        candidates.append((a + b) / 2)
+    candidates.append(everything[-1] + 0.01)
+
+    best = None
+    for c in candidates:
+        correct = sum(s >= c for s in human_scores) + sum(s < c for s in ai_scores)
+        acc = correct / (len(human_scores) + len(ai_scores))
+        margin = min(abs(s - c) for s in human_scores + ai_scores)
+        key = (acc, margin)
+        if best is None or key > best[0]:
+            best = (key, c)
+    (acc, _margin), cutoff = best
+    return cutoff, acc
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        prog="aidetect calibrate",
+        description="Fit the Binoculars threshold for a model pair on your own labelled set.")
+    ap.add_argument("--human-dir", required=True,
+                    help="folder of .txt files you can certify are human-written")
+    ap.add_argument("--ai-dir", required=True,
+                    help="folder of .txt files you know are LLM-written")
+    ap.add_argument("--check", help="optionally score this draft with the new threshold")
+    add_backend_args(ap)
+    args = ap.parse_args(argv)
+
+    for label, folder in (("--human-dir", args.human_dir), ("--ai-dir", args.ai_dir)):
+        if not glob.glob(os.path.join(folder, "*.txt")):
+            ap.error(f"{label}: no .txt files in {folder}")
+
+    pair_key, backend, device, tokenizer, observer, performer = load_backend(args)
+
+    # --- score the labelled set ---
+    human = score_folder(args.human_dir, tokenizer, observer, performer, device, backend)
+    ai = score_folder(args.ai_dir, tokenizer, observer, performer, device, backend)
+    human_scores = [s for _, s in human]
+    ai_scores = [s for _, s in ai]
+
+    print("\n=== calibration scores (higher = more human) ===")
+    print(f"{'HUMAN':<22}{'AI (LLM-written)':<22}")
+    for i in range(max(len(human), len(ai))):
+        h = f"{human[i][0]} {human[i][1]:.3f}" if i < len(human) else ""
+        a = f"{ai[i][0]} {ai[i][1]:.3f}" if i < len(ai) else ""
+        print(f"{h:<22}{a:<22}")
+    print(f"\nhuman: min {min(human_scores):.3f}  mean {sum(human_scores)/len(human_scores):.3f}  max {max(human_scores):.3f}")
+    print(f"ai   : min {min(ai_scores):.3f}  mean {sum(ai_scores)/len(ai_scores):.3f}  max {max(ai_scores):.3f}")
+
+    cutoff, acc = pick_threshold(human_scores, ai_scores)
+    print(f"\n>>> calibrated threshold: {cutoff:.3f}  (separates {acc*100:.0f}% of the {len(human)+len(ai)} samples)")
+    print("    flag as AI-ish when score < threshold")
+
+    # save for reuse / future recalibration
+    active_pairs = MLX_PAIRS if backend == "mlx" else PAIRS
+    out = {
+        "pair": active_pairs[pair_key],
+        "backend": backend,
+        "threshold": round(cutoff, 4),
+        "accuracy": round(acc, 4),
+        "n_human": len(human),
+        "n_ai": len(ai),
+        "human_mean": round(sum(human_scores)/len(human_scores), 4),
+        "ai_mean": round(sum(ai_scores)/len(ai_scores), 4),
+    }
+    ensure_user_dir()
+    thr_path = user_threshold_path(pair_tag(pair_key, backend))
+    json.dump(out, open(thr_path, "w"), indent=2)
+    print(f"    saved -> {thr_path}")
+
+    # --- run the calibrated check on a draft ---
+    if args.check:
+        print(f"\n=== checking {args.check} with threshold {cutoff:.3f} ===")
+        report(read_paragraphs(args.check), cutoff, tokenizer, observer, performer, device, backend)

aidetect/cli.py

@@ -0,0 +1,46 @@
+"""
+`aidetect` entry point.
+
+Subcommand modules are imported lazily and on demand: `aidetect count` must not
+pay a ~2s torch import to count words, and on a machine without mlx-vlm the
+torch-free subcommands still have to work.
+"""
+
+import sys
+
+COMMANDS = {
+    "count":     ("aidetect.count",      "IB-rules word count for a draft"),
+    "score":     ("aidetect.detect",     "score paragraphs with the desklib detector"),
+    "bino":      ("aidetect.binoculars", "second opinion via Binoculars (needs a model pair)"),
+    "extract":   ("aidetect.extract",    "pull finished prose out of a .docx into a .txt"),
+    "calibrate": ("aidetect.calibrate",  "fit a Binoculars threshold on your own labelled set"),
+}
+
+USAGE = "usage: aidetect <command> [options]\n\ncommands:\n" + "".join(
+    f"  {name:<10} {help}\n" for name, (_mod, help) in COMMANDS.items()
+) + "\nrun `aidetect <command> --help` for a command's options.\n"
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] in ("-h", "--help", "help"):
+        print(USAGE, end="")
+        return 0
+    if sys.argv[1] in ("-V", "--version"):
+        from importlib.metadata import version
+        print(version("aidetect"))
+        return 0
+
+    command = sys.argv[1]
+    if command not in COMMANDS:
+        print(f"aidetect: unknown command {command!r}\n", file=sys.stderr)
+        print(USAGE, end="", file=sys.stderr)
+        return 2
+
+    module_name = COMMANDS[command][0]
+    from importlib import import_module
+    module = import_module(module_name)
+    return module.main(sys.argv[2:])
+
+
+if __name__ == "__main__":
+    sys.exit(main())

aidetect/count.py

@@ -0,0 +1,118 @@
+"""
+IB word count for a draft.
+
+Word's own count is wrong for IB: it counts headings, block quotes, tables,
+footnotes and citations, none of which are assessed. This counts what the IB
+counts, and splits the total by section so an over-long draft says WHERE.
+
+Excluded, per the IB rules that are common to the EE and the subject IAs:
+  - headings                  (skipped by style)
+  - the bibliography onward   (stop at the Bibliography/Works Cited heading)
+  - block quotes and bullets  (same first-character rule extract.py uses)
+  - tables and footnotes      (python-docx never puts them in doc.paragraphs)
+  - in-text citations         (parentheticals containing a year / ibid / et al)
+
+    aidetect count draft.docx
+    aidetect count draft.docx --limit 4000
+    aidetect count draft.docx --limit 4000 --json
+"""
+
+import argparse
+import json
+import re
+
+from .text import is_end_heading, is_heading, is_prose
+
+# A parenthetical is a citation if it carries a 4-digit year, "ibid" or "et al".
+# ponytail: narrow on purpose. "(the second of these)" is prose and stays counted;
+# widening this to every parenthetical would silently eat hundreds of real words.
+CITATION = re.compile(
+    r"\((?:[^()]*(?:\b(?:1[6-9]|20)\d{2}\b|\bibid\b|\bet al\b)[^()]*)\)",
+    re.IGNORECASE,
+)
+
+
+def count_words(text):
+    """Words in one paragraph, with in-text citations removed.
+
+    Tokens with no letter or digit are dropped: removing "(Smith, 2024)" from
+    "...sharply (Smith, 2024)." strands the full stop as its own token, and a
+    lone "." is not a word.
+    """
+    stripped = CITATION.sub(" ", text)
+    return sum(1 for token in stripped.split() if any(c.isalnum() for c in token))
+
+
+def count_docx(path):
+    """Return (sections, total). sections is a list of (heading, words)."""
+    import docx
+
+    sections = [("(untitled)", 0)]
+    for p in docx.Document(path).paragraphs:
+        if is_end_heading(p):
+            break
+        if is_heading(p):
+            title = p.text.strip()
+            if title:
+                sections.append((title, 0))
+            continue
+        # min_words=1: the 25-word floor is a detector heuristic. A one-line
+        # paragraph is still words the examiner counts.
+        if is_prose(p, min_words=1):
+            title, words = sections[-1]
+            sections[-1] = (title, words + count_words(p.text))
+    sections = [s for s in sections if s[1] > 0]
+    return sections, sum(w for _, w in sections)
+
+
+def report(sections, total, limit):
+    width = max((len(t) for t, _ in sections), default=10)
+    for title, words in sections:
+        share = words / total if total else 0
+        print(f"  {title:<{width}}  {words:>5}  {'#' * round(share * 30)}")
+    print("-" * (width + 40))
+    if limit:
+        over = total - limit
+        verdict = f"{over:+d} over" if over > 0 else f"{-over} to spare"
+        print(f"  {'TOTAL':<{width}}  {total:>5}  / {limit} limit, {verdict}")
+    else:
+        print(f"  {'TOTAL':<{width}}  {total:>5}")
+    print("excludes headings, quotes, bullets, tables, footnotes, "
+          "citations and everything from the bibliography on.")
+
+
+def as_json(sections, total, limit):
+    """The machine interface. Every key is always present; `null` means the
+    question does not apply, not that it could not be answered. A draft with no
+    prose is an empty list and exit 0, because parsing succeeded and the honest
+    answer is zero."""
+    return {
+        "sections": [{"title": t, "words": w} for t, w in sections],
+        "total": total,
+        "limit": limit,
+        "over": None if limit is None else total - limit,
+    }
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="aidetect count",
+                                 description="IB-rules word count for a draft.")
+    ap.add_argument("path", help=".docx file to count")
+    ap.add_argument("--limit", type=int, default=None,
+                    help="word limit to measure against (e.g. 4000 for the EE)")
+    ap.add_argument("--json", action="store_true",
+                    help="emit one JSON object on stdout instead of the table")
+    args = ap.parse_args(argv)
+
+    if not args.path.lower().endswith(".docx"):
+        ap.error("count needs a .docx (a .txt has no headings or styles to go on)")
+
+    sections, total = count_docx(args.path)
+
+    if args.json:
+        print(json.dumps(as_json(sections, total, args.limit)))
+        return
+    if not sections:
+        print("No prose found. Check the file is a draft and not an outline.")
+        return
+    report(sections, total, args.limit)

aidetect/detect.py

@@ -0,0 +1,121 @@
+"""
+Local AI-writing detector for my drafts.
+
+Scores each paragraph of a .docx (or a .txt / --text string) with the
+desklib DeBERTa detector. Everything runs on my Mac, offline after the
+first model download. The score is a rough, directional read, NOT Turnitin:
+high just means "this paragraph reads AI-ish, maybe reword it".
+
+Usage:
+    aidetect score path/to/draft.docx
+    aidetect score notes.txt
+    aidetect score --text "some sentence to score"
+"""
+
+import argparse
+
+import torch
+import torch.nn as nn
+from transformers import AutoTokenizer, AutoConfig, AutoModel, PreTrainedModel
+
+from .text import MIN_WORDS, bar, read_paragraphs
+
+MODEL_ID = "desklib/ai-text-detector-v1.01"
+MAX_LEN = 768          # model's token window; longer paragraphs get truncated
+
+
+# --- the model class, copied verbatim from the desklib model card ---
+# It's a normal transformer with mean-pooling + a 1-unit classifier head.
+class DesklibAIDetectionModel(PreTrainedModel):
+    config_class = AutoConfig
+    # transformers 5.x reads this during from_pretrained; the model has no tied
+    # weights (encoder + linear head), so an empty mapping is correct. Without it,
+    # loading raises AttributeError on 5.x. ponytail: needed once mlx pulled 5.x in.
+    all_tied_weights_keys = {}
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.model = AutoModel.from_config(config)
+        self.classifier = nn.Linear(config.hidden_size, 1)
+        self.init_weights()
+
+    def forward(self, input_ids, attention_mask=None, labels=None):
+        outputs = self.model(input_ids, attention_mask=attention_mask)
+        last_hidden_state = outputs[0]
+        # mean-pool the token vectors, ignoring padding
+        mask = attention_mask.unsqueeze(-1).expand(last_hidden_state.size()).float()
+        summed = torch.sum(last_hidden_state * mask, dim=1)
+        counts = torch.clamp(mask.sum(dim=1), min=1e-9)
+        pooled = summed / counts
+        logits = self.classifier(pooled)
+        return {"logits": logits}
+
+
+def pick_device():
+    if torch.backends.mps.is_available():
+        return torch.device("mps")   # Apple Silicon GPU
+    return torch.device("cpu")
+
+
+def load_model(device):
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+    model = DesklibAIDetectionModel.from_pretrained(MODEL_ID)
+    model.to(device)
+    model.eval()
+    return tokenizer, model
+
+
+def score_text(text, tokenizer, model, device):
+    """Return P(AI-generated) in [0, 1] for one chunk of text."""
+    encoded = tokenizer(
+        text,
+        padding="max_length",
+        truncation=True,
+        max_length=MAX_LEN,
+        return_tensors="pt",
+    )
+    input_ids = encoded["input_ids"].to(device)
+    attention_mask = encoded["attention_mask"].to(device)
+    with torch.no_grad():
+        logits = model(input_ids=input_ids, attention_mask=attention_mask)["logits"]
+        return torch.sigmoid(logits).item()
+
+
+def report(paragraphs, tokenizer, model, device):
+    if not paragraphs:
+        print("No paragraphs with >= %d words found." % MIN_WORDS)
+        return
+    scores = []
+    for i, para in enumerate(paragraphs, 1):
+        prob = score_text(para, tokenizer, model, device)
+        scores.append(prob)
+        flag = "  <-- AI-ish" if prob >= 0.5 else ""
+        preview = para[:70].replace("\n", " ")
+        print(f"P{i:>3}  {prob:5.2f}  [{bar(prob)}]{flag}")
+        print(f"      {preview}...")
+    avg = sum(scores) / len(scores)
+    high = sum(1 for s in scores if s >= 0.5)
+    print("-" * 60)
+    print(f"average AI score: {avg:.2f}   |   {high}/{len(scores)} paragraphs flagged")
+    print("reminder: directional only, not a Turnitin score.")
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="aidetect score",
+                                 description="Local AI-writing detector (desklib).")
+    ap.add_argument("path", nargs="?", help=".docx or .txt file to score")
+    ap.add_argument("--text", help="score a single string instead of a file")
+    args = ap.parse_args(argv)
+
+    if not args.path and not args.text:
+        ap.error("give a file path or --text")
+
+    device = pick_device()
+    print(f"loading {MODEL_ID} on {device}... (first run downloads ~1.5GB)")
+    tokenizer, model = load_model(device)
+
+    if args.text:
+        prob = score_text(args.text, tokenizer, model, device)
+        print(f"AI score: {prob:.2f}  [{bar(prob)}]")
+    else:
+        report(read_paragraphs(args.path), tokenizer, model, device)

aidetect/extract.py

@@ -0,0 +1,40 @@
+"""
+Pull just the finished PROSE out of a .docx into a clean .txt, so the
+detector scores real writing instead of headings, bullets and note-scaffolding.
+
+Drops: headings, cover/TOC lines, footnotes (python-docx never reads those),
+tables (also not in doc.paragraphs), bullet lines, and my note-labels
+(NOTES / Verdict / Analysis: / Criticism / Mini-conclusion ...).
+
+    aidetect extract "in.docx" out.txt
+"""
+
+import argparse
+
+import docx
+
+from .text import MIN_WORDS, is_end_heading, is_prose
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="aidetect extract",
+                                 description="Extract finished prose from a .docx.")
+    ap.add_argument("in_path", help="source .docx")
+    ap.add_argument("out_path", help="destination .txt")
+    args = ap.parse_args(argv)
+
+    doc = docx.Document(args.in_path)
+    prose = []
+    for p in doc.paragraphs:
+        # Bibliography is the last section; once its heading shows up, the rest
+        # is citations, not prose. Stop here.
+        if is_end_heading(p):
+            break
+        if is_prose(p, min_words=MIN_WORDS):
+            prose.append(p.text.strip())
+    with open(args.out_path, "w", encoding="utf-8") as f:
+        f.write("\n\n".join(prose))
+    words = sum(len(p.split()) for p in prose)
+    print(f"kept {len(prose)} paragraphs, {words} words -> {args.out_path}")
+    print("note: this is the detector's prose filter, not an IB count. "
+          "Use `aidetect count` for that.")

aidetect/paths.py

@@ -0,0 +1,32 @@
+"""
+Where thresholds live.
+
+Two locations, checked in this order:
+  1. ~/.config/aidetect/threshold-<tag>.json — what `aidetect calibrate` writes.
+  2. the thresholds/ folder inside the installed package — the ones shipped.
+
+The package folder is read-only in spirit (it is site-packages on an install and
+gets replaced on upgrade), so calibration output never goes there.
+"""
+
+import os
+from importlib import resources
+
+USER_DIR = os.path.expanduser("~/.config/aidetect")
+
+
+def user_threshold_path(tag):
+    return os.path.join(USER_DIR, f"threshold-{tag}.json")
+
+
+def threshold_path(tag):
+    """Path to the shipped threshold for this pair, or None if there isn't one."""
+    ref = resources.files("aidetect") / "thresholds" / f"threshold-{tag}.json"
+    # as_file would be needed for a zipped install; these are always unpacked
+    # because the wheel has no zip-safe flag, so a plain path is fine.
+    return str(ref) if ref.is_file() else None
+
+
+def ensure_user_dir():
+    os.makedirs(USER_DIR, exist_ok=True)
+    return USER_DIR

aidetect/text.py

@@ -0,0 +1,64 @@
+"""
+Reading prose out of .docx and .txt files. No torch in here on purpose:
+`aidetect count` uses this module and should not pay a model import to count words.
+"""
+
+MIN_WORDS = 25   # ponytail: skip fragments; short text scores as noise
+
+# Lines that begin with any of these are note-scaffolding, not prose.
+NOTE_STARTS = (
+    "NOTES", "Verdict", "Analysis:", "Criticism", "Mini-conclusion",
+    "Tool definition", "Why chosen", "Overall synthesis", "Force =",
+    "POINTS", "Safest", "Moderate", "Research Question", "Word count",
+    "Table of Contents",
+)
+# ponytail: prefix heuristic, not a parser. If a real sentence ever starts
+# with one of these words it gets dropped too — check the output if a section vanishes.
+
+# Headings that mean "the prose is over, the rest is citations".
+END_HEADINGS = ("bibliography", "works cited", "references")
+
+
+def is_heading(p):
+    return p.style.name.startswith("Heading")
+
+
+def is_end_heading(p):
+    return is_heading(p) and p.text.strip().lower() in END_HEADINGS
+
+
+def is_prose(p, min_words=MIN_WORDS):
+    """True if this python-docx paragraph is finished prose, not scaffolding.
+
+    Tables and footnotes need no handling here: doc.paragraphs excludes table
+    cells, and python-docx never exposes footnotes at all. IB excludes both.
+    """
+    text = p.text.strip()
+    if len(text.split()) < min_words:
+        return False
+    if is_heading(p):
+        return False
+    if text[0] in "•-*“\"[»":               # bullet, quoted snippet, or [SCAFFOLD]/» note marker
+        return False
+    if text.startswith(NOTE_STARTS):
+        return False
+    return True
+
+
+def read_paragraphs(path, min_words=MIN_WORDS):
+    """Pull prose paragraphs out of a .docx or .txt file."""
+    if path.lower().endswith(".docx"):
+        import docx  # python-docx, only needed for Word files
+        doc = docx.Document(path)
+        chunks = [p.text for p in doc.paragraphs]
+    else:
+        with open(path, encoding="utf-8") as f:
+            # blank line separates paragraphs in a plain-text file
+            chunks = f.read().split("\n\n")
+    # keep only real paragraphs, not headings/blanks/fragments
+    return [c.strip() for c in chunks if len(c.split()) >= min_words]
+
+
+def bar(prob, width=20):
+    filled = round(prob * width)
+    return "#" * filled + "-" * (width - filled)

aidetect/thresholds/threshold-big.json

@@ -0,0 +1,12 @@
+{
+  "pair": [
+    "Qwen/Qwen2.5-1.5B",
+    "Qwen/Qwen2.5-1.5B-Instruct"
+  ],
+  "threshold": 0.9777,
+  "accuracy": 0.6667,
+  "n_human": 12,
+  "n_ai": 12,
+  "human_mean": 1.0185,
+  "ai_mean": 0.9891
+}

aidetect/thresholds/threshold-gemma-mlx.json

@@ -0,0 +1,13 @@
+{
+  "pair": [
+    "google/gemma-4-E2B",
+    "mlx-community/gemma-4-e2b-it-qat-OptiQ-4bit"
+  ],
+  "backend": "mlx",
+  "threshold": 0.8264,
+  "accuracy": 0.9583,
+  "n_human": 12,
+  "n_ai": 12,
+  "human_mean": 0.9005,
+  "ai_mean": 0.7126
+}

aidetect/thresholds/threshold-small.json

@@ -0,0 +1,12 @@
+{
+  "pair": [
+    "Qwen/Qwen2.5-0.5B",
+    "Qwen/Qwen2.5-0.5B-Instruct"
+  ],
+  "threshold": 0.9662,
+  "accuracy": 0.625,
+  "n_human": 12,
+  "n_ai": 12,
+  "human_mean": 1.0024,
+  "ai_mean": 0.9962
+}

aidetect-0.1.0.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.5
+Name: aidetect
+Version: 0.1.0
+Summary: Local, offline AI-writing detector and IB word counter for your own drafts
+Project-URL: Homepage, https://github.com/nitrimandylis/aidetect
+Project-URL: Source, https://github.com/nitrimandylis/aidetect
+Author: Nikolas Trimandylis
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-detection,binoculars,docx,ib,word-count
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Requires-Dist: mlx-vlm; sys_platform == 'darwin' and platform_machine == 'arm64'
+Requires-Dist: python-docx
+Requires-Dist: torch
+Requires-Dist: transformers
+Description-Content-Type: text/markdown
+
+```
+ █████╗ ██╗      ██████╗ ███████╗████████╗███████╗ ██████╗████████╗
+██╔══██╗██║      ██╔══██╗██╔════╝╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝
+███████║██║█████╗██║  ██║█████╗     ██║   █████╗  ██║        ██║
+██╔══██║██║╚════╝██║  ██║██╔══╝     ██║   ██╔══╝  ██║        ██║
+██║  ██║██║      ██████╔╝███████╗   ██║   ███████╗╚██████╗   ██║
+╚═╝  ╚═╝╚═╝      ╚═════╝ ╚══════╝   ╚═╝   ╚══════╝ ╚═════╝   ╚═╝
+```
+<div align="center">
+
+### `SCORE YOUR OWN PROSE // BEFORE A TEACHER SCORES IT FOR YOU`
+
+*a local, offline AI-writing detector and IB word counter for drafts you actually wrote*
+
+![pypi](https://img.shields.io/badge/pypi-aidetect-3775A9?style=flat-square&labelColor=111111)
+![language](https://img.shields.io/badge/language-python-3776AB?style=flat-square&labelColor=111111)
+![runs](https://img.shields.io/badge/runs-offline-2ea043?style=flat-square&labelColor=111111)
+![model](https://img.shields.io/badge/model-desklib_DeBERTa-8957e5?style=flat-square&labelColor=111111)
+![license](https://img.shields.io/badge/license-MIT-2ea043?style=flat-square&labelColor=111111)
+![telemetry](https://img.shields.io/badge/telemetry-0_(it's_your_essay)-111111?style=flat-square&labelColor=111111)
+
+</div>
+
+---
+
+## 🔍 What is this
+
+A command-line tool that reads a `.docx` or `.txt` and scores each paragraph
+0–1 on how AI-generated it reads, using the `desklib/ai-text-detector-v1.01`
+DeBERTa model — the one sitting at #1 on the RAID benchmark. Everything runs
+on your own machine; after the first model download it never touches the
+network. You point it at your Extended Essay, it tells you which paragraphs
+sound like a language model wrote them.
+
+The point isn't to cheat a detector. It's the opposite: I write my own drafts,
+and sometimes my own honest prose still trips these classifiers because that's
+what earnest formal writing looks like to them. This flags those paragraphs so
+I can reword before a teacher runs Turnitin and has an awkward conversation
+with me about it.
+
+It is directional, not oracular. A high score means "reword this," not "you're
+caught." It is not, and cannot be, the number Turnitin shows a teacher.
+
+```console
+nick@aidetect:~$ aidetect score EE-clean.txt
+P  1   0.08  [##------------------]
+P  2   0.71  [##############------]  <-- AI-ish
+average AI score: 0.34   |   1/6 paragraphs flagged
+reminder: directional only, not a Turnitin score.
+```
+
+## 🧠 The detection engine
+
+| | feature | what it actually does |
+|---|---|---|
+| 01 | **per-paragraph scoring** | what it actually catches — splits your draft and scores each paragraph, so you fix the two bad ones instead of rewriting everything |
+| 02 | **docx + txt input** | reads Word files straight (paragraphs, no headings) or plain text split on blank lines |
+| 03 | **prose extractor** | `aidetect extract` strips headings, bullets, footnotes and your own note-scaffolding first, so the score is about writing, not structure |
+| 04 | **offline after setup** | first run pulls ~1.5GB of model, every run after is airgapped — your essay never leaves the laptop |
+| 05 | **second opinion** | cross-check against the lighter [Ejhfast/fast-ai-detector] when one model's paranoia isn't enough |
+| 06 | **Binoculars (Gemma 4)** | a training-free perplexity-ratio detector — near chance with small Qwen pairs, but 96% on the labelled set once swapped to a Gemma 4 pair; see below |
+| 07 | **IB word count** | `aidetect count` (`--json` for scripts and agents) counts what the IB counts — no headings, quotes, tables, footnotes, citations or bibliography — and splits the total by section, so an over-long draft tells you *where* |
+
+## 🚀 Run it
+
+```bash
+uv tool install aidetect      # or: pipx install aidetect
+```
+
+```bash
+aidetect                                   # list the five subcommands
+aidetect count "draft.docx" --limit 4000   # IB word count, by section
+aidetect count "draft.docx" --json         # same, as one JSON object
+aidetect score "draft.docx"                # score a whole draft
+aidetect score --text "one sentence"       # score a single string
+aidetect bino  "draft.docx" --mlx --pair gemma
+```
+
+`count` and `extract` are instant and need no model. `score` and `bino` need a
+machine that can hold a transformer: built and tested on an 18GB Apple Silicon
+Mac, MPS-accelerated. Their first run downloads the model and will sit there for
+a minute — that's normal, not a hang. Every run after is fast and offline.
+
+On Apple Silicon the Gemma 4 MLX pair installs automatically. Elsewhere it is
+skipped and the Qwen pairs still work.
+
+### `--json`
+
+`count` takes `--json` and prints exactly one object on stdout, nothing else:
+
+```json
+{"sections": [{"title": "Introduction", "words": 812}], "total": 3940, "limit": 4000, "over": -60}
+```
+
+Every key is always present. `limit` and `over` are `null` when no `--limit` was
+given — that means "does not apply", not "could not be read". A draft with no
+prose is an empty `sections` list and exit 0. Errors go to stderr with a non-zero
+exit, so consumers branch on the exit code rather than parsing error text.
+
+## 🔩 Under the hood
+
+```mermaid
+flowchart LR
+    A[.docx / .txt] --> B[aidetect extract<br/>strip non-prose]
+    B --> C[read_paragraphs<br/>>= 25 words]
+    C --> D[desklib DeBERTa<br/>mean-pool + sigmoid]
+    D --> E[per-paragraph<br/>0-1 score + flags]
+```
+
+| file | job |
+|---|---|
+| `src/aidetect/cli.py` | the `aidetect` entry point — dispatches subcommands, importing each lazily so `count` never loads torch |
+| `src/aidetect/text.py` | shared, torch-free: what counts as prose, what ends a document, how a `.docx` is read |
+| `src/aidetect/count.py` | the IB word count — sections, citation stripping, budget |
+| `src/aidetect/detect.py` | loads the desklib model, scores each paragraph, prints the bars and flags |
+| `src/aidetect/extract.py` | pulls clean prose out of a `.docx` into a `.txt` — drops headings, bullets, note-labels |
+| `src/aidetect/binoculars.py` | training-free perplexity-ratio scorer over a base+instruct LM pair (Qwen, or Gemma 4 via `--mlx`; see below) |
+| `src/aidetect/calibrate.py` | fits a threshold on a labelled set you supply, saves it to `~/.config/aidetect` |
+| `src/aidetect/paths.py` | where thresholds are looked up — `~/.config/aidetect` first, then the ones in the package |
+| `src/aidetect/thresholds/` | the thresholds shipped with the package; a threshold you fit yourself wins over these |
+| `corpora/` | my labelled calibration sets. Repo-only, deliberately not shipped in the package |
+| `tests/` | count rules and Binoculars math, both self-checking, no model download |
+| `pyproject.toml` | package metadata and dependencies — torch · transformers · python-docx, plus mlx-vlm on Apple Silicon |
+
+## 🔭 Binoculars: shelved, then revived by Gemma 4
+
+[Binoculars](https://arxiv.org/abs/2401.12070) is a training-free detector: run
+text through two LMs that share a tokenizer (a base "observer" and an instruct
+"performer") and divide perplexity by cross-perplexity. Its designed model pair
+is Falcon-7B ×2 (~28GB) — too big for an 18GB Mac, so the fallback was a small
+same-family pair (Qwen2.5-0.5B or 1.5B) that fits.
+
+`aidetect calibrate` scores a labelled set — mine is 12 real pre-2020 IB Extended
+Essay paragraphs vs 12 LLM-written ones on the same topics — and finds the best
+separating threshold. Measured across pairs:
+
+| pair | best separation | chance |
+|---|---|---|
+| Qwen2.5-0.5B | 62% | 50% |
+| Qwen2.5-1.5B | 67% | 50% |
+| **Gemma 4 E2B** | **96%** | 50% |
+
+The Qwen pairs sit near a coin flip: their human and AI score clusters almost
+completely overlap, because the perplexity gap Binoculars exploits is sharp in
+larger models and mush in sub-2B ones. That was the original negative result.
+Swapping in a **Gemma 4** pair opens a clean gap (human mean 0.90 vs AI 0.71)
+and separates the set at 96%. Gemma 4 ships as a multimodal checkpoint, so
+`--mlx` quantizes it to 4-bit and runs it text-only through
+[mlx-vlm](https://github.com/Blaizzy/mlx-vlm), fitting the 18GB Mac in ~6GB:
+
+```bash
+aidetect bino IA-clean.txt --mlx --pair gemma   # uses the shipped threshold
+
+# refit the threshold on your own labelled set
+aidetect calibrate --human-dir corpora/human --ai-dir corpora/ai --mlx --pair gemma
+```
+
+desklib stays the primary detector; Binoculars is now a usable second opinion
+rather than a dead end. The calibration sets are not shipped with the package —
+clone the repo to reproduce the numbers, or point `--human-dir`/`--ai-dir` at
+your own. Your fitted threshold lands in `~/.config/aidetect` and takes
+precedence over the shipped one, so it survives an upgrade.
+
+## 🧪 The peer set: genre context, not a human class
+
+The 12 human samples are Extended Essays: English, History, Biology, Physics,
+Philosophy. A CS IA is a different animal, all database schemas, GUI components and
+method-by-method justification, and technical prose is inherently more
+predictable token-by-token, which drags perplexity-ratio scores down no matter
+who typed it. So a CS IA scoring below the EE human mean means less than it
+looks.
+
+`corpora/peer/` holds 12 paragraphs of real IB Computer Science IA prose
+(5 projects, 5 authors: sudokuMaster, IBOrganizer, MyCalendar, and two
+IBO-published new-syllabus specimens). Measured against the same anchors:
+
+| set | Binoculars mean | desklib mean |
+|---|---|---|
+| human (2008 EEs, verified pre-2020) | **0.90** | n/a |
+| **peer (CS IAs, 2021–2025)** | **0.85** | **0.46** |
+| ai (LLM-written, matched topics) | **0.71** | n/a |
+
+The genre gap is real and it is about 0.05 on Binoculars. Score your IA against
+`peer`, not against `human`.
+
+**It is not a human class and it never fits a threshold.** Every source
+postdates ChatGPT; three of the five were written in 2025. None carries an
+authorship attestation, and in 2025 a fair share of student IAs were not
+written unaided. Fold that into `human/` and any AI-assisted sample drags the
+mean down, lowers the threshold, and the tool starts clearing drafts for the
+wrong reason, a detector that reassures instead of measures. `aidetect calibrate`
+reads only the two folders you name, so `peer/` stays out of threshold fitting
+by construction, not by discipline.
+
+What it can tell you: *"my prose scores like other IAs in this genre."* What it
+can never tell you: *"my prose is human."* Matching a set you cannot vouch for
+proves you are not an outlier, nothing more.
+
+**Stack:** python · pytorch · transformers · mlx-vlm · desklib DeBERTa
+
+The lighter cross-check tool lives at [Ejhfast/fast-ai-detector] — it's a
+separate repo, not vendored here.
+
+---
+
+<div align="center">
+
+**[Nick Trimandylis](https://github.com/nitrimandylis)**
+
+`I WRITE MY OWN ESSAYS — THIS JUST CHECKS THEY STILL READ LIKE IT`
+
+MIT licensed — see [LICENSE](LICENSE).
+
+</div>
+
+[Ejhfast/fast-ai-detector]: https://github.com/Ejhfast/fast-ai-detector

aidetect-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+aidetect/__init__.py,sha256=JmB2DMVDsV7YJ9mWFRPMCM9gryATeppjQdyT6cPzibk,77
+aidetect/binoculars.py,sha256=eParkZIjAfHy0EgcO00-Pz28c1pQiXKW0Lwx4eEWNno,11140
+aidetect/calibrate.py,sha256=gmwM9P9sCdS2y3obMmANqnNbP5Lzdz-gs--X5t6U5cY,5524
+aidetect/cli.py,sha256=PZo5Y-guqI5GZdv1iU3ff484A6Oc0vlXS8A1zj_mVVo,1597
+aidetect/count.py,sha256=_2DfSk-8laIk6UBUWEmyRZCQmA8gJa6IVdwv9Wv6nNo,4556
+aidetect/detect.py,sha256=sRTQbD4wrdR_Ok9xk3Vhm_2mwBwyev9I9zeg-Y-Cl6Y,4463
+aidetect/extract.py,sha256=hLUFXfErkk5sEG2BhkX9hmfRs6WHsAkDAGaMbDtV3Vw,1480
+aidetect/paths.py,sha256=4mfijCfA-fmJ_vsRUyovAxrVvew6dTxjVkELafwGCWA,1039
+aidetect/text.py,sha256=WMhP9Jyo_7tSw9bNb3OXUQZHqa-9IP4iCgSjSuOOcNE,2329
+aidetect/thresholds/threshold-big.json,sha256=zUbg8AkNJWTzoadrPb7gEf5f1S3emg67IAlTR8CtKdU,198
+aidetect/thresholds/threshold-gemma-mlx.json,sha256=uAr1cH4uYTVuAamNqJ9H9E6qBqgwFJA1UKkdr42RQXo,236
+aidetect/thresholds/threshold-small.json,sha256=WE53N5jJ-hTYlMXlXIxy9TUwUgVdp-FxHEiHAdUp3Fs,197
+aidetect-0.1.0.dist-info/METADATA,sha256=EZK2F3iue1rUmE_uEv1NvmnHpgzSgE66ecLqbUiKxw4,12235
+aidetect-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+aidetect-0.1.0.dist-info/entry_points.txt,sha256=1ZHejHnZZ8c5gbi8KGxzgtSx8TUqCqy9ARhamI9KJVg,47
+aidetect-0.1.0.dist-info/licenses/LICENSE,sha256=wMe8eI4xhFhIOGRWTFaIq0mTgeCpY099f91fHxofxCI,1073
+aidetect-0.1.0.dist-info/RECORD,,

aidetect-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

aidetect-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aidetect = aidetect.cli:main

aidetect-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nick Trimandylis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.