tau-coding-agent 0.3.0__tar.gz → 0.3.5__tar.gz

{tau_coding_agent-0.3.0/tau_coding_agent.egg-info → tau_coding_agent-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.3.0
+Version: 0.3.5
 Summary: A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{tau_coding_agent-0.3.0 → tau_coding_agent-0.3.5}/docs/extensions.md

@@ -30,9 +30,11 @@ A subdirectory under `extensions/` is loaded if it has either:
 
 Before the entry file is executed, these specs are installed into the project or
 global packages venv (`uv pip install`, falling back to `pip` when `uv` isn't on
-PATH) and the venv's site-packages directory is added to `sys.path`. The install
-only runs once — a hash of the dependency list is cached, so unchanged manifests
-are a no-op on subsequent launches.
+PATH) and the venv's site-packages directory is appended to `sys.path`. Tau's
+runtime environment keeps precedence, so an extension cannot replace Tau's own
+dependencies with incompatible versions. The install only runs once — a hash of
+the dependency list is cached, so unchanged manifests are a no-op on subsequent
+launches.
 
 ## Entry point
 

{tau_coding_agent-0.3.0 → tau_coding_agent-0.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.3.0"
+version = "0.3.5"
 description = "A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -64,3 +64,14 @@ include = ["tau*"]
 tau = [
     "builtins/**/*",
 ]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+    "ruff>=0.4.0",
+    "mypy>=1.10.0",
+    "pyright>=1.1.360",
+]

tau_coding_agent-0.3.5/tau/agent/__init__.py

@@ -0,0 +1,11 @@
+from tau.agent.service import Agent
+from tau.agent.types import AgentConfig, AgentContext, AgentPhase, ContextUsage, PromptOptions
+
+__all__ = [
+    "Agent",
+    "AgentConfig",
+    "AgentContext",
+    "AgentPhase",
+    "PromptOptions",
+    "ContextUsage",
+]

{tau_coding_agent-0.3.0 → tau_coding_agent-0.3.5}/tau/agent/prompt/__init__.py

@@ -1,10 +1,10 @@
 """System prompt assembly for the coding agent."""
 
-from tau.agent.prompt.types import PromptOptions
 from tau.agent.prompt.builder import PromptBuilder, build_prompt
+from tau.agent.prompt.types import PromptOptions
 
 __all__ = [
-    'PromptOptions',
-    'PromptBuilder',
-    'build_prompt',
+    "PromptOptions",
+    "PromptBuilder",
+    "build_prompt",
 ]

{tau_coding_agent-0.3.0 → tau_coding_agent-0.3.5}/tau/agent/prompt/builder.py

@@ -8,10 +8,11 @@ from pathlib import Path
 
 from tau.agent.prompt.types import PromptOptions
 from tau.settings.paths import (
-    get_system_prompt_path,
     get_append_system_prompt_path,
     get_docs_dir,
+    get_examples_path,
     get_readme_path,
+    get_system_prompt_path,
 )
 
 
@@ -32,14 +33,80 @@ def load_project_context_file(cwd: Path) -> tuple[str, Path] | None:
                 pass
     return None
 
