vite-plus 0.1.0 → 0.1.1

package/AGENTS.md

@@ -2,43 +2,62 @@
 
 # Using Vite+, the Unified Toolchain for the Web
 
-This project is using Vite+, a modern toolchain built on top of Vite, Rolldown, Vitest, tsdown, Oxlint, and Oxfmt. Vite+ wraps these tools and package manager commands in a single, global CLI called `vp`. Vite+ is distinct from Vite, but it invokes Vite through `vp dev` and `vp build`.
+This project is using Vite+, a unified toolchain built on top of Vite, Rolldown, Vitest, tsdown, Oxlint, Oxfmt, and Vite Task. Vite+ wraps runtime management, package management, and frontend tooling in a single global CLI called `vp`. Vite+ is distinct from Vite, but it invokes Vite through `vp dev` and `vp build`.
 
 ## Vite+ Workflow
 
 `vp` is a global binary that handles the full development lifecycle. Run `vp help` to print a list of commands and `vp <command> --help` for information about a specific command.
 
-### Vite+ Commands
+### Start
+
+- create - Create a new project from a template
+- migrate - Migrate an existing project to Vite+
+- config - Configure hooks and agent integration
+- staged - Run linters on staged files
+- install (`i`) - Install dependencies
+- env - Manage Node.js versions
+
+### Develop
 
 - dev - Run the development server
-- build - Build for production
+- check - Run format, lint, and TypeScript type checks
 - lint - Lint code
-- test - Run tests
 - fmt - Format code
-- check - Run format, lint, and type checks
-- lib - Build library
-- migrate - Migrate an existing project to Vite+
-- create - Create a new monorepo package (in-project) or a new project (global)
-- exec - Execute a command in workspace packages (supports `--filter`, `-r`, `--parallel`)
-- run - Run tasks from `package.json` scripts
+- test - Run tests
 
-These commands map to their corresponding tools. For example, `vp dev --port 3000` runs Vite's dev server and works the same as Vite. `vp test` runs JavaScript tests through the bundled Vitest. The version of all tools can be checked using `vp --version`. This is useful when researching documentation, features, and bugs.
+### Execute
+
+- run - Run monorepo tasks
+- exec - Execute a command from local `node_modules/.bin`
+- dlx - Execute a package binary without installing it as a dependency
+- cache - Manage the task cache
+
+### Build
 
-### Package Manager Commands
+- build - Build for production
+- pack - Build libraries
+- preview - Preview production build
+
+### Manage Dependencies
 
 Vite+ automatically detects and wraps the underlying package manager such as pnpm, npm, or Yarn through the `packageManager` field in `package.json` or package manager-specific lockfiles.
 
-- install - Install all dependencies, or add packages if package names are provided
 - add - Add packages to dependencies
-- remove - Remove packages from dependencies
-- dlx - Execute a package binary without installing it as a dependency
-- info - View package information from the registry, including latest versions
-- link - Link packages for local development
+- remove (`rm`, `un`, `uninstall`) - Remove packages from dependencies
+- update (`up`) - Update packages to latest versions
+- dedupe - Deduplicate dependencies
 - outdated - Check for outdated packages
+- list (`ls`) - List installed packages
+- why (`explain`) - Show why a package is installed
+- info (`view`, `show`) - View package information from the registry
+- link (`ln`) / unlink - Manage local package links
 - pm - Forward a command to the package manager
-- unlink - Unlink packages
-- update - Update packages to their latest versions
-- why - Show why a package is installed
+
+### Maintain
+
+- upgrade - Update `vp` itself to the latest version
+
+These commands map to their corresponding tools. For example, `vp dev --port 3000` runs Vite's dev server and works the same as Vite. `vp test` runs JavaScript tests through the bundled Vitest. The version of all tools can be checked using `vp --version`. This is useful when researching documentation, features, and bugs.
 
 ## Common Pitfalls
 
