thwip-cli 1.0.0__py3-none-any.whl

thwip/config.py

@@ -0,0 +1,363 @@
+"""
+Configuration management for thwip.
+
+Handles:
+- Loading/saving ~/.thwip/config.toml
+- Auto-discovering API keys from installed agent configs and env vars
+- First-run setup wizard
+- Merging keys from all sources
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+import tomli_w
+
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+
+def get_config_dir() -> Path:
+    """Return ~/.thwip/, creating it if needed."""
+    config_dir = Path.home() / ".thwip"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_sessions_dir() -> Path:
+    """Return ~/.thwip/sessions/, creating it if needed."""
+    d = get_config_dir() / "sessions"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def get_config_path() -> Path:
+    return get_config_dir() / "config.toml"
+
+
+def get_usage_path() -> Path:
+    return get_config_dir() / "usage.json"
+
+
+# ---------------------------------------------------------------------------
+# API Key Discovery
+# ---------------------------------------------------------------------------
+
+# Map of env var names to provider keys
+ENV_KEY_MAP: dict[str, str] = {
+    "ANTHROPIC_API_KEY": "anthropic",
+    "OPENAI_API_KEY": "openai",
+    "GEMINI_API_KEY": "google",
+    "GOOGLE_API_KEY": "google",
+    "DEEPSEEK_API_KEY": "deepseek",
+    "MISTRAL_API_KEY": "mistral",
+    "GROQ_API_KEY": "groq",
+    "OPENROUTER_API_KEY": "openrouter",
+}
+
+# Known agent config file locations where we can find API keys
+AGENT_CONFIG_LOCATIONS: list[dict[str, Any]] = [
+    {
+        "provider": "anthropic",
+        "paths": ["~/.claude.json", "~/.claude/config.json", "~/.config/claude/config.json"],
+        "key_field": "apiKey",
+        "format": "json",
+    },
+    {
+        "provider": "openai",
+        "paths": ["~/.config/openai/config.json"],
+        "key_field": "api_key",
+        "format": "json",
+    },
+    {
+        "provider": "google",
+        "paths": [
+            "~/.config/gemini/config.json",
+            "~/.gemini/config.json",
+        ],
+        "key_field": "api_key",
+        "format": "json",
+    },
+]
+
+
+def discover_api_keys() -> dict[str, str]:
+    """
+    Auto-discover API keys from:
+    1. Environment variables
+    2. Installed agent config files
+    3. thwip's own config
+
+    Returns a dict of {provider: api_key}.
+    """
+    keys: dict[str, str] = {}
+
+    # --- 1. Environment variables ---
+    for env_var, provider in ENV_KEY_MAP.items():
+        val = os.environ.get(env_var, "").strip()
+        if val:
+            keys[provider] = val
+
+    # --- 2. Installed agent config files ---
+    for agent_conf in AGENT_CONFIG_LOCATIONS:
+        provider = agent_conf["provider"]
+        if provider in keys:
+            continue  # Already found from env
+
+        for path_str in agent_conf["paths"]:
+            path = Path(path_str).expanduser()
+            if not path.is_file():
+                continue
+            try:
+                if agent_conf["format"] == "json":
+                    data = json.loads(path.read_text())
+                    key_field = agent_conf["key_field"]
+                    # Support nested keys like {"credentials": {"api_key": "..."}}
+                    if isinstance(data, dict):
+                        val = data.get(key_field, "")
+                        if not val and "credentials" in data:
+                            val = data["credentials"].get(key_field, "")
+                        if val:
+                            keys[provider] = val
+                            break
+            except (json.JSONDecodeError, KeyError, TypeError, OSError):
+                continue
+
+    return keys
+
+
+def get_key_sources() -> dict[str, str]:
+    """Return where each discovered key came from (for display)."""
+    sources: dict[str, str] = {}
+
+    for env_var, provider in ENV_KEY_MAP.items():
+        if os.environ.get(env_var, "").strip():
+            sources[provider] = f"env:{env_var}"
+
+    for agent_conf in AGENT_CONFIG_LOCATIONS:
+        provider = agent_conf["provider"]
+        if provider in sources:
+            continue
+        for path_str in agent_conf["paths"]:
+            path = Path(path_str).expanduser()
+            if path.is_file():
+                try:
+                    data = json.loads(path.read_text())
+                    if data.get(agent_conf["key_field"]):
+                        sources[provider] = str(path)
+                        break
+                except (json.JSONDecodeError, OSError):
+                    continue
+
+    return sources
+
+
+# ---------------------------------------------------------------------------
+# Config Dataclass
+# ---------------------------------------------------------------------------
+
+@dataclass
+class FallbackConfig:
+    enabled: bool = True
+    chain: list[str] = field(default_factory=lambda: [
+        "claude/claude-sonnet-4",
+        "google/gemini-2.5-pro",
+        "openai/gpt-4.1",
+        "deepseek/deepseek-chat",
+        "ollama/llama3.3",
+    ])
+
+
+@dataclass
+class DisplayConfig:
+    show_agent_badge: bool = True
+    show_token_count: bool = True
+    show_cost: bool = True
+    show_capabilities: bool = True
+    markdown: bool = True
+    syntax_highlight: bool = True
+    max_width: int = 120
+    dynamic_ui: bool = True  # Change UI based on agent capabilities
+
+
+@dataclass
+class LimitsConfig:
+    warn_at_percent: int = 80
+    auto_switch: bool = False  # Prompt user vs auto-switch
+
+
+@dataclass
+class ThwipConfig:
+    """Main configuration object."""
+
+    # Defaults
+    default_agent: str = "claude"
+    default_model: str = "claude-sonnet-4"
+    project: str = "."
+    theme: str = "dark"
+    stream: bool = True
+    auto_save: bool = True
+    confirm_tools: bool = True
+
+    # API keys (merged from all sources)
+    keys: dict[str, str] = field(default_factory=dict)
+    key_sources: dict[str, str] = field(default_factory=dict)
+
+    # Ollama
+    ollama_host: str = "http://localhost:11434"
+
+    # Sub-configs
+    fallback: FallbackConfig = field(default_factory=FallbackConfig)
+    display: DisplayConfig = field(default_factory=DisplayConfig)
+    limits: LimitsConfig = field(default_factory=LimitsConfig)
+
+    @classmethod
+    def load(cls) -> "ThwipConfig":
+        """Load config from file, env vars, and agent configs."""
+        config = cls()
+        config_path = get_config_path()
+
+        # Load from file if exists
+        if config_path.is_file():
+            try:
+                with open(config_path, "rb") as f:
+                    data = tomllib.load(f)
+                config._apply_toml(data)
+            except Exception:
+                pass  # Use defaults on parse error
+
+        # Merge API keys from all sources
+        discovered = discover_api_keys()
+        config.key_sources = get_key_sources()
+
+        # Config file keys take priority, then discovered keys fill gaps
+        for provider, key in discovered.items():
+            if provider not in config.keys or not config.keys[provider]:
+                config.keys[provider] = key
+
+        return config
+
+    def _apply_toml(self, data: dict[str, Any]) -> None:
+        """Apply parsed TOML data to config fields."""
+        defaults = data.get("defaults", {})
+        if "agent" in defaults:
+            self.default_agent = defaults["agent"]
+        if "model" in defaults:
+            self.default_model = defaults["model"]
+        if "project" in defaults:
+            self.project = defaults["project"]
+        if "theme" in defaults:
+            self.theme = defaults["theme"]
+        if "stream" in defaults:
+            self.stream = defaults["stream"]
+        if "auto_save" in defaults:
+            self.auto_save = defaults["auto_save"]
+        if "confirm_tools" in defaults:
+            self.confirm_tools = defaults["confirm_tools"]
+
+        # Keys from config file
+        keys_data = data.get("keys", {})
+        for provider, key in keys_data.items():
+            if key:  # Only if non-empty
+                self.keys[provider] = key
+                self.key_sources[provider] = "config.toml"
+
+        # Ollama
+        ollama = data.get("ollama", {})
+        if "host" in ollama:
+            self.ollama_host = ollama["host"]
+
+        # Fallback
+        fallback = data.get("fallback", {})
+        if "enabled" in fallback:
+            self.fallback.enabled = fallback["enabled"]
+        if "chain" in fallback:
+            self.fallback.chain = fallback["chain"]
+
+        # Display
+        display = data.get("display", {})
+        for key in ("show_agent_badge", "show_token_count", "show_cost",
+                     "show_capabilities", "markdown", "syntax_highlight",
+                     "max_width", "dynamic_ui"):
+            if key in display:
+                setattr(self.display, key, display[key])
+
+        # Limits
+        limits = data.get("limits", {})
+        if "warn_at_percent" in limits:
+            self.limits.warn_at_percent = limits["warn_at_percent"]
+        if "auto_switch" in limits:
+            self.limits.auto_switch = limits["auto_switch"]
+
+    def save(self) -> None:
+        """Save current config to TOML file."""
+        data: dict[str, Any] = {
+            "defaults": {
+                "agent": self.default_agent,
+                "model": self.default_model,
+                "project": self.project,
+                "theme": self.theme,
+                "stream": self.stream,
+                "auto_save": self.auto_save,
+                "confirm_tools": self.confirm_tools,
+            },
+            "keys": {k: v for k, v in self.keys.items()},
+            "ollama": {
+                "host": self.ollama_host,
+            },
+            "fallback": {
+                "enabled": self.fallback.enabled,
+                "chain": self.fallback.chain,
+            },
+            "display": {
+                "show_agent_badge": self.display.show_agent_badge,
+                "show_token_count": self.display.show_token_count,
+                "show_cost": self.display.show_cost,
+                "show_capabilities": self.display.show_capabilities,
+                "markdown": self.display.markdown,
+                "syntax_highlight": self.display.syntax_highlight,
+                "max_width": self.display.max_width,
+                "dynamic_ui": self.display.dynamic_ui,
+            },
+            "limits": {
+                "warn_at_percent": self.limits.warn_at_percent,
+                "auto_switch": self.limits.auto_switch,
+            },
+        }
+
+        config_path = get_config_path()
+        with open(config_path, "wb") as f:
+            tomli_w.dump(data, f)
+
+    def get_key(self, provider: str) -> str | None:
+        """Get API key for a provider, returning None if not found."""
+        return self.keys.get(provider)
+
+    def has_key(self, provider: str) -> bool:
+        """Check if we have a valid API key for a provider."""
+        key = self.keys.get(provider, "")
+        return bool(key and key.strip())
+
+
+def create_default_config() -> None:
+    """Create default config file if it doesn't exist."""
+    config_path = get_config_path()
+    if config_path.is_file():
+        return
+
+    config = ThwipConfig()
+    # Discover any existing keys
+    config.keys = discover_api_keys()
+    config.save()

