Implement process entry execution with parameter mapping

Add support for executing Nextflow processes directly without explicit workflow definitions.

Key Features:
- Single process scripts run automatically: `nextflow run script.nf --param value`
- Multi-process scripts use entry selection: `nextflow run script.nf -entry process:name --param value`
- Automatic command-line parameter mapping to process input channels
- Support for all standard input types: val, path, env, tuple, each
- Comprehensive error handling with helpful suggestions

Implementation:
- Enhanced BaseScript with process entry workflow generation
- Added parameter mapping pipeline with input definition extraction
- Created specialized delegates for parsing compiled process bodies
- Added ScriptMeta methods for single/multi-process detection
- Comprehensive documentation and test coverage

This feature bridges the gap between command-line tools and workflow orchestration,
making Nextflow processes more accessible for direct execution scenarios.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: pditommaso

PROCESS_ENTRY_IMPLEMENTATION.md

@@ -0,0 +1,197 @@
+# Process Entry Execution - Implementation Summary
+
+## Overview
+
+This document describes the implementation of the process entry execution feature in Nextflow, which allows users to execute individual processes directly from the command line without writing explicit workflow definitions.
+
+## Features Implemented
+
+### 1. Automatic Single Process Execution
+- **Usage**: `nextflow run script.nf --param value`
+- **Behavior**: Scripts containing exactly one process execute automatically
+- **Implementation**: `createSingleProcessWorkflow()` in BaseScript.groovy
+
+### 2. Multi-Process Entry Selection
+- **Usage**: `nextflow run script.nf -entry process:NAME --param value`
+- **Behavior**: Scripts with multiple processes require explicit process selection
+- **Implementation**: Enhanced `-entry` option parsing in `run0()` method
+
+### 3. Command-Line Parameter Mapping
+- **Feature**: Automatic mapping of `--param value` arguments to process input channels
+- **Supported Types**: `val`, `path`, `env`, `tuple`, `each`
+- **Implementation**: `createProcessInputChannelsWithMapping()` and related methods
+
+## Architecture
+
+### Core Components
+
+#### 1. Process Entry Detection (`BaseScript.groovy:180-205`)
+```groovy
+// Enhanced entry parsing to support process:NAME syntax
+if( binding.entryName.startsWith('process:') ) {
+    final processName = binding.entryName.substring(8)
+    final processDef = meta.getProcess(processName)
+    entryFlow = createProcessEntryWorkflow(processDef)
+}
+```
+
+#### 2. Parameter Mapping Pipeline
+The parameter mapping follows a three-step pipeline:
+
+**Step 1: Input Definition Extraction** (`extractProcessInputDefinitions()`)
+- Clones the process body closure to avoid side effects
+- Uses `ProcessInputExtractionDelegate` to intercept internal Nextflow DSL calls
+- Captures `_in_val(TokenVar(name))` calls generated by the compiler
+- Returns structured input specifications: `[type: 'val', name: 'paramName']`
+
+**Step 2: Parameter-to-Channel Mapping** (`mapParametersToChannels()`)
+- Iterates through input specifications using traditional for loops
+- Looks up parameter values in `session.params` (populated from command-line)
+- Creates appropriate Nextflow channels based on input type
+
+**Step 3: Channel Creation** (`createChannelForInputType()`)
+- Converts parameter values to typed Nextflow channels
+- Handles type-specific logic (path validation, collection handling, etc.)
+- Provides fallback behavior for missing parameters
+
+#### 3. Synthetic Workflow Generation
+Both single and multi-process execution create synthetic workflows:
+```groovy
+def workflowLogic = { ->
+    def inputChannels = createProcessInputChannelsWithMapping(processDef)
+    this.invokeMethod(processName, inputChannels)
+}
+```
+
+### Key Classes
+
+#### ProcessInputExtractionDelegate
+- **Purpose**: Intercepts compiled process body execution to extract input definitions
+- **Key Methods**: `_in_val()`, `_in_path()`, `_in_env()`, etc.
+- **Design**: Uses method interception to capture TokenVar objects from compiled DSL
+
+#### TraditionalInputParsingDelegate
+- **Purpose**: Handles explicit `input { }` block declarations (legacy support)
+- **Usage**: Less common in modern Nextflow code
+- **Design**: Direct method mapping for input type declarations
+
+## Technical Details
+
+### Parameter Type Handling
+
+| Input Type | Command-Line Example | Channel Creation | Special Handling |
+|------------|---------------------|------------------|------------------|
+| `val name` | `--name "value"` | `Channel.of(paramValue)` | Direct value wrapping |
+| `path file` | `--file "input.txt"` | `Channel.of(Paths.get(paramValue))` | Path conversion + existence warning |
+| `env var` | `--var "VALUE"` | `Channel.of(paramValue)` | Optional parameter support |
+| `tuple items` | `--items "a,b,c"` | `Channel.of([paramValue])` | Collection wrapping |
+| `each item` | `--item "a,b,c"` | `Channel.fromIterable(split(','))` | Comma-separated parsing |
+
+### Error Handling
+
+#### Process Selection Errors
+```groovy
+// Unknown process name with suggestions
+def guess = allProcessNames.closest(processName)
+throw new IllegalArgumentException("Unknown process entry name: ${processName} -- Did you mean?\n${guess}")
+```
+
+#### Missing Parameter Errors
+```groovy
+// Type-specific error messages
+throw new IllegalArgumentException("Missing required value parameter: --${paramName}")
+```
+
+#### Multiple Process Detection
+```groovy
+// Clear guidance for multi-process scripts
+throw new AbortOperationException("Multiple processes found (${processNames}). Use -entry process:NAME to specify which process to execute.")
+```
+
+### Performance Optimizations
+
+1. **Traditional for loops** instead of iterators for parameter processing
+2. **Process body cloning** to avoid side effects during input extraction
+3. **Lazy evaluation** of parameter mapping (only when needed)
+4. **Minimal object allocation** in hot paths
+
+## Usage Examples
+
+### Single Process Script
+```groovy
+#!/usr/bin/env nextflow
+
+process analyzeData {
+    input:
+    val sampleName
+    path inputFile
+    
+    script:
+    """
+    echo "Analyzing ${sampleName} from ${inputFile}"
+    """
+}
+```
+
+**Execution**: `nextflow run analyze.nf --sampleName "sample1" --inputFile "data.txt"`
+
+### Multi-Process Script
+```groovy
+#!/usr/bin/env nextflow
+
+process processA {
+    input: val name
+    script: "echo Processing A: ${name}"
+}
+
+process processB {
+    input: val name  
+    script: "echo Processing B: ${name}"
+}
+```
+
+**Execution**: `nextflow run multi.nf -entry process:processA --name "test"`
+
+## Integration Points
+
+### ScriptMeta.groovy Enhancements
+- `hasSingleExecutableProcess()`: Detects single process + no workflows
+- `hasMultipleExecutableProcesses()`: Detects multiple processes + no workflows
+
+### BaseScript.groovy Structure
+```
+run0() - Entry point detection and workflow selection
+├── createSingleProcessWorkflow() - Single process execution
+├── createProcessEntryWorkflow() - Multi-process execution  
+└── createProcessInputChannelsWithMapping() - Parameter mapping pipeline
+    ├── extractProcessInputDefinitions() - Input extraction
+    ├── mapParametersToChannels() - Parameter-to-channel mapping
+    ├── createChannelForInputType() - Channel creation
+    └── createDefaultChannelForInputType() - Error handling
+```
+
+## Testing
+
+The implementation includes comprehensive test coverage:
+
+1. **Single Process Tests**: `single_process_test.nf`
+2. **Multi-Process Tests**: `complete_param_mapping_test.nf`
+3. **Parameter Type Tests**: Various input types (val, path, tuple, each)
+4. **Error Condition Tests**: Missing parameters, invalid process names
+5. **Edge Case Tests**: Empty processes, complex parameter combinations
+
+## Future Enhancements
+
+### Potential Improvements
+1. **Complex tuple support**: Multi-element tuples with mixed types
+2. **Parameter validation**: Type checking and constraints
+3. **Default parameter values**: Support for optional parameters with defaults
+4. **Configuration integration**: Process-specific parameter configuration
+5. **Interactive mode**: Parameter prompting for missing values
+
+### Performance Considerations
+1. **Input caching**: Cache extracted input definitions for repeated use
+2. **Compilation optimization**: Pre-compile parameter mapping logic
+3. **Memory efficiency**: Reduce object allocation in parameter processing
+
+This implementation successfully bridges the gap between command-line tool execution and workflow orchestration, making Nextflow processes more accessible for direct execution scenarios while maintaining full compatibility with existing workflow-based usage patterns.

