fun: Fun mode.

Author: cpojer

packages/cli/assets/error.png

@@ -771,4 +771,5 @@ module.exports.rewritePrettier = nativeBinding.rewritePrettier;
 module.exports.rewriteScripts = nativeBinding.rewriteScripts;
 module.exports.run = nativeBinding.run;
 module.exports.runCommand = nativeBinding.runCommand;
+module.exports.takeCheckFailureKind = nativeBinding.takeCheckFailureKind;
 module.exports.vitePlusHeader = nativeBinding.vitePlusHeader;

packages/cli/binding/index.cjs

@@ -369,5 +369,7 @@ export interface RunCommandResult {
   pathAccesses: Record<string, PathAccess>;
 }
 
+export declare function takeCheckFailureKind(): string | null;
+
 /** Render the Vite+ header using the Rust implementation. */
 export declare function vitePlusHeader(): string;

packages/cli/binding/index.d.cts

@@ -832,6 +832,13 @@ impl LintMessageKind {
             Self::LintAndTypeCheck => "Lint or type issues found",
         }
     }
+
+    fn failure_kind(self) -> &'static str {
+        match self {
+            Self::LintOnly => "lint",
+            Self::LintAndTypeCheck => "type-aware",
+        }
+    }
 }
 
 fn parse_check_summary(line: &str) -> Option<CheckSummary> {
@@ -1098,6 +1105,7 @@ async fn execute_direct_subcommand(
                             "Formatting failed during fix",
                         );
                     }
+                    crate::set_last_check_failure_kind(Some("formatting"));
                     return Ok(status);
                 }
             }
@@ -1175,6 +1183,7 @@ async fn execute_direct_subcommand(
                     }
                 }
                 if status != ExitStatus::SUCCESS {
+                    crate::set_last_check_failure_kind(Some(lint_message_kind.failure_kind()));
                     return Ok(status);
                 }
             }
@@ -1211,6 +1220,7 @@ async fn execute_direct_subcommand(
                         &combined_output,
                         "Formatting failed after lint fixes were applied",
                     );
