Ghostwriting Voice skill for Codex

Gives the Codex app a display name, a one-line description and a starter prompt for this skill.

interface:
  display_name: "Ghostwriting Voice"
  short_description: "Sound like the author, from their own samples"
  default_prompt: "$ghostwriting-voice Write a LinkedIn post in my voice from these notes; my past posts are in voice/samples"

#!/usr/bin/env python3
"""Measure the style of writing samples and compare a draft against them.

Prints a voice profile (sentence and paragraph length, contractions, pronouns,
punctuation habits, readability, favourite sentence openers and phrases) and, with
--compare, flags where a draft falls outside the range seen across the samples.
Standard library only.

Usage:
  python3 voice_profile.py SAMPLE [SAMPLE ...]
  python3 voice_profile.py samples/*.md --compare draft.md [--json profile.json]

Exit code: 0 ok (or draft within range), 1 draft has metrics out of range, 2 bad input.
"""
from __future__ import annotations

import argparse
import json
import math
import re
import statistics
import sys
from collections import Counter
from pathlib import Path

STOP = set("""a an the and or but if of to in on at by for with from as is are was were be been being
it its this that these those i me my we our you your he she they them their his her not no so do does
did have has had will would can could should may might just than then there here what which who whom
about into over under also very more most some any all each one two up out how when where why""".split())
# 's counts only after pronouns and function words, so possessives ("today's") do not
CONTRACTION = re.compile(
    r"\b(?:\w+n['\u2019]t|\w+['\u2019](?:re|ve|ll|d|m)"
    r"|(?:it|that|here|there|what|who|where|he|she|let|how)['\u2019]s)\b",
    re.I,
)
WORD = re.compile(r"[A-Za-z]+(?:['’][A-Za-z]+)?")
SENT_SPLIT = re.compile(r"(?<=[.!?])[\"')”\]]*\s+(?=[\"'(“\[]?[A-Z0-9])")
EMOJI = re.compile("[\U0001F300-\U0001FAFF☀-➿]")


def clean(text: str) -> str:
    text = re.sub(r"\A---\n.*?\n---\n", "", text, flags=re.S)       # frontmatter
    text = re.sub(r"```.*?```", "", text, flags=re.S)                # code blocks
    text = re.sub(r"!\[[^\]]*\]\([^)]*\)", "", text)                  # images
    text = re.sub(r"\[([^\]]*)\]\([^)]*\)", r"\1", text)              # links -> text
    text = re.sub(r"https?://\S+", "", text)
    return text


def syllables(word: str) -> int:
    w = word.lower().strip("'")
    if len(w) <= 3:
        return 1
    w = re.sub(r"(?:[^laeiouy]es|ed|[^laeiouy]e)$", "", w)
    w = re.sub(r"^y", "", w)
    return max(1, len(re.findall(r"[aeiouy]{1,2}", w)))


