feat(check): redefine --no-lint for type-check-only workflow (#1444)

## Summary

Redefines `vp check --no-lint` so it runs Oxlint's `--type-check-only`
path when
`lint.options.typeCheck` is enabled in `vite.config.ts`, and makes
`vp check --no-fmt --no-lint` the natural type-check-only invocation.

Replaces the abandoned PR #1417 approach (sidecar `.mjs` +
`--no-type-check`
CLI flag), which conflicts with upstream PR #1378 handing config
resolution
back to oxlint/oxfmt.

Related: closes #1275 for the lint-rule-noise-free type-error triage
workflow.

## Behavior matrix

| Command | Behavior |
| ----------------------------------------------- |
------------------------------------------------ |
| `vp check --no-lint` (typeCheck=true) | Runs `--type-check-only`; lint
rules suppressed |
| `vp check --no-lint` (typeCheck=false/missing) | Skips lint phase
entirely (existing behavior) |
| `vp check --no-fmt --no-lint` (typeCheck=true) | Type-check only |
| `vp check --no-fmt --no-lint` (typeCheck=false) | `error: No checks
enabled` with remediation hint |
| `vp check --fix --no-lint` (typeCheck=true) | fmt `--fix` + read-only
type-check diagnostics |

`--no-type-check` CLI flag is **not** introduced — deferred to a
follow-up once
oxlint exposes a symmetric OFF-direction flag for type-check.

## Key design notes

