moonrepo/moon

This system is a Rust-based monorepo management platform that combines a task runner, Moon, with a version manager, Proto. It orchestrates complex, parallel task execution across diverse toolchains using a plugin-driven architecture and content-addressable caching. The codebase also includes a discontinued CI service, Moonbase, and a dedicated documentation website.

44 changes.

The project underwent a comprehensive rewrite to version 2, introducing a new Rust-based core with modular crates for workspace, project, and task management, alongside a content-addressable cache and async graph builder. This architectural overhaul was accompanied by a complete rebranding to 'Moon', the release of the official CLI and TypeScript types, and the launch of a new Docusaurus-based documentation website with interactive visualizers.

71 changes.

This period focused on the foundational rewrite for version 2, introducing a new event-driven action pipeline, a plugin-based architecture for toolchains and extensions, and a comprehensive task execution system. It also established the core graph structures, configuration schemas, and CLI commands necessary to support the new modular design.

57 changes.

This period focused on establishing a background daemon for lifecycle management and introducing a robust, content-addressable caching system with remote storage support. It also expanded the plugin ecosystem through a tiered toolchain API and added AI integration via an MCP server.

A new Python scenario has been added to the system, enabling users to run Python-based tasks. This includes a configuration file defining a debug task and placeholder source files for the Python environment.

scenarios/python · high confidence

The website/blog directory now includes release announcement posts for moon versions v0.13 through v0.22. These posts document new capabilities such as the \moon check\ command, code generation via \moon generate\, first-class Docker support, per-project tool version overrides, webhooks, YAML anchor support, and the \moon migrate from-turborepo\ command.

website/blog · high confidence

The footer layout now includes a multi-step contact form that allows users to submit inquiries about consultation, partnership, or affiliation. The form collects a subject, email address, and message, then submits the data via POST to a Formspree endpoint, providing feedback on success or failure. The footer also displays links to GitHub, Discord, and Twitter, along with a Y Combinator logo.

website/src/theme/Footer/Layout · high confidence

A new debug subcommand module has been introduced, providing two specific tools for troubleshooting: 'debug config' and 'debug vcs'. The 'debug config' command prints the current state of the session's environment, including moon environment, proto environment, and various configuration objects (workspace, extensions, toolchains, and tasks). The 'debug vcs' command exposes version control system details, such as the default and local branches, their revisions, and lists of changed files (both overall and against the previous revision).

crates/app/src/commands/debug · high confidence

A new \feature-flags\ crate has been added to the project, providing a singleton-based registry for feature flags. The current implementation exposes a \Flag\ enum and a \FeatureFlags\ struct that allows checking if a flag is enabled (always returning true) and registering the instance globally. This serves as the foundational infrastructure for feature flag management, though the actual flag logic is currently a placeholder.

crates/feature-flags · high confidence

Introduces the \wasm/tc-tier3\ module as a new Extism plugin entry point. It re-exports types from \tc\_tier2\ and implements a \setup\_toolchain\ function that currently returns a default output. Other potential plugin functions (\register\_tool\, \load\_versions\, \locate\_executables\) are present in the codebase but commented out, indicating this is a scaffold for future plugin-aware action graph capabilities rather than a fully functional feature.

wasm/tc-tier3 · high confidence

A new interactive scenario has been added to the scenarios/interactive directory, providing reference implementations for reading user input from the command line in Go, JavaScript (Node.js), and Python. The moon.yml configuration file defines runnable tasks for these implementations using Go, Node.js, Bun, and Deno, enabling users to test or demonstrate interactive command-line input behavior across these specific runtimes.

scenarios/interactive · high confidence

The \crates/api\ crate now includes a new \launchpad\ module that provides functionality for checking for new versions of the tool and collecting anonymous toolchain usage telemetry. This module manages an anonymous user ID and repository ID to facilitate these checks, caching version check results to avoid excessive network requests, and integrates with the environment to detect CI/CD providers for telemetry purposes.

crates/api · high confidence

The reports module now includes an estimate feature that calculates potential time savings or losses by comparing the actual pipeline duration against an estimated baseline. This baseline emulates a non-parallelized execution model (with a 15% reduction for parallelism simulation) and excludes caching benefits, allowing users to see how much faster the current pipeline is compared to a hypothetical sequential run of the same tasks.

crates/action-pipeline/src/reports · high confidence

A new \Button\ component has been added to the website's UI source code, providing a reusable interface for both link-style and button-style interactions. This component supports size variants (default and large), disabled states, and custom styling via class names, utilizing Tailwind CSS for visual presentation. It automatically renders as an anchor tag when an \href\ is provided or as a button element for click handlers, standardizing the look and feel of interactive elements across the documentation site.

website/src/ui · high confidence

The .claude directory now includes symlinks pointing to the debug-task, doc-coauthoring, and improve-code-quality skills, making these capabilities available within the .claude context.

.claude · high confidence

The notifier crate now provides two new capabilities: sending native OS terminal notifications (using notify-rust) for local/remote detection, and posting events to configurable webhook endpoints. The webhook implementation includes payload serialization, optional acknowledgment requirements, and background request handling via a daemon client or spawned tasks.

crates/notifier/src · high confidence

New WASM plugins have been added to define toolchain requirements for tier 2 and tier 3 environments. The tier 2 plugin (\tc-tier2-reqs\) requires the tier 3 toolchain and conditionally enables environment setup based on the \testRequiresForEnvironment\ configuration flag. The tier 3 plugin (\tc-tier3-reqs\) similarly requires the tier 3 toolchain for setup but does not enable environment setup by default.

wasm/tc-tier2-reqs, wasm/tc-tier3-reqs · high confidence

A new scenario named 'deno-signals' has been introduced to demonstrate Deno's signal handling capabilities. The scenario includes a main script that registers listeners for SIGINT and SIGTERM signals, logging specific messages when the process is interrupted or terminated, and runs in an infinite loop with periodic logging. A moon.yml configuration file defines a 'dev' task that runs the script using 'deno run --watch -A main.ts', allowing for live-reload development.

scenarios/deno-signals · high confidence

New Dockerfiles have been added to the scripts/docker directory to facilitate building the moon workspace in a containerized environment. The primary Dockerfile provides a straightforward build process using the node:latest image, copying the moon binary, workspace configurations, and specific platform-specific packages before running setup, build, and prune commands. A second file, Dockerfile.staged, introduces a multi-stage build approach that separates the workspace scaffolding step from the final build stage, potentially optimizing the build cache and layer structure.

scripts/docker · high confidence

A new \bench-utils\ crate has been introduced to support benchmarking efforts. It provides a \create\_simple\_workspace\ helper that programmatically generates a sandbox environment containing multiple projects and a defined task dependency graph, facilitating consistent and repeatable performance testing scenarios.

crates/bench-utils · high confidence

A new shell script, generateCerts.sh, has been added to the scripts/data directory to facilitate the creation of self-signed CA, server, and client certificates. This tool generates the necessary key pairs and certificate files (including .crt, .key, and .pem variants) required for configuring mutual TLS in Bazel Remote API test fixtures, specifically targeting the crates/remote/tests/\_\fixtures\\_/certs-local directory.

scripts/data · high confidence

The \config-schema\ crate now automatically generates JSON Schema files (output to \website/static/schemas/v2\) and TypeScript type definitions (output to \packages/types/src\) from the project's configuration structs. This tooling injects dynamic toolchain plugin schemas into the project and toolchain configuration schemas, ensuring that IDE autocomplete and validation reflect the currently enabled toolchains, while also marking the deprecated \runner\ field in workspace config in favor of \pipeline\.

crates/config-schema · high confidence

Introduces the official CLI for moon, a build system and repository management tool. The package provides shell scripts (moon.js, moonx.js) and utility logic to locate and execute the corresponding Rust-based binaries (moon, moonx) for the current platform and architecture, enabling users to install, initialize, and run tasks within their repositories.

packages/cli · high confidence

The moon VS Code extension is now available, providing an in-editor interface for the moon build tool. Users can view projects and tags in tree views, run and check tasks directly from the editor, and visualize action, project, and task graphs. The extension includes a last-run report view, YAML schema validation for moon configuration files, and support for the Model Context Protocol (MCP). It requires moon to be installed in the workspace and supports both the legacy \.moon\ and the new \.config/moon\ configuration directories.

