voice-mode 4.1.0__py3-none-any.whl → 4.2.0__py3-none-any.whl

voice_mode/frontend/.next/types/app/api/connection-details/route.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-zm2dhhk4/voice_mode-4.1.0/voice_mode/frontend/app/api/connection-details/route.ts
+// File: /tmp/build-via-sdist-grc13230/voice_mode-4.2.0/voice_mode/frontend/app/api/connection-details/route.ts
 import * as entry from '../../../../../app/api/connection-details/route.js'
 import type { NextRequest } from 'next/server.js'
 

voice_mode/frontend/.next/types/app/layout.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-zm2dhhk4/voice_mode-4.1.0/voice_mode/frontend/app/layout.tsx
+// File: /tmp/build-via-sdist-grc13230/voice_mode-4.2.0/voice_mode/frontend/app/layout.tsx
 import * as entry from '../../../app/layout.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

voice_mode/frontend/.next/types/app/page.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-zm2dhhk4/voice_mode-4.1.0/voice_mode/frontend/app/page.tsx
+// File: /tmp/build-via-sdist-grc13230/voice_mode-4.2.0/voice_mode/frontend/app/page.tsx
 import * as entry from '../../../app/page.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

voice_mode/frontend/package-lock.json

@@ -1774,9 +1774,9 @@
       "license": "MIT"
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.211",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.211.tgz",
-      "integrity": "sha512-IGBvimJkotaLzFnwIVgW9/UD/AOJ2tByUmeOrtqBfACSbAw5b1G0XpvdaieKyc7ULmbwXVx+4e4Be8pOPBrYkw==",
+      "version": "1.5.212",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.212.tgz",
+      "integrity": "sha512-gE7ErIzSW+d8jALWMcOIgf+IB6lpfsg6NwOhPVwKzDtN2qcBix47vlin4yzSregYDxTCXOUqAZjVY/Z3naS7ww==",
       "dev": true,
       "license": "ISC"
     },

voice_mode/tools/claude_thinking.py

