Allow UCM commands to have “unprocessed” arguments

unison-cli/src/Unison/Codebase/Editor/HandleInput.hs

@@ -703,17 +703,23 @@ loop e = do
               Cli.Env {codebase} <- ask
               currentBranch <- Branch.withoutTransitiveLibs <$> Cli.getCurrentBranch0
               case Map.lookup command InputPatterns.patternMap of
-                Just (IP.InputPattern {args = argTypes}) -> do
-                  zip argTypes args & Monoid.foldMapM \case
-                    ((argName, _, IP.ArgumentType {fzfResolver = Just IP.FZFResolver {getOptions}}), "_") -> do
-                      pp <- Cli.getCurrentProjectPath
-                      results <- liftIO $ getOptions codebase pp currentBranch
-                      Cli.respond (DebugDisplayFuzzyOptions argName (Text.unpack <$> results))
-                    ((_, _, IP.ArgumentType {fzfResolver = Nothing}), "_") -> do
-                      Cli.respond DebugFuzzyOptionsNoResolver
-                    _ -> pure ()
-                Nothing -> do
-                  Cli.respond DebugFuzzyOptionsNoResolver
+                Just IP.InputPattern {params} ->
+                  either (Cli.respond . DebugFuzzyOptionsIncorrectArgs) (pure . fst)
+                    =<< IP.foldParamsWithM
+                      ( \_ (paramName, IP.ParameterType {fzfResolver}) arg ->
+                          if arg == "_"
+                            then case fzfResolver of
+                              Just IP.FZFResolver {getOptions} -> do
+                                pp <- Cli.getCurrentProjectPath
+                                results <- liftIO $ getOptions codebase pp currentBranch
+                                (,[]) <$> Cli.respond (DebugDisplayFuzzyOptions paramName (Text.unpack <$> results))
+                              Nothing -> (,[]) <$> Cli.respond DebugFuzzyOptionsNoResolver
+                            else pure ((), [])
+                      )
+                      ()
+                      params
+                      args
+                Nothing -> Cli.respond $ DebugFuzzyOptionsNoCommand command
             DebugFormatI -> do
               env <- ask
               void $ runMaybeT do

unison-cli/src/Unison/Codebase/Editor/Output.hs

@@ -359,6 +359,8 @@ data Output
   | DisplayDebugCompletions [Completion.Completion]
   | DisplayDebugLSPNameCompletions [(Text, Name, LabeledDependency)]
   | DebugDisplayFuzzyOptions Text [String {- arg description, options -}]
+  | DebugFuzzyOptionsIncorrectArgs (NonEmpty String)
+  | DebugFuzzyOptionsNoCommand String
   | DebugFuzzyOptionsNoResolver
   | DebugTerm (Bool {- verbose mode -}) (Either (Text {- A builtin hash -}) (Term Symbol Ann))
   | DebugDecl (Either (Text {- A builtin hash -}) (DD.Decl Symbol Ann)) (Maybe ConstructorId {- If 'Just' we're debugging a constructor of the given decl -})
@@ -620,6 +622,8 @@ isFailure o = case o of
   DisplayDebugCompletions {} -> False
   DisplayDebugLSPNameCompletions {} -> False
   DebugDisplayFuzzyOptions {} -> False
+  DebugFuzzyOptionsIncorrectArgs {} -> True
+  DebugFuzzyOptionsNoCommand {} -> True
   DebugFuzzyOptionsNoResolver {} -> True
   DebugTerm {} -> False
   DebugDecl {} -> False

unison-cli/src/Unison/Codebase/Transcript/Runner.hs

@@ -48,8 +48,8 @@ import Unison.Codebase.Transcript.Parser qualified as Transcript
 import Unison.Codebase.Verbosity (Verbosity, isSilent)
 import Unison.Codebase.Verbosity qualified as Verbosity
 import Unison.CommandLine
-import Unison.CommandLine.InputPattern (InputPattern (aliases, patternName))
-import Unison.CommandLine.InputPatterns (validInputs)
+import Unison.CommandLine.InputPattern (aliases, patternName)
+import Unison.CommandLine.InputPatterns qualified as IP
 import Unison.CommandLine.OutputMessages (notifyNumbered, notifyUser)
 import Unison.CommandLine.Welcome (asciiartUnison)
 import Unison.Parser.Ann (Ann)
@@ -174,7 +174,7 @@ run isTest verbosity dir codebase runtime sbRuntime nRuntime ucmVersion baseURL
   expectFailure <- newIORef False
   hasErrors <- newIORef False
   mBlock <- newIORef Nothing
-  let patternMap = Map.fromList $ (\p -> (patternName p, p) : ((,p) <$> aliases p)) =<< validInputs
+  let patternMap = Map.fromList $ (\p -> (patternName p, p) : ((,p) <$> aliases p)) =<< IP.validInputs
   let output' :: Bool -> Stanza -> IO ()
       output' inputEcho msg = do
         hide <- hideOutput inputEcho
@@ -326,7 +326,8 @@ run isTest verbosity dir codebase runtime sbRuntime nRuntime ucmVersion baseURL
                     liftIO (parseInput codebase curPath getProjectRoot numberedArgs patternMap args)
                       >>= either
                         -- invalid command is treated as a failure
-                        ( \msg -> do
+                        ( \failure -> do
+                            let msg = reportParseFailure failure
                             liftIO $ outputUcmResult msg
                             liftIO $ maybeDieWithMsg msg
                             Cli.returnEarlyWithoutOutput