def profile(text: str) -> dict:
    text = clean(text)
    paras = [p.strip() for p in re.split(r"\n\s*\n", text) if p.strip()]
    bullets = sum(1 for line in text.splitlines() if re.match(r"\s*([-*+]|\d+[.)])\s+", line))
    prose = " ".join(p for p in paras if not p.lstrip().startswith(("#", "|")))
    sentences = [s.strip() for s in SENT_SPLIT.split(prose) if len(WORD.findall(s)) >= 2]
    words = WORD.findall(prose)
    n = max(1, len(words))
    per_k = lambda count: round(1000 * count / n, 2)  # noqa: E731
    sent_lens = [len(WORD.findall(s)) for s in sentences] or [0]
    para_lens = [len(WORD.findall(p)) for p in paras] or [0]
    lower = [w.lower() for w in words]
    syl = sum(syllables(w) for w in words)
    flesch = 206.835 - 1.015 * (n / max(1, len(sentences))) - 84.6 * (syl / n)
    openers = Counter(WORD.findall(s)[0].lower() for s in sentences if WORD.findall(s))
    bigrams = Counter(
        f"{a} {b}" for a, b in zip(lower, lower[1:]) if a not in STOP or b not in STOP
    )
    content = Counter(w for w in lower if w not in STOP and len(w) > 3)
    return {
        "words": len(words),
        "sentences": len(sentences),
        "sentence_len_mean": round(statistics.mean(sent_lens), 1),
        "sentence_len_median": statistics.median(sent_lens),
        "sentence_len_p90": sorted(sent_lens)[max(0, math.ceil(0.9 * len(sent_lens)) - 1)],
        "short_sentences_pct": round(100 * sum(1 for x in sent_lens if x <= 6) / max(1, len(sent_lens)), 1),
        "paragraph_len_mean": round(statistics.mean(para_lens), 1),
        "bullets_per_1k": per_k(bullets),
        "contractions_per_1k": per_k(len(CONTRACTION.findall(prose))),
        "i_per_1k": per_k(sum(1 for w in lower if w in ("i", "i'm", "i've", "i'd", "i'll", "me", "my"))),
        "we_per_1k": per_k(sum(1 for w in lower if w in ("we", "we're", "we've", "our", "us"))),
        "you_per_1k": per_k(sum(1 for w in lower if w in ("you", "you're", "your", "you've", "you'll"))),
        "questions_per_1k": per_k(prose.count("?")),
        "exclamations_per_1k": per_k(prose.count("!")),
        "em_dashes_per_1k": per_k(prose.count("—") + prose.count(" -- ") + prose.count(" - ")),
        "semicolons_per_1k": per_k(prose.count(";")),
        "colons_per_1k": per_k(prose.count(":")),
        "parentheses_per_1k": per_k(prose.count("(")),
        "ly_adverbs_per_1k": per_k(sum(1 for w in lower if w.endswith("ly") and len(w) > 4)),
        "emoji_per_1k": per_k(len(EMOJI.findall(text))),
        "avg_word_len": round(sum(len(w) for w in words) / n, 2),
        "flesch_reading_ease": round(flesch, 1),
        "top_openers": [w for w, _ in openers.most_common(8)],
        "top_phrases": [p for p, c in bigrams.most_common(12) if c > 1],
        "top_words": [w for w, _ in content.most_common(15)],
    }


NUMERIC_SKIP = {"words", "sentences"}


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("samples", nargs="+", type=Path)
    ap.add_argument("--compare", type=Path, help="draft to check against the samples")
    ap.add_argument("--json", type=Path, help="write the profile as JSON")
    ap.add_argument("--tolerance", type=float, default=0.25, help="slack beyond sample range (fraction, default 0.25)")
    args = ap.parse_args()

    texts = []
    for p in args.samples:
        if not p.is_file():
            print(f"error: {p} not found", file=sys.stderr)
            return 2
        texts.append(p.read_text(encoding="utf-8", errors="replace"))
    per_sample = [profile(t) for t in texts]
    combined = profile("\n\n".join(texts))
    if combined["words"] < 300:
        print(f"warning: only {combined['words']} words of samples; 1,500+ gives a stable profile\n")

    print(f"Voice profile from {len(texts)} sample(s), {combined['words']} words\n")
    for k, v in combined.items():
        if isinstance(v, list):
            print(f"  {k:24} {', '.join(v)}")
        elif k not in NUMERIC_SKIP:
            lo = min(s[k] for s in per_sample)
            hi = max(s[k] for s in per_sample)
            rng = f"  (samples {lo}-{hi})" if len(per_sample) > 1 else ""
            print(f"  {k:24} {v}{rng}")

    out = {"combined": combined, "per_sample": per_sample}
    status = 0
    if args.compare:
        if not args.compare.is_file():
            print(f"error: {args.compare} not found", file=sys.stderr)
            return 2
        draft = profile(args.compare.read_text(encoding="utf-8", errors="replace"))
        out["draft"] = draft
        print(f"\nDraft {args.compare} ({draft['words']} words) vs samples:")
        flagged = 0
        for k, v in draft.items():
            if isinstance(v, list) or k in NUMERIC_SKIP:
                continue
            vals = [s[k] for s in per_sample] + [combined[k]]
            lo, hi = min(vals), max(vals)
            span = max(hi - lo, abs(combined[k]) * 0.2, 0.5)
            if v < lo - args.tolerance * span or v > hi + args.tolerance * span:
                flagged += 1
                direction = "higher" if v > hi else "lower"
                print(f"  OFF   {k:24} {v}  ({direction} than samples {lo}-{hi})")
            else:
                print(f"  ok    {k:24} {v}")
        shared = set(draft["top_phrases"]) & set(combined["top_phrases"])
        print(f"\n  shared signature phrases: {', '.join(sorted(shared)) or 'none'}")
        print(f"\n{flagged} metric(s) out of range")
        status = 1 if flagged else 0

    if args.json:
        args.json.write_text(json.dumps(out, indent=2), encoding="utf-8")
        print(f"\nJSON written to {args.json}")
    return status


if __name__ == "__main__":
    sys.exit(main())