thwip-cli 1.0.3__tar.gz → 1.0.4__tar.gz

{thwip_cli-1.0.3 → thwip_cli-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: thwip-cli
-Version: 1.0.3
+Version: 1.0.4
 Summary: Universal coding agent multiplexer: detect, switch, and route between AI coding agents seamlessly
 Project-URL: Homepage, https://github.com/tanmayhutt/thwip-cli
 Project-URL: Repository, https://github.com/tanmayhutt/thwip-cli

{thwip_cli-1.0.3 → thwip_cli-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thwip-cli"
-version = "1.0.3"
+version = "1.0.4"
 description = "Universal coding agent multiplexer: detect, switch, and route between AI coding agents seamlessly"
 readme = "README.md"
 license = "MIT"

{thwip_cli-1.0.3 → thwip_cli-1.0.4}/thwip/__init__.py

@@ -1,4 +1,4 @@
 """thwip: Universal Coding Agent Multiplexer."""
 
-__version__ = "1.0.3"
+__version__ = "1.0.4"
 __app_name__ = "thwip"

{thwip_cli-1.0.3 → thwip_cli-1.0.4}/thwip/agents/base.py

@@ -210,9 +210,22 @@ class BaseAgent(ABC):
 
     @abstractmethod
     def is_configured(self) -> bool:
-        """Check if this agent has a valid API key / credentials."""
+        """Check if this agent has a valid API key or OAuth/subscription credentials."""
         ...
 
+    def _has_cli_auth(self) -> dict[str, str] | None:
+        """
+        Check if the agent's CLI tool has its own OAuth/subscription auth.
+        Returns dict with 'method' and 'account' keys if found, else None.
+        Subclasses should override this.
+        """
+        return None
+
+    @property
+    def auth_method(self) -> str:
+        """Return the auth method in use: 'api_key', 'oauth', 'subscription', or 'none'."""
+        return "none"
+
     @abstractmethod
     def get_install_info(self) -> dict[str, str]:
         """
@@ -305,6 +318,15 @@ class BaseAgent(ABC):
         if not self.is_configured():
             return ("Installed (No Key)", "status.limited")
 
+        # Show auth method in status for non-API-key auth
+        auth = self.auth_method
+        if auth in ("oauth", "subscription"):
+            cli_auth = self._has_cli_auth()
+            account = cli_auth.get("account", "") if cli_auth else ""
+            if account:
+                return (f"Ready ({account})", "status.ready")
+            return ("Ready (CLI Auth)", "status.ready")
+
         limit = self.check_limits()
         if limit == LimitStatus.OK:
             return ("Ready", "status.ready")

{thwip_cli-1.0.3 → thwip_cli-1.0.4}/thwip/agents/claude_agent.py

@@ -155,7 +155,11 @@ class ClaudeAgent(BaseAgent):
     # --- Detection ---
 
     def is_installed(self) -> bool:
-        """Check if Claude Code CLI or Claude desktop app is installed or configured."""
+        """Check if Claude Code CLI or Claude desktop app is installed.
+
+        The ~/.claude directory alone is not sufficient since other IDEs
+        (like Antigravity) may create it.
+        """
         if self.is_configured():
             return True
         if shutil.which("claude") is not None:
@@ -163,13 +167,50 @@ class ClaudeAgent(BaseAgent):
         app_paths = [
             Path("/Applications/Claude.app"),
             Path.home() / "Applications" / "Claude.app",
-            Path.home() / ".claude",
         ]
         return any(p.exists() for p in app_paths)
 
+    def _has_cli_auth(self) -> dict[str, str] | None:
+        """Check for Claude Code subscription auth.
+
+        Requires the `claude` CLI binary or Claude.app to be present.
+        The ~/.claude directory alone is not sufficient since other IDEs
+        (like Antigravity) may create it.
+        """
+        has_cli = shutil.which("claude") is not None
+        has_app = Path("/Applications/Claude.app").exists() or (Path.home() / "Applications" / "Claude.app").exists()
+
+        if not has_cli and not has_app:
+            return None
+
+        claude_dir = Path.home() / ".claude"
+        if not claude_dir.is_dir():
+            return None
+
+        # Claude Code stores session data when authenticated
+        auth_indicators = [
+            claude_dir / "projects",
+            claude_dir / "backups",
+            claude_dir / "debug",
+        ]
+        has_sessions = any(p.is_dir() and any(p.iterdir()) for p in auth_indicators if p.exists())
+
+        if has_sessions:
+            return {"method": "subscription", "account": "Anthropic Max"}
+
+        return None
+
+    @property
+    def auth_method(self) -> str:
+        if self._get_api_key():
+            return "api_key"
+        if self._has_cli_auth():
+            return "subscription"
+        return "none"
+
     def is_configured(self) -> bool:
-        """Check if we have a valid Anthropic API key."""
-        return bool(self._get_api_key())
+        """Check if we have a valid API key or subscription auth."""
+        return bool(self._get_api_key()) or bool(self._has_cli_auth())
 
     def get_install_info(self) -> dict[str, str]:
         """Get Claude Code installation details."""
@@ -198,7 +239,6 @@ class ClaudeAgent(BaseAgent):
             app_paths = [
                 Path("/Applications/Claude.app"),
                 Path.home() / "Applications" / "Claude.app",
-                Path.home() / ".claude",
             ]
             for app in app_paths:
                 if app.exists():
@@ -213,29 +253,35 @@ class ClaudeAgent(BaseAgent):
     def get_subscription_info(self) -> SubscriptionInfo:
         """
         Determine subscription status.
-        We can't fully detect tier without an API call, but we can infer from
-        the key prefix and check basic validity.
+        Checks API key first, then CLI subscription auth.
         """
         key = self._get_api_key()
-        if not key:
+        if key:
+            if key.startswith("sk-ant-"):
+                return SubscriptionInfo(
+                    tier=SubscriptionTier.PRO,
+                    is_active=True,
+                    message="Anthropic API key detected",
+                )
             return SubscriptionInfo(
                 tier=SubscriptionTier.UNKNOWN,
-                is_active=False,
-                message="No API key found",
+                is_active=True,
+                message="API key detected",
             )
 
-        # Anthropic keys start with "sk-ant-"
-        if key.startswith("sk-ant-"):
+        cli_auth = self._has_cli_auth()
+        if cli_auth:
+            account = cli_auth.get("account", "Active")
             return SubscriptionInfo(
-                tier=SubscriptionTier.PRO,  # Assume pro if they have a key
+                tier=SubscriptionTier.PRO,
                 is_active=True,
-                message="API key detected",
+                message=f"Claude Code ({account})",
             )
 
         return SubscriptionInfo(
             tier=SubscriptionTier.UNKNOWN,
-            is_active=True,
-            message="API key format not recognized, but may work",
+            is_active=False,
+            message="No credentials found",
         )
 
     # --- Chat ---

{thwip_cli-1.0.3 → thwip_cli-1.0.4}/thwip/agents/google_agent.py

@@ -167,8 +167,31 @@ class GoogleAgent(BaseAgent):
         ]
         return any(p.exists() for p in app_paths)
 
+    def _has_cli_auth(self) -> dict[str, str] | None:
+        """Check for Google OAuth via Gemini CLI's google_accounts.json."""
+        acc_file = Path.home() / ".gemini" / "google_accounts.json"
+        if acc_file.is_file():
+            try:
+                data = json.loads(acc_file.read_text())
+                account = data.get("active") or ""
+                if not account and data.get("old"):
+                    account = data["old"][0]
+                if account:
+                    return {"method": "google_oauth", "account": account}
+            except Exception:
+                pass
+        return None
+
+    @property
+    def auth_method(self) -> str:
+        if self._get_api_key():
+            return "api_key"
+        if self._has_cli_auth():
+            return "oauth"
+        return "none"
+
     def is_configured(self) -> bool:
-        return bool(self._get_api_key())
+        return bool(self._get_api_key()) or bool(self._has_cli_auth())
 
     def get_install_info(self) -> dict[str, str]:
         info: dict[str, str] = {"method": "not installed", "path": "", "version": ""}
@@ -220,25 +243,32 @@ class GoogleAgent(BaseAgent):
 
     def get_subscription_info(self) -> SubscriptionInfo:
         key = self._get_api_key()
-        if not key:
+        if key:
+            if key.startswith("AIza"):
+                return SubscriptionInfo(
+                    tier=SubscriptionTier.FREE,
+                    is_active=True,
+                    message="Google API key detected",
+                )
             return SubscriptionInfo(
                 tier=SubscriptionTier.UNKNOWN,
-                is_active=False,
-                message="No API key found",
+                is_active=True,
+                message="API key detected",
             )
 
-        # Google Gemini API keys typically start with "AIza"
-        if key.startswith("AIza"):
+        cli_auth = self._has_cli_auth()
+        if cli_auth:
+            account = cli_auth.get("account", "")
             return SubscriptionInfo(
-                tier=SubscriptionTier.FREE,  # Free tier by default
+                tier=SubscriptionTier.PRO,
                 is_active=True,
-                message="Google API key detected",
+                message=f"Google OAuth ({account})" if account else "Google OAuth active",
             )
 
         return SubscriptionInfo(
             tier=SubscriptionTier.UNKNOWN,
-            is_active=True,
-            message="API key detected",
+            is_active=False,
+            message="No credentials found",
         )
 
     # --- Chat ---

{thwip_cli-1.0.3 → thwip_cli-1.0.4}/thwip/agents/openai_agent.py

@@ -193,8 +193,47 @@ class OpenAIAgent(BaseAgent):
         ]
         return any(p.exists() for p in app_paths)
 
+    def _has_cli_auth(self) -> dict[str, str] | None:
+        """Check for ChatGPT OAuth via Codex CLI's auth.json."""
+        auth_file = Path.home() / ".codex" / "auth.json"
+        if auth_file.is_file():
+            try:
+                data = json.loads(auth_file.read_text())
+                if data.get("auth_mode") == "chatgpt" and data.get("tokens"):
+                    tokens = data["tokens"]
+                    result: dict[str, str] = {"method": "chatgpt_oauth"}
+                    # Decode plan info from JWT id_token claims (no verification)
+                    id_token = tokens.get("id_token", "")
+                    if id_token:
+                        try:
+                            import base64
+                            parts = id_token.split(".")
+                            if len(parts) >= 2:
+                                payload = parts[1]
+                                padding = 4 - len(payload) % 4
+                                if padding != 4:
+                                    payload += "=" * padding
+                                claims = json.loads(base64.urlsafe_b64decode(payload))
+                                result["account"] = claims.get("email", "")
+                                auth_info = claims.get("https://api.openai.com/auth", {})
+                                result["plan"] = auth_info.get("chatgpt_plan_type", "")
+                        except Exception:
+                            pass
+                    return result
+            except Exception:
+                pass
+        return None
+
+    @property
+    def auth_method(self) -> str:
+        if self._get_api_key():
+            return "api_key"
+        if self._has_cli_auth():
+            return "subscription"
+        return "none"
+
     def is_configured(self) -> bool:
-        return bool(self._get_api_key())
+        return bool(self._get_api_key()) or bool(self._has_cli_auth())
 
     def get_install_info(self) -> dict[str, str]:
         info: dict[str, str] = {"method": "not installed", "path": "", "version": ""}
@@ -233,24 +272,44 @@ class OpenAIAgent(BaseAgent):
 
     def get_subscription_info(self) -> SubscriptionInfo:
         key = self._get_api_key()
-        if not key:
+        if key:
+            if key.startswith("sk-"):
+                return SubscriptionInfo(
+                    tier=SubscriptionTier.PRO,
+                    is_active=True,
+                    message="OpenAI API key detected",
+                )
             return SubscriptionInfo(
                 tier=SubscriptionTier.UNKNOWN,
-                is_active=False,
-                message="No API key found",
+                is_active=True,
+                message="API key detected",
             )
 
-        if key.startswith("sk-"):
+        cli_auth = self._has_cli_auth()
+        if cli_auth:
+            plan = cli_auth.get("plan", "")
+            account = cli_auth.get("account", "")
+            tier_map = {
+                "plus": SubscriptionTier.PRO,
+                "pro": SubscriptionTier.PRO,
+                "team": SubscriptionTier.TEAM,
+                "enterprise": SubscriptionTier.ENTERPRISE,
+            }
+            tier = tier_map.get(plan, SubscriptionTier.UNKNOWN)
+            plan_label = plan.title() if plan else "Active"
+            msg = f"ChatGPT {plan_label}"
+            if account:
+                msg += f" ({account})"
             return SubscriptionInfo(
-                tier=SubscriptionTier.PRO,
+                tier=tier,
                 is_active=True,
-                message="OpenAI API key detected",
+                message=msg,
             )
 
         return SubscriptionInfo(
             tier=SubscriptionTier.UNKNOWN,
-            is_active=True,
-            message="API key detected",
+            is_active=False,
+            message="No credentials found",
         )
 
     # --- Chat ---

{thwip_cli-1.0.3 → thwip_cli-1.0.4}/thwip/cli.py

@@ -107,6 +107,8 @@ class ThwipCLI:
         """Main async REPL loop."""
         # 1. Detect agents on system
         detected = self.detector.scan_all()
+        all_agents = self.registry.list_agents()
+        installed_count = len([a for a in all_agents if a.is_installed()])
         ready_count = len(self.registry.get_ready_agents())
 
         # 2. Display startup banner
@@ -118,7 +120,7 @@ class ThwipCLI:
                 model=self.session.current_model,
                 project_path=os.path.abspath(self.session.project_path),
                 session_name=self.session.name,
-                agents_detected=len(detected),
+                agents_detected=installed_count,
                 agents_ready=ready_count,
             )
         )
