CmdPal: Add history to the new run page (#40427)

_⚠️ targets #39955_

This adds history support to the new run page.

* It'll initialize the history with the history from the run dialog, if
there is any.
* Any new commands that are run, or files/dirs that are opened will also
get added to the history
* history will persist across reboots

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/FallbackExecuteItem.cs

@@ -15,10 +15,11 @@ namespace Microsoft.CmdPal.Ext.Shell;
 
 internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDisposable
 {
+    private readonly Action<string>? _addToHistory;
     private CancellationTokenSource? _cancellationTokenSource;
     private Task? _currentUpdateTask;
 
-    public FallbackExecuteItem(SettingsManager settings)
+    public FallbackExecuteItem(SettingsManager settings, Action<string>? addToHistory)
         : base(
             new NoOpCommand() { Id = "com.microsoft.run.fallback" },
             Resources.shell_command_display_title)
@@ -26,6 +27,7 @@ internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDispos
         Title = string.Empty;
         Subtitle = Properties.Resources.generic_run_command;
         Icon = Icons.RunV2Icon; // Defined in Icons.cs and contains the execute command icon.
+        _addToHistory = addToHistory;
     }
 
     public override void UpdateQuery(string query)
@@ -142,7 +144,7 @@ internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDispos
         if (exeExists)
         {
             // TODO we need to probably get rid of the settings for this provider entirely
-            var exeItem = ShellListPage.CreateExeItem(exe, args, fullExePath);
+            var exeItem = ShellListPage.CreateExeItem(exe, args, fullExePath, _addToHistory);
             Title = exeItem.Title;
             Subtitle = exeItem.Subtitle;
             Icon = exeItem.Icon;
@@ -151,7 +153,7 @@ internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDispos
         }
         else if (pathIsDir)
         {
-            var pathItem = new PathListItem(exe, query);
+            var pathItem = new PathListItem(exe, query, _addToHistory);
             Title = pathItem.Title;
             Subtitle = pathItem.Subtitle;
             Icon = pathItem.Icon;
@@ -160,7 +162,7 @@ internal sealed partial class FallbackExecuteItem : FallbackCommandItem, IDispos
         }
         else if (System.Uri.TryCreate(searchText, UriKind.Absolute, out var uri))
         {
-            Command = new OpenUrlCommand(searchText) { Result = CommandResult.Dismiss() };
+            Command = new OpenUrlWithHistoryCommand(searchText, _addToHistory) { Result = CommandResult.Dismiss() };
             Title = searchText;
         }
         else

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Helpers/ShellListPageHelpers.cs

@@ -7,7 +7,9 @@ using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CmdPal.Ext.Shell.Commands;
+using Microsoft.CmdPal.Ext.Shell.Pages;
 using Microsoft.CommandPalette.Extensions.Toolkit;
 
 namespace Microsoft.CmdPal.Ext.Shell.Helpers;
@@ -94,4 +96,80 @@ public class ShellListPageHelpers
             }
         }
     }
+
+    internal static ListItem? ListItemForCommandString(string query, Action<string>? addToHistory)
+    {
+        var li = new ListItem();
+
+        var searchText = query.Trim();
+        var expanded = Environment.ExpandEnvironmentVariables(searchText);
+        searchText = expanded;
+        if (string.IsNullOrEmpty(searchText) || string.IsNullOrWhiteSpace(searchText))
+        {
+            return null;
+        }
+
+        ShellListPage.ParseExecutableAndArgs(searchText, out var exe, out var args);
+
+        var exeExists = false;
+        var pathIsDir = false;
+        var fullExePath = string.Empty;
+
+        try
+        {
+            using var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(200));
+
+            // Use Task.Run with timeout - this will actually timeout even if the sync operations don't respond to cancellation
+            var pathResolutionTask = Task.Run(
+                () =>
+            {
+                // Don't check cancellation token here - let the Task timeout handle it
+                exeExists = ShellListPageHelpers.FileExistInPath(exe, out fullExePath);
+                pathIsDir = Directory.Exists(expanded);
+            },
+                CancellationToken.None); // Use None here since we're handling timeout differently
+
+            // Wait for either completion or timeout
+            pathResolutionTask.Wait(cts.Token);
+        }
+        catch (OperationCanceledException)
+        {
+        }
+
+        if (exeExists)
+        {
+            // TODO we need to probably get rid of the settings for this provider entirely
+            var exeItem = ShellListPage.CreateExeItem(exe, args, fullExePath, addToHistory);
+            li.Command = exeItem.Command;
+            li.Title = exeItem.Title;
+            li.Subtitle = exeItem.Subtitle;
+            li.Icon = exeItem.Icon;
+            li.MoreCommands = exeItem.MoreCommands;
+        }
+        else if (pathIsDir)
+        {
+            var pathItem = new PathListItem(exe, query, addToHistory);
+            li.Command = pathItem.Command;
+            li.Title = pathItem.Title;
+            li.Subtitle = pathItem.Subtitle;
+            li.Icon = pathItem.Icon;
+            li.MoreCommands = pathItem.MoreCommands;
+        }
+        else if (System.Uri.TryCreate(searchText, UriKind.Absolute, out var uri))
+        {
+            li.Command = new OpenUrlWithHistoryCommand(searchText) { Result = CommandResult.Dismiss() };
+            li.Title = searchText;
+        }
+        else
+        {
+            return null;
+        }
+
+        if (li != null)
+        {
+            li.TextToSuggest = searchText;
+        }
+
+        return li;
+    }
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Microsoft.CmdPal.Ext.Shell.csproj

