fathom-mcp 0.6.4 → 2.0.1

package/scripts/hook-toast.sh

@@ -1,139 +0,0 @@
-#!/bin/bash
-# hook-toast.sh — tmux status-line notifications for agent hooks.
-#
-# Uses tmux display-message — non-modal, no keyboard stealing.
-# Each toast targets the originating session via -t.
-#
-# Usage:
-#   hook-toast.sh <system> <message>          # show toast for 3s
-#   hook-toast.sh <system> --status <id>      # start a multi-stage toast (persistent)
-#   hook-toast.sh --update <id> <message>     # update a running toast
-#   hook-toast.sh --close <id>                # show final message, then clear
-#
-# Built-in systems: fathom, memento
-#   fathom  → 📝
-#   memento → 🧠
-#
-# Any other system name works too — gets a default 📌 icon.
-#
-# Multi-stage example (PreCompact):
-#   hook-toast.sh memento --status precompact
-#   hook-toast.sh --update precompact "⏳ Getting context..."
-#   hook-toast.sh --update precompact "⏳ Extracting memories..."
-#   hook-toast.sh --update precompact "✓ Stored 7 memories"
-#   hook-toast.sh --close precompact
-
-# Bail silently if not in tmux
-if ! tmux info &>/dev/null; then
-    exit 0
-fi
-
-# Derive session name — used for -t targeting
-SESSION=$(tmux display-message -p '#{session_name}' 2>/dev/null)
-if [ -z "$SESSION" ]; then
-    exit 0
-fi
-
-TOAST_DIR="/tmp/hook-toast/${SESSION}"
-mkdir -p "$TOAST_DIR"
-
-get_icon() {
-    case "$1" in
-        memento) echo "🧠" ;;
-        fathom)  echo "📝" ;;
-        *)       echo "📌" ;;
-    esac
-}
-
-get_title() {
-    case "$1" in
-        memento) echo "Memento" ;;
-        fathom)  echo "Fathom" ;;
-        *)       echo "$1" ;;
-    esac
-}
-
-# One-shot toast — display in status line for 3 seconds
-toast_oneshot() {
-    local system="$1"
-    local message="$2"
-    local icon title
-    icon=$(get_icon "$system")
-    title=$(get_title "$system")
-
-    tmux display-message -t "$SESSION" -d 3000 "$icon $title: $message"
-}
-
-# Start a multi-stage toast — persistent until --close
-toast_start() {
-    local system="$1"
-    local id="$2"
-    local meta_file="$TOAST_DIR/$id"
-    local icon title
-    icon=$(get_icon "$system")
-    title=$(get_title "$system")
-
-    # Save system info for --update to use
-    echo "$icon|$title" > "$meta_file"
-
-    tmux display-message -t "$SESSION" -d 0 "$icon $title: ⏳ Starting..."
-}
-
-# Update a running toast — replace the status line message
-toast_update() {
-    local id="$1"
-    local message="$2"
-    local meta_file="$TOAST_DIR/$id"
-
-    if [ -f "$meta_file" ]; then
-        local icon title
-        icon=$(cut -d'|' -f1 "$meta_file")
-        title=$(cut -d'|' -f2 "$meta_file")
-        tmux display-message -t "$SESSION" -d 0 "$icon $title: $message"
-    else
-        # Fallback — no meta file, just show raw message
-        tmux display-message -t "$SESSION" -d 0 "📌 $message"
-    fi
-}
-
-# Close a running toast — show final message briefly, then clear
-toast_close() {
-    local id="$1"
-    local meta_file="$TOAST_DIR/$id"
-
-    # Let the last --update message linger for 3s, then clean up
-    sleep 3
-    rm -f "$meta_file"
-    # Clear the display-message by showing empty briefly
-    tmux display-message -t "$SESSION" -d 1 ""
-}
-
-# --- Argument parsing ---
-case "${1:-}" in
-    --update)
-        toast_update "$2" "$3"
-        ;;
-    --close)
-        toast_close "$2"
-        ;;
-    --*)
-        echo "Unknown option: $1" >&2
-        exit 1
-        ;;
-    "")
-        echo "Usage: hook-toast.sh <system> <message>" >&2
-        echo "       hook-toast.sh <system> --status <id>" >&2
-        echo "       hook-toast.sh --update <id> <message>" >&2
-        echo "       hook-toast.sh --close <id>" >&2
-        exit 1
-        ;;
-    *)
-        SYSTEM="$1"
-        shift
-        if [ "${1:-}" = "--status" ]; then
-            toast_start "$SYSTEM" "$2"
-        else
-            toast_oneshot "$SYSTEM" "$*"
-        fi
-        ;;
-esac

