claude-voice 1.0.0

package/hooks/stop.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * Claude Code Hook: Stop
+ *
+ * This hook runs when Claude finishes responding.
+ * It extracts Claude's response and sends it to the TTS service.
+ * Respects user configuration for auto-speak.
+ */
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+const API_URL = 'http://127.0.0.1:3456';
+const CONFIG_FILE = path.join(os.homedir(), '.claude-voice', 'config.json');
+
+// Load configuration
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+  } catch {
+    // Use defaults
+  }
+  return {
+    tts: {
+      autoSpeak: true,
+      maxSpeechLength: 500,
+      skipCodeBlocks: true
+    }
+  };
+}
+
+async function sendToTTS(text, priority = false) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify({ text, priority });
+
+    const req = http.request(`${API_URL}/tts`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(data, 'utf8')
+      },
+      timeout: 5000
+    }, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          const response = JSON.parse(body);
+          resolve(response);
+        } catch {
+          resolve({ success: false });
+        }
+      });
+    });
+
+    req.on('error', () => resolve({ success: false }));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ success: false });
+    });
+
+    req.write(data);
+    req.end();
+  });
+}
+
+async function extractLastResponse(transcriptPath) {
+  if (!fs.existsSync(transcriptPath)) {
+    return null;
+  }
+
+  const fileStream = fs.createReadStream(transcriptPath);
+  const rl = readline.createInterface({
+    input: fileStream,
+    crlfDelay: Infinity
+  });
+
+  let lastAssistantMessage = null;
+
+  for await (const line of rl) {
+    try {
+      const entry = JSON.parse(line);
+
+      // Look for assistant messages
+      if (entry.type === 'assistant' && entry.message) {
+        // Extract text content from the message
+        if (entry.message.content) {
+          const textContent = entry.message.content
+            .filter(c => c.type === 'text')
+            .map(c => c.text)
+            .join('\n');
+
+          if (textContent) {
+            lastAssistantMessage = textContent;
+          }
+        }
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  return lastAssistantMessage;
+}
+
+// Extract abstract portion if marker is present
+function extractAbstract(text, config) {
+  const marker = config.voiceOutput?.abstractMarker || '<!-- TTS -->';
+
+  if (text.includes(marker)) {
+    // Extract text before the marker (the spoken abstract)
+    const abstract = text.split(marker)[0].trim();
+    return abstract || null;
+  }
+
+  return null;
+}
+
+// Clean text for TTS (remove markdown, code, etc.)
+function cleanForTTS(text) {
+  let cleaned = text;
+
+  // Remove code blocks
+  cleaned = cleaned.replace(/```[\s\S]*?```/g, '');
+
+  // Remove inline code
+  cleaned = cleaned.replace(/`[^`]+`/g, '');
+
+  // Remove markdown formatting
+  cleaned = cleaned.replace(/[*_~]/g, '');
+
+  // Remove URLs
+  cleaned = cleaned.replace(/https?:\/\/\S+/g, '');
+
+  // Remove file paths
+  cleaned = cleaned.replace(/\/[a-zA-Z0-9_\-./]+/g, '');
+
+  // Collapse multiple newlines
+  cleaned = cleaned.replace(/\n{2,}/g, '. ');
+  cleaned = cleaned.replace(/\n/g, ' ');
+
+  // Trim whitespace
+  cleaned = cleaned.trim();
+
+  return cleaned;
+}
+
+function summarizeForSpeech(text, config) {
+  if (!text) return null;
+
+  // First, try to extract abstract if voiceOutput is enabled
+  if (config.voiceOutput?.enabled !== false) {
+    const abstract = extractAbstract(text, config);
+    if (abstract) {
+      // Clean the abstract for TTS
+      return cleanForTTS(abstract) || null;
+    }
+  }
+
+  // Fallback: use existing logic for responses without abstract marker
+  let cleaned = text;
+  const maxLength = config.voiceOutput?.maxAbstractLength || config.tts?.maxSpeechLength || 500;
+  const skipCodeBlocks = config.tts?.skipCodeBlocks !== false;
+
+  // Remove code blocks if configured
+  if (skipCodeBlocks) {
+    cleaned = cleaned.replace(/```[\s\S]*?```/g, '');
+  }
+
+  // Remove inline code
+  cleaned = cleaned.replace(/`[^`]+`/g, '');
+
+  // Remove markdown formatting
+  cleaned = cleaned.replace(/[*_~]/g, '');
+
+  // Remove URLs
+  cleaned = cleaned.replace(/https?:\/\/\S+/g, '');
+
+  // Remove file paths
+  cleaned = cleaned.replace(/\/[a-zA-Z0-9_\-./]+/g, '');
+
+  // Collapse multiple newlines
+  cleaned = cleaned.replace(/\n{2,}/g, '. ');
+  cleaned = cleaned.replace(/\n/g, ' ');
+
+  // Trim whitespace
+  cleaned = cleaned.trim();
+
+  // Truncate to max length
+  if (cleaned.length > maxLength) {
+    const truncated = cleaned.substring(0, maxLength);
+    const lastSentence = truncated.lastIndexOf('.');
+    if (lastSentence > maxLength * 0.7) {
+      cleaned = truncated.substring(0, lastSentence + 1);
+    } else {
+      cleaned = truncated + '...';
+    }
+  }
+
+  return cleaned || null;
+}
+
+async function main() {
+  const config = loadConfig();
+
+  // Check if auto-speak is enabled
+  if (!config.tts || config.tts.autoSpeak === false) {
+    console.log(JSON.stringify({}));
+    return;
+  }
+
+  // Read hook input from stdin
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+
+  const hookData = JSON.parse(input);
+  const { transcript_path } = hookData;
+
+  if (!transcript_path) {
+    console.log(JSON.stringify({}));
+    return;
+  }
+
+  try {
+    // Extract Claude's last response
+    const lastResponse = await extractLastResponse(transcript_path);
+
+    if (lastResponse) {
+      // Summarize and clean for speech
+      const speechText = summarizeForSpeech(lastResponse, config);
+
+      if (speechText) {
+        await sendToTTS(speechText);
+      }
+    }
+  } catch {
+    // Silently fail - we don't want to interrupt Claude Code
+  }
+
+  // Output empty response
+  console.log(JSON.stringify({}));
+}
+
+main().catch(() => {
+  console.log(JSON.stringify({}));
+  process.exit(0); // Don't fail the hook
+});

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "claude-voice",
+  "version": "1.0.0",
+  "description": "Voice interface extension for Claude Code - TTS, STT, and wake word detection",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "claude-voice": "./bin/claude-voice"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.js",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "lint": "eslint src/**/*.ts",
+    "test": "jest"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "voice",
+    "tts",
+    "stt",
+    "speech",
+    "ai",
+    "extension",
+    "jarvis",
+    "wake-word"
+  ],
+  "author": "Enes Sahin <menesahin99@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Menesahin/claude-voice-extension.git"
+  },
+  "homepage": "https://github.com/Menesahin/claude-voice-extension#readme",
+  "bugs": {
+    "url": "https://github.com/Menesahin/claude-voice-extension/issues"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "express": "^4.18.2",
+    "inquirer": "^8.2.7",
+    "openai": "^4.20.0",
+    "ora": "^5.4.1",
+    "sherpa-onnx-darwin-arm64": "^1.12.20",
+    "sherpa-onnx-node": "^1.12.20"
+  },
+  "optionalDependencies": {
+    "@picovoice/porcupine-node": "^4.0.1",
+    "@picovoice/pvrecorder-node": "^1.2.8"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "files": [
+    "bin/**/*",
+    "dist/**/*",
+    "hooks/**/*",
+    "config/**/*",
+    "scripts/**/*",
+    "models/.gitkeep",
+    "python/**/*",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/python/stt_service.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+Speech-to-Text service using OpenAI Whisper.
+Can be run as a standalone script or as a Flask server.
+"""
+
+import argparse
+import json
+import sys
+import os
+
+def transcribe_audio(audio_path: str, model: str = "base", language: str = "en") -> dict:
+    """Transcribe audio file using Whisper."""
+    try:
+        import whisper
+    except ImportError:
+        return {"error": "openai-whisper not installed. Run: pip install openai-whisper"}
+
+    if not os.path.exists(audio_path):
+        return {"error": f"Audio file not found: {audio_path}"}
+
+    try:
+        # Load model (cached after first load)
+        model_instance = whisper.load_model(model)
+
+        # Transcribe
+        result = model_instance.transcribe(
+            audio_path,
+            language=language if language != "auto" else None,
+            fp16=False  # Use FP32 for better compatibility
+        )
+
+        return {
+            "transcript": result["text"].strip(),
+            "language": result.get("language", language),
+            "segments": result.get("segments", [])
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+def main():
+    parser = argparse.ArgumentParser(description="Whisper STT Service")
+    parser.add_argument("--audio", "-a", required=True, help="Path to audio file")
+    parser.add_argument("--model", "-m", default="base",
+                       choices=["tiny", "base", "small", "medium", "large"],
+                       help="Whisper model size")
+    parser.add_argument("--language", "-l", default="en",
+                       help="Language code (e.g., 'en', 'es') or 'auto' for detection")
+
+    args = parser.parse_args()
+
+    result = transcribe_audio(args.audio, args.model, args.language)
+    print(json.dumps(result))
+
+    if "error" in result:
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/python/voice_input.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""
+Voice Input - Record and transcribe speech
+Press ENTER to start recording, ENTER again to stop.
+Uses OpenAI Whisper API for transcription.
+"""
+
+import os
+import sys
+import tempfile
+import wave
+import struct
+
+def record_audio(filename, sample_rate=16000):
+    """Record audio using PyAudio"""
+    try:
+        import pyaudio
+    except ImportError:
+        print("Installing pyaudio...")
+        os.system("pip3 install pyaudio --quiet")
+        import pyaudio
+
+    CHUNK = 1024
+    FORMAT = pyaudio.paInt16
+    CHANNELS = 1
+
+    p = pyaudio.PyAudio()
+
+    stream = p.open(format=FORMAT,
+                    channels=CHANNELS,
+                    rate=sample_rate,
+                    input=True,
+                    frames_per_buffer=CHUNK)
+
+    print("\n🎤 Recording... (press ENTER to stop)")
+
+    frames = []
+
+    # Record until Enter is pressed
+    import select
+    while True:
+        data = stream.read(CHUNK, exception_on_overflow=False)
+        frames.append(data)
+
+        # Check for Enter key (non-blocking)
+        if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
+            sys.stdin.readline()
+            break
+
+    print("⏹️  Recording stopped.")
+
+    stream.stop_stream()
+    stream.close()
+    p.terminate()
+
+    # Save as WAV
+    wf = wave.open(filename, 'wb')
+    wf.setnchannels(CHANNELS)
+    wf.setsampwidth(p.get_sample_size(FORMAT))
+    wf.setframerate(sample_rate)
+    wf.writeframes(b''.join(frames))
+    wf.close()
+
+    return filename
+
+def transcribe_openai(audio_path):
+    """Transcribe using OpenAI Whisper API"""
+    try:
+        from openai import OpenAI
+    except ImportError:
+        print("Installing openai...")
+        os.system("pip3 install openai --quiet")
+        from openai import OpenAI
+
+    api_key = os.environ.get('OPENAI_API_KEY')
+    if not api_key:
+        print("❌ OPENAI_API_KEY not set")
+        return None
+
+    client = OpenAI(api_key=api_key)
+
+    with open(audio_path, 'rb') as audio_file:
+        transcript = client.audio.transcriptions.create(
+            model="whisper-1",
+            file=audio_file
+        )
+
+    return transcript.text
+
+def transcribe_local(audio_path):
+    """Transcribe using local Whisper"""
+    try:
+        import whisper
+    except ImportError:
+        print("Local whisper not available, using OpenAI API")
+        return transcribe_openai(audio_path)
+
+    model = whisper.load_model("base")
+    result = model.transcribe(audio_path)
+    return result["text"]
+
+def main():
+    print("╔════════════════════════════════════════╗")
+    print("║       Claude Voice Input               ║")
+    print("╠════════════════════════════════════════╣")
+    print("║  Press ENTER to start recording        ║")
+    print("║  Press ENTER again to stop & transcribe║")
+    print("║  Type 'q' to quit                      ║")
+    print("╚════════════════════════════════════════╝")
+
+    use_openai = os.environ.get('OPENAI_API_KEY') is not None
+    print(f"\nUsing: {'OpenAI Whisper API' if use_openai else 'Local Whisper'}")
+
+    while True:
+        print("\n" + "="*40)
+        user_input = input("Press ENTER to record (or 'q' to quit): ").strip().lower()
+
+        if user_input == 'q':
+            print("Goodbye!")
+            break
+
+        # Record
+        with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
+            temp_path = f.name
+
+        try:
+            record_audio(temp_path)
+
+            print("⏳ Transcribing...")
+
+            if use_openai:
+                text = transcribe_openai(temp_path)
+            else:
+                text = transcribe_local(temp_path)
+
+            if text:
+                print(f"\n📝 Transcript: \"{text}\"")
+
+                # Copy to clipboard on macOS
+                try:
+                    import subprocess
+                    subprocess.run(['pbcopy'], input=text.encode(), check=True)
+                    print("✅ Copied to clipboard! Paste with Cmd+V")
+                except:
+                    pass
+            else:
+                print("❌ No speech detected")
+
+        finally:
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+
+if __name__ == "__main__":
+    main()

package/scripts/install.sh

@@ -0,0 +1,147 @@
+#!/bin/bash
+#
+# Claude Voice Extension - Installation Script
+#
+# This script installs all dependencies and sets up the voice extension.
+
+set -e
+
+echo "╔══════════════════════════════════════════════════════════════╗"
+echo "║         Claude Voice Extension - Installation                ║"
+echo "╚══════════════════════════════════════════════════════════════╝"
+echo ""
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Get the script directory
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT_DIR="$( cd "$SCRIPT_DIR/.." && pwd )"
+
+echo "Project directory: $PROJECT_DIR"
+echo ""
+
+# Check prerequisites
+check_command() {
+    if command -v "$1" &> /dev/null; then
+        echo -e "${GREEN}✓${NC} $1 found"
+        return 0
+    else
+        echo -e "${RED}✗${NC} $1 not found"
+        return 1
+    fi
+}
+
+echo "Checking prerequisites..."
+echo ""
+
+# Check Node.js
+if ! check_command node; then
+    echo -e "${RED}Node.js is required. Please install Node.js 18+ and try again.${NC}"
+    echo "  brew install node"
+    exit 1
+fi
+
+NODE_VERSION=$(node -v | cut -d'v' -f2 | cut -d'.' -f1)
+if [ "$NODE_VERSION" -lt 18 ]; then
+    echo -e "${RED}Node.js 18+ is required. Current version: $(node -v)${NC}"
+    exit 1
+fi
+
+# Check npm
+check_command npm || exit 1
+
+# Check Python3
+if ! check_command python3; then
+    echo -e "${YELLOW}Python3 not found. Local Whisper STT will not work.${NC}"
+    echo "  brew install python@3.11"
+fi
+
+echo ""
+echo "Installing Node.js dependencies..."
+cd "$PROJECT_DIR"
+npm install
+
+echo ""
+echo "Building TypeScript..."
+npm run build
+
+echo ""
+echo "Installing Python dependencies (for local Whisper)..."
+if command -v python3 &> /dev/null; then
+    if command -v pip3 &> /dev/null; then
+        pip3 install -r requirements.txt --user || {
+            echo -e "${YELLOW}Warning: Failed to install Python dependencies.${NC}"
+            echo "Local Whisper STT may not work. You can install manually:"
+            echo "  pip3 install openai-whisper sounddevice numpy"
+        }
+    else
+        echo -e "${YELLOW}pip3 not found. Skipping Python dependencies.${NC}"
+    fi
+else
+    echo -e "${YELLOW}Skipping Python dependencies (Python3 not found).${NC}"
+fi
+
+echo ""
+echo "Setting up configuration..."
+CONFIG_DIR="$HOME/.claude-voice"
+mkdir -p "$CONFIG_DIR"
+
+if [ ! -f "$CONFIG_DIR/config.json" ]; then
+    cp "$PROJECT_DIR/config/default.json" "$CONFIG_DIR/config.json"
+    echo "Created default configuration at $CONFIG_DIR/config.json"
+else
+    echo "Configuration already exists at $CONFIG_DIR/config.json"
+fi
+
+echo ""
+echo "Making CLI executable..."
+chmod +x "$PROJECT_DIR/dist/cli.js"
+chmod +x "$PROJECT_DIR/dist/index.js"
+
+# Create symlink for global access
+echo ""
+echo "Creating global command link..."
+LINK_PATH="/usr/local/bin/claude-voice"
+if [ -L "$LINK_PATH" ] || [ -f "$LINK_PATH" ]; then
+    echo "Removing existing link..."
+    sudo rm -f "$LINK_PATH"
+fi
+sudo ln -s "$PROJECT_DIR/dist/cli.js" "$LINK_PATH" || {
+    echo -e "${YELLOW}Could not create global link. You can run the CLI with:${NC}"
+    echo "  node $PROJECT_DIR/dist/cli.js"
+}
+
+echo ""
+echo "Installing Claude Code hooks..."
+node "$PROJECT_DIR/dist/cli.js" install-hooks
+
+echo ""
+echo "╔══════════════════════════════════════════════════════════════╗"
+echo "║                   Installation Complete!                      ║"
+echo "╚══════════════════════════════════════════════════════════════╝"
+echo ""
+echo "Next steps:"
+echo ""
+echo "1. Set up API keys (optional, for cloud providers):"
+echo "   export OPENAI_API_KEY='your-key'      # For OpenAI TTS/STT"
+echo "   export ELEVENLABS_API_KEY='your-key'  # For ElevenLabs TTS"
+echo "   export PICOVOICE_ACCESS_KEY='your-key' # For wake word (free at picovoice.ai)"
+echo ""
+echo "2. Start the voice extension:"
+echo "   claude-voice start"
+echo ""
+echo "3. Test TTS:"
+echo "   claude-voice test-tts 'Hello, world!'"
+echo ""
+echo "4. Check status:"
+echo "   claude-voice status"
+echo ""
+echo "5. View/modify configuration:"
+echo "   claude-voice config"
+echo ""
+echo "For wake word detection, get a free API key at https://picovoice.ai"
+echo ""