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

tau/console/commands/packages.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import click
+
+
+@click.command("install")
+@click.argument("source")
+@click.option("--local", is_flag=True, default=False,
+              help="Install to project scope (.tau/venv/) instead of global (~/.tau/venv/).")
+def install(source: str, local: bool) -> None:
+    """Install a package as a tau extension source.
+
+    SOURCE formats:
+      pypi:name           install latest from PyPI
+      pypi:name@1.2.3     install pinned version
+      git+https://...     install from a git URL
+      ./path  or  /path   install from a local directory
+    """
+    from tau.packages.manager import PackageManager
+    from tau.settings.manager import SettingsManager
+    from tau.settings.paths import get_packages_venv
+
+    cwd = Path.cwd()
+    venv_dir = get_packages_venv(cwd) if local else get_packages_venv()
+    pkg_manager = PackageManager(venv_dir)
+
+    click.echo(f"Installing {source}…")
+    try:
+        entry = pkg_manager.install(source)
+    except Exception as e:
+        raise click.ClickException(str(e))
+
+    settings = SettingsManager.create(cwd)
+    settings.add_package(entry, local=local)
+    asyncio.run(settings.flush())
+
+    v = f"@{entry.version}" if entry.version else ""
+    scope = "project" if local else "global"
+    click.echo(click.style(f"✓ Installed {entry.name}{v} ({scope})", fg="green"))
+
+
+@click.command("remove")
+@click.argument("name")
+@click.option("--local", is_flag=True, default=False,
+              help="Remove from project scope instead of global.")
+def remove(name: str, local: bool) -> None:
+    """Remove an installed package by NAME."""
+    from tau.packages.manager import PackageManager
+    from tau.settings.manager import SettingsManager
+    from tau.settings.paths import get_packages_venv
+
+    cwd = Path.cwd()
+    venv_dir = get_packages_venv(cwd) if local else get_packages_venv()
+    pkg_manager = PackageManager(venv_dir)
+
+    click.echo(f"Removing {name}…")
+    try:
+        pkg_manager.remove(name)
+    except Exception as e:
+        raise click.ClickException(str(e))
+
+    settings = SettingsManager.create(cwd)
+    settings.remove_package(name, local=local)
+    asyncio.run(settings.flush())
+
+    click.echo(click.style(f"✓ Removed {name}", fg="green"))
+
+
+
+@click.command("list")
+@click.option("--local", is_flag=True, default=False,
+              help="Show project-scoped packages only.")
+@click.option("--all", "show_all", is_flag=True, default=False,
+              help="Show both global and project packages.")
+def list_packages(local: bool, show_all: bool) -> None:
+    """List installed packages."""
+    from tau.settings.manager import SettingsManager
+
+    cwd = Path.cwd()
+    settings = SettingsManager.create(cwd)
+
+    if show_all:
+        packages = settings.get_all_packages()
+        header = "Installed packages (global + project)"
+    elif local:
+        packages = settings.get_packages(local=True)
+        header = "Installed packages (project)"
+    else:
+        packages = settings.get_packages(local=False)
+        header = "Installed packages (global)"
+
+    if not packages:
+        click.echo("No packages installed.")
+        return
+
+    click.echo(f"{header}:\n")
+    for pkg in packages:
+        v = f"  {pkg.version}" if pkg.version else ""
+        status = click.style("  [disabled]", fg="bright_black") if not pkg.enabled else ""
+        source = click.style(f"  ({pkg.source})", fg="bright_black")
+        click.echo(f"  {pkg.name}{v}{status}{source}")

tau/console/commands/update.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+from pathlib import Path
+
+import click
+
+
+@click.command("update")
+@click.argument("name", required=False, default=None)
+@click.option("--local", is_flag=True, default=False,
+              help="Update in project scope instead of global.")
+def update(name: str | None, local: bool) -> None:
+    """Update tau itself, or update an extension package by NAME."""
+    if name is None:
+        _update_tau()
+        return
+
+    from tau.packages.manager import PackageManager
+    from tau.settings.manager import SettingsManager
+    from tau.settings.paths import get_packages_venv
+
+    cwd = Path.cwd()
+    venv_dir = get_packages_venv(cwd) if local else get_packages_venv()
+    pkg_manager = PackageManager(venv_dir)
+    settings = SettingsManager.create(cwd)
+
+    packages = settings.get_packages(local=local)
+    targets = [p for p in packages if p.name == name]
+
+    if not targets:
+        raise click.ClickException(f"Package '{name}' not found.")
+
+    for pkg in targets:
+        click.echo(f"Updating {pkg.name}…")
+        try:
+            new_version = pkg_manager.update(pkg.name)
+            settings.update_package_version(pkg.name, new_version, local=local)
+            arrow = f" → {new_version}" if new_version else ""
+            click.echo(click.style(f"✓ Updated {pkg.name}{arrow}", fg="green"))
+        except Exception as e:
+            click.echo(click.style(f"✗ {pkg.name}: {e}", fg="red"))
+
+    asyncio.run(settings.flush())
+
+
+def _update_tau() -> None:
+    """Upgrade tau itself using whichever installer manages this install."""
+    import os
+    import shutil
+    import subprocess
+    from tau.settings.paths import get_app_name, get_package_name
+
+    app = get_package_name()
+    click.echo(f"Updating {get_app_name()}…")
+
+    # Pick the upgrade tool that matches how this copy was installed, inferred
+    # from the venv it runs in, so we upgrade the right managed environment.
+    prefix = sys.prefix.replace(os.sep, "/")
+    if "/pipx/" in prefix and shutil.which("pipx"):
+        cmd = ["pipx", "upgrade", app]
+    elif "/uv/tools/" in prefix and shutil.which("uv"):
+        cmd = ["uv", "tool", "upgrade", app]
+    elif shutil.which("uv"):
+        cmd = ["uv", "tool", "upgrade", app]
+    elif shutil.which("pipx"):
+        cmd = ["pipx", "upgrade", app]
+    else:
+        cmd = [sys.executable, "-m", "pip", "install", "--upgrade", app]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode == 0:
+        click.echo(click.style(f"✓ {get_app_name()} updated successfully", fg="green"))
+    else:
+        raise click.ClickException(result.stderr.strip() or "Update failed.")