@@ -0,0 +1,285 @@
+"""Claude Code message extraction tools for Think Out Loud mode and conversation analysis."""
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+from voice_mode.server import mcp
+from voice_mode.config import THINK_OUT_LOUD_ENABLED
+
+logger = logging.getLogger("voice-mode")
+
+
+def find_claude_log_file(working_dir: Optional[str] = None) -> Optional[Path]:
+    """Find the current Claude Code conversation log file.
+    
+    Args:
+        working_dir: The working directory (defaults to CWD)
+        
+    Returns:
+        Path to the most recent JSONL log file, or None if not found
+    """
+    if working_dir is None:
+        working_dir = os.getcwd()
+    
+    logger.debug(f"Looking for Claude logs in working_dir: {working_dir}")
+    
+    # Transform path: /Users/admin/Code/github.com/project → -Users-admin-Code-github-com-project
+    # Note: Both slashes and dots are replaced with hyphens
+    project_dir = working_dir.replace('/', '-').replace('.', '-')
+    logger.debug(f"Transformed project dir: {project_dir}")
+    
+    # Build path to Claude logs
+    claude_base = Path.home() / '.claude' / 'projects'
+    log_dir = claude_base / project_dir
+    logger.debug(f"Claude log directory: {log_dir}")
+    
+    if not log_dir.exists():
+        logger.warning(f"Claude log directory does not exist: {log_dir}")
+        return None
+    
+    # Find most recent .jsonl file
+    log_files = sorted(
+        log_dir.glob('*.jsonl'), 
+        key=lambda p: p.stat().st_mtime,
+        reverse=True
+    )
+    
+    if log_files:
+        logger.info(f"Found {len(log_files)} Claude log files, using most recent: {log_files[0].name}")
+        return log_files[0]
+    else:
+        logger.warning(f"No .jsonl files found in {log_dir}")
+        return None
+
+
+def extract_messages_from_log(log_file: Path, last_n: int = 2, message_types: Optional[List[str]] = None) -> List[Dict[str, Any]]:
+    """Extract messages from Claude Code JSONL log.
+    
+    Args:
+        log_file: Path to the JSONL log file
+        last_n: Number of most recent messages to return (default: 2)
+        message_types: Optional list of message types to filter ('user', 'assistant', 'system')
+                      If None, returns all message types
+        
+    Returns:
+        List of messages with metadata
+    """
+    logger.debug(f"Extracting {last_n} messages from {log_file}, types={message_types}")
+    messages = []
+    
+    try:
+        with open(log_file, 'r') as f:
+            lines = f.readlines()
+        
+        logger.debug(f"Read {len(lines)} lines from log file")
+            
+        # Process lines in reverse to get most recent first
+        for i, line in enumerate(reversed(lines)):
+            if not line.strip():
+                continue
+                
+            try:
+                entry = json.loads(line)
+                entry_type = entry.get('type')
+                
+                # Filter by message type if specified
+                if message_types and entry_type not in message_types:
+                    continue
+                
+                # Extract user or assistant messages
+                if entry_type in ['user', 'assistant']:
+                    logger.debug(f"Found {entry_type} message at line {len(lines) - i}")
+                    message = entry.get('message', {})
+                    
+                    # Build message info
+                    message_info = {
+                        'type': entry_type,
+                        'role': message.get('role'),
+                        'content': message.get('content', []),
+                        'timestamp': entry.get('timestamp'),
+                        'uuid': entry.get('uuid'),
+                        'model': message.get('model') if entry_type == 'assistant' else None
+                    }
+                    
+                    # Add usage info for assistant messages
+                    if entry_type == 'assistant' and 'usage' in message:
+                        message_info['usage'] = message['usage']
+                    
+                    messages.append(message_info)
+                    
+                    if len(messages) >= last_n:
+                        logger.info(f"Extracted {len(messages)} messages successfully")
+                        return messages
+                        
+            except json.JSONDecodeError as e:
+                logger.debug(f"Skipping invalid JSON at line {len(lines) - i}: {e}")
+                continue
+                
+    except Exception as e:
+        logger.error(f"Error reading log file {log_file}: {e}")
+    
+    logger.info(f"Extracted {len(messages)} messages (requested {last_n})")    
+    return messages
+
+
+def extract_thinking_from_messages(messages: List[Dict[str, Any]]) -> List[str]:
+    """Extract thinking content from a list of messages.
+    
+    Args:
+        messages: List of message dictionaries
+        
+    Returns:
+        List of thinking text strings
+    """
+    thinking_texts = []
+    
+    for message in messages:
+        if message.get('type') == 'assistant':
+            content = message.get('content', [])
+            for item in content:
+                if isinstance(item, dict) and item.get('type') == 'thinking':
+                    text = item.get('text', '').strip()
+                    if text:
+                        thinking_texts.append(text)
+    
+    return thinking_texts
+
+
+@mcp.tool
+def get_claude_messages(
+    last_n: int = 2,
+    working_dir: Optional[str] = None,
+    message_types: Optional[List[str]] = None,
+    format: str = "full"
+) -> str:
+    """Extract messages from Claude Code conversation logs.
+    
+    This tool reads Claude Code's conversation logs to extract recent messages
+    for Think Out Loud mode and conversation analysis.
+    
+    Args:
+        last_n: Number of most recent messages to return (default: 2)
+        working_dir: Working directory to find logs for (defaults to CWD)
+        message_types: Optional list to filter by type ('user', 'assistant'). 
+                       If None, returns all types.
+        format: Output format - 'full' (complete message), 'text' (just text content),
+                'thinking' (just thinking content)
+        
+    Returns:
+        The extracted messages in the requested format
+    """
+    logger.debug(f"get_claude_messages called: last_n={last_n}, working_dir={working_dir}, types={message_types}, format={format}")
+    
+    # Check if Think Out Loud mode is enabled
+    if not THINK_OUT_LOUD_ENABLED:
+        logger.warning("Think Out Loud mode is not enabled")
+        return "Think Out Loud mode is not enabled. Set VOICEMODE_THINK_OUT_LOUD=true to enable."
+    
+    # Find the log file
+    log_file = find_claude_log_file(working_dir)
+    if not log_file:
+        return f"Could not find Claude Code logs for directory: {working_dir or os.getcwd()}"
+    
+    # Extract messages
+    messages = extract_messages_from_log(log_file, last_n, message_types)
+    
+    if not messages:
+        return f"No messages found in recent Claude Code logs."
+    
+    # Format output based on requested format
+    if format == "thinking":
+        # Extract only thinking content
+        thinking_texts = extract_thinking_from_messages(messages)
+        if not thinking_texts:
+            return "No thinking content found in recent messages."
+        if len(thinking_texts) == 1:
+            return thinking_texts[0]
+        return "\n\n=== Next Thinking ===\n\n".join(thinking_texts)
+    
+    elif format == "text":
+        # Extract just the text content
+        result = []
+        for msg in messages:
+            content_text = []
+            for item in msg.get('content', []):
+                if isinstance(item, dict):
+                    if item.get('type') == 'text':
+                        content_text.append(item.get('text', ''))
+                    elif item.get('type') == 'thinking':
+                        content_text.append(f"[Thinking: {item.get('text', '')}]")
+            if content_text:
+                result.append(f"{msg['type'].title()}: {' '.join(content_text)}")
+        return "\n\n".join(result)
+    
+    else:  # format == "full"
+        # Return complete message structure
+        result = []
+        for i, msg in enumerate(messages, 1):
+            result.append(f"=== Message {i} ===")
+            result.append(f"Type: {msg['type']}")
+            result.append(f"Timestamp: {msg.get('timestamp', 'Unknown')}")
+            if msg.get('model'):
+                result.append(f"Model: {msg['model']}")
+            
+            # Format content
+            content = msg.get('content', [])
+            if content:
+                result.append("Content:")
+                for item in content:
+                    if isinstance(item, dict):
+                        item_type = item.get('type', 'unknown')
+                        if item_type == 'text':
+                            result.append(f"  [Text]: {item.get('text', '')}")
+                        elif item_type == 'thinking':
+                            result.append(f"  [Thinking]: {item.get('text', '')}")
+                        elif item_type == 'tool_use':
+                            result.append(f"  [Tool Use]: {item.get('name', '')}")
+                        elif item_type == 'tool_result':
+                            result.append(f"  [Tool Result]: {item.get('content', '')[:100]}...")
+            result.append("")
+        
+        return "\n".join(result).strip()
+
+
+@mcp.tool
+def check_claude_context() -> str:
+    """Check if running in Claude Code context.
+    
+    Returns information about the Claude Code environment including:
+    - Whether Claude Code logs are accessible
+    - Current working directory
+    - Log file location if found
+    """
+    working_dir = os.getcwd()
+    log_file = find_claude_log_file(working_dir)
+    
+    result = []
+    result.append(f"Working Directory: {working_dir}")
+    result.append(f"Claude Logs Found: {'Yes' if log_file else 'No'}")
+    
+    if log_file:
+        result.append(f"Log File: {log_file}")
+        result.append(f"Log Size: {log_file.stat().st_size:,} bytes")
+        
+        # Check for recent activity
+        mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
+        now = datetime.now()
+        age = now - mtime
+        
+        if age.total_seconds() < 60:
+            result.append(f"Last Updated: {int(age.total_seconds())} seconds ago")
+        elif age.total_seconds() < 3600:
+            result.append(f"Last Updated: {int(age.total_seconds() / 60)} minutes ago")
+        else:
+            result.append(f"Last Updated: {int(age.total_seconds() / 3600)} hours ago")
+    else:
+        project_dir = working_dir.replace('/', '-')
+        expected_path = Path.home() / '.claude' / 'projects' / project_dir
+        result.append(f"Expected Log Location: {expected_path}")
+        result.append("Note: Logs are only created when using Claude Code (claude.ai/code)")
+    
+    return "\n".join(result)