packages/vscode-extension · high confidence

The new @moonrepo/report package provides utility functions for processing and displaying action results. It includes logic to map action statuses (such as passed, failed, cached, or flaky) to specific icons, determine if an action has failed or passed, and identify flaky or slow actions based on a configurable threshold. Additionally, it offers functions to sort run reports by label or time and format duration values into human-readable strings.

packages/report/src · high confidence

The \@moonrepo/types\ package is now available, providing the official TypeScript type definitions for the Moon build system. This release adds a complete type system covering project and task configurations, the action pipeline graph, event payloads for webhooks and internal hooks, MCP tool interfaces for AI agent integration, and template/codegen schemas. Users can now leverage these types for improved IDE autocomplete, type-safe configuration validation, and better tooling integration when building against the Moon API.

packages/types/src · high confidence

The \crates/action-context\ crate has been added to centralize the state of running tasks, including tracking target states (passed, failed, skipped), managing concurrency via named mutexes, and handling affected file tracking and dependency graphs. This new component provides the foundational context object used by the pipeline implementations to coordinate task execution, lock resources, and determine which targets should inherit arguments or be skipped based on dependency failures.

crates/action-context · high confidence

A new \AppContext\ struct has been added to the \app-context\ crate to serve as a central hub for application state. It aggregates core components such as the cache engine, console, VCS client, and plugin registries, alongside configuration objects for extensions, toolchains, and the workspace. This context also exposes file hashing capabilities, allowing users to hash files either via a native mechanism (controlled by the \native\_file\_hashing\ experiment flag) or through the VCS backend.

crates/app-context · high confidence

The \crates/query\ crate now provides a new query language (MQL) that allows users to filter projects and tasks using a declarative syntax. This feature supports filtering by language, project aliases, layers, stacks, tags, and task types, as well as specific task toolchains. Users can combine these criteria using logical operators (\AND\/\OR\) and comparison operators (\=\, \!=\, \\~\ for glob-like matching), with support for nested groups via parentheses and value lists.

crates/query · high confidence

The \crates/mcp\ crate now implements a Model Context Protocol (MCP) server, exposing a suite of tools that allow AI agents to interact with the Moon workspace. This includes code generation tools (\generate\, \get\_template\, \get\_templates\), project and task inspection tools (\get\_project\, \get\_projects\, \get\_task\, \get\_tasks\), workspace synchronization (\sync\_workspace\, \sync\_projects\), and version control utilities (\get\_changed\_files\). The server communicates via stdio and is designed to be invoked by external AI clients to automate development workflows.

crates/mcp · high confidence

The \crates/env\ crate now provides a \MoonEnvironment\ struct that centralizes the definition and resolution of key directory paths, including the store root, cache, plugins, temp, and templates directories. This struct resolves the store root by checking the \MOON\_HOME\ environment variable or falling back to \XDG\_DATA\_HOME\ or a default \.moon\ directory, and exposes methods for instantiation in both production and testing contexts.

crates/env · high confidence

Users can now manage toolchain and extension plugins directly via the CLI using the new \moon toolchain\ and \moon extension\ command groups. Each group provides \add\ to install and configure a plugin (with interactive prompts or minimal flags), \download\ to fetch configured plugins, and \info\ to inspect plugin metadata, configuration schemas, and available APIs. This adds a structured, user-facing interface for plugin lifecycle management within the application.

crates/app/src/commands/toolchain · high confidence

The \crates/daemon\ crate now provides a \DaemonConnector\ that manages a background process, handling startup, connection retries with exponential backoff, and graceful shutdown. Users benefit from transparent daemon acquisition: if the daemon is not running, it is spawned and waited for; if a version mismatch occurs (e.g., after an upgrade), the connector automatically restarts the daemon to ensure compatibility. The system also handles stale state cleanup and degrades gracefully to non-daemon operation if the background process fails to start within the timeout budget.

crates/daemon · high confidence

Users can now define reusable task configurations that are automatically inherited by projects based on conditions such as language, layer, stack, tags, or toolchains, using the new \inheritedTasks\ configuration system. This system supports complex matching logic (AND/OR/NOT clauses) and allows inheritance order to be controlled. Additionally, the configuration system now supports integrating external WASM-based extension plugins, which can be configured with unique identifiers and arbitrary configuration objects, enabling extensibility of the build system.

crates/config/src · high confidence

A new local caching layer based on content-addressable storage has been added to the \cas\ crate. This store organizes cached objects by their SHA256 hash in a git-style prefix-sharded directory layout, ensuring atomic writes via temporary files to prevent readers from seeing partial data. The implementation supports efficient file ingestion using copy-on-write reflinks where available, and includes a garbage collection mechanism to remove stale blobs or perform reachability sweeps based on usage age and reference counts.

crates/cas/src · high confidence

This change adds a new set of CLI commands for managing the background daemon process. Users can now start, stop, restart, and check the status of the daemon, as well as view its logs. The implementation includes platform-specific log tailing (using \tail\ on Unix and \Get-Content\ on Windows) and ensures that daemon operations respect the configuration setting that enables or disables the daemon feature.

crates/app/src/commands/daemon · high confidence

The \crates/daemon-client\ crate has been introduced to encapsulate communication with the moon daemon. It provides a \DaemonClient\ that connects via platform-specific endpoints (Unix domain sockets or Windows named pipes) with configurable timeouts for connection and RPC operations. A key behavioral addition is the \handshake\ method, which compares the client's version against the running daemon's version and protocol; if they mismatch, it signals a \HandshakeOutcome::Restart\, ensuring clients do not proceed with incompatible daemon versions. Error handling is refined with specific error types for connection failures, timeouts, and RPC errors, including logic to distinguish transient endpoint unavailability from other failures.

crates/daemon-client · high confidence

The hash crate now provides a structured \ContentHash\ type for SHA-256 hex digests and a \Digest\ struct that pairs a content hash with its byte size. This enables precise content addressing for caching and remote execution, with built-in serialization compatibility for existing cache manifests and explicit conversion traits to/from Bazel Remote Execution API digests.

crates/hash/src · high confidence

The action pipeline now uses an event-emitter architecture with dedicated subscriber modules to handle post-execution tasks. Users will see console output updates via the new ConsoleSubscriber, receive terminal toast notifications on pipeline success or failure via NotificationsSubscriber, generate local run reports (including duration and estimates) via ReportsSubscriber, and trigger webhook callbacks with optional acknowledgment via WebhooksSubscriber. Additionally, stale cache cleanup is now handled by a CleanupSubscriber, and toolchain usage telemetry is tracked in CI environments by TelemetrySubscriber.

crates/action-pipeline/src/subscribers · high confidence

Added the \exec-plan\ crate, which defines the data structures for configuring an execution plan. This includes the \ExecutionPlan\ struct and its sub-blocks (\AffectedBlock\, \GraphBlock\, \PipelineBlock\, \TargetsBlock\) to specify how targets are selected, how the dependency graph is traversed, and how the pipeline behaves (e.g., concurrency, failure handling).

crates/exec-plan · high confidence

This change adds the \extension-plugin\ crate, establishing the core infrastructure for loading and managing external plugins. It introduces the \ExtensionPlugin\ struct to handle plugin initialization and metadata, and the \ExtensionRegistry\ to manage plugin instances and their configurations. The system exposes specific lifecycle hooks that allow extensions to extend the CLI (\extend\_command\), modify the project graph (\extend\_project\_graph\), customize task execution (\extend\_task\_command\, \extend\_task\_script\), and synchronize project or workspace state (\sync\_project\, \sync\_workspace\). Tests verify that these hooks behave correctly when functions are missing or when processing virtual file paths.

crates/extension-plugin · high confidence

A new \file-group\ crate has been added to handle the collection and resolution of file paths, glob patterns, and environment variables. This component allows users to define groups of inputs that can be expanded into concrete file or directory lists relative to a workspace root, while explicitly rejecting unsupported token functions and variables.

crates/file-group/src · high confidence

Added the \crates/file-watcher\ crate, which defines the \FileEvent\ struct for representing file system changes (including mutation and directory-specific detection) and the \FileWatcher\ async trait for implementing file system monitoring logic.

crates/file-watcher · high confidence

