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

tau/builtins/tools/write.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+from tau.tool.types import (
+    Tool, ToolKind, ToolExecutionMode,
+    ToolInvocation, ToolResult,
+    ToolExecutionUpdateCallback, AbortSignal, ToolContext,
+)
+from tau.tool.render import call_line
+
+
+def _render_write_call(args: dict, _streaming: bool) -> list[str]:
+    return call_line("write", args.get("path", ""))
+
+
+class WriteParams(BaseModel):
+    """Parameters for the write tool."""
+    path: str = Field(description="Absolute path to the file to write.")
+    content: str = Field(description="Content to write to the file.")
+
+
+_PREVIEW_LINES = 5
+
+
+def _render_write_result(content: str, opts: Any) -> list[str]:
+    from tau.tui.ansi import DIM, GREEN, RESET
+    metadata = opts.metadata or {}
+    total_lines = metadata.get("total_lines", 0)
+    created = metadata.get("created", False)
+    lines = metadata.get("lines", [])
+
+    action = f"{GREEN}Created{RESET}" if created else "Written"
+    line_word = "line" if total_lines == 1 else "lines"
+    result = [f"{action} {total_lines} {line_word}"]
+
+    if not lines:
+        return result
+
+    show = lines if opts.expanded else lines[:_PREVIEW_LINES]
+    for i, text in enumerate(show, 1):
+        result.append(f"{DIM}{i}{RESET}  {text}")
+
+    if opts.expanded and len(lines) > _PREVIEW_LINES:
+        result.append(f"{DIM}  (ctrl+o to collapse){RESET}")
+    elif not opts.expanded and len(lines) > _PREVIEW_LINES:
+        result.append(f"{DIM}  ···  (ctrl+o to expand){RESET}")
+
+    return result
+
+
+class WriteTool(Tool):
+    """Tool for writing content to files."""
+    def __init__(self) -> None:
+        super().__init__(
+            name="write",
+            description=(
+                "Write content to a file, creating it (and any missing parent directories) if needed. "
+                "Overwrites the file if it already exists."
+            ),
+            schema=WriteParams,
+            kind=ToolKind.Write,
+            render_result=_render_write_result,
+            render_call=_render_write_call,
+            render_shell="default",
+            prompt_guidelines="Only use for new files or complete rewrites. Use edit to modify existing files.",
+        )
+
+    def get_display_name(self, args: dict[str, Any]) -> str:
+        """Get a short display name for the write operation."""
+        return args.get("path", "write")
+
+    async def execute(
+        self,
+        invocation: ToolInvocation,
+        tool_execution_update_callback: Optional[ToolExecutionUpdateCallback] = None,
+        signal: Optional[AbortSignal] = None,
+        context: Optional[ToolContext] = None,
+    ) -> ToolResult:
+        """Execute the file write operation."""
+        params = WriteParams.model_validate(invocation.params)
+        path = Path(params.path)
+
+        created = not path.exists()
+
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(params.content, encoding="utf-8")
+        except OSError as e:
+            return ToolResult.error(invocation.id, f"Cannot write file: {e}")
+
+        bytes_written = len(params.content.encode("utf-8"))
+        content_lines = params.content.splitlines()
+        total_lines = len(content_lines)
+        metadata = {
+            "file_path": str(path),
+            "total_lines": total_lines,
+            "bytes_written": bytes_written,
+            "created": created,
+            "lines": content_lines,
+        }
+        return ToolResult.ok(invocation.id, f"Written {bytes_written} bytes to {params.path}", metadata=metadata)

tau/commands/__init__.py

@@ -0,0 +1,10 @@
+"""Slash-command registry for the coding agent."""
+
+from tau.commands.types import CommandInfo, ParsedCommand
+from tau.commands.registry import CommandRegistry
+
+__all__ = [
+    'CommandInfo',
+    'ParsedCommand',
+    'CommandRegistry',
+]

