fix(plan): use task's cwd for synthetic requests instead of context cwd (#90)

# Lazy Cache Initialization and Improved Subpackage Task Execution

This PR makes two key improvements:

1. Adds lazy initialization of the SQLite cache to prevent race conditions when multiple processes start simultaneously. The cache is now created only when first accessed, using a file lock to ensure thread safety.

2. Fixes synthetic command execution in subpackages by ensuring commands use the task's resolved working directory rather than the original invocation context. This ensures tools like oxlint run in the correct package directory when invoked through a synthetic command.

Additional changes:
- Switched from `DiGraph` to `StableGraph` to preserve node indices during removal
- Added test fixtures for synthetic commands in subpackages
- Improved documentation for CLI argument handling
- Added `custom_subcommand()` method to inspect custom subcommands before session creation

Author: branchseer

Cargo.lock

@@ -76,8 +76,10 @@ futures-util = "0.3.31"
 insta = "1.44.3"
 libc = "0.2.172"
 memmap2 = "0.9.7"
+monostate = "1.0.2"
 nix = { version = "0.30.1", features = ["dir"] }
 ntapi = "0.4.1"
+once_cell = "1.19"
 os_str_bytes = "7.1.1"
 ouroboros = "0.18.5"
 owo-colors = "4.1.0"

Cargo.toml

@@ -21,6 +21,7 @@ derive_more = { workspace = true, features = ["from"] }
 diff-struct = { workspace = true }
 fspy = { workspace = true }
 futures-util = { workspace = true }
+once_cell = { workspace = true }
 owo-colors = { workspace = true }
 petgraph = { workspace = true }
 rayon = { workspace = true }

crates/vite_task/Cargo.toml

@@ -6,17 +6,37 @@ use vite_str::Str;
 use vite_task_graph::{TaskSpecifier, query::TaskQueryKind};
 use vite_task_plan::plan_request::{PlanOptions, PlanRequest, QueryPlanRequest};
 
-/// Represents the CLI arguments handled by vite-task, including both built-in and custom subcommands.
+/// Represents the CLI arguments handled by vite-task, including both built-in (like run) and custom subcommands (like lint).
 #[derive(Debug)]
 pub struct TaskCLIArgs<CustomSubcommand: Subcommand> {
     pub(crate) original: Arc<[Str]>,
     pub(crate) parsed: ParsedTaskCLIArgs<CustomSubcommand>,
 }
 
+impl<CustomSubcommand: Subcommand> TaskCLIArgs<CustomSubcommand> {
+    /// Inspect the custom subcommand (like lint/install). Returns `None` if it's built-in subcommand
+    /// The caller should not use this method to actually handle the custom subcommand. Instead, it should
+    /// private TaskSynthesizer to Session so that vite-task can handle custom subcommands consistently from
+    /// both direct CLI invocations and invocations in task scripts.
+    ///
+    /// This method is provided only to make it possible for the caller to behave differently BEFORE and AFTER the session.
+    /// For example, vite+ needs this method to skip auto-install when the custom subcommand is already `install`.
+    pub fn custom_subcommand(&self) -> Option<&CustomSubcommand> {
+        match &self.parsed {
+            ParsedTaskCLIArgs::BuiltIn(_) => None,
+            ParsedTaskCLIArgs::Custom(custom) => Some(custom),
+        }
+    }
+}
+
+/// Represents the overall CLI arguments, containing three kinds of subcommands:
+/// 1. Built-in subcommands handled by vite-task (like run)
+/// 2. Custom subcommands handled by vite-task with the help of TaskSyntheizer (like lint)
+/// 3. Custom subcommands not handled by vite-task (like vite+ commands without cache)
 pub enum CLIArgs<CustomSubcommand: Subcommand, NonTaskSubcommand: Subcommand> {
-    /// vite-task's own built-in subcommands
+    /// Subcommands handled by vite task, including built-in (like run) and custom (like lint)
     Task(TaskCLIArgs<CustomSubcommand>),
-    /// custom subcommands provided by vite+
+    /// Custom subcommands not handled by vite task (like vite+ commands without cache)
     NonTask(NonTaskSubcommand),
 }
 

crates/vite_task/src/cli/mod.rs

@@ -2,7 +2,7 @@
 
 pub mod display;
 
-use std::{fmt::Display, io::Write, sync::Arc, time::Duration};
+use std::{fmt::Display, fs::File, io::Write, sync::Arc, time::Duration};
 
 use bincode::{Decode, Encode, decode_from_slice, encode_to_vec};
 // Re-export display functions for convenience
@@ -71,6 +71,11 @@ impl ExecutionCache {
         tracing::info!("Creating task cache directory at {:?}", path);
         std::fs::create_dir_all(path)?;
 
+        // Use file lock to prevent race conditions when multiple processes initialize the database
+        let lock_path = path.join("db_open.lock");
+        let lock_file = File::create(lock_path.as_path())?;
+        lock_file.lock()?;
+
         let db_path = path.join("cache.db");
         let conn = Connection::open(db_path.as_path())?;
         conn.execute_batch("PRAGMA journal_mode=WAL;")?;
@@ -101,6 +106,7 @@ impl ExecutionCache {
                 }
             }
         }
+        // Lock is released when lock_file is dropped
         Ok(Self { conn: Mutex::new(conn) })
     }
 

crates/vite_task/src/session/cache/mod.rs

@@ -4,7 +4,7 @@ pub mod spawn;
 use std::sync::Arc;
 
 use futures_util::FutureExt;