@@ -326,15 +328,19 @@ class ThwipCLI:
     async def cmd_switch(self, agent_name: str, model_id: str = "") -> None:
         """Switch to a different agent and/or model."""
         if not agent_name:
-            agents = self.registry.list_agents()
-            console.print("\n[bold white]Available Coding Agents on Your Machine:[/bold white]")
+            all_agents = self.registry.list_agents()
+            installed = [a for a in all_agents if a.is_installed()]
 
-            # Group: Ready / Configured
-            ready_agents = [a for a in agents if a.is_configured()]
-            installed_agents = [a for a in agents if a.is_installed() and not a.is_configured()]
-            other_agents = [a for a in agents if not a.is_installed()]
+            if not installed:
+                print_error("No agents detected on your machine.")
+                return
 
-            ordered = ready_agents + installed_agents + other_agents
+            console.print("\n[bold white]Available Coding Agents on Your Machine:[/bold white]")
+
+            # Sort: configured first, then just installed
+            ready_agents = [a for a in installed if a.is_configured()]
+            unready_agents = [a for a in installed if not a.is_configured()]
+            ordered = ready_agents + unready_agents
 
             for i, a in enumerate(ordered, 1):
                 brand = get_brand(a.company)
@@ -347,10 +353,14 @@ class ThwipCLI:
                     f"({a.company}) - [{status_style}][{status_str}][/{status_style}][dim]{loc}[/dim]"
                 )
 