voice_mode/tools/sound_fonts/__init__.py

@@ -0,0 +1 @@
+"""Sound Fonts module for Voice Mode."""

voice_mode/tools/sound_fonts/audio_player.py

@@ -0,0 +1,87 @@
+"""
+Simple audio player for sound fonts.
+
+Handles audio playback with features like volume control, start/end times,
+and potential future support for URLs and looping.
+"""
+
+import subprocess
+from pathlib import Path
+from typing import Optional
+import sys
+
+
+class Player:
+    """Simple audio player using ffplay."""
+    
+    def play(
+        self,
+        file_path: str,
+        start: float = 0.0,
+        end: Optional[float] = None,
+        volume: float = 1.0
+    ) -> bool:
+        """
+        Play an audio file or slice of it.
+        
+        Args:
+            file_path: Path to audio file (local path, future: URLs)
+            start: Start time in seconds
+            end: End time in seconds (None for end of file)
+            volume: Volume multiplier (0.0 to 1.0)
+            
+        Returns:
+            True if playback started successfully, False otherwise
+        """
+        # Check if file exists (skip for URLs in future)
+        if not file_path.startswith(('http://', 'https://')):
+            path = Path(file_path)
+            if not path.exists():
+                if sys.stderr.isatty():
+                    print(f"Error: Audio file not found: {file_path}", file=sys.stderr)
+                return False
+        
+        # Build ffplay command for non-blocking audio playback
+        cmd = [
+            "ffplay",
+            "-nodisp",      # No video display
+            "-autoexit",    # Exit when playback ends
+            "-loglevel", "quiet",  # Suppress output
+        ]
+        
+        # Add start time if specified
+        if start > 0:
+            cmd.extend(["-ss", str(start)])
+        
+        # Add duration if end time specified
+        if end is not None:
+            duration = end - start
+            if duration > 0:
+                cmd.extend(["-t", str(duration)])
+        
+        # Add volume filter if not 1.0
+        if volume != 1.0:
+            # Clamp volume between 0 and 2 (200%)
+            volume = max(0.0, min(2.0, volume))
+            cmd.extend(["-af", f"volume={volume}"])
+        
+        # Add the file path
+        cmd.append(file_path)
+        
+        try:
+            # Run in background (non-blocking)
+            subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL
+            )
+            return True
+        except FileNotFoundError:
+            # ffplay not installed
+            if sys.stderr.isatty():
+                print("Error: ffplay not found. Please install ffmpeg.", file=sys.stderr)
+            return False
+        except Exception as e:
+            if sys.stderr.isatty():
+                print(f"Error playing audio: {e}", file=sys.stderr)
+            return False