+
+def _find_git_root(cwd: Path) -> Path | None:
+    """Walk up from cwd and return the first directory containing .git, or None."""
+    current = cwd.resolve()
+    while True:
+        if (current / ".git").exists():
+            return current
+        parent = current.parent
+        if parent == current:
+            return None
+        current = parent
+
+
+def load_project_context_files(cwd: Path) -> list[tuple[str, Path]]:
+    """Walk from git root (or cwd if not in a repo) down to cwd, collecting context files.
+
+    Returns (content, path) tuples ordered root-first so cwd instructions appear
+    last and take highest precedence when the model reads top-to-bottom.
+    """
+    candidates = ["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"]
+
+    def _load(directory: Path) -> tuple[str, Path] | None:
+        for filename in candidates:
+            path = directory / filename
+            if path.is_file():
+                try:
+                    content = path.read_text(encoding="utf-8").strip()
+                    return (content, path) if content else None
+                except OSError:
+                    pass
+        return None
+
+    resolved = cwd.resolve()
+    git_root = _find_git_root(resolved)
+    stop_at = git_root if git_root else resolved
+
+    # Collect directories from stop_at down to cwd
+    dirs: list[Path] = []
+    current = resolved
+    while True:
+        dirs.append(current)
+        if current == stop_at:
+            break
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+
+    seen: set[Path] = set()
+    results: list[tuple[str, Path]] = []
+    for directory in reversed(dirs):
+        entry = _load(directory)
+        if entry and entry[1] not in seen:
+            seen.add(entry[1])
+            results.append(entry)
+
+    return results
+
+
 _DEFAULT_IDENTITY = """\
-You are a coding agent. You help users understand, write, and modify code and files.
+You are a coding agent operating inside Tau, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
 
 You have strong software engineering skills. You think carefully before making changes,
 and follow the existing style and conventions of the project.
-If a task is ambiguous, ask a clarifying question before proceeding.\
 """
 
+_GENERAL_GUIDELINES = [
+    "If a task is ambiguous, ask a precise, clarifying question before proceeding.",
+    "Do only what the task asks; don't add features, refactors, or abstractions beyond scope.",
+    "Write comments when the *why* is non-obvious — well-named code explains itself.",
+    "Keep responses short, concise, and direct; don't summarize what you just did.",
+    "Prioritize accuracy over agreement — investigate before confirming, and disagree when the evidence calls for it.",
+]
+
 
 _GIT_STATUS_MAX_LINES = 30
 _GIT_LOG_COUNT = 5
@@ -136,7 +203,8 @@ class PromptBuilder:
     Assembles the system prompt from layered sources.
 
     Layers in order:
-      Identity              — SYSTEM.md if present, else built-in identity; --system bypasses entirely
+      Identity              — SYSTEM.md if present, else built-in identity;
+                              --system bypasses entirely
       Tools section         — auto-generated from tool list (descriptions + guidelines)
       Tau docs              — tau documentation and examples
       Project Instructions  — AGENTS.md or CLAUDE.md from project (if present)
@@ -155,6 +223,7 @@ class PromptBuilder:
     def build(self) -> str:
         """Build the complete system prompt."""
         identity = self._identity()
+        guidelines = self._guidelines_section()
         tools = self._tools_section()
         docs = self._docs_section()
         project_context = self._project_context_section()
@@ -162,7 +231,7 @@ class PromptBuilder:
         append = self._append()
         git = self._git_section()
         footer = self._footer()
-        return identity + tools + docs + project_context + skills + append + git + footer
+        return identity + guidelines + tools + docs + project_context + skills + append + git + footer
 
     # ------------------------------------------------------------------
     # Layers
@@ -178,6 +247,10 @@ class PromptBuilder:
 
         return _DEFAULT_IDENTITY
 
+    def _guidelines_section(self) -> str:
+        bullets = "\n".join(f"- {g}" for g in _GENERAL_GUIDELINES)
+        return f"\n\n# Guidelines\n\n{bullets}"
+
     def _tools_section(self) -> str:
         tools = self._opts.tools
         if not tools:
@@ -194,6 +267,7 @@ class PromptBuilder:
             if guideline:
                 guidelines.append(f"- **{t.name}**: {guideline.strip()}")
         section = "\n\n# Available Tools\n\n" + "\n".join(lines)
+        section+="\nIn addition to the tools above, you may have access to other custom tools depending on the project."
         if guidelines:
             section += "\n\n## Tool Guidelines\n\n" + "\n".join(guidelines)
         return section
