speakandcode 0.1.0__tar.gz

speakandcode-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Johnny Chien
+
+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.

speakandcode-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: speakandcode
+Version: 0.1.0
+Summary: Private voice-to-text for developers. Hold a key, speak, get text pasted into any app.
+Author: Johnny Chien
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/johnny-chien/voice-coding
+Project-URL: Repository, https://github.com/johnny-chien/voice-coding
+Keywords: voice,coding,transcription,developer-tools,voice-to-text
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sounddevice>=0.5
+Requires-Dist: soundfile>=0.12
+Requires-Dist: numpy>=1.24
+Requires-Dist: pynput>=1.7
+Requires-Dist: google-genai>=1.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: pyobjc-framework-Quartz>=9.0
+Dynamic: license-file
+
+# Voice Coding
+
+Private voice-to-text for developers. Hold a hotkey, speak, get text pasted into any app.
+
+- **Private** — audio goes to Gemini Flash (your own API key), nowhere else
+- **Fast** — ~1 second transcription via Gemini 3.0 Flash
+- **Universal** — auto-pastes into any focused app: VS Code, Terminal, Slack, browser, etc.
+- **Coding-aware** — "dot env" → `.env`, "camel case foo bar" → `fooBar`
+
+## Install
+
+```bash
+pip install speakandcode
+```
+
+## Setup
+
+1. Get a [Gemini API key](https://aistudio.google.com/apikey)
+2. Set your API key:
+   ```bash
+   export GEMINI_API_KEY=your_key_here
+   ```
+   Or create a `~/.voice-coding/.env` file:
+   ```
+   GEMINI_API_KEY=your_key_here
+   ```
+
+### macOS Permissions
+
+Your terminal app (Terminal.app / iTerm / VS Code) needs two permissions in **System Settings → Privacy & Security**:
+
+- **Microphone** — for audio recording
+- **Accessibility** — for global hotkey detection and auto-paste keystroke simulation
+
+After granting Accessibility, **restart your terminal app** for the permission to take effect.
+
+## Learn Project Vocabulary (Optional)
+
+Teach Voice Coding the vocabulary of any project you work on:
+
+```bash
+cd /path/to/your/project
+voice learn
+```
+
+This scans the repo (README, package.json, etc.) and merges its vocabulary into your global memory at `~/.voice-coding/memory.md`. Run it in each repo you work on — terms accumulate across projects.
+
+The memory file includes:
+
+- **Vocabulary** — project-specific terms with disambiguation hints (e.g., "Claude Code" not "clock code")
+- **Context** — brief descriptions of your projects and tech stacks
+- **Notes** — space for personal customizations (accent, language mixing, corrections you've noticed)
+
+Edit `~/.voice-coding/memory.md` anytime to add or fix terms.
+
+## Usage
+
+```bash
+voice
+```
+
+**Hold Alt (⌥)** to start recording. **Release Alt** to stop, transcribe, and auto-paste into whichever app is focused.
+
+Press **Ctrl+C** to quit.
+
+### Tips
+
+- Speak naturally — filler words (um, uh, like, you know) are automatically removed
+- Minor grammar is corrected while preserving your original wording
+- Recordings shorter than 0.5 seconds are ignored to prevent accidental triggers
+
+## Coding Transforms
+
+Voice Coding post-processes transcriptions with coding-aware rules:
+
+| You say | You get |
+|---------|---------|
+| "dot env" | `.env` |
+| "slash api" | `/api` |
+| "camel case foo bar" | `fooBar` |
+| "snake case my variable" | `my_variable` |
+| "open paren" | `(` |
+| "arrow" | `=>` |
+| "triple equals" | `===` |
+| "new line" | newline character |
+
+## How It Works
+
+1. A macOS `CGEventTap` listens for the Alt key globally (works in any app, including VS Code)
+2. `sounddevice` captures mic audio at 16kHz mono while the hotkey is held
+3. Audio is sent to Gemini 3.0 Flash for transcription, with vocabulary from `~/.voice-coding/memory.md` if present
+4. Post-processor applies coding-aware text transforms
+5. Result is copied to clipboard via `pbcopy` and pasted via `osascript` Cmd+V simulation

speakandcode-0.1.0/README.md

@@ -0,0 +1,93 @@
+# Voice Coding
+
+Private voice-to-text for developers. Hold a hotkey, speak, get text pasted into any app.
+
+- **Private** — audio goes to Gemini Flash (your own API key), nowhere else
+- **Fast** — ~1 second transcription via Gemini 3.0 Flash
+- **Universal** — auto-pastes into any focused app: VS Code, Terminal, Slack, browser, etc.
+- **Coding-aware** — "dot env" → `.env`, "camel case foo bar" → `fooBar`
+
+## Install
+
+```bash
+pip install speakandcode
+```
+
+## Setup
+
+1. Get a [Gemini API key](https://aistudio.google.com/apikey)
+2. Set your API key:
+   ```bash
+   export GEMINI_API_KEY=your_key_here
+   ```
+   Or create a `~/.voice-coding/.env` file:
+   ```
+   GEMINI_API_KEY=your_key_here
+   ```
+
+### macOS Permissions
+
+Your terminal app (Terminal.app / iTerm / VS Code) needs two permissions in **System Settings → Privacy & Security**:
+
+- **Microphone** — for audio recording
+- **Accessibility** — for global hotkey detection and auto-paste keystroke simulation
+
+After granting Accessibility, **restart your terminal app** for the permission to take effect.
+
+## Learn Project Vocabulary (Optional)
+
+Teach Voice Coding the vocabulary of any project you work on:
+
+```bash
+cd /path/to/your/project
+voice learn
+```
+
+This scans the repo (README, package.json, etc.) and merges its vocabulary into your global memory at `~/.voice-coding/memory.md`. Run it in each repo you work on — terms accumulate across projects.
+
+The memory file includes:
+
+- **Vocabulary** — project-specific terms with disambiguation hints (e.g., "Claude Code" not "clock code")
+- **Context** — brief descriptions of your projects and tech stacks
+- **Notes** — space for personal customizations (accent, language mixing, corrections you've noticed)
+
+Edit `~/.voice-coding/memory.md` anytime to add or fix terms.
+
+## Usage
+
+```bash
+voice
+```
+
+**Hold Alt (⌥)** to start recording. **Release Alt** to stop, transcribe, and auto-paste into whichever app is focused.
+
+Press **Ctrl+C** to quit.
+
+### Tips
+
+- Speak naturally — filler words (um, uh, like, you know) are automatically removed
+- Minor grammar is corrected while preserving your original wording
+- Recordings shorter than 0.5 seconds are ignored to prevent accidental triggers
+
+## Coding Transforms
+
+Voice Coding post-processes transcriptions with coding-aware rules:
+
+| You say | You get |
+|---------|---------|
+| "dot env" | `.env` |
+| "slash api" | `/api` |
+| "camel case foo bar" | `fooBar` |
+| "snake case my variable" | `my_variable` |
+| "open paren" | `(` |
+| "arrow" | `=>` |
+| "triple equals" | `===` |
+| "new line" | newline character |
+
+## How It Works
+
+1. A macOS `CGEventTap` listens for the Alt key globally (works in any app, including VS Code)
+2. `sounddevice` captures mic audio at 16kHz mono while the hotkey is held
+3. Audio is sent to Gemini 3.0 Flash for transcription, with vocabulary from `~/.voice-coding/memory.md` if present
+4. Post-processor applies coding-aware text transforms
+5. Result is copied to clipboard via `pbcopy` and pasted via `osascript` Cmd+V simulation

speakandcode-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "speakandcode"
+version = "0.1.0"
+description = "Private voice-to-text for developers. Hold a key, speak, get text pasted into any app."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [
+    { name = "Johnny Chien" },
+]
+keywords = ["voice", "coding", "transcription", "developer-tools", "voice-to-text"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: MacOS X",
+    "Intended Audience :: Developers",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "sounddevice>=0.5",
+    "soundfile>=0.12",
+    "numpy>=1.24",
+    "pynput>=1.7",
+    "google-genai>=1.0",
+    "python-dotenv>=1.0",
+    "pyobjc-framework-Quartz>=9.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/johnny-chien/voice-coding"
+Repository = "https://github.com/johnny-chien/voice-coding"
+
+[project.scripts]
+voice = "voice_coding.main:main"
+
+[tool.setuptools.packages.find]
+include = ["voice_coding*"]

speakandcode-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

speakandcode-0.1.0/speakandcode.egg-info/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: speakandcode
+Version: 0.1.0
+Summary: Private voice-to-text for developers. Hold a key, speak, get text pasted into any app.
+Author: Johnny Chien
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/johnny-chien/voice-coding
+Project-URL: Repository, https://github.com/johnny-chien/voice-coding
+Keywords: voice,coding,transcription,developer-tools,voice-to-text
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sounddevice>=0.5
+Requires-Dist: soundfile>=0.12
+Requires-Dist: numpy>=1.24
+Requires-Dist: pynput>=1.7
+Requires-Dist: google-genai>=1.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: pyobjc-framework-Quartz>=9.0
+Dynamic: license-file
+
+# Voice Coding
+
+Private voice-to-text for developers. Hold a hotkey, speak, get text pasted into any app.
+
+- **Private** — audio goes to Gemini Flash (your own API key), nowhere else
+- **Fast** — ~1 second transcription via Gemini 3.0 Flash
+- **Universal** — auto-pastes into any focused app: VS Code, Terminal, Slack, browser, etc.
+- **Coding-aware** — "dot env" → `.env`, "camel case foo bar" → `fooBar`
+
+## Install
+
+```bash
+pip install speakandcode
+```
+
+## Setup
+
+1. Get a [Gemini API key](https://aistudio.google.com/apikey)
+2. Set your API key:
+   ```bash
+   export GEMINI_API_KEY=your_key_here
+   ```
+   Or create a `~/.voice-coding/.env` file:
+   ```
+   GEMINI_API_KEY=your_key_here
+   ```
+
+### macOS Permissions
+
+Your terminal app (Terminal.app / iTerm / VS Code) needs two permissions in **System Settings → Privacy & Security**:
+
+- **Microphone** — for audio recording
+- **Accessibility** — for global hotkey detection and auto-paste keystroke simulation
+
+After granting Accessibility, **restart your terminal app** for the permission to take effect.
+
+## Learn Project Vocabulary (Optional)
+
+Teach Voice Coding the vocabulary of any project you work on:
+
+```bash
+cd /path/to/your/project
+voice learn
+```
+
+This scans the repo (README, package.json, etc.) and merges its vocabulary into your global memory at `~/.voice-coding/memory.md`. Run it in each repo you work on — terms accumulate across projects.
+
+The memory file includes:
+
+- **Vocabulary** — project-specific terms with disambiguation hints (e.g., "Claude Code" not "clock code")
+- **Context** — brief descriptions of your projects and tech stacks
+- **Notes** — space for personal customizations (accent, language mixing, corrections you've noticed)
+
+Edit `~/.voice-coding/memory.md` anytime to add or fix terms.
+
+## Usage
+
+```bash
+voice
+```
+
+**Hold Alt (⌥)** to start recording. **Release Alt** to stop, transcribe, and auto-paste into whichever app is focused.
+
+Press **Ctrl+C** to quit.
+
+### Tips
+
+- Speak naturally — filler words (um, uh, like, you know) are automatically removed
+- Minor grammar is corrected while preserving your original wording
+- Recordings shorter than 0.5 seconds are ignored to prevent accidental triggers
+
+## Coding Transforms
+
+Voice Coding post-processes transcriptions with coding-aware rules:
+
+| You say | You get |
+|---------|---------|
+| "dot env" | `.env` |
+| "slash api" | `/api` |
+| "camel case foo bar" | `fooBar` |
+| "snake case my variable" | `my_variable` |
+| "open paren" | `(` |
+| "arrow" | `=>` |
+| "triple equals" | `===` |
+| "new line" | newline character |
+
+## How It Works
+
+1. A macOS `CGEventTap` listens for the Alt key globally (works in any app, including VS Code)
+2. `sounddevice` captures mic audio at 16kHz mono while the hotkey is held
+3. Audio is sent to Gemini 3.0 Flash for transcription, with vocabulary from `~/.voice-coding/memory.md` if present
+4. Post-processor applies coding-aware text transforms
+5. Result is copied to clipboard via `pbcopy` and pasted via `osascript` Cmd+V simulation

speakandcode-0.1.0/speakandcode.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+speakandcode.egg-info/PKG-INFO
+speakandcode.egg-info/SOURCES.txt
+speakandcode.egg-info/dependency_links.txt
+speakandcode.egg-info/entry_points.txt
+speakandcode.egg-info/requires.txt
+speakandcode.egg-info/top_level.txt
+voice_coding/__init__.py
+voice_coding/clipboard.py
+voice_coding/learn_cmd.py
+voice_coding/main.py
+voice_coding/memory.py
+voice_coding/postprocessor.py
+voice_coding/recorder.py
+voice_coding/transcriber.py

speakandcode-0.1.0/speakandcode.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

speakandcode-0.1.0/speakandcode.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+voice = voice_coding.main:main

speakandcode-0.1.0/speakandcode.egg-info/requires.txt

@@ -0,0 +1,7 @@
+sounddevice>=0.5
+soundfile>=0.12
+numpy>=1.24
+pynput>=1.7
+google-genai>=1.0
+python-dotenv>=1.0
+pyobjc-framework-Quartz>=9.0

speakandcode-0.1.0/speakandcode.egg-info/top_level.txt

@@ -0,0 +1 @@
+voice_coding

speakandcode-0.1.0/voice_coding/__init__.py

@@ -0,0 +1 @@
+"""Voice Coding — Private voice-to-text for developers."""

speakandcode-0.1.0/voice_coding/clipboard.py

@@ -0,0 +1,23 @@
+"""Copy text to clipboard and auto-paste into the focused app."""
+
+import subprocess
+import time
+
+
+def copy_and_paste(text: str):
+    """Copy text to macOS clipboard via pbcopy, then simulate Cmd+V."""
+    # Copy to clipboard
+    subprocess.run(["pbcopy"], input=text.encode(), check=True)
+
+    # Small delay for clipboard to settle
+    time.sleep(0.05)
+
+    # Simulate Cmd+V in the focused app
+    subprocess.run(
+        [
+            "osascript",
+            "-e",
+            'tell application "System Events" to keystroke "v" using command down',
+        ],
+        check=True,
+    )

speakandcode-0.1.0/voice_coding/learn_cmd.py

@@ -0,0 +1,137 @@
+"""voice learn — scan a repo and merge its vocabulary into global memory."""
+
+import os
+import sys
+from pathlib import Path
+
+from dotenv import load_dotenv
+from google import genai
+from google.genai import types
+
+LEARN_MODEL = "gemini-3-flash-preview"
+
+GLOBAL_MEMORY_DIR = Path.home() / ".voice-coding"
+GLOBAL_MEMORY_FILE = GLOBAL_MEMORY_DIR / "memory.md"
+
+LEARN_PROMPT = """\
+You are helping a developer add project-specific vocabulary to their voice-to-text memory file.
+
+Given:
+1. The developer's EXISTING memory file (may be empty if this is their first time)
+2. A NEW project's context (README, package files, etc.)
+
+Generate an UPDATED memory file that MERGES the new project's vocabulary into the existing one.
+
+Rules:
+- Keep ALL existing vocabulary entries — do not remove anything
+- Add new terms from the project that are not already covered
+- If a term already exists, keep the existing entry (don't duplicate)
+- Keep all existing Context and Notes sections, and append new context about this project
+- Focus on terms that a speech-to-text model might get wrong
+- For each new term, add a disambiguation hint explaining what it is and what it should NOT be confused with
+- Example entry: | Claude Code | AI coding assistant CLI, not "clock code" or "cloud code" |
+
+The file should have these sections:
+
+## Vocabulary
+
+A markdown table with columns: Term | Hint
+(merged from existing + new project)
+
+## Context
+
+Brief descriptions of all projects the developer works on.
+
+## Notes
+
+Keep any existing notes. If this is the first time, add HTML comment examples:
+<!-- Add your own notes here -->
+<!-- Examples: -->
+<!-- - I have a [nationality] accent -->
+<!-- - When I say "X", I usually mean Y -->
+<!-- - I sometimes mix [language] and English -->
+
+Output ONLY the markdown content. Start with "# Voice Coding Memory" as the first line.
+Do NOT wrap in code fences.
+"""
+
+
+def _gather_repo_context(repo_dir: Path) -> str:
+    """Read key files from the repo to send as context."""
+    context_parts = []
+
+    for filename in [
+        "README.md",
+        "README",
+        "package.json",
+        "pyproject.toml",
+        "Cargo.toml",
+        "go.mod",
+        "Gemfile",
+        "CLAUDE.md",
+        "requirements.txt",
+    ]:
+        filepath = repo_dir / filename
+        if filepath.is_file():
+            content = filepath.read_text(encoding="utf-8", errors="ignore")[:4000]
+            context_parts.append(f"=== {filename} ===\n{content}")
+
+    try:
+        entries = sorted(p.name for p in repo_dir.iterdir() if not p.name.startswith("."))
+        context_parts.append(f"=== Directory listing ===\n{chr(10).join(entries)}")
+    except OSError:
+        pass
+
+    return "\n\n".join(context_parts)
+
+
+def run_learn():
+    """Scan current repo and merge its vocabulary into global memory."""
+    load_dotenv()
+    global_env = GLOBAL_MEMORY_DIR / ".env"
+    if not os.environ.get("GEMINI_API_KEY") and global_env.is_file():
+        load_dotenv(global_env)
+
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if not api_key:
+        print("Error: GEMINI_API_KEY not set.")
+        print("  Option 1: export GEMINI_API_KEY=your_key")
+        print(f"  Option 2: echo 'GEMINI_API_KEY=your_key' > {global_env}")
+        sys.exit(1)
+
+    repo_dir = Path.cwd()
+
+    print(f"Scanning {repo_dir.name}/ ...")
+    repo_context = _gather_repo_context(repo_dir)
+
+    if not repo_context.strip():
+        print("Warning: No project files found. Generating generic vocabulary.")
+
+    # Load existing global memory
+    existing_memory = ""
+    if GLOBAL_MEMORY_FILE.is_file():
+        existing_memory = GLOBAL_MEMORY_FILE.read_text(encoding="utf-8")
+        print(f"Found existing memory at {GLOBAL_MEMORY_FILE}")
+
+    print("Generating vocabulary with Gemini...")
+    client = genai.Client(api_key=api_key)
+
+    response = client.models.generate_content(
+        model=LEARN_MODEL,
+        contents=[
+            LEARN_PROMPT,
+            f"=== Existing memory file ===\n\n{existing_memory}" if existing_memory else "=== Existing memory file ===\n\n(empty — first time setup)",
+            f"=== New project context ===\n\n{repo_context}",
+        ],
+        config=types.GenerateContentConfig(
+            max_output_tokens=4096,
+        ),
+    )
+
+    memory_content = response.text.strip()
+
+    GLOBAL_MEMORY_DIR.mkdir(exist_ok=True)
+    GLOBAL_MEMORY_FILE.write_text(memory_content + "\n", encoding="utf-8")
+
+    print(f"Updated {GLOBAL_MEMORY_FILE}")
+    print("Edit this file anytime to add or fix terms.")

speakandcode-0.1.0/voice_coding/main.py

@@ -0,0 +1,137 @@
+"""Entry point — CLI router and global hotkey listener."""
+
+import os
+import sys
+import threading
+from pathlib import Path
+
+import Quartz
+from dotenv import load_dotenv
+
+from voice_coding.clipboard import copy_and_paste
+from voice_coding.postprocessor import postprocess
+from voice_coding.recorder import Recorder, SAMPLE_RATE
+from voice_coding.transcriber import transcribe
+
+GLOBAL_ENV = Path.home() / ".voice-coding" / ".env"
+
+
+def _load_env():
+    """Load .env from cwd first, then global ~/.voice-coding/.env as fallback."""
+    load_dotenv()
+    if not os.environ.get("GEMINI_API_KEY") and GLOBAL_ENV.is_file():
+        load_dotenv(GLOBAL_ENV)
+
+
+def _run_listener():
+    """Run the hold-to-record voice coding listener."""
+    _load_env()
+
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if not api_key:
+        print("Error: GEMINI_API_KEY not set.")
+        print("  Option 1: export GEMINI_API_KEY=your_key")
+        print(f"  Option 2: echo 'GEMINI_API_KEY=your_key' > {GLOBAL_ENV}")
+        sys.exit(1)
+
+    recorder = Recorder()
+    recording = False
+    alt_held = False
+    processing = False
+
+    def _finish_recording():
+        nonlocal recording, processing
+        if processing:
+            return
+        recording = False
+        processing = True
+        print("\r⏳ Transcribing...", end="", flush=True)
+
+        wav_bytes = recorder.stop()
+        if not wav_bytes:
+            print("\r⏳ Too short, skipped.      ")
+            processing = False
+            return
+
+        try:
+            duration_secs = len(wav_bytes) / (SAMPLE_RATE * 4)
+            print(f"\r⏳ Transcribing {duration_secs:.1f}s of audio ({len(wav_bytes) / 1024:.0f} KB)...", end="", flush=True)
+
+            raw_text = transcribe(wav_bytes, api_key)
+            print(f"\n📝 Raw transcription ({len(raw_text)} chars):")
+            print(f"--- START ---\n{raw_text}\n--- END ---")
+
+            text = postprocess(raw_text)
+            if text != raw_text:
+                print(f"📝 After postprocess ({len(text)} chars):")
+                print(f"--- START ---\n{text}\n--- END ---")
+
+            copy_and_paste(text)
+            print(f"✅ Pasted ({len(text)} chars)")
+        except Exception as e:
+            print(f"\r❌ Error: {e}      ")
+        finally:
+            processing = False
+
+    def cg_event_callback(proxy, event_type, event, refcon):
+        nonlocal recording, alt_held
+
+        if event_type == Quartz.kCGEventFlagsChanged:
+            flags = Quartz.CGEventGetFlags(event)
+            alt_now = bool(flags & Quartz.kCGEventFlagMaskAlternate)
+            if alt_now and not alt_held:
+                alt_held = True
+                if not recording and not processing:
+                    recording = True
+                    recorder.start()
+                    print("\r🎙  Recording... (release Alt to stop)", end="", flush=True)
+            elif not alt_now and alt_held:
+                alt_held = False
+                if recording:
+                    threading.Thread(target=_finish_recording, daemon=True).start()
+
+        return event
+
+    event_mask = (1 << Quartz.kCGEventFlagsChanged)
+
+    tap = Quartz.CGEventTapCreate(
+        Quartz.kCGSessionEventTap,
+        Quartz.kCGHeadInsertEventTap,
+        Quartz.kCGEventTapOptionDefault,
+        event_mask,
+        cg_event_callback,
+        None,
+    )
+
+    if tap is None:
+        print("Error: Failed to create event tap. Grant Accessibility permission to your terminal app.")
+        print("  System Settings → Privacy & Security → Accessibility")
+        sys.exit(1)
+
+    run_loop_source = Quartz.CFMachPortCreateRunLoopSource(None, tap, 0)
+    Quartz.CFRunLoopAddSource(
+        Quartz.CFRunLoopGetCurrent(),
+        run_loop_source,
+        Quartz.kCFRunLoopCommonModes,
+    )
+    Quartz.CGEventTapEnable(tap, True)
+
+    print("Voice Coding running. Hold Alt to record. Release Alt to stop. Ctrl+C to quit.")
+
+    try:
+        Quartz.CFRunLoopRun()
+    except KeyboardInterrupt:
+        print("\nStopped.")
+
+
+def main():
+    """CLI entry point — route to subcommand or default listener."""
+    if len(sys.argv) > 1 and sys.argv[1] == "learn":
+        from voice_coding.learn_cmd import run_learn
+        run_learn()
+    else:
+        _run_listener()
+
+
+if __name__ == "__main__":
+    main()

speakandcode-0.1.0/voice_coding/memory.py

@@ -0,0 +1,12 @@
+"""Load global voice coding memory from ~/.voice-coding/memory.md."""
+
+from pathlib import Path
+
+GLOBAL_MEMORY_FILE = Path.home() / ".voice-coding" / "memory.md"
+
+
+def load_memory() -> str:
+    """Load global memory.md content, or return empty string if not found."""
+    if GLOBAL_MEMORY_FILE.is_file():
+        return GLOBAL_MEMORY_FILE.read_text(encoding="utf-8")
+    return ""

speakandcode-0.1.0/voice_coding/postprocessor.py

@@ -0,0 +1,72 @@
+"""Coding-aware text transforms applied after transcription."""
+
+import re
+
+CODING_RULES: dict[str, str] = {
+    "dot env": ".env",
+    "double equals": "==",
+    "triple equals": "===",
+    "not equals": "!=",
+    "arrow": "=>",
+    "slash": "/",
+    "dot": ".",
+    "dash": "-",
+    "underscore": "_",
+    "equals": "=",
+    "hash": "#",
+    "at sign": "@",
+    "ampersand": "&",
+    "pipe": "|",
+    "tilde": "~",
+    "backtick": "`",
+    "open paren": "(",
+    "close paren": ")",
+    "open bracket": "[",
+    "close bracket": "]",
+    "open brace": "{",
+    "close brace": "}",
+    "new line": "\n",
+    "tab": "\t",
+}
+
+
+def _apply_coding_rules(text: str) -> str:
+    """Replace spoken coding phrases with their symbol equivalents."""
+    # Sort by length descending so multi-word rules match first
+    for phrase, replacement in sorted(
+        CODING_RULES.items(), key=lambda x: len(x[0]), reverse=True
+    ):
+        # Use word boundaries to avoid matching inside words (e.g. "dash" in "Dashboard")
+        pattern = r"\b" + re.escape(phrase) + r"\b"
+        text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
+    return text
+
+
+def _apply_camel_case(text: str) -> str:
+    """Convert 'camel case foo bar baz' → 'fooBarBaz'."""
+
+    def _to_camel(m: re.Match) -> str:
+        words = m.group(1).strip().split()
+        if not words:
+            return ""
+        return words[0].lower() + "".join(w.capitalize() for w in words[1:])
+
+    return re.sub(r"camel case\s+((?:\w+\s*){2,})", _to_camel, text, flags=re.IGNORECASE)
+
+
+def _apply_snake_case(text: str) -> str:
+    """Convert 'snake case foo bar baz' → 'foo_bar_baz'."""
+
+    def _to_snake(m: re.Match) -> str:
+        words = m.group(1).strip().split()
+        return "_".join(w.lower() for w in words)
+
+    return re.sub(r"snake case\s+((?:\w+\s*){2,})", _to_snake, text, flags=re.IGNORECASE)
+
+
+def postprocess(text: str) -> str:
+    """Apply all coding-aware transforms to transcribed text."""
+    text = _apply_camel_case(text)
+    text = _apply_snake_case(text)
+    text = _apply_coding_rules(text)
+    return text

speakandcode-0.1.0/voice_coding/recorder.py

@@ -0,0 +1,64 @@
+"""Microphone capture using sounddevice."""
+
+import io
+import threading
+import time
+
+import numpy as np
+import sounddevice as sd
+import soundfile as sf
+
+SAMPLE_RATE = 16000
+CHANNELS = 1
+DTYPE = "float32"
+MIN_DURATION_SECS = 0.5  # Ignore recordings shorter than this
+
+
+class Recorder:
+    def __init__(self):
+        self._frames: list[np.ndarray] = []
+        self._stream: sd.InputStream | None = None
+        self._lock = threading.Lock()
+        self._start_time: float = 0
+
+    def start(self):
+        """Open mic stream and start accumulating audio frames."""
+        with self._lock:
+            self._frames = []
+            self._start_time = time.monotonic()
+            self._stream = sd.InputStream(
+                samplerate=SAMPLE_RATE,
+                channels=CHANNELS,
+                dtype=DTYPE,
+                callback=self._callback,
+            )
+            self._stream.start()
+
+    def stop(self) -> bytes:
+        """Stop recording and return WAV bytes. Returns empty if too short."""
+        with self._lock:
+            duration = time.monotonic() - self._start_time
+
+            if self._stream is not None:
+                self._stream.stop()
+                self._stream.close()
+                self._stream = None
+
+            if not self._frames or duration < MIN_DURATION_SECS:
+                self._frames = []
+                return b""
+
+            audio = np.concatenate(self._frames, axis=0)
+            num_frames = len(self._frames)
+            self._frames = []
+
+        buf = io.BytesIO()
+        sf.write(buf, audio, SAMPLE_RATE, format="WAV", subtype="FLOAT")
+        wav_bytes = buf.getvalue()
+        print(f"🎙  Recorded {duration:.1f}s ({num_frames} chunks, {len(audio)} samples, {len(wav_bytes) / 1024:.0f} KB WAV)")
+        return wav_bytes
+
+    def _callback(self, indata: np.ndarray, frames: int, time_info, status):
+        if status:
+            pass  # silently ignore overflow warnings
+        self._frames.append(indata.copy())

speakandcode-0.1.0/voice_coding/transcriber.py

@@ -0,0 +1,64 @@
+"""Gemini Flash transcription."""
+
+from google import genai
+from google.genai import types
+
+from voice_coding.memory import load_memory
+
+MODEL = "gemini-3-flash-preview"
+
+BASE_PROMPT = (
+    "Transcribe this audio exactly as spoken. Output ONLY the transcription text. "
+    "No preamble, no labels, no commentary. Start directly with the spoken content. "
+    "Rules:\n"
+    "- Remove filler words: um, uh, like, you know, hmm, so, basically, right\n"
+    "- Fix minor grammar issues (subject-verb agreement, missing articles) but preserve the speaker's original wording and meaning\n"
+    "- Do NOT rephrase, summarize, or add content that was not spoken\n"
+    "- Do NOT hallucinate or generate text if the audio is silent or unclear — output nothing instead\n"
+    "- Preserve technical terms, code references, and proper nouns exactly as spoken\n"
+    "- This is a software developer dictating into a text field\n"
+    "- Default developer vocabulary (prefer these spellings when the audio matches):\n"
+    "  - 'VS Code' (editor, not 'V.S. code')\n"
+    "  - 'GitHub' (not 'get hub')\n"
+    "  - 'npm' (package manager)\n"
+    "  - 'API' (not 'A.P.I.')\n"
+    "  - 'CLI' (command line interface)\n"
+    "  - 'JSON' (not 'Jason')\n"
+    "  - 'regex' (regular expression)\n"
+    "  - 'localhost' (not 'local host')"
+)
+
+
+def _build_prompt() -> str:
+    """Build transcription prompt, appending memory.md if found."""
+    memory = load_memory()
+    if not memory:
+        return BASE_PROMPT
+    return BASE_PROMPT + "\n\n--- Project-specific context (from .voice-coding/memory.md) ---\n\n" + memory
+
+
+def transcribe(wav_bytes: bytes, api_key: str) -> str:
+    """Send WAV audio to Gemini Flash and return the transcription text."""
+    client = genai.Client(api_key=api_key)
+    prompt = _build_prompt()
+
+    response = client.models.generate_content(
+        model=MODEL,
+        contents=[
+            prompt,
+            types.Part.from_bytes(data=wav_bytes, mime_type="audio/wav"),
+        ],
+        config=types.GenerateContentConfig(
+            max_output_tokens=8192,
+        ),
+    )
+
+    # Log finish reason and token usage for debugging
+    if response.candidates:
+        candidate = response.candidates[0]
+        print(f"🔍 Finish reason: {candidate.finish_reason}")
+    if response.usage_metadata:
+        meta = response.usage_metadata
+        print(f"🔍 Tokens — prompt: {meta.prompt_token_count}, output: {meta.candidates_token_count}")
+
+    return response.text.strip()