@@ -14,6 +14,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\extensionsdk\Microsoft.CommandPalette.Extensions.Toolkit\Microsoft.CommandPalette.Extensions.Toolkit.csproj" />
+    <ProjectReference Include="..\..\Microsoft.CmdPal.Common\Microsoft.CmdPal.Common.csproj" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="System.CommandLine" />

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/OpenUrlWithHistoryCommand.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.IO;
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+namespace Microsoft.CmdPal.Ext.Shell;
+
+internal sealed partial class OpenUrlWithHistoryCommand : OpenUrlCommand
+{
+    private readonly Action<string>? _addToHistory;
+    private readonly string _url;
+
+    public OpenUrlWithHistoryCommand(string url, Action<string>? addToHistory = null)
+        : base(url)
+    {
+        _addToHistory = addToHistory;
+        _url = url;
+    }
+
+    public override CommandResult Invoke()
+    {
+        _addToHistory?.Invoke(_url);
+        var result = base.Invoke();
+        return result;
+    }
+}

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Pages/RunExeItem.cs

@@ -13,6 +13,7 @@ namespace Microsoft.CmdPal.Ext.Shell.Pages;
 internal sealed partial class RunExeItem : ListItem
 {
     private readonly Lazy<IconInfo> _icon;
+    private readonly Action<string>? _addToHistory;
 
     public override IIconInfo? Icon { get => _icon.Value; set => base.Icon = value; }
 
@@ -22,7 +23,9 @@ internal sealed partial class RunExeItem : ListItem
 
     private string _args = string.Empty;
 
-    public RunExeItem(string exe, string args, string fullExePath)
+    private string FullString => string.IsNullOrEmpty(_args) ? Exe : $"{Exe} {_args}";
+
+    public RunExeItem(string exe, string args, string fullExePath, Action<string>? addToHistory)
     {
         FullExePath = fullExePath;
         Exe = exe;
@@ -41,6 +44,8 @@ internal sealed partial class RunExeItem : ListItem
             return t.Result;
         });
 
+        _addToHistory = addToHistory;
+
         UpdateArgs(args);
 
         MoreCommands = [
@@ -89,16 +94,22 @@ internal sealed partial class RunExeItem : ListItem
 
     public void Run()
     {
+        _addToHistory?.Invoke(FullString);
+
         ShellHelpers.OpenInShell(FullExePath, _args);
     }
 
     public void RunAsAdmin()
     {
+        _addToHistory?.Invoke(FullString);
+
         ShellHelpers.OpenInShell(FullExePath, _args, runAs: ShellHelpers.ShellRunAsType.Administrator);
     }
 
     public void RunAsOther()
     {
+        _addToHistory?.Invoke(FullString);
+
         ShellHelpers.OpenInShell(FullExePath, _args, runAs: ShellHelpers.ShellRunAsType.OtherUser);
     }
 }

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/Pages/ShellListPage.cs

@@ -8,6 +8,7 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CmdPal.Common.Services;
 using Microsoft.CmdPal.Ext.Shell.Helpers;
 using Microsoft.CmdPal.Ext.Shell.Properties;
 using Microsoft.CommandPalette.Extensions;
@@ -20,7 +21,11 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
     private readonly ShellListPageHelpers _helper;
 
     private readonly List<ListItem> _topLevelItems = [];
-    private readonly List<ListItem> _historyItems = [];
+    private readonly Dictionary<string, ListItem> _historyItems = [];
+    private readonly List<ListItem> _currentHistoryItems = [];
+
+    private readonly IRunHistoryService _historyService;
+
     private RunExeItem? _exeItem;
     private List<ListItem> _pathItems = [];
     private ListItem? _uriItem;
@@ -28,13 +33,16 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
     private CancellationTokenSource? _cancellationTokenSource;
     private Task? _currentSearchTask;
 