voice_mode/tools/sound_fonts/hook_handler.py

@@ -0,0 +1,127 @@
+"""
+Hook Handler for Sound Fonts
+
+Handles parsing of Claude Code hook data and extracting relevant information
+for sound playback.
+"""
+
+import json
+import sys
+from typing import Dict, Any, Optional
+
+
+def parse_claude_code_hook(hook_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    Parse Claude Code hook data to extract sound-relevant information.
+    
+    Args:
+        hook_data: Raw hook data from Claude Code
+        
+    Returns:
+        Dict with tool_name, action, subagent_type, and metadata
+    """
+    # Extract tool name
+    tool_name = hook_data.get("tool_name")
+    if not tool_name:
+        return None
+    
+    # For PreToolUse hooks, action is "start"
+    # For PostToolUse hooks, action is "end"
+    # We'll assume "start" if not specified
+    action = hook_data.get("action", "start")
+    
+    # Extract subagent_type from tool_input for Task calls
+    subagent_type = None
+    tool_input = hook_data.get("tool_input", {})
+    if isinstance(tool_input, dict):
+        subagent_type = tool_input.get("subagent_type")
+    
+    # Extract any additional metadata
+    metadata = {
+        "session_id": hook_data.get("session_id"),
+        "cwd": hook_data.get("cwd"),
+        "timestamp": hook_data.get("timestamp"),
+    }
+    
+    return {
+        "tool_name": tool_name,
+        "action": action,
+        "subagent_type": subagent_type,
+        "metadata": metadata
+    }
+
+
+def read_hook_data_from_stdin() -> Optional[Dict[str, Any]]:
+    """
+    Read hook data from stdin (JSON format).
+    
+    Returns:
+        Parsed hook data or None if error
+    """
+    try:
+        return json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return None
+
+
+def parse_hook_arguments(args: list) -> Optional[Dict[str, Any]]:
+    """
+    Parse hook arguments from command line.
+    
+    Expected formats:
+    - JSON string as single argument
+    - Individual arguments: tool_name action [subagent_type] [metadata_json]
+    """
+    if len(args) == 1:
+        # Single JSON argument
+        try:
+            return json.loads(args[0])
+        except json.JSONDecodeError:
+            return None
+            
+    # Individual arguments
+    if len(args) < 2:
+        return None
+        
+    hook_data = {
+        "tool_name": args[0],
+        "action": args[1]
+    }
+    
+    if len(args) > 2:
+        hook_data["subagent_type"] = args[2]
+        
+    if len(args) > 3:
+        try:
+            hook_data["metadata"] = json.loads(args[3])
+        except:
+            hook_data["metadata"] = {}
+            
+    return hook_data
+
+
+def extract_subagent_from_metadata(metadata: Dict[str, Any]) -> Optional[str]:
+    """
+    Extract subagent_type from Claude Code hook metadata.
+    
+    For Task tool calls, the subagent_type might be in various places
+    depending on how Claude Code structures the hook data.
+    """
+    if not metadata:
+        return None
+        
+    # Direct subagent_type field
+    if "subagent_type" in metadata:
+        return metadata["subagent_type"]
+        
+    # Look in parameters
+    params = metadata.get("parameters", {})
+    if "subagent_type" in params:
+        return params["subagent_type"]
+        
+    # Look in tool_args or similar
+    tool_args = metadata.get("tool_args", {})
+    if "subagent_type" in tool_args:
+        return tool_args["subagent_type"]
+        
+    return None