@@ -46,11 +65,12 @@ Vite+ automatically detects and wraps the underlying package manager such as pnp
 - **Always use Vite commands to run tools:** Don't attempt to run `vp vitest` or `vp oxlint`. They do not exist. Use `vp test` and `vp lint` instead.
 - **Running scripts:** Vite+ commands take precedence over `package.json` scripts. If there is a `test` script defined in `scripts` that conflicts with the built-in `vp test` command, run it using `vp run test`.
 - **Do not install Vitest, Oxlint, Oxfmt, or tsdown directly:** Vite+ wraps these tools. They must not be installed directly. You cannot upgrade these tools by installing their latest versions. Always use Vite+ commands.
+- **Use Vite+ wrappers for one-off binaries:** Use `vp dlx` instead of package-manager-specific `dlx`/`npx` commands.
 - **Import JavaScript modules from `vite-plus`:** Instead of importing from `vite` or `vitest`, all modules should be imported from the project's `vite-plus` dependency. For example, `import { defineConfig } from 'vite-plus';` or `import { expect, test, vi } from 'vite-plus/test';`. You must not install `vitest` to import test utilities.
 - **Type-Aware Linting:** There is no need to install `oxlint-tsgolint`, `vp lint --type-aware` works out of the box.
 
 ## Review Checklist for Agents
 
 - [ ] Run `vp install` after pulling remote changes and before getting started.
-- [ ] Run `vp lint`, `vp fmt`, and `vp test` to validate changes.
+- [ ] Run `vp check` and `vp test` to validate changes.
 <!--VITE PLUS END-->

package/README.md

@@ -1,22 +1,26 @@
 # VITE+(⚡︎) Local CLI
 
 **The Unified Toolchain for the Web**
-_dev, build, test, lint, format, monorepo caching & more in a single dependency, built for scale, speed, and sanity_
+_runtime and package management, create, dev, check, test, build, pack, and monorepo task caching in a single dependency_
 
 This package provides the project-local version of Vite+. The global `vite` command automatically delegates to this package for all project-specific tasks.
 
 ---
 