tau/commands/registry.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from tau.commands.types import CommandInfo, ParsedCommand
+
+if TYPE_CHECKING:
+    from tau.runtime.service import Runtime
+
+
+class CommandRegistry:
+    """
+    Holds all registered slash commands and dispatches parsed input.
+    Attach a Runtime so handlers can call back into session lifecycle methods.
+    """
+
+    def __init__(self, runtime: Runtime | None = None) -> None:
+        """Initialize the command registry with optional runtime context."""
+        self.runtime = runtime
+        self._commands: dict[str, CommandInfo] = {}
+        from tau.builtins.commands import get_builtin_commands
+        for cmd in get_builtin_commands():
+            self.register(cmd)
+
+    def register(self, command: CommandInfo) -> None:
+        """Register a command with its name and aliases."""
+        self._commands[command.name] = command
+        for alias in command.aliases:
+            self._commands[alias] = command
+
+    def unregister(self, name: str) -> None:
+        """Remove a command and all its aliases."""
+        cmd = self._commands.get(name)
+        if cmd is None:
+            return
+        keys = [k for k, v in self._commands.items() if v is cmd]
+        for k in keys:
+            del self._commands[k]
+
+    def get(self, name: str) -> CommandInfo | None:
+        """Retrieve a command by name or alias."""
+        return self._commands.get(name)
+
+    def list(self) -> list[CommandInfo]:
+        """Return all registered commands (de-duplicated by name)."""
+        seen: set[str] = set()
+        result: list[CommandInfo] = []
+        for cmd in self._commands.values():
+            if cmd.name not in seen:
+                seen.add(cmd.name)
+                result.append(cmd)
+        return result
+
+    async def dispatch(self, parsed: ParsedCommand) -> bool:
+        """Invoke the matching command; return True if dispatched, False if not found."""
+        cmd = self._commands.get(parsed.name)
+        if cmd is None:
+            return False
+
+        missing = cmd.required_arg_names[len(parsed.args):]
+        if missing:
+            if self.runtime is not None:
+                plural = "s" if len(missing) > 1 else ""
+                self.runtime.notify(f"Missing required argument{plural}: {', '.join(missing)}")
+            return True
+
+        result = cmd.call(self, parsed.args)
+        if asyncio.iscoroutine(result):
+            await result
+        return True

tau/commands/types.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Awaitable, Callable
+
+if TYPE_CHECKING:
+    from tau.commands.registry import CommandRegistry
+    from tau.tui.autocomplete import AutocompleteItem
+
+
+@dataclass
+class CommandInfo:
+    """Metadata for a registered command."""
+    name: str
+    description: str
+    call: Callable[['CommandRegistry', list[str]], Awaitable[None] | None]
+    aliases: list[str] = field(default_factory=list)
+    argument_hint: str | None = None
+    get_argument_completions: Callable[[str], list['AutocompleteItem']] | None = None
+    required_arg_names: list[str] = field(default_factory=list)
+    """Names of the leading positional args that must be present, in order.
+
+    Any args beyond these are treated as optional. Declare required args
+    before optional ones, since this only checks a minimum count.
+    """
+
+
+@dataclass
+class ParsedCommand:
+    """Result of parsing a command string into name, args, and raw input."""
+    name: str
+    args: list[str]
+    raw: str

