vtype 0.1.0__tar.gz

vtype-0.1.0/.gitignore

@@ -0,0 +1,98 @@
+# Voice Claude Code - Git Ignore
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual Environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+# Keep .vscode/launch.json and tasks.json for dev workflow
+.vscode/settings.json
+.vscode/*.code-workspace
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Configuration (contains API keys - NEVER COMMIT)
+.env
+.env.local
+
+# Whisper Models (large files)
+models/*.bin
+models/*.pt
+*.bin
+*.pt
+
+# Audio files (temporary recordings)
+*.wav
+*.mp3
+*.ogg
+recordings/
+temp_audio/
+
+# Logs
+*.log
+logs/
+*.log.*
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Node / VSCode extension build artifacts
+node_modules/
+package-lock.json
+out/
+*.vsix
+
+# OS
+Thumbs.db
+.DS_Store
+
+# Backup files
+*.bak
+*.backup
+*~
+
+# Session data (if storing locally)
+sessions/
+*.session
+
+# Claude Code project settings
+.claude/
+
+# Azure Speech SDK cache
+.azure/
+
+# Porcupine models/keys
+*.ppn
+porcupine_key.txt

vtype-0.1.0/.vscode/launch.json

@@ -0,0 +1,13 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Run Extension",
+      "type": "extensionHost",
+      "request": "launch",
+      "args": ["--extensionDevelopmentPath=${workspaceFolder}"],
+      "outFiles": ["${workspaceFolder}/out/**/*.js"],
+      "preLaunchTask": "${defaultBuildTask}"
+    }
+  ]
+}

vtype-0.1.0/.vscode/tasks.json

@@ -0,0 +1,16 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "npm: compile",
+      "type": "npm",
+      "script": "compile",
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      },
+      "problemMatcher": ["$tsc"],
+      "detail": "Compile TypeScript extension"
+    }
+  ]
+}

vtype-0.1.0/.vscodeignore