complete_param_mapping_test.nf

@@ -0,0 +1,109 @@
+#!/usr/bin/env nextflow
+
+/*
+ * Complete Parameter Mapping Test
+ * 
+ * This demonstrates full command-line parameter mapping to process inputs
+ * 
+ * Usage examples:
+ *   ./launch.sh run complete_param_mapping_test.nf -entry process:analyzeFile --inputFile test_data.txt --sample "sample1" 
+ *   ./launch.sh run complete_param_mapping_test.nf -entry process:processValues --name "test" --count 42
+ *   ./launch.sh run complete_param_mapping_test.nf -entry process:handleMultiple --data input.csv --format "json" --options "verbose"
+ */
+
+// Process with file and value inputs
+process analyzeFile {
+    debug true
+    publishDir "./results", mode: 'copy'
+    
+    input:
+    path inputFile     // Maps to --inputFile parameter  
+    val sample         // Maps to --sample parameter
+    
+    output:
+    path "analysis_*.txt"
+    
+    script:
+    """
+    echo "Analyzing file: ${inputFile}"
+    echo "Sample: ${sample}"
+    echo "Analysis results for ${sample}" > analysis_${sample}.txt
+    echo "File content:" >> analysis_${sample}.txt
+    cat ${inputFile} >> analysis_${sample}.txt
+    """
+}
+
+// Process with value inputs only
+process processValues {
+    debug true
+    
+    input:
+    val name           // Maps to --name parameter
+    val count          // Maps to --count parameter  
+    
+    script:
+    """
+    echo "Processing: ${name}"
+    echo "Count: ${count}"
+    echo "Computed result: \$((${count} * 2))"
+    """
+}
+
+// Process with multiple input types
+process handleMultiple {
+    debug true
+    publishDir "./results", mode: 'copy'
+    
+    input:
+    path data          // Maps to --data parameter
+    val format         // Maps to --format parameter  
+    val options        // Maps to --options parameter
+    
+    output:
+    path "output_*"
+    
+    script:
+    """
+    echo "Processing data: ${data}"
+    echo "Output format: ${format}" 
+    echo "Options: ${options}"
+    echo "Processed data in ${format} format" > output_${format}.txt
+    echo "Options used: ${options}" >> output_${format}.txt
+    echo "Original data:" >> output_${format}.txt
+    cat ${data} >> output_${format}.txt
+    """
+}
+
+// Process with each input (for collections)
+process processEach {
+    debug true
+    
+    input:
+    each item          // Maps to --item parameter (comma-separated values)
+    
+    script:
+    """
+    echo "Processing item: ${item}"
+    echo "Item processed: \$(date)"
+    """
+}
+
+/*
+ * USAGE EXAMPLES:
+ * 
+ * 1. File and value parameters:
+ *    ./launch.sh run complete_param_mapping_test.nf -entry process:analyzeFile --inputFile test_data.txt --sample "sample1"
+ * 
+ * 2. Value parameters only:
+ *    ./launch.sh run complete_param_mapping_test.nf -entry process:processValues --name "experiment1" --count 100
+ * 
+ * 3. Multiple mixed parameters:
+ *    ./launch.sh run complete_param_mapping_test.nf -entry process:handleMultiple --data input.csv --format "json" --options "verbose,debug"
+ * 
+ * 4. Each parameter with comma-separated values:
+ *    ./launch.sh run complete_param_mapping_test.nf -entry process:processEach --item "item1,item2,item3"
+ * 
+ * 5. Error handling (missing required parameter):
+ *    ./launch.sh run complete_param_mapping_test.nf -entry process:analyzeFile --inputFile test_data.txt
+ *    # Should show error: "Missing required parameter: --sample"
+ */