From b5fe6276d8ab374d6ce9aafce77e528ed0380037 Mon Sep 17 00:00:00 2001 From: Nixie Date: Wed, 5 Aug 2026 11:06:51 +0000 Subject: [PATCH 1/2] fix(slack): render <@user>, <@subteam^group> and <#channel> mentions as rich-text elements The Block Kit converter parsed bold/italic/code/links but passed Slack-native mention syntax (<@U...>, <@subteam^S...>, <#C...>) through as literal text, because rich_text blocks render their own elements and ignore the mrkdwn Text fallback on modern clients. Agents therefore had no way to mention users in outbound Slack messages. Add mention patterns to the inline parser emitting RichTextUser, RichTextUserGroup and RichTextChannel (all present in SlackNet 0.17.x), including the labeled forms (<@U123|name>, <#C123|general>). Covers paragraphs, list items and quotes via the shared ParseInlineElements. Adds 5 converter tests: user, labeled user, user group, channel, and user mention inside a bullet list item. --- .../Channels/SlackBlockConverterTests.cs | 67 ++++++++++++++++++- .../SlackBlockConverter.cs | 29 +++++++- 2 files changed, 94 insertions(+), 2 deletions(-) diff --git a/src/Netclaw.Actors.Tests/Channels/SlackBlockConverterTests.cs b/src/Netclaw.Actors.Tests/Channels/SlackBlockConverterTests.cs index b2428ba1b..87f7ac4df 100644 --- a/src/Netclaw.Actors.Tests/Channels/SlackBlockConverterTests.cs +++ b/src/Netclaw.Actors.Tests/Channels/SlackBlockConverterTests.cs @@ -1,4 +1,4 @@ -// ----------------------------------------------------------------------- +// ----------------------------------------------------------------------- // // Copyright (C) 2026 - 2026 Petabridge, LLC // @@ -416,4 +416,69 @@ public void BoldAndItalicNested_HandledCorrectly() Assert.NotNull(styled); Assert.Equal("bold and italic", styled.Text); } + + [Fact] + public void UserMention_ProducesRichTextUser() + { + var blocks = SlackBlockConverter.Convert("Ping <@U01SU57E553> when ready"); + + var rtb = Assert.Single(blocks.OfType()); + var section = Assert.Single(rtb.Elements.OfType()); + + var user = Assert.Single(section.Elements.OfType()); + Assert.Equal("U01SU57E553", user.UserId); + + var texts = section.Elements.OfType().ToList(); + Assert.Equal("Ping ", texts[0].Text); + Assert.Equal(" when ready", texts[1].Text); + } + + [Fact] + public void UserMention_WithLabel_ProducesRichTextUser() + { + var blocks = SlackBlockConverter.Convert("Thanks <@U01SU57E553|david>!"); + + var rtb = Assert.Single(blocks.OfType()); + var section = Assert.Single(rtb.Elements.OfType()); + + var user = Assert.Single(section.Elements.OfType()); + Assert.Equal("U01SU57E553", user.UserId); + } + + [Fact] + public void UserGroupMention_ProducesRichTextUserGroup() + { + var blocks = SlackBlockConverter.Convert("Heads up <@subteam^S0123ABC>"); + + var rtb = Assert.Single(blocks.OfType()); + var section = Assert.Single(rtb.Elements.OfType()); + + var group = Assert.Single(section.Elements.OfType()); + Assert.Equal("subteam^S0123ABC", group.UserGroupId); + } + + [Fact] + public void ChannelMention_ProducesRichTextChannel() + { + var blocks = SlackBlockConverter.Convert("Posted in <#C0AM51E342X> already"); + + var rtb = Assert.Single(blocks.OfType()); + var section = Assert.Single(rtb.Elements.OfType()); + + var channel = Assert.Single(section.Elements.OfType()); + Assert.Equal("C0AM51E342X", channel.ChannelId); + } + + [Fact] + public void UserMention_InListItem_ProducesRichTextUser() + { + var blocks = SlackBlockConverter.Convert("- David: approve <@U01SU57E553>"); + + var rtb = Assert.Single(blocks.OfType()); + var list = Assert.Single(rtb.Elements.OfType()); + var item = list.Elements[0]; + + var user = Assert.Single(item.Elements.OfType()); + Assert.Equal("U01SU57E553", user.UserId); + } } diff --git a/src/Netclaw.Channels.Slack/SlackBlockConverter.cs b/src/Netclaw.Channels.Slack/SlackBlockConverter.cs index e6001295e..e6fadc472 100644 --- a/src/Netclaw.Channels.Slack/SlackBlockConverter.cs +++ b/src/Netclaw.Channels.Slack/SlackBlockConverter.cs @@ -1,4 +1,4 @@ -// ----------------------------------------------------------------------- +// ----------------------------------------------------------------------- // // Copyright (C) 2026 - 2026 Petabridge, LLC // @@ -277,6 +277,20 @@ private static (int Index, int Length, RichTextSectionElement? Element, string? : new RichTextLink { Url = url }; }); + // Slack-native mentions passed through by the agent: <@U...> + // user, <@subteam^S...> user group, <#C...> channel. Without + // explicit rich-text elements the Block Kit surface renders + // the syntax as literal text (the mrkdwn Text fallback handles + // them natively, but blocks win on every modern client). + TryMatch(UserMentionRegex(), text, ref best, (m) => + new RichTextUser { UserId = m.Groups[1].Value }); + + TryMatch(UserGroupMentionRegex(), text, ref best, (m) => + new RichTextUserGroup { UserGroupId = m.Groups[1].Value }); + + TryMatch(ChannelMentionRegex(), text, ref best, (m) => + new RichTextChannel { ChannelId = m.Groups[1].Value }); + if (best.Element is null) return (0, 0, null, null); @@ -357,4 +371,17 @@ private static string StripInlineMarkdown(string text) // Ordered list prefix: 1. or 2. etc. [GeneratedRegex(@"^\d+\.\s")] private static partial Regex OrderedListPrefix(); + + // Slack user mention: <@U0123ABC> or <@W0123ABC>, optionally with a + // fallback label (<@U0123ABC|david>). + [GeneratedRegex(@"<@([UW][0-9A-Z]+)(?:\|[^>]+)?>")] + private static partial Regex UserMentionRegex(); + + // Slack user-group mention: <@subteam^S0123ABC>. + [GeneratedRegex(@"<@(subteam\^[S0-9A-Z]+)>")] + private static partial Regex UserGroupMentionRegex(); + + // Slack channel mention: <#C0123ABC>, optionally with a label. + [GeneratedRegex(@"<#(C[0-9A-Z]+)(?:\|[^>]+)?>")] + private static partial Regex ChannelMentionRegex(); } From 3766eeaf05934c4f5614dd1afcc8b23bafe4a1b4 Mon Sep 17 00:00:00 2001 From: Nixie Date: Wed, 5 Aug 2026 15:37:37 +0000 Subject: [PATCH 2/2] =?UTF-8?q?fix(slack):=20address=20review=20=E2=80=94?= =?UTF-8?q?=20bare=20usergroup=20ID,=20labeled=20usergroup,=20CGD=20channe?= =?UTF-8?q?l=20prefixes,=20restore=20BOM?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - UserGroupMentionRegex now captures the bare group ID (S...) instead of the subteam^-prefixed token; RichTextUserGroup.UserGroupId expects the ID as returned by usergroups.list. - Usergroup regex accepts the labeled form (<@subteam^S123|oncall>), matching the user and channel regexes. - Channel regex accepts C/G/D prefixes so private channels and group DMs convert too. - Restores the UTF-8 BOM the repo keeps on these files. - Tests updated (bare ID assertion) and extended (labeled usergroup, private channel): 32 SlackBlockConverterTests pass. --- .../Channels/SlackBlockConverterTests.cs | 28 +++++++++++++++++-- .../SlackBlockConverter.cs | 12 +++++--- 2 files changed, 34 insertions(+), 6 deletions(-) diff --git a/src/Netclaw.Actors.Tests/Channels/SlackBlockConverterTests.cs b/src/Netclaw.Actors.Tests/Channels/SlackBlockConverterTests.cs index 87f7ac4df..142f3488e 100644 --- a/src/Netclaw.Actors.Tests/Channels/SlackBlockConverterTests.cs +++ b/src/Netclaw.Actors.Tests/Channels/SlackBlockConverterTests.cs @@ -1,4 +1,4 @@ -// ----------------------------------------------------------------------- +// ----------------------------------------------------------------------- // // Copyright (C) 2026 - 2026 Petabridge, LLC // @@ -454,7 +454,31 @@ public void UserGroupMention_ProducesRichTextUserGroup() var section = Assert.Single(rtb.Elements.OfType()); var group = Assert.Single(section.Elements.OfType()); - Assert.Equal("subteam^S0123ABC", group.UserGroupId); + Assert.Equal("S0123ABC", group.UserGroupId); + } + + [Fact] + public void UserGroupMention_WithLabel_ProducesRichTextUserGroup() + { + var blocks = SlackBlockConverter.Convert("Escalate to <@subteam^S0123ABC|oncall> now"); + + var rtb = Assert.Single(blocks.OfType()); + var section = Assert.Single(rtb.Elements.OfType()); + + var group = Assert.Single(section.Elements.OfType()); + Assert.Equal("S0123ABC", group.UserGroupId); + } + + [Fact] + public void PrivateChannelMention_ProducesRichTextChannel() + { + var blocks = SlackBlockConverter.Convert("Also in <#G0123ABC|private-ops>"); + + var rtb = Assert.Single(blocks.OfType()); + var section = Assert.Single(rtb.Elements.OfType()); + + var channel = Assert.Single(section.Elements.OfType()); + Assert.Equal("G0123ABC", channel.ChannelId); } [Fact] diff --git a/src/Netclaw.Channels.Slack/SlackBlockConverter.cs b/src/Netclaw.Channels.Slack/SlackBlockConverter.cs index e6fadc472..ce0bc5e85 100644 --- a/src/Netclaw.Channels.Slack/SlackBlockConverter.cs +++ b/src/Netclaw.Channels.Slack/SlackBlockConverter.cs @@ -1,4 +1,4 @@ -// ----------------------------------------------------------------------- +// ----------------------------------------------------------------------- // // Copyright (C) 2026 - 2026 Petabridge, LLC // @@ -377,11 +377,15 @@ private static string StripInlineMarkdown(string text) [GeneratedRegex(@"<@([UW][0-9A-Z]+)(?:\|[^>]+)?>")] private static partial Regex UserMentionRegex(); - // Slack user-group mention: <@subteam^S0123ABC>. - [GeneratedRegex(@"<@(subteam\^[S0-9A-Z]+)>")] + // Slack user-group mention: <@subteam^S0123ABC>, optionally with a + // label (<@subteam^S0123ABC|oncall>). Captures the bare group ID — + // the rich-text usergroup element takes the ID as returned by + // usergroups.list, without the subteam^ prefix. + [GeneratedRegex(@"<@subteam\^([S0-9A-Z]+)(?:\|[^>]+)?>")] private static partial Regex UserGroupMentionRegex(); // Slack channel mention: <#C0123ABC>, optionally with a label. - [GeneratedRegex(@"<#(C[0-9A-Z]+)(?:\|[^>]+)?>")] + // C = public channel, G = private channel/group DM, D = DM. + [GeneratedRegex(@"<#([CGD][0-9A-Z]+)(?:\|[^>]+)?>")] private static partial Regex ChannelMentionRegex(); }