@@ -201,6 +275,10 @@ class PromptBuilder:
     def _project_context_section(self) -> str:
         """Include project-specific context from AGENTS.md or CLAUDE.md if present.
 
+        Walks from git root down to cwd, loading one file per directory.
+        Each file is wrapped in <project_instructions path="..."> so the model
+        knows which directory each set of rules comes from.
+
         Skipped if:
         - disable_context_files is True (--no-context-files flag)
         - project is not trusted (--no-approve flag or trust store)
@@ -209,36 +287,52 @@ class PromptBuilder:
             return ""
         if self._opts.project_trusted is False:
             return ""
-        context = load_project_context_file(self._opts.cwd)
-        if not context:
+        files = load_project_context_files(self._opts.cwd)
+        if not files:
             return ""
-        content, path = context
+        blocks = "".join(
+            f'<project_instructions path="{path}">\n{content}\n</project_instructions>\n\n'
+            for content, path in files
+        )
         return (
-            f"\n\n# Project Instructions\n\n"
-            f"Project-specific guidelines and rules (from {path.name}):\n\n"
-            f"{content}\n\n"
-            "Follow project-specific instructions before general Tau guidelines."
+            "\n\n# Project Instructions\n\n"
+            "Project-specific guidelines (follow before general Tau guidelines):\n\n"
+            "<project_context>\n\n"
+            + blocks
+            + "</project_context>"
         )
 
     def _docs_section(self) -> str:
         readme = get_readme_path()
         docs = get_docs_dir()
+        examples = get_examples_path()
         return (
             "\n\nTau documentation (read only when the user asks about Tau itself, its"
             " settings, extensions, themes, skills, tools, sessions, or keybindings):\n"
             f"- README: {readme}\n"
             f"- Docs directory: {docs}\n"
-            "- When asked about: settings (docs/settings.md), tools (docs/tools.md),"
+            f"- Examples directory: {examples} (extensions, custom tools, themes, skills)\n"
+            "- When asked about: quickstart (docs/quickstart.md),"
+            " installation (docs/installation.md),"
+            " usage (docs/usage.md), CLI flags (docs/cli-reference.md),"
+            " architecture (docs/architecture.md),"
+            " settings (docs/settings.md), tools (docs/tools.md),"
             " extensions (docs/extensions.md), themes (docs/themes.md),"
-            " skills (docs/skills.md), keybindings (docs/keybindings.md),"
-            " sessions (docs/sessions.md), usage (docs/usage.md),"
-            " Python API (docs/python-api.md), inference providers (docs/inference-providers.md)\n"
-            "- Resolve all doc paths under the Docs directory above, not the current working directory\n"
+            " skills (docs/skills.md), prompts (docs/prompts.md),"
+            " keybindings (docs/keybindings.md),"
+            " sessions (docs/sessions.md), messages (docs/messages.md),"
+            " Python API (docs/python-api.md),"
+            " inference providers (docs/inference-providers.md),"
+            " auth (docs/auth.md)\n"
+            "- Resolve all doc paths under the Docs directory above,"
+            " not the current working directory\n"
+            "- Resolve all example paths under the Examples directory above\n"
             "- Read .md files completely and follow cross-references before answering"
         )
 
     def _skills_section(self) -> str:
         from tau.skills.registry import skill_registry
+
         block = skill_registry.format_for_system_prompt(self._opts.skills)
         return f"\n\n{block}" if block else ""
 

{tau_coding_agent-0.3.0 → tau_coding_agent-0.3.5}/tau/agent/prompt/types.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 from pathlib import Path
 from typing import Any
+
 from pydantic import BaseModel, Field
+
 from tau.tool.types import Tool
 
 
 class PromptOptions(BaseModel):
     """Options for constructing the system prompt."""
-    model_config = {'arbitrary_types_allowed': True}
+
+    model_config = {"arbitrary_types_allowed": True}
 
     cwd: Path
     tools: list[Tool] = Field(default_factory=list)

{tau_coding_agent-0.3.0 → tau_coding_agent-0.3.5}/tau/agent/service.py

@@ -4,19 +4,26 @@ import asyncio
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from tau.agent.types import AgentConfig, AgentContext, AgentPhase, PromptOptions, ContextUsage
-from tau.hooks.service import Hooks
+from tau.agent.types import AgentConfig, AgentContext, AgentPhase, ContextUsage, PromptOptions
 from tau.hooks.engine import MessageEndEvent, MessageRollbackEvent, SavePointEvent, SettledEvent
-from tau.message.types import AgentMessage, AssistantMessage, TerminalExecutionMessage, LLMMessage, UserMessage, TextContent, ToolMessage
+from tau.hooks.service import Hooks
+from tau.message.types import (
+    AgentMessage,
+    AssistantMessage,
+    LLMMessage,
+    TerminalExecutionMessage,
+    TextContent,
+    ToolMessage,
+    UserMessage,
+)
 from tau.message.utils import strip_unusable_trailing_assistant
 from tau.tool.types import ToolInvocation, ToolResult
 
 if TYPE_CHECKING:
     from tau.engine.service import Engine
-    from tau.session.manager import SessionManager
     from tau.runtime.service import Runtime
     from tau.session.compaction import CompactionPreparation
-
+    from tau.session.manager import SessionManager
 
 
 def _to_llm_messages(messages: list[AgentMessage]) -> list[LLMMessage]:
@@ -29,7 +36,8 @@ def _to_llm_messages(messages: list[AgentMessage]) -> list[LLMMessage]:
     errors) and are skipped — an assistant turn with neither content nor tool
     calls is invalid to send back and triggers provider 400s.
     """
