Fix markup bug and simplify wildcard detection logic

- Fix: Escape patterns and keys using Markup.Escape() to prevent Spectre.Console markup interpretation
- Fix: Apply escaping to all user-provided strings that appear in markup (patterns, keys, paths)
- Simplify: Remove smart detection logic - --regex flag is the sole determinant
- Update: Tests to reflect simplified detection logic (wildcards detected regardless of regex syntax)

The --regex flag takes precedence over automatic wildcard detection, so we don't need
to check for regex-specific syntax in IsWildcardPattern(). This makes the logic clearer
and more predictable.

Author: nickprotop

COMMANDS.md

@@ -163,7 +163,8 @@ Summary Table:
 
 **Modes:**
 - **Exact match (default):** View a single specific key
-- **Regex mode (with --regex):** View all keys matching a pattern
+- **Wildcard mode (automatic):** Use `*` and `?` for simple pattern matching
+- **Regex mode (with --regex):** View all keys matching a regex pattern
 
 **Examples:**
 
@@ -182,6 +183,40 @@ lrm view SaveButton --format json
 lrm view SaveButton --format simple
 ```
 
+**Wildcard Patterns (Automatic Detection):**
+```bash
+# View all Error keys (App.* → App followed by anything)
+lrm view "Error.*"
+
+# View all keys ending with .Text
+lrm view "*.Text"
+
+# View all Button keys
+lrm view "Button.*"
+
+# View all keys (match everything)
+lrm view "*"
+
+# View numbered items with single digit (Item1, Item2, etc.)
+lrm view "Item?"
+
+# View keys with exactly 4 characters
+lrm view "????"
+
+# View all keys containing "Error" anywhere
+lrm view "*Error*"
+
+# Combine wildcards: keys starting with App and ending with Text
+lrm view "App.*Text"
+
+# Escape wildcards to match literal * or ?
+lrm view "Special\*Key"  # Matches literal asterisk
+lrm view "Test\?Value"   # Matches literal question mark
+
+# With sorting and limit
+lrm view "Button.*" --sort --limit 10
+```
+
 **Multiple Keys (Regex Pattern):**
 ```bash
 # View all Error keys
