Default to the repl sub-command when no args are passed

modules/cli-options/src/main/scala/scala/cli/commands/DefaultOptions.scala

@@ -2,12 +2,18 @@ package scala.cli.commands
 
 import caseapp._
 
+// format: off
 case class DefaultOptions(
   @Recurse
-  runOptions: RunOptions = RunOptions(),
+    shared: SharedOptions = SharedOptions(),
+  @Recurse
+    sharedRun: SharedRunOptions = SharedRunOptions(),
+  @Recurse
+    sharedRepl: SharedReplOptions = SharedReplOptions(),
   @Name("-version")
-  version: Boolean = false
+    version: Boolean = false
 )
+// format: on
 
 object DefaultOptions {
   implicit lazy val parser: Parser[DefaultOptions] = Parser.derive

modules/cli-options/src/main/scala/scala/cli/commands/ReplOptions.scala

@@ -8,32 +8,7 @@ final case class ReplOptions(
   @Recurse
     shared: SharedOptions = SharedOptions(),
   @Recurse
-    sharedJava: SharedJavaOptions = SharedJavaOptions(),
-  @Recurse
-    watch: SharedWatchOptions = SharedWatchOptions(),
-  @Recurse
-    compileCross: CompileCrossOptions = CompileCrossOptions(),
-
-  @Group("Repl")
-  @HelpMessage("Use Ammonite (instead of the default Scala REPL)")
-  @Name("A")
-  @Name("amm")
-    ammonite: Option[Boolean] = None,
-
-  @Group("Repl")
-  @HelpMessage("Set the Ammonite version")
-  @Name("ammoniteVer")
-    ammoniteVersion: Option[String] = None,
-
-  @Group("Repl")
-  @Name("a")
-  @Hidden
-    ammoniteArg: List[String] = Nil,
-
-  @Group("Repl")
-  @Hidden
-  @HelpMessage("Don't actually run the REPL, just fetch it")
-    replDryRun: Boolean = false
+    sharedRepl: SharedReplOptions = SharedReplOptions()
 )
 // format: on
 

modules/cli-options/src/main/scala/scala/cli/commands/RunOptions.scala

@@ -15,38 +15,7 @@ final case class RunOptions(
   @Recurse
     shared: SharedOptions = SharedOptions(),
   @Recurse
-    benchmarking: BenchmarkingOptions = BenchmarkingOptions(),
-  @Recurse
-    sharedJava: SharedJavaOptions = SharedJavaOptions(),
-  @Recurse
-    watch: SharedWatchOptions = SharedWatchOptions(),
-  @Recurse
-    compileCross: CompileCrossOptions = CompileCrossOptions(),
-  @Recurse
-    mainClass: MainClassOptions = MainClassOptions(),
-  @Group("Run")
-  @Hidden
-  @HelpMessage("Run as a Spark job, using the spark-submit command")
-  @ExtraName("spark")
-    sparkSubmit: Option[Boolean] = None,
-  @Group("Run")
-  @HelpMessage("Run as a Spark job, using a vanilla Spark distribution downloaded by Scala CLI")
-  @ExtraName("sparkStandalone")
-    standaloneSpark: Option[Boolean] = None,
-  @Group("Run")
-  @HelpMessage("Run as a Hadoop job, using the \"hadoop jar\" command")
-  @ExtraName("hadoop")
-    hadoopJar: Boolean = false,
-  @Group("Run")
-  @HelpMessage("Print the command that would have been run (one argument per line), rather than running it")
-    command: Boolean = false,
-  @Group("Run")
-  @HelpMessage("Temporary / working directory where to write generated launchers")
-    scratchDir: Option[String] = None,
-  @Group("Run")
-  @Hidden
-  @HelpMessage("Run Java commands using a manifest-based class path (shortens command length)")
-    useManifest: Option[Boolean] = None
+    sharedRun: SharedRunOptions = SharedRunOptions()
 )
 // format: on
 

modules/cli-options/src/main/scala/scala/cli/commands/SharedReplOptions.scala

@@ -0,0 +1,43 @@
+package scala.cli.commands
+
+import caseapp.*
+import caseapp.core.help.Help
+
+// format: off
+final case class SharedReplOptions(
+  @Recurse
+    sharedJava: SharedJavaOptions = SharedJavaOptions(),
+  @Recurse
+    watch: SharedWatchOptions = SharedWatchOptions(),
+  @Recurse
+    compileCross: CompileCrossOptions = CompileCrossOptions(),
+
+  @Group("Repl")
+  @HelpMessage("Use Ammonite (instead of the default Scala REPL)")
+  @Name("A")
+  @Name("amm")
+    ammonite: Option[Boolean] = None,
+
+  @Group("Repl")
+  @HelpMessage("Set the Ammonite version")
+  @Name("ammoniteVer")
+    ammoniteVersion: Option[String] = None,
+
+  @Group("Repl")
+  @Name("a")
+  @Hidden
+    ammoniteArg: List[String] = Nil,
+
+  @Group("Repl")
+  @Hidden
+  @HelpMessage("Don't actually run the REPL, just fetch it")
+    replDryRun: Boolean = false
+)
+// format: on
+
+object SharedReplOptions {
+  implicit lazy val parser: Parser[SharedReplOptions] = Parser.derive
+  implicit lazy val help: Help[SharedReplOptions]     = Help.derive
+  // Parser.Aux for using SharedReplOptions with @Recurse in other options
+  implicit lazy val parserAux: Parser.Aux[SharedReplOptions, parser.D] = parser
+}

modules/cli-options/src/main/scala/scala/cli/commands/SharedRunOptions.scala

@@ -0,0 +1,51 @@
+package scala.cli.commands
+
+import caseapp.*
+import caseapp.core.help.Help
+
+import scala.cli.commands.BloopExitOptions.parser
+
+// format: off
+final case class SharedRunOptions(
+  @Recurse
+    benchmarking: BenchmarkingOptions = BenchmarkingOptions(),
+  @Recurse
+    sharedJava: SharedJavaOptions = SharedJavaOptions(),
+  @Recurse
+    watch: SharedWatchOptions = SharedWatchOptions(),
+  @Recurse
+    compileCross: CompileCrossOptions = CompileCrossOptions(),
+  @Recurse
+    mainClass: MainClassOptions = MainClassOptions(),
+  @Group("Run")
+  @Hidden
+  @HelpMessage("Run as a Spark job, using the spark-submit command")
+  @ExtraName("spark")
+    sparkSubmit: Option[Boolean] = None,
+  @Group("Run")
+  @HelpMessage("Run as a Spark job, using a vanilla Spark distribution downloaded by Scala CLI")
+  @ExtraName("sparkStandalone")
+    standaloneSpark: Option[Boolean] = None,
+  @Group("Run")
+  @HelpMessage("Run as a Hadoop job, using the \"hadoop jar\" command")
+  @ExtraName("hadoop")
+    hadoopJar: Boolean = false,
+  @Group("Run")
+  @HelpMessage("Print the command that would have been run (one argument per line), rather than running it")
+    command: Boolean = false,
+  @Group("Run")
+  @HelpMessage("Temporary / working directory where to write generated launchers")
+    scratchDir: Option[String] = None,
+  @Group("Run")
+  @Hidden
+  @HelpMessage("Run Java commands using a manifest-based class path (shortens command length)")
+    useManifest: Option[Boolean] = None
+)
+// format: on
+
+object SharedRunOptions {
+  implicit lazy val parser: Parser[SharedRunOptions] = Parser.derive
+  implicit lazy val help: Help[SharedRunOptions]     = Help.derive
+  // Parser.Aux for using SharedRunOptions with @Recurse in other options
+  implicit lazy val parserAux: Parser.Aux[SharedRunOptions, parser.D] = parser
+}

modules/cli/src/main/scala/scala/cli/ScalaCliCommands.scala

@@ -106,12 +106,13 @@ class ScalaCliCommands(
   override def main(args: Array[String]): Unit = {
 
     // quick hack, until the raw args are kept in caseapp.RemainingArgs by case-app
-    actualDefaultCommand.anyArgs = args.nonEmpty
+    actualDefaultCommand.rawArgs = args
 
     commands.foreach {
       case c: NeedsArgvCommand => c.setArgv(progName +: args)
       case _                   =>
     }
+    actualDefaultCommand.setArgv(progName +: args)
 
     val processedArgs =
       if (args.lengthCompare(1) > 0 && isShebangFile(args(0)))

modules/cli/src/main/scala/scala/cli/commands/Default.scala

@@ -2,6 +2,7 @@ package scala.cli.commands
 
 import caseapp.core.help.RuntimeCommandsHelp
 import caseapp.core.{Error, RemainingArgs}
+import scala.cli.commands.util.SharedOptionsUtil.*
 
 import scala.build.internal.Constants
 import scala.cli.{CurrentParams, ScalaCliHelp}
@@ -16,10 +17,9 @@ class Default(
 
   override protected def commandLength = 0
 
-  override def group = "Main"
-  override def sharedOptions(options: DefaultOptions) =
-    Some[scala.cli.commands.SharedOptions](options.runOptions.shared)
-  private[cli] var anyArgs = false
+  override def group                                                         = "Main"
+  override def sharedOptions(options: DefaultOptions): Option[SharedOptions] = Some(options.shared)
+  private[cli] var rawArgs                                                   = Array.empty[String]
   override def helpAsked(progName: String, maybeOptions: Either[Error, DefaultOptions]): Nothing = {
     println(defaultHelp)
     sys.exit(0)
@@ -28,16 +28,17 @@ class Default(
     println(defaultFullHelp)
     sys.exit(0)
   }
+
   def run(options: DefaultOptions, args: RemainingArgs): Unit = {
-    CurrentParams.verbosity = options.runOptions.shared.logging.verbosity
-    if (options.version)
-      println(Version.versionInfo(isSipScala))
-    else if (anyArgs)
-      Run.run(
-        options.runOptions,
-        args
-      )
+    CurrentParams.verbosity = options.shared.logging.verbosity
+    if options.version then println(Version.versionInfo(isSipScala))
     else
-      helpAsked(finalHelp.progName, Right(options))
+      (
+        if args.remaining.nonEmpty then RunOptions.parser
+        else ReplOptions.parser
+      ).parse(rawArgs) match
+        case Left(e)                              => error(e)
+        case Right((replOptions: ReplOptions, _)) => Repl.run(replOptions, args)
+        case Right((runOptions: RunOptions, _))   => Run.run(runOptions, args)
   }
 }

modules/cli/src/main/scala/scala/cli/commands/Repl.scala

@@ -17,22 +17,23 @@ import scala.cli.commands.util.CommonOps.SharedDirectoriesOptionsOps
 
 object Repl extends ScalaCommand[ReplOptions] {
   override def group = "Main"
-  override def names = List(
+  override def names: List[List[String]] = List(
     List("console"),
     List("repl")
   )
-  override def sharedOptions(options: ReplOptions) = Some(options.shared)
+  override def sharedOptions(options: ReplOptions): Option[SharedOptions] = Some(options.shared)
 
   def buildOptions(ops: ReplOptions): BuildOptions = {
     import ops._
+    import ops.sharedRepl._
     def ammoniteVersionOpt = ammoniteVersion.map(_.trim).filter(_.nonEmpty)
 
     val baseOptions = shared.buildOptions()
     baseOptions.copy(
       javaOptions = baseOptions.javaOptions.copy(
         javaOpts =
           baseOptions.javaOptions.javaOpts ++
-            sharedJava.allJavaOpts.map(JavaOpt(_)).map(Positioned.commandLine _)
+            sharedJava.allJavaOpts.map(JavaOpt(_)).map(Positioned.commandLine)
       ),
       notForBloopOptions = baseOptions.notForBloopOptions.copy(
         replOptions = baseOptions.notForBloopOptions.replOptions.copy(
@@ -90,7 +91,7 @@ object Repl extends ScalaCommand[ReplOptions] {
         directories,
         logger,
         allowExit = allowExit,
-        options.replDryRun
+        options.sharedRepl.replDryRun
       )
       res match {
         case Left(ex) =>
@@ -100,7 +101,7 @@ object Repl extends ScalaCommand[ReplOptions] {
       }
     }
 
-    val cross = options.compileCross.cross.getOrElse(false)
+    val cross = options.sharedRepl.compileCross.cross.getOrElse(false)
     val configDb = ConfigDb.open(options.shared.directories.directories)
       .orExit(logger)
     val actionableDiagnostics =
@@ -110,14 +111,19 @@ object Repl extends ScalaCommand[ReplOptions] {
 
     if (inputs.isEmpty) {
       val artifacts = initialBuildOptions.artifacts(logger, Scope.Main).orExit(logger)
-      doRunRepl(initialBuildOptions, artifacts, None, allowExit = !options.watch.watchMode)
-      if (options.watch.watchMode) {
+      doRunRepl(
+        initialBuildOptions,
+        artifacts,
+        None,
+        allowExit = !options.sharedRepl.watch.watchMode
+      )
+      if (options.sharedRepl.watch.watchMode) {
         // nothing to watch, just wait for Ctrl+C
         WatchUtil.printWatchMessage()
         WatchUtil.waitForCtrlC()
       }
     }
-    else if (options.watch.watchMode) {
+    else if (options.sharedRepl.watch.watchMode) {
       val watcher = Build.watch(
         inputs,
         initialBuildOptions,
@@ -219,7 +225,7 @@ object Repl extends ScalaCommand[ReplOptions] {
       .map(_.last.stripSuffix(".class"))
       .sorted
     val warnRootClasses = rootClasses.nonEmpty &&
-      options.notForBloopOptions.replOptions.useAmmoniteOpt.exists(_ == true)
+      options.notForBloopOptions.replOptions.useAmmoniteOpt.contains(true)
     if (warnRootClasses)
       logger.message(
         s"Warning: found classes defined in the root package (${rootClasses.mkString(", ")})." +