thwip/detector.py

@@ -0,0 +1,259 @@
+"""
+System-wide coding agent & LLM detector.
+
+Scans the local machine for:
+1. CLI binaries (claude, agy, gemini, codex, aider, copilot, ollama)
+2. npm global packages
+3. Python / pip packages
+4. VS Code & Cursor extensions (Cline, Continue, Copilot, etc.)
+5. macOS Applications (/Applications/Cursor.app, /Applications/Windsurf.app)
+6. Environment variables & agent credential files
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from thwip.agents.base import Capability
+
+
+@dataclass
+class DetectedTool:
+    """An AI coding tool or agent discovered on the system."""
+    name: str
+    company: str
+    category: str               # "CLI Agent", "IDE App", "Editor Extension", "Local Engine"
+    install_path: str
+    version: str | None = None
+    is_configured: bool = False
+    config_source: str = ""
+    capabilities: list[str] = field(default_factory=list)
+    subscription_status: str = "Unknown"
+
+
+# Comprehensive signature database of AI coding tools
+KNOWN_CLI_TOOLS: list[dict[str, Any]] = [
+    {
+        "name": "Claude Code",
+        "company": "Anthropic",
+        "binaries": ["claude"],
+        "category": "CLI Agent",
+        "capabilities": ["Chat", "File Edit", "Code Run", "Terminal", "Git", "Search"],
+        "key_env": "ANTHROPIC_API_KEY",
+        "config_files": ["~/.claude.json", "~/.claude/config.json"],
+    },
+    {
+        "name": "Antigravity / Gemini CLI",
+        "company": "Google",
+        "binaries": ["agy", "gemini", "antigravity"],
+        "category": "CLI Agent",
+        "capabilities": ["Chat", "File Edit", "Code Run", "Terminal", "Browser", "Search"],
+        "key_env": "GEMINI_API_KEY",
+        "config_files": ["~/.config/gemini/config.json", "~/.gemini/config.json"],
+    },
+    {
+        "name": "Codex / OpenAI CLI",
+        "company": "OpenAI",
+        "binaries": ["codex", "openai"],
+        "category": "CLI Agent",
+        "capabilities": ["Chat", "File Edit", "Code Run", "Terminal"],
+        "key_env": "OPENAI_API_KEY",
+        "config_files": ["~/.config/openai/config.json"],
+    },
+    {
+        "name": "Aider",
+        "company": "Independent",
+        "binaries": ["aider"],
+        "category": "CLI Agent",
+        "capabilities": ["Chat", "File Edit", "Git"],
+        "key_env": "OPENAI_API_KEY",
+        "config_files": ["~/.aider.conf.yml"],
+    },
+    {
+        "name": "GitHub Copilot CLI",
+        "company": "GitHub / Microsoft",
+        "binaries": ["github-copilot-cli", "copilot"],
+        "category": "CLI Agent",
+        "capabilities": ["Chat", "Terminal Suggestions"],
+        "key_env": "GITHUB_TOKEN",
+        "config_files": ["~/.config/github-copilot/hosts.json"],
+    },
+    {
+        "name": "Ollama",
+        "company": "Ollama",
+        "binaries": ["ollama"],
+        "category": "Local Engine",
+        "capabilities": ["Chat", "File Edit", "Code Run"],
+        "key_env": "",
+        "config_files": [],
+    },
+]
+
+KNOWN_APPS: list[dict[str, Any]] = [
+    {
+        "name": "Cursor",
+        "company": "Cursor Inc",
+        "mac_path": "/Applications/Cursor.app",
+        "category": "IDE App",
+        "capabilities": ["Chat", "File Edit", "Terminal", "Codebase Indexing"],
+    },
+    {
+        "name": "Windsurf",
+        "company": "Codeium",
+        "mac_path": "/Applications/Windsurf.app",
+        "category": "IDE App",
+        "capabilities": ["Chat", "File Edit", "Terminal", "Cascade Flows"],
+    },
+]
+
+KNOWN_EXTENSIONS: list[dict[str, Any]] = [
+    {
+        "id": "saoudrizwan.claude-dev",
+        "name": "Cline (Claude Dev)",
+        "company": "Independent",
+        "capabilities": ["Chat", "File Edit", "Terminal", "Browser"],
+    },
+    {
+        "id": "continue.continue",
+        "name": "Continue.dev",
+        "company": "Continue",
+        "capabilities": ["Chat", "File Edit", "Autocomplete"],
+    },
+    {
+        "id": "github.copilot",
+        "name": "GitHub Copilot",
+        "company": "Microsoft",
+        "capabilities": ["Chat", "Autocomplete"],
+    },
+]
+
+
+class SystemDetector:
+    """Scans and discovers all AI coding agents and installed environments."""
+
+    def __init__(self) -> None:
+        self.detected_tools: list[DetectedTool] = []
+
+    def scan_all(self) -> list[DetectedTool]:
+        """Perform a full system discovery scan."""
+        tools: list[DetectedTool] = []
+
+        # 1. Scan CLI Tools
+        for spec in KNOWN_CLI_TOOLS:
+            binary_found = None
+            for b in spec["binaries"]:
+                p = shutil.which(b)
+                if p:
+                    binary_found = p
+                    break
+
+            is_configured = False
+            config_source = ""
+
+            # Check environment variables
+            if spec.get("key_env") and os.environ.get(spec["key_env"]):
+                is_configured = True
+                config_source = f"env:{spec['key_env']}"
+
+            # Check config files
+            if not is_configured:
+                for c_file in spec.get("config_files", []):
+                    cp = Path(c_file).expanduser()
+                    if cp.is_file():
+                        is_configured = True
+                        config_source = str(cp)
+                        break
+
+            # Ollama is configured if binary is present
+            if spec["name"] == "Ollama" and binary_found:
+                is_configured = True
+                config_source = "localhost:11434"
+
+            if binary_found or is_configured:
+                # Try getting version
+                ver = None
+                if binary_found:
+                    try:
+                        res = subprocess.run(
+                            [binary_found, "--version"],
+                            capture_output=True,
+                            text=True,
+                            timeout=3,
+                        )
+                        if res.returncode == 0:
+                            ver = res.stdout.strip().split("\n")[0]
+                    except Exception:
+                        pass
+
+                sub_status = "Active" if is_configured else "Needs Key"
+                if spec["name"] == "Ollama":
+                    sub_status = "Unlimited"
+
+                tools.append(
+                    DetectedTool(
+                        name=spec["name"],
+                        company=spec["company"],
+                        category=spec["category"],
+                        install_path=binary_found or "(API only)",
+                        version=ver,
+                        is_configured=is_configured,
+                        config_source=config_source,
+                        capabilities=spec["capabilities"],
+                        subscription_status=sub_status,
+                    )
+                )
+
+        # 2. Scan macOS /Applications
+        for app in KNOWN_APPS:
+            p = Path(app["mac_path"])
+            if p.exists():
+                tools.append(
+                    DetectedTool(
+                        name=app["name"],
+                        company=app["company"],
+                        category=app["category"],
+                        install_path=str(p),
+                        version="Installed",
+                        is_configured=True,
+                        config_source="macOS App",
+                        capabilities=app["capabilities"],
+                        subscription_status="Active",
+                    )
+                )
+
+        # 3. Scan VS Code extensions
+        try:
+            res = subprocess.run(
+                ["code", "--list-extensions"],
+                capture_output=True,
+                text=True,
+                timeout=4,
+            )
+            if res.returncode == 0:
+                installed_exts = res.stdout.lower().splitlines()
+                for ext in KNOWN_EXTENSIONS:
+                    if ext["id"].lower() in installed_exts:
+                        tools.append(
+                            DetectedTool(
+                                name=f"{ext['name']} (VS Code)",
+                                company=ext["company"],
+                                category="Editor Extension",
+                                install_path="VS Code Extension",
+                                version="Installed",
+                                is_configured=True,
+                                config_source="VS Code Config",
+                                capabilities=ext["capabilities"],
+                                subscription_status="Active",
+                            )
+                        )
+        except Exception:
+            pass
+
+        self.detected_tools = tools
+        return tools

thwip/limits.py

@@ -0,0 +1,84 @@
+"""
+Usage tracking & limit management for thwip.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+from thwip.config import get_usage_path
+from thwip.utils import estimate_cost
+
+
+@dataclass
+class AgentUsageStats:
+    """Cumulative usage statistics for a specific agent."""
+    input_tokens: int = 0
+    output_tokens: int = 0
+    request_count: int = 0
+    estimated_cost: float = 0.0
+    last_limit_hit_timestamp: float = 0.0
+    last_error: str = ""
+
+
+class UsageTracker:
+    """Tracks token usage and costs across sessions and agents."""
+
+    def __init__(self) -> None:
+        self.stats: dict[str, AgentUsageStats] = {}
+        self.load()
+
+    def record_usage(self, agent_name: str, model: str, input_tokens: int, output_tokens: int) -> None:
+        """Record tokens used for an agent call."""
+        if agent_name not in self.stats:
+            self.stats[agent_name] = AgentUsageStats()
+
+        st = self.stats[agent_name]
+        st.input_tokens += input_tokens
+        st.output_tokens += output_tokens
+        st.request_count += 1
+        st.estimated_cost += estimate_cost(model, input_tokens, output_tokens)
+        self.save()
+
+    def record_limit_hit(self, agent_name: str, error_msg: str) -> None:
+        """Record when an agent hits a rate limit or quota."""
+        if agent_name not in self.stats:
+            self.stats[agent_name] = AgentUsageStats()
+        self.stats[agent_name].last_limit_hit_timestamp = time.time()
+        self.stats[agent_name].last_error = error_msg
+        self.save()
+
+    def get_summary(self) -> dict[str, Any]:
+        """Return summary of total spend and tokens."""
+        total_tokens = sum(s.input_tokens + s.output_tokens for s in self.stats.values())
+        total_cost = sum(s.estimated_cost for s in self.stats.values())
+        total_reqs = sum(s.request_count for s in self.stats.values())
+        return {
+            "total_tokens": total_tokens,
+            "total_cost": total_cost,
+            "total_requests": total_reqs,
+            "by_agent": {k: asdict(v) for k, v in self.stats.items()},
+        }
+
+    def save(self) -> None:
+        path = get_usage_path()
+        data = {k: asdict(v) for k, v in self.stats.items()}
+        try:
+            path.write_text(json.dumps(data, indent=2))
+        except Exception:
+            pass
+
+    def load(self) -> None:
+        path = get_usage_path()
+        if not path.is_file():
+            return
+        try:
+            data = json.loads(path.read_text())
+            for k, v in data.items():
+                self.stats[k] = AgentUsageStats(**v)
+        except Exception:
+            pass