@@ -209,6 +244,22 @@ lrm view ".*Label.*" --regex --limit 50
 lrm view "Error\..*" --regex --format json
 ```
 
+**Wildcards vs Regex:**
+
+Wildcards are simpler and more intuitive for most users:
+- `*` matches zero or more characters (like `.*` in regex)
+- `?` matches exactly one character (like `.` in regex)
+- Automatically detected - no flag needed
+- Special regex chars are escaped automatically
+
+Use explicit `--regex` when you need:
+- Alternation: `(Error|Warning)\..*`
+- Character classes: `Item[0-9]+`
+- Anchors: `^Start` or `End$`
+- Quantifiers: `Item[0-9]{2,4}`
+
+The tool automatically detects wildcards if the pattern contains `*` or `?` but doesn't have regex-specific syntax like `^`, `$`, `[`, `(`, `+`, or `|`.
+
 **Output formats:**
 
 **Table (single key):**
@@ -225,9 +276,9 @@ Key: SaveButton
 Present in 2/2 language(s), 0 empty value(s)
 ```
 
-**Table (multiple keys with regex):**
+**Table (multiple keys with wildcard):**
 ```
-Pattern: Error\..*
+Pattern: Error.* (wildcard)
 Matched 3 key(s)
 
 ┌───────────────────┬──────────────┬─────────────────┐

Commands/ViewCommand.cs

@@ -74,7 +74,7 @@ public override int Execute(CommandContext context, Settings settings, Cancellat
             var format = settings.GetOutputFormat();
             if (format == OutputFormat.Table)
             {
-                AnsiConsole.MarkupLine($"[blue]Scanning:[/] {resourcePath}");
+                AnsiConsole.MarkupLine($"[blue]Scanning:[/] {Markup.Escape(resourcePath)}");
                 AnsiConsole.WriteLine();
             }
 
@@ -116,6 +116,16 @@ public override int Execute(CommandContext context, Settings settings, Cancellat
 
             // Find matching keys
             List<string> matchedKeys;
+            bool usedWildcards = false;
+            string originalPattern = settings.Key;
+
+            // Auto-detect and convert wildcard patterns to regex
+            if (!settings.UseRegex && IsWildcardPattern(settings.Key))
+            {
+                settings.Key = ConvertWildcardToRegex(settings.Key);
+                settings.UseRegex = true;
+                usedWildcards = true;
+            }
 
             if (settings.UseRegex)
             {
@@ -149,7 +159,7 @@ public override int Execute(CommandContext context, Settings settings, Cancellat
                 var existingEntry = defaultFile.Entries.FirstOrDefault(e => e.Key == settings.Key);
                 if (existingEntry == null)
                 {
-                    AnsiConsole.MarkupLine($"[red]✗ Key '{settings.Key}' not found![/]");
+                    AnsiConsole.MarkupLine($"[red]✗ Key '{Markup.Escape(settings.Key)}' not found![/]");
                     return 1;
                 }
                 matchedKeys = new List<string> { settings.Key };
@@ -178,23 +188,25 @@ public override int Execute(CommandContext context, Settings settings, Cancellat
             // Check if we have any matches
             if (matchedKeys.Count == 0)
             {
-                var patternType = settings.UseRegex ? "pattern" : "key";
-                AnsiConsole.MarkupLine($"[red]✗ No keys match {patternType} '{settings.Key}'[/]");
+                var patternType = usedWildcards ? "wildcard" : (settings.UseRegex ? "pattern" : "key");
+                var displayPattern = usedWildcards ? originalPattern : settings.Key;
+                // Escape pattern to prevent Spectre.Console markup interpretation
+                AnsiConsole.MarkupLine($"[red]✗ No keys match {patternType} '{Markup.Escape(displayPattern)}'[/]");
                 return 1;
             }
 
             // Display based on format
             switch (format)
             {
                 case OutputFormat.Json:
-                    DisplayJson(matchedKeys, resourceFiles, settings.ShowComments, settings);
+                    DisplayJson(matchedKeys, resourceFiles, settings.ShowComments, settings, usedWildcards, originalPattern);
                     break;
                 case OutputFormat.Simple:
-                    DisplaySimple(matchedKeys, resourceFiles, settings.ShowComments, settings);
+                    DisplaySimple(matchedKeys, resourceFiles, settings.ShowComments, settings, usedWildcards, originalPattern);
                     break;
                 case OutputFormat.Table:
                 default:
-                    DisplayTable(matchedKeys, resourceFiles, settings.ShowComments, settings);
+                    DisplayTable(matchedKeys, resourceFiles, settings.ShowComments, settings, usedWildcards, originalPattern);
                     break;
             }
 
@@ -221,7 +233,7 @@ private void DisplayConfigNotice(Settings settings)
         }
     }
 
-    private void DisplayTable(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings)
+    private void DisplayTable(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings, bool usedWildcards, string originalPattern)
     {
         DisplayConfigNotice(settings);
 
@@ -233,13 +245,13 @@ private void DisplayTable(List<string> keys, List<Core.Models.ResourceFile> reso
         else
         {
             // Multiple keys - new grouped format
-            DisplayMultipleKeysTable(keys, resourceFiles, showComments, settings);
+            DisplayMultipleKeysTable(keys, resourceFiles, showComments, settings, usedWildcards, originalPattern);
         }
     }
 
     private void DisplaySingleKeyTable(string key, List<Core.Models.ResourceFile> resourceFiles, bool showComments)
     {
-        AnsiConsole.MarkupLine($"[yellow]Key:[/] [bold]{key}[/]");
+        AnsiConsole.MarkupLine($"[yellow]Key:[/] [bold]{Markup.Escape(key)}[/]");
         AnsiConsole.WriteLine();
 
         var table = new Table();
@@ -303,9 +315,24 @@ private void DisplaySingleKeyTable(string key, List<Core.Models.ResourceFile> re
         AnsiConsole.MarkupLine($"[dim]Present in {present}/{total} language(s), {empty} empty value(s)[/]");
     }
 
-    private void DisplayMultipleKeysTable(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings)
+    private void DisplayMultipleKeysTable(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings, bool usedWildcards, string originalPattern)
     {
-        var patternDisplay = settings.UseRegex ? $"Pattern: {settings.Key}" : $"Keys: {keys.Count}";
+        string patternDisplay;
+        if (usedWildcards)
+        {
+            // Escape pattern to prevent Spectre.Console markup interpretation
+            patternDisplay = $"Pattern: {Markup.Escape(originalPattern)} [dim](wildcard)[/]";
+        }
+        else if (settings.UseRegex)
+        {
+            // Escape pattern to prevent Spectre.Console markup interpretation
+            patternDisplay = $"Pattern: {Markup.Escape(originalPattern)} [dim](regex)[/]";
+        }
+        else
+        {
+            patternDisplay = $"Keys: {keys.Count}";
+        }
+
         AnsiConsole.MarkupLine($"[yellow]{patternDisplay}[/]");
         AnsiConsole.MarkupLine($"[dim]Matched {keys.Count} key(s)[/]");
         AnsiConsole.WriteLine();
@@ -353,7 +380,7 @@ private void DisplayMultipleKeysTable(List<string> keys, List<Core.Models.Resour
         AnsiConsole.MarkupLine($"[dim]Showing {keys.Count} key(s) across {resourceFiles.Count} language(s)[/]");
     }
 
-    private void DisplayJson(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings)
+    private void DisplayJson(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings, bool usedWildcards, string originalPattern)
     {
         if (keys.Count == 1)
         {
@@ -363,7 +390,7 @@ private void DisplayJson(List<string> keys, List<Core.Models.ResourceFile> resou
         else
         {
             // Multiple keys - array format
-            DisplayMultipleKeysJson(keys, resourceFiles, showComments, settings);
+            DisplayMultipleKeysJson(keys, resourceFiles, showComments, settings, usedWildcards, originalPattern);
         }
     }
 
@@ -399,7 +426,7 @@ private void DisplaySingleKeyJson(string key, List<Core.Models.ResourceFile> res
         Console.WriteLine(OutputFormatter.FormatJson(output));
     }
 
-    private void DisplayMultipleKeysJson(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings)
+    private void DisplayMultipleKeysJson(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings, bool usedWildcards, string originalPattern)
     {
         var keyObjects = new List<object>();
 
@@ -434,15 +461,16 @@ private void DisplayMultipleKeysJson(List<string> keys, List<Core.Models.Resourc
 
         var output = new
         {
-            pattern = settings.UseRegex ? settings.Key : (string?)null,
+            pattern = settings.UseRegex || usedWildcards ? originalPattern : (string?)null,
+            patternType = usedWildcards ? "wildcard" : (settings.UseRegex ? "regex" : (string?)null),
             matchCount = keys.Count,
             keys = keyObjects
         };
 
         Console.WriteLine(OutputFormatter.FormatJson(output));
     }
 
-    private void DisplaySimple(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings)
+    private void DisplaySimple(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings, bool usedWildcards, string originalPattern)
     {
         if (keys.Count == 1)
         {
@@ -452,7 +480,7 @@ private void DisplaySimple(List<string> keys, List<Core.Models.ResourceFile> res
         else
         {
             // Multiple keys
-            DisplayMultipleKeysSimple(keys, resourceFiles, showComments, settings);
+            DisplayMultipleKeysSimple(keys, resourceFiles, showComments, settings, usedWildcards, originalPattern);
         }
     }
 
@@ -476,9 +504,22 @@ private void DisplaySingleKeySimple(string key, List<Core.Models.ResourceFile> r
         }
     }
 
-    private void DisplayMultipleKeysSimple(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings)
+    private void DisplayMultipleKeysSimple(List<string> keys, List<Core.Models.ResourceFile> resourceFiles, bool showComments, Settings settings, bool usedWildcards, string originalPattern)
     {
-        var patternDisplay = settings.UseRegex ? $"Pattern: {settings.Key}" : $"Keys: {keys.Count}";
+        string patternDisplay;
+        if (usedWildcards)
+        {
+            patternDisplay = $"Pattern: {originalPattern} (wildcard)";
+        }
+        else if (settings.UseRegex)
+        {
+            patternDisplay = $"Pattern: {originalPattern} (regex)";
+        }
+        else
+        {
+            patternDisplay = $"Keys: {keys.Count}";
+        }
+
         Console.WriteLine(patternDisplay);
         Console.WriteLine($"Matched {keys.Count} key(s)");
         Console.WriteLine();
@@ -511,4 +552,84 @@ private void DisplayMultipleKeysSimple(List<string> keys, List<Core.Models.Resou
             }
         }
     }
+
+    /// <summary>
+    /// Detects if a pattern contains wildcard characters (* or ?) that should be converted to regex.
+    /// Handles backslash escaping for literal wildcard characters.
+    /// </summary>
+    internal static bool IsWildcardPattern(string pattern)
+    {
+        // Simply check if pattern contains unescaped wildcards
+        // The --regex flag takes precedence, so we don't need "smart" detection
+        for (int i = 0; i < pattern.Length; i++)
+        {
+            char c = pattern[i];
+
+            // Check if this is an escaped character
+            if (c == '\\' && i + 1 < pattern.Length)
+            {
+                i++; // Skip next character
+                continue;
+            }
+
+            // Check for unescaped wildcards
+            if (c == '*' || c == '?')
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Converts a wildcard pattern to a regex pattern.
+    /// Supports:
+    /// - * for zero or more characters
+    /// - ? for exactly one character
+    /// - \* and \? for literal asterisk and question mark
+    /// </summary>
+    internal static string ConvertWildcardToRegex(string wildcardPattern)
+    {
+        var result = new System.Text.StringBuilder();
+
+        for (int i = 0; i < wildcardPattern.Length; i++)
+        {
+            char c = wildcardPattern[i];
+
+            if (c == '\\' && i + 1 < wildcardPattern.Length)
+            {
+                char next = wildcardPattern[i + 1];
+                if (next == '*' || next == '?')
+                {
+                    // Escaped wildcard - treat as literal
+                    result.Append('\\').Append(next);
+                    i++; // Skip next character
+                }
+                else
+                {
+                    // Other escaped character - escape for regex
+                    result.Append(Regex.Escape(c.ToString()));
+                }
+            }
+            else if (c == '*')
+            {
+                // Wildcard: match any characters
+                result.Append(".*");
+            }
+            else if (c == '?')
+            {
+                // Wildcard: match single character
+                result.Append('.');
+            }
+            else
+            {
+                // Regular character - escape for regex
+                result.Append(Regex.Escape(c.ToString()));
+            }
+        }
+
+        // Anchor to match entire string
+        return "^" + result.ToString() + "$";
+    }
 }