docs/CHANGELOG_V1.md
moonx as a binary to the @moonrepo/cli npm package.--upstream (dependencies) and --downstream (dependents) options to moon ci to control
the graph depth for affected tracking.mutex would not be respected, and tasks would still run in parallel.MOON_TOOLCHAIN_FORCE_GLOBALS has been set.optional parameter to task glob outputs.ParseManifestInput.root and ParseLockInput.root fields.package.json catalogs.parse_manifest to resolve versions from applicable catalogs.extends did not support query strings in URLs.project input types were not being included in the task hash, resulting in
re-runs not working.extends did not support query strings in URLs.projectsBuildData.json cache state.**/moon.yml and a root-level moon.yml existed,
would trigger an invalid identifier error.ParseLockOutput.packages field.unstable_deno
identifier.
deno.json and deno.jsonc manifest files.deno.lock lock files.deno install.unstable_javascript toolchain.project://<id>project: '<id>'^.group://<name>group: '<name>'@files, @globs, etc, token functions.file://<path> and file: '<path>'glob://<pattern> and glob: '<pattern>'optional support to file outputs.runInCI task option:
only - Only run the task in CI, and not locally, when affected.skip - Skip running in CI but run locally and allow task relationships to be valid.packageManager with deno.install_dependencies and setup_environment to take project toolchain configuration
into account.ManifestDependencyConfig.reference field.SyncProjectInput.toolchain_workspace_config field.go.mod parsing failures when tool is a list.uv venv.MOON_TASK_RETRY_ATTEMPT and MOON_TASK_RETRY_TOTAL environment
variables, which can be accessed in child processes.ARG<n> (1-index based).PATH
correctly.pnpm-lock.yaml parsing issues when using pnpm as a package manager.PATHs may not always be injected correctly.package.json dependency version parsing issues..prototools, as there's no way to differentiate between the legacy and modern
toolchains.moon query touched-files to default to comparing against remote branches when in CI, and
local when not in CI. This aligns with the other moon query commands.
--local and --remote flags.unstable_javascript
unstable_bun and unstable_node
unstable_javascript
plugin.unstable_npm, unstable_pnpm, and unstable_yarn
unstable_javascript plugin.npm-shrinkwrap.json.node, and is now configured at the top-level within
.moon/toolchain.yml.cache option, alongside the existing boolean.
local to only use the local cache.remote to only use the remote cache.unstable_remote.cache.localReadOnly setting, which turns local development caching
into a read-only mode (only downloads, doesn't upload).PATH.moon task command to include all PATHs that are injected when running the task.moon run --profile option.
unstable_node
toolchain.MOON_TASK_HASH environment variable for the current hash,
which can be read from child processes.PATH, even
when proto is not required.affectedFiles and runFromWorkspaceRoot generating invalid
paths.moon docker file generating invalid Dockerfiles after the recent proto install changes.bins when installing multiple packages from different modules in parallel.uv venv, we now include the --no-managed-python flag when the python.version
setting is defined. This should ensure that moon/proto's Python managed version is used.uv sync, we now include the --no-managed-python flag unless the
python.uv.syncArgs setting is defined.path and git values from dependencies.includeSharedTypes and syncProjectReferences are both enabled, and the shared types
folder contains a tsconfig.json, it will also be synced as a project reference.define_requirements plugin API for tier 2.DefineRequirementsInput and DefineRequirementsOutput types.MoonContext.get_project_root and get_project_root_from_source methods.ExtendProjectGraphInput.toolchain_config field.ExtendTaskCommandInput.toolchain_config and project fields.ExtendTaskScriptInput.toolchain_config and project fields.load_toolchain_config and load_project_toolchain_config functions.load_toolchain_config_by_id host function.moon setup failing when proto is not available.$HOME, $USER, and $PWD environment variables.layer would trigger a violation error.? and wasn't in URI format.type for layer, etc).@moonrepo/cli package.SetupProto action, which is now part of the
action graph, and does not run on every command. It's also a bit smarter and will only install
when a toolchain requires it.file://) and globs (glob://).optional param, which allows the file to be optional (missing) during hashing.
Defaults to true.content param, which will match against the file's contents to determine affected
state.cache param, which controls whether the glob results should be cached or not.@moonrepo/cli npm package to no longer rely on postinstall scripts.type to layer, as it better reflects what it does, a layer of access within
the project stack. For backwards compatibility, the type name will still be supported until
v2. The following changes have been made:
type -> layer in moon.yml--type -> --layer in moon query projectsprojectType -> projectLayer for MQL$projectType -> $projectLayer for task tokensenforceProjectTypeRelationships -> enforceLayerRelationships in .moon/workspace.ymlmoon query touched-files --defaultBranch requiring a "true" or "false" explicit value.go.* parsing failures when there was no trailing newline.spec" error. This is triggered when the global proto binary is
using v0.51, and moon is using proto < v0.50.5.bun.lock parsing error.2025-06-18 from
2025-03-26 - in turn, allowing Claude Code to use the MCP.
sync_projects tool to sync all projects if no IDs provided.moon ci job calculation.versionFromPrototools, which controls how we inherit
a version from the root .prototools file. By default this is enabled, but can be configured with
a string if the IDs don't match.extend_task_script WASM
API.moon setup to also install toolchain plugins..prototools.moon docker prune would force install all toolchains. If you were relying
on this functionality, run moon docker setup instead.ExtendTaskScriptOutput.script field.RegisterToolchainOutput.lock_file_name to RegisterToolchainOutput.lock_file_names
and its type to Vec<String>.RegisterToolchainOutput.manifest_file_name to
RegisterToolchainOutput.manifest_file_names and its type to Vec<String>.unstable_go
identifier.
go.work files.go.mod files.go.sum and go.work.sum files.go mod vendor) during Docker prune.moon mcp.
get_touched_files - Gets touched files between base and head.sync_projects - Runs the SyncProject action for one or many projects.sync_workspace - Runs the SyncWorkspace action.moon toolchain command and sub-commands.
.moon/toolchain.yml with moon toolchain add.moon toolchain info.notifier.terminalNotifications setting in .moon/workspace.yml.notifier.webhookAcknowledge setting, that ensures webhooks resolve with a 2xx status
code.rust_toolchain to v0.2.0.
LocateDependenciesRootInput.toolchain_config field.PruneDockerInput.toolchain_config field.ScaffoldDockerInput.toolchain_config field.git:// based code generation couldn't checkout a specific commit.moon migrate --skipTouchedFilesCheck option.moon ci to always run the sync workspace action, even when no tasks are affected.git commands would attempt to execute, even when no git binary was found.moon docker scaffold would over scaffold the same project multiple times.MOON_TOOLCHAIN_FORCE_GLOBALS is set.git commands that are executed for git:// based code generation.llms.txt file to our website.MOON_WORKSPACE_ROOT environment variable.rust_toolchain to v0.1.2.
cargo-binstall failing in CI when the binary already exists.SetupEnvironmentInput.globals_dir field.unstable_rust identifier (instead of rust).
addMsrvConstraint setting.moon mcp command, which starts an MCP (model context protocol) stdio server
that responds to AI agent requests.
get_project, get_projects, get_task, get_tasks.run_task, etc.environment.initializing and environment.initialized events.root and toolchain fields to dependencies.installing and dependencies.installed
events.runtime field in all events. Will be removed once toolchain plugins are
complete.SetupEnvironment and InstallDependencies actions.ManifestDependency type to be an enum instead of a struct.ProjectDependency.via field.${VAR:+default}) were
not parsed correctly.$E: - Elvish$env:: - Ion$ENV. - Murex$env. - Nu$env: - PowerShellMOON_TOOLCHAIN_FORCE_GLOBALS wasn't respected for Python and Rust
toolchains.SetupEnvironment action that executes the setup_environment WASM API.InstallDependencies action that executes the install_dependencies WASM API.docker prune to utilize the new WASM APIs for toolchain plugins.--host and --port options to moon action-graph, moon task-graph, and
moon project-graph.--stdin option to moon ci and moon run, which will allow touched files to be passed
via stdin, instead of running VCS commands to determine them.
unstable_remote.cache.verifyIntegrity setting, that will verify the digest of
downloaded blobs to ensure they aren't corrupted or incomplete. Will degrade performance but
ensure reliability.array and object variable types in template.yml. The values must be JSON
compatible.generator.templates to support https:// URLs that point to an archive that can be
unpacked.moon.{yml,pkl} not being allowed as a task input. However, will
not be included when using **/*.args or env of a task dependency would not invalidate its cache.env.extend_project_graph - Extend projects with toolchain specific info.extend_task_command - Extend the command child process with parameters.extend_task_script - Extend the script child process with parameters.locate_dependencies_root - Locate the package dependencies workspace root.parse_manifest - Parse a manifest file to extract dependencies.parse_lock - Parse a lock file to extract resolved dependencies.InstallDependenciesInput.packages and production fields.InstallDependenciesOutput.operations field.PruneDockerInput.projects and root fields.PruneDockerOutput.SetupEnvironmentOutput.operations field.SetupToolchainOutput.operations field.SyncWorkspaceInput.toolchain_config field.TeardownToolchainInput.version field.moon ci and moon run accepting touched files via stdin, as it's causing issues in CI
environments. Will revisit for the next release.moon run to support passing touched files via stdin.affectedFiles and runFromWorkspaceRoot would pass invalid relative
file paths.moon ci to support passing touched files via stdin.InstallDependencies action for WASM plugins.
SetupEnvironment action for WASM plugins.
SetupToolchain but before InstallDependencies.RunTask to setup toolchains and install dependencies for each toolchain that has
been configured, instead of just the 1st one (work in progress).SyncProject to no longer depend on SetupToolchain, and not be grouped by
language/toolchain, and instead encompass all of them applicable to the project.cacheKey, which can be used to seed the hash, and invalidate local and
remote caches.priority, that controls the position in the pipeline queue.
critical, high, normal (default), or low.--log=verbose level, which includes span information on top of the trace level.--theme=light or MOON_THEME=light.
toolchain.installing and toolchain.installed, which emit when a
toolchain WASM plugin is installing a tool (via proto).experiments.fasterGlobWalk and experiments.gitV2 experiments.locate_dependencies_root - Locates the dependencies root (workspace).setup_environment - Runs operations to setup an environment for a project/workspace before
installing dependencies and running tasks.install_dependencies - Defines commands to install/dedupe dependencies.setup_toolchain - Runs operations after the tool has been installed.teardown_toolchain - Runs operations before the tool will be uninstalled.inputs wouldn't filter the file list when hashing.--version and --help.moon templates to render a list of data.moon query projects and moon query tasks to render a table of data.pipeline (formerly runner) in .moon/workspace.yml to control which
kinds of action nodes exist in the action graph when running tasks.
syncWorkspace setting toggles the root SyncWorkspace action.syncProjects setting toggles the SyncProject actions, and can be scoped to project IDs.syncProjectDependencies setting toggles whether to recursively link SyncProject actions
based on project dependencies.installDependencies setting toggles the InstallWorkspaceDeps and InstallProjectDeps
actions, and can be scoped to toolchain IDs.experiments.fasterGlobWalk setting to .moon/workspace.yml, that will use a better
glob walker implementation. Do note that this is experimental and may be buggy!
experiments.gitV2 setting to .moon/workspace.yml, that uses a new Git implementation.
--no-actions flag to moon run, that will run the task without including the other
actions, like SyncProject, SetupToolchain, etc.--json flag to moon templates.pipeline.archivableTargets setting. All tasks are now automatically cached if
using Bazel Remote Caching.moon docker file to inherit the default Docker image from any applicable toolchain
plugins.moon sync to no longer be deprecated, and instead sync the workspace and all projects.DefineDockerMetadataOutput.default_image field.SettingPrompt.description field.npx @moonrepo/cli would no longer work.toolchain.typescript = true in moon.yml would not inherit it as a
toolchain.MOON_REMOTE_* environment variables for many unstable_remote settings.toolchain disabled state in
moon.yml into account.preset would sometimes not be inherited when using extends.typescript_toolchain to v0.1.3.
extends is missing during task hashing.moon.yml.
# Before
toolchain:
typescript:
disable: true
# After
toolchain:
typescript: false # or null
--include option from moon docker scaffold (it's been long deprecated). Use the
docker settings instead.typescript settings in .moon/toolchain.yml can now be defined as overrides in
moon.yml.SyncWorkspace and SyncProject actions.moon docker commands.moonx executable, which is a shorthand for moon run.
moon
binary.moon run ~:build, which will run the build task in the closest project
(traversing upwards).$XDG_DATA_HOME support when detecting the moon store. Will be used if $MOON_HOME is not
set, and will fallback to $HOME/.moon.moon init with toolchain plugin support.toolchain.default in moon.yml to support a list of IDs.unstable_remote.auth.headers to support environment variable interpolation..moon/cache/schemas to dynamically include toolchain plugin
configuration.git hash-object) to continously pipe stdin to avoid hanging processes.hasher.batchSize in .moon/workspace.yml.register_toolchain - Registers the toolchain and provide metadata for detection and other
purposes.initialize_toolchain - Provides prompts to use during moon init to gather settings values.define_toolchain_config - Defines a configuration schema for use within JSON schemas.define_docker_metadata - Defines metadata related to docker commands.hash_task_contents - Injects content into the task hashing process.prune_docker - Custom operations to run during docker prune.scaffold_docker - Custom operations to run during docker scaffold.sync_project - Runs syncing operations per project (during the SyncProject action).sync_workspace - Runs syncing operations at the workspace root (during the SyncWorkspace
action).download_extension to v0.0.9.migrate_nx_extension to v0.0.9.
--cleanup to remove them.migrate_turborepo_extension to v0.1.6.
--cleanup to remove them.git hash-object) would hang when there are too many files
being hashed.script would always be forced to the "system" toolchain.moon task-graph, moon-project-graph, and moon action-graph to request a port
dynamically, instead of defaulting to 8000.moon *-graph commands could not be CTRL+C'd.git clone failed.project.name in pyproject.toml.project.dependencies in pyproject.toml.
tool.uv or workspaces.pyproject.toml or uv.lock would sometimes not be parsed.moon setup wouldn't load configuration.moon docker scaffold would unexpectedly install the toolchain languages.moon docker scaffold would not copy uv.toml and uv.lock files.python.version wouldn't regenerate the Python virtual environment.NO_COLOR or FORCE_COLOR would be overwritten for task child processes.runner.killProcessThreshold setting to control the threshold in which to force kill
child processes when a signal is received. Defaults to 2 seconds.bash and batch project language's would not inherit tasks.bun.lock parsing issues.yarn.lock files throughout the repository, allowing for
multiple Yarn/Node workspaces..pkl) based configuration to always be enabled, and is no longer hidden behind an
experimental flag.
http(s) protocols for gRPC servers, instead of just grpc(s).unstable_remote.api setting, which can be used to inform the server's API format.
Defaults to grpc.unstable_remote.auth setting, which can be used for HTTP Bearer/token Authorization
based endpoints. Can also be used to set headers for all requests.MOON_DEBUG_REMOTE environment variable, which can be used to debug internal errors for
diagnosing connection/integration issues.bun.lock file. We do our best to detect this, but we suggest
configuring --save-text-lockfile.deno install. Will now run this command instead of deno cache.deno_lockfile crate).deno.installArgs setting.python.packageManager and python.uv
settings.
python.rootRequirementsOnly to python.rootVenvOnly (old name still works)..prototools.dependsOn) are now automatically inferred from Cargo.toml
dependencies.inferInputs option to not infer environment variables from popular CI/CD
providers, as those values constantly change, causing tasks to always be affected. If you would
like to reference these values, add them as an explicit inputs.moon commands are
ran in parallel.NO_COLOR and FORCE_COLOR being unexpectedly set in some situations.language would no longer inherit global tasks of the same
name.platform setting in moon.yml, use toolchain.default instead.
language setting and any
config files in the project/workspace root. This pattern is preferred when possible.platform task setting, use toolchain instead.taskPlatform query field, use taskToolchain instead.--platform option for moon query tasks, use --toolchain instead.$taskPlatform token, use $taskToolchain instead.moon run and moon ci using a glob-like syntax.
:build-*, app-*:build, #tag-{foo,bar}:build, etc.--no-bail flag to moon run, that will continue running tasks even when a task fails.glob://) to generator.templates in .moon/workspace.yml, allowing you
to glob for your codegen template locations.inferInputs, that will automatically infer inputs based on file groups and
substituted environment variables used within the task.runInCI to support the values "always" (always run) and "affected" (only run
if affected, same as true).script, command, args, or env.extends setting in .moon/workspace.yml, toolchain.yml, and tasks.yml, to
support a list of files/URLs to extend.unstable_remote.cache.compression setting, which can be set to zstd to enable
zstandard compression on output blobs.moon templates command:
--filter option to filter the templates list by ID.ctrl+cing multiple persistent tasks would sometimes leave them running in
the background.python venv would fail to find an applicable Python version.python.version is not
defined.moon ci showing incorrect job related logs.python.rootRequirementsOnly to false by default.requirements.txt, otherwise the package root, or
workspace root if python.rootRequirementsOnly is enabled.PATH.inputs: []) would always be marked as
affected.moon ci would trigger a shallow checkout error, even when a base revision
is provided.id setting in moon.yml, you can no longer reference that
project in dependencies and targets using its original ID.moon query tasks command.
moon project-graph --json output no longer includes task data (the tasks field is an empty
map).
moon task-graph to access this data, and piece things together using the project
taskTargets field.moon project --json output pieces everything together automatically.bazel-remote to be used.version is configured.requirements.txt to resolve and install dependencies.python setting to .moon/toolchain.yml.toolchain.python setting to moon.yml.moon bin commands to support Python.moon task-graph command.--upstream and --downstream options to moon query tasks.$arch, $os, $osFamily, $vcsBranch, $vcsRepository,
$vcsRevision, $workingDirrust.binstallVersion setting to .moon/toolchain.yml.read() for environment variables.strictProjectIds experiment and you can no longer reference the original ID.disallowRunInCiMismatch experiment and you can no longer have a CI based task
depend on a non-CI based task.moon project-graph <id> not including all dependencies/dependents. It was only showing
direct relationships.experiments.strictProjectIds setting to .moon/workspace.yml. When enabled, will
disallow using original IDs for renamed projects (via the id setting) when building the project
graph.destination to be relative from the workspace root if prefixed with
/, otherwise the current working directory.[working_dir] and [workspace_root] variables were not working in the
template.yml destination setting.npx commands (primarily through lockfile deduping)..env files not existing in certain environments.timeout would apply to the overall run, and not for each
attempt when using the retryCount option.merge, that defines the same strategy for all applicable fields. Can be
overridden with mergeX task options.moon setting to .moon/toolchain.yml, which can be used to customize the update check
process.moon query projects including dependency projects by default. Can be controlled with
--upstream.moon query projects regex patterns not working when used in conjunction with affected.--upstream and --downstream options to moon query projects.cacheLifetime, that controls how long a task will be cached for.preserve, that preserves the original inherited value.vcs.hookFormat to .moon/workspace.yml, that can customize the shell/file
format for hooks.outputs to support token and environment variables.moon query projects to include the project description as a trailing value.moon query tasks to include the task type and platform, and the task description as a
trailing value.**/* inputs for tasks..git to exist).id was renamed in moon.yml wasn't being reflected when
inheriting project dependencies through the toolchain/platform integration.optionalDependencies not being considered a project relationship for Bun/Node implicit
package.json detection.moon ci.
bun bun.lockb commands, instead of running them for every task.$FOO or ${FOO} - If variable is missing, keeps the original syntax (current default).$FOO? or ${FOO?} - If variable is missing, replaces with an empty string.$FOO! or ${FOO!} - Ignores variable substitution and preserves the syntax (without !).*, $, +, and [].register_extension API. All built-in extensions
have been updated.actionPipelineV2 experiment and the new pipeline is now always enabled. The old
pipeline code has been deleted. If you run into any problems, please report an issue!strictProjectAliases experiment and enabled its functionality going forward.preset task setting, that enables a collection of task options.
local setting, which is now deprecated.os task option, which allows a specific operating system to be targeted for the task.@meta token function that can access project metadata.$projectName, $projectChannel, and $projectOwner token variables.codeowners.requiredApprovals setting to .moon/workspace.yml, that will apply
requirements to all paths.disallowRunInCiMismatch, that errors when a task that is runInCI
enabled depends on a task that is runInCI disabled. These kinds of relationships cause a handful
of issues in the pipeline.
moon ci and may also apply to moon run in the future.MOON_TOOLCHAIN_FORCE_GLOBALS to support filtering by tool IDs, instead of applying to
everything..prototools..prototools wasn't always loaded.requiredAppprovals wouldn't allow 1.runInCI: false, would not run
as affected in moon ci because the dependency task was skipped.There have been reports of the moon.exe binary being flagged as a Trojan on Windows. This looks to
be a common false positive (Wacatac.B!ml) that targets Rust built binaries (as seen in the
Tauri project as well).
While this isn't a simple fix on our end, we're publishing a new binary to replace the old one. You
may also have to unquarantine moon on your system. And lastly, we also suggest
adding an exclusion for moon.exe to Windows Defender.
moon query results.moon docker scaffold would not respect .gitignore files.git status.project.metadata to moon.yml so that custom fields can be defined.@in and @out tokens not being able to reference other token functions.script or env weren't resolving relative
to the project or workspace root (based on options).experiments.actionPipelineV2 setting in .moon/workspace.yml by default.
script, as an alternative to command + args.
&&), pipes, and redirects.moon docker file, that can be used to generate an initial multi-stage
Dockerfile for a project.docker settings to both .moon/workspace.yml and moon.yml, allowing it to be
configured at the workspace and project levels.unixShell and windowsShell task options..moon/cache/schemas, so that they
can be dynamically created based on the current moon version and environment.
moon sync config-schemas command to manually run this operation.node.syncPackageManagerField setting, to control the packageManager field in
package.json.yarn set version and instead rely entirely on proto's toolchain.bun.installArgs and node.bun.installArgs to stay in sync.moon run --affected not auto-installing dependencies in CI.pwsh.exe would not fallback to powershell.exe when the former does
not exist.CARGO_HOME during automatic rustup installation.CARGO_HOME, to support relative paths../.moon docker scaffold.sh instead of bash when one could not be detected.ciReport.json file not being created with the experimental pipeline.--version and in logs.target.* events to task.*, and *.finished to *.completed.pipeline.aborted event. Instead, an aborted field is now passed to
pipeline.completed.action field with a new node field within task.* events.pipeline.completed entirely. Instead of calculating values for you, we now pass all
results allowing you to calculate them yourself.experiments.actionPipelineV2 setting in .moon/workspace.yml.
options.timeout setting).SyncNodeProject(app) -> SyncProject(node, app)).--dump flag, that will dump a trace profile that can be inspected in
chrome://tracing.moon completions command to support Nushell.unixShell with new options: ion, nu (nushell), pwsh (powershell), xonsh.windowsShell with new options: elvish, fish, nu (nushell), xonsh.package.json packageManager field would be set with an invalid
version specifier.bun.version and node.bun.version to stay in sync when one is defined and the other
isn't. This helps to avoid tool discrepancies.moon --version.git version parsing when the version contains invalid semver parts.download to v0.0.5.migrate-nx to v0.0.5.migrate-turborepo to v0.1.2.
moon docker scaffold that ensures that .moon/cache is ignored in a root
.dockerignore file. This helps to avoid interoperability issues.moon docker commands to help uncover future issues.noop tasks would not cache / invalidate cache. This is a regression from
the recent task runner changes.target-output.archiving,
target-output.archived, target-output.hydrating, target-output.hydrated,
target-output.cache-check.--summary flag to moon run and moon check that will include a summary of all actions
that were processed/failed within the pipeline. This is the same output used in moon ci..prototools in the workspace root was not being respected when running moon
commands in a sub-directory.PROTO_*_VERSION environment variables being set to *, resulting in unexpected versions
being resolved.@moonrepo/cli to work better on Windows.runInCI was being overzealously applied to moon run commands.runInCI weren't always being filtered properly.deps.env not supporting variable substitution.core.hooksPath setting is
now only used if the path is within the current repository..prototools weren't being respected.deps.args and deps.env not expanding tokens correctly.moon templates command, that lists all available codegen templates.--dependents flag to moon project-graph <id> and moon query projects, to include
downstream dependents of a focused/affected project.mutex task option, allowing for exclusivity and to ensure only 1 task is running at a
time for the same mutex.runner.autoCleanCache setting to .moon/workspace.yml, allowing the post-run clean
mechanism to be controlled.moon ci to automatically determine base/head revisions based on your current CI provider
(when applicable).moon generate:
multiple is enabled.?layout= query parameter.dagre (default), klay, grid, breadthfirst**/*. This is typically what
users want, to avoid greedy tasks.language field.node.packageManager: 'bun'../ in input/output globs would cause matching failures.moon query.moon docker scaffold would copy all sources when a project depends on a
root-level project.bun_plugin to v0.11.
moon clean wasn't removing nested files.package.json syncing would create incorrect link:s for Bun.moon ext would trigger a "No such file or directory" error.migrate-nx to v0.0.3.
package.json names.git: and npm: locators to the generator.templates setting in .moon/workspace.yml.
id setting to template.yml, so that templates can customize their name (instead of
using the folder name).variables() function for templates that returns an object of all variables available.template.yml:
order setting to control the order in which they are prompted for.internal setting that ignores values passed on the command line.default settings to support an array of values.internal task option, which marks tasks as internal only..moon/tasks/node-frontend.yml or .moon/tasks/bun-backend-application.yml.moon project and moon task to include the configuration files that tasks inherit from.moon task to include the modes it belongs to.platform was being detected as node (when not enabled), and
should have been bun. If you're using both bun and node in the same workspace, moon has a
hard time detecting which should be used for what project. If you run into issues, explicitly set
the platform in the project's moon.yml.MOON_DEBUG_WASM environment variable, for including additional logging output, and
optionally dumping memory/core profiles.moon docker scaffold where Rust projects in the workspace skeleton would
fail to compile as they were missing a lib/main entry point.moon docker prune where an unknown project type would trigger toolchain
errors.env variable substitution not being able to reference values from an .env file.bun.lockb would fail if using github: protocols.stack setting into account. For
example, frontend applications can now depend on backend applications, where as previously they
could not.In v1.22, we made a change to affected tasks that
pass all inputs as arguments, instead of passing .. This change was made to not overzealously
pass files to the task that it doesn't care about, but it ended up causing problems for certain
commands.
We didn't want to revert the change, but it also wasn't easy to fix without causing other issues, so
as a compromise, we opted to introduce a new task option, affectedPassInputs to handle this
functionality.
configuration and scaffolding variants to the project type setting in moon.yml.
stack setting to moon.yml, for categorizing which tech stack it belongs to.
frontend, backend, infrastructure, and systems.projectStack field to the query language (MQL).$projectStack token variable for tasks.moon query projects command to support a --stack option, and include the stack
in the output.moon project command to include the stack in the output.description setting for tasks, for providing human-readable information.
moon project and moon task commands to include the description in the output.installArgs setting for bun/npm/pnpm/yarn in .moon/toolchain.yml, to customize the
args used when installing dependencies.migrate-nx, for migrating from Nx to moon.
nx.json, workspace.json, and project.json files.*, for example
$VITE_*.
VITE_.envFile task option to support a list of file paths.migrate-turborepo extension.
inputs as the list of files provided, instead of ..bun install was not running with --production in Docker prune.$PWD in a task was pointing to the wrong directory.deno_plugin to v0.9.1.
rust_plugin to v0.8.1.
liblzma.5.dylib issues on macOS arm64.moon ci, is a hard failure.moon run, will disable affected checks.version is configured.deno.lock lockfile to extract and resolve dependencies.deno.version setting to .moon/toolchain.yml.toolchain.deno setting to moon.yml.moon bin and moon docker commands to support Deno.migrate-turborepo, with new functionality.
moon migrate from-turborepo command.--bun flag.globalDotEnv, dotEnv, and outputMode.moon node run-script.moon.yml, instead of warning.unixShell and windowsShell task options, so that the underlying shell can be configured
per task.bun.inferTasksFromScripts setting to .moon/toolchain.yml, for compatibility with
Node.js.fileGroups.@envs(group) token function for referencing environment variables.--quiet global argument, for hiding non-critical moon output.moon node run-script command. Run the task through a package manager instead,
like npm run or yarn run.shell option, so that glob
expansion works correctly.moon docker scaffold not copying the project specific moon.yml file, resulting in a
skewed project graph.moon ext command.taskOptions setting to .moon task configs, allowing default task options to be
defined.
optional field to task deps, allowing the dependency to be optional during
inheritance.moon run,
moon check, and moon ci.
bun_plugin to v0.9.node_plugin and node_depman_plugin to v0.9.
bundled-npm and intercept-globals settings to be false by default (instead of
true).rust_plugin to v0.8.This fixes a bad 1.19.2 release.
proto binary was not available.proto binary not being available in a Dockerfile when running moon docker commands.@moonrepo/cli postinstall script not working correctly for Bun Arm64.experiments.interweavedTaskInheritance setting from .moon/workspace.yml.
Interweaved inheritance is now always enabled (was previously true by default).experiments.taskOutputBoundaries setting from .moon/workspace.yml. We opted to
remove boundaries entirely, as they caused more problems than solved. Task outputs may now overlap
without issue.implicitDeps in .moon/tasks.yml and task deps in moon.yml to support arguments and
environment variables for the dependency target.destination field to template.yml, to customize a default location.extends field to template.yml, allowing templates to extend and inherit other
templates.[var] syntax to support filters: [var | camel_case].bun_plugin to v0.7.node_plugin and node_depman_plugin to v0.7.rust_plugin to v0.6.experiments.strictProjectAliases setting
in .moon/workspace.yml..
(ignore dotfiles).@dirs and @files tokens didn't always work correctly in outputs.@moonrepo/cli package pulling in different @moonrepo/core-* versionsproto even when not required.PATH to locate the executable.shell option.proto binary if it does not exist.moon init command.
--to option.bun tool.moon.yml to support customizing the project name using the id field.
.moon/workspace.yml.MOON_INSTALL_DIR environment variable, to control where the moon binary is installed
to.moon upgrade failing when not ran in a moon workspace.CODEOWNERS being written with double trailing newlines.bun_plugin to v0.6.node_plugin and node_depman_plugin to v0.6.1.rust_plugin to v0.5.typescript.includeProjectReferenceSources and typescript.syncProjectReferencesToPaths
settings not including project references that were manually added (not auto-synced).cargo-binstall would error when trying to install it and it already exists.version is configured.bun.lockb lockfile to extract and resolve dependencies.bun setting to .moon/toolchain.yml.toolchain.bun setting to moon.yml.moon bin and moon docker commands to support Bun.platform to support "bun".typescript.root setting to denote the TypeScript root.typescript.includeSharedTypes setting, for syncing a shared types path to all
project's include.typescript.includeProjectReferenceSources setting, for syncing project reference files
to all project's include.typescript.syncProjectReferencesToPaths setting to always include the wildcard, and
not require an index file.bun.rootPackageOnly and node.rootPackageOnly settings to support the "one version
rule" pattern.build scope instead of peer scope. This
should alleviate some of the pain points with package.json syncing.moon.yml files.node_depman_plugin to v0.5.1.projects globs to support ending in moon.yml.node.dependencyVersionFormat to fallback to a supported format when the chosen
node.packageManager does not support the configured (or default) version format.package.json, when a
root-level project was dependending on non-root project tasks.bun_plugin to v0.5.deno_plugin to v0.5.go_plugin to v0.5.node_plugin and node_depman_plugin to v0.5.python_plugin to v0.2.rust_plugin to v0.4.schema_plugin (TOML) to v0.5.moon ci not treating dependents as "CI only" when running locally.../** **/).node.packageManager: 'bun'.rust.components and rust.targets settings to .moon/toolchain.yml.rustup when the pipeline is ran.MOON_TOOLCHAIN_FORCE_GLOBALS environment variable, that will force all toolchain tools
to use the global binary available on PATH, instead of downloading and installing.experiments.interweavedTaskInheritance: false in
.moon/workspace.yml.automation, for projects like E2E and integration testing.yarn dlx, pnpm dlx,
bunx.moon ci and git would fail if there's only 1 commit on the base branch.runInCI was not respected when a task is a dependency of an affected task.replace merge strategy would not apply for empty values.PROTO_OFFLINE wouldn't use global binaries when available.moon run --interactive to allow more than 1 target.SyncProject action
type.build dependencies, and be over
zealous with root-level projects.cargo-binstall package.deps) on other tasks from arbitrary projects (the parent project doesn't
implicitly or explicitly depend on the other project) will now automatically mark that other
project as a "peer" dependency. For example, "b" becomes a peer dependency for "a".SyncWorkspace action, instead of this action running
arbitrarily.RunTarget to RunTask, including interactive and persistent variants.moonrepo/setup-toolchain,
that replaces both setup-moon-action and setup-proto.moon action-graph command.--dependents argument to moon action-graph.RunTask actions using environment variables.moon dep-graph command.moon ci or moon run --dependents) wouldn't always
locate all downstream tasks.moon docker scaffold was too greedy and would copy files it shouldn't.PATH inconsistencies when executing npm/pnpm/yarn binaries.lower_case and upper_case stripping characters.moon dep-graph to support a task in closest project, similar to moon run.extends setting..moon/tasks would be parsed as YAML configs.moon run shorthand, where "run" can be omitted. For example, moon run app:build can be
written as moon app:build.
:.moon ci to support running an explicit list of targets, instead of running everything.node.version, npm.version, pnpm.version, yarn.version, and rust.version to
support partial versions and requirements/ranges like 1.2, 1, or ^1.2..moon/tasks to support nested folders, for better organization of task files.projectName query would not work correctly.rust toolchain and attempting to install bins.pnpm or yarn would panic based on configuration combination.deps within global tasks would not apply exclude/rename overrides.moon upgrade would require a workspace.allowFailure task option, allowing tasks to fail without bailing the entire run.
--help menus.runner.archivableTargets to support tag scoped targets.moon query tasks to filter out projects with no tasks.moon query tasks --affected to filter based on affected task, instead of affected
project.moon init not using the remote default branch when scaffolding.interactive field to task options. This marks tasks as interactive, so they can use
stdin.extends field to task configurations. This allows tasks to extend and inherit settings
from sibling tasks.env values to support token functions and variables.outputs to support negated globs..yaml extension.moon ci would no run affected targets based on touched files.moon project-graph --json to include the fully expanded graph data._).experiments setting to .moon/workspace.yml.command and args are now substituted.deps can now depend on tag targets (#tag:task).env are now used when substituting values, alongside system-level.outputs can now use token variables..raw extension.project to query both project name AND alias.projectName for only querying by name.@files token would not invalidate the project graph cache..env would not invalidate the project graph cache..gitignore patterns weren't always applied correctly.git hash-object commands would fail if moon was setup in a sub-directory.--json), resulting in JSON parsing errors.These changes are fixing edge cases that should not have been allowed, but may break existing repos. If these changes become troublesome, we'll revert.
MOON_BASE and MOON_HEAD environment variables.
moon ci and moon run.deno.bins setting to .moon/toolchain.yml.hasher.ignorePatterns and hasher.ignoreMissingPatterns settings to
.moon/workspace.yml.moon ci to include a summary of all failed actions.moon run to compare against the previous commit when running on the default branch and
using --remote.rust.bins in .moon/toolchain.yml to support an object for each bin entry.
git --version.vcs.hooks and vcs.syncHooks settings to .moon/workspace.yml.moon sync hooks command.--clean and --force flags to moon sync codeowners command.moon init to:
vcs.provider setting.InstallNodeDeps action to SetupNodeTool action. This includes
syncing packageManager, engines, and version files. This should feel more natural.dev, start, or serve tasks would not always be marked as local.CODEOWNERS to take .editorconfig into account when generating.git branch commands would fail on <= v2.22.@moonrepo/types.CODEOWNERS) support.
owners setting to moon.yml.codeowners setting to .moon/workspace.yml.moon sync codeowners command.vcs.provider setting to .moon/workspace.yml.SyncWorkspace, that'll be used for workspace-level checks.workspace.syncing and workspace.synced webhooks.MOON_OUTPUT_STYLE and MOON_RETRY_COUNT environment variables.moon sync command, use moon sync projects instead.cargo generate-lockfile would run in the wrong directory.--color.--log or MOON_LOG would error when running nested moon commands.;, &&, etc.persistent task option to moon.yml (is also set via local).platform detection to only use the platform if the toolchain language is enabled.runInCI was false.rust as a supported platform variant.rust setting to .moon/toolchain.yml.toolchain.rust setting to moon.yml.rust setting in .prototools.moon init and moon bin commands to support Rust.moon docker scaffold command to scaffold Cargo files.moon docker prune command to delete the target directory.run when it should be test.moon init --yes to not enable all tools, and instead enable based on file detection.moon init templates. Will no longer scaffold .moon/tasks.yml.#tag:task, which will run a task for all projects with the
given tag.moon query projects and moon query tasks to support MQL for filtering results.node.aliasPackageNames setting. Aliases will always be loaded now.pnpm-lock.yaml with no packages would fail to parse.git status, which would log a warning.--query option to the moon run command, allowing for advanced targeting.manifest.json.node_modules/.bin/moon as another lookup location for the moon binary when running
globally.$projectAlias token was not substituting correctly..moon/tasks/tag-<name>.yml.MOON_COLOR would fail validation.commands.moon task command, for viewing resolved information about a task.moon run to be able to run tasks in the closest project based on current working
directory.noop tasks to be cacheable, so that they can be used for cache hit early returns.moon binary.hasher.batchSize to control the number of files to be hashed per batch.git hash-object during the
inputs collection process. For large projects, you'll see improved performance.hasher.walkStrategy
was "vcs".noop task would not start or run in
parallel.moon run or moon check would hang when not running in a workspace.~/.moon.envFile to log a warning instead of triggering an error when .env. is missing.envFile to support workspace relative paths when prefixed with /..moon/tasks/*.yml were not scaffolded into Dockerfiles.moon upgrade command to install the moon binary to
~/.moon/bin.constraints setting to .moon/workspace.yml, allowing for project/dep relationships to
be enforced.hasher.warnOnMissingInputs setting to .moon/workspace.yml.shell task option to moon.yml that will wrap system tasks in a shell.tags setting to moon.yml for project categorization.--tags option to the moon query projects command.telemetry setting to .moon/workspace.yml.$projectAlias, $date, $time, $datetime, and $timestamp.env and .env files to support variable substitution using ${VAR_NAME} syntax.[] is configured, and all **/* is inherited.check, ci, run, and sync commands..moon/cache.