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

tau/packages/manager.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from tau.packages.types import ParsedSource
+from tau.packages.utils import parse_source, extensions_from_pyproject
+from tau.settings.paths import get_app_name
+
+
+class PackageManager:
+    """Manages Python extension packages in a dedicated venv."""
+
+    def __init__(self, venv_dir: Path) -> None:
+        self.venv_dir = venv_dir
+
+    # ── Venv paths ────────────────────────────────────────────────────────────
+
+    @property
+    def _python(self) -> Path:
+        """Return the path to the venv's Python executable."""
+        if sys.platform == "win32":
+            return self.venv_dir / "Scripts" / "python.exe"
+        return self.venv_dir / "bin" / "python"
+
+    @property
+    def _pip_exe(self) -> Path:
+        """Return the path to the venv's pip executable."""
+        if sys.platform == "win32":
+            return self.venv_dir / "Scripts" / "pip.exe"
+        return self.venv_dir / "bin" / "pip"
+
+    def _has_uv(self) -> bool:
+        """Check if uv package manager is installed."""
+        return shutil.which("uv") is not None
+
+    def ensure_venv(self) -> None:
+        """Create the venv if it does not already exist."""
+        if self._python.exists():
+            return
+        self.venv_dir.mkdir(parents=True, exist_ok=True)
+        if self._has_uv():
+            subprocess.run(["uv", "venv", str(self.venv_dir)], check=True, capture_output=True)
+        else:
+            subprocess.run(
+                [sys.executable, "-m", "venv", str(self.venv_dir)],
+                check=True, capture_output=True,
+            )
+
+    def site_packages(self) -> Path | None:
+        """Return the venv's site-packages directory."""
+        if not self._python.exists():
+            return None
+        result = subprocess.run(
+            [str(self._python), "-c", "import site; print(site.getsitepackages()[0])"],
+            capture_output=True, text=True,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return Path(result.stdout.strip())
+        return None
+
+    # ── Package operations ────────────────────────────────────────────────────
+
+    def install(self, source: str) -> "PackageEntry":
+        """Install a package and return a PackageEntry with metadata."""
+        from tau.settings.types import PackageEntry
+        parsed = parse_source(source)
+        self.ensure_venv()
+
+        if self._has_uv():
+            cmd = ["uv", "pip", "install", "--python", str(self._python), parsed.install_spec]
+        else:
+            cmd = [str(self._pip_exe), "install", parsed.install_spec]
+        subprocess.run(cmd, check=True)
+
+        installed_path = self._find_package_dir(parsed.name)
+        version = parsed.version or self._get_installed_version(parsed.name)
+
+        return PackageEntry(
+            source=source,
+            name=parsed.name,
+            version=version,
+            installed_path=str(installed_path) if installed_path else None,
+        )
+
+    def remove(self, name: str) -> None:
+        """Uninstall a package from the venv."""
+        if self._has_uv():
+            cmd = ["uv", "pip", "uninstall", "--python", str(self._python), name]
+        else:
+            cmd = [str(self._pip_exe), "uninstall", "-y", name]
+        subprocess.run(cmd, check=True)
+
+    def install_requirements(self, dependencies: list[str]) -> None:
+        """Install a batch of dependency specs (e.g. extension-declared requirements)."""
+        if not dependencies:
+            return
+        self.ensure_venv()
+        if self._has_uv():
+            cmd = ["uv", "pip", "install", "--python", str(self._python), *dependencies]
+        else:
+            cmd = [str(self._pip_exe), "install", *dependencies]
+        subprocess.run(cmd, check=True, capture_output=True)
+
+    def update(self, name: str) -> str | None:
+        """Upgrade a package to the latest version and return the new version string."""
+        if self._has_uv():
+            cmd = ["uv", "pip", "install", "--python", str(self._python), "--upgrade", name]
+        else:
+            cmd = [str(self._pip_exe), "install", "--upgrade", name]
+        subprocess.run(cmd, check=True)
+        return self._get_installed_version(name)
+
+    # ── Extension discovery ───────────────────────────────────────────────────
+
+    def find_extension_files(self, name: str, installed_path: str | None = None) -> list[Path]:
+        """Return the extension .py files for an installed package.
+
+        Discovery order:
+          1. manifest.json with {get_app_name_lower(): {"extensions": [...]}}
+          2. pyproject.toml with [tool.{get_app_name_lower()}] extensions list
+          3. __init__.py that defines register()
+        """
+        if installed_path:
+            pkg_dir = Path(installed_path)
+        else:
+            pkg_dir = self._find_package_dir(name)
+
+        if not pkg_dir or not pkg_dir.is_dir():
+            return []
+
+        # 1. manifest.json
+        manifest = pkg_dir / "manifest.json"
+        if manifest.is_file():
+            try:
+                data = json.loads(manifest.read_text(encoding="utf-8"))
+                declared = data.get(get_app_name().lower(), {}).get("extensions", [])
+                if declared:
+                    return [(pkg_dir / p).resolve() for p in declared if (pkg_dir / p).is_file()]
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        # 2. pyproject.toml (package dir or its parent)
+        for pp in [pkg_dir / "pyproject.toml", pkg_dir.parent / "pyproject.toml"]:
+            if pp.is_file():
+                found = extensions_from_pyproject(pp, pp.parent)
+                if found:
+                    return found
+
+        # 3. __init__.py with a register() function
+        init = pkg_dir / "__init__.py"
+        if init.is_file():
+            try:
+                content = init.read_text(encoding="utf-8")
+                if "def register(" in content or "async def register(" in content:
+                    return [init.resolve()]
+            except OSError:
+                pass
+
+        return []
+
+    # ── Helpers ───────────────────────────────────────────────────────────────
+
+    def _get_installed_version(self, name: str) -> str | None:
+        """Query the installed version of a package."""
+        if not self._python.exists():
+            return None
+        for n in [name.replace("-", "_").lower(), name.lower()]:
+            result = subprocess.run(
+                [str(self._python), "-c",
+                 f"import importlib.metadata; print(importlib.metadata.version({n!r}))"],
+                capture_output=True, text=True,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+        return None
+
+    def _find_package_dir(self, name: str) -> Path | None:
+        """Locate the installation directory of a package in site-packages."""
+        site_pkgs = self.site_packages()
+        if not site_pkgs or not site_pkgs.is_dir():
+            return None
+        for candidate in [name, name.replace("-", "_"), name.replace("-", "_").lower()]:
+            p = site_pkgs / candidate
+            if p.is_dir():
+                return p
+        return None

tau/packages/types.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+
+class SourceType(str, Enum):
+    PYPI = "pypi"
+    GIT = "git"
+    LOCAL = "local"
+
+
+@dataclass
+class ParsedSource:
+    source: SourceType
+    raw: str
+    name: str
+    version: Optional[str] = None
+    install_spec: Optional[str] = None  # argument passed to pip install

tau/packages/utils.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from tau.packages.types import ParsedSource, SourceType
+from tau.settings.paths import get_app_name
+
+
+def parse_source(source: str) -> ParsedSource:
+    """Parse a package source string into its components.
+
+    Supported formats:
+      pypi:package-name
+      pypi:package-name@1.0.0
+      git+https://github.com/user/repo
+      git+https://github.com/user/repo@v1
+      /absolute/path  or  ./relative/path  or  ~/path
+      bare-name  (treated as pypi)
+    """
+    s = source.strip()
+
+    if s.startswith("pypi:"):
+        rest = s[5:]
+        if "@" in rest:
+            name, _, version = rest.partition("@")
+        else:
+            name, version = rest, None
+        name = name.strip()
+        spec = f"{name}=={version}" if version else name
+        return ParsedSource(source=SourceType.PYPI, raw=source, name=name, version=version, install_spec=spec)
+
+    if s.startswith("git+"):
+        # git+https://github.com/user/repo@tag  →  name = "repo"
+        base = re.sub(r"@[^/]+$", "", s) if "@" in s else s
+        name = re.sub(r"\.git$", "", base).rstrip("/").split("/")[-1]
+        return ParsedSource(source=SourceType.GIT, raw=source, name=name, install_spec=source)
+
+    if s.startswith(("/", ".", "~")):
+        path = Path(s).expanduser().resolve()
+        return ParsedSource(source=SourceType.LOCAL, raw=source, name=path.name, install_spec=str(path))
+
+    # Bare name — treat as pypi
+    m = re.match(r"^([a-zA-Z0-9_.-]+)(?:@(.+))?$", s)
+    if m:
+        name, version = m.group(1), m.group(2)
+        spec = f"{name}=={version}" if version else name
+        return ParsedSource(source=SourceType.PYPI, raw=source, name=name, version=version, install_spec=spec)
+
+    raise ValueError(f"Cannot parse package source: {source!r}")
+
+
+def extensions_from_pyproject(pyproject: Path, base: Path) -> list[Path]:
+    """Read [tool.tau].extensions from a pyproject.toml and return resolved paths."""
+    try:
+        try:
+            import tomllib  # Python 3.11+
+        except ImportError:
+            try:
+                import tomli as tomllib  # type: ignore[no-redef]
+            except ImportError:
+                return []
+        data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+        declared = data.get("tool", {}).get(get_app_name().lower(), {}).get("extensions", [])
+        return [(base / p).resolve() for p in declared if (base / p).is_file()]
+    except Exception:
+        return []

tau/prompts/expand.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import re
+import shlex
+
+
+def _parse_args(args_str: str) -> list[str]:
+    """Parse a shell-style argument string into a list of arguments."""
+    try:
+        return shlex.split(args_str)
+    except ValueError:
+        return args_str.split()
+
+
+def expand(content: str, args_str: str) -> str:
+    """
+    Substitute argument placeholders in template content.
+
+    Patterns supported:
+        $1, $2, ...         Positional argument (1-based)
+        $@ or $ARGUMENTS    All arguments joined with spaces
+        ${1:-default}       Positional with fallback default
+        ${@:N}              Args from index N (1-based) joined
+        ${@:N:L}            Args from N, length L
+    """
+    args = _parse_args(args_str.strip()) if args_str.strip() else []
+    all_args = " ".join(args)
+
+    def _brace(match: re.Match) -> str:
+        inner = match.group(1)
+
+        # ${@:N} or ${@:N:L}
+        m = re.match(r"@:(\d+)(?::(\d+))?$", inner)
+        if m:
+            n = int(m.group(1)) - 1
+            length = int(m.group(2)) if m.group(2) else None
+            sliced = args[n : n + length] if length is not None else args[n:]
+            return " ".join(sliced)
+
+        # ${N:-default}
+        m = re.match(r"(\d+):-(.*)$", inner)
+        if m:
+            idx = int(m.group(1)) - 1
+            return args[idx] if idx < len(args) else m.group(2)
+
+        # ${N}
+        m = re.match(r"(\d+)$", inner)
+        if m:
+            idx = int(m.group(1)) - 1
+            return args[idx] if idx < len(args) else ""
+
+        return match.group(0)
+
+    result = re.sub(r"\$\{([^}]+)\}", _brace, content)
+    result = re.sub(r"\$(?:@|ARGUMENTS)\b", all_args, result)
+    result = re.sub(r"\$([1-9])\b", lambda m: args[int(m.group(1)) - 1] if int(m.group(1)) - 1 < len(args) else "", result)
+
+    return result

tau/prompts/loader.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from tau.prompts.types import LoadPromptsResult, PromptLoadError, PromptTemplate
+
+
+def _parse_frontmatter(text: str) -> tuple[dict[str, str], str]:
+    """Parse YAML frontmatter from markdown text."""
+    text = text.lstrip("\n")
+    if not text.startswith("---"):
+        return {}, text
+    end = text.find("\n---", 3)
+    if end == -1:
+        return {}, text
+    fm_text = text[3:end].strip()
+    body = text[end + 4:].lstrip("\n")
+    meta: dict[str, str] = {}
+    for line in fm_text.splitlines():
+        if ":" in line:
+            key, _, val = line.partition(":")
+            meta[key.strip().lower()] = val.strip()
+    return meta, body
+
+
+def load_template_from_file(path: Path) -> tuple[PromptTemplate | None, str | None]:
+    """Load a prompt template from a markdown file."""
+    try:
+        text = path.read_text(encoding="utf-8")
+    except Exception as exc:
+        return None, f"read error: {exc}"
+
+    meta, body = _parse_frontmatter(text)
+    body = body.strip()
+    if not body:
+        return None, "template body is empty"
+
+    name = path.stem.lower()
+    description = meta.get("description", "")
+    if not description:
+        for line in body.splitlines():
+            stripped = line.strip().lstrip("#").strip()
+            if stripped:
+                description = stripped[:120]
+                break
+
+    argument_hint = meta.get("argument-hint") or meta.get("argument_hint") or None
+
+    return PromptTemplate(
+        name=name,
+        description=description,
+        content=body,
+        argument_hint=argument_hint,
+        file_path=str(path),
+    ), None
+
+
+def load_templates_from_dir(directory: Path) -> LoadPromptsResult:
+    """Load all prompt templates from a directory."""
+    result = LoadPromptsResult()
+    if not directory.is_dir():
+        return result
+    for path in sorted(directory.glob("*.md")):
+        tmpl, err = load_template_from_file(path)
+        if err or tmpl is None:
+            result.errors.append(PromptLoadError(str(path), err or "unknown error"))
+            continue
+        result.templates[tmpl.name] = tmpl
+    return result

tau/prompts/registry.py

@@ -0,0 +1,45 @@
+"""
+Prompt template registry.
+
+Priority (highest wins):
+    project  (.tau/prompts/*.md  relative to cwd)
+    global   (~/.tau/prompts/*.md)
+    builtin  (tau/builtins/prompts/)
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from tau.core.registry import Registry
+from tau.prompts.types import PromptLoadError, PromptTemplate
+from tau.prompts.loader import load_templates_from_dir
+
+
+class PromptRegistry(Registry[PromptTemplate, PromptLoadError]):
+    def _load_from_dir(self, path: Path) -> Any:
+        return load_templates_from_dir(path)
+
+    def _get_dir(self, cwd: Path | None = None) -> Path:
+        from tau.settings.paths import get_prompts_dir
+        return get_prompts_dir(cwd)
+
+    def _builtins_subdir(self) -> str:
+        return "prompts"
+
+    def _extract_items(self, result: Any) -> dict[str, PromptTemplate]:
+        return result.templates
+
+    def _extract_errors(self, result: Any) -> list[PromptLoadError]:
+        return result.errors
+
+    def expand(self, name: str, args_str: str) -> str | None:
+        """Expand a prompt template with the given arguments."""
+        tmpl = self.get(name)
+        if tmpl is None:
+            return None
+        from tau.prompts.expand import expand as _expand
+        return _expand(tmpl.content, args_str)
+
+
+prompt_registry = PromptRegistry()

tau/prompts/types.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class PromptTemplate:
+    name: str
+    description: str
+    content: str
+    argument_hint: str | None = None
+    file_path: str = ""
+
+
+@dataclass
+class PromptLoadError:
+    path: str
+    error: str
+
+
+@dataclass
+class LoadPromptsResult:
+    templates: dict[str, PromptTemplate] = field(default_factory=dict)
+    errors: list[PromptLoadError] = field(default_factory=list)

tau/rpc/__init__.py

@@ -0,0 +1,8 @@
+from tau.rpc.types import RpcResponse, RpcSessionState
+from tau.rpc.mode import run_rpc_mode
+
+__all__ = [
+    "run_rpc_mode",
+    "RpcResponse",
+    "RpcSessionState",
+]