-    from tau.message.types import CompactionSummaryMessage, ToolCallContent, ThinkingContent
+    from tau.message.types import CompactionSummaryMessage, ThinkingContent, ToolCallContent
+
     result: list[LLMMessage] = []
     for msg in messages:
         if isinstance(msg, CompactionSummaryMessage):
@@ -40,8 +48,7 @@ def _to_llm_messages(messages: list[AgentMessage]) -> list[LLMMessage]:
                 result.append(msg.to_user_message())
         elif isinstance(msg, AssistantMessage):
             has_usable = any(
-                isinstance(c, (TextContent, ToolCallContent, ThinkingContent))
-                for c in msg.contents
+                isinstance(c, (TextContent, ToolCallContent, ThinkingContent)) for c in msg.contents
             )
             if has_usable:
                 result.append(msg)
@@ -114,6 +121,7 @@ class Agent:
     def update_context_tokens(self) -> None:
         """Recalculate context token usage."""
         from tau.session.compaction import estimate_context_tokens
+
         session_ctx = self._session_manager.build_session_context()
         llm_messages = _to_llm_messages(session_ctx.messages)
         usage = estimate_context_tokens(llm_messages)
@@ -122,7 +130,9 @@ class Agent:
     def get_context_usage(self) -> ContextUsage | None:
         """Get current context token usage and limits."""
         self.update_context_tokens()
