tsugite-cli 0.14.0__tar.gz → 0.14.2__tar.gz

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsugite-cli
-Version: 0.14.0
+Version: 0.14.2
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE
@@ -263,6 +263,7 @@ Provides-Extra: daemon
 Requires-Dist: cronsim>=2.6; extra == 'daemon'
 Requires-Dist: discord-py>=2.3.2; extra == 'daemon'
 Requires-Dist: py-vapid>=1.9.0; extra == 'daemon'
+Requires-Dist: python-multipart>=0.0.9; extra == 'daemon'
 Requires-Dist: pywebpush>=2.0.0; extra == 'daemon'
 Requires-Dist: starlette>=0.36; extra == 'daemon'
 Requires-Dist: uvicorn>=0.25; extra == 'daemon'
@@ -337,6 +338,18 @@ tsu run my-agent.md "do the thing"
 tsu daemon
 ```
 
+### Output modes
+
+`tsu run` keeps its terminal output plain by default so logs are copy-pasteable and behave
+in nested tmux / non-Rich-friendly shells. Pick a richer or quieter mode when you need it:
+
+| Mode | When to use |
+| --- | --- |
+| **Default (plain)** | Everyday interactive runs and piped output (`tsu run ... \| less`). |
+| `--ui live` | Long-running interactive runs where a persistent footer showing turn / current tool / tokens / cost / elapsed time is useful. Falls back to plain if stdout is not a TTY or `NO_COLOR` is set. |
+| `--headless` | CI/scripts: result on stdout, no progress chrome. Combine with `--verbose` for stderr trace. |
+| `--plain` | Force plain explicitly (same as the default; useful when overriding configs/aliases). |
+
 ## Features
 
 - **Multi-step workflows** with `<!-- tsu:step -->` to chain steps and pass data between them

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/README.md

@@ -67,6 +67,18 @@ tsu run my-agent.md "do the thing"
 tsu daemon
 ```
 
+### Output modes
+
+`tsu run` keeps its terminal output plain by default so logs are copy-pasteable and behave
+in nested tmux / non-Rich-friendly shells. Pick a richer or quieter mode when you need it:
+
+| Mode | When to use |
+| --- | --- |
+| **Default (plain)** | Everyday interactive runs and piped output (`tsu run ... \| less`). |
+| `--ui live` | Long-running interactive runs where a persistent footer showing turn / current tool / tokens / cost / elapsed time is useful. Falls back to plain if stdout is not a TTY or `NO_COLOR` is set. |
+| `--headless` | CI/scripts: result on stdout, no progress chrome. Combine with `--verbose` for stderr trace. |
+| `--plain` | Force plain explicitly (same as the default; useful when overriding configs/aliases). |
+
 ## Features
 
 - **Multi-step workflows** with `<!-- tsu:step -->` to chain steps and pass data between them

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.14.0"
+version = "0.14.2"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"
@@ -34,6 +34,7 @@ daemon = [
   "cronsim>=2.6",
   "starlette>=0.36",
   "uvicorn>=0.25",
+  "python-multipart>=0.0.9",
   "pywebpush>=2.0.0",
   "py-vapid>=1.9.0",
 ]
@@ -49,12 +50,23 @@ build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["tsugite"]
 
+[tool.hatch.build.targets.sdist]
+include = [
+  "/tsugite",
+  "/README.md",
+  "/LICENSE",
+  "/CONTRIBUTING.md",
+  "/AGENTS.md",
+  "/pyproject.toml",
+]
+
 [tool.uv.workspace]
 members = ["plugins/*"]
 
 [tool.uv.sources]
 tsugite-cli = { workspace = true }
 tsugite-tmux = { workspace = true }
+tsugite-acp = { workspace = true }
 
 [tool.ruff]
 target-version = "py311"
@@ -73,7 +85,7 @@ line-length = 120
 
 [tool.pytest.ini_options]
 testpaths = ["tests", "plugins"]
-addopts = "-n auto --dist loadscope --cov=tsugite --cov-report=term-missing --cov-report=html --cov-report=xml"
+addopts = "-n auto --dist loadfile --cov=tsugite --cov-report=term-missing --cov-report=html --cov-report=xml"
 asyncio_mode = "strict"
 asyncio_default_fixture_loop_scope = "function"
 filterwarnings = ["ignore::RuntimeWarning"]