-use petgraph::{algo::toposort, graph::DiGraph};
+use petgraph::{algo::toposort, stable_graph::StableGraph};
 use vite_path::AbsolutePath;
 use vite_task_plan::{
     ExecutionItemKind, ExecutionPlan, LeafExecutionKind, SpawnExecution, TaskExecution,
@@ -46,9 +46,9 @@ impl ExecutionContext<'_> {
     ) -> Result<(), ExecutionAborted> {
         match item_kind {
             ExecutionItemKind::Expanded(graph) => {
-                // clone for reversing edges and removing nodes
-                let mut graph: DiGraph<&TaskExecution, (), ExecutionIx> =
-                    graph.map(|_, task_execution| task_execution, |_, ()| ());
+                // Use StableGraph to preserve node indices during removal
+                let mut graph: StableGraph<&TaskExecution, (), _, ExecutionIx> =
+                    graph.map(|_, task_execution| task_execution, |_, ()| ()).into();
 
                 // To be consistent with the package graph in vite_package_manager and the dependency graph definition in Wikipedia
                 // https://en.wikipedia.org/wiki/Dependency_graph, we construct the graph with edges from dependents to dependencies
@@ -339,10 +339,24 @@ impl<'a, CustomSubcommand> Session<'a, CustomSubcommand> {
         plan: ExecutionPlan,
         mut reporter: Box<dyn Reporter>,
     ) -> Result<(), ExitStatus> {
+        // Lazily initialize the cache on first execution
+        let cache = match self.cache() {
+            Ok(cache) => cache,
+            Err(err) => {
+                reporter.handle_event(ExecutionEvent {
+                    execution_id: ExecutionId::zero(),
+                    kind: ExecutionEventKind::Error {
+                        message: format!("Failed to initialize cache: {err}"),
+                    },
+                });
+                return Err(ExitStatus(1));
+            }
+        };
+
         let mut execution_context = ExecutionContext {
             event_handler: &mut *reporter,
             current_execution_id: ExecutionId::zero(),
-            cache: &self.cache,
+            cache,
             cache_base_path: &self.workspace_path,
         };
 

crates/vite_task/src/session/execute/mod.rs

@@ -10,6 +10,7 @@ use cache::ExecutionCache;
 pub use cache::{CacheMiss, FingerprintMismatch};
 use clap::{Parser, Subcommand};
 pub use event::ExecutionEvent;
+use once_cell::sync::OnceCell;
 pub use reporter::{LabeledReporter, Reporter};
 use vite_path::{AbsolutePath, AbsolutePathBuf};
 use vite_str::Str;
@@ -142,7 +143,10 @@ pub struct Session<'a, CustomSubcommand> {
 
     plan_request_parser: PlanRequestParser<'a, CustomSubcommand>,
 
-    cache: ExecutionCache,
+    /// Cache is lazily initialized to avoid SQLite race conditions when multiple
+    /// processes (e.g., parallel `vite lib` commands) start simultaneously.
+    cache: OnceCell<ExecutionCache>,
+    cache_path: AbsolutePathBuf,
 }
 
 fn get_cache_path_of_workspace(workspace_root: &AbsolutePath) -> AbsolutePathBuf {
@@ -181,13 +185,7 @@ impl<'a, CustomSubcommand> Session<'a, CustomSubcommand> {
         let workspace_node_modules_bin = workspace_root.path.join("node_modules").join(".bin");
         prepend_path_env(&mut envs, &workspace_node_modules_bin)?;
 
-        if !cache_path.as_path().exists()
-            && let Some(cache_dir) = cache_path.as_path().parent()
-        {
-            tracing::info!("Creating task cache directory at {}", cache_dir.display());
-            std::fs::create_dir_all(cache_dir)?;
-        }
-        let cache = ExecutionCache::load_from_path(cache_path)?;
+        // Cache is lazily initialized on first access to avoid SQLite race conditions
         Ok(Self {
             workspace_path: Arc::clone(&workspace_root.path),
             lazy_task_graph: LazyTaskGraph::Uninitialized {
@@ -197,12 +195,16 @@ impl<'a, CustomSubcommand> Session<'a, CustomSubcommand> {
             envs: Arc::new(envs),
             cwd,
             plan_request_parser: PlanRequestParser { task_synthesizer: callbacks.task_synthesizer },
-            cache,
+            cache: OnceCell::new(),
+            cache_path,
         })
     }
 
-    pub fn cache(&self) -> &ExecutionCache {
-        &self.cache
+    /// Lazily initializes and returns the execution cache.
+    /// The cache is only created when first accessed to avoid SQLite race conditions
+    /// when multiple processes start simultaneously.
+    pub fn cache(&self) -> anyhow::Result<&ExecutionCache> {
+        self.cache.get_or_try_init(|| ExecutionCache::load_from_path(self.cache_path.clone()))
     }
 
     pub fn workspace_path(&self) -> Arc<AbsolutePath> {

crates/vite_task/src/session/mod.rs

@@ -14,7 +14,7 @@ path = "src/main.rs"
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
-monostate = "1.0.2"
+monostate = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 vite_path = { workspace = true }
 vite_str = { workspace = true }

crates/vite_task_bin/Cargo.toml

@@ -0,0 +1,5 @@
+{
+  "scripts": {
+    "lint": "vite run a#lint"
+  }
+}

crates/vite_task_bin/tests/test_snapshots/fixtures/synthetic-in-subpackage/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "a",
+  "scripts": {
+    "lint": "vite lint"
+  }
+}