tau-coding-agent 0.6.8__tar.gz → 0.7.0__tar.gz

{tau_coding_agent-0.6.8/tau_coding_agent.egg-info → tau_coding_agent-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.6.8
+Version: 0.7.0
 Summary: A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -31,9 +31,9 @@ Requires-Dist: grapheme==0.6.0
 Requires-Dist: arrow==1.4.0
 Requires-Dist: kiwisolver==1.5.0
 Requires-Dist: tiktoken==0.13.0
+Requires-Dist: rapidfuzz==3.14.3
 Provides-Extra: tools
 Requires-Dist: ripgrep>=14.0.0; extra == "tools"
-Requires-Dist: ast-grep-cli>=0.44.0; extra == "tools"
 Dynamic: license-file
 
 <div align="center">

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.6.8"
+version = "0.7.0"
 description = "A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -35,6 +35,7 @@ dependencies = [
     "arrow==1.4.0",
     "kiwisolver==1.5.0",
     "tiktoken==0.13.0",
+    "rapidfuzz==3.14.3",
 ]
 
 [project.scripts]
@@ -74,7 +75,7 @@ tau = [
 testpaths = ["tests"]
 
 [project.optional-dependencies]
-tools = ["ripgrep>=14.0.0", "ast-grep-cli>=0.44.0"]
+tools = ["ripgrep>=14.0.0"]
 
 [dependency-groups]
 dev = [

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/agent/prompt/builder.py

@@ -212,10 +212,23 @@ def _detect_machine() -> str:
 
 
 def _detect_shell() -> str:
-    """Detect the user's shell from $SHELL, falling back to common shells on PATH."""
+    """Detect the user's shell from $SHELL, falling back to common shells on PATH.
+
+    On Windows, ``$SHELL`` is a POSIX convention and is essentially never set,
+    so this used to fall through to up to 4 ``shutil.which()`` calls, each
+    scanning every ``PATH`` entry against every ``PATHEXT`` suffix for shells
+    (zsh, fish, sh) that don't exist on Windows. We instead resolve the native
+    shell directly from environment variables the OS always sets, with no
+    PATH scan.
+    """
     shell = os.environ.get("SHELL", "")
     if shell:
         return Path(shell).name
+    if sys.platform == "win32":
+        if os.environ.get("PSModulePath"):
+            return "powershell"
+        comspec = os.environ.get("COMSPEC", "")
+        return Path(comspec).stem if comspec else "cmd"
     for candidate in ("bash", "zsh", "fish", "sh"):
         if shutil.which(candidate):
             return candidate

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/builtins/extensions/sandbox/__init__.py

@@ -74,7 +74,14 @@ def register(tau: ExtensionAPI) -> None:
             asyncio.ensure_future(_prewarm())
 
     @tau.on("session_shutdown")
-    async def _on_shutdown(_event: Any, _ctx: ExtensionContext) -> None:
+    async def _on_session_shutdown(_event: Any, _ctx: ExtensionContext) -> None:
+        await manager.stop()
+
+    @tau.on("runtime_stop")
+    async def _on_runtime_stop(_event: Any, _ctx: ExtensionContext) -> None:
+        # session_shutdown only fires on session transitions (new/resume/clone),
+        # not on actual process exit, so the microVM would otherwise keep running
+        # until its own idle_timeout — reap it here too, same as the lsp extension.
         await manager.stop()
 
     async def cmd_sandbox(ctx: ExtensionContext, args: list[str]) -> None:

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/console/cli.py

@@ -5,15 +5,18 @@ import logging
 import os
 import sys
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import click
 
 from tau.console.commands.auth import auth
 from tau.console.commands.packages import install, list_packages, remove
 from tau.console.commands.update import update
-from tau.runtime.service import Runtime
 from tau.settings.paths import get_app_version
 
+if TYPE_CHECKING:
+    from tau.runtime.service import Runtime
+
 _MODES = ("interactive", "print", "json", "rpc")
 _OUTPUT_FORMATS = ("text", "json")
 

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/extensions/loader.py

@@ -409,7 +409,11 @@ class ExtensionLoader:
         """Install an extension's declared dependencies, once per dependency set.
 
         Runs synchronously (called via ``asyncio.to_thread``) so the blocking
-        subprocess install doesn't stall the event loop.
+        subprocess install doesn't stall the event loop. A failed install is
+        cached too, not just successes — otherwise a dependency that can never
+        build on this interpreter (e.g. no wheel for a free-threaded Python
+        build, missing compiler) retries the full failing subprocess on every
+        single startup instead of failing fast after the first attempt.
         """
         from tau.packages.manager import PackageManager
 
@@ -424,7 +428,7 @@ class ExtensionLoader:
 
         digest = hashlib.sha256("\n".join(sorted(deps)).encode("utf-8")).hexdigest()
         cache_file = venv_dir / ".tau_ext_deps.json"
-        cache: dict[str, str] = {}
+        cache: dict[str, Any] = {}
         if cache_file.is_file():
             try:
                 cache = json.loads(cache_file.read_text(encoding="utf-8"))
@@ -433,12 +437,29 @@ class ExtensionLoader:
                 cache = {}
 
         key = str(subdir.resolve())
-        if cache.get(key) != digest:
-            _log.info("Installing dependencies for extension %r: %s", subdir.name, ", ".join(deps))
+        entry = cache.get(key)
+        # Older cache files stored the digest directly as a bare string (success-only).
+        cached_digest = entry.get("digest") if isinstance(entry, dict) else entry
+        if cached_digest == digest:
+            if isinstance(entry, dict) and not entry.get("ok", True):
+                raise RuntimeError(
+                    f"Dependencies for extension {subdir.name!r} previously failed to "
+                    f"install: {entry.get('error', 'unknown error')}"
+                )
+            add_site_packages_path(pkg_mgr.site_packages())
+            return
+
+        _log.info("Installing dependencies for extension %r: %s", subdir.name, ", ".join(deps))
+        try:
             pkg_mgr.install_requirements(deps)
-            cache[key] = digest
+        except Exception as exc:
+            cache[key] = {"digest": digest, "ok": False, "error": str(exc)}
             cache_file.parent.mkdir(parents=True, exist_ok=True)
             cache_file.write_text(json.dumps(cache, indent=2), encoding="utf-8")
+            raise
+        cache[key] = {"digest": digest, "ok": True}
+        cache_file.parent.mkdir(parents=True, exist_ok=True)
+        cache_file.write_text(json.dumps(cache, indent=2), encoding="utf-8")
 
         add_site_packages_path(pkg_mgr.site_packages())
 

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/inference/provider/oauth/anthropic_claude_code.py

@@ -308,11 +308,9 @@ class AnthropicClaudeCodeOAuthProvider(OAuthProvider):
         pass
 
     @property
-    def api(self):
-        """Return the API class that handles requests with this provider's tokens."""
-        from tau.inference.api.text.anthropic_claude_code import AnthropicClaudeCodeAPI
-
-        return AnthropicClaudeCodeAPI
+    def api(self) -> str:
+        """Registry key for the API class; resolved (and the SDK imported) lazily."""
+        return "anthropic_claude_code"
 
     async def validate(
         self, credential: OAuthCredential, signal: AbortSignal | None = None

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/inference/provider/oauth/github_copilot.py

@@ -353,8 +353,6 @@ class GitHubCopilotOAuthProvider(OAuthProvider):
         return not (signal and signal.is_set())
 
     @property
-    def api(self):
-        """Return the API class that handles requests with this provider's tokens."""
-        from tau.inference.api.text.github_copilot_chat import GitHubCopilotChatAPI
-
-        return GitHubCopilotChatAPI
+    def api(self) -> str:
+        """Registry key for the API class; resolved (and the SDK imported) lazily."""
+        return "github_copilot_chat"

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/inference/provider/oauth/google_antigravity.py

@@ -277,11 +277,9 @@ class GoogleAntigravityOAuthProvider(OAuthProvider):
             pass
 
     @property
-    def api(self):
-        """Return the API class that handles requests with this provider's tokens."""
-        from tau.inference.api.text.google_antigravity import GoogleAntigravityAPI
-
-        return GoogleAntigravityAPI
+    def api(self) -> str:
+        """Registry key for the API class; resolved (and the SDK imported) lazily."""
+        return "google_antigravity"
 
     async def validate(
         self, credential: OAuthCredential, signal: AbortSignal | None = None

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/inference/provider/oauth/openai_codex.py

@@ -326,11 +326,9 @@ class OpenAICodexOAuthProvider(OAuthProvider):
         await asyncio.to_thread(_revoke_token_sync, credential.refresh)
 
     @property
-    def api(self):
-        """Return the API class that handles requests with this provider's tokens."""
-        from tau.inference.api.text.openai_codex_responses import OpenAICodexResponsesAPI
-
-        return OpenAICodexResponsesAPI
+    def api(self) -> str:
+        """Registry key for the API class; resolved (and the SDK imported) lazily."""
+        return "openai_codex_responses"
 
     async def validate(
         self, credential: OAuthCredential, signal: AbortSignal | None = None

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/inference/provider/oauth/xai_grok.py

@@ -269,11 +269,9 @@ class XAIGrokOAuthProvider(OAuthProvider):
         await asyncio.to_thread(_revoke_token_sync, credential.refresh)
 
     @property
-    def api(self):
-        """Return the API class that handles requests with this provider's tokens."""
-        from tau.inference.api.text.xai_responses import XAIAPIResponses
-
-        return XAIAPIResponses
+    def api(self) -> str:
+        """Registry key for the API class; resolved (and the SDK imported) lazily."""
+        return "xai"
 
     async def validate(
         self, credential: OAuthCredential, signal: AbortSignal | None = None

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/inference/provider/types.py

@@ -32,8 +32,10 @@ class OAuthProvider(ABC):
 
     @property
     @abstractmethod
-    def api(self) -> type[BaseLLMAPI]:
-        """Return the LLM API class for this provider."""
+    def api(self) -> str | type[BaseLLMAPI]:
+        """Return the LLM API class for this provider, or a lazy 'registry-key' /
+        'module:ClassName' reference so the provider SDK isn't imported until
+        the API is actually resolved (first request)."""
         ...
 
     @abstractmethod

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/tui/utils.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import difflib
 import re
 import subprocess
 import unicodedata
@@ -633,24 +632,34 @@ def _is_diff(text: str) -> bool:
 
 
 def _word_diff(old: str, new: str, inverse: Callable[[str], str]) -> tuple[str, str]:
-    """Highlight changed words with inverse video."""
+    """Highlight changed words with inverse video.
+
+    Uses rapidfuzz's C++ Indel opcodes instead of difflib.SequenceMatcher —
+    difflib has pathological worst-case slowness on some inputs, and
+    rapidfuzz is meaningfully faster on long lines with the same
+    equal/insert/delete opcode semantics (Indel never emits "replace"; a
+    substitution surfaces as an adjacent delete+insert pair instead, which
+    renders identically here since each tag only ever touches one side).
+    """
+    from rapidfuzz.distance import Indel
+
     old_words = re.split(r"(\s+)", old)
     new_words = re.split(r"(\s+)", new)
-    sm = difflib.SequenceMatcher(None, old_words, new_words, autojunk=False)
+    opcodes = Indel.opcodes(old_words, new_words)
 
     old_out, new_out = [], []
-    for tag, i1, i2, j1, j2 in sm.get_opcodes():
-        old_chunk = "".join(old_words[i1:i2])
-        new_chunk = "".join(new_words[j1:j2])
-        if tag == "equal":
+    for op in opcodes:
+        old_chunk = "".join(old_words[op.src_start : op.src_end])
+        new_chunk = "".join(new_words[op.dest_start : op.dest_end])
+        if op.tag == "equal":
             old_out.append(old_chunk)
             new_out.append(new_chunk)
-        elif tag == "replace":
+        elif op.tag == "replace":
             old_out.append(inverse(old_chunk) if old_chunk.strip() else old_chunk)
             new_out.append(inverse(new_chunk) if new_chunk.strip() else new_chunk)
-        elif tag == "delete":
+        elif op.tag == "delete":
             old_out.append(inverse(old_chunk) if old_chunk.strip() else old_chunk)
-        elif tag == "insert":
+        elif op.tag == "insert":
             new_out.append(inverse(new_chunk) if new_chunk.strip() else new_chunk)
 
     return "".join(old_out), "".join(new_out)

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau/utils/version_check.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import contextlib
 
 _TIMEOUT = 5.0
@@ -42,19 +43,31 @@ def _is_newer(latest: str, current: str) -> bool:
         return False
 
 
+def _fetch_latest_version_sync() -> str:
+    """Blocking GET against PyPI; run off the event loop (see ``check_for_new_version``)."""
+    import httpx
+
+    with httpx.Client(timeout=_TIMEOUT) as client:
+        resp = client.get(_pypi_url(), headers={"Accept": "application/json"})
+        resp.raise_for_status()
+        data = resp.json()
+        return data.get("info", {}).get("version", "")
+
+
 async def check_for_new_version(current_version: str) -> str | None:
-    """Return the latest PyPI version string if newer than current, else None."""
+    """Return the latest PyPI version string if newer than current, else None.
+
+    Runs on a worker thread: building an httpx client constructs an SSL
+    context, which on Windows enumerates the system certificate store and can
+    take several hundred ms of synchronous CPU work. Doing that inline on the
+    event loop — even though this whole check is itself a backgrounded,
+    unawaited task — would still stall the just-launched TUI's render loop for
+    that duration, since both share the same thread.
+    """
     try:
-        import httpx
-
-        async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
-            resp = await client.get(_pypi_url(), headers={"Accept": "application/json"})
-            if not resp.is_success:
-                return None
-            data = resp.json()
-            latest = data.get("info", {}).get("version", "")
-            if latest and _is_newer(latest, current_version):
-                return latest
+        latest = await asyncio.to_thread(_fetch_latest_version_sync)
+        if latest and _is_newer(latest, current_version):
+            return latest
     except Exception:
         return None
     return None

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0/tau_coding_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.6.8
+Version: 0.7.0
 Summary: A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -31,9 +31,9 @@ Requires-Dist: grapheme==0.6.0
 Requires-Dist: arrow==1.4.0
 Requires-Dist: kiwisolver==1.5.0
 Requires-Dist: tiktoken==0.13.0
+Requires-Dist: rapidfuzz==3.14.3
 Provides-Extra: tools
 Requires-Dist: ripgrep>=14.0.0; extra == "tools"
-Requires-Dist: ast-grep-cli>=0.44.0; extra == "tools"
 Dynamic: license-file
 
 <div align="center">

{tau_coding_agent-0.6.8 → tau_coding_agent-0.7.0}/tau_coding_agent.egg-info/requires.txt

@@ -24,7 +24,7 @@ grapheme==0.6.0
 arrow==1.4.0
 kiwisolver==1.5.0
 tiktoken==0.13.0
+rapidfuzz==3.14.3
 
 [tools]
 ripgrep>=14.0.0
-ast-grep-cli>=0.44.0