tau-coding-agent 0.1.0__py3-none-any.whl

tau/tui/commands/auth.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import asyncio
+
+from tau.tui.commands.context import CommandContext
+
+
+def open_login_selector(ctx: CommandContext) -> None:
+    """Step 1 — choose auth type: subscription (OAuth) or API key."""
+    from tau.inference.api.text.service import TextLLM
+    from tau.inference.provider.types import OAuthProvider, APIProvider
+    from tau.tui.components.select_list import SelectItem
+
+    has_oauth = any(isinstance(p, OAuthProvider) for p in TextLLM._providers.list())
+    has_api   = any(isinstance(p, APIProvider)   for p in TextLLM._providers.list())
+
+    if has_oauth and has_api:
+        items = [
+            SelectItem(label="Subscription", description="OAuth — GitHub Copilot, OpenAI Codex, etc.", value="oauth"),
+            SelectItem(label="API key",      description="A static key, $ENV_VAR, or !command for a provider", value="api_key"),
+        ]
+        def on_type(auth_type: str) -> None:
+            if auth_type == "oauth":
+                open_oauth_provider_selector(ctx)
+            else:
+                open_api_key_provider_selector(ctx)
+        ctx.layout.open_tree_selector(items, on_type, lambda: ctx.notify("Login cancelled."))
+    elif has_oauth:
+        open_oauth_provider_selector(ctx)
+    else:
+        open_api_key_provider_selector(ctx)
+
+
+def _provider_items(providers: list) -> list:
+    from tau.tui.components.select_list import SelectItem
+    return [SelectItem(label=p.name, description=p.id, value=p.id) for p in providers]
+
+
+def open_oauth_provider_selector(ctx: CommandContext) -> None:
+    """Step 2 (OAuth path) — pick which OAuth provider to log in to."""
+    from tau.inference.api.text.service import TextLLM
+    from tau.inference.provider.types import OAuthProvider
+
+    providers = [p for p in TextLLM._providers.list() if isinstance(p, OAuthProvider)]
+    if not providers:
+        ctx.notify("No subscription providers available.")
+        return
+
+    items = _provider_items(providers)
+
+    def on_pick(provider_id: str) -> None:
+        asyncio.ensure_future(run_oauth_login(ctx, provider_id))
+
+    ctx.layout.open_tree_selector(items, on_pick, lambda: ctx.notify("Login cancelled."))
+
+
+async def run_oauth_login(ctx: CommandContext, provider_id: str) -> None:
+    """Run the full OAuth login flow, wiring callbacks to the TUI."""
+    import webbrowser
+    from tau.tui.ansi import BOLD, DIM, RESET
+    from tau.inference.api.text.service import TextLLM
+    from tau.inference.provider.types import OAuthProvider
+    from tau.inference.provider.oauth.types import OAuthLoginCallbacks, OAuthPrompt, OAuthAuthInfo
+
+    provider = next(
+        (p for p in TextLLM._providers.list()
+         if isinstance(p, OAuthProvider) and p.id == provider_id),
+        None,
+    )
+    if provider is None:
+        ctx.notify(f"Provider '{provider_id}' not found.")
+        return
+
+    ctx.layout.open_oauth_status([
+        f"  {BOLD}Logging in to {provider.name}{RESET}  {DIM}(Esc not available during flow){RESET}",
+    ])
+
+    _prompt_future: asyncio.Future[str] | None = None
+
+    def on_auth(info: OAuthAuthInfo) -> None:
+        ctx.layout.open_oauth_status([
+            f"  {BOLD}Logging in to {provider.name}{RESET}",
+            "",
+            f"  {DIM}Open this URL in your browser:{RESET}",
+            f"  {info.url}",
+        ])
+        if info.instructions:
+            ctx.layout.update_oauth_status(f"  {DIM}{info.instructions}{RESET}")
+        webbrowser.open(info.url)
+
+    async def on_prompt(prompt: OAuthPrompt) -> str:
+        nonlocal _prompt_future
+        loop = asyncio.get_event_loop()
+        _prompt_future = loop.create_future()
+        label = prompt.message
+        if prompt.placeholder:
+            label += f"  ({DIM}{prompt.placeholder}{RESET})"
+        ctx.layout.close_oauth_status()
+        ctx.layout.open_prompt(
+            label=label,
+            on_commit=lambda val: _prompt_future.set_result(val) if not _prompt_future.done() else None,
+            on_cancel=lambda: _prompt_future.set_exception(asyncio.CancelledError()) if not _prompt_future.done() else None,
+            secret=False,
+        )
+        try:
+            return await _prompt_future
+        except asyncio.CancelledError:
+            raise ValueError("Login cancelled")
+
+    def on_progress(message: str) -> None:
+        ctx.layout.open_oauth_status([
+            f"  {BOLD}Logging in to {provider.name}{RESET}",
+            f"  {DIM}{message}{RESET}",
+        ])
+
+    callbacks = OAuthLoginCallbacks(
+        on_auth=on_auth,
+        on_prompt=on_prompt,
+        on_progress=on_progress,
+    )
+
+    try:
+        await TextLLM._auth_manager.login(provider_id, callbacks)
+        ctx.layout.close_oauth_status()
+        ctx.notify(f"Logged in to {provider.name}. Credentials saved.")
+        if ctx.on_palette_refresh is not None:
+            ctx.on_palette_refresh()
+    except asyncio.CancelledError:
+        ctx.layout.close_oauth_status()
+        ctx.notify("Login cancelled.")
+    except Exception as exc:
+        ctx.layout.close_oauth_status()
+        msg = str(exc)
+        if msg and msg.lower() != "login cancelled":
+            ctx.notify(f"Login failed: {msg}")
+
+
+def open_api_key_provider_selector(ctx: CommandContext) -> None:
+    """Step 2 (API key path) — pick which provider to save a key for."""
+    from tau.inference.api.text.service import TextLLM
+    from tau.inference.provider.types import APIProvider
+
+    providers = [p for p in TextLLM._providers.list() if isinstance(p, APIProvider)]
+    if not providers:
+        ctx.notify("No API key providers available.")
+        return
+
+    items = _provider_items(providers)
+
+    def on_pick(provider_id: str) -> None:
+        provider = next((p for p in providers if p.id == provider_id), None)
+        if provider is None:
+            return
+        ctx.layout.open_prompt(
+            label=f"API key for {provider.name}  (literal, $ENV_VAR, or !command):",
+            on_commit=lambda key: _save_api_key(ctx, provider_id, provider.name, key),
+            on_cancel=lambda: ctx.notify("Login cancelled."),
+            secret=True,
+        )
+
+    ctx.layout.open_tree_selector(items, on_pick, lambda: ctx.notify("Login cancelled."))
+
+
+def _save_api_key(ctx: CommandContext, provider_id: str, provider_name: str, key: str) -> None:
+    from tau.inference.api.text.service import TextLLM
+    from tau.auth.types import APICredential
+
+    key = key.strip()
+    if not key:
+        ctx.notify("API key cannot be empty.")
+        return
+    TextLLM._auth_manager.set(provider_id, APICredential(key=key))
+    # $ENV_VAR / !command references are stored as-is and resolved at runtime.
+    ref = " (resolved at runtime)" if key[:1] in ("$", "!") else ""
+    ctx.notify(f"API key saved for {provider_name}.{ref}")
+    if ctx.on_palette_refresh is not None:
+        ctx.on_palette_refresh()
+
+
+def get_palette_overrides() -> dict[str, str]:
+    """Return dynamic palette description overrides for /login and /logout."""
+    overrides: dict[str, str] = {}
+    try:
+        from tau.inference.api.text.service import TextLLM
+        auth = TextLLM._auth_manager
+        auth.reload()
+        logged_in = auth.list()
+        if logged_in:
+            providers_str = ", ".join(logged_in)
+            overrides["login"] = f"Add credentials  ·  active: {providers_str}"
+            overrides["logout"] = f"Remove credentials  ·  active: {providers_str}"
+        else:
+            overrides["login"] = "Add credentials  ·  none active"
+            overrides["logout"] = "Remove credentials  ·  none active"
+    except Exception:
+        pass
+    return overrides
+
+
+def open_logout_selector(ctx: CommandContext) -> None:
+    from tau.inference.api.text.service import TextLLM
+    from tau.tui.components.select_list import SelectItem
+
+    TextLLM._auth_manager.reload()
+    stored = TextLLM._auth_manager.list()
+    if not stored:
+        ctx.notify(
+            "No stored credentials. /logout only removes keys saved by /login — "
+            "environment variables are unchanged."
+        )
+        return
+
+    providers = TextLLM._providers.list()
+    provider_map = {p.id: p for p in providers}
+
+    items = [
+        SelectItem(
+            label=provider_map[pid].name if pid in provider_map else pid,
+            description=pid,
+            value=pid,
+        )
+        for pid in stored
+    ]
+
+    def on_pick(provider_id: str) -> None:
+        name = provider_map[provider_id].name if provider_id in provider_map else provider_id
+        TextLLM._auth_manager.remove(provider_id)
+        ctx.notify(f"Removed stored credentials for {name}.")
+        if ctx.on_palette_refresh is not None:
+            ctx.on_palette_refresh()
+
+    ctx.layout.open_tree_selector(items, on_pick, lambda: ctx.notify("Logout cancelled."))

