Add Quick Fix UI and support for custom CommandNotFound OSC

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -1308,7 +1308,7 @@ namespace winrt::TerminalApp::implementation
                 //       requires context from the control)
                 // then get that here.
                 const bool shouldGetContext = realArgs.UseCommandline() ||
-                                              WI_IsFlagSet(source, SuggestionsSource::CommandHistory);
+                                              WI_IsAnyFlagSet(source, SuggestionsSource::CommandHistory | SuggestionsSource::WinGetCommandNotFound);
                 if (shouldGetContext)
                 {
                     if (const auto& control{ _GetActiveControl() })
@@ -1348,6 +1348,16 @@ namespace winrt::TerminalApp::implementation
                     }
                 }
 
+                if (WI_IsFlagSet(source, SuggestionsSource::WinGetCommandNotFound) &&
+                    context != nullptr)
+                {
+                    const auto recentCommands = Command::ToSendInputCommands(context.WinGetSuggestions());
+                    for (const auto& t : recentCommands)
+                    {
+                        commandsCollection.push_back(t);
+                    }
+                }
+
                 // Open the palette with all these commands in it.
                 _OpenSuggestions(_GetActiveControl(),
                                  winrt::single_threaded_vector<Command>(std::move(commandsCollection)),

src/cascadia/TerminalApp/Resources/en-US/Resources.resw

@@ -898,4 +898,4 @@
   <data name="RestartConnectionToolTip" xml:space="preserve">
     <value>Restart the active pane connection</value>
   </data>
-</root>
+</root>

src/cascadia/TerminalApp/TerminalAppLib.vcxproj

@@ -439,6 +439,11 @@
       <ResolvedFrom>CppWinRTImplicitlyExpandTargetPlatform</ResolvedFrom>
       <IsSystemReference>True</IsSystemReference>
     </Reference>
+    <Reference Include="$(OpenConsoleDir)src\cascadia\TerminalApp\Microsoft.Management.Deployment.winmd">
+      <IsWinMDFile>true</IsWinMDFile>
+      <Private>false</Private>
+      <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
+    </Reference>
   </ItemGroup>
   <!-- ====================== Compiler & Linker Flags ===================== -->
   <ItemDefinitionGroup>

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -11,6 +11,7 @@
 #include "RequestReceiveContentArgs.g.cpp"
 
 #include <filesystem>
+#include <winrt/Microsoft.Management.Deployment.h>
 
 #include <inc/WindowingBehavior.h>
 #include <LibraryResources.h>
@@ -26,6 +27,7 @@
 #include "Utils.h"
 
 using namespace winrt;
+using namespace winrt::Microsoft::Management::Deployment;
 using namespace winrt::Microsoft::Terminal::Control;
 using namespace winrt::Microsoft::Terminal::Settings::Model;
 using namespace winrt::Microsoft::Terminal::TerminalConnection;
@@ -1670,6 +1672,8 @@ namespace winrt::TerminalApp::implementation
 
         term.ShowWindowChanged({ get_weak(), &TerminalPage::_ShowWindowChangedHandler });
 
+        //term.SearchMissingCommand({ get_weak(), &TerminalPage::_SearchMissingCommandHandler });
+
         // Don't even register for the event if the feature is compiled off.
         if constexpr (Feature_ShellCompletions::IsEnabled())
         {
@@ -2952,6 +2956,191 @@ namespace winrt::TerminalApp::implementation
         ShowWindowChanged.raise(*this, args);
     }
 
+    void TerminalPage::_SearchMissingCommandHandler(const IInspectable sender, const winrt::Microsoft::Terminal::Control::SearchMissingCommandEventArgs args)
+    {
+#if 0
+        static constexpr CLSID CLSID_PackageManager = { 0xC53A4F16, 0x787E, 0x42A4, 0xB3, 0x04, 0x29, 0xEF, 0xFB, 0x4B, 0xF5, 0x97 }; //C53A4F16-787E-42A4-B304-29EFFB4BF597
+        static constexpr CLSID CLSID_FindPackagesOptions = { 0x572DED96, 0x9C60, 0x4526, { 0x8F, 0x92, 0xEE, 0x7D, 0x91, 0xD3, 0x8C, 0x1A } }; //572DED96-9C60-4526-8F92-EE7D91D38C1A
+        static constexpr CLSID CLSID_PackageMatchFilter = { 0xD02C9DAF, 0x99DC, 0x429C, { 0xB5, 0x03, 0x4E, 0x50, 0x4E, 0x4A, 0xB0, 0x00 } }; //D02C9DAF-99DC-429C-B503-4E504E4AB000
+
+        static constexpr unsigned int maxSuggestions = 5;
+        bool tooManySuggestions = false;
+
+        // TODO CARLOS: this is where we fail! "Class not registered" error
+        PackageManager pkgManager = winrt::create_instance<PackageManager>(CLSID_PackageManager, CLSCTX_ALL);
+        auto catalogRef = pkgManager.GetPredefinedPackageCatalog(PredefinedPackageCatalog::OpenWindowsCatalog);
+        auto connectResult = catalogRef.Connect();
+        int retryCount = 0;
+        while (connectResult.Status() != ConnectResultStatus::Ok && retryCount < 3)
+        {
+            connectResult = catalogRef.Connect();
+            ++retryCount;
+        }
+        if (connectResult.Status() != ConnectResultStatus::Ok)
+        {
+            return;
+        }
+        auto catalog = connectResult.PackageCatalog();
+
+        // Perform the query (search by command)
+        auto packageMatchFilter = winrt::create_instance<PackageMatchFilter>(CLSID_PackageMatchFilter, CLSCTX_ALL);
+        auto findPackagesOptions = winrt::create_instance<FindPackagesOptions>(CLSID_FindPackagesOptions, CLSCTX_ALL);
+
+        // Helper lambda to apply a filter to the query
+        auto applyPackageMatchFilter = [&packageMatchFilter, &findPackagesOptions](PackageMatchField field, PackageFieldMatchOption matchOption, hstring query) {
+            // Configure filter
+            packageMatchFilter.Field(field);
+            packageMatchFilter.Option(matchOption);
+            packageMatchFilter.Value(query);
+
+            // Apply filter
+            findPackagesOptions.ResultLimit(maxSuggestions + 1u);
+            findPackagesOptions.Filters().Clear();
+            findPackagesOptions.Filters().Append(packageMatchFilter);
+        };
+
+        // Helper lambda to retrieve the best matching package(s) from the query's result
+        auto tryGetBestMatchingPackage = [&tooManySuggestions](IVectorView<MatchResult> matches) {
+            std::vector<CatalogPackage> results;
+            results.reserve(std::min(matches.Size(), maxSuggestions));
+            if (matches.Size() == 1)
+            {
+                // One match --> return the package
+                results.emplace_back(matches.GetAt(0).CatalogPackage());
+            }
+            else if (matches.Size() > 1)
+            {
+                // Multiple matches --> display top 5 matches (prioritize best matches first)
+                std::queue<CatalogPackage> bestExactMatches, secondaryMatches, tertiaryMatches;
+                for (auto match : matches)
+                {
+                    switch (match.MatchCriteria().Option())
+                    {
+                    case PackageFieldMatchOption::EqualsCaseInsensitive:
+                    case PackageFieldMatchOption::Equals:
+                        bestExactMatches.push(match.CatalogPackage());
+                        break;
+                    case PackageFieldMatchOption::StartsWithCaseInsensitive:
+                        secondaryMatches.push(match.CatalogPackage());
+                        break;
+                    case PackageFieldMatchOption::ContainsCaseInsensitive:
+                        tertiaryMatches.push(match.CatalogPackage());
+                        break;
+                    }
+                }
+
+                // Now return the top maxSuggestions
+                while (results.size() < maxSuggestions)
+                {
+                    if (bestExactMatches.size() > 0)
+                    {
+                        results.emplace_back(bestExactMatches.front());
+                        bestExactMatches.pop();
+                    }
+                    else if (secondaryMatches.size() > 0)
+                    {
+                        results.emplace_back(secondaryMatches.front());
+                        secondaryMatches.pop();
+                    }
+                    else if (tertiaryMatches.size() > 0)
+                    {
+                        results.emplace_back(tertiaryMatches.front());
+                        tertiaryMatches.pop();
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+            }
+            tooManySuggestions = matches.Size() > maxSuggestions;
+            return results;
+        };
+
+        // Search by command
+        auto missingCmd = args.MissingCommand();
+        std::wstring searchOption = L"command";
+        applyPackageMatchFilter(PackageMatchField::Command, PackageFieldMatchOption::StartsWithCaseInsensitive, missingCmd);
+        auto findPackagesResult = catalog.FindPackages(findPackagesOptions);
+        auto matches = findPackagesResult.Matches();
+        auto pkgList = tryGetBestMatchingPackage(matches);
+        if (pkgList.empty())
+        {
+            // No matches found --> search by name
+            applyPackageMatchFilter(PackageMatchField::Name, PackageFieldMatchOption::ContainsCaseInsensitive, missingCmd);
+
+            findPackagesResult = catalog.FindPackages(findPackagesOptions);
+            matches = findPackagesResult.Matches();
+            pkgList = tryGetBestMatchingPackage(matches);
+            searchOption = L"name";
+
+            if (pkgList.empty())
+            {
+                // No matches found --> search by moniker
+                applyPackageMatchFilter(PackageMatchField::Moniker, PackageFieldMatchOption::ContainsCaseInsensitive, missingCmd);
+
+                // Perform the query (search by name)
+                findPackagesResult = catalog.FindPackages(findPackagesOptions);
+                matches = findPackagesResult.Matches();
+                pkgList = tryGetBestMatchingPackage(matches);
+                searchOption = L"moniker";
+            }
+        }
+
+        // Display packages in UI
+        if (!pkgList.empty())
+        {
+            std::vector<std::wstring> suggestions;
+            suggestions.reserve(pkgList.size());
+            for (auto pkg : pkgList)
+            {
+                suggestions.emplace_back(fmt::format(L"winget install --id {}", pkg.Id()));
+            }
+
+            std::wstring footer = tooManySuggestions ?
+                                      fmt::format(L"winget search --{} {}", searchOption, missingCmd) :
+                                      L"";
+
+            // TODO CARLOS: no more info bar; replace!
+            //ShowCommandNotFoundInfoBar(suggestions, footer);
+        }
+#elif defined(DEBUG) || defined(_DEBUG) || defined(DBG)
+        //const bool tooManySuggestions = false;
+        //const std::wstring searchOption = L"command";
+        const std::wstring missingCmd = args.MissingCommand().data();
+        std::vector<std::wstring> pkgList = { L"pkg1", L"pkg2", L"pkg3" };
+        std::vector<hstring> suggestions;
+        suggestions.reserve(pkgList.size());
+        for (auto pkg : pkgList)
+        {
+            suggestions.emplace_back(fmt::format(L"winget install --id {}", pkg));
+        }
+
+        // This will come in on a background (not-UI, not output) thread.
+
+        // Parse the json string into a collection of actions
+        try
+        {
+            //auto commandsCollection = Command::ParsePowerShellMenuComplete(args.MenuJson(),
+            //                                                               args.ReplacementLength());
+
+            auto suggestionsWinRT = winrt::single_threaded_vector<hstring>(std::move(suggestions));
+            auto commandsCollection = Command::ToSendInputCommands(suggestionsWinRT);
+
+            //auto weakThis{ get_weak() };
+            //Dispatcher().RunAsync(CoreDispatcherPriority::Normal, [weakThis, commandsCollection, sender]() {
+            //    // On the UI thread...
+            //    if (const auto& page{ weakThis.get() })
+            //    {
+            //        // Open the Suggestions UI with the commands from the control
+            //        page->_OpenSuggestions(sender.try_as<TermControl>(), commandsCollection, SuggestionsMode::Menu, L"");
+            //    }
+            //});
+        }
+        CATCH_LOG();
+#endif
+    }
+
     // Method Description:
     // - Paste text from the Windows Clipboard to the focused terminal
     void TerminalPage::_PasteText()

src/cascadia/TerminalApp/TerminalPage.h

@@ -518,6 +518,8 @@ namespace winrt::TerminalApp::implementation
 
         void _ShowWindowChangedHandler(const IInspectable sender, const winrt::Microsoft::Terminal::Control::ShowWindowArgs args);
 
+        void _SearchMissingCommandHandler(const IInspectable sender, const winrt::Microsoft::Terminal::Control::SearchMissingCommandEventArgs args);
+
         winrt::fire_and_forget _windowPropertyChanged(const IInspectable& sender, const winrt::Windows::UI::Xaml::Data::PropertyChangedEventArgs& args);
 
         void _onTabDragStarting(const winrt::Microsoft::UI::Xaml::Controls::TabView& sender, const winrt::Microsoft::UI::Xaml::Controls::TabViewTabDragStartingEventArgs& e);