claude-code-tools 1.19.4__tar.gz → 1.19.6__tar.gz

{claude_code_tools-1.19.4 → claude_code_tools-1.19.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 1.19.4
+Version: 1.19.6
 Summary: Collection of tools for working with Claude Code
 License-File: LICENSE
 Requires-Python: >=3.11

{claude_code_tools-1.19.4 → claude_code_tools-1.19.6}/claude_code_tools/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Tools - Collection of utilities for Claude Code."""
 
-__version__ = "1.19.4"
+__version__ = "1.19.6"

{claude_code_tools-1.19.4 → claude_code_tools-1.19.6}/claude_code_tools/voice_type/app.py

@@ -15,7 +15,7 @@ from enum import Enum
 from typing import Callable
 
 from .config import Config
-from .inject import Typist, copy_to_clipboard, play_sound
+from .inject import SoundPlayer, Typist, copy_to_clipboard
 from .logic import (
     collapse_repeats,
     contains_phrase,
@@ -44,6 +44,9 @@ class VoiceTypeApp:
     def __init__(self, cfg: Config) -> None:
         self.cfg = cfg
         self.typist = Typist()
+        # Preload the chimes so the first one is instant and in sync
+        # with the overlay (afplay would lag ~100 ms behind the pill).
+        self._sound = SoundPlayer(cfg.sound_start, cfg.sound_stop)
         self._lock = threading.Lock()
         self._state = (
             State.ACTIVE
@@ -140,7 +143,7 @@ class VoiceTypeApp:
             if pre_msg is not None:
                 self._status(pre_msg)
             if self.cfg.sounds and State.ACTIVE in (old, new):
-                play_sound(
+                self._sound.play(
                     self.cfg.sound_start
                     if new == State.ACTIVE
                     else self.cfg.sound_stop

claude_code_tools-1.19.6/claude_code_tools/voice_type/inject.py

@@ -0,0 +1,167 @@
+"""Keystroke injection and audio feedback.
+
+Typing goes through pynput's ``keyboard.Controller``, which synthesizes
+key events into whatever application currently has focus. On macOS the
+process running voice-type (your terminal) needs Accessibility permission
+(System Settings > Privacy & Security > Accessibility).
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+_SYSTEM_SOUNDS = Path("/System/Library/Sounds")
+
+
+class Typist:
+    """Types text into the focused application via synthetic key events."""
+
+    def __init__(self) -> None:
+        from pynput.keyboard import Controller
+
+        self._keyboard = Controller()
+
+    def type_text(self, text: str) -> None:
+        """Type ``text`` at the current cursor position."""
+        self._keyboard.type(text)
+
+    def press_enter(self) -> None:
+        """Press Enter in the focused application."""
+        from pynput.keyboard import Key
+
+        self._keyboard.tap(Key.enter)
+
+
+def _resolve_sound(name: str) -> Path | None:
+    """Map a sound name or path to an existing file, or None."""
+    if not name:
+        return None
+    p = Path(name) if "/" in name else _SYSTEM_SOUNDS / f"{name}.aiff"
+    return p if p.exists() else None
+
+
+def play_sound(name: str) -> None:
+    """Play a sound by spawning ``afplay`` (the fallback path).
+
+    Higher-latency than :class:`SoundPlayer` because afplay's own
+    CoreAudio startup delays audio-out ~100 ms; used only when the
+    preloaded AudioServices path is unavailable. No-ops off macOS / on
+    missing files.
+    """
+    sound = _resolve_sound(name) if sys.platform == "darwin" else None
+    if sound is None:
+        return
+    subprocess.Popen(
+        ["afplay", str(sound)],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+class SoundPlayer:
+    """Instant start/stop sounds via CoreAudio ``AudioServices``.
+
+    Spawning ``afplay`` per sound delays audio-out ~100 ms behind the
+    in-process overlay, so the chime lands visibly after the waveform
+    pill. AudioServices plays a *preloaded* system-sound id in well
+    under a millisecond with no run loop, keeping sound and pill in
+    sync. Sounds are registered once at construction; playback is
+    thread-safe and asynchronous. Falls back to ``afplay`` when the
+    framework can't be loaded, and no-ops off macOS.
+    """
+
+    def __init__(self, *names: str) -> None:
+        self._ids: dict[str, int] = {}
+        self._at = None
+        self._cf = None
+        self._ctypes = None
+        if sys.platform == "darwin":
+            try:
+                import ctypes
+                import ctypes.util
+
+                self._ctypes = ctypes
+                at = ctypes.CDLL(ctypes.util.find_library("AudioToolbox"))
+                cf = ctypes.CDLL(
+                    ctypes.util.find_library("CoreFoundation")
+                )
+                cf.CFURLCreateFromFileSystemRepresentation.restype = (
+                    ctypes.c_void_p
+                )
+                cf.CFURLCreateFromFileSystemRepresentation.argtypes = [
+                    ctypes.c_void_p,
+                    ctypes.c_char_p,
+                    ctypes.c_long,
+                    ctypes.c_bool,
+                ]
+                cf.CFRelease.argtypes = [ctypes.c_void_p]
+                at.AudioServicesCreateSystemSoundID.restype = (
+                    ctypes.c_int32
+                )
+                at.AudioServicesCreateSystemSoundID.argtypes = [
+                    ctypes.c_void_p,
+                    ctypes.POINTER(ctypes.c_uint32),
+                ]
+                at.AudioServicesPlaySystemSound.argtypes = [
+                    ctypes.c_uint32
+                ]
+                self._at, self._cf = at, cf
+            except Exception:
+                self._at = None
+        for name in names:
+            self._sid(name)  # preload so the first play is instant
+
+    def _sid(self, name: str) -> int | None:
+        """Return the (cached) system-sound id for ``name``, or None."""
+        if not name or self._at is None:
+            return None
+        if name in self._ids:
+            return self._ids[name]
+        path = _resolve_sound(name)
+        if path is None:
+            return None
+        try:
+            raw = str(path).encode()
+            url = self._cf.CFURLCreateFromFileSystemRepresentation(
+                None, raw, len(raw), False
+            )
+            if not url:
+                return None
+            sid = self._ctypes.c_uint32(0)
+            err = self._at.AudioServicesCreateSystemSoundID(
+                url, self._ctypes.byref(sid)
+            )
+            self._cf.CFRelease(url)
+            if err != 0 or sid.value == 0:
+                return None
+            self._ids[name] = sid.value
+            return sid.value
+        except Exception:
+            return None
+
+    def play(self, name: str) -> None:
+        """Play ``name`` instantly; fall back to afplay if needed."""
+        if not name or sys.platform != "darwin":
+            return
+        sid = self._sid(name)
+        if sid is not None:
+            try:
+                self._at.AudioServicesPlaySystemSound(sid)
+                return
+            except Exception:
+                pass
+        play_sound(name)
+
+
+def copy_to_clipboard(text: str) -> None:
+    """Put ``text`` on the macOS clipboard (no-op elsewhere/on failure)."""
+    if sys.platform != "darwin" or not text:
+        return
+    try:
+        subprocess.run(
+            ["pbcopy"], input=text.encode(), check=False, timeout=5
+        )
+    except Exception:
+        pass

{claude_code_tools-1.19.4 → claude_code_tools-1.19.6}/claude_code_tools/voice_type/overlay.py

@@ -21,11 +21,12 @@ from typing import Callable
 SampleFn = Callable[[], tuple[str, bool, float]]
 TickFn = Callable[[], None]
 
-_WIDTH = 280.0
-_HEIGHT = 46.0
-_MARGIN_BOTTOM = 96.0
-_BARS = 64
-_TICK_SECONDS = 0.05
+_WIDTH = 200.0
+_HEIGHT = 150.0
+_MARGIN_BOTTOM = 120.0
+# Points around the blob's rim (smoothness) and frame rate.
+_BLOB_POINTS = 108
+_TICK_SECONDS = 0.033  # ~30 fps, smooth wobble
 
 
 def overlay_available() -> bool:
@@ -59,6 +60,7 @@ def run_overlay(sample: SampleFn, tick: TickFn, stopped: Callable[[], bool]) ->
         NSBackingStoreBuffered,
         NSBezierPath,
         NSColor,
+        NSGradient,
         NSMakeRect,
         NSPanel,
         NSScreen,
@@ -66,60 +68,96 @@ def run_overlay(sample: SampleFn, tick: TickFn, stopped: Callable[[], bool]) ->
     )
 
     class WaveView(AppKit.NSView):  # noqa: D401
-        """Draws the pill background, state dot, and scrolling bars."""
+        """A glowing blue blob that wobbles and swells with the voice.
+
+        A soft orb sits at the bottom of the screen: it breathes gently
+        in silence and, as the live gain-adjusted mic level rises, its
+        rim deforms (organic multi-harmonic wobble) and the whole blob
+        swells — so its shape reflects the actual audio. Bluish, with a
+        radial gradient core, a rim highlight, and an outer halo for
+        presence.
+        """
 
         def initWithFrame_(self, frame):  # noqa: ANN001, ANN201, N802
             self = objc.super(WaveView, self).initWithFrame_(frame)
             if self is None:
                 return None
-            self.levels = [0.0] * _BARS
+            self.amp = 0.0  # smoothed audio level driving the wobble
+            self.phase = 0.0
             self.recording = False
-            self.label = ""
             return self
 
         def push_(self, sample):  # noqa: ANN001, ANN201, N802
-            label, recording, level = sample
-            self.levels = self.levels[1:] + [max(0.0, min(1.0, level))]
+            _label, recording, level = sample
+            level = max(0.0, min(1.0, float(level)))
+            # Fast attack, slow release: pops on speech, settles gently.
+            k = 0.55 if level > self.amp else 0.15
+            self.amp += k * (level - self.amp)
+            self.phase += 0.16
             self.recording = bool(recording)
-            self.label = str(label)
             self.setNeedsDisplay_(True)
 
+        def _blob_path(self, cx, cy, base_r):  # noqa: ANN001, ANN202
+            import math
+
+            path = NSBezierPath.bezierPath()
+            wob = 0.09 + 0.42 * self.amp      # rim deformation depth
+            breathe = 0.05 * math.sin(self.phase * 0.5)
+            swell = 1.0 + 0.24 * self.amp     # overall growth with volume
+            for i in range(_BLOB_POINTS + 1):
+                a = 2.0 * math.pi * i / _BLOB_POINTS
+                shape = (
+                    math.sin(3 * a + self.phase)
+                    + 0.6 * math.sin(5 * a - 1.3 * self.phase)
+                    + 0.3 * math.sin(7 * a + 1.7 * self.phase)
+                ) / 1.9
+                r = base_r * swell * (1.0 + breathe + wob * shape)
+                x = cx + r * math.cos(a)
+                y = cy + r * math.sin(a)
+                if i == 0:
+                    path.moveToPoint_((x, y))
+                else:
+                    path.lineToPoint_((x, y))
+            path.closePath()
+            return path
+
         def drawRect_(self, rect):  # noqa: ANN001, ANN201, N802
             b = self.bounds()
-            pill = NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(
-                b, b.size.height / 2, b.size.height / 2
+            cx, cy = b.size.width / 2, b.size.height / 2
+            base_r = min(b.size.width, b.size.height) * 0.26
+
+            # outer halo for presence
+            halo = self._blob_path(cx, cy, base_r * 1.28)
+            NSColor.colorWithCalibratedRed_green_blue_alpha_(
+                0.30, 0.62, 1.0, 0.20
+            ).setFill()
+            halo.fill()
+
+            # the blob: radial gradient core -> deeper blue rim
+            blob = self._blob_path(cx, cy, base_r)
+            core = NSColor.colorWithCalibratedRed_green_blue_alpha_(
+                0.60, 0.85, 1.0, 0.85
             )
-            NSColor.colorWithCalibratedWhite_alpha_(0.08, 0.82).setFill()
-            pill.fill()
-            if self.recording:
-                bar_color = NSColor.colorWithCalibratedRed_green_blue_alpha_(
-                    1.0, 0.27, 0.23, 1.0
-                )
-            else:
-                bar_color = NSColor.colorWithCalibratedWhite_alpha_(
-                    0.62, 0.9
-                )
-            bar_color.setFill()
-            # state dot on the left
-            dot = 8.0
-            dot_rect = NSMakeRect(
-                14.0, (b.size.height - dot) / 2, dot, dot
+            edge = NSColor.colorWithCalibratedRed_green_blue_alpha_(
+                0.16, 0.44, 0.98, 0.70
+            )
+            grad = NSGradient.alloc().initWithStartingColor_endingColor_(
+                core, edge
             )
-            NSBezierPath.bezierPathWithOvalInRect_(dot_rect).fill()
-            # scrolling waveform bars, mirrored around the centerline
-            left = 30.0
-            right = 14.0
-            span = b.size.width - left - right
-            bw = span / _BARS
-            mid = b.size.height / 2
-            max_half = b.size.height / 2 - 7.0
-            for i, level in enumerate(self.levels):
-                half = max(1.0, level * max_half)
-                x = left + i * bw
-                bar = NSMakeRect(x, mid - half, max(1.0, bw - 2.0), 2 * half)
-                NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(
-                    bar, 1.0, 1.0
-                ).fill()
+            if grad is not None:
+                grad.drawInBezierPath_relativeCenterPosition_(
+                    blob, (0.0, 0.28)
+                )
+            else:  # pragma: no cover - gradient unavailable
+                edge.setFill()
+                blob.fill()
+
+            # bright rim
+            NSColor.colorWithCalibratedRed_green_blue_alpha_(
+                0.75, 0.92, 1.0, 0.9
+            ).setStroke()
+            blob.setLineWidth_(2.0)
+            blob.stroke()
 
     class Driver(AppKit.NSObject):
         """NSTimer target: samples audio, ticks the app, ends the loop.

{claude_code_tools-1.19.4 → claude_code_tools-1.19.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-code-tools"
-version = "1.19.4"
+version = "1.19.6"
 description = "Collection of tools for working with Claude Code"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -131,7 +131,7 @@ markers = [
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "1.19.4"
+version = "1.19.6"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:version",

claude_code_tools-1.19.4/claude_code_tools/voice_type/inject.py

@@ -1,69 +0,0 @@
-"""Keystroke injection and audio feedback.
-
-Typing goes through pynput's ``keyboard.Controller``, which synthesizes
-key events into whatever application currently has focus. On macOS the
-process running voice-type (your terminal) needs Accessibility permission
-(System Settings > Privacy & Security > Accessibility).
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-_SYSTEM_SOUNDS = Path("/System/Library/Sounds")
-
-
-class Typist:
-    """Types text into the focused application via synthetic key events."""
-
-    def __init__(self) -> None:
-        from pynput.keyboard import Controller
-
-        self._keyboard = Controller()
-
-    def type_text(self, text: str) -> None:
-        """Type ``text`` at the current cursor position."""
-        self._keyboard.type(text)
-
-    def press_enter(self) -> None:
-        """Press Enter in the focused application."""
-        from pynput.keyboard import Key
-
-        self._keyboard.tap(Key.enter)
-
-
-def play_sound(name: str) -> None:
-    """Play a named macOS system sound or a sound file path.
-
-    ``name`` is either a system sound name (e.g. "Glass", "Bottle" —
-    see /System/Library/Sounds) or an absolute path to an audio file.
-    Silently no-ops off macOS, on empty names, and on missing files.
-    """
-    if sys.platform != "darwin" or not name:
-        return
-    sound = (
-        Path(name)
-        if "/" in name
-        else _SYSTEM_SOUNDS / f"{name}.aiff"
-    )
-    if not sound.exists():
-        return
-    subprocess.Popen(
-        ["afplay", str(sound)],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-
-
-def copy_to_clipboard(text: str) -> None:
-    """Put ``text`` on the macOS clipboard (no-op elsewhere/on failure)."""
-    if sys.platform != "darwin" or not text:
-        return
-    try:
-        subprocess.run(
-            ["pbcopy"], input=text.encode(), check=False, timeout=5
-        )
-    except Exception:
-        pass