-        percent = (self._context_tokens / self._context_window * 100) if self._context_window else None
+        percent = (
+            (self._context_tokens / self._context_window * 100) if self._context_window else None
+        )
         return ContextUsage(
             tokens=self._context_tokens,
             context_window=self._context_window,
@@ -191,7 +201,7 @@ class Agent:
             case _:
                 pass
 
-    async def _on_message_rollback(self, event: "MessageRollbackEvent") -> None:
+    async def _on_message_rollback(self, event: MessageRollbackEvent) -> None:
         """Retract the last ``event.count`` persisted messages from the session.
 
         Fired when an interrupted tool turn is dropped: the assistant tool-call
@@ -209,22 +219,26 @@ class Agent:
     async def compact(self, custom_instructions: str | None = None) -> bool:
         """Manually trigger context compaction. Returns True if compaction ran."""
         from tau.session.compaction import prepare_compaction
+
         entries = self._session_manager.get_branch()
         preparation = prepare_compaction(entries, self._config.compaction)
         if preparation is None:
             return False
-        await self._apply_compaction(preparation, entries, manual=True, custom_instructions=custom_instructions)
+        await self._apply_compaction(
+            preparation, entries, manual=True, custom_instructions=custom_instructions
+        )
         return True
 
     async def _apply_compaction(
         self,
-        preparation: "CompactionPreparation",
+        preparation: CompactionPreparation,
         entries: list,
         manual: bool,
         custom_instructions: str | None = None,
     ) -> None:
         """Run a prepared compaction, persist the summary, and emit the end event."""
         from tau.hooks.engine import CompactionEndEvent
+
         result, from_extension = await self._run_compaction(
             preparation, entries, manual=manual, custom_instructions=custom_instructions
         )
@@ -234,16 +248,19 @@ class Agent:
             tokens_before=result.tokens_before,
         )
         self._compaction_failures = 0
-        await self.hooks.emit(CompactionEndEvent(
-            manual=manual,
-            tokens_before=result.tokens_before,
-            summary_length=len(result.summary),
-            from_extension=from_extension,
-        ))
+        await self.hooks.emit(
+            CompactionEndEvent(
+                manual=manual,
+                tokens_before=result.tokens_before,
+                summary_length=len(result.summary),
+                from_extension=from_extension,
+            )
+        )
 
     def _latest_compaction_timestamp(self) -> float | None:
         """Timestamp of the most recent compaction in the active branch, if any."""
         from tau.session.types import CompactionEntry
+
         for entry in reversed(self._session_manager.get_branch()):
             if isinstance(entry, CompactionEntry):
                 return entry.timestamp
@@ -252,8 +269,9 @@ class Agent:
     async def _check_compaction(self) -> None:
         """Auto-compact if context usage exceeds the threshold. Circuit-breaks after 3 failures."""
         from tau.session.compaction import (
-            estimate_context_tokens, should_compact,
+            estimate_context_tokens,
             prepare_compaction,
+            should_compact,
         )
 
         if self._compaction_failures >= 3:
@@ -305,6 +323,7 @@ class Agent:
           leaving no room to generate, so it stops with zero output.
         """
         from tau.inference.types import StopReason
+
         cw = self._context_window
         if cw <= 0:
             return False
@@ -312,9 +331,9 @@ class Agent:
         inp = u.input_tokens + u.cache_read_tokens
         if message.stop_reason == StopReason.Stop and inp > cw:
             return True
-        if message.stop_reason == StopReason.Length and u.output_tokens == 0 and inp >= cw * 0.99:
-            return True
-        return False
+        return bool(
+            message.stop_reason == StopReason.Length and u.output_tokens == 0 and inp >= cw * 0.99
+        )
 
     async def _try_overflow_recovery(self) -> bool:
         """If the last turn died with a context-overflow error, compact once and signal a retry.
@@ -358,11 +377,18 @@ class Agent:
         if self._runtime is None:
             return
         from tau.extensions.context import ExtensionContext
+
         ctx = ExtensionContext.from_runtime(self._runtime)
         if ctx.ui is not None:
             ctx.ui.notify(message)
 
-    async def _run_compaction(self, preparation: "CompactionPreparation", entries: list, manual: bool, custom_instructions: str | None = None) -> tuple:
+    async def _run_compaction(
+        self,
+        preparation: CompactionPreparation,
+        entries: list,
+        manual: bool,
+        custom_instructions: str | None = None,
+    ) -> tuple:
         """Emit before_compaction (allowing interception), then run the default algorithm.
 
         Returns (CompactionResult, from_extension: bool).
@@ -370,14 +396,20 @@ class Agent:
         Exceptions in before_compaction handlers are swallowed — first non-error result wins,
         consistent with error-fallthrough behaviour.
         """
+        from tau.hooks.engine import (
+            BeforeCompactionEvent,
+            BeforeCompactionResult,
+            CompactionStartEvent,
+        )
         from tau.session.compaction import compact as _compact
-        from tau.hooks.engine import BeforeCompactionEvent, BeforeCompactionResult, CompactionStartEvent
 
-        before_results = await self.hooks.emit(BeforeCompactionEvent(
-            preparation=preparation,
-            entries=entries,
-            manual=manual,
-        ))
+        before_results = await self.hooks.emit(
+            BeforeCompactionEvent(
+                preparation=preparation,
+                entries=entries,
+                manual=manual,
+            )
+        )
 
         for res in before_results:
             if not isinstance(res, BeforeCompactionResult):
@@ -388,7 +420,9 @@ class Agent:
                 return res.compaction, True
 
         await self.hooks.emit(CompactionStartEvent(manual=manual))
-        result = await _compact(preparation, self._engine.llm, custom_instructions=custom_instructions)  # type: ignore[arg-type]
+        result = await _compact(
+            preparation, self._engine.llm, custom_instructions=custom_instructions
+        )  # type: ignore[arg-type]
         return result, False
 
     # -------------------------------------------------------------------------
@@ -398,7 +432,9 @@ class Agent:
     async def invoke(self, text: str, options: PromptOptions | None = None) -> None:
         """Run one user turn."""
         if self._phase != AgentPhase.IDLE:
-            raise RuntimeError(f"Agent is busy (phase={self._phase!r}). Wait for the current operation to finish.")
+            raise RuntimeError(
+                f"Agent is busy (phase={self._phase!r}). Wait for the current operation to finish."
+            )
 
         opts = options or PromptOptions()
 
@@ -452,11 +488,11 @@ class Agent:
 
     async def _run(self, ctx: AgentContext) -> None:
         unsubscribe = self.hooks.register(
-            'message_end',
+            "message_end",
             lambda event: self._on_message_end(event),
         )
         unsubscribe_rollback = self.hooks.register(
-            'message_rollback',
+            "message_rollback",
             lambda event: self._on_message_rollback(event),
         )
         try:

{tau_coding_agent-0.3.0 → tau_coding_agent-0.3.5}/tau/agent/types.py

@@ -1,21 +1,23 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from enum import Enum
+from enum import StrEnum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel
+
 from tau.message.types import LLMMessage
+from tau.session.compaction import DEFAULT_COMPACTION_SETTINGS, CompactionSettings
 from tau.session.types import MessageMeta
-from tau.session.compaction import CompactionSettings, DEFAULT_COMPACTION_SETTINGS
 
 if TYPE_CHECKING:
     from tau.tool.types import Tool
 
 
-class AgentPhase(str, Enum):
+class AgentPhase(StrEnum):
     """Agent execution phase."""
+
     IDLE = "idle"
     TURN = "turn"
 
@@ -23,6 +25,7 @@ class AgentPhase(str, Enum):
 @dataclass
 class AgentContext:
     """Snapshot of everything the LLM receives for one turn."""
+
     system_prompt: str
     messages: list[LLMMessage]
     tools: list[Tool] = field(default_factory=list)
@@ -30,7 +33,8 @@ class AgentContext:
 
 class AgentConfig(BaseModel):
     """Internal runtime config passed to Agent.__init__."""
-    model_config = {'arbitrary_types_allowed': True}
+
+    model_config = {"arbitrary_types_allowed": True}
 
     cwd: Path
     system_prompt: str = ""
@@ -39,11 +43,10 @@ class AgentConfig(BaseModel):
     compaction: CompactionSettings = DEFAULT_COMPACTION_SETTINGS
 
 
-
-
 class PromptOptions(BaseModel):
     """Configuration options for prompt submission."""
-    model_config = {'arbitrary_types_allowed': True}
+
+    model_config = {"arbitrary_types_allowed": True}
 
     meta: MessageMeta | None = None
     images: list[bytes] = []
@@ -54,8 +57,7 @@ class PromptOptions(BaseModel):
 @dataclass
 class ContextUsage:
     """Token usage and context window statistics."""
+
     tokens: int
     context_window: int
     percent: float | None = None
-
-