-Vite+ combines [Vite](https://vite.dev/), [Vitest](https://vitest.dev/), [Oxlint](https://oxc.rs/docs/guide/usage/linter.html), [Oxfmt](https://oxc.rs/docs/guide/usage/formatter.html), [tsdown](https://tsdown.dev/) and [Rolldown](https://rolldown.rs/) as a single zero-config toolchain:
+Vite+ is the unified entry point for local web development. It combines [Vite](https://vite.dev/), [Vitest](https://vitest.dev/), [Oxlint](https://oxc.rs/docs/guide/usage/linter.html), [Oxfmt](https://oxc.rs/docs/guide/usage/formatter.html), [Rolldown](https://rolldown.rs/), [tsdown](https://tsdown.dev/), and [Vite Task](https://github.com/voidzero-dev/vite-task) into one zero-config toolchain that also manages runtime and package manager workflows:
 
-- **Dev Server:** Powered by Vite's fast development experience with native ES modules and instant HMR
-- **Build Tool:** Optimized production builds using Rolldown and Oxc
-- **Testing:** Seamless Vitest integration with fast feedback loops
-- **Linting:** Ships with Oxlint for quick code quality checks
-- **Task Runner:** Monorepo task execution with automated caching and dependency resolution
-- **Package Management:** Vite+ wraps package managers to provide a unified interface
+- **`vp env`:** Manage Node.js globally and per project
+- **`vp install`:** Install dependencies with automatic package manager detection
+- **`vp dev`:** Run Vite's fast native ESM dev server with instant HMR
+- **`vp check`:** Run formatting, linting, and type checks in one command
+- **`vp test`:** Run tests through bundled Vitest
+- **`vp build`:** Build applications for production with Vite + Rolldown
+- **`vp run`:** Execute monorepo tasks with caching and dependency-aware scheduling
+- **`vp pack`:** Build libraries for npm publishing or standalone app binaries
+- **`vp create` / `vp migrate`:** Scaffold new projects and migrate existing ones
 
-Vite+ is built to scale with your codebase while reducing your devtools to a single dependency.
+All of this is configured from your project root and works across Vite's framework ecosystem.
+Vite+ is fully open-source under the MIT license.
 
 ## Getting Started
 
@@ -25,44 +29,115 @@ Install Vite+ globally as `vp`:
 For Linux or macOS:
 
 ```bash
-curl -fsSL https://staging.viteplus.dev/install.sh | bash
+curl -fsSL https://viteplus.dev/install.sh | bash
 ```
 
 For Windows:
 
 ```bash
-irm https://staging.viteplus.dev/install.ps1 | iex
+irm https://viteplus.dev/install.ps1 | iex
 ```
 
 `vp` handles the full development lifecycle such as package management, development servers, linting, formatting, testing and building for production.
 
-### Vite+ Commands
+## Configuring Vite+
+
+Vite+ can be configured using a single `vite.config.ts` at the root of your project:
+
+```ts
+import { defineConfig } from 'vite-plus';
+
+export default defineConfig({
+  // Standard Vite configuration for dev/build/preview.
+  plugins: [],
+
+  // Vitest configuration.
+  test: {
+    include: ['src/**/*.test.ts'],
+  },
+
+  // Oxlint configuration.
+  lint: {
+    ignorePatterns: ['dist/**'],
+  },
+
+  // Oxfmt configuration.
+  fmt: {
+    semi: true,
+    singleQuote: true,
+  },
+
+  // Vite Task configuration.
+  run: {
+    tasks: {
+      'generate:icons': {
+        command: 'node scripts/generate-icons.js',
+        envs: ['ICON_THEME'],
+      },
+    },
+  },
+
+  // `vp staged` configuration.
+  staged: {
+    '*': 'vp check --fix',
+  },
+});
+```
+
+This lets you keep the configuration for your development server, build, test, lint, format, task runner, and staged-file workflow in one place with type-safe config and shared defaults.
+
+Use `vp migrate` to migrate to Vite+. It merges tool-specific config files such as `.oxlintrc*`, `.oxfmtrc*`, and lint-staged config into `vite.config.ts`.
+
+### CLI Workflows (`vp help`)
+
+#### Start
+
+- **create** - Create a new project from a template
+- **migrate** - Migrate an existing project to Vite+
+- **config** - Configure hooks and agent integration
+- **staged** - Run linters on staged files
+- **install** (`i`) - Install dependencies
+- **env** - Manage Node.js versions
+
+#### Develop
 
 - **dev** - Run the development server
-- **build** - Build for production
+- **check** - Run format, lint, and type checks
 - **lint** - Lint code
-- **test** - Run tests
 - **fmt** - Format code
-- **lib** - Build library
-- **migrate** - Migrate an existing project to Vite+
-- **create** - Create a new monorepo package (in-project) or a new project (global)
-- **run** - Run tasks from `package.json` scripts
+- **test** - Run tests
+
+#### Execute
+
+- **run** - Run monorepo tasks
+- **exec** - Execute a command from local `node_modules/.bin`
+- **dlx** - Execute a package binary without installing it as a dependency
+- **cache** - Manage the task cache
+
+#### Build
 
-### Package Manager Commands
+- **build** - Build for production
+- **pack** - Build libraries
+- **preview** - Preview production build
+
+#### Manage Dependencies
 
-Vite+ automatically detects and wraps the underlying package manager such as pnpm, npm, or Yarn through the `packageManager` field in `package.json` or package manager-specific lockfiles.
+Vite+ automatically wraps your package manager (pnpm, npm, or Yarn) based on `packageManager` and lockfiles:
 
-- **install** - Install all dependencies, or add packages if package names are provided
 - **add** - Add packages to dependencies
-- **remove** - Remove packages from dependencies
-- **dlx** - Execute a package binary without installing it as a dependency
-- **info** - View package information from the registry, including latest versions
-- **link** - Link packages for local development
-- **outdated** - Check for outdated packages
+- **remove** (`rm`, `un`, `uninstall`) - Remove packages from dependencies
+- **update** (`up`) - Update packages to latest versions
+- **dedupe** - Deduplicate dependencies
+- **outdated** - Check outdated packages
+- **list** (`ls`) - List installed packages
+- **why** (`explain`) - Show why a package is installed
+- **info** (`view`, `show`) - View package metadata from the registry
+- **link** (`ln`) / **unlink** - Manage local package links
 - **pm** - Forward a command to the package manager
-- **unlink** - Unlink packages
-- **update** - Update packages to their latest versions
-- **why** - Show why a package is installed
+
+#### Maintain
+
+- **upgrade** - Update `vp` itself to the latest version
 
 ### Scaffolding your first Vite+ project
 

package/dist/bin.js

@@ -9,7 +9,9 @@
  * vite-plus installation using oxc_resolver and runs its dist/bin.js directly.
  * If no local installation is found, this global dist/bin.js is used as fallback.
  */
+import path from 'node:path';
 import { run } from '../binding/index.js';
+import { applyToolInitConfigToViteConfig, inspectInitCommand } from './init-config.js';
 import { doc } from './resolve-doc.js';
 import { fmt } from './resolve-fmt.js';
 import { lint } from './resolve-lint.js';
@@ -17,6 +19,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 { accent, log } from './utils/terminal.js';
 // Parse command line arguments
 let args = process.argv.slice(2);
 // Transform `vp help [command]` into `vp [command] --help`
@@ -53,21 +56,51 @@ else if (command === 'staged') {
 }
 else {
     // All other commands — delegate to Rust core via NAPI binding
-    run({
-        lint,
-        pack,
-        fmt,
-        vite,
-        test,
-        doc,
-        resolveUniversalViteConfig,
-        args: process.argv.slice(2),
-    })
-        .then((exitCode) => {
-        process.exit(exitCode);
-    })
-        .catch((err) => {
+    try {
+        const initInspection = inspectInitCommand(command, args.slice(1));
+        if (initInspection.handled &&
+            initInspection.configKey &&
+            initInspection.hasExistingConfigKey &&
+            initInspection.existingViteConfigPath) {
+            log(`Skipped initialization: '${accent(initInspection.configKey)}' already exists in '${accent(path.basename(initInspection.existingViteConfigPath))}'.`);
+            process.exit(0);
+        }
+        const exitCode = await run({
+            lint,
+            pack,
+            fmt,
+            vite,
+            test,
+            doc,
+            resolveUniversalViteConfig,
+            args: process.argv.slice(2),
+        });
+        let finalExitCode = exitCode;
+        if (exitCode === 0) {
+            try {
+                const result = await applyToolInitConfigToViteConfig(command, args.slice(1));
+                if (result.handled &&
+                    result.action === 'added' &&
+                    result.configKey &&
+                    result.viteConfigPath) {
+                    log(`Added '${accent(result.configKey)}' to '${accent(path.basename(result.viteConfigPath))}'.`);
+                }
+                if (result.handled &&
+                    result.action === 'skipped-existing' &&
+                    result.configKey &&
+                    result.viteConfigPath) {
+                    log(`Skipped initialization: '${accent(result.configKey)}' already exists in '${accent(path.basename(result.viteConfigPath))}'.`);
+                }
+            }
+            catch (err) {
+                console.error('[Vite+] Failed to initialize config in vite.config.ts:', err);
+                finalExitCode = 1;
+            }
+        }
+        process.exit(finalExitCode);
+    }
+    catch (err) {
         console.error('[Vite+] run error:', err);
         process.exit(1);
-    });
+    }
 }

package/dist/global/migrate.js

@@ -135,6 +135,17 @@ async function main() {
 		}
 	}
 	const packageManager = workspaceInfoOptional.packageManager ?? await selectPackageManager(options.interactive);
+	let shouldSetupHooks = await promptGitHooks(options);
+	const selectedAgentTargetPaths = await selectAgentTargetPaths({
+		interactive: options.interactive,
+		agent: options.agent,
+		onCancel: () => cancelAndExit()
+	});
+	const selectedEditor = await selectEditor({
+		interactive: options.interactive,
+		editor: options.editor,
+		onCancel: () => cancelAndExit()
+	});
 	const downloadResult = await downloadPackageManager$1(packageManager, workspaceInfoOptional.packageManagerVersion, options.interactive);
 	const workspaceInfo = {
 		...workspaceInfoOptional,
@@ -156,7 +167,6 @@ async function main() {
 	if (!isViteSupported || !isVitestSupported) {
 		cancelAndExit("Vite+ cannot automatically migrate this project yet.", 1);
 	}
-	let shouldSetupHooks = await promptGitHooks(options);
 	if (shouldSetupHooks) {
 		const reason = preflightGitHooksSetup(workspaceInfo.rootDir);
 		if (reason) {
@@ -173,21 +183,11 @@ async function main() {
 	if (shouldSetupHooks) {
 		installGitHooks(workspaceInfo.rootDir);
 	}
-	const selectedAgentTargetPaths = await selectAgentTargetPaths({
-		interactive: options.interactive,
-		agent: options.agent,
-		onCancel: () => cancelAndExit()
-	});
 	await writeAgentInstructions({
 		projectRoot: workspaceInfo.rootDir,
 		targetPaths: selectedAgentTargetPaths,
 		interactive: options.interactive
 	});
-	const selectedEditor = await selectEditor({
-		interactive: options.interactive,
-		editor: options.editor,
-		onCancel: () => cancelAndExit()
-	});
 	await writeEditorConfigs({
 		projectRoot: workspaceInfo.rootDir,
 		editorId: selectedEditor,

package/dist/global/version.js

@@ -1,5 +1,5 @@
 import { o as VITE_PLUS_NAME } from "./json-Bfvtp2rL.js";
-import { t as detectPackageMetadata } from "./package-Pq2biU7_.js";
+import { r as hasVitePlusDependency, t as detectPackageMetadata } from "./package-Pq2biU7_.js";
 import { a as renderCliDoc, n as log, t as accent } from "./terminal-Cb-NuRkb.js";
 import path from "node:path";
 import fs from "node:fs";
@@ -16,8 +16,27 @@ function getCliVersion() {
 	return pkg?.version ?? null;
 }
 function getLocalMetadata(cwd) {
+	if (!isVitePlusDeclaredInAncestors(cwd)) {
+		return null;
+	}
 	return detectPackageMetadata(cwd, VITE_PLUS_NAME) ?? null;
 }
+function isVitePlusDeclaredInAncestors(cwd) {
+	let currentDir = path.resolve(cwd);
+	while (true) {
+		const packageJsonPath = path.join(currentDir, "package.json");
+		const pkg = readPackageJsonFromPath(packageJsonPath);
+		if (pkg && hasVitePlusDependency(pkg)) {
+			return true;
+		}
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) {
+			break;
+		}
+		currentDir = parentDir;
+	}
+	return false;
+}
 function readPackageJsonFromPath(packageJsonPath) {
 	try {
 		return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
@@ -114,17 +133,19 @@ async function printVersion(cwd) {
 			bundledVersionKey: "tsdown"
 		}
 	];
-	const resolvedTools = tools.map((tool) => ({
-		tool,
-		version: localMetadata ? resolveToolVersion(tool, localMetadata.path) : null
-	}));
-	sections.push({
-		title: "Tools",
-		rows: resolvedTools.map(({ tool, version }) => ({
-			label: accent(tool.displayName),
-			description: version ? `v${version}` : "Not found"
-		}))
-	});
+	if (localMetadata) {
+		const resolvedTools = tools.map((tool) => ({
+			tool,
+			version: resolveToolVersion(tool, localMetadata.path)
+		}));
+		sections.push({
+			title: "Tools",
+			rows: resolvedTools.map(({ tool, version }) => ({
+				label: accent(tool.displayName),
+				description: version ? `v${version}` : "Not found"
+			}))
+		});
+	}
 	log(renderCliDoc({ sections }));
 }
 await printVersion(process.cwd());

package/dist/init-config.d.ts

@@ -0,0 +1,20 @@
+export interface InitCommandInspection {
+    handled: boolean;
+    configKey?: 'lint' | 'fmt';
+    existingViteConfigPath?: string;
+    hasExistingConfigKey?: boolean;
+}
+export interface ApplyToolInitResult {
+    handled: boolean;
+    action?: 'added' | 'skipped-existing' | 'no-generated-config';
+    configKey?: 'lint' | 'fmt';
+    viteConfigPath?: string;
+}
+export declare function inspectInitCommand(command: string | undefined, args: string[], projectPath?: string): InitCommandInspection;
+/**
+ * Merge generated tool config from `vp lint/fmt --init` (and fmt --migrate)
+ * into the project's vite config, then remove the generated standalone file.
+ *
+ * Returns true when the command was an init/migrate command (handled), false otherwise.
+ */
+export declare function applyToolInitConfigToViteConfig(command: string | undefined, args: string[], projectPath?: string): Promise<ApplyToolInitResult>;

package/dist/init-config.js

@@ -0,0 +1,210 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { mergeJsonConfig } from '../binding/index.js';
+import { fmt as resolveFmt } from './resolve-fmt.js';
+import { runCommandSilently } from './utils/command.js';
+import { VITE_PLUS_NAME } from './utils/constants.js';
+const INIT_COMMAND_SPECS = {
+    lint: {
+        configKey: 'lint',
+        triggerFlags: ['--init'],
+        defaultConfigFiles: ['.oxlintrc.json'],
+    },
+    fmt: {
+        configKey: 'fmt',
+        triggerFlags: ['--init', '--migrate'],
+        defaultConfigFiles: ['.oxfmtrc.json', '.oxfmtrc.jsonc'],
+    },
+};
+const VITE_CONFIG_FILES = [
+    'vite.config.ts',
+    'vite.config.mts',
+    'vite.config.cts',
+    'vite.config.js',
+    'vite.config.mjs',
+    'vite.config.cjs',
+];
+function optionTerminatorIndex(args) {
+    const index = args.indexOf('--');
+    return index === -1 ? args.length : index;
+}
+function hasTriggerFlag(args, triggerFlags) {
+    const limit = optionTerminatorIndex(args);
+    for (let i = 0; i < limit; i++) {
+        const arg = args[i];
+        if (triggerFlags.some((flag) => arg === flag || arg.startsWith(`${flag}=`))) {
+            return true;
+        }
+    }
+    return false;
+}
+function extractConfigPathArg(args) {
+    const limit = optionTerminatorIndex(args);
+    for (let i = 0; i < limit; i++) {
+        const arg = args[i];
+        if (arg === '-c' || arg === '--config') {
+            const value = args[i + 1];
+            return value ? value : null;
+        }
+        if (arg.startsWith('--config=')) {
+            return arg.slice('--config='.length);
+        }
+        if (arg.startsWith('-c=')) {
+            return arg.slice('-c='.length);
+        }
+    }
+    return null;
+}
+function resolveGeneratedConfigPath(projectPath, args, defaultConfigFiles) {
+    const configArg = extractConfigPathArg(args);
+    if (configArg) {
+        const resolved = path.isAbsolute(configArg) ? configArg : path.join(projectPath, configArg);
+        if (fs.existsSync(resolved)) {
+            return resolved;
+        }
+    }
+    for (const filename of defaultConfigFiles) {
+        const fullPath = path.join(projectPath, filename);
+        if (fs.existsSync(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+function findViteConfigPath(projectPath) {
+    for (const filename of VITE_CONFIG_FILES) {
+        const fullPath = path.join(projectPath, filename);
+        if (fs.existsSync(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+function ensureViteConfigPath(projectPath) {
+    const existing = findViteConfigPath(projectPath);
+    if (existing) {
+        return existing;
+    }
+    const viteConfigPath = path.join(projectPath, 'vite.config.ts');
+    fs.writeFileSync(viteConfigPath, `import { defineConfig } from '${VITE_PLUS_NAME}';
+
+export default defineConfig({});
+`);
+    return viteConfigPath;
+}
+function hasConfigKey(viteConfigPath, configKey) {
+    const viteConfig = fs.readFileSync(viteConfigPath, 'utf8');
+    return new RegExp(`\\b${configKey}\\s*:`).test(viteConfig);
+}
+async function vpFmt(cwd, filePath) {
+    const { binPath, envs } = await resolveFmt();
+    const result = await runCommandSilently({
+        command: binPath,
+        args: ['--write', filePath],
+        cwd,
+        envs: {
+            ...process.env,
+            ...envs,
+        },
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to format ${filePath} with vp fmt:\n${result.stdout.toString()}${result.stderr.toString()}`);
+    }
+}
+function resolveInitSpec(command, args) {
+    if (!command) {
+        return null;
+    }
+    const spec = INIT_COMMAND_SPECS[command];
+    if (!spec || !hasTriggerFlag(args, spec.triggerFlags)) {
+        return null;
+    }
+    return spec;
+}
+export function inspectInitCommand(command, args, projectPath = process.cwd()) {
+    const spec = resolveInitSpec(command, args);
+    if (!spec) {
+        return { handled: false };
+    }
+    const viteConfigPath = findViteConfigPath(projectPath);
+    if (!viteConfigPath) {
+        return {
+            handled: true,
+            configKey: spec.configKey,
+            hasExistingConfigKey: false,
+        };
+    }
+    return {
+        handled: true,
+        configKey: spec.configKey,
+        existingViteConfigPath: viteConfigPath,
+        hasExistingConfigKey: hasConfigKey(viteConfigPath, spec.configKey),
+    };
+}
+/**
+ * Merge generated tool config from `vp lint/fmt --init` (and fmt --migrate)
+ * into the project's vite config, then remove the generated standalone file.
+ *
+ * Returns true when the command was an init/migrate command (handled), false otherwise.
+ */
+export async function applyToolInitConfigToViteConfig(command, args, projectPath = process.cwd()) {
+    const inspection = inspectInitCommand(command, args, projectPath);
+    if (!inspection.handled || !inspection.configKey) {
+        return { handled: false };
+    }
+    const spec = INIT_COMMAND_SPECS[command];
+    const viteConfigPath = ensureViteConfigPath(projectPath);
+    const generatedConfigPath = resolveGeneratedConfigPath(projectPath, args, spec.defaultConfigFiles);
+    if (hasConfigKey(viteConfigPath, spec.configKey)) {
+        if (generatedConfigPath) {
+            fs.rmSync(generatedConfigPath, { force: true });
+        }
+        return {
+            handled: true,
+            action: 'skipped-existing',
+            configKey: spec.configKey,
+            viteConfigPath,
+        };
+    }
+    if (spec.configKey === 'lint' && hasTriggerFlag(args, ['--init'])) {
+        const lintInitConfigPath = path.join(projectPath, '.vite-plus-lint-init.oxlintrc.json');
+        fs.writeFileSync(lintInitConfigPath, '{}');
+        const mergeResult = mergeJsonConfig(viteConfigPath, lintInitConfigPath, spec.configKey);
+        if (!mergeResult.updated) {
+            throw new Error(`Failed to initialize lint config in ${path.basename(viteConfigPath)}`);
+        }
+        fs.writeFileSync(viteConfigPath, mergeResult.content);
+        fs.rmSync(lintInitConfigPath, { force: true });
+        if (generatedConfigPath) {
+            fs.rmSync(generatedConfigPath, { force: true });
+        }
+        await vpFmt(projectPath, path.relative(projectPath, viteConfigPath));
+        return {
+            handled: true,
+            action: 'added',
+            configKey: spec.configKey,
+            viteConfigPath,
+        };
+    }
+    if (!generatedConfigPath) {
+        return {
+            handled: true,
+            action: 'no-generated-config',
+            configKey: inspection.configKey,
+            viteConfigPath,
+        };
+    }
+    const mergeResult = mergeJsonConfig(viteConfigPath, generatedConfigPath, spec.configKey);
+    if (!mergeResult.updated) {
+        throw new Error(`Failed to merge ${path.basename(generatedConfigPath)} into ${path.basename(viteConfigPath)}`);
+    }
+    fs.writeFileSync(viteConfigPath, mergeResult.content);
+    fs.rmSync(generatedConfigPath, { force: true });
+    await vpFmt(projectPath, path.relative(projectPath, viteConfigPath));
+    return {
+        handled: true,
+        action: 'added',
+        configKey: spec.configKey,
+        viteConfigPath,
+    };
+}

package/dist/lint.d.ts

@@ -0,0 +1 @@
+export { type AllowWarnDeny, type DummyRule, type DummyRuleMap, type ExternalPluginEntry, type ExternalPluginsConfig, type OxlintConfig, type OxlintEnv, type OxlintGlobals, type OxlintOverride, type RuleCategories, defineConfig, } from 'oxlint';

package/dist/lint.js

@@ -0,0 +1 @@
+export { defineConfig, } from 'oxlint';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plus",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "MIT",
   "bin": {
     "oxfmt": "./bin/oxfmt",
@@ -55,6 +55,10 @@
       "import": "./binding/index.cjs",
       "require": "./binding/index.cjs"
     },
+    "./lint": {
+      "types": "./dist/lint.d.ts",
+      "import": "./dist/lint.js"
+    },
     "./package.json": "./package.json",
     "./pack": {
       "types": "./dist/pack.d.ts",
@@ -297,8 +301,8 @@
     "oxlint": "^1.51.0",
     "oxlint-tsgolint": "^0.15.0",
     "picocolors": "^1.1.1",
-    "@voidzero-dev/vite-plus-core": "0.1.0",
-    "@voidzero-dev/vite-plus-test": "0.1.0"
+    "@voidzero-dev/vite-plus-core": "0.1.1",
+    "@voidzero-dev/vite-plus-test": "0.1.1"
   },
   "devDependencies": {
     "@napi-rs/cli": "^3.4.1",
@@ -321,7 +325,7 @@
     "yaml": "^2.8.1",
     "@voidzero-dev/vite-plus-prompts": "0.0.0",
     "rolldown": "1.0.0-rc.6",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.1.0"
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.1.1"
   },
   "napi": {
     "binaryName": "vite-plus",
@@ -339,12 +343,12 @@
     "node": "^20.19.0 || >=22.12.0"
   },
   "optionalDependencies": {
-    "@voidzero-dev/vite-plus-darwin-arm64": "0.1.0",
-    "@voidzero-dev/vite-plus-darwin-x64": "0.1.0",
-    "@voidzero-dev/vite-plus-linux-arm64-gnu": "0.1.0",
-    "@voidzero-dev/vite-plus-linux-x64-gnu": "0.1.0",
-    "@voidzero-dev/vite-plus-win32-x64-msvc": "0.1.0",
-    "@voidzero-dev/vite-plus-win32-arm64-msvc": "0.1.0"
+    "@voidzero-dev/vite-plus-darwin-arm64": "0.1.1",
+    "@voidzero-dev/vite-plus-darwin-x64": "0.1.1",
+    "@voidzero-dev/vite-plus-linux-arm64-gnu": "0.1.1",
+    "@voidzero-dev/vite-plus-linux-x64-gnu": "0.1.1",
+    "@voidzero-dev/vite-plus-win32-x64-msvc": "0.1.1",
+    "@voidzero-dev/vite-plus-win32-arm64-msvc": "0.1.1"
   },
   "scripts": {
     "build": "oxnode -C dev ./build.ts",