Adds a new standalone package, @moonrepo/visualizer, which provides a project graph and dependency graph visualizer for moon. The package is built using Preact and Vite, styled with Tailwind CSS, and includes configuration files (vite.config.mjs, tailwind.config.cjs, tsconfig.json) along with an entry point (index.html) and documentation (README.md).

packages/visualizer · high confidence

The \crates/pdk-api/src\ directory has been restructured into distinct modules (\common\, \context\, \extension\, \host\, \prompts\, \toolchain\, \vcs\) to expose a comprehensive plugin development kit. This change introduces new APIs allowing plugins to initialize with configuration prompts, extend the project graph and command execution logic, and interact with version control systems via a versioned protocol (v6). It also adds host capabilities for executing commands with caching strategies and tracking operation statuses, providing the foundational interfaces for toolchain and extension plugins.

crates/pdk-api/src · high confidence

The \action-pipeline\ crate now provides a new foundation for executing actions, replacing the previous system. This new pipeline introduces an event-driven architecture via an \EventEmitter\ and \Subscriber\ pattern, enabling richer observability through events for pipeline lifecycle, task execution, and environment setup. It features a new \JobDispatcher\ that manages concurrency and dependency resolution using topological sorting and priority groups, and includes dedicated subscribers for console output, notifications, reports, and webhooks. The implementation also adds support for graceful cancellation and abortion of in-flight jobs, ensuring that dependent actions are correctly handled when a failure or signal occurs.

crates/action-graph/src, crates/action-pipeline/src · high confidence

The \crates/process\ module has been introduced to provide a new, async-first interface for executing external commands. This crate adds a \Command\ builder that supports environment variable management, working directory configuration, and input piping. It introduces \SharedChild\ for safe concurrent access to child processes and a \ProcessRegistry\ singleton to track running tasks and handle graceful shutdowns on signals. The implementation includes continuous stdin piping for streaming data, output capturing, and robust error reporting that distinguishes between exit codes and termination signals.

crates/process · high confidence

The \crates/task-graph\ crate has been added, providing a new directed-acyclic graph (DAG) structure to manage task dependencies and relationships. This change introduces a dedicated \TaskGraph\ type that handles task expansion, caching, and focused graph operations, replacing or augmenting previous graph logic. Users benefit from improved performance and memory efficiency in how tasks are resolved and executed within the workspace.

crates/task-graph · high confidence

A new \task-builder\ crate has been added to handle the construction and validation of tasks and their dependencies. This component introduces stricter validation for task dependencies, preventing tasks marked with \allowFailure\ from being depended upon, enforcing that non-persistent tasks do not depend on persistent ones, and ensuring dependencies can run in CI. It also supports scoped dependency resolution (e.g., \^:task\ for all deps, \^build:task\ for build-scoped deps) and tag-based project queries, while providing detailed error diagnostics for invalid dependency targets, unknown extends sources, and unsupported command syntaxes.

crates/task-builder/src · high confidence

The workspace crate has been replaced with a new implementation that builds the project and task graphs. This new builder supports asynchronous graph construction, integrates with the VCS for file hashing and cache invalidation, and allows plugins (toolchains and extensions) to extend the project graph. It also introduces a new repository type detection (monorepo vs polyrepo) and handles project aliasing and task tagging for dependency resolution.

crates/workspace/src · high confidence

The \crates/actions/src/operations\ module now exposes dedicated operations to synchronize workspace-level configuration artifacts. Users can now trigger the generation and caching of \.github/CODEOWNERS\ files (with configurable sorting), JSON configuration schemas (including dynamic toolchain plugin schemas), and VCS hooks. Each operation supports a force mode to bypass caching and uses fingerprinting to regenerate only when the underlying configuration or workspace state changes, ensuring consistency without unnecessary re-computation.

crates/actions/src/operations · high confidence

The \crates/docker\ crate now includes a new \generate\_dockerfile\ function that programmatically creates Dockerfiles using Tera templates. Users can configure the generated image by specifying a base image (defaulting to \scratch\), enabling or disabling the moon toolchain (automatically disabled for Alpine images), and defining optional \build\_task\ and \start\_task\ targets. The generator supports a multi-stage build process including skeleton, build, and start stages, with optional steps for running setup and pruning dependencies. A custom template option is also available for users who need specific Dockerfile structures.

crates/docker · high confidence

Added a new TypeScript module defining the \ProtoTool\ interface and a \loadToolsData\ function to fetch and parse plugin metadata from the official moonrepo/proto registry. This enables the website to dynamically display built-in, community, and third-party tools with their associated metadata such as author, format, and binary locations.

website/src/data · high confidence

Added a new \checks\ feature for tasks, allowing users to define pre-execution validation steps (such as fingerprint or requirement checks) that run before the main task command. This change introduces a new execution pipeline within the task runner, including \CheckExecutor\ and \ChecksRunner\ modules, which handle the parallel execution of these checks with independent timeout monitoring and output capture. The system integrates with the existing command builder to construct check-specific commands and provides detailed error reporting for failed checks, ensuring tasks only proceed when all defined conditions are met.

crates/task-runner/src · high confidence

The new \crates/task-expander\ crate centralizes the logic for expanding task configurations, handling the resolution of tokens and variables within commands, scripts, arguments, environment variables, and dependency definitions. It introduces a \TaskExpander\ that processes task graphs, including the injection of dependency outputs as inputs when \cacheStrategy: outputs\ is set, and a \TokenExpander\ that manages variable substitution and function replacement across different scopes. The module also defines specific error types for invalid token usage, scope mismatches, and dependency constraints (such as \allowFailure\ or \persistent\ task rules), providing clearer feedback when task definitions violate these structural requirements.

crates/task-expander/src · high confidence

The new \wasm/tc-tier1\ plugin registers a toolchain that recognizes \tc.cfg\ and \tc.lock\ files, extending the project graph by applying aliases from these manifests and tracking lock files as inputs. It also provides functionality to scaffold Docker configurations (writing files during configs and sources phases) and prune vendor directories during Docker cleanup, serving as a test implementation for toolchain integration behaviors.

wasm/tc-tier1 · high confidence

Added a new plugin module in the \wasm/tc-tier2-setup-env\ location that implements the \define\_requirements\ and \setup\_environment\ functions. This allows tests to opt into specific toolchain requirements via a \testEnvRequirements\ configuration and enables controlled failure simulation through a \testSetupEnvironmentFailure\ flag, facilitating more robust pipeline testing for downstream environment setup behaviors.

wasm/tc-tier2-setup-env · high confidence

The new \crates/project\ crate defines the core \Project\ struct and its associated configuration, exposing types such as \ProjectConfig\, \LayerType\, \StackType\, and \FileGroup\. It implements project aliasing (supporting both IDs and plugin-derived aliases), dependency resolution, and toolchain management, while providing error handling for unknown tasks or file groups via \ProjectError\. This module serves as the central model for project identity, structure, and inherited task configuration within the workspace.

crates/project · high confidence

The \crates/toolchain-plugin\ crate is introduced, providing the core infrastructure for managing toolchain plugins. This includes a \ToolchainPlugin\ struct that wraps WASM plugins to handle tool detection, installation, and location caching via the \proto\ core, and a \ToolchainRegistry\ that manages the lifecycle and configuration of these plugins. The crate exposes APIs for detecting project languages and toolchain usage, defining requirements, and extending task commands, effectively replacing the previous platform system with a plugin-based approach.

crates/toolchain-plugin/src · high confidence

The \crates/toolchain\ crate is introduced, providing the core data structures and logic for managing toolchain versions. It defines the \ToolchainSpec\ struct to represent tool identifiers and version requirements, and adds configuration helpers to handle environment-based overrides (via \MOON\_TOOLCHAIN\_FORCE\_GLOBALS\) and resolve toolchain IDs against enabled lists.

crates/toolchain · high confidence

Added a new \WorkspaceWatcher\ component that monitors the file system for changes to project, task, and workspace configuration files (such as \.prototools\, \moon.config\, and \.moon/\*.config\). When these files are modified, the watcher automatically invalidates relevant caches and triggers background rebuilds of the project context and dependency graphs, ensuring the daemon stays in sync with the workspace state without requiring manual intervention.

crates/app/src/watchers · high confidence

