Task Execution

/**
 * Run one or many targets and their dependencies in topological order
 * Provides intelligent caching and parallel execution
 */
moon run <...targets> [-- <args>]

# Aliases:
moon r <...targets>
moonx <...targets>

# Target Format Patterns:
# project:task     Run specific task in specific project
# :task           Run task in all projects  
# #tag:task       Run task in projects with specified tag
# task            Run task in closest project (based on current directory)

# Arguments:
# <...targets>    One or more target patterns to execute
# [-- <args>]     Additional arguments passed to underlying command

# Core Options:
-f, --force             Force run ignoring touched files and affected status
--dependents           Run downstream dependent targets as well
-i, --interactive      Run target in interactive mode
--query <statement>    Filter projects using query language
-s, --summary          Display summary and stats of the run
-u, --updateCache      Bypass cache and force update existing items
--no-actions           Run task without other pipeline actions
-n, --no-bail          Continue executing tasks instead of aborting on failure

# Debugging Options:
--profile <type>       Record and generate profile (cpu, heap)

# Affected Options:
--affected             Only run if affected by changed files
--remote               Determine affected against remote (default branch)
--status <type>        Filter affected by change status
--stdin                Accept touched files from stdin for affected checks

# Run specific task in specific project
moon run app:build

# Run task across all projects
moon run :test

# Run multiple tasks
moon run app:build server:test

# Run task in projects with tag
moon run '#frontend:build'

# Run with query filtering
moon run :build --query "language=javascript"

# Force run ignoring cache
moon run app:build --force

# Run with summary output
moon run :test --summary

# Continue on failures (useful for pre-commit)
moon run :lint --no-bail

# Run only affected by changes
moon run :test --affected

# Pass additional arguments to underlying command
moon run app:serve -- --port 3000 --host 0.0.0.0

/**
 * Query language for filtering projects and tasks
 * Supports logical operators and various criteria
 */
--query <statement>

# Query Operators:
# &&               Logical AND
# ||               Logical OR  
# !                Logical NOT
# ()               Grouping

# Query Criteria:
# language=<lang>       Filter by programming language
# projectType=<type>    Filter by project type (application, library, tool)
# tag=<tag>            Filter by project tag
# project~<pattern>     Filter by project name pattern
# projectSource~<path>  Filter by project source path pattern

# TypeScript applications only
moon run :build --query "language=typescript && projectType=application"

# Projects with React in the name
moon run :test --query "project~react-*"

# Frontend tagged projects or libraries
moon run :lint --query "tag=frontend || projectType=library"

# Projects in packages directory
moon run :build --query "projectSource~packages/*"

/**
 * Display task dependency graph for analysis
 * Shows execution order and dependencies
 */
moon task-graph <...targets>

# Options:
--dot      Output in DOT format for Graphviz
--json     Output in JSON format for programmatic use

# Show task graph for build
moon task-graph app:build

# Generate DOT format for visualization
moon task-graph :test --dot > tasks.dot

# JSON format for scripting
moon task-graph app:build --json | jq '.nodes'

/**
 * Display action graph that would be executed
 * Includes tasks, dependency installations, and other actions
 */
moon action-graph <...targets>
# Alias: moon ag

# Options:
--dot      Output in DOT format
--json     Output in JSON format

/**
 * Display detailed information about a specific task
 * Shows configuration, dependencies, and metadata
 */
moon task <target>
# Alias: moon t

# Arguments:
# <target>    Task target in project:task format

# Options:
--json     Output in JSON format

# Get task information
moon task app:build

# JSON output for scripting
moon task app:build --json

# Change Status Types:
# all          All changes (default)
# added        Newly added files
# deleted      Deleted files  
# modified     Modified files
# staged       Files staged for commit
# unstaged     Unstaged changes
# untracked    Untracked files

# Environment Variables:
MOON_BASE=<revision>    Base revision for comparison (default: main branch)
MOON_HEAD=<revision>    Head revision for comparison (default: HEAD)

# Run tests only for affected projects
moon run :test --affected

# Check affected against remote branch
moon run :test --affected --remote

# Filter by specific change types
moon run :lint --affected --status modified --status added

# Custom revision comparison
MOON_BASE=develop MOON_HEAD=feature-branch moon run :test --affected

/**
 * Interactive mode for tasks requiring user input
 * Preserves stdin/stdout for interactive commands
 */
moon run <target> --interactive

# Use cases:
# - Interactive test runners (Jest watch mode)
# - Development servers requiring input
# - CLI tools with prompts
# - Debugging sessions

# Cache Modes (via --cache or MOON_CACHE):
# off          Disable caching entirely
# read         Read from cache but don't write
# read-write   Normal caching behavior (default)
# write        Write to cache but don't read

# Update cache for specific runs
moon run app:build --updateCache

# Disable caching for debugging
moon run app:test --cache off

# Set maximum concurrent tasks
moon run :build --concurrency 4

# Environment variable
MOON_CONCURRENCY=2 moon run :test