flowchart TD
  A[Global hotkey chord] -->|Hammerspoon| B[record.sh]
  B -->|sox records mic| C[recording.wav]
  C -->|whisper.cpp transcribes| D[Clipboard]
  D -->|auto Cmd+V| E[Text at your cursor]
 
  F[Select text + hotkey] -->|Shortcuts Quick Action| G[rewrite.sh]
  G -->|local LLM via Ollama| H[Clipboard]
  H -->|you press Cmd+V| I[Rewritten text]

brew --version
git --version
python3 --version

mkdir -p ~/bin

brew install sox whisper-cpp

mkdir -p ~/.whisper-models
curl -L -o ~/.whisper-models/ggml-large-v3-turbo.bin \
  https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin

#!/bin/bash
#
# record.sh — toggle voice recording + local Whisper transcription.
#   1st run: starts recording the microphone to a temp .wav (sox).
#   2nd run: stops recording, transcribes with whisper.cpp, copies text to clipboard.
 
set -uo pipefail
 
# Ensure Homebrew's bin dir is on PATH (Hammerspoon launches with a minimal PATH).
export PATH="/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin:$PATH"
 
MODEL="${WHISPER_MODEL:-$HOME/.whisper-models/ggml-large-v3-turbo.bin}"
WHISPER_BIN="${WHISPER_BIN:-/opt/homebrew/bin/whisper-cli}"
SOX_BIN="${SOX_BIN:-/opt/homebrew/bin/sox}"
 
WORKDIR="/tmp/whisper_dictation"
WAV="$WORKDIR/recording.wav"
LOCK="$WORKDIR/record.pid"
LOGFILE="$WORKDIR/record.log"
 
mkdir -p "$WORKDIR"
log() { echo "$(date '+%H:%M:%S') [record.sh] $*" | tee -a "$LOGFILE" >&2; }
log "=== invoked (lock exists: $([[ -f "$LOCK" ]] && echo yes || echo no)) ==="
 
# Self-heal: a lock whose sox process isn't running is stale — clear it.
if [[ -f "$LOCK" ]]; then
    STALE_PID="$(cat "$LOCK" 2>/dev/null)"
    if ! kill -0 "$STALE_PID" 2>/dev/null; then
        log "Stale lock found (pid $STALE_PID not running) — clearing it."
        rm -f "$LOCK"
    fi
fi
 
# ---- STOP branch: a recording is already in progress ----------------------
if [[ -f "$LOCK" ]]; then
    REC_PID="$(cat "$LOCK")"
    log "Stopping recording (pid $REC_PID)…"
    kill "$REC_PID" 2>/dev/null
    pkill -f "$SOX_BIN -q" 2>/dev/null   # kill any stray recorders
    sleep 0.2
    rm -f "$LOCK"
 
    if [[ ! -s "$WAV" ]]; then
        log "ERROR: no audio was captured ($WAV is empty)."
        echo "STATUS:NOAUDIO"; exit 1
    fi
    if [[ ! -f "$MODEL" ]]; then
        log "ERROR: model not found at $MODEL"; exit 1
    fi
 
    log "Transcribing with whisper.cpp…"
    "$WHISPER_BIN" -m "$MODEL" -f "$WAV" -nt -np -otxt -of "$WORKDIR/out" >/dev/null 2>&1
 
    TXT="$WORKDIR/out.txt"
    if [[ ! -f "$TXT" ]]; then
        log "ERROR: transcription failed (no output file)."
        echo "STATUS:FAILED"; exit 1
    fi
 
    RESULT="$(sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' "$TXT" | sed '/^$/d')"
    printf '%s' "$RESULT" | pbcopy
    log "Done. Copied to clipboard: $RESULT"
    rm -f "$WAV" "$TXT"
    echo "STATUS:TRANSCRIBED"; exit 0
fi
 
# ---- START branch: begin a new recording ----------------------------------
pkill -f "$SOX_BIN -q" 2>/dev/null
rm -f "$WAV"
log "Recording… run this script again to stop."
 
# 16 kHz mono 16-bit is what whisper.cpp expects. -d = default input device.
# Redirect sox's output so it does NOT hold open the pipe Hammerspoon watches.
"$SOX_BIN" -q -d -r 16000 -c 1 -b 16 "$WAV" >>"$LOGFILE" 2>&1 &
SOX_PID=$!
echo "$SOX_PID" > "$LOCK"
 
sleep 0.3
if ! kill -0 "$SOX_PID" 2>/dev/null; then
    log "ERROR: sox failed to start. Mic permission for the launching app?"
    rm -f "$LOCK"; echo "STATUS:NOAUDIO"; exit 1
fi
 
log "Recording started (pid $SOX_PID)."
echo "STATUS:STARTED"; exit 0

chmod +x ~/bin/record.sh

bash ~/bin/record.sh     # speak: "call the async function with a callback"
bash ~/bin/record.sh     # run again to stop + transcribe
pbpaste; echo            # should print your sentence

brew install --cask hammerspoon

-- init.lua — Hammerspoon config for voice dictation.
-- Hold Left Command + Right Option together to toggle recording.
 
local RECORD_SCRIPT = os.getenv("HOME") .. "/bin/record.sh"
local LOCK_FILE = "/tmp/whisper_dictation/record.pid"
local busy = false
 
local function pasteFromClipboard()
    hs.eventtap.keyStroke({ "cmd" }, "v")
end
 
local function isRecording()
    local f = io.open(LOCK_FILE, "r")
    if f then f:close() return true end
    return false
end
 