tau/console/cli.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+import sys
+import os
+import logging
+import click
+import asyncio
+from pathlib import Path
+from tau.runtime.service import Runtime
+from tau.console.commands.auth import auth
+from tau.console.commands.packages import install, remove, list_packages
+from tau.console.commands.update import update
+from tau.settings.paths import get_app_version
+
+_MODES = ("interactive", "print", "json", "rpc")
+_OUTPUT_FORMATS = ("text", "json")
+
+
+def resolve_mode(mode: str | None, print_flag: bool, prompt: str | None, output_format: str) -> str:
+    """Determine the run mode: interactive, print, json, or rpc."""
+    if mode is not None:
+        return mode
+    if prompt is not None:
+        return "json" if output_format == "json" else "print"
+    if print_flag or not sys.stdout.isatty():
+        return "print"
+    return "interactive"
+
+
+def resolve_model(model: str | None, provider: str | None) -> tuple[str | None, str | None]:
+    """Parse provider/model shorthand. Explicit --provider always wins."""
+    if model and provider is None and "/" in model:
+        inferred_provider, _, model_id = model.partition("/")
+        return inferred_provider, model_id
+    return provider, model  # None when not specified; runtime falls back to settings then default
+
+
+@click.group(invoke_without_command=True, context_settings={"help_option_names": ["-h", "--help"]})
+@click.argument("message", required=False, default=None)
+@click.option("--version", "-v", is_flag=True, default=False, help="Print version and exit.")
+@click.option("--debug", "-d", is_flag=True, default=False, help="Enable debug logging.")
+@click.option("--cwd", "-c", default=None, metavar="PATH", help="Set the working directory.")
+@click.option("--prompt", "-p", default=None, metavar="TEXT",
+              help="Run a single prompt in non-interactive mode.")
+@click.option("--output-format", "-f", type=click.Choice(_OUTPUT_FORMATS), default="text", show_default=True,
+              help="Output format for non-interactive mode (text, json).")
+@click.option("--quiet", "-q", is_flag=True, default=False,
+              help="Hide spinner in non-interactive mode.")
+@click.option("--provider", default=None, help="Provider to use (e.g. groq, mistral, openrouter).")
+@click.option("--model", default=None, help="Model ID, or provider/model shorthand (e.g. groq/llama-3.3-70b-versatile).")
+@click.option("--theme", "-t", default=None, metavar="NAME",
+              help="UI theme: default, dracula, nord, gruvbox, catppuccin.")
+@click.option("--resume", "-r", is_flag=True, default=False,
+              help="Resume the most recent session.")
+@click.option("--system", "-s", default=None, metavar="TEXT",
+              help="Inject additional text into the system prompt.")
+@click.option("--session", default=None, metavar="ID",
+              help="Resume a specific session by ID or path.")
+@click.option("--ephemeral", "-e", is_flag=True, default=False,
+              help="Don't save this session to disk.")
+@click.option("--print", "print_flag", is_flag=True, default=False,
+              help="Shorthand for --mode print.")
+@click.option("--mode", type=click.Choice(_MODES), default=None,
+              help="Run mode: interactive (default), print, json, rpc.")
+@click.option("--no-context-files", "-nc", is_flag=True, default=False,
+              help="Disable AGENTS.md and CLAUDE.md discovery and loading.")
+@click.option("--approve", "-a", is_flag=True, default=False,
+              help="Trust project-local files (extensions, settings, context files).")
+@click.option("--no-approve", "-na", is_flag=True, default=False,
+              help="Don't trust project-local files (opposite of --approve).")
+@click.pass_context
+def cli(
+    ctx: click.Context,
+    message: str | None,
+    version: bool,
+    debug: bool,
+    cwd: str | None,
+    prompt: str | None,
+    output_format: str,
+    quiet: bool,
+    provider: str | None,
+    model: str | None,
+    theme: str | None,
+    resume: bool,
+    system: str | None,
+    session: str | None,
+    ephemeral: bool,
+    print_flag: bool,
+    mode: str | None,
+    no_context_files: bool,
+    approve: bool,
+    no_approve: bool,
+) -> None:
+    """Tau — an AI coding agent in your terminal."""
+    if version:
+        click.echo(get_app_version())
+        return
+
+    if debug:
+        logging.basicConfig(level=logging.DEBUG, format="%(levelname)s %(name)s: %(message)s")
+
+    if cwd:
+        os.chdir(cwd)
+
+    ctx.ensure_object(dict)
+    ctx.obj["message"] = prompt or message
+    ctx.obj["provider"] = provider
+    ctx.obj["model"] = model
+    ctx.obj["theme"] = theme
+    ctx.obj["resume"] = resume
+    ctx.obj["system"] = system or ""
+    ctx.obj["session"] = session
+    ctx.obj["ephemeral"] = ephemeral
+    ctx.obj["quiet"] = quiet
+    ctx.obj["mode"] = resolve_mode(mode, print_flag, prompt, output_format)
+    ctx.obj["no_context_files"] = no_context_files
+    ctx.obj["approve"] = approve
+    ctx.obj["no_approve"] = no_approve
+
+    if ctx.invoked_subcommand is None:
+        asyncio.run(_start(ctx.obj))
+
+
+async def _start(opts: dict) -> None:
+    """Start the runtime with the given options and run in the specified mode."""
+    from tau.runtime.service import Runtime
+    from tau.runtime.types import RuntimeConfig
+
+    resolved_provider, resolved_model = resolve_model(opts["model"], opts["provider"])
+    session_file = Path(opts["session"]).resolve() if opts["session"] else None
+
+    # Determine project trust from flags
+    project_trusted = None
+    if opts.get("approve"):
+        project_trusted = True
+    elif opts.get("no_approve"):
+        project_trusted = False
+
+    config = RuntimeConfig(
+        cwd=Path.cwd(),
+        model_id=resolved_model,
+        provider=resolved_provider,
+        resume=opts["resume"],
+        session_file=session_file,
+        persist_session=not opts["ephemeral"],
+        mode=opts["mode"],
+        system_prompt=opts.get("system", ""),
+        disable_context_files=opts.get("no_context_files", False),
+        project_trusted=project_trusted,
+    )
+
+    runtime = await Runtime.create(config)
+
+    try:
+        match opts["mode"]:
+            case "interactive":
+                await _run_interactive(runtime, opts["theme"])
+            case "print":
+                await _run_print(runtime, opts["message"], quiet=opts.get("quiet", False))
+            case "json":
+                await _run_json(runtime, opts["message"], quiet=opts.get("quiet", False))
+            case "rpc":
+                from tau.rpc.mode import run_rpc_mode
+                await run_rpc_mode(runtime)
+    finally:
+        # Emit `runtime_stop` once, in every mode, on the way out — symmetric to
+        # the `runtime_ready` fired in Runtime.create.
+        await runtime.ashutdown()
+
+
+async def _run_interactive(runtime: "Runtime", theme: str | None) -> None:
+    """Run the interactive TUI mode."""
+    from tau.tui.app import App
+    app = await App.create(runtime, theme=theme)
+    await app.run()
+
+
+async def _run_print(runtime: "Runtime", message: str | None, quiet: bool = False) -> None:
+    """Run in print mode: send a message and print the response."""
+    if not message:
+        raise click.ClickException("A message is required in print mode. Usage: tau --print \"your prompt\"")
+
+    from tau.message.types import AssistantMessage
+    from tau.hooks.types import SettledEvent
+
+    result: AssistantMessage | None = None
+    settled = asyncio.Event()
+
+    async def on_message_end(event: object) -> None:
+        """Capture the final assistant message."""
+        nonlocal result
+        msg = getattr(event, "message", None)
+        if isinstance(msg, AssistantMessage):
+            result = msg
+
+    async def on_settled(_event: object) -> None:
+        """Signal that processing is complete."""
+        settled.set()
+
+    hooks = runtime.hooks
+    unsub_msg = hooks.register("message_end", on_message_end)
+    unsub_settled = hooks.register("settled", on_settled)
+
+    try:
+        await runtime.invoke(message)
+        await settled.wait()
+    finally:
+        unsub_msg()
+        unsub_settled()
+
+    if result is None:
+        raise click.ClickException("No response received.")
+
+    for content in result.contents:
+        if hasattr(content, "text"):
+            click.echo(content.text, nl=False)
+
+
+async def _run_json(runtime: "Runtime", message: str | None, quiet: bool = False) -> None:
+    """Run in JSON mode: send a message and return structured JSON output."""
+    if not message:
+        raise click.ClickException("A message is required in json mode. Usage: tau --mode json \"your prompt\"")
+
+    import json
+    import dataclasses
+    from tau.hooks.types import SettledEvent
+
+    settled = asyncio.Event()
+
+    def _serialize(event: object) -> str:
+        if dataclasses.is_dataclass(event) and not isinstance(event, type):
+            return json.dumps(dataclasses.asdict(event))
+        return json.dumps({"type": type(event).__name__})
+
+    async def on_event(event: object) -> None:
+        """Output event as JSON and signal when settled."""
+        click.echo(_serialize(event))
+        if isinstance(event, SettledEvent):
+            settled.set()
+
+    hooks = runtime.hooks
+    hook_names = [
+        "agent_start", "agent_end", "message_start", "message_update",
+        "message_end", "tool_execution_start", "tool_execution_end",
+        "settled",
+    ]
+    unsubs = [hooks.register(name, on_event) for name in hook_names]
+
+    try:
+        await runtime.invoke(message)
+        await settled.wait()
+    finally:
+        for unsub in unsubs:
+            unsub()
+
+
+cli.add_command(auth)
+cli.add_command(install)
+cli.add_command(remove)
+cli.add_command(update)
+cli.add_command(list_packages, name="list")
+
+
+def main() -> None:
+    """Entry point for the CLI."""
+    cli()