package/scripts/kokoro-bridge.py

@@ -1,196 +0,0 @@
-#!/usr/bin/env python3
-"""Kokoro TTS bridge — persistent daemon with preloaded model.
-
-Listens on a Unix socket for TTS requests. Model is loaded once on startup,
-so subsequent requests skip the ~10-15s model load time.
-
-Protocol (line-delimited JSON over Unix socket):
-  Request:  {"text": "hello", "output": "/tmp/out.wav", "speed": 1.0, "play": false}
-  Response: {"ok": true, "file": "/tmp/out.wav"}
-
-Socket path: /tmp/fathom-kokoro.sock
-"""
-
-import json
-import os
-import signal
-import socket
-import subprocess
-import sys
-import threading
-
-import numpy as np
-import soundfile as sf
-from kokoro import KPipeline
-
-SOCKET_PATH = "/tmp/fathom-kokoro.sock"
-SAMPLE_RATE = 24000
-MAX_CHUNK_CHARS = 500
-VOICE_A = "am_echo"
-VOICE_B = "bf_alice"
-WEIGHT_A = 0.7
-
-
-def chunk_text(text):
-    """Split text into chunks of ~MAX_CHUNK_CHARS on sentence boundaries."""
-    sentences = []
-    current = []
-    for char in text:
-        current.append(char)
-        if char in ".!?" and len(current) > 1:
-            sentences.append("".join(current).strip())
-            current = []
-    if current:
-        tail = "".join(current).strip()
-        if tail:
-            sentences.append(tail)
-
-    chunks = []
-    buf = []
-    buf_len = 0
-    for s in sentences:
-        if buf_len + len(s) > MAX_CHUNK_CHARS and buf:
-            chunks.append(" ".join(buf))
-            buf = [s]
-            buf_len = len(s)
-        else:
-            buf.append(s)
-            buf_len += len(s)
-    if buf:
-        chunks.append(" ".join(buf))
-    return chunks
-
-
-class KokoroBridge:
-    def __init__(self):
-        print("Loading Kokoro model...", file=sys.stderr)
-        self.pipe = KPipeline(lang_code="a")
-        self.voice = self.pipe.load_voice(VOICE_A) * WEIGHT_A + self.pipe.load_voice(VOICE_B) * (
-            1 - WEIGHT_A
-        )
-        print("Model loaded.", file=sys.stderr)
-        self._lock = threading.Lock()
-
-    def speak(self, text, output, speed=1.0, play=False):
-        """Generate WAV from text. Thread-safe (one request at a time)."""
-        with self._lock:
-            chunks = chunk_text(text)
-            all_audio = []
-            for chunk in chunks:
-                for _, _, audio in self.pipe(chunk, voice=self.voice, speed=speed):
-                    audio_np = audio.numpy() if hasattr(audio, "numpy") else audio
-                    all_audio.append(audio_np)
-                    if play:
-                        pcm = (audio_np * 32767).astype(np.int16).tobytes()
-                        subprocess.run(
-                            ["aplay", "-q", "-r", str(SAMPLE_RATE), "-f", "S16_LE", "-c", "1"],
-                            input=pcm,
-                            check=True,
-                        )
-            if all_audio:
-                sf.write(output, np.concatenate(all_audio), SAMPLE_RATE)
-            return output
-
-    def handle_request(self, data):
-        """Process a single JSON request and return a response dict."""
-        text = data.get("text", "")
-        file_path = data.get("file")
-        output = data.get("output")
-        speed = data.get("speed", 1.0)
-        play = data.get("play", False)
-
-        if file_path:
-            try:
-                with open(file_path) as f:
-                    text = f.read().strip()
-            except Exception as e:
-                return {"error": f"Cannot read file: {e}"}
-
-        if not text:
-            return {"error": "No text provided"}
-        if not output:
-            return {"error": "No output path provided"}
-
-        try:
-            result_path = self.speak(text, output, speed=speed, play=play)
-            return {"ok": True, "file": result_path}
-        except Exception as e:
-            return {"error": str(e)}
-
-
-def handle_client(conn, bridge):
-    """Handle a single client connection."""
-    try:
-        data = b""
-        while True:
-            chunk = conn.recv(65536)
-            if not chunk:
-                break
-            data += chunk
-            if b"\n" in data:
-                break
-
-        if not data:
-            return
-
-        request = json.loads(data.decode("utf-8").strip())
-        response = bridge.handle_request(request)
-        conn.sendall((json.dumps(response) + "\n").encode("utf-8"))
-    except json.JSONDecodeError:
-        conn.sendall(b'{"error": "Invalid JSON"}\n')
-    except Exception as e:
-        try:
-            conn.sendall((json.dumps({"error": str(e)}) + "\n").encode("utf-8"))
-        except Exception:
-            pass
-    finally:
-        conn.close()
-
-
-def main():
-    # Clean up stale socket
-    if os.path.exists(SOCKET_PATH):
-        os.unlink(SOCKET_PATH)
-
-    bridge = KokoroBridge()
-
-    server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    server.bind(SOCKET_PATH)
-    os.chmod(SOCKET_PATH, 0o660)
-    server.listen(5)
-    server.settimeout(1.0)  # Allow periodic signal checks
-
-    running = True
-
-    def shutdown(signum, frame):
-        nonlocal running
-        print("\nShutting down...", file=sys.stderr)
-        running = False
-
-    signal.signal(signal.SIGTERM, shutdown)
-    signal.signal(signal.SIGINT, shutdown)
-
-    print(f"Kokoro bridge listening on {SOCKET_PATH}", file=sys.stderr)
-    # Signal readiness to parent process
-    print("READY", flush=True)
-
-    while running:
-        try:
-            conn, _ = server.accept()
-            # Handle each client in a thread (but the lock serializes TTS work)
-            t = threading.Thread(target=handle_client, args=(conn, bridge), daemon=True)
-            t.start()
-        except TimeoutError:
-            continue
-        except Exception as e:
-            if running:
-                print(f"Accept error: {e}", file=sys.stderr)
-
-    server.close()
-    if os.path.exists(SOCKET_PATH):
-        os.unlink(SOCKET_PATH)
-    print("Bridge stopped.", file=sys.stderr)
-
-
-if __name__ == "__main__":
-    main()