+            not_installed = len(all_agents) - len(installed)
+            if not_installed > 0:
+                console.print(f"\n  [dim]{not_installed} other providers available (DeepSeek, Groq, Ollama, OpenRouter). Use /agents to see all.[/dim]")
+
             choice = input(f"\nEnter choice [1-{len(ordered)}]: ").strip()
             if choice.isdigit() and 1 <= int(choice) <= len(ordered):
                 agent_name = ordered[int(choice) - 1].name
-            elif choice.lower() in [a.name for a in agents]:
+            elif choice.lower() in [a.name for a in installed]:
                 agent_name = choice.lower()
             else:
                 print_warning("Switch cancelled.")

{thwip_cli-1.0.3 → thwip_cli-1.0.4}/thwip/theme.py

@@ -16,6 +16,8 @@ from rich.table import Table
 from rich.text import Text
 from rich.theme import Theme
 from rich.markdown import Markdown
+
+from thwip import __version__
 from rich.syntax import Syntax
 from rich import box
 
@@ -151,7 +153,7 @@ def render_startup_banner(
     lines.append("╚═╝   ╚═╝  ╚═╝ ╚══╝╚══╝ ╚═╝╚═╝     \n\n", style="dim")
 
     lines.append("  Universal Coding Agent Multiplexer", style="bold white")
-    lines.append("  v1.0.2\n\n", style="dim")
+    lines.append(f"  v{__version__}\n\n", style="dim")
     lines.append("  Agent:       ", style="dim")
     lines.append(f"{agent_name}", style=brand.label_style)
     lines.append(f" ({company})\n", style="dim")
@@ -163,7 +165,7 @@ def render_startup_banner(
     lines.append(f"{session_name}\n", style="white")
     lines.append("  Environment: ", style="dim")
     lines.append(f"{agents_detected}", style="bold white")
-    lines.append(" tools detected, ", style="dim")
+    lines.append(" agents installed, ", style="dim")
     lines.append(f"{agents_ready}", style="success")
     lines.append(" ready\n\n", style="dim")
     lines.append("  Quickstart:  Type ", style="dim")

{thwip_cli-1.0.3 → thwip_cli-1.0.4}/uv.lock

@@ -1022,7 +1022,7 @@ wheels = [
 
 [[package]]
 name = "thwip-cli"
-version = "1.0.2"
+version = "1.0.4"
 source = { editable = "." }
 dependencies = [
     { name = "anthropic" },