tau/core/registry.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Generic, TypeVar
+
+T = TypeVar("T")
+E = TypeVar("E")
+
+
+class Registry(ABC, Generic[T, E]):
+    """
+    Base for lazy-loaded 3-tier content registries (prompts, skills).
+
+    Load priority (highest wins): project → global → builtin.
+    Subclasses supply the loader, dir resolver, and result accessors.
+    """
+
+    def __init__(self) -> None:
+        self._registry: dict[str, T] = {}
+        self._builtins_loaded = False
+
+    # ── Abstract interface ────────────────────────────────────────────────────
+
+    @abstractmethod
+    def _load_from_dir(self, path: Path) -> Any:
+        """Load items from *path*; returns a result object with errors and items."""
+
+    @abstractmethod
+    def _get_dir(self, cwd: Path | None = None) -> Path:
+        """Return the global (or *cwd*-scoped) config directory for this type."""
+
+    @abstractmethod
+    def _builtins_subdir(self) -> str:
+        """Subdirectory name under the builtins root (e.g. 'prompts', 'skills')."""
+
+    @abstractmethod
+    def _extract_items(self, result: Any) -> dict[str, T]:
+        """Pull the name→item mapping out of a load result."""
+
+    @abstractmethod
+    def _extract_errors(self, result: Any) -> list[E]:
+        """Pull the error list out of a load result."""
+
+    def _item_key(self, item: T) -> str:
+        return getattr(item, "name").lower()
+
+    # ── Shared implementation ─────────────────────────────────────────────────
+
+    def _ensure_builtins(self) -> None:
+        if self._builtins_loaded:
+            return
+        from tau.settings.paths import get_builtins_dir
+        _dir = get_builtins_dir() / self._builtins_subdir()
+        for item in self._extract_items(self._load_from_dir(_dir)).values():
+            self._registry[self._item_key(item)] = item
+        self._builtins_loaded = True
+
+    def reload(
+        self,
+        cwd: Path | None = None,
+        extra_paths: list[str] | None = None,
+    ) -> list[E]:
+        """Clear and reload builtins + external from scratch."""
+        self._registry.clear()
+        self._builtins_loaded = False
+        errors = self.load_external(cwd)
+        for p in (extra_paths or []):
+            r = self._load_from_dir(Path(p))
+            errors.extend(self._extract_errors(r))
+            self._registry.update(self._extract_items(r))
+        return errors
+
+    def load_external(self, cwd: Path | None = None) -> list[E]:
+        """Load from global and optional project-specific directories."""
+        self._ensure_builtins()
+        errors: list[E] = []
+        g = self._load_from_dir(self._get_dir())
+        errors.extend(self._extract_errors(g))
+        self._registry.update(self._extract_items(g))
+        if cwd is not None:
+            p = self._load_from_dir(self._get_dir(cwd))
+            errors.extend(self._extract_errors(p))
+            self._registry.update(self._extract_items(p))
+        return errors
+
+    def get(self, name: str) -> T | None:
+        self._ensure_builtins()
+        return self._registry.get(name.lower())
+
+    def list(self) -> list[T]:
+        self._ensure_builtins()
+        return list(self._registry.values())
+
+    def register(self, item: T) -> None:
+        self._registry[self._item_key(item)] = item
+
+    def unregister(self, name: str) -> None:
+        key = name.lower()
+        if key not in self._registry:
+            raise ValueError(f"{name!r} is not registered.")
+        del self._registry[key]

tau/engine/__init__.py

@@ -0,0 +1,47 @@
+from tau.engine.types import (
+    EngineState as AgentState,
+    EngineOptions as Options,
+    AgentEvent,
+    AgentEventType,
+    AgentStartEvent,
+    AgentEndEvent,
+    TurnStartEvent,
+    TurnEndEvent,
+    MessageStartEvent,
+    MessageUpdateEvent,
+    MessageEndEvent,
+    ToolExecutionStartEvent,
+    ToolExecutionUpdateEvent,
+    ToolExecutionEndEvent,
+    AgentErrorEvent,
+    SteeringMode,
+    FollowupMode,
+    FollowupQueue,
+    SteeringQueue,
+)
+from tau.tool.types import ToolExecutionMode
+from tau.engine.service import Engine as Agent
+
+__all__ = [
+    "Agent",
+    "AgentState",
+    "Options",
+    "AgentEvent",
+    "AgentEventType",
+    "AgentStartEvent",
+    "AgentEndEvent",
+    "TurnStartEvent",
+    "TurnEndEvent",
+    "MessageStartEvent",
+    "MessageUpdateEvent",
+    "MessageEndEvent",
+    "ToolExecutionStartEvent",
+    "ToolExecutionUpdateEvent",
+    "ToolExecutionEndEvent",
+    "AgentErrorEvent",
+    "ToolExecutionMode",
+    "SteeringMode",
+    "FollowupMode",
+    "FollowupQueue",
+    "SteeringQueue",
+]