package/scripts/kokoro-speak.py

@@ -1,107 +0,0 @@
-#!/usr/bin/env python3
-"""Kokoro TTS — generate speech to WAV, optionally play aloud.
-
-Usage:
-  echo "Hello world" | python kokoro-speak.py --output /tmp/speech.wav
-  python kokoro-speak.py --file /path/to/text.txt --output /tmp/speech.wav
-  python kokoro-speak.py --output /tmp/speech.wav --play
-  python kokoro-speak.py --speed 1.2 --output /tmp/speech.wav --play
-
-Always writes WAV to --output path. With --play, also streams audio to aplay
-during generation. Prints the output path to stdout on success.
-
-Voice: am_echo 70% + bf_alice 30% (masculine American with British warmth).
-Audio: 24kHz, 16-bit signed LE.
-"""
-
-import argparse
-import subprocess
-import sys
-
-import numpy as np
-import soundfile as sf
-from kokoro import KPipeline
-
-SAMPLE_RATE = 24000
-MAX_CHUNK_CHARS = 500
-VOICE_A = "am_echo"
-VOICE_B = "bf_alice"
-WEIGHT_A = 0.7
-
-
-def chunk_text(text):
-    """Split text into chunks of ~MAX_CHUNK_CHARS on sentence boundaries."""
-    sentences = []
-    current = []
-    for char in text:
-        current.append(char)
-        if char in ".!?" and len(current) > 1:
-            sentences.append("".join(current).strip())
-            current = []
-    if current:
-        tail = "".join(current).strip()
-        if tail:
-            sentences.append(tail)
-
-    chunks = []
-    buf = []
-    buf_len = 0
-    for s in sentences:
-        if buf_len + len(s) > MAX_CHUNK_CHARS and buf:
-            chunks.append(" ".join(buf))
-            buf = [s]
-            buf_len = len(s)
-        else:
-            buf.append(s)
-            buf_len += len(s)
-    if buf:
-        chunks.append(" ".join(buf))
-    return chunks
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Kokoro TTS speaker")
-    parser.add_argument("--file", help="Path to text file to read aloud")
-    parser.add_argument("--speed", type=float, default=1.0, help="Speech speed (default: 1.0)")
-    parser.add_argument("--output", required=True, help="Path to write WAV file (always written)")
-    parser.add_argument(
-        "--play", action="store_true", help="Also play audio aloud via aplay during generation"
-    )
-    args = parser.parse_args()
-
-    if args.file:
-        with open(args.file) as f:
-            text = f.read().strip()
-    else:
-        text = sys.stdin.read().strip()
-
-    if not text:
-        print("No text provided.", file=sys.stderr)
-        sys.exit(1)
-
-    # Load pipeline and blend voice
-    pipe = KPipeline(lang_code="a")
-    voice = pipe.load_voice(VOICE_A) * WEIGHT_A + pipe.load_voice(VOICE_B) * (1 - WEIGHT_A)
-
-    chunks = chunk_text(text)
-
-    # Always collect audio for WAV; optionally stream to aplay during generation
-    all_audio = []
-    for chunk in chunks:
-        for _, _, audio in pipe(chunk, voice=voice, speed=args.speed):
-            audio = audio.numpy() if hasattr(audio, "numpy") else audio
-            all_audio.append(audio)
-            if args.play:
-                pcm = (audio * 32767).astype(np.int16).tobytes()
-                subprocess.run(
-                    ["aplay", "-q", "-r", str(SAMPLE_RATE), "-f", "S16_LE", "-c", "1"],
-                    input=pcm,
-                    check=True,
-                )
-    if all_audio:
-        sf.write(args.output, np.concatenate(all_audio), SAMPLE_RATE)
-    print(args.output)
-
-
-if __name__ == "__main__":
-    main()

