Allow module run to run modules with local path (#7057)

Co-authored-by: Ben Sherman <bentshermann@gmail.com>

Author: jorgee

docs/reference/cli.md

@@ -1277,11 +1277,10 @@ The `module` command provides a comprehensive system for managing registry-based
 
 (cli-module-run)=
 
-`run [options] [namespace/name] [--<input_name> <input-value>]`
+`run [options] [namespace/name | path] [--<input_name> <input-value>]`
 
-: Execute a module directly from the registry without creating a wrapper workflow.
-: Automatically downloads the module if not already installed. Accepts all standard Nextflow run options.
-: The `module run` command extends the `run` command and accepts all its options, including `-profile`, `-resume`, `-c`, etc. Command-line params (i.e., `--<input_name>`) are inferred from the module's declared inputs.
+: Execute a module directly. Can be a remote module (`namespace/name`) or a local module path (beginning with `./`, `../`, or `/`). Automatically downloads the module if not already installed.
+: Accepts all standard Nextflow run options, including `-profile`, `-resume`, `-c`, etc. Command-line params (i.e., `--<input_name>`) are inferred from the module's declared inputs.
 : The following additional options are available:
 
   `-version`
@@ -1290,15 +1289,20 @@ The `module` command provides a comprehensive system for managing registry-based
 : **Examples:**
 
   ```console
-  # Run module with inputs
-  $ nextflow module run nf-core/fastqc --input 'data/*.fastq.gz'
+  # Run remote module
+  $ nextflow module run nf-core/fastqc \
+      --input 'data/*.fastq.gz'
 
-  # Run specific version with Nextflow options
+  # Run remote module with specific version and run options
   $ nextflow module run nf-core/fastqc \
-      --input 'data/*.fastq.gz' \
       -version 1.0.0 \
-      -profile docker \
+      --input 'data/*.fastq.gz' \
+      -with-conda \
       -resume
+
+  # Run local module
+  $ nextflow module run ./modules/nf-core/fastqc/main.nf \
+      --input 'data/*.fastq.gz'
   ```
 
 (cli-module-search)=

modules/nextflow/src/main/groovy/nextflow/cli/module/CmdModuleRun.groovy

@@ -16,23 +16,22 @@
 
 package nextflow.cli.module
 
+import java.nio.file.Path
+
 import com.beust.jcommander.Parameter
 import com.beust.jcommander.Parameters
 import groovy.transform.CompileStatic
 import io.seqera.npr.client.RegistryClient
+import nextflow.Const
 import nextflow.cli.CmdRun
 import nextflow.config.ConfigBuilder
 import nextflow.config.RegistryConfig
 import nextflow.exception.AbortOperationException
 import nextflow.module.ModuleReference
-import nextflow.module.RegistryClientFactory
 import nextflow.module.ModuleResolver
-
+import nextflow.module.RegistryClientFactory
 import nextflow.util.TestOnly
 
-import java.nio.file.Path
-import java.nio.file.Paths
-
 /**
  * Module run subcommand
  *
@@ -58,31 +57,53 @@ class CmdModuleRun extends CmdRun {
     @Override
     void run() {
         if( !args ) {
-            throw new AbortOperationException("Arguments not provided")
+            throw new AbortOperationException("Module name/path not provided")
+        }
+
+        final moduleFile = isLocalModule(args[0])
+            ? resolveLocalModule(args[0])
+            : resolveRemoteModule(args[0], version)
+
+        if( moduleFile ) {
+            args[0] = moduleFile.toAbsolutePath().toString()
+            super.run()
         }
+    }
+
+    private boolean isLocalModule(String str) {
+        return str.startsWith('/') || str.startsWith('./') || str.startsWith('../')
+    }
+
+    private Path resolveLocalModule(String str) {
+        final module = Path.of(str).toAbsolutePath().normalize()
+        final path = module.isDirectory() ? module.resolve(Const.DEFAULT_MAIN_FILE_NAME) : module
+        if( !path.exists() )
+            throw new AbortOperationException("Invalid module path: ${str}")
+        return path
+    }
 
+    private Path resolveRemoteModule(String name, String version) {
         // Parse and validate module reference
         ModuleReference reference
         try {
-            reference = ModuleReference.parse(args[0])
+            reference = ModuleReference.parse(name)
         } catch( Exception e ) {
-            throw new AbortOperationException("Invalid module reference: ${args[0]}", e)
+            throw new AbortOperationException("Invalid module reference: ${name}", e)
         }
 
         // Get config
-        def baseDir = root ?: Paths.get('.').toAbsolutePath().normalize()
-        def config = new ConfigBuilder()
+        final baseDir = root ?: Path.of('.').toAbsolutePath().normalize()
+        final config = new ConfigBuilder()
             .setOptions(launcher.options)
             .setBaseDir(baseDir)
             .build()
 
-        def registryConfig = config.navigate('registry') as RegistryConfig ?: new RegistryConfig()
-
-        def resolver = new ModuleResolver(baseDir, client ?: RegistryClientFactory.forConfig(registryConfig))
-        Path moduleFile = resolver.installModule(reference, version)
-        if( moduleFile ) {
-            args[0] = moduleFile.toAbsolutePath().toString()
-            super.run()
+        final registryConfig = new RegistryConfig(config.registry as Map ?: Collections.emptyMap())
+        try {
+            final resolver = new ModuleResolver(baseDir, client ?: RegistryClientFactory.forConfig(registryConfig))
+            return resolver.installModule(reference, version)
+        } catch( Exception e ) {
+            throw new AbortOperationException("Unable to install module: ${name}", e)
         }
     }
 }

modules/nextflow/src/test/groovy/nextflow/cli/module/CmdModuleRunTest.groovy

@@ -195,6 +195,73 @@ class CmdModuleRunTest extends Specification {
 
     }
 
+    def 'should run module from local path'() {
+        given:
+        def moduleScript = '''
+            process CREATE_LOCAL_FILE {
+                output:
+                path "local_output.txt"
+
+                script:
+                """
+                echo "Local module executed" > local_output.txt
+                """
+            }
+        '''.stripIndent()
+
+        and:
+        // Create a local module directory with main.nf
+        def moduleDir = tempDir.resolve('local-module')
+        Files.createDirectories(moduleDir)
+        moduleDir.resolve('main.nf').text = moduleScript
+
+        def escapedPath = Pattern.quote(tempDir.toString())
+        def pattern = ~/"${escapedPath}\/.+\/local_output\.txt"/
+
+        and:
+        def cmd = new CmdModuleRun()
+        def opts = new CliOptions()
+        opts.setQuiet(true)
+        cmd.launcher = Mock(Launcher) {
+            getOptions() >> opts
+            getCliString() >> "nextflow module run ${moduleDir}"
+        }
+        cmd.args = [moduleDir.toString()]
+        cmd.root = tempDir
+        cmd.workDir = tempDir.toString()
+        cmd.outputDir = tempDir.resolve('results').toString()
+        cmd.outputFormat = 'json'
+
+        when:
+        cmd.run()
+        def stdout = capture
+            .toString()
+            .readLines()// remove the log part
+            .findResults { line -> !line.contains('DEBUG') ? line : null }
+            .findResults { line -> !line.contains('INFO') ? line : null }.join(" ")
+
+        then:
+        assert (stdout =~ pattern).find()
+    }
+
+    def 'should fail when path and module do not exist'() {
+        given:
+        def nonExistentPath = tempDir.resolve('does-not-exist').toString()
+        def cmd = new CmdModuleRun()
+        cmd.launcher = Mock(Launcher) {
+            getOptions() >> null
+        }
+        cmd.args = [nonExistentPath]
+        cmd.root = tempDir
+
+        when:
+        cmd.run()
+
+        then:
+        def e = thrown(AbortOperationException)
+        e.message.contains('Invalid module path')
+    }
+
     def 'should fail with no arguments'() {
         given:
         def cmd = new CmdModuleRun()