The website now includes a new set of reusable UI components for text rendering, located in \website/src/ui/typography\. This adds \Heading\ (supporting levels 1–6 with responsive sizing), \Label\ (with semantic variants like success, warning, failure, and info), \Link\ (wrapping Docusaurus links with size and variant styling), and \Text\ (a flexible paragraph/text element with alignment, overflow, weight, and transform options). These components provide a consistent, theme-aware typography system for the site's content.

website/src/ui/typography · high confidence

Added two new agent skills to the .agents directory: a 'doc-coauthoring' skill that guides users through a structured three-stage workflow (context gathering, refinement, and reader testing) for creating technical documentation, and an 'improve-code-quality' skill that performs structured audits on Rust code paths by running automated tools (clippy, rustfmt, nextest) and performing manual analysis for security, performance, and readability issues. The code quality skill includes evaluation scripts to verify its behavior on specific crates.

.agents · high confidence

Added two new shell scripts to the CI pipeline: \generateTestPlan.sh\ configures OS-specific runner selections based on a coverage flag (using higher-spec runners when coverage is enabled), and \warmPluginsCache.sh\ pre-warms the plugin cache by sequentially invoking the toolchain info command for JavaScript, Node, NPM, and TypeScript plugins.

scripts/ci · high confidence

The application now includes a comprehensive set of new commands for managing and inspecting the workspace, including \action-graph\, \bin\, \check\, \ci\, \clean\, \completions\, \exec\, \ext\, \generate\, \hash\, \init\, \mcp\, \project\, \project-graph\, \projects\, \run\, \setup\, \sync\, and \task\. These commands provide users with the ability to visualize dependency graphs, execute tasks with various failure modes, manage toolchains and environments, generate code from templates, inspect project and task metadata, and initialize new workspaces.

crates/app/src/commands · high confidence

The \moon docker\ command now includes four new subcommands: \scaffold\ copies project sources and configuration files into a Docker build context based on toolchain-defined globs; \file\ generates a Dockerfile for a specific project, allowing users to specify a base image, build/start tasks, and custom templates; \setup\ installs toolchains and dependencies for focused projects by reading a manifest and running the action pipeline; and \prune\ removes extraneous dependencies and development artifacts from the Docker build context. These commands rely on the new toolchain plugin system to define metadata and perform operations like locating dependency roots and executing prune/install actions.

crates/app/src/commands/docker · high confidence

The documentation site has been rebuilt using Docusaurus, introducing a modern static site generator for moon and proto. This change adds a new website directory containing configuration files (docusaurus.config.ts, tailwind.config.js, babel.config.js), a custom Prism syntax highlighting theme, and a dark mode synchronization script to ensure consistent styling with the application. The site structure includes organized sidebars for documentation, guides, and commands, along with a custom footer component and deployment settings for GitHub Pages.

website · high confidence

The Moon product section now features a dedicated landing page with a new Hero component that displays the Moon logo, a description of the tool as a Rust-based task runner and monorepo manager, and a dynamic terminal animation. This animation simulates the execution of \moon run :build\, visually demonstrating parallel target builds and completion times to showcase performance. The page also includes a direct link to the current CLI version on npm and a Y Combinator badge.

website/src/components/Products/Moon · high confidence

The \crates/pdk\ crate now provides a new set of APIs for building toolchain and extension plugins. This includes argument parsing utilities, functions to load projects and tasks by ID or target, and methods to retrieve and parse configuration for both extensions and toolchains (including schema-based validation). Additionally, it offers helper functions to check if a toolchain is enabled for a project and to locate root directories by traversing upwards from a starting path.

crates/pdk · high confidence

The \pdk-test-utils\ crate now provides a comprehensive testing framework for plugin and toolchain development. It introduces \MoonWasmSandbox\ to create isolated environments for extensions and toolchains, \ExtensionTestWrapper\ and \ToolchainTestWrapper\ to simplify invoking plugin APIs (such as \extend\_command\, \extend\_project\_graph\, and \hash\_task\_contents\), and \MockedHostFuncs\ to intercept and mock host functions like \load\_project\ and \load\_task\. This allows developers to write unit tests for their plugins without needing a full runtime environment.

crates/pdk-test-utils · high confidence

The Proto product page now features a new Hero section that displays the current version fetched from the upstream repository, a dynamic terminal animation demonstrating installation commands for Bun, Deno, Node, Go, and Rust (with Windows support), and a Tools Grid showcasing supported language logos and linking to third-party plugin counts. Additionally, a ToolCard component has been added to display individual tool details, including installation usage, available binaries, global directories, and detection sources for both built-in and third-party tools.

website/src/components/Products/Proto · high confidence

The \wasm/tc-tier2\ module now provides a concrete WASM-based toolchain implementation that handles dependency resolution and task command/script extension. It introduces \locate\_dependencies\_root\ to identify workspace members and \install\_dependencies\ to execute install/dedupe commands (with test-specific marker file and command generation support), alongside \extend\_task\_command\ and \extend\_task\_script\ functions that allow tasks to have their commands, arguments, environment variables, and scripts modified or wrapped by the toolchain layer.

wasm/tc-tier2 · high confidence

The \crates/actions\ library has been introduced, providing core utilities for action execution. It includes \utils.rs\ which implements content hashing via \ContentHasher\ and lock management (\HashLock\) to prevent concurrent execution, along with logic to skip actions based on environment variables using pattern matching (e.g., \node:20.0.0\ or comma-separated lists). The crate also exposes modules for actions, operations, plugins, and utils.

crates/actions/src · high confidence

A new \run\_pooled\_tasks\ function has been added to the \async-utils\ crate, allowing users to execute a queue of asynchronous tasks with a concurrency limit based on the number of CPU cores. This utility ensures that outputs are processed and returned in the same order as the inputs, providing deterministic behavior for consumers even when tasks complete out of order. If any task or input handler fails, the function aborts all running tasks and propagates the error immediately.

crates/async-utils · high confidence

The \crates/cache\ module now provides a new \CacheEngine\ that manages local caching via a content-addressable storage (CAS) layer, a dedicated \HashEngine\ for generating and storing file/content hashes, and a \StateEngine\ for tracking project and task states. This introduces a new mechanism for hashing files (producing consistent hex digests) and storing task outputs as hashed archives, alongside utilities for cleaning stale cache artifacts based on lifetime configurations. Benchmarks and tests have been added to validate the performance and correctness of the new file hashing and cache management logic.

crates/cache · high confidence

The \crates/cache-item\ crate introduces a new \CacheItem\ type that manages JSON-based cache state files. Users can now control cache behavior via the \MOON\_CACHE\ environment variable, supporting four modes: \off\ (no I/O), \read\ (read-only), \write\ (write-only), and \read-write\ (default). The implementation automatically handles file extensions (defaulting to \.json\) and provides a \CommonCacheState\ struct with a \last\_hash\ field for tracking cache validity.

crates/cache-item · high confidence

The \crates/codegen/src\ module introduces a new code generation engine built on the Tera templating library. This system allows templates to inherit from other templates via an \extends\ list, merging variables and files during generation. It provides new Tera filters for string case conversion (camel, kebab, pascal, snake, upper, lower) and path manipulation (join, relative), and supports frontmatter in template files to control output behavior such as merging JSON/YAML content or skipping files.

crates/codegen/src · high confidence

The \crates/common\ library has been introduced, providing shared utilities for the project. It includes environment detection functions in \env.rs\ to identify CI, Docker, WSL, SSH, and test contexts, as well as path manipulation helpers in \path.rs\ for normalizing separators and resolving relative paths. The \id.rs\ module standardizes identifier handling by re-exporting \starbase\_id\ and adding extension traits for stable/unstable ID generation. Additionally, \macros.rs\ provides serialization macros for cacheable structures, and tests have been added to validate the new ID validation logic.

crates/common · high confidence

The \crates/config-loader\ crate has been introduced to centralize configuration loading, featuring a new \ConfigCache\ that persists parsed configs to disk with a 24-hour TTL to reduce redundant I/O. It adds native support for HCL configuration files via a dedicated parser that handles \locals\ and a \concat\ function, and expands the \ConfigFinder\ to recognize \.hcl\ files alongside existing formats. The loader now automatically resolves built-in toolchain and extension plugin locators (such as \unstable\_ruby\, \unstable\_python\, and \download\) using environment variables \MOON\_BUILTIN\_REGISTRY\_HOST\ and \MOON\_BUILTIN\_REGISTRY\_NAMESPACE\ (defaulting to \ghcr.io\ and \moonrepo\), falling back to GitHub releases if \MOON\_PLUGINS\_USE\_URL\_DIST\ is enabled.