-    public ShellListPage(SettingsManager settingsManager, bool addBuiltins = false)
+    private bool _loadedInitialHistory;
+
+    public ShellListPage(SettingsManager settingsManager, IRunHistoryService runHistoryService, bool addBuiltins = false)
     {
         Icon = Icons.RunV2Icon;
         Id = "com.microsoft.cmdpal.shell";
         Name = Resources.cmd_plugin_name;
         PlaceholderText = Resources.list_placeholder_text;
         _helper = new(settingsManager);
+        _historyService = runHistoryService;
 
         EmptyContent = new CommandItem()
         {
@@ -68,8 +76,6 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
         _cancellationTokenSource = new CancellationTokenSource();
         var cancellationToken = _cancellationTokenSource.Token;
 
-        IsLoading = true;
-
         try
         {
             // Save the latest search task
@@ -139,6 +145,10 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
             _pathItems.Clear();
             _exeItem = null;
             _uriItem = null;
+
+            _currentHistoryItems.Clear();
+            _currentHistoryItems.AddRange(_historyItems.Values);
+
             return;
         }
 
@@ -206,6 +216,7 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
             && (!exeExists || pathIsDir)
             && couldResolvePath)
         {
+            IsLoading = true;
             await CreatePathItemsAsync(expanded, searchText, cancellationToken);
         }
 
@@ -231,18 +242,53 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
             _uriItem = null;
         }
 
+        var histItemsNotInSearch =
+            _historyItems
+                .Where(kv => !kv.Key.Equals(newSearch, StringComparison.OrdinalIgnoreCase));
+        if (_exeItem != null)
+        {
+            // If we have an exe item, we want to remove it from the history items
+            histItemsNotInSearch = histItemsNotInSearch
+                .Where(kv => !kv.Value.Title.Equals(_exeItem.Title, StringComparison.OrdinalIgnoreCase));
+        }
+
+        if (_uriItem != null)
+        {
+            // If we have an uri item, we want to remove it from the history items
+            histItemsNotInSearch = histItemsNotInSearch
+                .Where(kv => !kv.Value.Title.Equals(_uriItem.Title, StringComparison.OrdinalIgnoreCase));
+        }
+
+        // Filter the history items based on the search text
+        var filterHistory = (string query, KeyValuePair<string, ListItem> pair) =>
+        {
+            // Fuzzy search on the key (command string)
+            var score = StringMatcher.FuzzySearch(query, pair.Key).Score;
+            return score;
+        };
+
+        var filteredHistory =
+            ListHelpers.FilterList<KeyValuePair<string, ListItem>>(
+                histItemsNotInSearch,
+                searchText,
+                filterHistory)
+            .Select(p => p.Value);
+
+        _currentHistoryItems.Clear();
+        _currentHistoryItems.AddRange(filteredHistory);
+
         // Final cancellation check
         cancellationToken.ThrowIfCancellationRequested();
     }
 
-    private static ListItem PathToListItem(string path, string originalPath, string args = "")
+    private static ListItem PathToListItem(string path, string originalPath, string args = "", Action<string>? addToHistory = null)
     {
-        var pathItem = new PathListItem(path, originalPath);
+        var pathItem = new PathListItem(path, originalPath, addToHistory);
 
         // Is this path an executable? If so, then make a RunExeItem
         if (IsExecutable(path))
         {
-            var exeItem = new RunExeItem(Path.GetFileName(path), args, path);
+            var exeItem = new RunExeItem(Path.GetFileName(path), args, path, addToHistory);
 
             exeItem.MoreCommands = [
             .. exeItem.MoreCommands,
@@ -255,24 +301,30 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
 
     public override IListItem[] GetItems()
     {
+        if (!_loadedInitialHistory)
+        {
+            LoadInitialHistory();
+        }
+
         var filteredTopLevel = ListHelpers.FilterList(_topLevelItems, SearchText);
         List<ListItem> uriItems = _uriItem != null ? [_uriItem] : [];
         List<ListItem> exeItems = _exeItem != null ? [_exeItem] : [];
+
         return
             exeItems
             .Concat(filteredTopLevel)
-            .Concat(_historyItems)
+            .Concat(_currentHistoryItems)
             .Concat(_pathItems)
             .Concat(uriItems)
             .ToArray();
     }
 
-    internal static RunExeItem CreateExeItem(string exe, string args, string fullExePath)
+    internal static RunExeItem CreateExeItem(string exe, string args, string fullExePath, Action<string>? addToHistory)
     {
         // PathToListItem will return a RunExeItem if it can find a executable.
         // It will ALSO add the file search commands to the RunExeItem.
-        return PathToListItem(fullExePath, exe, args) as RunExeItem ??
-               new RunExeItem(exe, args, fullExePath);
+        return PathToListItem(fullExePath, exe, args, addToHistory) as RunExeItem ??
+               new RunExeItem(exe, args, fullExePath, addToHistory);
     }
 
     private void CreateAndAddExeItems(string exe, string args, string fullExePath)
@@ -284,7 +336,7 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
         }
         else
         {
-            _exeItem = CreateExeItem(exe, args, fullExePath);
+            _exeItem = CreateExeItem(exe, args, fullExePath, AddToHistory);
         }
     }
 
@@ -442,6 +494,40 @@ internal sealed partial class ShellListPage : DynamicListPage, IDisposable
         };
     }
 
