claude-code-tools 1.29.1__tar.gz → 1.29.2__tar.gz

{claude_code_tools-1.29.1 → claude_code_tools-1.29.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-tools
-Version: 1.29.1
+Version: 1.29.2
 Summary: Collection of tools for working with Claude Code
 License-File: LICENSE
 Requires-Python: >=3.11

{claude_code_tools-1.29.1 → claude_code_tools-1.29.2}/claude_code_tools/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Tools - Collection of utilities for Claude Code."""
 
-__version__ = "1.29.1"
+__version__ = "1.29.2"

{claude_code_tools-1.29.1 → claude_code_tools-1.29.2}/claude_code_tools/agent_tunnel/config.py

@@ -104,6 +104,10 @@ class MattermostConfig:
     allowed_user_ids: list[str] = field(default_factory=list)
     # false only for a self-signed test server.
     verify_tls: bool = True
+    # Handle answered when a teammate just @-mentions the bot without naming
+    # a handle ("@bot how does X work?"). Empty = use the only shared session
+    # when exactly one is live, else ask which.
+    default_handle: str = ""
 
 
 @dataclass
@@ -385,6 +389,10 @@ respond_to_dms = false
 # channel_ids = []        # 26-char channel ids
 # allowed_user_ids = []   # empty = anyone in the watched channels
 # verify_tls = true
+# Handle answered when someone just @-mentions the bot without naming one
+# ("@bot how does X work?"). Unset = the only shared session when exactly
+# one is live, else the bot asks which.
+# default_handle = ""
 
 [claude]
 binary = "claude"

{claude_code_tools-1.29.1 → claude_code_tools-1.29.2}/claude_code_tools/agent_tunnel/mattermost_bot.py

@@ -141,11 +141,23 @@ def parse_posted(event: dict[str, Any]) -> Optional[MMPost]:
     )
 
 
+def resolve_default_handle(cfg: TunnelConfig, live: Sequence[str]) -> str:
+    """Handle to answer for a bare ``@bot`` mention.
+
+    The configured ``default_handle`` wins. With none set, a single shared
+    session is unambiguous; with several, the bot asks which one.
+    """
+    if cfg.mattermost.default_handle:
+        return cfg.mattermost.default_handle
+    return live[0] if len(live) == 1 else ""
+
+
 @dataclass
 class Route:
     """What the bot should do with one post."""
 
-    action: str  # ignore | list | open | unknown_handle | followup | close
+    # ignore | list | open | unknown_handle | which_handle | followup | close
+    action: str
     thread_key: str = ""
     root_id: str = ""
     handle: str = ""
@@ -161,6 +173,7 @@ def route_post(
     allowed_user_ids: Sequence[str],
     is_bound: Callable[[str], bool],
     handle_live: Callable[[str], bool],
+    default_handle: str = "",
 ) -> Route:
     """Decide what to do with a post (pure; no I/O).
 
@@ -172,6 +185,8 @@ def route_post(
         allowed_user_ids: If non-empty, only these users are answered.
         is_bound: Whether a thread key is bound to a session.
         handle_live: Whether a handle is currently shared.
+        default_handle: Handle to use when the bot is @-mentioned without
+            one (see ``resolve_default_handle``); "" = ask which.
 
     Returns:
         The routing decision.
@@ -194,7 +209,18 @@ def route_post(
     if post.root_id:
         key = f"mm:{post.root_id}"
         if not is_bound(key):
-            return ignore
+            # Not our thread yet. Teammates still address the bot inside one
+            # (e.g. answering its "which session?" question), so an explicit
+            # handle or @bot mention opens a binding on that root; anything
+            # else stays ignored.
+            return _open_route(
+                text,
+                post_id=post.root_id,
+                bot_username=bot_username,
+                handle_live=handle_live,
+                default_handle=default_handle,
+                complain_unknown=False,
+            )
         # A reply that opens with @someone-else (or @all/@channel/@here) is
         # teammates talking among themselves. A leading @bot is stripped.
         who = leading_mention(text)
@@ -208,21 +234,74 @@ def route_post(
             return Route("close", thread_key=key, root_id=post.root_id)
         return Route("followup", thread_key=key, root_id=post.root_id, text=text)
 
+    return _open_route(
+        text,
+        post_id=post.id,
+        bot_username=bot_username,
+        handle_live=handle_live,
+        default_handle=default_handle,
+    )
+
+
+def _open_route(
+    text: str,
+    *,
+    post_id: str,
+    bot_username: str,
+    handle_live: Callable[[str], bool],
+    default_handle: str,
+    complain_unknown: bool = True,
+) -> Route:
+    """Route a message that may open a thread on ``post_id`` (pure).
+
+    Used for a root post and for a message inside a thread the bot has not
+    bound yet: both are "someone addressing the bot in the channel".
+    ``complain_unknown`` is off in the latter case, so ordinary chatter
+    there stays unanswered.
+    """
+    ignore = Route("ignore")
+    # An @bot mention is how a teammate naturally addresses the bot. Strip
+    # it; whatever follows is the question (a handle may still lead it).
+    mentioned = False
+    who = leading_mention(text)
+    if who is not None:
+        if who in BROADCAST_MENTIONS or who != bot_username.lower():
+            return ignore  # teammates talking to each other
+        mentioned = True
+        text = _MENTION_RE.sub("", text.lstrip(), count=1).strip()
+
     if is_list_command(text):
-        return Route("list", root_id=post.id)
-    token, _, remainder = text.partition(" ")
-    handle = token.strip().lower()
+        return Route("list", root_id=post_id)
+    # Split on ANY whitespace: a handle followed by a newline is still a
+    # handle, and must not fall through to the default.
+    parts = text.split(None, 1)
+    handle = parts[0].strip().lower() if parts else ""
+    remainder = parts[1].strip() if len(parts) > 1 else ""
     if handle_live(handle):
         return Route(
             "open",
-            thread_key=f"mm:{post.id}",
-            root_id=post.id,
+            thread_key=f"mm:{post_id}",
+            root_id=post_id,
             handle=handle,
-            text=remainder.strip(),
+            text=remainder,
         )
-    # Only complain if it clearly looks like a handle attempt.
-    if HANDLE_RE.match(handle) and not remainder:
-        return Route("unknown_handle", root_id=post.id, handle=handle)
+    if mentioned:
+        # Addressed to the bot but no handle named: answer the default one,
+        # but only while it is actually shared.
+        if not default_handle or not handle_live(default_handle):
+            return Route("which_handle", root_id=post_id)
+        return Route(
+            "open",
+            thread_key=f"mm:{post_id}",
+            root_id=post_id,
+            handle=default_handle,
+            text=text,
+        )
+    # Only complain if it clearly looks like a handle attempt — and never
+    # inside someone else's thread, where a one-word reply ("thanks") would
+    # otherwise draw a "no live session" answer.
+    if complain_unknown and HANDLE_RE.match(handle) and not remainder:
+        return Route("unknown_handle", root_id=post_id, handle=handle)
     return ignore
 
 
@@ -553,6 +632,9 @@ class _Router:
             allowed_user_ids=self.cfg.mattermost.allowed_user_ids,
             is_bound=lambda key: relay.store.get(key) is not None,
             handle_live=lambda h: self.registry.get(h) is not None,
+            default_handle=resolve_default_handle(
+                self.cfg, [r.handle for r in self.registry.active()]
+            ),
         )
         if route.action == "ignore":
             return
@@ -560,6 +642,13 @@ class _Router:
         sender = post.sender or "A teammate"
         if route.action == "list":
             await dest.send(relay.handles_text())
+        elif route.action == "which_handle":
+            live = self.registry.active()
+            example = live[0].handle if live else "handle"
+            await dest.send(
+                "Which session should I ask? Put its handle first, e.g. "
+                f"`{example} your question`.\n\n" + relay.handles_text()
+            )
         elif route.action == "unknown_handle":
             await dest.send(
                 f"No live session for handle `{route.handle}`. "

{claude_code_tools-1.29.1 → claude_code_tools-1.29.2}/docs/agent-tunnel-spec.md

@@ -236,6 +236,14 @@ Daemon + core — `claude_code_tools/agent_tunnel/`:
 Mattermost routes the same way, with Mattermost's thread model: a root post
 `\<handle\> [question]` in a watched channel (26-char `channel_ids`) opens a
 thread keyed `mm:<root post id>`, and the bot answers as replies under it.
+A root post that simply **@-mentions the bot** works too — the mention is
+stripped and what follows is the question, answered against
+`[mattermost] default_handle` (unset: the only shared session when exactly
+one is live, else the bot replies asking which handle to use). A handle may
+still lead the question after the mention.
+A message inside a thread the bot has NOT bound is routed the same way as a
+root post (so a teammate can answer the bot's "which session?" question
+in place); anything else there is left alone.
 Replies in a bound thread are follow-ups; a reply opening with
 `@someone-else`, `@all`, `@channel` or `@here` is side-chat and ignored, and
 a leading `@bot` is stripped. `!list`/`!handles` and `!done`/`!close`/`!end`

{claude_code_tools-1.29.1 → claude_code_tools-1.29.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-code-tools"
-version = "1.29.1"
+version = "1.29.2"
 description = "Collection of tools for working with Claude Code"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -113,7 +113,7 @@ markers = [
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "1.29.1"
+version = "1.29.2"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:version",