crates/config-loader · high confidence

This change introduces the \crates/daemon-utils\ crate, providing shared utilities for managing the background daemon process. It implements platform-specific endpoint resolution (Unix sockets on Linux/macOS, named pipes on Windows), file-based advisory locking to ensure exclusive daemon ownership and prevent race conditions during spawn, and cross-platform helpers for process liveness checks and detached execution. The crate also handles persistent state management (PID, version, endpoint) and cleanup of daemon files while preserving lock files for reuse across runs.

crates/daemon-utils · high confidence

The website now includes several new React components to enhance the documentation experience. \AddDepsTabs\ and \CreateDepTabs\ provide copyable shell commands for adding or creating dependencies across Yarn (classic and v1), npm, pnpm, and Bun, with support for workspace and peer/dev flags. \LangSelector\ and \LangPartials\ allow users to switch between language contexts (Bun, Deno, Go, Node.js, PHP, Python, Ruby, Rust) to view relevant code examples. \ComparisonTable\ displays a detailed feature comparison between Moon, Nx, and Turborepo across workspace, toolchain, and project categories. Additional layout components (\Columns\, \ComparisonColumn\, \TwoColumn\, \NextSteps\) and utility components (\FeatureStatus\, \Image\, \NonWasmTabs\ for JSON/TOML/YAML conversion) are also added to support these content structures.

website/src/components · high confidence

A new graph visualization feature has been added, implemented via a new \graph\ command module. This change introduces a local web server (using \tiny\_http\) that serves an HTML page (rendered via \tera\) containing graph data and a JavaScript visualizer. The server supports a configurable JS URL, defaulting to a local development server or a CDN (\@moonrepo/visualizer\) in production, and automatically opens the browser to the visualization URL upon startup.

crates/app/src/commands/graph · high confidence

The website's homepage now includes three new React components: CTA, which renders styled call-to-action links; ProductSection, which displays product features with logos, titles, descriptions, and icon lists in a grid layout; and UsedBy, which showcases company logos (Depot, Gallery) and provides a link for other companies to list their affiliation. These components form the structural basis for the updated homepage content.

website/src/components/Home · high confidence

Added new shell and PowerShell installation scripts for Moon and Proto. The Moon scripts support version 2+ by delegating to the cargo-dist installer, while also handling Windows PATH configuration. The Proto scripts now install the proto-shim executable alongside the main binary and automatically run the setup command to configure the user's shell environment upon installation.

website/static/install · high confidence

The \app-macros\ crate introduces two new procedural macros, \with\_shared\_exec\_args\ and \with\_affected\_args\, to simplify CLI argument definitions. \with\_shared\_exec\_args\ injects common execution options such as force-run, interactive mode, execution plan paths, and parallelism controls into structs. \with\_affected\_args\ adds options for comparing branches or commits (base/head) and including graph relations. These macros reduce boilerplate by automatically extending struct fields and generating conversion logic for execution arguments.

crates/app-macros · high confidence

Added three new React components to the website's product section: Features, AdditionalFeatures, and HeroIcon. The Features component renders a tiered, responsive layout with gradient headers and icon-based feature lists, while AdditionalFeatures provides a simpler grid view for supplementary capabilities. HeroIcon serves as a shared UI element for displaying icons alongside text in product headers.

website/src/components/Products · high confidence