tau/console/commands/auth.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import json
+
+import click
+
+
+@click.group("auth", context_settings={"help_option_names": ["-h", "--help"]})
+def auth():
+    """Manage API key credentials."""
+
+
+# ---------------------------------------------------------------------------
+# list
+# ---------------------------------------------------------------------------
+
+@auth.command("list")
+def auth_list():
+    """List all stored credentials with masked keys."""
+    data = _load()
+    if not data:
+        click.echo("No credentials stored.")
+        return
+    for provider, cred in data.items():
+        cred_type = cred.get("type", "?")
+        if cred_type == "api_key":
+            key = cred.get("key", "")
+            masked = key[:6] + "…" + key[-4:] if len(key) > 10 else "***"
+            click.echo(f"  {provider:<24} api_key   {masked}")
+        else:
+            click.echo(f"  {provider:<24} {cred_type}")
+
+
+# ---------------------------------------------------------------------------
+# set
+# ---------------------------------------------------------------------------
+
+@auth.command("set")
+@click.argument("provider")
+@click.argument("key")
+def auth_set(provider, key):
+    """Store an API key for a PROVIDER."""
+    data = _load()
+    data[provider] = {"type": "api_key", "key": key}
+    _save(data)
+    click.echo(f"Saved API key for '{provider}'.")
+
+
+# ---------------------------------------------------------------------------
+# unset
+# ---------------------------------------------------------------------------
+
+@auth.command("unset")
+@click.argument("provider")
+def auth_unset(provider):
+    """Remove stored credentials for a PROVIDER."""
+    data = _load()
+    if provider not in data:
+        raise click.ClickException(f"No credentials found for '{provider}'.")
+    del data[provider]
+    _save(data)
+    click.echo(f"Unset credentials for '{provider}'.")
+
+
+# ---------------------------------------------------------------------------
+# status
+# ---------------------------------------------------------------------------
+
+@auth.command("status")
+def auth_status():
+    """Show configuration status for all known providers."""
+    from tau.builtins.providers.text import api_providers, oauth_providers
+    from tau.auth.manager import AuthManager
+    from tau.inference.provider.registry import ProviderRegistry
+    from tau.inference.provider.types import OAuthProvider
+
+    registry = ProviderRegistry()
+    for p in api_providers + oauth_providers:
+        registry.text.register(p)
+
+    manager = AuthManager.create(registry)
+
+    all_providers = api_providers + oauth_providers
+    header = f"  {'Provider':<24} {'Type':<8} {'Source':<8} Status"
+    separator = "  " + "─" * 54
+    click.echo(header)
+    click.echo(separator)
+
+    for provider in all_providers:
+        status = manager.get_auth_status(provider.id)
+        ptype = "oauth" if isinstance(provider, OAuthProvider) else "api_key"
+
+        if status.configured:
+            source = click.style(f"{status.source:<8}", fg="cyan")
+            indicator = click.style("✓ configured", fg="green")
+        else:
+            source = click.style(f"{'—':<8}", fg="bright_black")
+            indicator = click.style("✗ not configured", fg="bright_black")
+
+        click.echo(f"  {provider.id:<24} {ptype:<8} {source} {indicator}")
+
+
+# ---------------------------------------------------------------------------
+# login
+# ---------------------------------------------------------------------------
+
+@auth.command("login")
+@click.argument("provider")
+def auth_login(provider):
+    """Start an OAuth login flow for a PROVIDER."""
+    import asyncio
+    asyncio.run(_login(provider))
+
+
+async def _login(provider_id: str) -> None:
+    from tau.builtins.providers.text import oauth_providers
+    from tau.auth.manager import AuthManager
+    from tau.inference.provider.registry import ProviderRegistry
+    from tau.inference.provider.oauth.types import OAuthLoginCallbacks
+
+    oauth_ids = [p.id for p in oauth_providers]
+    if provider_id not in oauth_ids:
+        raise click.ClickException(
+            f"'{provider_id}' does not support OAuth. "
+            f"Use 'tau auth set {provider_id} <key>' instead."
+        )
+
+    registry = ProviderRegistry()
+    for p in oauth_providers:
+        registry.text.register(p)
+
+    manager = AuthManager.create(registry)
+
+    callbacks = OAuthLoginCallbacks(
+        on_url=lambda url: click.echo(f"Open this URL to authenticate:\n\n  {url}\n"),
+        on_code=lambda: click.echo("Waiting for authentication…"),
+    )
+
+    click.echo(f"Logging in to '{provider_id}'…")
+    await manager.login(provider_id, callbacks)
+    click.echo(click.style(f"✓ Logged in to '{provider_id}'.", fg="green"))
+
+
+# ---------------------------------------------------------------------------
+# logout
+# ---------------------------------------------------------------------------
+
+@auth.command("logout")
+@click.argument("provider")
+def auth_logout(provider):
+    """Revoke OAuth credentials for a PROVIDER."""
+    import asyncio
+    asyncio.run(_logout(provider))
+
+
+async def _logout(provider_id: str) -> None:
+    from tau.builtins.providers.text import oauth_providers
+    from tau.auth.manager import AuthManager
+    from tau.inference.provider.registry import ProviderRegistry
+
+    registry = ProviderRegistry()
+    for p in oauth_providers:
+        registry.text.register(p)
+
+    manager = AuthManager.create(registry)
+
+    if not manager.has(provider_id):
+        raise click.ClickException(f"No stored credentials found for '{provider_id}'.")
+
+    await manager.logout(provider_id)
+    click.echo(click.style(f"✓ Logged out of '{provider_id}'.", fg="green"))
+
+
+# ---------------------------------------------------------------------------
+# Storage helpers
+# ---------------------------------------------------------------------------
+
+def _load() -> dict:
+    from tau.settings.paths import get_auth_path
+    path = get_auth_path()
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text())
+    except Exception:
+        return {}
+
+
+def _save(data: dict) -> None:
+    from tau.settings.paths import get_auth_path
+    path = get_auth_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n")