voice-vibecoder 2.5.3__tar.gz → 2.6.0__tar.gz

{voice_vibecoder-2.5.3 → voice_vibecoder-2.6.0}/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 <!-- version list -->
 
+## v2.6.0 (2026-02-20)
+
+### Features
+
+- **agent_task**: Support matching by display name in session lookup
+  ([`a97e0e6`](https://github.com/snokam/voice-vibecoder/commit/a97e0e67fdf7178ddee182acc275957a471e2691))
+
+### Refactoring
+
+- **instances**: Simplify branch key assignment logic
+  ([`58f5d34`](https://github.com/snokam/voice-vibecoder/commit/58f5d3475d1696dd3b92252e3843ee2e4a04826b))
+
+
 ## v2.5.3 (2026-02-20)
 
 ### Bug Fixes

{voice_vibecoder-2.5.3 → voice_vibecoder-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-vibecoder
-Version: 2.5.3
+Version: 2.6.0
 Summary: Olaf The Vibecoder — a voice-controlled coding assistant using OpenAI Realtime API + Claude Code
 Project-URL: Homepage, https://github.com/snokam/voice-vibecoder
 Project-URL: Repository, https://github.com/snokam/voice-vibecoder

{voice_vibecoder-2.5.3 → voice_vibecoder-2.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "voice-vibecoder"
-version = "2.5.3"
+version = "2.6.0"
 description = "Olaf The Vibecoder — a voice-controlled coding assistant using OpenAI Realtime API + Claude Code"
 readme = "README.md"
 requires-python = ">=3.10"

{voice_vibecoder-2.5.3 → voice_vibecoder-2.6.0}/src/voice_vibecoder/__init__.py

@@ -3,7 +3,7 @@
 A voice-controlled coding assistant using OpenAI Realtime API + Claude Code.
 """
 
-__version__ = "2.5.3"
+__version__ = "2.6.0"
 
 from voice_vibecoder.app_config import VoiceConfig
 from voice_vibecoder.ui.screen import VoiceCodingScreen

{voice_vibecoder-2.5.3 → voice_vibecoder-2.6.0}/src/voice_vibecoder/instances.py

@@ -125,9 +125,6 @@ class InstanceRegistry:
             self.on_status_change(instance.instance_id, instance.status)
         if self.on_instance_change:
             self.on_instance_change()
-        # Start file tree updates for code instances (skip for sessions)
-        from voice_vibecoder.tools.file_tree import start_file_tree_updates
-        start_file_tree_updates(instance.instance_id, worktree_path, self)
         return instance
 
     def create_session(self, name: str, agent_type: str = "claude") -> AgentInstance:
@@ -136,16 +133,20 @@ class InstanceRegistry:
         if existing:
             return existing
         with self._lock:
+            # Re-check under lock to prevent race between concurrent creates
+            branch_key = f"_session_{name}"
+            if branch_key in self._branch_index:
+                return self._instances[self._branch_index[branch_key]]
             instance = AgentInstance(
                 instance_id=uuid.uuid4().hex[:8],
-                branch=f"_session_{name}",
+                branch=branch_key,
                 worktree_path="",
                 agent_type=agent_type,
                 instance_type=InstanceType.SESSION,
                 display_name=name,
             )
             self._instances[instance.instance_id] = instance
-            self._branch_index[instance.branch] = instance.instance_id
+            self._branch_index[branch_key] = instance.instance_id
         self._save_state()
         if self.on_status_change:
             self.on_status_change(instance.instance_id, instance.status)
@@ -415,11 +416,4 @@ class InstanceRegistry:
                 self._branch_index[branch] = instance.instance_id
                 loaded.append(instance)
 
-        # Start file tree updates for code instances only
-        from voice_vibecoder.tools.file_tree import start_file_tree_updates
-        for inst in loaded:
-            if inst.instance_type == InstanceType.SESSION:
-                continue
-            start_file_tree_updates(inst.instance_id, inst.worktree_path, self)
-
         return loaded

{voice_vibecoder-2.5.3 → voice_vibecoder-2.6.0}/src/voice_vibecoder/session.py

@@ -128,8 +128,12 @@ class RealtimeSession:
             self._on_status("connected")
 
     async def configure_session(self) -> None:
+        from voice_vibecoder.tools.agent_task import warm_mcp_cache
         from voice_vibecoder.tools.handlers import get_active_instances_text, get_startup_context
 
+        # Pre-warm MCP server cache so first agent spawn doesn't pay the cost
+        warm_mcp_cache()
+
         s = self._settings
         overrides = self._voice_config.system_instructions if self._voice_config else None
         instructions = get_system_instructions(

{voice_vibecoder-2.5.3 → voice_vibecoder-2.6.0}/src/voice_vibecoder/tools/agent_task.py

@@ -23,10 +23,11 @@ _CLAUDE_JSON = Path.home() / ".claude.json"
 
 # Cached MCP servers — loaded once per session, files rarely change
 _mcp_cache: dict[str, dict] | None = None
+_mcp_lock = threading.Lock()
 
 
 def _load_mcp_servers() -> dict[str, dict]:
-    """Load MCP servers (cached after first call).
+    """Load MCP servers (cached after first call, thread-safe).
 
     Priority order:
     1. MCP_SERVERS_JSON environment variable (for Azure/production)
@@ -37,50 +38,60 @@ def _load_mcp_servers() -> dict[str, dict]:
     if _mcp_cache is not None:
         return _mcp_cache
 
-    import os
-    from voice_vibecoder.tools.dispatch import _repo_root
+    with _mcp_lock:
+        # Double-check after acquiring the lock
+        if _mcp_cache is not None:
+            return _mcp_cache
+
+        import os
+        from voice_vibecoder.tools.dispatch import _repo_root
+
+        servers: dict[str, dict] = {}
 
-    servers: dict[str, dict] = {}
+        # Load from .mcp.json in repo root
+        if _repo_root:
+            mcp_json = Path(_repo_root) / ".mcp.json"
+            if mcp_json.exists():
+                try:
+                    data = json.loads(mcp_json.read_text())
+                    servers.update(data.get("mcpServers", {}))
+                except Exception as e:
+                    logger.warning("Failed to read .mcp.json: %s", e)
 
-    # Load from .mcp.json in repo root
-    if _repo_root:
-        mcp_json = Path(_repo_root) / ".mcp.json"
-        if mcp_json.exists():
+        # Load from ~/.claude.json
+        if _repo_root and _CLAUDE_JSON.exists():
             try:
-                data = json.loads(mcp_json.read_text())
-                servers.update(data.get("mcpServers", {}))
+                data = json.loads(_CLAUDE_JSON.read_text())
+                project_key = str(Path(_repo_root))
+                project_data = data.get("projects", {}).get(project_key, {})
+                local_servers = project_data.get("mcpServers", {})
+                servers.update(local_servers)
             except Exception as e:
-                logger.warning("Failed to read .mcp.json: %s", e)
+                logger.warning("Failed to read ~/.claude.json: %s", e)
 
-    # Load from ~/.claude.json
-    if _repo_root and _CLAUDE_JSON.exists():
-        try:
-            data = json.loads(_CLAUDE_JSON.read_text())
-            project_key = str(Path(_repo_root))
-            project_data = data.get("projects", {}).get(project_key, {})
-            local_servers = project_data.get("mcpServers", {})
-            servers.update(local_servers)
-        except Exception as e:
-            logger.warning("Failed to read ~/.claude.json: %s", e)
-
-    # MCP_SERVERS_JSON takes precedence (for Azure Container Apps)
-    mcp_env = os.environ.get("MCP_SERVERS_JSON")
-    if mcp_env:
-        try:
-            env_servers = json.loads(mcp_env)
-            servers.update(env_servers.get("mcpServers", env_servers))
-            logger.info("Loaded MCP servers from MCP_SERVERS_JSON environment variable")
-        except Exception as e:
-            logger.warning("Failed to parse MCP_SERVERS_JSON: %s", e)
+        # MCP_SERVERS_JSON takes precedence (for Azure Container Apps)
+        mcp_env = os.environ.get("MCP_SERVERS_JSON")
+        if mcp_env:
+            try:
+                env_servers = json.loads(mcp_env)
+                servers.update(env_servers.get("mcpServers", env_servers))
+                logger.info("Loaded MCP servers from MCP_SERVERS_JSON environment variable")
+            except Exception as e:
+                logger.warning("Failed to parse MCP_SERVERS_JSON: %s", e)
+
+        # Ensure each MCP server inherits process env vars (the Claude CLI may
+        # not forward its own env to MCP server subprocesses).
+        for _name, cfg in servers.items():
+            if "env" not in cfg:
+                cfg["env"] = dict(os.environ)
+
+        _mcp_cache = servers
+        return servers
 
-    # Ensure each MCP server inherits process env vars (the Claude CLI may
-    # not forward its own env to MCP server subprocesses).
-    for _name, cfg in servers.items():
-        if "env" not in cfg:
-            cfg["env"] = dict(os.environ)
 
-    _mcp_cache = servers
-    return servers
+def warm_mcp_cache() -> None:
+    """Pre-load MCP server config so it's ready when agents spawn."""
+    _load_mcp_servers()
 
 
 def _create_runner(agent_type: str, permission_mode: str, mcp_servers: dict | None, env: dict | None = None) -> AgentRunner:
@@ -198,6 +209,10 @@ def _handle_send_to_session(message: str, session_name: str | None = None, agent
             session_name = "session"
 
     instance = _registry.get_session_by_name(session_name)
+    # Also try matching by display_name (LLM may use different session keys
+    # for the same logical session, e.g. "calendar-today" vs "today-s-calendar")
+    if not instance and display_name:
+        instance = _registry.get_session_by_name(display_name)
     is_new_session = instance is None
     if not instance:
         instance = _registry.create_session(session_name, agent_type=target_agent)

{voice_vibecoder-2.5.3 → voice_vibecoder-2.6.0}/src/voice_vibecoder/tools/file_tree.py

@@ -9,6 +9,7 @@ timer while an agent is running.
 import logging
 import subprocess
 import threading
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import PurePosixPath
 
 logger = logging.getLogger(__name__)
@@ -16,16 +17,15 @@ logger = logging.getLogger(__name__)
 MAX_DEPTH = 10  # Maximum tree depth to prevent excessive nesting
 
 
-def _merge_base(worktree_path: str) -> str:
-    """Get the merge-base commit between main and HEAD."""
-    result = subprocess.run(
-        ["git", "merge-base", "main", "HEAD"],
-        cwd=worktree_path,
+def _git(args: list[str], cwd: str) -> subprocess.CompletedProcess:
+    """Run a git command and return the CompletedProcess."""
+    return subprocess.run(
+        ["git", *args],
+        cwd=cwd,
         capture_output=True,
         text=True,
         timeout=10,
     )
-    return result.stdout.strip() if result.returncode == 0 else "main"
 
 
 def _build_tree_node(path: str, status: str | None, is_folder: bool) -> dict:
@@ -112,26 +112,25 @@ def get_file_tree(worktree_path: str) -> dict:
          "summary": {"modified": N, "new": N, "deleted": N, "unchanged": N}}
     """
     try:
-        # Get branch name
-        branch_result = subprocess.run(
-            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-            cwd=worktree_path,
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-        root = branch_result.stdout.strip() if branch_result.returncode == 0 else "unknown"
+        # Run independent git commands in parallel, then diff after merge-base
+        with ThreadPoolExecutor(max_workers=4) as pool:
+            branch_fut = pool.submit(_git, ["rev-parse", "--abbrev-ref", "HEAD"], worktree_path)
+            base_fut = pool.submit(_git, ["merge-base", "main", "HEAD"], worktree_path)
+            untracked_fut = pool.submit(_git, ["ls-files", "--others", "--exclude-standard"], worktree_path)
+            all_files_fut = pool.submit(_git, ["ls-files"], worktree_path)
+
+            # Wait for merge-base, then submit diff (overlaps with ls-files)
+            base_result = base_fut.result()
+            base = base_result.stdout.strip() if base_result.returncode == 0 else "main"
+            diff_fut = pool.submit(_git, ["diff", "--name-status", base], worktree_path)
+
+            # Collect remaining results
+            branch_result = branch_fut.result()
+            diff_result = diff_fut.result()
+            untracked_result = untracked_fut.result()
+            all_files_result = all_files_fut.result()
 
-        base = _merge_base(worktree_path)
-
-        # Get modified/deleted files vs merge-base
-        diff_result = subprocess.run(
-            ["git", "diff", "--name-status", base],
-            cwd=worktree_path,
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
+        root = branch_result.stdout.strip() if branch_result.returncode == 0 else "unknown"
 
         changed: dict[str, str] = {}  # path -> status
         if diff_result.returncode == 0:
@@ -151,29 +150,12 @@ def get_file_tree(worktree_path: str) -> dict:
                     elif status_code in ("R", "C"):
                         changed[path] = "modified"
 
-        # Get untracked files
-        untracked_result = subprocess.run(
-            ["git", "ls-files", "--others", "--exclude-standard"],
-            cwd=worktree_path,
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
         if untracked_result.returncode == 0:
             for path in untracked_result.stdout.strip().splitlines():
                 path = path.strip()
                 if path and path not in changed:
                     changed[path] = "new"
 
-        # Get all tracked files to show complete project structure
-        all_files_result = subprocess.run(
-            ["git", "ls-files"],
-            cwd=worktree_path,
-            capture_output=True,
-            text=True,
-            timeout=10,
-        )
-
         all_paths: dict[str, str] = {}  # path -> status
         if all_files_result.returncode == 0:
             for f in all_files_result.stdout.strip().splitlines():