Merge pull request #2 from matt-richardson/add-seq-convert-filter

Add SeqConvertFilter tool for fuzzy-to-strict filter conversion

Author: willibrandon

README.md

@@ -98,10 +98,18 @@ The following tools are available through the MCP protocol:
   - Returns: Snapshot of events captured during the wait period (may be empty if no events match)
 
 - **`SignalList`** - List available signals (read-only)
-  - Parameters: 
+  - Parameters:
     - `workspace` (optional): Specific workspace to query
   - Returns: List of signals with their definitions
 
+- **`SeqConvertFilter`** - Convert fuzzy filter to strict filter expression
+  - Parameters:
+    - `fuzzyFilter` (required): Fuzzy search text (e.g., "error", "timeout")
+    - `workspace` (optional): Specific workspace to query
+  - Returns: Strict Seq filter expression for use in `SeqSearch`
+  - Use case: Help users write correct filter expressions
+  - Example: Convert "error" to a proper Seq filter expression
+
 ## Claude Desktop Integration
 
 ### Option 1: Using .NET Global Tool (Recommended)

src/SeqMcpServer/Mcp/SeqTools.cs

@@ -4,9 +4,21 @@
 using SeqMcpServer.Services;
 using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;
+using System.Text.Json.Serialization;
 
 namespace SeqMcpServer.Mcp;
 
+/// <summary>
+/// Result of converting a fuzzy filter expression to a strict Seq filter expression.
+/// </summary>
+/// <param name="StrictExpression">The strict filter expression (the original input if no conversion was needed).</param>
+/// <param name="MatchedAsText">True if Seq interpreted the input as a free-text search rather than a filter expression.</param>
+/// <param name="ReasonIfMatchedAsText">Explanation of why the input was interpreted as text, or null when it wasn't.</param>
+public sealed record SeqConvertFilterResult(
+    [property: JsonPropertyName("strictExpression")] string StrictExpression,
+    [property: JsonPropertyName("matchedAsText")] bool MatchedAsText,
+    [property: JsonPropertyName("reasonIfMatchedAsText"), JsonIgnore(Condition = JsonIgnoreCondition.Never)] string? ReasonIfMatchedAsText);
+
 /// <summary>
 /// MCP tools for interacting with Seq structured logging server.
 /// </summary>
@@ -173,4 +185,49 @@ public static async Task<List<SignalEntity>> SignalList(
             throw;
         }
     }
+
+    /// <summary>
+    /// Convert a fuzzy filter expression to a strict Seq filter expression.
+    /// </summary>
+    /// <remarks>
+    /// Seq supports both "fuzzy" filters (like typing in the UI search box) and "strict" filters
+    /// (formal filter expressions). This tool converts fuzzy filters to strict ones, helping users
+    /// write correct filter expressions. For example, "error" becomes a proper filter expression.
+    /// The result includes whether the filter was interpreted as a text search and the reason if so.
+    /// </remarks>
+    /// <param name="fac">Factory for creating Seq connections</param>
+    /// <param name="fuzzyFilter">The fuzzy filter expression to convert (e.g., "error", "timeout")</param>
+    /// <param name="workspace">Optional workspace identifier for multi-tenant scenarios</param>
+    /// <param name="ct">Cancellation token</param>
+    /// <returns>Conversion result including the strict expression and metadata about the conversion</returns>
+    [McpServerTool, Description("Convert a fuzzy filter expression to a strict Seq filter expression. Helps write correct filters for SeqSearch.")]
+    public static async Task<SeqConvertFilterResult> SeqConvertFilter(
+        SeqConnectionFactory fac,
+        [Required] string fuzzyFilter,
+        string? workspace = null,
+        CancellationToken ct = default)
+    {
+        try
+        {
+            var conn = fac.Create(workspace);
+            var result = await conn.Expressions.ToStrictAsync(fuzzyFilter, cancellationToken: ct);
+
+            if (result == null)
+            {
+                return new SeqConvertFilterResult(fuzzyFilter, false, null);
+            }
+
+            return new SeqConvertFilterResult(
+                result.StrictExpression ?? fuzzyFilter,
+                result.MatchedAsText,
+                result.ReasonIfMatchedAsText);
+        }
+        catch (Exception)
+        {
+            // Re-throw to let MCP handle the error. Unlike the list-returning tools in this
+            // file, there is no unambiguous "empty" SeqConvertFilterResult value, so cancellation
+            // also propagates rather than being swallowed.
+            throw;
+        }
+    }
 }

tests/SeqMcpServer.Tests/McpToolsIntegrationTests.cs

@@ -1,3 +1,4 @@
+using System.Text.Json;
 using DotNet.Testcontainers.Builders;
 using DotNet.Testcontainers.Containers;
 using Microsoft.Extensions.Configuration;
@@ -240,12 +241,49 @@ protected async Task MCP_Client_CanListTools_Core()
         // Act - List available tools via MCP
         var tools = await McpClient.ListToolsAsync();
 
-        // Assert - Should have our three tools
+        // Assert - Should have our four tools
         Assert.NotNull(tools);
         Assert.Contains(tools, t => t.Name == "SeqSearch");
         Assert.Contains(tools, t => t.Name == "SeqWaitForEvents");
         Assert.Contains(tools, t => t.Name == "SignalList");
-        Assert.Equal(3, tools.Count);
+        Assert.Contains(tools, t => t.Name == "SeqConvertFilter");
+        Assert.Equal(4, tools.Count);
+    }
+
+    [Theory]
+    // Bareword and invalid syntax fall back to text-match
+    [InlineData("error", "\"error\"", true)]
+    [InlineData("error timeout", "\"error timeout\"", true)]
+    // Already-strict filter expressions pass through unchanged
+    [InlineData("@Level = 'Error'", "@Level = 'Error'", false)]
+    [InlineData("Application = 'foo'", "Application = 'foo'", false)]
+    // Fuzzy-but-valid expression gets normalized (== becomes =)
+    [InlineData("User=='alice'", "User = 'alice'", false)]
+    public async Task SeqConvertFilter_ReturnsExpectedResult(string fuzzyFilter, string expectedStrict, bool expectedMatchedAsText)
+    {
+        var result = await _mcpClient!.CallToolAsync(
+            "SeqConvertFilter",
+            new Dictionary<string, object?>
+            {
+                ["fuzzyFilter"] = fuzzyFilter
+            });
+
+        Assert.NotNull(result);
+        Assert.NotNull(result.Content);
+        Assert.True(result.Content.Any());
+        Assert.False(result.IsError);
+
+        var contentJson = JsonSerializer.Serialize(result.Content.First());
+        using var outer = JsonDocument.Parse(contentJson);
+        var innerText = outer.RootElement.GetProperty("text").GetString();
+        Assert.NotNull(innerText);
+        using var inner = JsonDocument.Parse(innerText);
+
+        Assert.Equal(expectedStrict, inner.RootElement.GetProperty("strictExpression").GetString());
+        Assert.Equal(expectedMatchedAsText, inner.RootElement.GetProperty("matchedAsText").GetBoolean());
+
+        var reason = inner.RootElement.GetProperty("reasonIfMatchedAsText").GetString();
+        Assert.Equal(expectedMatchedAsText, !string.IsNullOrEmpty(reason));
     }
 
     private async Task WriteTestEventAsync(string messageTemplate, string propertyName, bool propertyValue)