+                    crate::set_last_check_failure_kind(Some("formatting"));
                     return Ok(status);
                 }
                 if let Some(started) = fmt_fix_started {
@@ -1663,6 +1673,12 @@ mod tests {
         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");
+        assert_eq!(kind.failure_kind(), "type-aware");
+    }
+
+    #[test]
+    fn lint_message_kind_reports_plain_lint_failures() {
+        assert_eq!(LintMessageKind::LintOnly.failure_kind(), "lint");
     }
 
     #[test]

packages/cli/binding/src/cli.rs

@@ -18,7 +18,13 @@ mod package_manager;
 #[allow(dead_code)]
 mod utils;
 
-use std::{collections::HashMap, error::Error as StdError, ffi::OsStr, fmt::Write as _, sync::Arc};
+use std::{
+    collections::HashMap,
+    error::Error as StdError,
+    ffi::OsStr,
+    fmt::Write as _,
+    sync::{Arc, LazyLock, Mutex},
+};
 
 use napi::{anyhow, bindgen_prelude::*, threadsafe_function::ThreadsafeFunction};
 use napi_derive::napi;
@@ -28,6 +34,21 @@ use crate::cli::{
     BoxedResolverFn, CliOptions as ViteTaskCliOptions, ResolveCommandResult, ViteConfigResolverFn,
 };
 
+static LAST_CHECK_FAILURE_KIND: LazyLock<Mutex<Option<String>>> =
+    LazyLock::new(|| Mutex::new(None));
+
+pub(crate) fn set_last_check_failure_kind(kind: Option<&str>) {
+    let mut last_failure_kind =
+        LAST_CHECK_FAILURE_KIND.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    *last_failure_kind = kind.map(str::to_owned);
+}
+
+fn take_last_check_failure_kind() -> Option<String> {
+    let mut last_failure_kind =
+        LAST_CHECK_FAILURE_KIND.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    last_failure_kind.take()
+}
+
 /// Module initialization - sets up tracing for debugging
 #[napi_derive::module_init]
 pub fn init() {
@@ -130,6 +151,8 @@ fn format_error_message(error: &(dyn StdError + 'static)) -> String {
 /// and process JavaScript callbacks (via ThreadsafeFunction).
 #[napi]
 pub async fn run(options: CliOptions) -> Result<i32> {
+    set_last_check_failure_kind(None);
+
     // Use provided cwd or current directory
     let mut cwd = current_dir()?;
     if let Some(options_cwd) = options.cwd {
@@ -198,6 +221,11 @@ pub async fn run(options: CliOptions) -> Result<i32> {
     }
 }
 
+#[napi]
+pub fn take_check_failure_kind() -> Option<String> {
+    take_last_check_failure_kind()
+}
+
 /// Render the Vite+ header using the Rust implementation.
 #[napi]
 pub fn vite_plus_header() -> String {

packages/cli/binding/src/lib.rs

@@ -20,7 +20,7 @@
 
 import { execSync } from 'node:child_process';
 import { existsSync, globSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { copyFile, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { copyFile, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parseArgs } from 'node:util';
@@ -60,6 +60,7 @@ const napiArgs = process.argv
 
 if (!skipTs) {
   await buildCli();
+  await copyCliAssets();
   buildGlobalModules();
   generateLicenseFile({
     title: 'Vite-Plus CLI license',
@@ -165,10 +166,11 @@ async function buildCli() {
     console.error(formatDiagnostics(cjsDiagnostics, cjsHost));
     process.exit(1);
   }
-  await rename(
-    join(projectDir, 'dist/define-config.js'),
-    join(projectDir, 'dist/define-config.cjs'),
-  );
+  const defineConfigJsPath = join(projectDir, 'dist/define-config.js');
+  const defineConfigCjsPath = join(projectDir, 'dist/define-config.cjs');
+  if (existsSync(defineConfigJsPath)) {
+    await copyFile(defineConfigJsPath, defineConfigCjsPath);
+  }
 
   const host = createCompilerHost(options);
 
@@ -196,6 +198,30 @@ async function buildCli() {
     console.error(formatDiagnostics(diagnostics, host));
     process.exit(1);
   }
+
+  if (existsSync(defineConfigJsPath)) {
+    await copyFile(defineConfigJsPath, defineConfigCjsPath);
+  } else if (existsSync(defineConfigCjsPath)) {
+    await copyFile(defineConfigCjsPath, defineConfigJsPath);
+  }
+}
+
+async function copyCliAssets() {
+  const assetsDir = join(projectDir, 'assets');
+  if (!existsSync(assetsDir)) {
+    return;
+  }
+
+  const distAssetsDir = join(projectDir, 'dist', 'assets');
+  await mkdir(distAssetsDir, { recursive: true });
+
+  for (const entry of readdirSync(assetsDir)) {
+    const sourcePath = join(assetsDir, entry);
+    if (!statSync(sourcePath).isFile()) {
+      continue;
+    }
+    await copyFile(sourcePath, join(distAssetsDir, entry));
+  }
 }
 
 function buildGlobalModules() {

packages/cli/build.ts

@@ -102,6 +102,10 @@
       "types": "./dist/test/internal/browser.d.ts",
       "default": "./dist/test/internal/browser.js"
     },
+    "./test/internal/module-runner": {
+      "types": "./dist/test/internal/module-runner.d.ts",
+      "default": "./dist/test/internal/module-runner.js"
+    },
     "./test/runners": {
       "types": "./dist/test/runners.d.ts",
       "default": "./dist/test/runners.js"
@@ -131,9 +135,9 @@
       "types": "./dist/test/snapshot.d.ts",
       "default": "./dist/test/snapshot.js"
     },
-    "./test/runtime": {
-      "types": "./dist/test/runtime.d.ts",
-      "default": "./dist/test/runtime.js"
+    "./test/mocker": {
+      "types": "./dist/test/mocker.d.ts",
+      "default": "./dist/test/mocker.js"
     },
     "./test/worker": {
       "types": "./dist/test/worker.d.ts",

packages/cli/package.json

@@ -12,7 +12,7 @@
 
 import path from 'node:path';
 
-import { run } from '../binding/index.js';
+import { run, takeCheckFailureKind } from '../binding/index.js';
 import { applyToolInitConfigToViteConfig, inspectInitCommand } from './init-config.js';
 import { doc } from './resolve-doc.js';
 import { fmt } from './resolve-fmt.js';
@@ -21,6 +21,7 @@ import { pack } from './resolve-pack.js';
 import { test } from './resolve-test.js';
 import { resolveUniversalViteConfig } from './resolve-vite-config.js';
 import { vite } from './resolve-vite.js';
+import { normalizeCheckFailureKind, printCheckFailureImage } from './utils/check-failure-image.js';
 import { accent, errorMsg, log } from './utils/terminal.js';
 
 function getErrorMessage(err: unknown): string {
@@ -94,6 +95,13 @@ if (command === 'create') {
     });
 
     let finalExitCode = exitCode;
+    if (command === 'check' && finalExitCode !== 0) {
+      await printCheckFailureImage(
+        process.stderr,
+        process.env,
+        normalizeCheckFailureKind(takeCheckFailureKind()),
+      );
+    }
     if (exitCode === 0) {
       try {
         const result = await applyToolInitConfigToViteConfig(command, args.slice(1));
@@ -126,6 +134,13 @@ if (command === 'create') {
     process.exit(finalExitCode);
   } catch (err) {
     errorMsg(getErrorMessage(err));
+    if (command === 'check') {
+      await printCheckFailureImage(
+        process.stderr,
+        process.env,
+        normalizeCheckFailureKind(takeCheckFailureKind()),
+      );
+    }
     process.exit(1);
   }
 }

packages/cli/src/bin.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  buildKittyImageSequence,
+  buildOsc1337FileSequence,
+  detectInlineImageProtocol,
+  getCheckFailureCaption,
+  getImagePlacement,
+  normalizeCheckFailureKind,
+  readPngDimensions,
+} from '../check-failure-image.js';
+
+describe('detectInlineImageProtocol', () => {
+  it('prefers the OSC 1337 file protocol for iTerm2 and WezTerm', () => {
+    expect(detectInlineImageProtocol({ TERM_PROGRAM: 'iTerm.app' })).toBe('file');
+    expect(detectInlineImageProtocol({ TERM_PROGRAM: 'WezTerm' })).toBe('file');
+  });
+
+  it('uses kitty graphics for kitty-compatible terminals', () => {
+    expect(detectInlineImageProtocol({ KITTY_WINDOW_ID: '12' })).toBe('kitty');
+    expect(detectInlineImageProtocol({ TERM_PROGRAM: 'ghostty' })).toBe('kitty');
+    expect(detectInlineImageProtocol({ TERM: 'xterm-kitty' })).toBe('kitty');
+  });
+
+  it('falls back to sixel when advertised and an encoder is available', () => {
+    expect(detectInlineImageProtocol({ TERM_FEATURES: 'RGBSx' }, { canRenderSixel: true })).toBe(
+      'sixel',
+    );
+  });
+
+  it('returns null when no supported image protocol is available', () => {
+    expect(detectInlineImageProtocol({ TERM: 'xterm-256color' })).toBeNull();
+  });
+});
+
+describe('inline image sequences', () => {
+  it('builds a kitty graphics sequence with the encoded file path', () => {
+    const sequence = buildKittyImageSequence('/tmp/error.png', {
+      columns: 26,
+      rows: 17,
+    });
+
+    expect(sequence).toContain('a=T,t=f,f=100,c=26,r=17');
+    expect(sequence).toContain(Buffer.from('/tmp/error.png').toString('base64'));
+    expect(sequence).toContain('\u001b_G');
+  });
+
+  it('builds an OSC 1337 file sequence with the encoded file contents', () => {
+    const sequence = buildOsc1337FileSequence('/tmp/error.png', Buffer.from('png-bytes'), {
+      columns: 26,
+      rows: 17,
+    });
+
+    expect(sequence).toContain(']1337;File=');
+    expect(sequence).toContain('width=26;height=17;preserveAspectRatio=1;inline=1');
+    expect(sequence).toContain(Buffer.from('error.png').toString('base64'));
+    expect(sequence).toContain(Buffer.from('png-bytes').toString('base64'));
+  });
+});
+
+describe('PNG helpers', () => {
+  it('reads dimensions from the PNG header and derives a bounded placement', () => {
+    const png = Buffer.from(
+      '89504e470d0a1a0a0000000d494844520000038a000004c0080600000000000000',
+      'hex',
+    );
+
+    expect(readPngDimensions(png)).toEqual({ width: 906, height: 1216 });
+    expect(getImagePlacement({ width: 906, height: 1216 })).toEqual({
+      columns: 26,
+      rows: 17,
+    });
+  });
+});
+
+describe('fun mode captions', () => {
+  it('uses the requested default caption for generic failures', () => {
+    expect(getCheckFailureCaption('error')).toBe(
+      'The static analysis enthusiast says: outstanding, another error',
+    );
+  });
+
+  it('varies the caption by failure kind', () => {
+    expect(getCheckFailureCaption('formatting')).toContain('another formatting error');
+    expect(getCheckFailureCaption('lint')).toContain('another lint error');
+    expect(getCheckFailureCaption('type-aware')).toContain('another type-aware error');
+  });
+
+  it('normalizes unknown failure kinds to the generic error caption', () => {
+    expect(normalizeCheckFailureKind('formatting')).toBe('formatting');
+    expect(normalizeCheckFailureKind('lint')).toBe('lint');
+    expect(normalizeCheckFailureKind('type-aware')).toBe('type-aware');
+    expect(normalizeCheckFailureKind('something-else')).toBe('error');
+    expect(normalizeCheckFailureKind(null)).toBe('error');
+  });
+});