- **typeAware prerequisite.** Type-check only runs when both
`lint.options.typeAware` and `lint.options.typeCheck` are true, matching
the
`--type-check` / `--type-aware` flag dependency in
`rfcs/check-command.md`
("If `--no-type-aware` is set, `--type-check` is also implicitly
disabled").
- **`--fix --no-lint` on a typeCheck-enabled project** runs fmt `--fix`
and
then type-check as read-only diagnostics. On type error, fmt's
completion
pass line is still surfaced so lint-staged / pre-commit flows can tell
the
  working tree was mutated before the failure (previously swallowed).
- **No sidecar.** Config resolution is left to oxlint/oxfmt per PR
#1378.

Author: jong-kyung

crates/vite_global_cli/src/help.rs

@@ -760,7 +760,10 @@ fn delegated_help_doc(command: &str) -> Option<HelpDoc> {
                     vec![
                         row("--fix", "Auto-fix format and lint issues"),
                         row("--no-fmt", "Skip format check"),
-                        row("--no-lint", "Skip lint check"),
+                        row(
+                            "--no-lint",
+                            "Skip lint rules; type-check still runs when `lint.options.typeCheck` is true",
+                        ),
                         row(
                             "--no-error-on-unmatched-pattern",
                             "Do not exit with error when pattern is unmatched",

docs/guide/check.md

@@ -14,7 +14,10 @@ We recommend turning `typeCheck` on so `vp check` becomes the single command for
 
 ```bash
 vp check
-vp check --fix # Format and run autofixers.
+vp check --fix             # Format and run autofixers.
+vp check --no-fmt          # Skip format; run lint (and type-check if enabled).
+vp check --no-lint         # Skip lint rules; keep type-check when enabled.
+vp check --no-fmt --no-lint # Type-check only (requires `typeCheck` enabled).
 ```
 
 ## Configuration

packages/cli/binding/src/check/analysis.rs

@@ -39,41 +39,61 @@ pub(super) struct LintFailure {
 pub(super) enum LintMessageKind {
     LintOnly,
     LintAndTypeCheck,
+    TypeCheckOnly,
 }
 
 impl LintMessageKind {
-    pub(super) fn from_lint_config(lint_config: Option<&serde_json::Value>) -> Self {
-        let type_check_enabled = lint_config
-            .and_then(|config| config.get("options"))
-            .and_then(|options| options.get("typeCheck"))
-            .and_then(serde_json::Value::as_bool)
-            .unwrap_or(false);
-
-        if type_check_enabled { Self::LintAndTypeCheck } else { Self::LintOnly }
+    pub(super) fn from_flags(lint_enabled: bool, type_check_enabled: bool) -> Self {
+        match (lint_enabled, type_check_enabled) {
+            (true, true) => Self::LintAndTypeCheck,
+            (true, false) => Self::LintOnly,
+            (false, true) => Self::TypeCheckOnly,
+            (false, false) => unreachable!(
+                "from_flags called with (false, false); caller must guard on run_lint_phase"
+            ),
+        }
     }
 
     pub(super) fn success_label(self) -> &'static str {
         match self {
             Self::LintOnly => "Found no warnings or lint errors",
             Self::LintAndTypeCheck => "Found no warnings, lint errors, or type errors",
+            Self::TypeCheckOnly => "Found no type errors",
         }
     }
 
     pub(super) fn warning_heading(self) -> &'static str {
         match self {
             Self::LintOnly => "Lint warnings found",
             Self::LintAndTypeCheck => "Lint or type warnings found",
+            Self::TypeCheckOnly => "Type warnings found",
         }
     }
 
     pub(super) fn issue_heading(self) -> &'static str {
         match self {
             Self::LintOnly => "Lint issues found",
             Self::LintAndTypeCheck => "Lint or type issues found",
+            Self::TypeCheckOnly => "Type errors found",
         }
     }
 }
 
+/// `typeCheck` requires `typeAware` as a prerequisite — oxlint's type-aware
+/// analysis must be on for TypeScript diagnostics to surface.
+pub(super) fn lint_config_type_check_enabled(lint_config: Option<&serde_json::Value>) -> bool {
+    let options = lint_config.and_then(|config| config.get("options"));
+    let type_aware = options
+        .and_then(|options| options.get("typeAware"))
+        .and_then(serde_json::Value::as_bool)
+        .unwrap_or(false);
+    let type_check = options
+        .and_then(|options| options.get("typeCheck"))
+        .and_then(serde_json::Value::as_bool)
+        .unwrap_or(false);
+    type_aware && type_check
+}
+
 fn parse_check_summary(line: &str) -> Option<CheckSummary> {
     let rest = line.strip_prefix("Finished in ")?;
     let (duration, rest) = rest.split_once(" on ")?;
@@ -227,29 +247,65 @@ pub(super) fn analyze_lint_output(output: &str) -> Option<Result<LintSuccess, Li
 mod tests {
     use serde_json::json;
 
-    use super::LintMessageKind;
+    use super::{LintMessageKind, lint_config_type_check_enabled};
 
     #[test]
     fn lint_message_kind_defaults_to_lint_only_without_typecheck() {
-        assert_eq!(LintMessageKind::from_lint_config(None), LintMessageKind::LintOnly);
-        assert_eq!(
-            LintMessageKind::from_lint_config(Some(&json!({ "options": {} }))),
-            LintMessageKind::LintOnly
-        );
+        assert!(!lint_config_type_check_enabled(None));
+        assert!(!lint_config_type_check_enabled(Some(&json!({ "options": {} }))));
+        assert_eq!(LintMessageKind::from_flags(true, false), LintMessageKind::LintOnly);
     }
 
     #[test]
     fn lint_message_kind_detects_typecheck_from_vite_config() {
-        let kind = LintMessageKind::from_lint_config(Some(&json!({
+        let config = json!({
             "options": {
                 "typeAware": true,
                 "typeCheck": true
             }
-        })));
+        });
 
+        assert!(lint_config_type_check_enabled(Some(&config)));
+
+        let kind = LintMessageKind::from_flags(true, true);
         assert_eq!(kind, LintMessageKind::LintAndTypeCheck);
         assert_eq!(kind.success_label(), "Found no warnings, lint errors, or type errors");
         assert_eq!(kind.warning_heading(), "Lint or type warnings found");
         assert_eq!(kind.issue_heading(), "Lint or type issues found");
     }
+
+    #[test]
+    fn lint_message_kind_type_check_only_labels() {
+        let kind = LintMessageKind::from_flags(false, true);
+        assert_eq!(kind, LintMessageKind::TypeCheckOnly);
+        assert_eq!(kind.success_label(), "Found no type errors");
+        assert_eq!(kind.warning_heading(), "Type warnings found");
+        assert_eq!(kind.issue_heading(), "Type errors found");
+    }
+
+    #[test]
+    fn lint_config_type_check_enabled_rejects_non_bool_values() {
+        assert!(!lint_config_type_check_enabled(Some(&json!({
+            "options": { "typeAware": true, "typeCheck": "true" }
+        }))));
+        assert!(!lint_config_type_check_enabled(Some(&json!({
+            "options": { "typeAware": true, "typeCheck": 1 }
+        }))));
+        assert!(!lint_config_type_check_enabled(Some(&json!({
+            "options": { "typeAware": true, "typeCheck": null }
+        }))));
+    }
+
+    #[test]
+    fn lint_config_type_check_requires_type_aware_prerequisite() {
+        assert!(!lint_config_type_check_enabled(Some(&json!({
+            "options": { "typeCheck": true }
+        }))));
+        assert!(!lint_config_type_check_enabled(Some(&json!({
+            "options": { "typeAware": false, "typeCheck": true }
+        }))));
+        assert!(!lint_config_type_check_enabled(Some(&json!({
+            "options": { "typeAware": true, "typeCheck": false }
+        }))));
+    }
 }

packages/cli/binding/src/check/mod.rs

@@ -10,7 +10,8 @@ use vite_task::ExitStatus;
 
 use self::analysis::{
     LintMessageKind, analyze_fmt_check_output, analyze_lint_output, format_count, format_elapsed,
-    print_error_block, print_pass_line, print_stdout_block, print_summary_line,
+    lint_config_type_check_enabled, print_error_block, print_pass_line, print_stdout_block,
+    print_summary_line,
 };
 use crate::cli::{
     CapturedCommandOutput, SubcommandResolver, SynthesizableSubcommand, resolve_and_capture_output,
@@ -28,14 +29,6 @@ pub(crate) async fn execute_check(
     cwd: &AbsolutePathBuf,
     cwd_arc: &Arc<AbsolutePath>,
 ) -> Result<ExitStatus, Error> {
-    if no_fmt && no_lint {
-        output::error("No checks enabled");
-        print_summary_line(
-            "`vp check` did not run because both `--no-fmt` and `--no-lint` were set",
-        );
-        return Ok(ExitStatus(1));
-    }
-
     let mut status = ExitStatus::SUCCESS;
     let has_paths = !paths.is_empty();
     // In --fix mode with file paths (the lint-staged use case), implicitly suppress
@@ -46,6 +39,18 @@ pub(crate) async fn execute_check(
     let mut deferred_lint_pass: Option<(String, String)> = None;
     let resolved_vite_config = resolver.resolve_universal_vite_config().await?;
 
+    let type_check_enabled = lint_config_type_check_enabled(resolved_vite_config.lint.as_ref());
+    let lint_enabled = !no_lint;
+    let run_lint_phase = lint_enabled || type_check_enabled;
+
+    if no_fmt && !run_lint_phase {
+        output::error("No checks enabled");
+        print_summary_line(
+            "Enable `lint.options.typeCheck` in vite.config.ts to use `vp check --no-fmt --no-lint` for type-check only, or drop a flag to re-enable fmt/lint.",
+        );
+        return Ok(ExitStatus(1));
+    }
+
     if !no_fmt {
         let mut args = if fix { vec![] } else { vec!["--check".to_string()] };
         if suppress_unmatched {
@@ -109,7 +114,7 @@ pub(crate) async fn execute_check(
             }
         }
 
-        if fix && no_lint && status == ExitStatus::SUCCESS {
+        if fix && !run_lint_phase && status == ExitStatus::SUCCESS {
             print_pass_line(
                 "Formatting completed for checked files",
                 Some(&format!("({})", format_elapsed(fmt_start.elapsed()))),
@@ -127,11 +132,12 @@ pub(crate) async fn execute_check(
         }
     }
 
-    if !no_lint {
-        let lint_message_kind =
-            LintMessageKind::from_lint_config(resolved_vite_config.lint.as_ref());
+    if run_lint_phase {
+        let lint_message_kind = LintMessageKind::from_flags(lint_enabled, type_check_enabled);
         let mut args = Vec::new();
-        if fix {
+        // oxlint cannot auto-fix type diagnostics, so `--fix` is dropped on the
+        // type-check-only path.
+        if fix && lint_enabled {
             args.push("--fix".to_string());
         }
         // `vp check` parses oxlint's human-readable summary output to print
@@ -140,6 +146,9 @@ pub(crate) async fn execute_check(
         // parser think linting never started. Force the default reporter here so the
         // captured output is stable across local and CI environments.
         args.push("--format=default".to_string());
+        if !lint_enabled && type_check_enabled {
+            args.push("--type-check-only".to_string());
+        }
         if suppress_unmatched {
             args.push("--no-error-on-unmatched-pattern".to_string());
         }
@@ -206,13 +215,18 @@ pub(crate) async fn execute_check(
             }
         }
         if status != ExitStatus::SUCCESS {
+            // Surface fmt `--fix` completion before bailing so users can see
+            // the working tree was mutated before the lint/type-check error.
+            if fix && !no_fmt {
+                flush_deferred_pass_lines(&mut fmt_fix_started, &mut deferred_lint_pass);
+            }
             return Ok(status);
         }
     }
 
     // Re-run fmt after lint --fix, since lint fixes can break formatting
-    // (e.g. the curly rule adding braces to if-statements)
-    if fix && !no_fmt && !no_lint {
+    // (e.g. the curly rule adding braces to if-statements).
+    if fix && !no_fmt && lint_enabled {
         let mut args = Vec::new();
         if suppress_unmatched {
             args.push("--no-error-on-unmatched-pattern".to_string());
@@ -240,20 +254,33 @@ pub(crate) async fn execute_check(
             );
             return Ok(status);
         }
-        if let Some(started) = fmt_fix_started {
-            print_pass_line(
-                "Formatting completed for checked files",
-                Some(&format!("({})", format_elapsed(started.elapsed()))),
-            );
-        }
-        if let Some((message, detail)) = deferred_lint_pass.take() {
-            print_pass_line(&message, Some(&detail));
-        }
+        flush_deferred_pass_lines(&mut fmt_fix_started, &mut deferred_lint_pass);
+    }
+
+    // Type-check-only mode skips the re-fmt block above, so flush deferred
+    // pass lines here.
+    if fix && !no_fmt && run_lint_phase && !lint_enabled {
+        flush_deferred_pass_lines(&mut fmt_fix_started, &mut deferred_lint_pass);
     }
 
     Ok(status)
 }
 
+fn flush_deferred_pass_lines(
+    fmt_fix_started: &mut Option<Instant>,
+    deferred_lint_pass: &mut Option<(String, String)>,
+) {
+    if let Some(started) = fmt_fix_started.take() {
+        print_pass_line(
+            "Formatting completed for checked files",
+            Some(&format!("({})", format_elapsed(started.elapsed()))),
+        );
+    }
+    if let Some((message, detail)) = deferred_lint_pass.take() {
+        print_pass_line(&message, Some(&detail));
+    }
+}
+
 /// Combine stdout and stderr from a captured command output.
 fn combine_output(captured: CapturedCommandOutput) -> (ExitStatus, String) {
     let combined = if captured.stderr.is_empty() {

packages/cli/binding/src/cli/types.rs

@@ -90,7 +90,7 @@ pub enum SynthesizableSubcommand {
         /// Skip format check
         #[arg(long = "no-fmt")]
         no_fmt: bool,
-        /// Skip lint check
+        /// Skip lint rules; type-check still runs when `lint.options.typeCheck` is true
         #[arg(long = "no-lint")]
         no_lint: bool,
         /// Do not exit with error when pattern is unmatched

packages/cli/snap-tests-global/command-check-help/snap.txt

@@ -6,7 +6,7 @@ Run format, lint, and type checks.
 Options:
   --fix                            Auto-fix format and lint issues
   --no-fmt                         Skip format check
-  --no-lint                        Skip lint check
+  --no-lint                        Skip lint rules; type-check still runs when `lint.options.typeCheck` is true
   --no-error-on-unmatched-pattern  Do not exit with error when pattern is unmatched
   -h, --help                       Print help
 
@@ -26,7 +26,7 @@ Run format, lint, and type checks.
 Options:
   --fix                            Auto-fix format and lint issues
   --no-fmt                         Skip format check
-  --no-lint                        Skip lint check
+  --no-lint                        Skip lint rules; type-check still runs when `lint.options.typeCheck` is true
   --no-error-on-unmatched-pattern  Do not exit with error when pattern is unmatched
   -h, --help                       Print help
 
@@ -46,7 +46,7 @@ Run format, lint, and type checks.
 Options:
   --fix                            Auto-fix format and lint issues
   --no-fmt                         Skip format check
-  --no-lint                        Skip lint check
+  --no-lint                        Skip lint rules; type-check still runs when `lint.options.typeCheck` is true
   --no-error-on-unmatched-pattern  Do not exit with error when pattern is unmatched
   -h, --help                       Print help
 

packages/cli/snap-tests/check-all-skipped/snap.txt

@@ -1,4 +1,4 @@
 [1]> vp check --no-fmt --no-lint
 error: No checks enabled
 
-`vp check` did not run because both `--no-fmt` and `--no-lint` were set
+Enable `lint.options.typeCheck` in vite.config.ts to use `vp check --no-fmt --no-lint` for type-check only, or drop a flag to re-enable fmt/lint.

packages/cli/snap-tests/check-fix-lint-error-not-swallowed/snap.txt

@@ -10,3 +10,4 @@ error: Lint issues found
   help: Avoid eval(). For JSON parsing use JSON.parse(); for dynamic property access use bracket notation (obj[key]); for other cases refactor to avoid evaluating strings as code.
 
 Found 1 error and 0 warnings in 1 file (<variable>ms, <variable> threads)
+pass: Formatting completed for checked files (<variable>ms)

packages/cli/snap-tests/check-fix-no-fmt-no-lint-typecheck/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "check-fix-no-fmt-no-lint-typecheck",
+  "version": "0.0.0",
+  "private": true
+}

packages/cli/snap-tests/check-fix-no-fmt-no-lint-typecheck/snap.txt

@@ -0,0 +1,2 @@
+> vp check --fix --no-fmt --no-lint
+pass: Found no type errors in 2 files (<variable>ms, <variable> threads)