tsugite-cli 0.23.0__tar.gz → 0.23.1__tar.gz

{tsugite_cli-0.23.0 → tsugite_cli-0.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tsugite-cli
-Version: 0.23.0
+Version: 0.23.1
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE

{tsugite_cli-0.23.0 → tsugite_cli-0.23.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.23.0"
+version = "0.23.1"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"

{tsugite_cli-0.23.0 → tsugite_cli-0.23.1}/tsugite/approval.py

@@ -1,9 +1,9 @@
 """Backend-driven approval primitive.
 
 A human-in-the-loop gate that pauses a turn before an action and asks the user
-to approve or deny it. It rides the same InteractionBackend used by ``ask_user``,
-so an approval surfaces on whatever adapter the user is on (CLI prompt, web SSE
-frame, etc.).
+to approve or deny it, once or persistently. It rides the same InteractionBackend
+used by ``ask_user``, so an approval surfaces on whatever adapter the user is on
+(CLI prompt, web SSE frame, etc.).
 
 Fail-closed by design: when no interactive surface is available (no backend, or a
 non-interactive scheduler/headless backend), or when the reply is unrecognized,
@@ -15,34 +15,39 @@ from typing import Literal, Optional
 
 from tsugite.interaction import NonInteractiveBackend, get_interaction_backend
 
-ApprovalDecision = Literal["approve", "deny", "always"]
+ApprovalDecision = Literal["approve", "deny", "always", "never"]
 
 APPROVE_LABEL = "Approve"
 DENY_LABEL = "Deny"
 ALWAYS_LABEL = "Always allow"
+NEVER_LABEL = "Always deny"
 
 _LABEL_TO_DECISION = {
     APPROVE_LABEL: "approve",
     DENY_LABEL: "deny",
     ALWAYS_LABEL: "always",
+    NEVER_LABEL: "never",
 }
 
 
-def request_approval(prompt: str, *, allow_always: bool = False, detail: Optional[str] = None) -> str:
+def request_approval(
+    prompt: str, *, allow_always: bool = False, allow_never: bool = False, detail: Optional[str] = None
+) -> str:
     """Ask the user to approve an action, returning an :data:`ApprovalDecision`.
 
-    Builds ``Approve``/``Deny`` options (plus ``Always allow`` when
-    ``allow_always``) and routes them through the active interaction backend as an
-    ``"approval"`` question, then maps the chosen label back to ``"approve"``,
-    ``"deny"``, or ``"always"``.
+    Builds ``Approve``/``Deny`` options (plus ``Always allow`` when ``allow_always``
+    and ``Always deny`` when ``allow_never``) and routes them through the active
+    interaction backend as an ``"approval"`` question, then maps the chosen label
+    back to a decision.
 
     Args:
         prompt: The action to approve, phrased as a question.
         allow_always: Offer an "Always allow" option (a persistent allow).
+        allow_never: Offer an "Always deny" option (a persistent deny).
         detail: Extra context appended below the prompt for the user to read.
 
     Returns:
-        One of ``"approve"``, ``"deny"``, or ``"always"``.
+        One of ``"approve"``, ``"deny"``, ``"always"``, or ``"never"``.
 
     Fail-closed: returns ``"deny"`` WITHOUT prompting when there is no backend or
     the backend is non-interactive, and for any unrecognized reply.
@@ -54,6 +59,8 @@ def request_approval(prompt: str, *, allow_always: bool = False, detail: Optiona
     options = [APPROVE_LABEL, DENY_LABEL]
     if allow_always:
         options.append(ALWAYS_LABEL)
+    if allow_never:
+        options.append(NEVER_LABEL)
 
     question = f"{prompt}\n\n{detail}" if detail else prompt
     answer = backend.ask_user(question, "approval", options)

{tsugite_cli-0.23.0 → tsugite_cli-0.23.1}/tsugite/core/record_store.py

@@ -201,6 +201,7 @@ class RecordStore:
     valid_transitions: dict[str, frozenset[str]]
     terminal_states: frozenset[str]
     transition_error_cls: type[ValueError] = ValueError
+    missing_error_cls: type[LookupError] = KeyError
 
     def __init__(self, path: Path):
         self._path = path  # legacy JSON location; migration source only
@@ -237,11 +238,18 @@ class RecordStore:
         with self._lock:
             return [r for r in self._records.values() if r.parent_session_id == parent_session_id]
 
+    def require(self, record_id: str):
+        """Raises `missing_error_cls` when no record has that id."""
+        record = self.get(record_id)
+        if record is None:
+            raise self.missing_error_cls(f"Unknown {self.record_label}: {record_id}")
+        return record
+
     def update_state(self, record_id: str, new_state: str):
         with self._lock:
             record = self._records.get(record_id)
             if record is None:
-                raise KeyError(f"Unknown {self.record_label}: {record_id}")
+                raise self.missing_error_cls(f"Unknown {self.record_label}: {record_id}")
             allowed = self.valid_transitions.get(record.state, frozenset())
             if new_state not in allowed:
                 raise self.transition_error_cls(
@@ -270,7 +278,7 @@ class RecordStore:
         with self._lock:
             record = self._records.get(record_id)
             if record is None:
-                raise KeyError(f"Unknown {self.record_label}: {record_id}")
+                raise self.missing_error_cls(f"Unknown {self.record_label}: {record_id}")
             for key, value in fields.items():
                 if not hasattr(record, key):
                     raise ValueError(f"Unknown {self.record_cls.__name__} field: {key}")

{tsugite_cli-0.23.0 → tsugite_cli-0.23.1}/tsugite/history/reconstruction.py

@@ -11,6 +11,7 @@ from datetime import datetime
 from typing import Any, Dict, Iterable, List, Optional
 from xml.sax.saxutils import escape, quoteattr
 
+from tsugite.prompt_xml import El
 from tsugite.renderer import format_prompt_ts, parse_iso_utc
 
 from .models import Event
@@ -176,6 +177,11 @@ def _event_to_message(event: Event, executed: bool = False) -> Optional[Dict[str
         return {"role": "user", "content": _format_error_xml(event.data)}
     if event.type == "delivery":
         return {"role": "user", "content": _delivery_xml(event.data, event.ts)}
+    if event.type == "error":
+        # send_failed is a notification that never left the daemon, not a turn failure.
+        if event.data.get("kind") == "send_failed":
+            return None
+        return {"role": "user", "content": _turn_failed_xml(event.data, event.ts)}
     return None
 
 
@@ -223,6 +229,22 @@ def _delivery_xml(data: Dict[str, Any], ts: Optional[datetime] = None) -> str:
     return "\n".join(parts)
 
 
+_TURN_FAILED_NOTE = (
+    "The previous attempt failed before it finished. Continue from where it stopped rather than starting over."
+)
+
+
+def _turn_failed_xml(data: Dict[str, Any], ts: datetime) -> str:
+    return El(
+        "tsugite_turn_failed",
+        [
+            El("note", [_TURN_FAILED_NOTE], inline=True),
+            El("error", [data.get("error")], inline=True),
+        ],
+        {"ts": _format_event_ts(ts)},
+    ).render()
+
+
 def _format_error_xml(data: Dict[str, Any]) -> str:
     reason = data.get("reason", "")
     msg = (

{tsugite_cli-0.23.0 → tsugite_cli-0.23.1}/tsugite/permissions.py

@@ -3,23 +3,26 @@
 Merges two YAML sources, the same way hooks does:
 
 1. ``runtime_path``: a mutable ``permissions.yaml`` next to ``daemon.yaml``.
-   "Always allow" decisions append here, so they survive a restart.
+   "Always allow" and "Always deny" decisions append here, so they survive a restart.
 2. ``workspace_dir``: an optional, read-only ``<workspace_dir>/.tsugite/permissions.yaml``,
    hand-authored per agent (exactly like ``.tsugite/hooks.yaml``). The store never
    writes it.
 
-``is_allowed`` is the union of both files. ``allow`` only ever writes the runtime
+``is_listed`` is the union of both files. ``add`` only ever writes the runtime
 file, atomically, preserving every unrelated section.
 
-The file groups allowlists by section, e.g.::
+The file groups lists by section, e.g.::
 
     web:
       fetch_allowlist:
         - example.com
+      fetch_denylist:
+        - ads.example.com
 
-The generic ``is_allowed(section, key)`` / ``allow(section, key)`` address a list
-by dotted path (``"web.fetch_allowlist"``). The ``web_fetch_*`` wrappers hide that
-layout so callers stay decoupled from it.
+The generic ``is_listed(section, key)`` / ``add(section, key)`` address a list by
+dotted path (``"web.fetch_allowlist"``). The ``web_fetch_*`` wrappers hide that
+layout so callers stay decoupled from it. The store applies no precedence between
+lists. The caller decides.
 """
 
 import contextvars
@@ -31,6 +34,7 @@ import yaml
 from tsugite.utils import atomic_write_text
 
 WEB_FETCH_ALLOWLIST = "web.fetch_allowlist"
+WEB_FETCH_DENYLIST = "web.fetch_denylist"
 
 
 def _load_yaml_mapping(path: Optional[Path]) -> dict:
@@ -70,20 +74,20 @@ def _atomic_write_yaml(path: Path, data: dict) -> None:
 
 
 class Permissions:
-    """Union of a mutable runtime allowlist and a read-only workspace allowlist."""
+    """Union of a mutable runtime permissions file and a read-only workspace one."""
 
     def __init__(self, runtime_path: Path, workspace_dir: Optional[Path] = None):
         self.runtime_path = Path(runtime_path)
         self._workspace_path = (Path(workspace_dir) / ".tsugite" / "permissions.yaml") if workspace_dir else None
 
-    def is_allowed(self, section: str, key: str) -> bool:
+    def is_listed(self, section: str, key: str) -> bool:
         """True if ``key`` is listed at dotted ``section`` in EITHER source."""
         parts = section.split(".")
         return key in _get_list(_load_yaml_mapping(self.runtime_path), parts) or key in _get_list(
             _load_yaml_mapping(self._workspace_path), parts
         )
 
-    def allow(self, section: str, key: str) -> None:
+    def add(self, section: str, key: str) -> None:
         """Append ``key`` to the RUNTIME file's list at dotted ``section``.
 
         Only ever touches the runtime file (never the workspace file), writes
@@ -102,11 +106,19 @@ class Permissions:
 
     def web_fetch_allowed(self, domain: str) -> bool:
         """True if ``domain`` is on the web fetch allowlist (either source)."""
-        return self.is_allowed(WEB_FETCH_ALLOWLIST, domain.lower())
+        return self.is_listed(WEB_FETCH_ALLOWLIST, domain.lower())
 
     def web_fetch_allow(self, domain: str) -> None:
         """Persist ``domain`` to the runtime web fetch allowlist."""
-        self.allow(WEB_FETCH_ALLOWLIST, domain.lower())
+        self.add(WEB_FETCH_ALLOWLIST, domain.lower())
+
+    def web_fetch_denied(self, domain: str) -> bool:
+        """True if ``domain`` is on the web fetch denylist (either source)."""
+        return self.is_listed(WEB_FETCH_DENYLIST, domain.lower())
+
+    def web_fetch_deny(self, domain: str) -> None:
+        """Persist ``domain`` to the runtime web fetch denylist."""
+        self.add(WEB_FETCH_DENYLIST, domain.lower())
 
 
 _permissions_var: contextvars.ContextVar[Optional[Permissions]] = contextvars.ContextVar("permissions", default=None)

{tsugite_cli-0.23.0 → tsugite_cli-0.23.1}/tsugite/tools/http.py

@@ -18,6 +18,11 @@ _WEB_EXTRA_HINT = "Install it with: pip install 'tsugite-cli[web]'"
 # reach anything the original request couldn't.
 _MAX_REDIRECTS = 5
 
+# readability emits a near-empty node when it finds no article. An extraction that is
+# both short and a sliver of the whole page means extraction failed, not a short article.
+_MIN_ARTICLE_CHARS = 200
+_ARTICLE_PAGE_RATIO = 10
+
 
 def _extract_article(html: str) -> str:
     """Extract the main article body from HTML using readability (optional dep)."""
@@ -150,9 +155,21 @@ def fetch_text(
     if "text/html" not in content_type or (not strip_html and not extract_article):
         return text
 
-    if extract_article:
-        text = _extract_article(text)
-    return convert_html_to_markdown(text)
+    if not extract_article:
+        return convert_html_to_markdown(text)
+
+    article = convert_html_to_markdown(_extract_article(text))
+    article_len = len(article.strip())
+    if article_len >= _MIN_ARTICLE_CHARS:
+        return article
+
+    page = convert_html_to_markdown(text)
+    page_len = len(page.strip())
+    if not page_len:
+        raise RuntimeError(f"{url} has no readable text; the page is likely rendered client-side")
+    if article_len * _ARTICLE_PAGE_RATIO < page_len:
+        return page
+    return article
 
 
 # No sensitive_args: the built-in key rules already redact Authorization,