feat: migration config to vite.config.ts (#320)

This PR adds functionality to migrate standalone configuration files (`.oxlintrc`, `.oxfmtrc`) into the unified vite.config.ts format. The implementation:

- Adds TypeScript language support to ast-grep for parsing config files
- Creates AST-based rules for merging JSON configs into vite.config.ts
- Handles various config formats including object literals, function callbacks, and plain exports
- Properly converts JSON to TypeScript object literals with correct formatting
- Exposes a new `mergeJsonConfig` function in the binding API
- Updates the migration process to automatically merge configs when detected

The implementation handles edge cases like trailing commas, function callbacks, and different export styles to ensure reliable migration.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Adds AST-driven migration that merges .oxlintrc/.oxfmtrc into vite.config, rewrites vite/vitest imports to vite-plus, exposes merge/rewrite APIs in bindings, and updates CLI with version checks and new workflow with tests.
> 
> - **Migration Engine (Rust `vite_migration`)**:
>   - Add TypeScript parsing support via `ast-grep` features.
>   - Implement `merge_json_config` and `rewrite_import` with AST rules to:
>     - Merge `.oxlintrc`/`.oxfmtrc` into `defineConfig` (supports object, function callbacks, plain exports, return vars, satisfies).
>     - Rewrite `import ... from 'vite'` and `'vitest/config'` to `'@voidzero-dev/vite-plus'`.
>   - Include reusable rule files: `rules/oxlint-*.yaml`, `rules/rewrite-import.yaml`.
> - **Bindings (NAPI + JS)**:
>   - Expose `mergeJsonConfig` and `rewriteImport` in `packages/cli/binding` (TS defs and JS exports).
> - **CLI Migration Flow (`packages/global/src/migration`)**:
>   - Detect `vite.config.*`/`vitest.config.*` and rewrite imports.
>   - Auto-create `vite.config.ts` when missing and merge oxlint/oxfmt configs; remove old files.
>   - Enforce minimum versions (`vite>=7`, `vitest>=4`) with clear errors; upgrade Yarn <4.10 when needed.
>   - Apply package manager overrides/resolutions and update scripts; handle monorepos and root workspace files.
> - **Detection & Utilities**:
>   - Add package metadata/version detection; config file detection extended to Vitest.
> - **Tests & Docs**:
>   - Add snapshot tests covering TS/JS, monorepo (pnpm/yarn), auto-create config, and unsupported versions.
>   - Update RFC with import rewrite and merged config examples.
> - **Deps**:
>   - Add `tree-sitter-typescript` via `ast-grep-language` feature; add `tempfile` for tests.
> 
> <sup>Written by [Cursor Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit 3d3af8c. This will update automatically on new commits. Configure [here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: fengmk2

Cargo.lock

@@ -39,7 +39,7 @@ anyhow = "1.0.98"
 # Safe to migrate back to the official ast-grep release once PR #2359 is merged and a new version is published.
 ast-grep-config = { git = "https://github.com/fengmk2/ast-grep.git", rev = "2f4c6924438a72e136485f0e14cd136b2e17d8d3" }
 ast-grep-core = { git = "https://github.com/fengmk2/ast-grep.git", rev = "2f4c6924438a72e136485f0e14cd136b2e17d8d3" }
-ast-grep-language = { git = "https://github.com/fengmk2/ast-grep.git", rev = "2f4c6924438a72e136485f0e14cd136b2e17d8d3", default-features = false, features = ["lang-bash"] }
+ast-grep-language = { git = "https://github.com/fengmk2/ast-grep.git", rev = "2f4c6924438a72e136485f0e14cd136b2e17d8d3", default-features = false, features = ["lang-bash", "lang-typescript"] }
 backon = "1.3.0"
 bincode = "2.0.1"
 bstr = { version = "1.12.0", default-features = false, features = ["alloc", "std"] }

Cargo.toml

@@ -13,5 +13,8 @@ ast-grep-language = { workspace = true }
 serde_json = { workspace = true, features = ["preserve_order"] }
 vite_error = { workspace = true }
 
+[dev-dependencies]
+tempfile = { workspace = true }
+
 [lints]
 workspace = true

crates/vite_migration/Cargo.toml

@@ -0,0 +1,82 @@
+use ast_grep_config::{GlobalRules, RuleConfig, from_yaml_string};
+use ast_grep_core::replacer::Replacer;
+use ast_grep_language::{LanguageExt, SupportLang};
+use vite_error::Error;
+
+/// Apply ast-grep rules to content and return the transformed content
+///
+/// This is the core transformation function that:
+/// 1. Parses the rule YAML
+/// 2. Applies each rule to find matches
+/// 3. Replaces matches from back to front to maintain correct positions
+///
+/// # Arguments
+///
+/// * `content` - The source content to transform
+/// * `rule_yaml` - The ast-grep rules in YAML format
+///
+/// # Returns
+///
+/// A tuple of (transformed_content, was_updated)
+pub(crate) fn apply_rules(content: &str, rule_yaml: &str) -> Result<(String, bool), Error> {
+    let rules = load_rules(rule_yaml)?;
+    let result = apply_loaded_rules(content, &rules);
+    let updated = result != content;
+    Ok((result, updated))
+}
+
+/// Load ast-grep rules from YAML string
+pub(crate) fn load_rules(yaml: &str) -> Result<Vec<RuleConfig<SupportLang>>, Error> {
+    let globals = GlobalRules::default();
+    let rules: Vec<RuleConfig<SupportLang>> = from_yaml_string::<SupportLang>(yaml, &globals)?;
+    Ok(rules)
+}
+
+/// Apply pre-loaded ast-grep rules to content
+///
+/// This is useful when you need to apply the same rules multiple times
+/// (e.g., processing multiple scripts in a loop).
+///
+/// # Arguments
+///
+/// * `content` - The source content to transform
+/// * `rules` - Pre-loaded ast-grep rules
+///
+/// # Returns
+///
+/// The transformed content (always returns a new string, even if unchanged)
+pub(crate) fn apply_loaded_rules(content: &str, rules: &[RuleConfig<SupportLang>]) -> String {
+    let mut current = content.to_string();
+
+    for rule in rules {
+        // Parse current content with the rule's language
+        let grep = rule.language.ast_grep(&current);
+        let root = grep.root();
+
+        let matcher = &rule.matcher;
+
+        // Get the fixer if available (rules without fix are pure lint, skip them)
+        let fixers = match rule.get_fixer() {
+            Ok(f) if !f.is_empty() => f,
+            _ => continue,
+        };
+
+        // Collect all matches and their replacements
+        let mut replacements = Vec::new();
+        for node in root.find_all(matcher) {
+            let range = node.range();
+            let replacement_bytes = fixers[0].generate_replacement(&node);
+            let replacement_str = String::from_utf8_lossy(&replacement_bytes).to_string();
+            replacements.push((range.start, range.end, replacement_str));
+        }
+
+        // Replace from back to front to maintain correct positions
+        replacements.sort_by_key(|(start, _, _)| std::cmp::Reverse(*start));
+
+        for (start, end, replacement) in replacements {
+            current.replace_range(start..end, &replacement);
+        }
+    }
+
+    current
+}

crates/vite_migration/src/ast_grep.rs

@@ -1,3 +1,6 @@
+mod ast_grep;
 mod package;
+mod vite_config;
 
 pub use package::rewrite_scripts;
+pub use vite_config::{MergeResult, RewriteResult, merge_json_config, rewrite_import};

crates/vite_migration/src/lib.rs

@@ -1,15 +1,9 @@
-use ast_grep_config::{GlobalRules, RuleConfig, from_yaml_string};
-use ast_grep_core::replacer::Replacer;
-use ast_grep_language::{LanguageExt, SupportLang};
+use ast_grep_config::RuleConfig;
+use ast_grep_language::SupportLang;
 use serde_json::{Map, Value};
 use vite_error::Error;
 
-/// load script rules from yaml file
-fn load_ast_grep_rules(yaml: &str) -> Result<Vec<RuleConfig<SupportLang>>, Error> {
-    let globals = GlobalRules::default();
-    let rules: Vec<RuleConfig<SupportLang>> = from_yaml_string::<SupportLang>(&yaml, &globals)?;
-    Ok(rules)
-}
+use crate::ast_grep;
 
 // Marker to replace "cross-env " before ast-grep processing
 // Using a fake env var assignment that won't match our rules
@@ -22,57 +16,23 @@ fn rewrite_script(script: &str, rules: &[RuleConfig<SupportLang>]) -> String {
     let has_cross_env = script.contains(CROSS_ENV_REPLACEMENT);
 
     // Step 1: Replace "cross-env " with marker so ast-grep can see the actual commands
-    let mut current = if has_cross_env {
+    let preprocessed = if has_cross_env {
         script.replace(CROSS_ENV_REPLACEMENT, CROSS_ENV_MARKER)
     } else {
         script.to_string()
     };
 
     // Step 2: Process with ast-grep
-    for rule in rules {
-        // only handle bash rules
-        if rule.language != SupportLang::Bash {
-            continue;
-        }
-
-        // parse current script with corresponding language
-        let grep = rule.language.ast_grep(&current);
-        let root = grep.root();
-
-        // this matcher is the AST matcher generated by deserializing the YAML rule
-        let matcher = &rule.matcher;
-
-        // rules may not have fix (pure lint), skip here
-        let fixers = match rule.get_fixer() {
-            Ok(f) if !f.is_empty() => f,
-            _ => continue,
-        };
-
-        // collect all matches and their replacements
-        let mut replacements = Vec::new();
-        for node in root.find_all(matcher) {
-            let range = node.range();
-            let replacement_bytes = fixers[0].generate_replacement(&node);
-            let replacement_str = String::from_utf8_lossy(&replacement_bytes).to_string();
-            replacements.push((range.start, range.end, replacement_str));
-        }
-
-        // Replace from back to front
-        replacements.sort_by_key(|(start, _, _)| std::cmp::Reverse(*start));
-
-        for (start, end, replacement) in replacements {
-            current.replace_range(start..end, &replacement);
-        }
-    }
+    let result = ast_grep::apply_loaded_rules(&preprocessed, rules);
 
     // Step 3: Replace marker back with "cross-env " (only if we replaced it)
-    if has_cross_env { current.replace(CROSS_ENV_MARKER, CROSS_ENV_REPLACEMENT) } else { current }
+    if has_cross_env { result.replace(CROSS_ENV_MARKER, CROSS_ENV_REPLACEMENT) } else { result }
 }
 
 /// rewrite scripts json content using rules from rules_yaml
 pub fn rewrite_scripts(scripts_json: &str, rules_yaml: &str) -> Result<Option<String>, Error> {
     let mut scripts: Map<String, Value> = serde_json::from_str(scripts_json)?;
-    let rules = load_ast_grep_rules(rules_yaml)?;
+    let rules = ast_grep::load_rules(rules_yaml)?;
 
     let mut updated = false;
     // get scripts field (object)
@@ -156,9 +116,7 @@ fix: vite test
 
     #[test]
     fn test_rewrite_script() {
-        let globals = GlobalRules::default();
-        let rules: Vec<RuleConfig<SupportLang>> =
-            from_yaml_string::<SupportLang>(&RULES_YAML, &globals).unwrap();
+        let rules = ast_grep::load_rules(RULES_YAML).unwrap();
         // vite commands
         assert_eq!(rewrite_script("vite", &rules), "vite dev");
         assert_eq!(rewrite_script("vite dev", &rules), "vite dev");