-- The SCRIPT (via its lock file) is the single source of truth. We show an
-- immediate banner, then update it from the script's reported STATUS line.
local function toggleDictation()
    if busy then return end
    busy = true
    hs.alert.closeAll()
    hs.alert.show(isRecording() and "Transcribing…" or "Recording… (chord again to stop)", 10)
 
    hs.task.new("/bin/bash", function(_exitCode, stdout, _stderr)
        busy = false
        hs.alert.closeAll()
        if stdout:find("STATUS:STARTED") then
            hs.alert.show("Recording… (chord again to stop)", 10)
        elseif stdout:find("STATUS:TRANSCRIBED") then
            hs.timer.doAfter(0.15, function()
                pasteFromClipboard()
                hs.alert.show("Done", 1)
            end)
        elseif stdout:find("STATUS:NOAUDIO") then
            hs.alert.show("No audio captured", 2)
        else
            hs.alert.show("Transcription failed", 2)
        end
    end, { RECORD_SCRIPT }):start()
end
 
-- Left Command = keycode 55, Right Option = keycode 61.
local LEFT_CMD_KEYCODE, RIGHT_OPTION_KEYCODE = 55, 61
local leftCmdDown, rightOptDown, chordActive = false, false, false
 
local function checkChord()
    if leftCmdDown and rightOptDown then
        if not chordActive then chordActive = true; toggleDictation() end
    else
        chordActive = false
    end
end
 
dictationWatcher = hs.eventtap.new({ hs.eventtap.event.types.flagsChanged }, function(e)
    local kc, flags = e:getKeyCode(), e:getFlags()
    if kc == LEFT_CMD_KEYCODE then
        leftCmdDown = flags.cmd == true; checkChord()
    elseif kc == RIGHT_OPTION_KEYCODE then
        rightOptDown = flags.alt == true; checkChord()
    end
    return false
end)
dictationWatcher:start()
 
hs.alert.show("Dictation config loaded (Left Cmd + Right Option)", 1)

brew install ollama
brew services start ollama        # keeps it running across reboots
ollama pull qwen2.5:14b           # ~9 GB; great for rewriting emails & technical text

#!/bin/bash
#
# rewrite.sh — rewrite selected text in a given style using a LOCAL model (Ollama).
#   Usage:  echo "text" | rewrite.sh <style>
#   <style>: professional | longer | shorter | casual | prompt
 
set -uo pipefail
 
LOGFILE="/tmp/rewrite.log"
exec 2>>"$LOGFILE"
echo "=== $(date '+%F %T') invoked style=${1:-} ===" >>"$LOGFILE"
 
export PATH="/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin:$PATH"
 
MODEL="${REWRITE_MODEL:-qwen2.5:14b}"
OLLAMA_URL="${OLLAMA_URL:-http://localhost:11434/api/chat}"
STYLE="${1:-professional}"
 
INPUT="$(cat)"
[[ -z "${INPUT//[[:space:]]/}" ]] && INPUT="$(pbpaste)"
if [[ -z "${INPUT//[[:space:]]/}" ]]; then
    echo "ERROR: no input text." >&2; exit 1
fi
 
case "$STYLE" in
    professional) INSTR="Rewrite the following text in a more professional tone." ;;
    longer)       INSTR="Expand the following text with more detail and explanation, keeping the same meaning and tone." ;;
    shorter)      INSTR="Condense the following text to its essential meaning, as briefly as possible." ;;
    casual)       INSTR="Rewrite the following text in a relaxed, casual, conversational tone." ;;
    prompt)       INSTR="You are a professional prompt engineer. Rewrite the following into a clear, well-structured prompt for an AI assistant: make the instructions precise and unambiguous, specify the desired output and format, and add any obviously helpful context or constraints, while preserving the original intent. Return only the improved prompt." ;;
    *)            INSTR="Rewrite the following text." ;;
esac
 
RESULT="$(OLLAMA_URL="$OLLAMA_URL" REWRITE_MODEL="$MODEL" INSTR="$INSTR" INPUT="$INPUT" python3 <<'PY'
import os, sys, json, urllib.request, urllib.error
url, model = os.environ["OLLAMA_URL"], os.environ["REWRITE_MODEL"]
instr, text = os.environ["INSTR"], os.environ["INPUT"]
system = ("You are a careful text editor. You rewrite the user's text as instructed and "
          "return ONLY the rewritten text — no preamble, no quotes, no explanation.")
body = json.dumps({
    "model": model, "stream": False, "options": {"temperature": 0.4},
    "messages": [{"role": "system", "content": system},
                 {"role": "user", "content": f"{instr}\n\nText:\n{text}"}],
}).encode("utf-8")
req = urllib.request.Request(url, data=body, headers={"content-type": "application/json"})
try:
    with urllib.request.urlopen(req, timeout=120) as resp:
        sys.stdout.write(json.load(resp)["message"]["content"].strip())
except urllib.error.URLError as e:
    sys.stderr.write("Could not reach Ollama (%s). Is it running?\n" % e); sys.exit(1)
except Exception as e:
    sys.stderr.write("Request failed: %s\n" % e); sys.exit(1)
PY
)"
 
[[ -z "$RESULT" ]] && { echo "ERROR: empty response." >&2; exit 1; }
printf '%s' "$RESULT" | pbcopy
printf '%s' "$RESULT"

chmod +x ~/bin/rewrite.sh
echo "hey can u send me that file whenever ur free thx" | ~/bin/rewrite.sh professional
echo "write a function that sorts users by signup date" | ~/bin/rewrite.sh prompt