@@ -129,4 +141,5 @@ dev = [
   "ruff>=0.1",
   "vulture>=2.14",
   "tsugite-tmux",
+  "tsugite-acp",
 ]

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/tsugite/agent_inheritance.py

@@ -281,6 +281,7 @@ def merge_scalar_fields(parent, child) -> Dict[str, Any]:
         "model": child.model if child.model else parent.model,
         "max_turns": child.max_turns if child.max_turns != 5 else parent.max_turns,
         "reasoning_effort": child.reasoning_effort if child.reasoning_effort else parent.reasoning_effort,
+        "auto_load_agent_list": child.auto_load_agent_list or parent.auto_load_agent_list,
     }
 
 
@@ -321,6 +322,7 @@ def merge_list_fields(parent, child) -> Dict[str, List]:
     merged_tools = _merge_dedup(parent.tools, child.tools)
     merged_attachments = _merge_attachments(parent.attachments, child.attachments)
     merged_skills = _merge_dedup(parent.auto_load_skills, child.auto_load_skills)
+    merged_auto_load_agents = _merge_dedup(parent.auto_load_agents, child.auto_load_agents)
 
     # Custom tools - deduplicate by "name" field (child overrides parent)
     custom_tool_dict = {}
@@ -333,6 +335,7 @@ def merge_list_fields(parent, child) -> Dict[str, List]:
         "prefetch": (parent.prefetch or []) + (child.prefetch or []),
         "custom_tools": list(custom_tool_dict.values()),
         "auto_load_skills": merged_skills,
+        "auto_load_agents": merged_auto_load_agents,
     }
 
 

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/tsugite/agent_preparation.py

@@ -547,6 +547,19 @@ class AgentPreparer:
                 # Silently continue if prefetch fails
                 prefetch_context = {}
 
+        # Step 1b: Opt-in <available_agents> injection. Default agents call
+        # list_available_agents() on demand instead of carrying the full list.
+        if "available_agents" not in prefetch_context and (
+            agent_config.auto_load_agent_list or agent_config.auto_load_agents
+        ):
+            from tsugite.tools.agents import discover_agents, format_agents_markdown
+
+            agents = discover_agents()
+            if agent_config.auto_load_agents:
+                wanted = set(agent_config.auto_load_agents)
+                agents = [a for a in agents if a["name"] in wanted]
+            prefetch_context["available_agents"] = format_agents_markdown(agents)
+
         # Step 2: Execute tool directives (unless skip_tool_directives=True for render)
         if skip_tool_directives:
             modified_content = agent.content

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/tsugite/agent_runner/exec_directives.py

@@ -7,7 +7,7 @@ execution note, and returns the modified content plus a context dict of assigned
 
 from typing import Any, Dict, List, Optional, Tuple
 
-from tsugite.agent_runner.exec_runner import run_python_block
+from tsugite.agent_runner.exec_runner import ExecBlockResult, run_python_block
 from tsugite.md_agents import ExecDirective, extract_exec_directives
 
 

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/tsugite/builtin_agents/default.md

@@ -15,6 +15,7 @@ attachments:
 max_turns: 10
 tools:
   - spawn_agent
+  - list_available_agents
   - read_file
   - list_files
   - write_file
@@ -36,9 +37,6 @@ tools:
 auto_load_skills:
   - response-patterns
 prefetch:
-  - tool: list_agents
-    args: {}
-    assign: available_agents
   - tool: get_skills_for_template
     args: {}
     assign: available_skills
@@ -54,6 +52,14 @@ instructions: |
   Before starting work, check the `<available_skills>` section and load one if it matches.
   Call `load_skill("skill_name")` and wait for the next turn before proceeding.
 