tau/tui/commands/context.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tau.runtime.service import Runtime
+    from tau.tui.components.layout import Layout
+    from tau.tui.tui import TUI
+
+
+@dataclass
+class CommandContext:
+    """Minimal context injected into every TUI command handler.
+
+    This is the single seam between App (orchestrator) and the command
+    modules (feature logic). Commands receive this instead of holding a
+    reference to the full App, so they can be called from keyboard
+    shortcuts, extension APIs, or tests without instantiating App.
+    """
+    runtime: "Runtime"
+    layout: "Layout"
+    tui: "TUI"
+    on_palette_refresh: Callable[[], None] | None = field(default=None)
+
+    def notify(self, text: str) -> None:
+        """Post a system status note to the chat stream."""
+        from tau.message.types import CustomMessage, LinesContent
+        lines = text.splitlines() + [""]
+        contents = [LinesContent(lines=lines)]
+        msg = CustomMessage(
+            custom_type="system",
+            timestamp=time.time(),
+            contents=contents,
+        )
+        self.layout.add_message(msg)
+        self.tui.request_render()

tau/tui/commands/misc.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+
+from tau.tui.commands.context import CommandContext
+
+
+def cmd_copy(ctx: CommandContext) -> None:
+    from tau.session.types import MessageEntry as SessionMessageEntry
+    from tau.message.types import AssistantMessage
+
+    sm = ctx.runtime.session_manager
+    if sm is None:
+        ctx.notify("No active session.")
+        return
+
+    text = ""
+    for entry in reversed(sm.get_branch()):
+        if isinstance(entry, SessionMessageEntry):
+            msg = entry.message
+            if isinstance(msg, AssistantMessage):
+                text = msg.text_content()
+                break
+
+    if not text:
+        ctx.notify("No assistant messages to copy.")
+        return
+
+    try:
+        copy_to_clipboard(text)
+        ctx.notify("Copied last assistant message to clipboard.")
+    except Exception as exc:
+        ctx.notify(f"Copy failed: {exc}")
+
+
+def copy_to_clipboard(text: str) -> None:
+    if sys.platform == "darwin":
+        subprocess.run(["pbcopy"], input=text.encode(), check=True)
+    else:
+        for cmd in [["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]]:
+            try:
+                subprocess.run(cmd, input=text.encode(), check=True, capture_output=True)
+                return
+            except (FileNotFoundError, subprocess.CalledProcessError):
+                continue
+        raise RuntimeError("No clipboard tool found. Install xclip, xsel, or wl-copy.")
+
+
+def show_help(ctx: CommandContext) -> None:
+    from tau.prompts.registry import prompt_registry
+
+    cmds = sorted(ctx.runtime.commands.list(), key=lambda c: c.name)
+    cmd_lines = "\n".join(f"  /{c.name:<14} {c.description}" for c in cmds)
+
+    tmpls = sorted(prompt_registry.list(), key=lambda t: t.name)
+    tmpl_lines = "\n".join(
+        f"  /{t.name:<14} {t.description}" + (f"  {t.argument_hint}" if t.argument_hint else "")
+        for t in tmpls
+    )
+
+    shortcuts = (
+        "  Enter          Submit / steer mid-task when agent is busy\n"
+        "  Alt+Enter      Queue as follow-up (waits for agent to finish)\n"
+        "  Alt+↑          Restore queued messages into editor\n"
+        "  Esc            Abort running agent (restores queued messages)\n"
+        "  Ctrl+C         Abort running agent / quit when idle\n"
+        "  Page Up        Enter scroll mode  (Esc / End to exit)\n"
+        "  @<path>        Attach a file — browse with ↑↓, Tab to select\n"
+        "  /<command>     Run a slash command — executes immediately\n"
+        "  /name [args]   Expand a prompt template and send to agent\n"
+        "  !<cmd>         Run a shell command — executes immediately"
+    )
+
+    ext_shortcuts = ctx.runtime.extension_shortcuts
+    ext_lines = ""
+    if ext_shortcuts:
+        rows = "\n".join(f"  {s.key:<14} {s.description or ''}" for s in ext_shortcuts)
+        ext_lines = f"\n\nExtension shortcuts:\n{rows}"
+
+    tmpl_section = f"\n\nPrompt templates:\n{tmpl_lines}" if tmpl_lines else ""
+    ctx.notify(f"Commands:\n{cmd_lines}{tmpl_section}\n\nKeyboard shortcuts:\n{shortcuts}{ext_lines}")

tau/tui/commands/model.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import asyncio
+
+from tau.tui.commands.context import CommandContext
+
+
+def open_model_selector(ctx: CommandContext) -> None:
+    """Open the model selector modal."""
+    import asyncio
+
+    try:
+        from tau.inference.api.text.service import TextLLM
+        models = TextLLM.list_available()
+    except Exception as exc:
+        ctx.notify(f"Failed to load models: {exc}")
+        return
+
+    if not models:
+        ctx.notify("No models available. Use /login to add providers.")
+        return
+
+    llm = getattr(getattr(ctx.runtime.agent, "_engine", None), "llm", None) if ctx.runtime.agent else None
+    model = getattr(llm, "model", None) if llm is not None else None
+    current_key = f"{model.provider}/{model.id}" if model is not None else ""
+
+    def commit(value: tuple[str, str]) -> None:
+        model_id, provider = value
+        asyncio.ensure_future(_apply_model(ctx, model_id, provider))
+
+    ctx.layout.open_model_selector(models, current_key, commit, lambda: ctx.notify("Model selection cancelled."))
+
+
+async def _apply_model(ctx: CommandContext, model_id: str, provider: str) -> None:
+    try:
+        await ctx.runtime.set_model(model_id, provider)
+        ctx.notify(f"Model set to {provider}/{model_id}")
+        if ctx.on_palette_refresh is not None:
+            ctx.on_palette_refresh()
+    except Exception as exc:
+        ctx.notify(f"Failed to set model: {exc}")
+
+
+def open_effort_selector(ctx: CommandContext) -> None:
+    from tau.inference.types import ThinkingLevel
+
+    agent = ctx.runtime.agent
+    model = None
+    if agent is not None:
+        model = getattr(agent._engine.llm, "model", None)
+
+    if model is None or not getattr(model, "thinking", False):
+        ctx.notify("Model doesn't support thinking")
+        return
+
+    current_level = None
+    if agent is not None:
+        current_level = agent._engine.llm.api.options.thinking_level
+    current = current_level.value if current_level else ThinkingLevel.Off.value
+
+    levels = [lv.value for lv in ThinkingLevel]
+
+    def commit(level_val: str) -> None:
+        asyncio.ensure_future(_apply_effort(ctx, level_val))
+
+    ctx.layout.open_effort_selector(levels, current, commit, lambda: ctx.notify("Effort selection cancelled."))
+
+
+def get_palette_overrides(agent: object) -> dict[str, str]:
+    """Return dynamic palette description overrides for /model and /effort."""
+    overrides: dict[str, str] = {}
+
+    llm = getattr(getattr(agent, "_engine", None), "llm", None) if agent is not None else None
+    model = getattr(llm, "model", None) if llm is not None else None
+
+    if model is not None:
+        provider = getattr(model, "provider", "") or ""
+        model_id = getattr(model, "id", "") or ""
+        overrides["model"] = f"{provider}/{model_id}" if provider else model_id
+    else:
+        overrides["model"] = "Switch the active model"
+
+    effort_val = None
+    if llm is not None:
+        opts = getattr(getattr(llm, "api", None), "options", None)
+        if opts is not None:
+            level = getattr(opts, "thinking_level", None)
+            if level is not None:
+                effort_val = getattr(level, "value", str(level))
+    overrides["effort"] = effort_val if effort_val is not None else "Set thinking effort level"
+
+    return overrides
+
+
+async def _apply_effort(ctx: CommandContext, level_val: str) -> None:
+    from tau.hooks.tui import ThinkingLevelSelectEvent
+    from tau.inference.types import ThinkingLevel
+
+    agent = ctx.runtime.agent
+    if agent is None:
+        return
+    previous_level = agent._engine.llm.api.options.thinking_level
+    level = ThinkingLevel(level_val)
+    agent._engine.llm.api.options.thinking_level = None if level == ThinkingLevel.Off else level
+
+    sm = ctx.runtime.session_manager
+    if sm is not None:
+        sm.append_thinking_level_change(level)
+
+    settings = ctx.runtime.settings_manager
+    if settings is not None:
+        settings.set_thinking_level(level)
+
+    await ctx.runtime.hooks.emit(ThinkingLevelSelectEvent(level=level, previous_level=previous_level))
+
+    ctx.notify(f"Effort set to {level_val}")
+    if ctx.on_palette_refresh is not None:
+        ctx.on_palette_refresh()