Skip to content

github/awesome-copilot / skills/speak-summary

speak-summary

Verified

Convert text, markdown, or a summary produced by another skill into a listenable MP3 using local CPU-only neural text-to-speech. Rewrites written prose for the ear before synthesising. Use when the user asks to "read this out", "turn this into audio", "make an MP3", "I want to listen to this", "podcast version", or wants a spoken digest for a commute or breakfast.

FileKindSize
SKILL.mdskill md6.3 KB
scripts/tts.shexecutablescript5.8 KB

scripts/tts.sh

View on GitHub
#!/usr/bin/env bash
# Convert a plain-text briefing into an MP3 using local neural TTS (Kyutai pocket-tts).
#
# Usage: tts.sh <input.txt> <output.mp3> [voice.safetensors]
#
# CPU-only and fully offline after the first model download, so it runs the same
# on an Apple Silicon Mac and in a Linux cloud agent container. No text is sent
# to any cloud TTS service.
#
# Resolution order for the engine:
#   1. pocket-tts already on PATH (e.g. `brew install pocket-tts`)
#   2. a cached venv at $SPEAK_TTS_HOME (default ~/.cache/speak-summary/venv)
#   3. create that venv and `pip install pocket-tts`
# Set SPEAK_TTS_BIN to point at a specific pocket-tts binary to skip all this.
set -euo pipefail

IN="${1:?usage: tts.sh <input.txt> <output.mp3> [voice.safetensors]}"
OUT="${2:?usage: tts.sh <input.txt> <output.mp3> [voice.safetensors]}"
VOICE="${3:-}"

TTS_HOME="${SPEAK_TTS_HOME:-$HOME/.cache/speak-summary/venv}"

# pocket-tts supports Python >=3.10,<3.15. The system python3 is often outside
# that range, so search for a usable interpreter rather than assuming.
find_python() {
  for c in python3.14 python3.13 python3.12 python3.11 python3.10 python3; do
    p="$(command -v "$c" 2>/dev/null)" || continue
    "$p" -c 'import sys; raise SystemExit(0 if (3,10) <= sys.version_info < (3,15) else 1)' 2>/dev/null \
      && { echo "$p"; return 0; }
  done
  return 1
}

resolve_tts() {
  if [ -n "${SPEAK_TTS_BIN:-}" ]; then echo "$SPEAK_TTS_BIN"; return; fi
  if command -v pocket-tts >/dev/null 2>&1; then command -v pocket-tts; return; fi
  if [ -x "$TTS_HOME/bin/pocket-tts" ]; then echo "$TTS_HOME/bin/pocket-tts"; return; fi

  PY="$(find_python)" || {
    cat >&2 <<'MSG'
No suitable Python found. pocket-tts requires Python >=3.10 and <3.15.
Install one (e.g. 'brew install python@3.14' or 'apt-get install -y python3.12-venv'),
or install pocket-tts yourself and point SPEAK_TTS_BIN at the binary.
MSG
    exit 1
  }

  echo "pocket-tts not found; creating a virtualenv at $TTS_HOME using $PY (one-off, a few minutes)..." >&2
  "$PY" -m venv "$TTS_HOME" >&2 || { echo "Failed to create virtualenv (is the venv module installed?)." >&2; exit 1; }
  "$TTS_HOME/bin/pip" install --quiet --upgrade pip >&2
  "$TTS_HOME/bin/pip" install --quiet pocket-tts >&2 || { echo "Failed to install pocket-tts." >&2; exit 1; }
  [ -x "$TTS_HOME/bin/pocket-tts" ] || { echo "pocket-tts install completed but the binary is missing." >&2; exit 1; }
  echo "$TTS_HOME/bin/pocket-tts"
}

TTS="$(resolve_tts)"
[ -x "$TTS" ] || { echo "TTS engine not executable: $TTS" >&2; exit 1; }

# Encoder: prefer ffmpeg; fall back to macOS afconvert (AAC in .m4a) if absent.
ENCODER=""
if command -v ffmpeg >/dev/null 2>&1; then ENCODER="ffmpeg"
elif command -v afconvert >/dev/null 2>&1; then ENCODER="afconvert"
else
  echo "Need ffmpeg to encode audio. Install with 'brew install ffmpeg' or 'apt-get install -y ffmpeg'." >&2
  exit 1