package/scripts/setup-kokoro.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-# One-shot setup: create venv and install Kokoro TTS dependencies.
-# Idempotent — skips if already set up.
-# Uses uv for fast installs and Python version management.
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-VENV_DIR="$SCRIPT_DIR/.kokoro-venv"
-PYTHON_VERSION="3.13"
-
-if [ -d "$VENV_DIR" ] && "$VENV_DIR/bin/python" -c "import kokoro, soundfile" 2>/dev/null; then
-    echo "Kokoro venv already set up at $VENV_DIR"
-    exit 0
-fi
-
-echo "Creating venv at $VENV_DIR (Python $PYTHON_VERSION)..."
-uv venv --python "$PYTHON_VERSION" "$VENV_DIR"
-
-echo "Installing kokoro and soundfile..."
-uv pip install --python "$VENV_DIR/bin/python" "kokoro>=0.9.4" soundfile numpy pip
-
-echo "Downloading spacy model (needed by kokoro)..."
-"$VENV_DIR/bin/python" -m spacy download en_core_web_sm
-
-echo "Verifying imports..."
-"$VENV_DIR/bin/python" -c "import kokoro, soundfile, numpy; print('OK')"
-
-echo "Setup complete."

package/scripts/vault-frontmatter-lint.js

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Vault frontmatter lint hook for Claude Code PostToolUse (Write/Edit).
- *
- * Reads the tool result from stdin (JSON), checks if the file is inside a
- * vault/ directory and ends in .md. If so, validates frontmatter.
- * Exits 0 on pass, 1 on failure (with error message on stderr).
- *
- * Environment: CLAUDE_TOOL_NAME, CLAUDE_FILE_PATH are set by Claude Code hooks.
- */
-
-import fs from "fs";
-import path from "path";
-import { parseFrontmatter, validateFrontmatter } from "../src/frontmatter.js";
-
-const toolName = process.env.CLAUDE_TOOL_NAME || "";
-const filePath = process.env.CLAUDE_FILE_PATH || "";
-
-// Only check Write and Edit tools
-if (toolName !== "Write" && toolName !== "Edit") {
-  process.exit(0);
-}
-
-// Only check .md files inside a vault/ directory
-if (!filePath || !filePath.endsWith(".md")) {
-  process.exit(0);
-}
-
-// Check if the file is inside a vault/ directory
-const parts = filePath.split(path.sep);
-if (!parts.includes("vault")) {
-  process.exit(0);
-}
-
-// Read the file and validate
-try {
-  const content = fs.readFileSync(filePath, "utf-8");
-
-  // Only validate if file has frontmatter
-  if (!content.startsWith("---")) {
-    process.exit(0);
-  }
-
-  const { fm } = parseFrontmatter(content);
-  if (Object.keys(fm).length === 0) {
-    process.exit(0);
-  }
-
-  const errors = validateFrontmatter(fm);
-  if (errors.length > 0) {
-    process.stderr.write(`Vault frontmatter validation failed for ${path.basename(filePath)}:\n`);
-    for (const err of errors) {
-      process.stderr.write(`  - ${err}\n`);
-    }
-    process.exit(1);
-  }
-} catch (e) {
-  // File read errors are non-fatal for the hook
-  if (e.code !== "ENOENT") {
-    process.stderr.write(`Frontmatter lint error: ${e.message}\n`);
-  }
-}
-
-process.exit(0);