+  ## Delegating to Sub-Agents
+
+  The list of available sub-agents is not auto-attached to your context. When a task
+  clearly benefits from a specialized agent (and isn't something you can handle inline),
+  call `list_available_agents()` to discover them, then `spawn_agent(path, prompt)` to
+  delegate. Skip both for simple tasks or single-file edits - most work doesn't need
+  delegation.
+
   ## Guidelines
 
   - Be concise and direct in your responses

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/tsugite/builtin_skills/tsugite-jinja-reference/SKILL.md

@@ -76,10 +76,11 @@ Injected via `AgentRenderer.env.globals`:
   ```
 
 ### Environment Access
-- `env` → Dictionary of environment variables (`os.environ`)
+- `env` → Dictionary of environment variables (`os.environ`). Also callable as `env(key, default)`.
   ```jinja2
   Debug mode: {{ env.get("DEBUG", "false") }}
   API endpoint: {{ env["API_URL"] }}
+  With default: {{ env("DEBUG", "false") }}
   ```
 
 ## Control Patterns

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/tsugite/cli/chat.py

@@ -60,12 +60,9 @@ def chat(
         workspace_attachments = _build_workspace_attachments(resolved_workspace)
 
     with workspace_directory_context(resolved_workspace, root, console) as path_context:
-        # Handle conversation resume
-        resume_turns = None
-
         if continue_ is not None:
             from tsugite.agent_runner.history_integration import get_latest_conversation
-            from tsugite.history import get_history_dir, get_turns
+            from tsugite.history import get_history_dir
 
             if continue_ == "" or continue_.lower() == "latest":
                 history_opts.continue_id = get_latest_conversation()
@@ -77,16 +74,10 @@ def chat(
                 history_opts.continue_id = continue_
                 console.print(f"[cyan]Resuming conversation: {history_opts.continue_id}[/cyan]")
 
-            try:
-                session_path = get_history_dir() / f"{history_opts.continue_id}.jsonl"
-                resume_turns = get_turns(session_path)
-                console.print(f"[cyan]Loaded {len(resume_turns)} previous turns[/cyan]")
-            except FileNotFoundError:
+            session_path = get_history_dir() / f"{history_opts.continue_id}.jsonl"
+            if not session_path.exists():
                 console.print(f"[red]Conversation not found: {history_opts.continue_id}[/red]")
                 raise typer.Exit(1)
-            except Exception as e:
-                console.print(f"[red]Failed to load conversation: {e}[/red]")
-                raise typer.Exit(1)
 
         agent_to_load = agent if agent else "default"
         _, primary_agent_path, _ = load_and_validate_agent(agent_to_load, console)
@@ -100,7 +91,6 @@ def chat(
             agent_path=primary_agent_path,
             exec_options=exec_opts,
             history_options=history_opts,
-            resume_turns=resume_turns,
             path_context=path_context,
             workspace_attachments=workspace_attachments,
         )

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/tsugite/cli/plugins.py

@@ -156,15 +156,15 @@ def test_hello_custom():
 
 def _patch_root_pyproject(root_pyproject: Path, dist_name: str) -> None:
     text = root_pyproject.read_text()
-    sources_line = f'{dist_name} = {{ workspace = true }}\n'
+    sources_line = f"{dist_name} = {{ workspace = true }}\n"
     dev_dep_line = f'  "{dist_name}",\n'
 
     if dist_name in text:
         return  # idempotent
 
     new_text = re.sub(
-        r'(\[tool\.uv\.sources\][^\[]*?tsugite-cli = \{ workspace = true \}\n)',
-        rf'\1{sources_line}',
+        r"(\[tool\.uv\.sources\][^\[]*?tsugite-cli = \{ workspace = true \}\n)",
+        rf"\1{sources_line}",
         text,
         count=1,
     )
@@ -172,8 +172,8 @@ def _patch_root_pyproject(root_pyproject: Path, dist_name: str) -> None:
         raise typer.BadParameter("Could not locate [tool.uv.sources] block in root pyproject.toml")
 
     new_text2 = re.sub(
-        r'(\[dependency-groups\]\s*\ndev\s*=\s*\[(?:[^\]]|\n)*?)\n\]',
-        rf'\1\n{dev_dep_line.rstrip()}\n]',
+        r"(\[dependency-groups\]\s*\ndev\s*=\s*\[(?:[^\]]|\n)*?)\n\]",
+        rf"\1\n{dev_dep_line.rstrip()}\n]",
         new_text,
         count=1,
     )
@@ -185,7 +185,9 @@ def _patch_root_pyproject(root_pyproject: Path, dist_name: str) -> None:
 
 @plugin_app.command("create")
 def plugin_create(
-    name: str = typer.Argument(help="Plugin short name (lowercase, alphanumeric + hyphens). E.g. 'discord' creates tsugite-discord."),
+    name: str = typer.Argument(
+        help="Plugin short name (lowercase, alphanumeric + hyphens). E.g. 'discord' creates tsugite-discord."
+    ),
     dry_run: bool = typer.Option(False, "--dry-run", help="Print planned changes without writing"),
 ):
     """Scaffold a new workspace plugin under plugins/tsugite-<name>/."""

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/tsugite/cli/run.py

@@ -1,6 +1,5 @@
 """CLI run command - execute agents."""
 
-import sys
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -97,16 +96,18 @@ def _resolve_ui_mode(ui_mode: Optional[str], ui_opts: UIOptions, console: Consol
         console.print("[red]Error: --ui cannot be used with --plain or --headless[/red]")
         raise typer.Exit(1)
 
-    ui_modes = {"plain", "headless"}
+    ui_modes = {"plain", "headless", "live"}
     ui_lower = ui_mode.lower()
     if ui_lower not in ui_modes:
-        console.print(f"[red]Error: Invalid UI mode '{ui_mode}'. Choose from: {', '.join(ui_modes)}[/red]")
+        console.print(f"[red]Error: Invalid UI mode '{ui_mode}'. Choose from: {', '.join(sorted(ui_modes))}[/red]")
         raise typer.Exit(1)
 
     if ui_lower == "plain":
         ui_opts.plain = True
     elif ui_lower == "headless":
         ui_opts.headless = True
+    elif ui_lower == "live":
+        ui_opts.live = True
 
     return ui_opts
 
@@ -169,7 +170,14 @@ def _execute_agent_with_ui(
     use_plain_output: bool,
     console: Console,
 ):
-    """Execute agent with appropriate UI mode."""
+    """Execute agent with appropriate UI mode.
+
+    Dispatch order:
+      1. --headless / --final-only -> custom_agent_ui with silent progress
+      2. --ui live (on a real TTY) -> three-region LiveUIHandler
+      3. fall-through default -> plain logger (covers no flags, --plain, piped/NO_COLOR,
+         and --ui live degraded to plain by should_use_plain_output)
+    """
     from tsugite.ui import create_plain_logger, custom_agent_ui
 
     if ui_opts.headless or ui_opts.final_only:
@@ -188,22 +196,16 @@ def _execute_agent_with_ui(
             executor_kwargs["custom_logger"] = custom_logger
             return executor(**executor_kwargs)
 
-    if use_plain_output:
-        custom_logger = create_plain_logger()
-        with custom_logger.ui_handler.progress_context():
+    if ui_opts.live and not use_plain_output:
+        from tsugite.ui import create_live_logger
+
+        custom_logger = create_live_logger(show_reasoning=ui_opts.show_reasoning)
+        with custom_logger.ui_handler.live_context():
             executor_kwargs["custom_logger"] = custom_logger
             return executor(**executor_kwargs)
 
-    default_console = Console(file=sys.stderr, force_terminal=True, no_color=ui_opts.no_color)
-    with custom_agent_ui(
-        console=default_console,
-        show_code=not ui_opts.non_interactive,
-        show_observations=not ui_opts.non_interactive,
-        show_progress=not ui_opts.no_color,
-        show_llm_messages=ui_opts.show_reasoning,
-        show_panels=False,
-        show_debug_messages=ui_opts.verbose,
-    ) as custom_logger:
+    custom_logger = create_plain_logger(show_reasoning=ui_opts.show_reasoning)
+    with custom_logger.ui_handler.progress_context():
         executor_kwargs["custom_logger"] = custom_logger
         return executor(**executor_kwargs)
 
@@ -246,7 +248,11 @@ def run(
     ),
     root: Optional[str] = typer.Option(None, "--root", help="Working directory"),
     model: Optional[str] = typer.Option(None, "--model", "-m", help="Override agent model"),
-    ui: Optional[str] = typer.Option(None, "--ui", help="UI mode: plain, headless, or live (default: minimal)"),
+    ui: Optional[str] = typer.Option(
+        None,
+        "--ui",
+        help="UI mode: plain, headless, or live. Default: plain (auto-degrades when piped or NO_COLOR is set)",
+    ),
     non_interactive: bool = typer.Option(False, "--non-interactive", help="Run without interactive prompts"),
     history_dir: Optional[str] = typer.Option(None, "--history-dir", help="Directory to store history files"),
     no_color: bool = typer.Option(False, "--no-color", help="Disable ANSI colors"),
@@ -407,8 +413,8 @@ def run(
     import os
 
     if subagent_mode:
-        if ui_opts.plain or ui_opts.headless:
-            console.print("[red]Error: --subagent-mode cannot be combined with --plain or --headless[/red]")
+        if ui_opts.plain or ui_opts.headless or ui_opts.live:
+            console.print("[red]Error: --subagent-mode cannot be combined with --plain, --headless, or --ui live[/red]")
             raise typer.Exit(1)
 
         ui_opts.non_interactive = True

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/tsugite/cli/workspace.py

@@ -142,7 +142,6 @@ def onboard_workspace(
         agent_path=agent_path,
         exec_options=exec_opts,
         history_options=history_opts,
-        resume_turns=None,
         path_context=path_context,
         workspace_attachments=workspace_attachments,
     )

{tsugite_cli-0.14.0 → tsugite_cli-0.14.2}/tsugite/core/executor.py

@@ -8,18 +8,47 @@ injected `state` object persist across turns.
 """
 
 import ast
+import contextlib
 import io
+import os
 import pprint
 import sys
+import threading
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, Iterator, List, Optional
 
 from tsugite.core.state import load_state, save_state
 from tsugite.exceptions import StateSerializationError
 
 PPRINT_WIDTH = 100
 
+# CWD is process-global. Concurrent execute() calls in different threads must
+# serialize their chdir+exec+restore window; the lock is held across the whole
+# user-code exec(), so heavy parallel LocalExecutor turns serialize end-to-end.
+# Accepted trade-off: silent disagreement between raw `os.getcwd()` and tool
+# path resolution is worse than the serialization. `spawn_session` returns
+# immediately so a parent holding the lock doesn't starve a nested child.
+_chdir_lock = threading.Lock()
+
+
+@contextlib.contextmanager
+def _locked_chdir(target: Optional[Path]) -> Iterator[None]:
+    """chdir to target under `_chdir_lock`; restore CWD and release on exit.
+
+    No-op when target is None.
+    """
+    if target is None:
+        yield
+        return
+    with _chdir_lock:
+        previous = os.getcwd()
+        os.chdir(str(target))
+        try:
+            yield
+        finally:
+            os.chdir(previous)
+
 
 def _looks_html_escaped(source: str) -> bool:
     """True if `source` is HTML-entity-escaped XML (observation content leaked into exec)."""
@@ -203,6 +232,11 @@ class LocalExecutor:
         self._sticky_injections: Dict[str, Any] = {}
         self._content_blocks: Dict[str, str] = {}
 
+        target = workspace_dir
+        if target is None and path_context is not None:
+            target = path_context.effective_cwd or path_context.workspace_dir
+        self._chdir_target_resolved: Optional[Path] = Path(target).resolve() if target is not None else None
+
         self.namespace: Dict[str, Any] = self._build_turn_namespace()
 
     def _build_turn_namespace(self) -> Dict[str, Any]:
@@ -317,11 +351,24 @@ class LocalExecutor:
             return pprint.pformat(value, width=PPRINT_WIDTH, compact=False)
         return repr(value)
 
+    def _workspace_chdir_target(self) -> Optional[Path]:
+        """Target for the per-execute chdir, or None if CWD already matches (or no workspace)."""
+        target = self._chdir_target_resolved
+        if target is None:
+            return None
+        try:
+            if target == Path.cwd().resolve():
+                return None
+        except FileNotFoundError:
+            pass
+        return target
+
     async def execute(self, code: str) -> ExecutionResult:
         """Execute code using exec().
 
         Automatically displays the value of the last expression (REPL-like behavior).
-        CWD is managed at CLI level - no directory changes here.
+        When a workspace is bound, chdir to it under a process-wide lock so raw
+        Python file APIs (os.getcwd, open, Path.cwd) resolve against the workspace.
 
         Args:
             code: Python code to execute
@@ -367,19 +414,20 @@ class LocalExecutor:
             sys.stdout = stdout_capture
             sys.stderr = stderr_capture
 
-            setup_code, last_expr = self._split_code_for_last_expr(code)
+            with _locked_chdir(self._workspace_chdir_target()):
+                setup_code, last_expr = self._split_code_for_last_expr(code)
 
-            if last_expr:
-                if setup_code.strip():
-                    exec(setup_code, self.namespace)
+                if last_expr:
+                    if setup_code.strip():
+                        exec(setup_code, self.namespace)
 
-                result = eval(last_expr, self.namespace)
+                    result = eval(last_expr, self.namespace)
 
-                if result is not None:
-                    formatted = self._format_value(result)
-                    print(formatted)
-            else:
-                exec(code, self.namespace)
+                    if result is not None:
+                        formatted = self._format_value(result)
+                        print(formatted)
+                else:
+                    exec(code, self.namespace)
 
         except Exception as e:
             exec_error = f"{type(e).__name__}: {str(e)}"