Merge branch 'main' into fix/basic-readme-markdown

Author: sleitor

Cargo.lock

@@ -124,6 +124,7 @@ dunce = "1.0.3"
 either = "1.9.0"
 futures = "0.3.31"
 git2 = { version = "0.20.4", default-features = false }
+gix-index = { version = "0.47.0", default-features = false }
 hex = "0.4.3"
 httpmock = { version = "0.8.0", default-features = false }
 indicatif = "0.18.3"

Cargo.toml

@@ -605,6 +605,7 @@ impl APIClient {
     /// Builds a shared HTTP client with optional connect timeout. This is
     /// the single TLS initialization point — all consumers should share the
     /// resulting client.
+    #[tracing::instrument(skip_all)]
     pub fn build_http_client(connect_timeout: Option<Duration>) -> Result<reqwest::Client> {
         let mut builder = reqwest::Client::builder();
         if let Some(dur) = connect_timeout {

crates/turborepo-api-client/src/lib.rs

@@ -119,12 +119,12 @@ mod tests {
     // Mock the turborepo_dirs functions for testing
     fn create_mock_vercel_config_dir() -> AbsoluteSystemPathBuf {
         let tmp_dir = tempdir().expect("Failed to create temp dir");
-        AbsoluteSystemPathBuf::try_from(tmp_dir.into_path()).expect("Failed to create path")
+        AbsoluteSystemPathBuf::try_from(tmp_dir.keep()).expect("Failed to create path")
     }
 
     fn create_mock_turbo_config_dir() -> AbsoluteSystemPathBuf {
         let tmp_dir = tempdir().expect("Failed to create temp dir");
-        AbsoluteSystemPathBuf::try_from(tmp_dir.into_path()).expect("Failed to create path")
+        AbsoluteSystemPathBuf::try_from(tmp_dir.keep()).expect("Failed to create path")
     }
 
     fn setup_auth_file(

crates/turborepo-auth/src/auth/mod.rs

@@ -256,13 +256,19 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
 
         let mut visited = HashSet::new();
         let mut engine: Engine<Building, TaskDefinition> = Engine::default();
+        let mut turbo_json_chain_cache: HashMap<PackageName, Vec<&TurboJson>> = HashMap::new();
 
         while let Some(task_id) = traversal_queue.pop_front() {
             {
                 let (task_id, span) = task_id.clone().split();
                 engine.add_task_location(task_id.into_owned(), span);
             }
 
+            // Skip before doing expensive work if we've already processed this task.
+            if visited.contains(task_id.as_inner()) {
+                continue;
+            }
+
             // For root tasks, verify they are either explicitly enabled OR (when using
             // add_all_tasks mode like devtools) have a definition in root turbo.json.
             // Tasks defined without the //#  prefix (like "transit") in root turbo.json
@@ -323,17 +329,13 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
                 )));
             }
 
-            let task_definition = self.task_definition(
+            let task_definition = self.task_definition_cached(
                 turbo_json_loader,
                 &task_id,
                 &task_id.as_non_workspace_task_name(),
+                &mut turbo_json_chain_cache,
             )?;
 
-            // Skip this iteration of the loop if we've already seen this taskID
-            if visited.contains(task_id.as_inner()) {
-                continue;
-            }
-
             visited.insert(task_id.as_inner().clone());
 
             // Note that the Go code has a whole if/else statement for putting stuff into
@@ -576,19 +578,51 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
         Ok(TaskDefinitionResult::not_found())
     }
 
-    fn task_definition(
+    /// Resolves the merged `TaskDefinition` for a task, caching the turbo.json
+    /// chain per package. The chain only depends on the package name (not the
+    /// task), so multiple tasks in the same package share the cached chain.
+    fn task_definition_cached<'b>(
         &self,
-        turbo_json_loader: &L,
+        turbo_json_loader: &'b L,
         task_id: &Spanned<TaskId>,
         task_name: &TaskName,
+        chain_cache: &mut HashMap<PackageName, Vec<&'b TurboJson>>,
     ) -> Result<TaskDefinition, BuilderError> {
         let processed_task_definition = ProcessedTaskDefinition::from_iter(
-            self.task_definition_chain(turbo_json_loader, task_id, task_name)?,
+            self.task_definition_chain_cached(turbo_json_loader, task_id, task_name, chain_cache)?,
         );
         let path_to_root = self.path_to_root(task_id.as_inner())?;
         TaskDefinition::from_processed(processed_task_definition, &path_to_root)
     }
 
+    /// Like `task_definition_chain` but caches the turbo.json chain per
+    /// package.
+    fn task_definition_chain_cached<'b>(
+        &self,
+        turbo_json_loader: &'b L,
+        task_id: &Spanned<TaskId>,
+        task_name: &TaskName,
+        chain_cache: &mut HashMap<PackageName, Vec<&'b TurboJson>>,
+    ) -> Result<Vec<ProcessedTaskDefinition>, BuilderError> {
+        let package_name = PackageName::from(task_id.package());
+        let turbo_json_chain = match chain_cache.get(&package_name) {
+            Some(cached) => cached.clone(),
+            None => {
+                let chain = self.turbo_json_chain(turbo_json_loader, &package_name)?;
+                chain_cache.insert(package_name, chain.clone());
+                chain
+            }
+        };
+
+        Self::resolve_task_definitions_from_chain(
+            turbo_json_chain,
+            task_id,
+            task_name,
+            self.is_single,
+            self.should_validate_engine,
+        )
+    }
+
     pub fn task_definition_chain(
         &self,
         turbo_json_loader: &L,
@@ -597,6 +631,25 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
     ) -> Result<Vec<ProcessedTaskDefinition>, BuilderError> {
         let package_name = PackageName::from(task_id.package());
         let turbo_json_chain = self.turbo_json_chain(turbo_json_loader, &package_name)?;
+        Self::resolve_task_definitions_from_chain(
+            turbo_json_chain,
+            task_id,
+            task_name,
+            self.is_single,
+            self.should_validate_engine,
+        )
+    }
+
+    /// Given a resolved turbo.json chain for a package, extract the task
+    /// definitions for a specific task by walking the chain and handling
+    /// `extends: false`.
+    fn resolve_task_definitions_from_chain(
+        turbo_json_chain: Vec<&TurboJson>,
+        task_id: &Spanned<TaskId>,
+        task_name: &TaskName,
+        is_single: bool,
+        should_validate_engine: bool,
+    ) -> Result<Vec<ProcessedTaskDefinition>, BuilderError> {
         let mut task_definitions = Vec::new();
 
         // Find the first package in the chain (iterating in reverse from leaf to root)
@@ -645,7 +698,7 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
             task_definitions.push(root_definition)
         }
 
-        if self.is_single {
+        if is_single {
             return match task_definitions.is_empty() {
                 true => {
                     let (span, text) = task_id.span_and_text("turbo.json");
@@ -667,7 +720,7 @@ impl<'a, L: TurboJsonLoader> EngineBuilder<'a, L> {
             }
         }
 
-        if task_definitions.is_empty() && self.should_validate_engine {
+        if task_definitions.is_empty() && should_validate_engine {
             let (span, text) = task_id.span_and_text("turbo.json");
             return Err(BuilderError::MissingPackageTask(Box::new(
                 MissingPackageTaskError {

crates/turborepo-engine/src/builder.rs

@@ -63,6 +63,7 @@ impl<T: TaskDefinitionInfo + Clone + Send + Sync + 'static> Engine<Built, T> {
     // finish even once a task sends back the stop signal. This is suboptimal
     // since it would mean the visitor would need to also track if
     // it is cancelled :)
+    #[tracing::instrument(skip_all)]
     pub async fn execute(
         self: Arc<Self>,
         options: ExecutionOptions,

crates/turborepo-engine/src/execute.rs

@@ -440,6 +440,24 @@ fn needs_path_cleaning(s: &str) -> bool {
     false
 }
 
+/// Returns true if the pattern contains glob metacharacters (*, ?, [, {).
+/// Literal file paths return false.
+pub fn is_glob_pattern(pattern: &str) -> bool {
+    // Check for unescaped glob metacharacters
+    let mut chars = pattern.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '\\' {
+            // Skip escaped character
+            chars.next();
+            continue;
+        }
+        if matches!(c, '*' | '?' | '[' | '{') {
+            return true;
+        }
+    }
+    false
+}
+
 pub fn globwalk_with_settings(
     base_path: &AbsoluteSystemPath,
     include: &[ValidatedGlob],

crates/turborepo-globwalk/src/lib.rs

@@ -60,7 +60,7 @@ pub struct TaskHashable<'a> {
     pub global_hash: &'a str,
     pub task_dependency_hashes: Vec<String>,
     pub hash_of_files: &'a str,
-    pub external_deps_hash: Option<String>,
+    pub external_deps_hash: Option<&'a str>,
 
     // task
     pub package_dir: Option<turbopath::RelativeUnixPathBuf>,
@@ -320,7 +320,7 @@ impl From<TaskHashable<'_>> for Builder<HeapAllocator> {
 
         builder.set_hash_of_files(task_hashable.hash_of_files);
         if let Some(external_deps_hash) = task_hashable.external_deps_hash {
-            builder.set_external_deps_hash(&external_deps_hash);
+            builder.set_external_deps_hash(external_deps_hash);
         }
 
         builder.set_task(task_hashable.task);
@@ -512,7 +512,7 @@ mod test {
             task_dependency_hashes: vec!["task_dependency_hash".to_string()],
             package_dir: Some(turbopath::RelativeUnixPathBuf::new("package_dir").unwrap()),
             hash_of_files: "hash_of_files",
-            external_deps_hash: Some("external_deps_hash".to_string()),
+            external_deps_hash: Some("external_deps_hash"),
             task: "task",
             outputs: TaskOutputs {
                 inclusions: vec!["inclusions".to_string()],

crates/turborepo-hash/src/lib.rs

@@ -127,7 +127,7 @@ turborepo-profile-md = { workspace = true }
 turborepo-repository = { path = "../turborepo-repository" }
 turborepo-run-cache = { path = "../turborepo-run-cache" }
 turborepo-run-summary = { workspace = true }
-turborepo-scm = { workspace = true, features = ["git2"] }
+turborepo-scm = { workspace = true, features = ["git2", "gix"] }
 turborepo-scope = { path = "../turborepo-scope" }
 turborepo-shim = { workspace = true }
 turborepo-signals = { workspace = true }

crates/turborepo-lib/Cargo.toml

@@ -357,6 +357,10 @@ impl RunBuilder {
         )?;
 
         let env_at_execution_start = EnvironmentVariableMap::infer();
+        // Pre-warm the turbo.json cache: read and parse all package turbo.json
+        // files in parallel before the engine builder needs them sequentially.
+        turbo_json_loader.preload_all();
+
         let mut engine = self.build_engine(
             &pkg_dep_graph,
             &root_turbo_json,