Simplify Args to Task/Tool; remove execute_synthetic and Lint/Test/EnvTest

- Args now only has Task (forwarded to session.main) and Tool (finds vtt
  in PATH and synthesizes a plan request)
- Remove session.execute_synthetic and all related test fixtures (exec-api,
  e2e-env-test)
- Convert builtin-different-cwd to use print-cwd, lint-dot-git and
  e2e-lint-cache to use print-file, builtin-non-zero-exit to use
  replace-file-content with missing searchValue
- Update plan fixtures from vt lint to vt tool print lint, and
  vt env-test to TEST_VAR=val vt tool print-env

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: branchseer

crates/vite_task_bin/src/lib.rs

@@ -6,7 +6,6 @@ use std::{
 };
 
 use clap::Parser;
-use rustc_hash::FxHashMap;
 use vite_path::AbsolutePath;
 use vite_str::Str;
 use vite_task::{
@@ -47,66 +46,14 @@ pub fn find_executable(
     Ok(executable_path.into_os_string().into())
 }
 
-/// Create a synthetic plan request for running a tool from `node_modules/.bin`.
-///
-/// # Errors
-///
-/// Returns an error if the executable cannot be found.
-fn synthesize_node_modules_bin_task(
-    executable_name: &str,
-    args: &[Str],
-    envs: &Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>,
-    cwd: &Arc<AbsolutePath>,
-) -> anyhow::Result<SyntheticPlanRequest> {
-    Ok(SyntheticPlanRequest {
-        program: find_executable(get_path_env(envs), cwd, executable_name)?,
-        args: args.into(),
-        cache_config: UserCacheConfig::with_config(EnabledCacheConfig {
-            env: None,
-            untracked_env: None,
-            input: None,
-        }),
-        envs: Arc::clone(envs),
-    })
-}
-
-/// Create a synthetic plan request for running a `vtt` subcommand.
-///
-/// # Errors
-///
-/// Returns an error if the `vtt` executable cannot be found.
-fn synthesize_vtt_task(
-    subcommand: &str,
-    args: &[Str],
-    cache_config: UserCacheConfig,
-    envs: &Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>,
-    cwd: &Arc<AbsolutePath>,
-) -> anyhow::Result<SyntheticPlanRequest> {
-    let mut full_args = vec![Str::from(subcommand)];
-    full_args.extend_from_slice(args);
-    Ok(SyntheticPlanRequest {
-        program: find_executable(get_path_env(envs), cwd, "vtt")?,
-        args: full_args.into(),
-        cache_config,
-        envs: Arc::clone(envs),
-    })
-}
-
 #[derive(Debug, Parser)]
 #[command(name = "vt", version)]
 pub enum Args {
-    Lint {
+    /// Run a tool via vtt.
+    Tool {
         #[clap(trailing_var_arg = true, allow_hyphen_values = true)]
         args: Vec<Str>,
     },
-    Test {
-        #[clap(trailing_var_arg = true, allow_hyphen_values = true)]
-        args: Vec<Str>,
-    },
-    EnvTest {
-        name: Str,
-        value: Str,
-    },
     #[command(flatten)]
     Task(Command),
 }
@@ -131,32 +78,18 @@ impl vite_task::CommandHandler for CommandHandler {
             std::iter::once(command.program.as_str()).chain(command.args.iter().map(Str::as_str)),
         )?;
         match args {
-            Args::Lint { args } => Ok(HandledCommand::Synthesized(
-                synthesize_node_modules_bin_task("oxlint", &args, &command.envs, &command.cwd)?,
-            )),
-            Args::Test { args } => Ok(HandledCommand::Synthesized(
-                synthesize_node_modules_bin_task("vitest", &args, &command.envs, &command.cwd)?,
-            )),
-            Args::EnvTest { name, value } => {
-                let mut envs = FxHashMap::clone(&command.envs);
-                envs.insert(
-                    Arc::from(OsStr::new(name.as_str())),
-                    Arc::from(OsStr::new(value.as_str())),
-                );
-                let envs = Arc::new(envs);
-
-                let untracked = vec![name.clone()];
-                Ok(HandledCommand::Synthesized(synthesize_vtt_task(
-                    "print-env",
-                    std::slice::from_ref(&name),
-                    UserCacheConfig::with_config(EnabledCacheConfig {
+            Args::Tool { args } => {
+                let program = find_executable(get_path_env(&command.envs), &command.cwd, "vtt")?;
+                Ok(HandledCommand::Synthesized(SyntheticPlanRequest {
+                    program,
+                    args: args.into_iter().filter(|a| a.as_str() != "--").collect(),
+                    cache_config: UserCacheConfig::with_config(EnabledCacheConfig {
                         env: None,
-                        untracked_env: Some(untracked),
+                        untracked_env: None,
                         input: None,
                     }),
-                    &envs,
-                    &command.cwd,
-                )?))
+                    envs: Arc::clone(&command.envs),
+                }))
             }
             Args::Task(parsed) => Ok(HandledCommand::ViteTaskCommand(parsed)),
         }

crates/vite_task_bin/src/main.rs

@@ -1,16 +1,11 @@
-use std::{process::ExitCode, sync::Arc};
+use std::process::ExitCode;
 
 use clap::Parser;
-use vite_str::Str;
-use vite_task::{
-    EnabledCacheConfig, ExitStatus, Session, UserCacheConfig, get_path_env,
-    plan_request::SyntheticPlanRequest,
-};
+use vite_task::{ExitStatus, Session};
 use vite_task_bin::{Args, OwnedSessionConfig};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<ExitCode> {
-    #[expect(clippy::large_futures, reason = "top-level await in main, no alternative")]
     let exit_status = run().await?;
     Ok(exit_status.0.into())
 }
@@ -21,35 +16,7 @@ async fn run() -> anyhow::Result<ExitStatus> {
     let session = Session::init(owned_config.as_config())?;
     match args {
         Args::Task(parsed) => session.main(parsed).await,
-        args => {
-            // If env FOO is set, run `vtt print-env FOO` via Session::exec before proceeding.
-            // In vite-plus, Session::exec is used for auto-install.
-            let envs = session.envs();
-            if envs.contains_key(std::ffi::OsStr::new("FOO")) {
-                let program =
-                    vite_task_bin::find_executable(get_path_env(envs), session.cwd(), "vtt")?;
-                let request = SyntheticPlanRequest {
-                    program,
-                    args: [Str::from("print-env"), Str::from("FOO")].into(),
-                    cache_config: UserCacheConfig::with_config({
-                        EnabledCacheConfig {
-                            env: Some(Box::from([Str::from("FOO")])),
-                            untracked_env: None,
-                            input: None,
-                        }
-                    }),
-                    envs: Arc::clone(envs),
-                };
-                let cache_key: Arc<[Str]> = Arc::from([Str::from("print-env-foo")]);
-                #[expect(
-                    clippy::large_futures,
-                    reason = "execute_synthetic produces a large future"
-                )]
-                let status = session.execute_synthetic(request, cache_key, true).await?;
-                if status != ExitStatus::SUCCESS {
-                    return Ok(status);
-                }
-            }
+        args @ Args::Tool { .. } => {
             #[expect(clippy::print_stdout, reason = "CLI binary output for non-task commands")]
             {
                 println!("{args:?}");

crates/vite_task_bin/src/vtt.rs

@@ -11,7 +11,7 @@ fn main() {
     if args.len() < 2 {
         eprintln!("Usage: vtt <subcommand> [args...]");
         eprintln!(
-            "Subcommands: check-tty, print, print-env, print-file, read-stdin, replace-file-content, touch-file"
+            "Subcommands: check-tty, print, print-cwd, print-env, print-file, read-stdin, replace-file-content, touch-file"
         );
         std::process::exit(1);
     }
@@ -25,6 +25,7 @@ fn main() {
             cmd_print(&args[2..]);
             Ok(())
         }
+        "print-cwd" => cmd_print_cwd(),
         "print-env" => cmd_print_env(&args[2..]),
         "print-file" => cmd_print_file(&args[2..]),
         "read-stdin" => cmd_read_stdin(),
@@ -56,6 +57,12 @@ fn cmd_print(args: &[String]) {
     println!("{}", args.join(" "));
 }
 
+fn cmd_print_cwd() -> Result<(), Box<dyn std::error::Error>> {
+    let cwd = std::env::current_dir()?;
+    println!("{}", cwd.display());
+    Ok(())
+}
+
 fn cmd_print_env(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     if args.is_empty() {
         return Err("Usage: vtt print-env <VAR_NAME>".into());

crates/vite_task_bin/tests/e2e_snapshots/fixtures/builtin-different-cwd/.gitignore

@@ -1,5 +1,6 @@
 {
   "scripts": {
-    "lint": "vt lint"
+    "cwd1": "cd folder1 && vt tool print-cwd",
+    "cwd2": "cd folder2 && vt tool print-cwd"
   }
 }

crates/vite_task_bin/tests/e2e_snapshots/fixtures/builtin-different-cwd/folder1/a.js

@@ -1,11 +1,10 @@
-# Tests that tasks have separate cache per cwd
+# Tests that synthetic tasks have separate cache per cwd
 
 [[e2e]]
 name = "builtin different cwd"
 steps = [
-  "cd folder1 && vt run lint # cache miss in folder1",
-  "cd folder2 && vt run lint # cache miss in folder2",
-  "echo 'console.log(1);' > folder2/a.js # modify folder2",
-  "cd folder1 && vt run lint # cache hit",
-  "cd folder2 && vt run lint # cache miss",
+  "vt run cwd1 # cache miss in folder1",
+  "vt run cwd2 # cache miss in folder2 (different cwd)",
+  "vt run cwd1 # cache hit in folder1",
+  "vt run cwd2 # cache hit in folder2",
 ]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/builtin-different-cwd/folder2/a.js

@@ -2,25 +2,21 @@
 source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
 expression: e2e_outputs
 ---
-[1]> cd folder1 && vt run lint # cache miss in folder1
-Error: Invalid vite task command: vt with args ["lint"] under cwd "<workspace>/"
+> vt run cwd1 # cache miss in folder1
+~/folder1$ vt tool print-cwd
+<workspace>/folder1
+> vt run cwd2 # cache miss in folder2 (different cwd)
+~/folder2$ vt tool print-cwd
+<workspace>/folder2
+> vt run cwd1 # cache hit in folder1
+~/folder1$ vt tool print-cwd ◉ cache hit, replaying
+<workspace>/folder1
 
-Caused by:
-    cannot find binary path
-[1]> cd folder2 && vt run lint # cache miss in folder2
-Error: Invalid vite task command: vt with args ["lint"] under cwd "<workspace>/"
-
-Caused by:
-    cannot find binary path
-> echo 'console.log(1);' > folder2/a.js # modify folder2
-
-[1]> cd folder1 && vt run lint # cache hit
-Error: Invalid vite task command: vt with args ["lint"] under cwd "<workspace>/"
-
-Caused by:
-    cannot find binary path
-[1]> cd folder2 && vt run lint # cache miss
-Error: Invalid vite task command: vt with args ["lint"] under cwd "<workspace>/"
+---
+vt run: cache hit.
+> vt run cwd2 # cache hit in folder2
+~/folder2$ vt tool print-cwd ◉ cache hit, replaying
+<workspace>/folder2
 
-Caused by:
-    cannot find binary path
+---
+vt run: cache hit.

crates/vite_task_bin/tests/e2e_snapshots/fixtures/builtin-different-cwd/package.json

@@ -1,6 +1,6 @@
 {
   "name": "builtin-non-zero-exit-test",
   "scripts": {
-    "lint": "vt lint"
+    "lint": "vt tool replace-file-content bad.js NOTFOUND replacement"
   }
 }