This change introduces the core configuration structs for the project module, enabling more granular control over project settings. Users can now define dependency scopes (production, development, build, peer, root) and sources (explicit vs implicit) via \ProjectDependencyConfig\. Docker integration is configured through \ProjectDockerConfig\, allowing control over file generation and scaffolding. The \LanguageType\ enum supports a wide range of languages (including aliases like c++ and c\#) and custom languages. Project-level overrides for toolchain versions and workspace inheritance (including task inclusion/exclusion/renaming and merge strategies for env and file groups) are now defined in \ProjectToolchainsConfig\ and \ProjectWorkspaceConfig\. Finally, code ownership is managed via \OwnersConfig\, supporting path-based ownership mapping with validation for default owners and support for Bitbucket and GitLab specific features.

crates/config/src/project · high confidence

The CLI now includes a \query\ subcommand with four new capabilities: \affected\ to determine which projects and tasks are impacted by file changes (respecting CI context and supporting async tracking via an experiment flag), \changed-files\ to list files between revisions with options for base/head branches, local/remote state, and change status, \projects\ to filter the project graph by attributes like ID, alias, language, layer, stack, source, tags, tasks, and affected status, and \tasks\ to filter the task graph by ID, command, script, project, toolchain, type, tags, and affected status. All query results are output as JSON.

crates/app/src/commands/query · high confidence

The repository now includes a new set of bash scripts in \scripts/release/\ to manage the build and publishing workflow. \release.sh\ handles the distribution of Rust binaries by extracting artifacts from a \cargo-dist\ manifest and copying them into the appropriate \core-\*\ npm packages, while \publish.sh\ manages the publishing of secondary npm packages. The workflow uses \npm\ for publishing to support OIDC authentication, applies version bumps via Yarn workspaces, and commits changes before invoking \cargo release\ for the Rust crate.

scripts/release · high confidence

The \cache-remote\ crate now provides two new storage backends, \GrpcRemoteStorage\ and \HttpRemoteStorage\, implementing the Bazel Remote Execution API for remote caching. These backends support configurable TLS and mutual TLS (mTLS) authentication, custom HTTP headers, and zstd compression for gRPC streams and batches. The \manifest\ crate includes new helpers and packers to serialize task outputs into the Bazel \ActionResult\ format required by these remote caches.

crates/cache-remote · high confidence

The sync command module has been expanded with four new subcommands: \code-owners\ (or \codeowners\) to sync aggregated code owners to a CODEOWNERS file, \config-schemas\ (or \schemas\) to generate configuration JSON schemas for editor use, \vcs-hooks\ (or \hooks\) to sync and generate hook scripts for the workspace's configured VCS, and \projects\ to sync all projects and configs in the workspace. These commands provide dedicated CLI interfaces for managing these specific workspace artifacts, replacing or supplementing previous implicit sync behaviors.

crates/app/src/commands/syncs · high confidence

A new \task-hasher\ crate has been introduced to centralize and manage task fingerprinting and hashing logic. This change introduces a \TaskFingerprint\ struct that captures task inputs, dependencies, environment variables, and outputs to generate deterministic hashes for caching. It also implements a \TaskHasher\ that aggregates file inputs (supporting both glob patterns and VCS-tracked changes) and hashes toolchain contents, ensuring that task caches are invalidated correctly when underlying code or configuration changes.

crates/task-hasher/src · high confidence

The \crates/test-utils\ crate has been introduced to provide a standardized testing infrastructure. It includes \MoonSandbox\ for creating isolated test environments with consistent environment variables (such as \MOON\_HOME\ and \PROTO\_HOME\ isolation) and helper methods to update configuration files, and \WorkspaceMocker\ for programmatically constructing and configuring workspace states, including loading configs, setting toolchains, and managing project graphs. This allows tests to reliably simulate various workspace configurations without side effects.

crates/test-utils · high confidence

The \crates/token\ crate introduces a new token engine built on the Tera templating library, enabling users to render dynamic strings using a defined syntax. This engine exposes global context variables for the host environment, current datetime, workspace configuration, extensions, toolchains, version control details, and project metadata. It also provides template filters for case conversion (camel, kebab, snake, pascal, title) and functions to access environment variables and conditionally render content based on CI or Docker environments.

crates/token · high confidence

A new \renderGraph\ utility has been added to the website's utils, enabling the visualization of dependency graphs using Cytoscape.js with a Dagre layout. This function styles nodes and edges with specific colors and dimensions based on task types (such as 'run-task', 'sync-project', or 'setup-toolchain'), providing users with a clear, visual representation of project structures and dependencies within the website interface.

website/src/utils · high confidence

A new \migrate v2\ command has been added to help users upgrade their existing moon v1 workspaces to moon v2. This command automatically migrates configuration files (workspace, toolchain, tasks, and project configs) by renaming settings (e.g., \platform\ to \toolchains\, \command\ to \script\), restructuring task arguments, and handling inherited task configurations. It supports a \--yes\ flag to skip confirmation prompts and includes safeguards for unsupported Pkl configuration files.

crates/app/src/commands/migrate · high confidence

The \workspace-graph\ crate introduces a unified \WorkspaceGraph\ that combines project and task graphs, providing new \query\_projects\ and \query\_tasks\ methods. These methods allow users to filter projects and tasks using a criteria-based query system that supports logical operators (AND/OR) and conditions on fields such as language, project ID, aliases, layer, tags, and task attributes like type, tags, and toolchains. The implementation includes caching for query results and ensures deterministic ordering of matches.

crates/workspace-graph · high confidence

Templates now support YAML frontmatter to configure individual file behavior, including options to force overwrite, override the destination path, or skip writing the file entirely. Additionally, the system introduces a unified template locator that allows sources to be specified via explicit protocols (archive URLs, git repositories with revisions, npm packages, local files, or glob patterns) or inferred automatically from the string format.

crates/config/src/template · high confidence

The codeowners feature now supports generating CODEOWNERS files for Bitbucket repositories. This change introduces a new \CodeownersGenerator\ that handles VCS-specific formatting for GitHub, GitLab, and Bitbucket, and a \CodeownersFingerprint\ struct to track configuration state. Users can now configure code ownership rules that are correctly rendered for Bitbucket's specific syntax requirements.

crates/codeowners/src · high confidence

The notifier crate now explicitly links the CoreServices and AppKit frameworks on macOS during the build process. This ensures that the build succeeds on macOS targets by satisfying dependencies that were previously unresolved or implicitly handled.

crates/notifier · high confidence

The documentation website now applies a custom visual theme by introducing \website/src/css/custom.css\ and \website/src/css/theme.css\. These files define CSS variables for light and dark modes, override default Docusaurus styling to align with the product's design system (using specific font families, colors, and spacing), and integrate Tailwind CSS utilities to ensure consistent rendering across the site.

website/src/css · high confidence

The documentation website now uses custom React components for the article link (A), document breadcrumbs (DocBreadcrumbs), and pagination navigation (PaginatorNavLink), replacing the default Docusaurus implementations. The breadcrumb component specifically integrates a language selector and displays a notice that the current documentation is for moon v2, with a link to the frozen v1 docs. Additionally, a custom Prism language loader is introduced to dynamically register additional programming languages defined in the site configuration, enabling syntax highlighting for a broader set of languages in code blocks.

website/src/theme · high confidence

The daemon's internal RPC contract has been updated to version 2, requiring clients to restart the daemon to ensure compatibility. This change introduces new RPC methods for archiving and hydrating task outputs, cleaning the cache, and hashing files, alongside existing lifecycle and status endpoints. The protocol definition also integrates Bazel Remote Execution types for action results and maps them to the \bazel-remote-apis\ crate to ensure consistent type generation.

crates/daemon-proto · high confidence

The daemon server logic has been extracted into a new \crates/daemon-server\ crate, introducing a dedicated file watcher that monitors workspace changes (debounced and filtering ignored directories like \.git\ and \node\_modules\) and RPC endpoints for archiving and hydrating task outputs. This change establishes the core daemon service structure, including lifecycle management, idle timeout handling, and background task tracking, while separating error definitions and file event dispatching into distinct modules.

crates/daemon-server/src · high confidence

The \project-constraints\ crate now validates dependency relationships between projects based on their assigned layers (such as Application, Library, Tool, etc.) and tags. It prevents projects from depending on others that violate the defined layer hierarchy (e.g., an Application depending on another Application within the same stack) and ensures that tagged dependencies meet specific tag requirements. This helps maintain architectural integrity by enforcing allowed dependency paths and preventing invalid cross-layer or cross-tag references.

crates/project-constraints · high confidence

The Git VCS module has been replaced with a new implementation that uses the Gix library for repository discovery and layout resolution, replacing the previous approach. This change introduces a new \GitError\ enum for structured error reporting, adds validation to prevent command injection via revision arguments, and includes logic to safely skip uninitialized submodules during tree loading. Additionally, the module now normalizes branch references (e.g., stripping \refs/heads/\ prefixes) and cleans Git version strings for consistent parsing.

crates/vcs/src/git · high confidence

The \NodeState\ enum in \crates/graph-utils\ now passes through specific deserialization errors from its inner type \T\ instead of returning a generic failure. This change ensures that when configuration or data fails to parse, users receive detailed error messages indicating exactly which field or value caused the issue, rather than a vague deserialization error.

crates/graph-utils · high confidence

A new \AugmentedCommand\ builder has been added to the \process-augment\ crate to centralize how commands are constructed and modified. This component handles the inheritance of executable paths, arguments, and environment variables from tasks, projects, and global contexts, while providing a structured way for plugins to extend commands via \extend\_command\, \extend\_task\_command\, and \extend\_task\_script\ hooks. It also supports specific task check execution and manages path ordering for toolchain and plugin injections, replacing the previous ad-hoc command augmentation logic.

crates/process-augment/src · high confidence

The VCS module has been extracted into its own crate and now exposes a unified \Vcs\ trait that defines core repository operations such as retrieving branch information, file hashes, and repository metadata. A new \ChangedFiles\ data structure has been added to track file statuses (added, deleted, modified, staged, unstaged, untracked), providing a structured way to query repository changes. This change establishes the foundational interface for version control interactions, replacing previous ad-hoc implementations with a consistent, trait-based approach.

crates/vcs/src · high confidence

The website now includes a new \Icon\ wrapper component and a \ProductIcon\ component that maps specific product concepts (such as projects, tasks, toolchains, and social links) to named icons from the Carbon and Material Symbols icon sets. This replaces previous icon usage patterns with a centralized, type-safe system for rendering product-specific graphics in the UI.

website/src/ui/iconography · high confidence

The plugin system now supports in-memory caching for command execution, allowing repeated commands with identical inputs to skip re-execution within the same session. It also enforces strict parsing for task commands and arguments, ensuring that only valid, well-formed commands are processed. Additionally, the system now co-locates all hash/digest/fingerprint logic into a single crate for consistency and introduces a new file hashing mechanism for more accurate change detection.

crates/actions/src/plugins · high confidence

The action runner now uses a new internal model where actions are composed of a list of operations (such as task execution, setup, and sync) rather than a single process. This change introduces a \priority\ option for tasks to control execution order and ensures that non-UTF-8 output from tasks is preserved lossily in logs instead of being dropped. Additionally, the system now correctly propagates the specific exit code of the last executed task operation, rather than collapsing failures to a generic code.

crates/action · high confidence

The application entry point has been restructured around a new \MoonSession\ type that manages the runtime context, including lazy initialization of the workspace graph, project/task graphs, cache engine, and daemon client. The CLI command definitions have been consolidated into a single \Commands\ enum in \app.rs\, exposing subcommands such as \action-graph\, \daemon\, \exec\, \mcp\, and \toolchain\. Error handling is now centralized in \app\_error.rs\ with structured diagnostic codes, and interactive prompts are handled via a new \prompts.rs\ module using the \iocraft\ UI components. Configuration serialization helpers and progress display utilities have been added to \helpers.rs\ to support the new action pipeline execution flow.

crates/app/src · high confidence

The cache system has been replaced with a new storage layer that supports both local and remote backends. This change introduces a \Storage\ coordinator that manages multiple backends, handles background connection establishment, and waits for remote backends to connect before allowing cache reads or writes to prevent errors during startup. The local backend now uses a Content-Addressable Storage (CAS) structure for blobs and manifests, includes a garbage collection mechanism with a grace period for unreferenced blobs, and supports legacy directory migration. A new \Blob\ abstraction standardizes content handling with SHA-256 digests, and the system now supports shared worktree caching configurations.

crates/cache-storage · high confidence

The console crate has been replaced with a new rendering system that integrates the \iocraft\ UI library and \starbase\_console\ infrastructure. This change introduces a \MoonReporter\ for structured output, a \MoonConsole\ wrapper for interactive prompts (including improved Ctrl+C handling), and a custom \ConsoleTheme\ that defines specific progress bar characters and branding styles. Users will see updated visual formatting for task statuses, checkpoints, and pipeline summaries, along with more robust handling of interactive input interrupts.

crates/console · high confidence

The \crates/target\ module has been added to provide a new, standardized system for parsing and managing task targets. This change introduces support for scoped dependency prefixes (such as \^:\ for all dependencies, \^build:\ for build dependencies, and \\~:\ for the current project), tag-based scoping (e.g., \\#tag:task\), and glob-based target matching (e.g., \project:\\ or \\:task\). It also enforces stricter validation for target formats, ensuring that fully qualified identifiers are used where required and providing clear error messages for invalid scopes or wildcards.

crates/target · high confidence

The \crates/task\ module has been restructured to support a more flexible task definition system. Tasks now explicitly distinguish between file inputs, glob inputs, file outputs, and glob outputs, allowing for precise dependency tracking and caching. The \TaskOptions\ struct introduces a wide range of configuration capabilities, including \affected\_files\ filtering, \cache\ and \cache\_lifetime\ settings, \env\_files\ for environment variable injection, \priority\ levels, \retry\_count\, \timeout\, and OS-specific execution (\os\). Additionally, the \TaskArg\ type now handles quoted and unquoted values correctly for shell execution, and the \Task\ struct supports \checks\, \deps\, \tags\, and \toolchains\. This change enables more robust task orchestration, better caching strategies, and finer-grained control over task execution in CI and local environments.

crates/task · high confidence

The project-builder crate now constructs projects by inheriting tasks, file groups, and environment variables from global workspace configurations. This change introduces configuration-based task inheritance, allowing projects to extend and merge settings from parent scopes. It also adds support for \workspace.mergeStrategies\ to control how environment variables and other inherited fields are merged, ensuring predictable behavior when multiple configuration sources define the same values.

crates/project-builder/src · high confidence

The project-expander crate now includes a new ProjectExpander component that resolves project dependency aliases during the expansion phase. When a project is expanded, its dependencies are processed to replace any alias references with their corresponding concrete project IDs, ensuring that the final project configuration uses explicit identifiers rather than aliases.

crates/project-expander · high confidence

The project-graph crate now provides a new internal graph structure that separates production and development dependencies into distinct acyclic partitions, allowing cycles only across the production/development boundary. This change adds support for multiple project aliases, a configurable default/main project, and improved error handling for graph construction issues such as cycles or missing project IDs.

crates/project-graph/src · high confidence

The toolchain module has been restructured into a tiered plugin system (tier1, tier2, and tier3) to standardize how toolchains are registered, configured, and managed. Tier1 exposes core registration and Docker scaffolding interfaces, tier2 handles dependency resolution and environment setup requirements, and tier3 manages toolchain installation and teardown. This change replaces the previous platform system with a more modular approach, allowing plugins to define specific capabilities like version detection, manifest parsing, and dependency installation through distinct, organized API surfaces.

crates/pdk-api/src/toolchain · high confidence

The Moonbase product landing page has been updated to clearly state that the service is discontinued. The Hero component now includes a prominent red warning message reading 'This product has been discontinued!' alongside a link to the 'moon' product, while the Pricing section remains present but indicates that the 'Grow' tier is 'Coming soon' and links to the external moonrepo.app site for further details.

website/src/components/Products/Moonbase · high confidence

The configuration system for task inputs and outputs has been restructured to support URI/object formats (e.g., \file://\, \glob://\) with query parameters. Users can now define file inputs with content-matching regex patterns and optional flags, specify file group formats (such as returning only directories or environment variables), and configure glob caching. Similarly, outputs support optional flags to prevent task failures when expected files are missing. This change introduces new config structs (\FileInput\, \FileGroupInput\, \GlobInput\, \FileOutput\, \GlobOutput\) and a \OneOrMany\ type to handle both single values and lists in configuration files.

crates/config/src/shapes · high confidence

The affected tracker has been replaced with a new implementation that provides more precise control over dependency and dependent analysis. Users can now configure \UpstreamScope\ and \DownstreamScope\ (None, Direct, Deep) for both projects and tasks, allowing them to limit the depth of impact analysis. The system also introduces new \AffectedBy\ reasons, including \EnvironmentVariable\ and \AlwaysAffected\ (for CI contexts), and supports content-matching for input files. Cycle detection is built into the tracking logic to prevent infinite loops during graph traversal.

crates/affected/src · high confidence

The application now uses dedicated systems in \crates/app/src/systems\ to manage core initialization. Startup logic (\startup.rs\) has been updated to locate the workspace root by looking for a \.moon\ configuration directory (supporting the \MOON\_WORKSPACE\_ROOT\ environment variable) and loads workspace, toolchain, extension, and task configurations. Color output is now handled by a new \bootstrap\ system that respects \NO\_COLOR\, \MOON\_COLOR\, and \FORCE\_COLOR\ environment variables to ensure consistent terminal styling. Additionally, a new \execute\ system checks for available moon updates at runtime and provides specific upgrade instructions based on the installation method (Proto or moon).

crates/app/src/systems · high confidence

The \crates/actions/src/actions\ module has been rewritten to introduce a new plugin-driven action system. This change replaces previous implementations with dedicated actions for setting up the \proto\ tool, configuring toolchains, installing dependencies, and running tasks. It also introduces new synchronization actions (\sync\_project\ and \sync\_workspace\) that allow toolchains and extensions to update configuration files, codeowners, and VCS hooks. These actions are now executed via a unified action graph, enabling better caching, skipping logic based on environment variables (e.g., \MOON\_SKIP\_INSTALL\_DEPS\), and support for tier-3 toolchains that download and install their own binaries.

crates/actions/src/actions · high confidence

The website now includes dedicated landing pages for the moon task runner, proto version manager, and moonbase CI service. The homepage (\index.tsx\) introduces these products with high-level value propositions, while the individual product pages (\moon.tsx\, \proto.tsx\, \moonbase.tsx\) detail specific features such as smart hashing, multi-language support, and artifact caching. These pages replace the previous content structure to provide clearer product positioning and onboarding paths for users.

website/src/pages · high confidence

The \crates/app/src/queries\ module has been replaced with a new implementation that provides structured querying capabilities for the workspace. Users can now filter projects and tasks using regex-based options (such as \id\, \alias\, \layer\, \tags\, \toolchain\, and \command\) or via a query language, and additionally filter results based on whether they are affected by recent changes. A new \changed\_files\ query allows users to retrieve lists of modified files, supporting comparisons against a base/head, the previous commit, or local changes, with specific handling for shallow Git checkouts and CI environments.

crates/app/src/queries · high confidence

The toolchain configuration module has been restructured into dedicated config structs: \BinConfig\ and \BinEntry\ allow users to specify global binary installations with options like force-installation and local-only scope; \MoonConfig\ defines secure URLs for checking and downloading moon updates; and \ProtoConfig\ sets the default proto CLI version (0.60.2) used for managing other toolchains. These changes introduce a new, structured way to configure toolchain-related behaviors in the project.

crates/config/src/toolchain · high confidence

The project has been renamed from Monolith to Moon, reflected in the new \moon.yml\ workspace configuration, updated \README.md\, and the addition of \.prototools\ for managing toolchain versions (Node, Yarn, Bun, Deno, Python, etc.). The build and development infrastructure has been significantly restructured: the old \prettier.config.js\ has been removed in favor of a new \vite.config.ts\ that integrates \vite-plus\ for linting, formatting, and testing; the Rust toolchain is now pinned to version 1.98.0 via \rust-toolchain.toml\; and binary releases are now managed by \cargo-dist\ using \dist-workspace.toml\. Additionally, the repository now includes a \justfile\ for common development tasks, a \clippy.toml\ to disallow standard HashMap/HashSet in favor of FxHashMap, and updated \.gitignore\ and \.dockerignore\ files to reflect the new Moon-specific cache and artifact paths.

(repo-wide) · high confidence

The VCS hooks system has been restructured to improve reliability and cross-platform support. A new fingerprinting mechanism (HooksFingerprint) tracks hook configurations to ensure accurate cache invalidation and state management. The hook generation logic now automatically detects the appropriate shell (Bash on Unix, PowerShell/Pwsh on Windows) and generates corresponding hook files. Additionally, the cleanup process has been enhanced to safely remove previous hook states and directories (specifically .moon/hooks or .config/moon/hooks) without interfering with hooks managed by other tools like husky or lefthook.

crates/vcs-hooks/src · high confidence

The \env-var\ crate has been completely restructured to provide a new, robust system for managing environment variables. This change introduces a new \GlobalEnvBag\ for centralized, thread-safe variable management and a new \DotEnv\ parser that supports \.env\ file loading with proper handling of comments, \export\ prefixes, and quoted values. A key behavioral improvement is the new \EnvSubstitutor\, which enables deep variable interpolation within \.env\ files and task definitions, allowing variables to reference global, local, or previously defined dotenv variables. Additionally, the system now supports shell-specific syntax variants (such as \$E:VAR\ for Elvish, \$env:VAR\ for PowerShell, and \${VAR}\ with flags like \:-\ for defaults) to ensure compatibility across different development environments.

crates/env-var · high confidence

The plugin system in \crates/plugin/src\ has been completely rewritten to support asynchronous plugin loading and execution. The new \PluginRegistry\ manages both extension and toolchain plugins, loading WASM modules on-demand with parallel execution while maintaining deterministic result ordering. A new \MoonHostData\ structure provides plugins with access to the workspace graph, environment, and configuration via host functions like \load\_project\_by\_id\ and \load\_task\_by\_target\. The registry now uses the \scc\ crate for concurrent-safe plugin storage and integrates with \warpgate\ for WASM plugin management, allowing plugins to safely interact with the Moon environment without blocking the main thread.

crates/plugin/src · high confidence

The visualizer's frontend has been completely rewritten using Preact and Tailwind CSS, replacing the previous implementation. This change introduces a new interactive graph visualization powered by Cytoscape.js, allowing users to switch between layout algorithms (dagre, klay, breadthfirst, grid) via a UI selector that persists the choice in the URL query string. The update also supports a new v2 graph data structure alongside the legacy v1 format, enabling more detailed rendering of action nodes (such as sync-workspace, setup-toolchain, and run-task variants) and their dependencies.

packages/visualizer/src · high confidence

The workspace configuration schema has been refactored from a single monolithic structure into distinct, dedicated modules for specific feature areas. This change introduces new configuration files for content-addressable storage (CAS) caching, code ownership rules, project constraints, Docker integration, experimental features, template generation, file hashing, terminal/webhook notifications, action pipeline behavior, remote execution services, and version control system (VCS) settings. Users will now interact with a more granular and organized configuration structure in \.moon/workspace.yml\, where settings are grouped by domain (e.g., \cache.cas\, \docker\, \pipeline\, \remote\, \vcs\) rather than being scattered across a flat list.

crates/config/src/workspace · high confidence

The CLI now clears the O\_NONBLOCK flag on standard input, output, and error file descriptors at startup. This prevents fatal EAGAIN (WouldBlock) errors and mid-task crashes when the CLI is invoked in environments that inherit non-blocking stdio, such as the GitHub Actions log forwarder.

crates/cli/src · high confidence

Added Git integration tests and fixtures; Added benchmarking for ToolchainRegistry operations; Added benchmarking infrastructure for AffectedTracker and WorkspaceBuilder; Added comprehensive integration tests for the task runner; Added comprehensive tests for the project graph builder; Added integration tests for CLI commands and fixtures; Added integration tests for actions and utilities; Added integration tests for daemon server RPCs, file watching, and task output caching; Added integration tests for toolchain plugin requirements and dependency workspace detection; Added pipeline test fixtures for Unix and Windows; Added signal handling and exit code test scenarios; Added snapshot tests for cache command input gathering; Added snapshot tests for project graph alias and cycle rendering; Added test fixtures and unit tests for HCL and Pkl configuration formats; Added test fixtures for CLI task features; Added test fixtures for CLI template generator; Added test fixtures for language and toolchain configurations; Added test fixtures for project graph aliasing, inheritance, and dependency resolution; Added test plugin for tc-tier3 toolchain install and locate flows; Added tests for AugmentedCommand toolchain inheritance behavior; Added tests for CAS store operations and garbage collection; Added tests for CodeownersGenerator across multiple VCS providers; Added tests for VCS hooks generation and cleanup; Added tests for action graph builder and test utilities; Added tests for action pipeline priority ordering and abort behavior; Added tests for codegen template inheritance, extension, and file processing; Added tests for file group pattern matching and directory resolution; Added tests for hash, digest, and content hashing logic; Added tests for project builder configuration and file group inheritance; Added tests for task builder and dependency resolution; Added tests for task expansion and token replacement logic; Added tests for task input hashing and ignore patterns; Added tests for the affected tracker's project and task cycle detection; Added tests for the plugin registry; Added tests for the report package's action and time formatting utilities; Snapshot tests added for CLI commands and graph outputs; Snapshot tests for action graph builder; WASM test plugin validates core crate compatibility.

A dependency / build maintenance change in (dependencies) — 1207 commits (145 fixs), 147 files.

(dependencies) · medium confidence · unverified

The project's package manager has been upgraded to Yarn 4.16.0, replacing the previous version with the new release binary. This update also introduces a new \.yarn/declined.txt\ file to explicitly track and reject specific packages (\@moonrepo/report\ and \website\) from installation.

.yarn · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 55 → 55 (+0.1)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 78 → 78 (-0.0)
• Architecture 70 → 71 (+0.1)
• Maturity 64 → 64 (-0.0)
• Readiness 68 → 55 (-13.3)
• Security 39 → 56 (+17.5)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 51 (new)
• Performance 73 (new)

• Critical CVE: [CVE redacted] (yarn.lock)
• Critical CVE: [CVE redacted] (yarn.lock)
• Critical CVE: [CVE redacted] (yarn.lock)
• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Documentation: no installation or build instructions (README.md)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• High CVE: [CVE redacted] (yarn.lock)
• …and 91 more

• Confusing naming convention: 'new' and 'new_full' suggest a constructor pattern, but 'new_full' implies 'new' is incomplete or defaulting. In Rust, 'new' is the standard constructor. Using 'new_full' for a second constructor is non-idiomatic and confusing.
• Dependency hygiene PARTLY measured — Cargo dependencies read, dependency currency not (crates.io unreachable)
• Documentation: contradicts the code (docs/CHANGELOG_V0.md)
• Duplicate intent: Both methods take a path and return a String, implying they perform the same normalization of path separators. The names 'normalize' and 'standardize' are semantically identical in this context.
• Duplicate intent: Two methods appear to check for the same CI environment condition. 'is_ci' is likely the standard accessor, while 'is_ci_env' is redundant or a legacy alias.
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High vulnerability: [GHSA redacted] (yarn.lock)
• Inconsistent return types and error handling: 'locate_root' returns a VirtualPath directly (implying it never fails or panics on failure), while 'locate_root_with_check' returns AnyResult. This inconsistency in error handling strategy for similar operations is confusing.
• Inconsistent return types and error handling: Same issue as 'locate_root' vs 'locate_root_with_check'. 'locate_root_many' returns VirtualPath directly, while the 'with_check' variant returns AnyResult.
• Inverted test pyramid
• Low cohesion: ExtensionRegistry (LCOM4 6) (crates/extension-plugin/src/extension_registry.rs)
• Low cohesion: MoonSandbox (LCOM4 4) (crates/test-utils/src/sandbox.rs)
• Low cohesion: MoonSession (LCOM4 5) (crates/app/src/session.rs)
• Low cohesion: ToolchainRegistry (LCOM4 17) (crates/toolchain-plugin/src/toolchain_registry.rs)
• …and 36 more

• 11 commits — 7 feature/other, 4 fixes

• (root) — 5 commits
• crates/app — 2 commits
• crates/cache-storage — 1 commit
• crates/config-loader — 1 commit
• crates/task-runner — 1 commit
• crates/vcs — 1 commit

• fix: fix(query): respect CI environment when tracking affected tasks and projects (#2707)
• fix: fix: Audit 09/26 (#2731)
• fix: fix: Restore numeric options (0-3) for MOON_COLOR (#2713)
• fix: fix: Wait for remote storage to connect before reading or writing the cache (#2715)
• change: chore: Bump packages
• change: chore: Bump packages
• change: chore: Release
• change: chore: Release
• change: docs: Update changelog.
• change: feat: Add MOON_BUILTIN_REGISTRY_HOST and MOON_BUILTIN_REGISTRY_NAMESPACE (#2709)
• change: perf: collect working tree status once per run (#2702)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

moonrepo/moon was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.