nrwl/nx

Features

• Angular Build Runners - Provides optimized build pipelines for Angular applications with support for high-performance bundling.
• Monorepo Build Tools - Orchestrates builds for large-scale monorepos by mapping project dependencies and executing only tasks impacted by specific code changes.
• Dependency Mapping - Examines source files to identify and map static, dynamic, or implicit relationships between projects for accurate impact analysis.
• Build and Task Automation - Orchestrates build pipelines and task execution across monorepo projects by analyzing dependencies and code changes.
• Durable Task Orchestrators - Orchestrates task execution by analyzing dependencies and parallelizing operations to maximize hardware utilization.
• Dependency Graph Orchestrators - Maps project relationships to analyze code impact and execute only affected tasks during builds.
• Distributed Task Orchestrators - Orchestrates parallel task execution across distributed computing resources while sharing cached artifacts to accelerate large-scale builds.
• Content-Addressable Caches - Stores task outputs based on input hashes to prevent redundant computation across local and remote environments.
• Affected Project Detectors - Identifies the minimal set of projects impacted by code changes to avoid unnecessary task execution.
• Affected Project Execution - Optimizes build and test times by identifying and executing only the tasks impacted by specific code changes.
• Monorepo Managers - Provides a suite of automation tools for code generation, dependency management, and workspace maintenance within a unified monorepo environment.
• Task Execution - Analyzes code changes to execute only impacted tasks while utilizing caching to reuse build artifacts.
• CI Workflow Automations - Integrates build and test processes into CI pipelines to execute only the code affected by recent changes.
• Release Automation - Coordinates versioning, changelog generation, and publishing for multiple projects within a monorepo.
• Background Daemons - Maintains a persistent background process that monitors file changes for near-instant build feedback.
• Dependency Boundary Enforcers - Enforces architectural boundaries by restricting dependencies between libraries to maintain code integrity.
• Task Orchestration Engines - Parallelizes build, test, and deployment tasks across multiple machines while utilizing content-addressable caching for high-performance execution.
• Task Caching Configurations - Configures task caching patterns to prevent redundant work by reusing results for identical inputs.
• Method Result Caches - Provides local caching of task execution results to avoid redundant processing when inputs remain unchanged.
• Distributed Caching - Shares build and test results across team members and CI environments to eliminate redundant computation and accelerate development cycles.
• Task Output Persistence - Shares task execution results across machines and environments to eliminate redundant work in distributed teams.
• Result Caching - Caches deterministic task outputs locally to significantly reduce build and test times.
• Persistent Graph Caching Processes - Maintains a persistent background process that keeps the project graph in memory for near-instant build feedback.
• Build & Bundling Tools - Compiles source code into production-ready assets for client-side and server-side rendering.
• Build Plugin Integrators - Integrates technology-specific automation for code generation, task execution, and dependency detection to support diverse development stacks.
• Build Task Runners - Enables the definition of specialized execution logic for custom build, test, and deployment tasks.
• Workspace Initializers - Automates the setup of new development workspaces and integrates existing codebases into a unified monorepo.
• Package Publishing Pipelines - Automates version updates and artifact publishing to registries as part of the build workflow.
• Parallel Task Runners - Executes build and test tasks concurrently across multiple machines to reduce total build time.
• Project Task Definitions - Registers shell commands and scripts as executable tasks to unify management across different project types.
• Project Version Managers - Centralizes dependency version management to ensure consistent package versions across all projects in a workspace.
• Independent Version Group Managers - Manages versioning and release cadences for grouped projects within a monorepo.
• Remote Build Caches - Synchronizes task artifacts across machines and CI executions using shared cloud storage.
• Task Automation Pipelines - Defines and manages execution dependencies between tasks to ensure correct build sequences.
• Task Inference Engines - Automates task configuration and caching settings by programmatically detecting project files and mapping them to build or test commands.
• Task Dependency Management - Defines execution order and prerequisites for tasks across the project graph.
• Visual Task Managers - Provides a graphical interface within code editors to manage tasks, explore project dependencies, and execute commands without manual terminal input.
• Dependency Cascade Updaters - Propagates version changes automatically across dependent projects to ensure consistency throughout the monorepo.
• External Task Orchestrators - Orchestrates build and test commands across diverse technology stacks within a single repository.
• CI Agent Scalers - Provides dynamic allocation of CI compute resources to balance workloads and scale execution capacity based on project needs.
• CI Self-Healing Systems - Implements self-healing CI workflows that automatically analyze and propose fixes for pipeline failures.
• Workspace Initializers - Provides automated setup for monorepo structures with integrated build, test, and linting tools.
• Distributed Task Queues - Dynamically assigns build and test tasks to available machines in a CI cluster to balance workload and scale capacity.
• Plugin Frameworks - Integrates specialized tools and generators for specific frameworks or languages to automate project configuration and maintenance.
• GitHub Release Automators - Generates release notes from conventional commits and publishes them as official releases on GitHub.
• Commit-Based Versioning Engines - Automatically calculates and applies semantic version increments by analyzing commit history against standard conventions.
• Abstract Syntax Tree Tools - Parses source code into tree structures to perform accurate refactoring and automated code transformations.
• Project Metadata Tags - Validates import rules against metadata tags to prevent unauthorized coupling between projects.
• Module Boundary Enforcement - Enforces strict boundaries between code modules by preventing unauthorized imports based on project tags.
• Plugin-Based Architectures - Integrates custom automation logic through a modular interface that scans and registers project configurations.
• Flaky Task Retry Managers - Automatically identifies and re-runs non-deterministic tasks to improve continuous integration pipeline reliability.
• Parallel Task Executors - Executes multiple tasks across projects in parallel while respecting dependency constraints to maximize build performance.
• Workload Orchestrators - Coordinates and distributes concurrent build and test workloads across multiple machines to maintain consistent execution times.
• Test Suite Partitioning - Partitions large test suites into individual file-level tasks for parallel execution across multiple compute nodes.
• Custom Workflow Generators - Provides a framework for defining custom generators to standardize project scaffolding and development workflows.
• Monorepo Management - Build system for scaling and maintaining monorepos.
• Monorepos - Build system for scaling and maintaining monorepos.
• Build Tools - Provides plugin and tooling support for monorepo-based Angular development.
• Build Tools and Bundlers - Extensible build framework for monorepos and large-scale development.
• Build Tools and Tooling - Monorepo platform for scaling builds and CI.
• 开发者工具 - Extensible build system for monorepo management.
• Project Scaffolding - Monorepo-ready scaffolding for React and testing frameworks.
• Query Result Caching - Synchronizes task outputs across team members and CI environments to eliminate redundant work.
• Task Result Storage - Synchronizes build and task outputs across team members and CI environments to accelerate development cycles.
• Task Execution Engines - Executes build and test operations concurrently across multiple projects to streamline development workflows in large monorepos.
• Dependency Graph Explorers - Provides AI agents with graph-based dependency data and terminal access to improve context and reduce manual exploration.
• Dependency Caches - Caches package dependencies locally to accelerate CI pipelines and improve build performance.
• Task Sandboxing - Isolates task execution environments to ensure build consistency and prevent unauthorized file access.
• Target Default Centralizers - Centralizes common task settings like caching and dependencies in a global configuration file so individual projects inherit consistent behavior without redundant definitions.
• Proxy Caches - Uses a local proxy cache for external packages to reduce network latency and protect against registry outages.
• Parallel Execution - Runs multiple build or test processes simultaneously to reduce execution time by utilizing available CPU resources.
• Release Changelog Generators - Generates release notes by analyzing commit messages against conventional commit patterns to determine version increments.
• Project Node Identifiers - Automatically discovers and registers projects within the monorepo by scanning workspace configurations.
• Repository Migration Orchestrators - Executes custom scripts during version upgrades to update configurations and refactor code across a monorepo.
• Version Plan Processors - Processes version plan files to automate version increments and changelog generation for project groups.
• Project Workspaces - Links multiple projects within a single repository to manage shared dependencies and local structure.
• CI Workflow Generators - Generates standardized CI configuration files that integrate task execution, caching, and distribution.
• Build Caches - Reuses intermediate Docker build layers from a registry cache to reduce total image build times.
• Automated Fix Validators - Analyzes failed CI tasks to propose fixes and automatically re-runs flaky operations to maintain pipeline stability.
• Pipeline Failure Recovery - Analyzes failed CI builds and applies verified fixes to allow autonomous recovery of pipeline health.
• Build System Extensions - Defines custom logic to discover and register projects within a workspace by implementing standardized interfaces for file-based configuration processing.
• Docker Target Configurators - Enables execution of builds and tests requiring a Docker daemon directly within the CI environment.
• Container Image Caching - Caches container images in a local registry mirror to accelerate downloads and improve availability.
• Dependency Visualizers - Displays graphical representations of project dependencies impacted by code changes to help developers understand update scope.
• Codebase Modularization - Organizes application logic into independent local libraries to enforce boundaries and improve reusability.
• Test Suite Partitioners - Distributes large test suites across multiple parallel agents to ensure rapid completion of verification processes.
• Migration Agents - Uses AI agents to execute project imports and resolve environment-specific configuration issues.
• Task Input Monitors - Monitors task execution by tracking filesystem access to ensure build isolation and cache integrity.
• Pipeline-Specific Caches - Creates branch-specific cache environments to prevent cross-workflow cache pollution in distributed CI environments.
• Interactive Migration Managers - Provides interactive control to selectively apply, reorder, or skip migration tasks during workspace updates.
• Cache Input and Output Specifications - Defines specific files, environment variables, and outputs that determine task cache validity.
• AI Coding Assistant Rules - Supplies workspace-specific context and documentation to AI coding tools to improve the relevance of generated suggestions.
• Automated Update Managers - Synchronizes package versions and configuration files across the monorepo to ensure consistent tooling environments.
• Build & Release Automation - Provides a programmatic interface to build custom, dynamic release processes for complex requirements.
• Build Error Reporters - Posts build logs and performance insights directly into merge request comments for immediate review.
• Incremental Build Caches - Caches type information for individual projects to enable incremental builds and reduce memory usage.
• Tooling Configuration Updaters - Modifies project files programmatically during generation to enforce organizational standards and apply custom settings to build or test tools.
• Deployment - Generates production-ready deployment manifests and lock files by analyzing project dependency graphs.
• Package Registries - Configures and manages package publication to various registries with support for scoped overrides.
• Package Migrators - Automates the migration of dependencies and configuration files to handle breaking changes across the workspace.
• Project Changelogs - Maintains individual changelog files for each project to document component-specific changes.
• Automated Task Detectors - Automatically detects and registers project scripts and configurations as executable tasks.
• Repository Importers - Integrates external repositories into a monorepo while preserving commit history and lineage.
• Code Generation - Scaffolds files and performs complex code transformations using an API that understands the project graph.
• Build Environment Configurations - Maps environment variables to specific build settings and overrides to manage different deployment targets or environment-specific behaviors within a single project.
• Project Scaffolding - Provides custom code generators to enforce organizational standards and best practices for new files.
• Application Generators - Scaffolds structured project files and configurations for applications and libraries using automated tools.
• Task Inference Engines - Analyzes configuration files to automatically register build, test, and lint tasks without manual setup.
• Task Configuration Overrides - Provides mechanisms to override inferred task settings at the project or workspace level.
• Custom Task Executors - Invokes multiple build or test tasks programmatically within a single custom executor.
• Task Isolation Enforcers - Restricts task process file access to declared scopes to ensure build consistency and identify undeclared dependencies.
• Pull Request Status Trackers - Provides immediate feedback on code changes by posting build summaries and logs directly to pull request comments.
• Smart CI Pipelines - Analyzes failing CI tasks to suggest or apply fixes that restore build health automatically.
• Container Image Registries - Automates the building, tagging, and pushing of containerized applications to remote registries as part of the release workflow.
• Library Distribution Bundlers - Bundles and packages libraries into optimized artifacts for distribution to external registries.
• Release Behavior Configurators - Enables granular control over versioning and publishing logic for specific project subsets within the workspace.
• Import Access Policies - Validates code imports against tag-based constraints during build processes to enforce architectural boundaries.
• Automated Task Execution Engines - Monitors file modifications to automatically trigger and batch build or test commands during development.
• Task Boundary Validators - Monitors file system access during task execution to detect undeclared inputs or outputs.
• Dependency Boundary Overrides - Permits specific project imports that violate global tagging rules by defining explicit configuration exceptions.
• Versioning Policies - Centralizes dependency definitions at the workspace root to ensure consistent versions across all projects and prevent runtime conflicts.
• Editor Failure Notifications - Sends notifications about build or test failures directly to the developer's editor for faster resolution.
• Distributed CI Completion Signals - Signals task completion to ensure compute resources are released and CI statuses are updated accurately.
• AI Agent Integrations - Provides integration interfaces for AI coding agents to navigate, modify, and monitor monorepo tasks.
• Organization-Based Access Management - Automates user provisioning and permissions by mapping organization memberships from version control providers.
• Interactive Graph Visualizers - Provides interactive maps of project tasks and their interdependencies to visualize execution flow and debug build pipelines.
• Continuous Process Executors - Manages long-running background services and ensures they are ready before dependent tasks execute.
• Build-Time Code Generators - Generates buildable library outputs to allow applications to reference pre-compiled code and reduce build times.
• Automated Code Refactoring - Integrates automated refactoring scripts into generation pipelines to modify source code programmatically.
• Command Standardizers - Allows running arbitrary terminal commands as project tasks to integrate external tools into the standard workflow.
• Commit Type Behavior Configurators - Enables definition of how specific commit types influence versioning logic and changelog organization.
• Tooling Defaults - Provides pre-configured settings for common development tools so that projects can function without requiring manual configuration files for standard use cases.
• Dependency Consistency Validators - Detects and resolves version mismatches between individual projects and workspace standards.
• Workspace File Modifiers - Programmatically creates, updates, and deletes files using templates to scaffold code structures.
• Extensible CLI Workspaces - Integrates non-JavaScript languages through plugins that provide automatic dependency detection and target inference.
• IDE Extensions - Integrates task execution and project exploration directly into development environments.
• Process Result Handlers - Posts build and test results to pull requests to provide immediate feedback on the impact of code changes.
• Visual Generators - Provides a visual interface to select and configure generators with real-time previews of file changes.
• Project Configuration - Standardizes tool execution and manages dependency updates across the repository using plugins.
• Pre-versioning Tasks - Executes custom build scripts automatically before version updates to ensure distribution files are ready.
• Root Task Executors - Executes and manages workspace-wide tasks with integrated caching and pipeline support.
• Versioned Package Managers - Updates version numbers and internal dependency references across multiple manifest files to ensure consistent releases.
• Version Overrides - Allows forcing specific dependency versions to bypass default recommendations during updates.
• Dependency Graph Visualizers - Generates interactive dependency graph visualizations to help developers identify impacted projects and understand architectural relationships.
• Build Tool Integrations - Discovers and configures build, test, and linting tasks across diverse languages via a modular plugin system.
• Task Precondition Configurators - Triggers generators before tasks to verify or update project settings and environment configurations.
• Workflow Task Generators - Combines multiple pre-built automation tasks into a single workflow to modify project files efficiently.
• Zero-Dependency Initializers - Bootstraps workspace environments in non-JavaScript repositories to enable task orchestration without package manager files.
• Browser Compatibility Configurations - Specifies target browser versions to determine necessary code transformations, polyfills, and build optimizations for web applications.
• Environment Variable Configurations - Loads environment variables from project-specific or workspace-level files based on target names and configurations to manage application settings across different environments.
• Project Release Filters - Restricts release operations to specific project subsets using patterns, tags, or directories.
• Cached Artifact Encryption - Secures stored build artifacts using workspace-specific encryption keys.
• Social Authentication Providers - Restricts workspace access by requiring authentication through configured third-party identity providers.
• Task Artifact Encryption - Encrypts task outputs locally before transmission to remote caches to ensure data privacy.
• Execution Failure Policies - Implements policies to detect and recover from CI agent failures during task execution.
• Automatic Plugin Initializers - Registers a plugin within the workspace configuration automatically when a user installs the package, ensuring immediate readiness for task inference.
• Plugin Version Management - Automates the alignment of package versions across a monorepo to ensure compatibility.
• Reactive Change Detection - Monitors dependency changes to trigger task execution only for impacted projects within the monorepo.
• Execution Logs - Captures and stores terminal output from automated tasks to simplify debugging and monitoring of pipeline activities.
• Flaky Task Analyzers - Analyzes task reliability and identifies flaky processes to improve workspace health and build stability.
• Task Violation Monitors - Tracks and reports unauthorized file access during task execution to identify configuration errors.
• End-to-End Testing - Splits large end-to-end test suites into individual tasks to enable parallel execution across multiple compute nodes.
• Pull Request Integrations - Integrates build results and execution logs directly into pull requests for immediate feedback.
• Application Bundlers - Transforms source code into optimized bundles using high-performance bundlers to accelerate build times.
• Server-Side Rendering - Provides server-side rendering capabilities for web applications to improve performance and SEO.

Star 历史