+    private void LoadInitialHistory()
+    {
+        var hist = _historyService.GetRunHistory();
+        var histItems = hist
+            .Select(h => (h, ShellListPageHelpers.ListItemForCommandString(h, AddToHistory)))
+            .Where(tuple => tuple.Item2 != null)
+            .Select(tuple => (tuple.h, tuple.Item2!))
+            .ToList();
+        _historyItems.Clear();
+
+        // Add all the history items to the _historyItems dictionary
+        foreach (var (h, item) in histItems)
+        {
+            _historyItems[h] = item;
+        }
+
+        _currentHistoryItems.Clear();
+        _currentHistoryItems.AddRange(histItems.Select(tuple => tuple.Item2));
+
+        _loadedInitialHistory = true;
+    }
+
+    internal void AddToHistory(string commandString)
+    {
+        if (string.IsNullOrWhiteSpace(commandString))
+        {
+            return; // Do not add empty or whitespace items
+        }
+
+        _historyService.AddRunHistoryItem(commandString);
+        LoadInitialHistory();
+        DoUpdateSearchText(SearchText);
+    }
+
     public void Dispose()
     {
         _cancellationTokenSource?.Cancel();

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/PathListItem.cs

@@ -16,8 +16,8 @@ internal sealed partial class PathListItem : ListItem
 
     public override IIconInfo? Icon { get => _icon.Value; set => base.Icon = value; }
 
-    public PathListItem(string path, string originalDir)
-        : base(new OpenUrlCommand(path))
+    public PathListItem(string path, string originalDir, Action<string>? addToHistory)
+        : base(new OpenUrlWithHistoryCommand(path, addToHistory))
     {
         var fileName = Path.GetFileName(path);
         _isDirectory = Directory.Exists(path);
@@ -50,6 +50,7 @@ internal sealed partial class PathListItem : ListItem
             new CommandContextItem(new CopyTextCommand(path) { Name = Properties.Resources.copy_path_command_name }) { }
         ];
 
+        // TODO: Follow-up during 0.4. Add the indexer commands here.
         // MoreCommands = [
         //    new CommandContextItem(new OpenWithCommand(indexerItem)),
         //    new CommandContextItem(new ShowFileInFolderCommand(indexerItem.FullPath) { Name = Resources.Indexer_Command_ShowInFolder }),

src/modules/cmdpal/ext/Microsoft.CmdPal.Ext.Shell/ShellCommandsProvider.cs

@@ -2,6 +2,7 @@
 // The Microsoft Corporation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using Microsoft.CmdPal.Common.Services;
 using Microsoft.CmdPal.Ext.Shell.Helpers;
 using Microsoft.CmdPal.Ext.Shell.Pages;
 using Microsoft.CmdPal.Ext.Shell.Properties;
@@ -15,18 +16,24 @@ public partial class ShellCommandsProvider : CommandProvider
     private readonly CommandItem _shellPageItem;
 
     private readonly SettingsManager _settingsManager = new();
+    private readonly ShellListPage _shellListPage;
     private readonly FallbackCommandItem _fallbackItem;
+    private readonly IRunHistoryService _historyService;
 
-    public ShellCommandsProvider()
+    public ShellCommandsProvider(IRunHistoryService runHistoryService)
     {
+        _historyService = runHistoryService;
+
         Id = "Run";
         DisplayName = Resources.cmd_plugin_name;
         Icon = Icons.RunV2Icon;
         Settings = _settingsManager.Settings;
 
-        _fallbackItem = new FallbackExecuteItem(_settingsManager);
+        _shellListPage = new ShellListPage(_settingsManager, _historyService);
 
-        _shellPageItem = new CommandItem(new ShellListPage(_settingsManager))
+        _fallbackItem = new FallbackExecuteItem(_settingsManager, _shellListPage.AddToHistory);
+
+        _shellPageItem = new CommandItem(_shellListPage)
         {
             Icon = Icons.RunV2Icon,
             Title = Resources.shell_command_name,