@@ -0,0 +1,10 @@
+.vscode/**
+.claude/**
+config/**
+node_modules/**
+src/**
+tsconfig.json
+.gitignore
+*.vsix
+voice_terminal.py
+widget.py

vtype-0.1.0/DESIGN.md

@@ -0,0 +1,101 @@
+# Voice Claude Code — Design
+
+## What it is
+
+A VSCode extension that adds voice input to Claude Code. The user presses a keyboard shortcut, speaks, and the transcribed text is pasted into the Claude Code chat input. No webview, no browser, no server — just a status bar button and a Python backend.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────┐
+│  VSCode Extension (extension.ts)        │
+│  ─ Status bar: $(mic) Voice             │
+│  ─ Keybinding: Ctrl+Alt+V               │
+│  ─ Spawns voice_backend.py via stdin    │
+│  ─ IPC: line-delimited text protocol    │
+└──────────────┬──────────────────────────┘
+               │ stdin/stdout
+               ▼
+┌─────────────────────────────────────────┐
+│  Python Backend (voice_backend.py)      │
+│                                         │
+│  sounddevice (RMS VAD)                  │
+│    ↓ speech detected                    │
+│  openai-whisper (base model)            │
+│    ↓ transcribed text                   │
+│  pyperclip → clipboard                  │
+│    ↓ PASTE: signal to extension         │
+│  extension calls claude-vscode.focus    │
+│    ↓ DO_PASTE signal back (150ms later) │
+│  pynput → Ctrl+V at OS level            │
+└─────────────────────────────────────────┘
+```
+
+## IPC Protocol
+
+**Extension → Backend (stdin):**
+| Command | Meaning |
+|---|---|
+| `START` | Begin listening |
+| `STOP` | Stop listening, go idle |
+| `DO_PASTE` | Focus confirmed, paste now |
+| `QUIT` | Shut down |
+
+**Backend → Extension (stdout):**
+| Message | Meaning |
+|---|---|
+| `READY` | Whisper model loaded |
+| `LISTENING` | Waiting for speech |
+| `SPEAKING` | Recording |
+| `TRANSCRIBING` | Whisper processing |
+| `PASTE:<text>` | Text ready, requesting focus |
+| `PASTED:<text>` | Paste complete |
+| `IDLE` | Stopped |
+| `ERROR:<msg>` | Something went wrong |
+
+## Focus management
+
+The tricky part: pynput simulates Ctrl+V at the OS level, so the correct window must have focus at the exact moment of paste. If the user opened a file editor while speaking, a naive paste would land in the editor.
+
+**Solution — round-trip before paste:**
+1. Backend copies text to clipboard, emits `PASTE:<text>`, then blocks on a threading.Event
+2. Extension receives `PASTE:`, calls `claude-vscode.focus` (the same command as `Ctrl+Esc`)
+3. After 150ms (enough for webview focus to propagate), extension sends `DO_PASTE`
+4. Backend unblocks, runs pynput Ctrl+V
+
+This ensures the Claude Code input always has OS-level focus at paste time, regardless of what the user did while speaking. Timeout of 2s prevents blocking indefinitely if the extension crashes.
+
+## Key decisions
+
+**No LLM cleanup layer** — an earlier iteration piped Whisper output through a local qwen2.5:1.5b model (via Ollama) to strip filler words and resolve self-corrections. Removed because Claude Code's AI is more than capable of understanding natural speech patterns, and the cleanup added ~2.8s latency per utterance with no real benefit.
+
+**No TTS** — not needed. The user reads Claude's responses normally.
+
+**No wake word** — user activates manually via Ctrl+Alt+V. Simpler, no always-on mic.
+
+**No webview** — earlier design used a browser-based UI with WebSockets. Scrapped in favour of a status bar item that works with whatever text area has focus.
+
+**openai-whisper not whisper.cpp** — Python bindings are easier to integrate. `base` model gives acceptable accuracy and speed on CPU.
+
+**pynput for paste** — OS-level Ctrl+V simulation works with any input, including VSCode webview panels that don't support the VSCode clipboard paste command.
+
+## VAD parameters
+
+```python
+SPEECH_RMS   = 0.015   # RMS threshold to start recording
+SILENCE_RMS  = 0.010   # RMS threshold to detect silence
+SILENCE_SECS = 1.2     # Seconds of silence to end utterance
+MIN_SPEECH   = 0.4     # Minimum speech duration (seconds)
+```
+
+## File structure
+
+```
+voice-claude-code/
+├── src/extension.ts       — VSCode extension (TypeScript)
+├── voice_backend.py       — Python: VAD + Whisper + paste
+├── package.json           — Extension manifest, keybindings, settings
+├── tsconfig.json          — TypeScript config
+├── requirements.txt       — Python dependencies
+└── out/extension.js       — Compiled output (gitignored)
+```

vtype-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Voice Claude Code
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vtype-0.1.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: vtype
+Version: 0.1.0
+Summary: Offline voice input — speak into any focused window, no cloud required
+License: MIT
+License-File: LICENSE
+Keywords: dictation,offline,speech,voice,voice-input,whisper
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: openai-whisper
+Requires-Dist: pynput
+Requires-Dist: sounddevice
+Description-Content-Type: text/markdown
+
+# vtype
+
+**Offline voice input for any focused window.** Press `Ctrl+Alt+V`, speak, and your words are typed instantly — no cloud, no API key, no subscription.
+
+Works in Claude Code terminal, VS Code, any text editor, browser, chat app — whatever window is focused.
+
+---
+
+## Install
+
+```bash
+pip install vtype
+```
+
+> **First run** downloads the Whisper speech model (~150 MB). Subsequent runs are instant.
+
+## Usage
+
+```bash
+vtype
+```
+
+- Press `Ctrl+Alt+V` — starts listening
+- Speak naturally
+- Silence for ~1 second → transcribes and types into the focused window
+- Press `Ctrl+Alt+V` again to cancel
+- `Ctrl+C` to quit
+
+## Requirements
+
+- Python 3.9+
+- A microphone
+- FFmpeg (for audio processing)
+
+**FFmpeg install:**
+
+| Platform | Command |
+|----------|---------|
+| Windows  | `winget install ffmpeg` |
+| macOS    | `brew install ffmpeg` |
+| Linux    | `sudo apt install ffmpeg` |
+
+## How it works
+
+- Speech detection runs locally using RMS-based VAD (no network calls)
+- Transcription uses [OpenAI Whisper](https://github.com/openai/whisper) (base model, runs on CPU)
+- Text is typed via OS-level keyboard simulation — works in any window including terminals and browser tabs
+
+## Privacy
+
+Everything runs on your machine. Audio never leaves your device.
+
+## License
+
+MIT

vtype-0.1.0/README.md

@@ -0,0 +1,77 @@
+# Claude Voice
+
+**Talk to Claude instead of typing.** Press `Ctrl+Alt+V`, speak your prompt, and it appears in Claude Code's chat input — ready to send.
+
+**No API key. No cloud. No subscription. Runs 100% offline on your machine.**
+
+![Claude Voice demo](images/demo.gif)
+
+---
+
+## Why Claude Voice?
+
+- **No API key required** — just install and speak
+- **Your voice never leaves your computer** — speech is processed locally on your machine
+- **Works offline** — no internet connection needed after the initial model download
+- **Free to use** — no per-request costs, no subscriptions
+
+---
+
+## Setup
+
+**1. Install Python dependencies**
+
+```bash
+pip install openai-whisper sounddevice pynput pyperclip numpy
+```
+
+> The first use downloads a ~140 MB speech recognition model. After that, everything runs fully offline with no internet connection required.
+
+**2. Reload VS Code**
+
+`Ctrl+Shift+P` → **Developer: Reload Window**
+
+That's it. Look for the **🎤 Voice** button in your status bar.
+
+---
+
+## How to use
+
+1. Press `Ctrl+Alt+V` (Windows/Linux) or `Cmd+Alt+V` (Mac) — or click **🎤 Voice** in the status bar
+2. Speak your prompt naturally
+3. Pause for ~1 second when done — your words appear in Claude Code's chat input
+4. Press `Enter` to send
+
+Press `Ctrl+Alt+V` again at any time to cancel.
+
+---
+
+## Requirements
+
+- [Claude Code](https://marketplace.visualstudio.com/items?itemName=Anthropic.claude-code) extension installed
+- Python 3.9 or higher
+- A microphone
+
+---
+
+## Settings
+
+| Setting | Default | Description |
+|---|---|---|
+| `claude-voice.focusTarget` | `claude` | `claude` = always focus Claude Code input before pasting. `none` = paste wherever focus already is (works with any input field). |
+
+---
+
+## Troubleshooting
+
+**"Missing Python dependencies"** — Run `pip install openai-whisper sounddevice pynput pyperclip numpy` in your terminal.
+
+**Nothing appears after speaking** — Make sure the Claude Code panel is open. The extension automatically focuses the Claude Code input before pasting.
+
+**Text goes to the wrong app** — The extension checks that VS Code is the active window before pasting. If you switch away while it's transcribing, the paste is safely discarded.
+
+**macOS** — `pynput` requires Accessibility permissions: System Settings → Privacy & Security → Accessibility → enable VS Code.
+
+**Linux** — Requires `xdotool`: `sudo apt install xdotool`
+
+**Slow first transcription** — Whisper loads on first use (~5s). Subsequent transcriptions are faster.

vtype-0.1.0/README_PYPI.md

@@ -0,0 +1,55 @@
+# vtype
+
+**Offline voice input for any focused window.** Press `Ctrl+Alt+V`, speak, and your words are typed instantly — no cloud, no API key, no subscription.
+
+Works in Claude Code terminal, VS Code, any text editor, browser, chat app — whatever window is focused.
+
+---
+
+## Install
+
+```bash
+pip install vtype
+```
+
+> **First run** downloads the Whisper speech model (~150 MB). Subsequent runs are instant.
+
+## Usage
+
+```bash
+vtype
+```
+
+- Press `Ctrl+Alt+V` — starts listening
+- Speak naturally
+- Silence for ~1 second → transcribes and types into the focused window
+- Press `Ctrl+Alt+V` again to cancel
+- `Ctrl+C` to quit
+
+## Requirements
+
+- Python 3.9+
+- A microphone
+- FFmpeg (for audio processing)
+
+**FFmpeg install:**
+
+| Platform | Command |
+|----------|---------|
+| Windows  | `winget install ffmpeg` |
+| macOS    | `brew install ffmpeg` |
+| Linux    | `sudo apt install ffmpeg` |
+
+## How it works
+
+- Speech detection runs locally using RMS-based VAD (no network calls)
+- Transcription uses [OpenAI Whisper](https://github.com/openai/whisper) (base model, runs on CPU)
+- Text is typed via OS-level keyboard simulation — works in any window including terminals and browser tabs
+
+## Privacy
+
+Everything runs on your machine. Audio never leaves your device.
+
+## License
+
+MIT

vtype-0.1.0/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "claude-voice",
+  "displayName": "Claude Voice",
+  "description": "Talk to Claude instead of typing. Press a shortcut, speak your prompt, and it appears in Claude Code ready to send.",
+  "version": "0.1.4",
+  "publisher": "jsaluja",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jsaluja/claude-voice"
+  },
+  "keywords": ["claude", "voice", "speech", "whisper", "ai", "assistant", "dictation"],
+  "engines": {
+    "vscode": "^1.85.0"
+  },
+  "icon": "images/icon.png",
+  "galleryBanner": {
+    "color": "#18181f",
+    "theme": "dark"
+  },
+  "categories": ["AI", "Other"],
+  "activationEvents": ["onStartupFinished"],
+  "main": "./out/extension.js",
+  "contributes": {
+    "commands": [
+      {
+        "command": "claude-voice.toggle",
+        "title": "Toggle Voice Input",
+        "category": "Claude Voice"
+      }
+    ],
+    "configuration": {
+      "title": "Claude Voice",
+      "properties": {
+        "claude-voice.focusTarget": {
+          "type": "string",
+          "enum": ["claude", "none"],
+          "default": "claude",
+          "description": "Where to focus before pasting. 'claude' = always focus Claude Code input. 'none' = paste wherever focus already is."
+        }
+      }
+    },
+    "keybindings": [
+      {
+        "command": "claude-voice.toggle",
+        "key": "ctrl+alt+v",
+        "mac": "cmd+alt+v"
+      }
+    ]
+  },
+  "scripts": {
+    "compile": "tsc -p ./",
+    "watch": "tsc -watch -p ./",
+    "vscode:prepublish": "npm run compile",
+    "package": "vsce package"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.85.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0",
+    "@vscode/vsce": "^2.22.0"
+  }
+}

vtype-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vtype"
+version = "0.1.0"
+description = "Offline voice input — speak into any focused window, no cloud required"
+readme = "README_PYPI.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["voice", "speech", "whisper", "dictation", "offline", "voice-input"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Utilities",
+    "Environment :: Console",
+]
+dependencies = [
+    "openai-whisper",
+    "sounddevice",
+    "pynput",
+    "numpy",
+]
+
+[project.scripts]
+vtype = "vtype.__main__:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["vtype"]

vtype-0.1.0/requirements.txt

@@ -0,0 +1,5 @@
+openai-whisper
+sounddevice
+pynput
+pyperclip
+numpy

vtype-0.1.0/src/extension.ts

@@ -0,0 +1,135 @@
+import * as vscode from 'vscode';
+import * as cp from 'child_process';
+import * as path from 'path';
+
+let backend: cp.ChildProcess | null = null;
+let statusBar: vscode.StatusBarItem;
+let listening = false;
+let extPath = '';
+let deactivating = false;
+
+export function activate(context: vscode.ExtensionContext) {
+    statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 1000);
+    statusBar.text = '$(sync~spin) Voice';
+    statusBar.tooltip = 'Voice: loading...';
+    statusBar.command = 'claude-voice.toggle';
+    statusBar.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
+    statusBar.show();
+    context.subscriptions.push(statusBar);
+
+    vscode.window.showInformationMessage('Click 🎤 Voice in the status bar or press Ctrl+Alt+V to talk to the agent');
+
+    extPath = context.extensionPath;
+    startBackend();
+
+    context.subscriptions.push(
+        vscode.commands.registerCommand('claude-voice.toggle', toggle)
+    );
+}
+
+function startBackend() {
+    const script = path.join(extPath, 'voice_backend.py');
+    const python = process.platform === 'win32' ? 'python' : 'python3';
+    backend = cp.spawn(python, [script], { cwd: extPath });
+
+    backend.stdout?.on('data', (data: Buffer) => {
+        for (const line of data.toString().split('\n')) {
+            const msg = line.trim();
+            if (msg) { onMessage(msg); }
+        }
+    });
+
+    let stderrBuf = '';
+    backend.stderr?.on('data', (d: Buffer) => {
+        const text = d.toString();
+        stderrBuf += text;
+        console.log('[voice]', text.trim());
+    });
+
+    backend.on('exit', (code) => {
+        backend = null;
+        listening = false;
+        if (deactivating) { return; }
+        statusBar.text = '$(mic-filled) Voice (error)';
+        statusBar.color = new vscode.ThemeColor('statusBarItem.errorForeground');
+        if (stderrBuf.includes('ModuleNotFoundError') || stderrBuf.includes('No module named')) {
+            vscode.window.showErrorMessage(
+                'Claude Voice: Missing Python dependencies. Run: pip install -r requirements.txt',
+                'Copy Command'
+            ).then(sel => {
+                if (sel === 'Copy Command') { vscode.env.clipboard.writeText('pip install openai-whisper sounddevice pynput pyperclip numpy'); }
+            });
+            return;
+        }
+        stderrBuf = '';
+        vscode.window.showWarningMessage(`Voice backend crashed (code ${code}) — restarting in 3s...`);
+        setTimeout(() => {
+            if (!deactivating) {
+                statusBar.text = '$(mic) Voice';
+                statusBar.color = undefined;
+                startBackend();
+            }
+        }, 3000);
+    });
+}
+
+function onMessage(msg: string) {
+    if (msg === 'READY') {
+        statusBar.text = '$(mic) Voice';
+        statusBar.tooltip = 'Click to start voice input';
+        statusBar.color = undefined;
+    } else if (msg === 'LISTENING') {
+        statusBar.text = '$(radio-tower) Listening...';
+        statusBar.tooltip = 'Click to stop';
+        statusBar.color = new vscode.ThemeColor('statusBarItem.warningForeground');
+    } else if (msg === 'TRANSCRIBING') {
+        statusBar.text = '$(loading~spin) Transcribing...';
+        statusBar.tooltip = 'Click to stop';
+        statusBar.color = undefined;
+    } else if (msg === 'IDLE') {
+        statusBar.text = '$(mic) Voice';
+        statusBar.tooltip = 'Click to start voice input';
+        statusBar.color = undefined;
+        listening = false;
+    } else if (msg.startsWith('PASTE:')) {
+        const text = msg.slice(6);
+        const target = vscode.workspace.getConfiguration('claude-voice').get<string>('focusTarget', 'claude');
+        const windowFocused = vscode.window.state.focused;
+        const inEditor = vscode.window.activeTextEditor !== undefined;
+        // Only focus-redirect when VS Code is already focused and user is in a text editor.
+        // If VS Code is not focused, don't call claude-vscode.focus — it snaps to conversation 1,
+        // disrupting multi-conversation workflows. The backend will discard the paste and stay listening.
+        const needsFocus = target === 'claude' && windowFocused && inEditor;
+        if (needsFocus) { vscode.commands.executeCommand('claude-vscode.focus'); }
+        // Always wait at least 100ms — even without focus redirect, the shortcut
+        // momentarily pulls focus from the webview input and it needs time to recover
+        setTimeout(() => { backend?.stdin?.write('DO_PASTE\n'); }, needsFocus ? 150 : 100);
+        vscode.window.setStatusBarMessage(`Voice: "${text.slice(0, 60)}"`, 3000);
+    } else if (msg.startsWith('PASTED:')) {
+    } else if (msg.startsWith('ERROR:')) {
+        vscode.window.showWarningMessage(msg.slice(6));
+        statusBar.text = '$(mic) Voice';
+        statusBar.color = undefined;
+        listening = false;
+    }
+}
+
+function toggle() {
+    if (!backend?.stdin) {
+        vscode.window.showWarningMessage('Voice backend not running.');
+        return;
+    }
+    if (!listening) {
+        listening = true;
+        backend.stdin.write('START\n');
+    } else {
+        listening = false;
+        backend.stdin.write('STOP\n');
+    }
+}
+
+export function deactivate() {
+    deactivating = true;
+    backend?.stdin?.write('QUIT\n');
+    backend?.kill();
+}

vtype-0.1.0/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2020",
+    "outDir": "./out",
+    "lib": ["ES2020"],
+    "sourceMap": true,
+    "rootDir": "./src",
+    "strict": true
+  },
+  "exclude": ["node_modules", ".vscode-test"]
+}

vtype-0.1.0/voice_backend.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Voice backend — VAD + Whisper + paste.
+Commands from stdin:  START, STOP, QUIT, DO_PASTE
+Status to stdout:     READY, LISTENING, SPEAKING, TRANSCRIBING, PASTE:<text>, PASTED:<text>, IDLE, ERROR:<msg>
+"""
+
+import sys
+import platform
+import threading
+import numpy as np
+import sounddevice as sd
+import whisper
+import pyperclip
+from pynput.keyboard import Controller as KbController, Key
+
+def _is_vscode_focused():
+    """Returns True if VSCode is the foreground window. Fails open on unsupported platforms."""
+    try:
+        system = platform.system()
+        if system == 'Windows':
+            import ctypes
+            user32 = ctypes.windll.user32
+            hwnd = user32.GetForegroundWindow()
+            length = user32.GetWindowTextLengthW(hwnd)
+            buf = ctypes.create_unicode_buffer(length + 1)
+            user32.GetWindowTextW(hwnd, buf, length + 1)
+            return 'visual studio code' in buf.value.lower()
+        elif system == 'Darwin':
+            import subprocess
+            result = subprocess.run(
+                ['osascript', '-e', 'tell application "System Events" to get name of first application process whose frontmost is true'],
+                capture_output=True, text=True, timeout=1
+            )
+            return 'code' in result.stdout.strip().lower()
+        elif system == 'Linux':
+            import subprocess
+            result = subprocess.run(
+                ['xdotool', 'getactivewindow', 'getwindowname'],
+                capture_output=True, text=True, timeout=1
+            )
+            return 'visual studio code' in result.stdout.strip().lower()
+    except Exception:
+        pass
+    return True  # fail open: unknown platform or tool missing — allow paste
+
+SAMPLE_RATE  = 16000
+CHUNK_SIZE   = int(SAMPLE_RATE * 0.1)   # 100ms chunks
+
+SPEECH_RMS   = 0.015
+SILENCE_RMS  = 0.010
+SILENCE_SECS = 1.2
+MIN_SPEECH   = 0.4
+
+IDLE      = 'idle'
+LISTENING = 'listening'
+SPEAKING  = 'speaking'
+
+# ── Load Whisper ─────────────────────────────────────────────────────────────
+sys.stderr.write("Loading Whisper model...\n")
+sys.stderr.flush()
+_model = whisper.load_model("base")
+sys.stderr.write("Whisper ready\n")
+sys.stderr.flush()
+print("READY", flush=True)
+
+# ── State ─────────────────────────────────────────────────────────────────────
+_state          = IDLE
+_speech_buf     = []
+_silence_cnt    = 0
+_lock           = threading.Lock()
+_do_paste_event = threading.Event()  # set by DO_PASTE command from extension
+
+def _emit(msg):
+    print(msg, flush=True)
+
+# ── Audio callback ────────────────────────────────────────────────────────────
+def _audio_cb(indata, frames, t, status):
+    global _state, _speech_buf, _silence_cnt
+
+    if _state not in (LISTENING, SPEAKING):
+        return
+
+    rms = float(np.sqrt(np.mean(indata ** 2)))
+
+    with _lock:
+        if _state == LISTENING:
+            if rms > SPEECH_RMS:
+                _state = SPEAKING
+                _speech_buf = [indata.copy()]
+                _silence_cnt = 0
+
+        elif _state == SPEAKING:
+            _speech_buf.append(indata.copy())
+            if rms < SILENCE_RMS:
+                _silence_cnt += 1
+                if _silence_cnt * 0.1 >= SILENCE_SECS:
+                    buf = list(_speech_buf)
+                    _speech_buf = []
+                    _silence_cnt = 0
+                    _state = LISTENING
+                    _emit('TRANSCRIBING')
+                    threading.Thread(target=_process, args=(buf,), daemon=True).start()
+            else:
+                _silence_cnt = 0
+
+_stream = sd.InputStream(
+    samplerate=SAMPLE_RATE, channels=1, dtype='float32',
+    blocksize=CHUNK_SIZE, callback=_audio_cb
+)
+_stream.start()
+
+# ── Transcribe + paste ────────────────────────────────────────────────────────
+def _process(chunks):
+    audio = np.concatenate(chunks).flatten()
+    if len(audio) / SAMPLE_RATE < MIN_SPEECH:
+        _emit('LISTENING')
+        return
+
+    result = _model.transcribe(audio, language='en', fp16=False, verbose=False)
+    text = result['text'].strip()
+
+    if not text:
+        _emit('LISTENING')
+        return
+
+    # Signal extension to focus Claude input, then wait for DO_PASTE ack
+    pyperclip.copy(text)
+    _do_paste_event.clear()
+    _emit(f'PASTE:{text}')
+    got_ack = _do_paste_event.wait(timeout=2.0)
+
+    if not got_ack:
+        _emit('LISTENING')
+        return
+
+    if not _is_vscode_focused():
+        # Foreground window is not VSCode — discard paste but keep listening
+        _emit('LISTENING')
+        return
+
+    kb = KbController()
+    paste_key = Key.cmd if platform.system() == 'Darwin' else Key.ctrl
+    kb.press(paste_key)
+    kb.press('v')
+    kb.release('v')
+    kb.release(paste_key)
+
+    _emit(f'PASTED:{text}')
+    _emit('LISTENING')
+
+# ── Command loop ──────────────────────────────────────────────────────────────
+for line in sys.stdin:
+    cmd = line.strip()
+    if cmd == 'START':
+        with _lock:
+            _state = LISTENING
+            _speech_buf = []
+            _silence_cnt = 0
+        _emit('LISTENING')
+    elif cmd == 'DO_PASTE':
+        _do_paste_event.set()
+    elif cmd == 'STOP':
+        with _lock:
+            _state = IDLE
+            _speech_buf = []
+            _silence_cnt = 0
+        _emit('IDLE')
+    elif cmd == 'QUIT':
+        break
+
+_stream.stop()

vtype-0.1.0/voice_terminal.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""
+voice_terminal.py — Voice input for Claude Code terminal (standalone).
+
+Press Ctrl+Alt+V to start listening.
+Speak. Silence auto-triggers transcription.
+Transcribed text is typed into the focused terminal window.
+Press Ctrl+Alt+V again to cancel.
+
+Run with: python voice_terminal.py
+"""
+
+import sys
+import platform  # used for OS notifications
+import threading
+import numpy as np
+import sounddevice as sd
+import whisper
+from pynput import keyboard
+from pynput.keyboard import Controller as KbController
+
+SAMPLE_RATE  = 16000
+CHUNK_SIZE   = int(SAMPLE_RATE * 0.1)   # 100ms chunks
+
+SPEECH_RMS   = 0.015
+SILENCE_RMS  = 0.010
+SILENCE_SECS = 1.2
+MIN_SPEECH   = 0.4
+
+IDLE         = 'idle'
+LISTENING    = 'listening'
+SPEAKING     = 'speaking'
+TRANSCRIBING = 'transcribing'
+
+# ── Terminal window detection ─────────────────────────────────────────────────
+
+# ── Notification ──────────────────────────────────────────────────────────────
+def _notify(title, message=''):
+    """Show a brief OS notification."""
+    try:
+        system = platform.system()
+        if system == 'Darwin':
+            import subprocess
+            subprocess.run(
+                ['osascript', '-e',
+                 f'display notification "{message}" with title "{title}"'],
+                timeout=2, capture_output=True
+            )
+        elif system == 'Windows':
+            # Use PowerShell toast notification
+            import subprocess
+            script = (
+                f'[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime] | Out-Null;'
+                f'$template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02);'
+                f'$template.SelectSingleNode("//text[@id=1]").InnerText = "{title}";'
+                f'$template.SelectSingleNode("//text[@id=2]").InnerText = "{message}";'
+                f'$notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("Claude Voice");'
+                f'$notifier.Show([Windows.UI.Notifications.ToastNotification]::new($template));'
+            )
+            subprocess.run(['powershell', '-Command', script], timeout=3, capture_output=True)
+        elif system == 'Linux':
+            import subprocess
+            subprocess.run(['notify-send', title, message], timeout=2, capture_output=True)
+    except Exception:
+        pass  # notifications are best-effort
+
+# ── Load Whisper ───────────────────────────────────────────────────────────────
+print("Claude Voice — loading speech model...", flush=True)
+_model = whisper.load_model("base")
+print("Ready. Press Ctrl+Alt+V to start/stop voice input.", flush=True)
+_notify("Claude Voice", "Ready — press Ctrl+Alt+V to speak")
+
+# ── State ──────────────────────────────────────────────────────────────────────
+_state       = IDLE
+_speech_buf  = []
+_silence_cnt = 0
+_lock        = threading.Lock()
+_kb          = KbController()
+
+# ── Audio callback ─────────────────────────────────────────────────────────────
+def _audio_cb(indata, frames, t, status):
+    global _state, _speech_buf, _silence_cnt
+
+    if _state not in (LISTENING, SPEAKING):
+        return
+
+    rms = float(np.sqrt(np.mean(indata ** 2)))
+
+    with _lock:
+        if _state == LISTENING:
+            if rms > SPEECH_RMS:
+                _state = SPEAKING
+                _speech_buf = [indata.copy()]
+                _silence_cnt = 0
+
+        elif _state == SPEAKING:
+            _speech_buf.append(indata.copy())
+            if rms < SILENCE_RMS:
+                _silence_cnt += 1
+                if _silence_cnt * 0.1 >= SILENCE_SECS:
+                    buf = list(_speech_buf)
+                    _speech_buf = []
+                    _silence_cnt = 0
+                    _state = TRANSCRIBING
+                    threading.Thread(target=_process, args=(buf,), daemon=True).start()
+            else:
+                _silence_cnt = 0
+
+_stream = sd.InputStream(
+    samplerate=SAMPLE_RATE, channels=1, dtype='float32',
+    blocksize=CHUNK_SIZE, callback=_audio_cb
+)
+_stream.start()
+
+# ── Transcribe + type ──────────────────────────────────────────────────────────
+def _process(chunks):
+    global _state
+
+    audio = np.concatenate(chunks).flatten()
+    if len(audio) / SAMPLE_RATE < MIN_SPEECH:
+        with _lock:
+            _state = LISTENING
+        return
+
+    result = _model.transcribe(audio, language='en', fp16=False, verbose=False)
+    text = result['text'].strip()
+
+    if not text:
+        with _lock:
+            _state = LISTENING
+        return
+
+    _kb.type(text)
+
+    with _lock:
+        _state = LISTENING
+
+# ── Hotkey toggle ──────────────────────────────────────────────────────────────
+def _toggle():
+    global _state, _speech_buf, _silence_cnt
+    with _lock:
+        if _state == IDLE:
+            _state = LISTENING
+            _speech_buf = []
+            _silence_cnt = 0
+            _notify("Claude Voice", "Listening...")
+            print("[voice] Listening...", flush=True)
+        elif _state == TRANSCRIBING:
+            pass  # busy, ignore
+        else:
+            _state = IDLE
+            _speech_buf = []
+            _silence_cnt = 0
+            _notify("Claude Voice", "Stopped")
+            print("[voice] Stopped.", flush=True)
+
+_stop_event = threading.Event()
+
+print("Hotkey active. Ctrl+C to quit.", flush=True)
+with keyboard.GlobalHotKeys({'<ctrl>+<alt>+v': _toggle}) as hotkey:
+    try:
+        while not _stop_event.is_set():
+            _stop_event.wait(timeout=0.5)
+    except KeyboardInterrupt:
+        pass
+
+_stream.stop()
+print("Claude Voice stopped.", flush=True)

vtype-0.1.0/vtype/__init__.py

@@ -0,0 +1,3 @@
+"""vtype — offline voice input for any focused window."""
+
+__version__ = "0.1.0"

vtype-0.1.0/vtype/__main__.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""
+vtype — offline voice input for any focused window.
+
+Press Ctrl+Alt+V to start/stop listening.
+Speak. Silence auto-triggers transcription.
+Transcribed text is typed into whatever window is currently focused.
+
+Usage:
+    vtype
+"""
+
+import platform
+import subprocess
+import threading
+
+import numpy as np
+import sounddevice as sd
+import whisper
+from pynput import keyboard
+from pynput.keyboard import Controller as KbController
+
+SAMPLE_RATE  = 16000
+CHUNK_SIZE   = int(SAMPLE_RATE * 0.1)   # 100ms chunks
+
+SPEECH_RMS   = 0.015
+SILENCE_RMS  = 0.010
+SILENCE_SECS = 1.2
+MIN_SPEECH   = 0.4    # seconds
+
+IDLE         = 'idle'
+LISTENING    = 'listening'
+SPEAKING     = 'speaking'
+TRANSCRIBING = 'transcribing'
+
+
+def _notify(title, message=''):
+    """Show a brief OS notification (best-effort)."""
+    try:
+        system = platform.system()
+        if system == 'Darwin':
+            subprocess.run(
+                ['osascript', '-e',
+                 f'display notification "{message}" with title "{title}"'],
+                timeout=2, capture_output=True
+            )
+        elif system == 'Windows':
+            script = (
+                '[Windows.UI.Notifications.ToastNotificationManager,'
+                ' Windows.UI.Notifications, ContentType=WindowsRuntime] | Out-Null;'
+                '$t = [Windows.UI.Notifications.ToastNotificationManager]::'
+                'GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02);'
+                f'$t.SelectSingleNode("//text[@id=1]").InnerText = "{title}";'
+                f'$t.SelectSingleNode("//text[@id=2]").InnerText = "{message}";'
+                '$n = [Windows.UI.Notifications.ToastNotificationManager]::'
+                'CreateToastNotifier("vtype");'
+                '$n.Show([Windows.UI.Notifications.ToastNotification]::new($t));'
+            )
+            subprocess.run(['powershell', '-Command', script],
+                           timeout=3, capture_output=True)
+        elif system == 'Linux':
+            subprocess.run(['notify-send', title, message],
+                           timeout=2, capture_output=True)
+    except Exception:
+        pass
+
+
+class VType:
+    def __init__(self, model_size='base'):
+        self.model_size = model_size
+        self.state      = IDLE
+        self.speech_buf = []
+        self.silence_cnt = 0
+        self.lock       = threading.Lock()
+        self.kb         = KbController()
+        self.model      = None
+        self.stream     = None
+
+    # ── Audio callback ────────────────────────────────────────────────────────
+    def _audio_cb(self, indata, frames, t, status):
+        if self.state not in (LISTENING, SPEAKING):
+            return
+
+        rms = float(np.sqrt(np.mean(indata ** 2)))
+
+        with self.lock:
+            if self.state == LISTENING:
+                if rms > SPEECH_RMS:
+                    self.state = SPEAKING
+                    self.speech_buf = [indata.copy()]
+                    self.silence_cnt = 0
+
+            elif self.state == SPEAKING:
+                self.speech_buf.append(indata.copy())
+                if rms < SILENCE_RMS:
+                    self.silence_cnt += 1
+                    if self.silence_cnt * 0.1 >= SILENCE_SECS:
+                        buf = list(self.speech_buf)
+                        self.speech_buf = []
+                        self.silence_cnt = 0
+                        self.state = TRANSCRIBING
+                        threading.Thread(
+                            target=self._process, args=(buf,), daemon=True
+                        ).start()
+                else:
+                    self.silence_cnt = 0
+
+    # ── Transcribe + type ─────────────────────────────────────────────────────
+    def _process(self, chunks):
+        audio = np.concatenate(chunks).flatten()
+        if len(audio) / SAMPLE_RATE < MIN_SPEECH:
+            with self.lock:
+                self.state = LISTENING
+            return
+
+        result = self.model.transcribe(audio, language='en', fp16=False, verbose=False)
+        text = result['text'].strip()
+
+        if text:
+            self.kb.type(text)
+
+        with self.lock:
+            self.state = LISTENING
+
+    # ── Hotkey toggle ─────────────────────────────────────────────────────────
+    def _toggle(self):
+        with self.lock:
+            if self.state == IDLE:
+                self.state = LISTENING
+                self.speech_buf = []
+                self.silence_cnt = 0
+                _notify("vtype", "Listening...")
+                print("[vtype] Listening...", flush=True)
+            elif self.state == TRANSCRIBING:
+                pass  # busy — ignore
+            else:
+                self.state = IDLE
+                self.speech_buf = []
+                self.silence_cnt = 0
+                _notify("vtype", "Stopped")
+                print("[vtype] Stopped.", flush=True)
+
+    # ── Main loop ─────────────────────────────────────────────────────────────
+    def run(self):
+        print(f"vtype — loading speech model ({self.model_size})...", flush=True)
+        self.model = whisper.load_model(self.model_size)
+        print("Ready. Press Ctrl+Alt+V to start/stop voice input.", flush=True)
+        _notify("vtype", "Ready — press Ctrl+Alt+V to speak")
+
+        self.stream = sd.InputStream(
+            samplerate=SAMPLE_RATE, channels=1, dtype='float32',
+            blocksize=CHUNK_SIZE, callback=self._audio_cb
+        )
+        self.stream.start()
+
+        stop_event = threading.Event()
+        print("Press Ctrl+C to quit.", flush=True)
+        with keyboard.GlobalHotKeys({'<ctrl>+<alt>+v': self._toggle}):
+            try:
+                while not stop_event.is_set():
+                    stop_event.wait(timeout=0.5)
+            except KeyboardInterrupt:
+                pass
+
+        self.stream.stop()
+        print("vtype stopped.", flush=True)
+
+
+def main():
+    VType().run()
+
+
+if __name__ == '__main__':
+    main()