fi

WORK="$(mktemp -d)"
trap 'rm -rf "$WORK"' EXIT

# pocket-tts quality degrades on very long inputs, so split into ~600-char chunks
# on sentence boundaries, synthesise each, then concatenate.
python3 - "$IN" "$WORK" <<'PY'
import re, sys, pathlib
src = pathlib.Path(sys.argv[1]).read_text()
work = pathlib.Path(sys.argv[2])

# Strip markdown that would otherwise be read aloud as noise.
src = re.sub(r'```.*?```', ' ', src, flags=re.S)          # fenced code
src = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', src)        # links -> label
src = re.sub(r'^\s*#{1,6}\s*', '', src, flags=re.M)       # headings
src = re.sub(r'^\s*[-*+]\s+', '', src, flags=re.M)        # bullets
src = re.sub(r'[*_`>|~]+', '', src)                       # emphasis/code/table pipes
src = re.sub(r'https?://\S+', '', src)                    # bare URLs
src = re.sub(r'[ \t]+', ' ', src)
src = re.sub(r'\n{2,}', '\n\n', src).strip()

MAX = 600
chunks, cur = [], ""
for sent in re.split(r'(?<=[.!?])\s+|\n\n', src):
    sent = sent.strip()
    if not sent:
        continue
    # A single sentence longer than MAX is split on commas as a last resort.
    while len(sent) > MAX:
        cut = sent.rfind(',', 0, MAX)
        cut = cut if cut > MAX // 2 else sent.rfind(' ', 0, MAX)
        cut = cut if cut > 0 else MAX
        if cur:
            chunks.append(cur); cur = ""
        chunks.append(sent[:cut].strip())
        sent = sent[cut:].strip(' ,')
    if len(cur) + len(sent) + 1 > MAX:
        if cur:
            chunks.append(cur)
        cur = sent
    else:
        cur = f"{cur} {sent}".strip()
if cur:
    chunks.append(cur)

if not chunks:
    raise SystemExit("No speakable text found in input.")

for i, c in enumerate(chunks):
    (work / f"chunk_{i:04d}.txt").write_text(c)
PY

N=0
for f in "$WORK"/chunk_*.txt; do
  IDX="$(basename "$f" .txt)"
  ARGS=(generate --quiet --text "$(cat "$f")" --output-path "$WORK/$IDX.wav")
  [ -n "$VOICE" ] && ARGS+=(--voice "$VOICE")
  N=$((N+1))
  echo "  synthesising chunk $N ..." >&2
  "$TTS" "${ARGS[@]}" >/dev/null
  echo "file '$WORK/$IDX.wav'" >> "$WORK/list.txt"
done

mkdir -p "$(dirname "$OUT")"

if [ "$ENCODER" = "ffmpeg" ]; then
  ffmpeg -hide_banner -loglevel error -y -f concat -safe 0 -i "$WORK/list.txt" \
    -c:a libmp3lame -b:a 96k -ar 24000 -ac 1 "$OUT"
else
  # afconvert cannot concat, so join the WAVs first, then encode to AAC.
  python3 - "$WORK" "$WORK/joined.wav" <<'PY'
import sys, wave, pathlib
work, out = pathlib.Path(sys.argv[1]), sys.argv[2]
parts = sorted(work.glob("chunk_*.wav"))
with wave.open(parts[0], 'rb') as w0:
    params = w0.getparams()
with wave.open(out, 'wb') as o:
    o.setparams(params)
    for p in parts:
        with wave.open(str(p), 'rb') as w:
            o.writeframes(w.readframes(w.getnframes()))
PY
  OUT="${OUT%.mp3}.m4a"
  afconvert -f m4af -d aac -b 96000 "$WORK/joined.wav" "$OUT"
  echo "Note: ffmpeg not available; wrote AAC (.m4a) instead of MP3." >&2
fi

SIZE="$(du -h "$OUT" | cut -f1)"
echo "Wrote $OUT ($SIZE, $N chunks)"
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 467kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 319kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 319kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 319kUpdated Claude CodeCodexVerifiedInstall