feat: add vite migration command

Author: fengmk2

crates/vite_migration/Cargo.toml

@@ -11,7 +11,6 @@ ast-grep-config = { workspace = true }
 ast-grep-core = { workspace = true }
 ast-grep-language = { workspace = true }
 serde_json = { workspace = true, features = ["preserve_order"] }
-tokio = { workspace = true, features = ["fs"] }
 vite_error = { workspace = true }
 
 [dev-dependencies]

crates/vite_migration/src/lib.rs

@@ -1,3 +1,3 @@
 mod package;
 
-pub use package::rewrite_package_json_scripts;
+pub use package::rewrite_scripts;

crates/vite_migration/src/package.rs

@@ -1,15 +1,11 @@
-use std::path::Path;
-
 use ast_grep_config::{GlobalRules, RuleConfig, from_yaml_string};
 use ast_grep_core::replacer::Replacer;
 use ast_grep_language::{LanguageExt, SupportLang};
-use serde_json::Value;
-use tokio::fs;
+use serde_json::{Map, Value};
 use vite_error::Error;
 
 /// load script rules from yaml file
-async fn load_ast_grep_rules(yaml_path: &Path) -> Result<Vec<RuleConfig<SupportLang>>, Error> {
-    let yaml = fs::read_to_string(yaml_path).await?;
+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)
@@ -59,46 +55,55 @@ fn rewrite_script(script: &str, rules: &[RuleConfig<SupportLang>]) -> String {
     current
 }
 
-/// rewrite scripts in package.json using rules from rules_yaml_path
-pub async fn rewrite_package_json_scripts(
-    package_json_path: &Path,
-    rules_yaml_path: &Path,
-) -> Result<bool, Error> {
-    let content = fs::read_to_string(package_json_path).await?;
-    let mut json: Value = serde_json::from_str(&content)?;
-    let rules = load_ast_grep_rules(rules_yaml_path).await?;
+/// 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 mut updated = false;
     // get scripts field (object)
-    if let Some(scripts) = json.get_mut("scripts").and_then(Value::as_object_mut) {
-        let keys: Vec<String> = scripts.keys().cloned().collect();
-        for key in keys {
-            if let Some(Value::String(script)) = scripts.get(&key) {
-                let new_script = rewrite_script(script, &rules);
-                if new_script != *script {
+    // let keys: Vec<String> = scripts.keys().cloned().collect();
+    for value in scripts.values_mut() {
+        if value.is_array() {
+            // lint-staged scripts can be an array of strings
+            // https://github.com/lint-staged/lint-staged?tab=readme-ov-file#packagejson-example
+            if let Some(sub_scripts) = value.as_array_mut() {
+                for sub_script in sub_scripts.iter_mut() {
+                    if sub_script.is_string()
+                        && let Some(raw_script) = sub_script.as_str()
+                    {
+                        let new_script = rewrite_script(raw_script, &rules);
+                        if new_script != raw_script {
+                            updated = true;
+                            *sub_script = Value::String(new_script);
+                        }
+                    }
+                }
+            }
+        } else if value.is_string() {
+            if let Some(raw_script) = value.as_str() {
+                let new_script = rewrite_script(raw_script, &rules);
+                if new_script != raw_script {
                     updated = true;
-                    scripts.insert(key.clone(), Value::String(new_script));
+                    *value = Value::String(new_script);
                 }
             }
         }
     }
 
     if updated {
-        // write back to file
-        let new_content = serde_json::to_string_pretty(&json)?;
-        fs::write(package_json_path, new_content).await?;
+        let new_content = serde_json::to_string_pretty(&scripts)?;
+        Ok(Some(new_content))
+    } else {
+        Ok(None)
     }
-
-    Ok(updated)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn test_rewrite_script() {
-        let yaml = r#"
+    const RULES_YAML: &str = r#"
 # vite => vite dev
 ---
 id: replace-vite-alone
@@ -148,10 +153,13 @@ language: bash
 rule:
   pattern: oxlint $$$ARGS
 fix: vite lint $$$ARGS
-"#;
+    "#;
+
+    #[test]
+    fn test_rewrite_script() {
         let globals = GlobalRules::default();
         let rules: Vec<RuleConfig<SupportLang>> =
-            from_yaml_string::<SupportLang>(&yaml, &globals).unwrap();
+            from_yaml_string::<SupportLang>(&RULES_YAML, &globals).unwrap();
         // vite commands
         assert_eq!(rewrite_script("vite", &rules), "vite dev");
         assert_eq!(rewrite_script("vite dev", &rules), "vite dev");
@@ -230,4 +238,63 @@ fix: vite lint $$$ARGS
             "npm run type-check && vite lint --type-aware"
         );
     }
+
+    #[test]
+    fn test_rewrite_package_json_scripts_success() {
+        let package_json_scripts = r#"
+{
+    "dev": "vite"
+}
+        "#;
+        let updated = rewrite_scripts(package_json_scripts, &RULES_YAML)
+            .expect("failed to rewrite package.json scripts");
+        assert!(updated.is_some());
+        assert_eq!(
+            updated.unwrap(),
+            r#"
+{
+  "dev": "vite dev"
+}
+        "#
+            .trim()
+        );
+    }
+
+    #[test]
+    fn test_rewrite_package_json_scripts_lint_staged() {
+        let package_json_scripts = r#"
+        {
+            "*.js": ["oxlint --fix --type-aware", "oxfmt --fix"],
+            "*.ts": "oxfmt --fix"
+        }
+        "#;
+        let updated = rewrite_scripts(package_json_scripts, &RULES_YAML)
+            .expect("failed to rewrite package.json scripts");
+        assert!(updated.is_some());
+        assert_eq!(
+            updated.unwrap(),
+            r#"
+{
+  "*.js": [
+    "vite lint --fix --type-aware",
+    "oxfmt --fix"
+  ],
+  "*.ts": "oxfmt --fix"
+}
+        "#
+            .trim()
+        );
+    }
+
+    #[test]
+    fn test_rewrite_package_json_scripts_no_update() {
+        let package_json_scripts = r#"
+        {
+            "foo": "bar"
+        }
+        "#;
+        let updated = rewrite_scripts(package_json_scripts, &RULES_YAML)
+            .expect("failed to rewrite package.json scripts");
+        assert!(updated.is_none());
+    }
 }

packages/cli/binding/index.d.ts

@@ -143,28 +143,28 @@ export interface PathAccess {
 }
 
 /**
- * Rewrite package.json scripts using rules from rules_yaml_path
+ * Rewrite scripts json content using rules from rules_yaml
  *
  * # Arguments
  *
- * * `package_json_path` - The path to the package.json file
- * * `rules_yaml_path` - The path to the ast-grep rules.yaml file
+ * * `scripts_json` - The scripts section of the package.json file as a JSON string
+ * * `rules_yaml` - The ast-grep rules.yaml as a YAML string
  *
  * # Returns
  *
- * * `updated` - Whether the package.json scripts were updated
+ * * `updated` - The updated scripts section of the package.json file as a JSON string, or `null` if no updates were made
  *
  * # Example
  *
  * ```javascript
- * const updated = await rewritePackageJsonScripts("package.json", "rules.yaml");
+ * const updated = rewriteScripts("scripts section json content here", "ast-grep rules yaml content here");
  * console.log(`Updated: ${updated}`);
  * ```
  */
-export declare function rewritePackageJsonScripts(
-  packageJsonPath: string,
-  rulesYamlPath: string,
-): Promise<boolean>;
+export declare function rewriteScripts(
+  scriptsJson: string,
+  rulesYaml: string,
+): string | null;
 
 /**
  * Main entry point for the CLI, called from JavaScript.

packages/cli/binding/index.js

@@ -783,12 +783,12 @@ if (!nativeBinding) {
 const {
   detectWorkspace,
   downloadPackageManager,
-  rewritePackageJsonScripts,
+  rewriteScripts,
   run,
   runCommand,
 } = nativeBinding;
 export { detectWorkspace };
 export { downloadPackageManager };
-export { rewritePackageJsonScripts };
+export { rewriteScripts };
 export { run };
 export { runCommand };

packages/cli/binding/src/lib.rs

@@ -31,7 +31,7 @@ use vite_task::ResolveCommandResult;
 
 use crate::cli::{Args, CliOptions as ViteTaskCliOptions, Commands};
 pub use crate::{
-    migration::rewrite_package_json_scripts,
+    migration::rewrite_scripts,
     package_manager::{detect_workspace, download_package_manager},
 };
 

packages/cli/binding/src/migration.rs

@@ -1,35 +1,26 @@
-use std::path::PathBuf;
-
 use napi::{anyhow, bindgen_prelude::*};
 use napi_derive::napi;
 
-/// Rewrite package.json scripts using rules from rules_yaml_path
+/// Rewrite scripts json content using rules from rules_yaml
 ///
 /// # Arguments
 ///
-/// * `package_json_path` - The path to the package.json file
-/// * `rules_yaml_path` - The path to the ast-grep rules.yaml file
+/// * `scripts_json` - The scripts section of the package.json file as a JSON string
+/// * `rules_yaml` - The ast-grep rules.yaml as a YAML string
 ///
 /// # Returns
 ///
-/// * `updated` - Whether the package.json scripts were updated
+/// * `updated` - The updated scripts section of the package.json file as a JSON string, or `null` if no updates were made
 ///
 /// # Example
 ///
 /// ```javascript
-/// const updated = await rewritePackageJsonScripts("package.json", "rules.yaml");
+/// const updated = rewriteScripts("scripts section json content here", "ast-grep rules yaml content here");
 /// console.log(`Updated: ${updated}`);
 /// ```
 #[napi]
-pub async fn rewrite_package_json_scripts(
-    package_json_path: String,
-    rules_yaml_path: String,
-) -> Result<bool> {
-    let package_json_path = PathBuf::from(&package_json_path);
-    let rules_yaml_path = PathBuf::from(&rules_yaml_path);
+pub fn rewrite_scripts(scripts_json: String, rules_yaml: String) -> Result<Option<String>> {
     let updated =
-        vite_migration::rewrite_package_json_scripts(&package_json_path, &rules_yaml_path)
-            .await
-            .map_err(anyhow::Error::from)?;
+        vite_migration::rewrite_scripts(&scripts_json, &rules_yaml).map_err(anyhow::Error::from)?;
     Ok(updated)
 }

packages/cli/binding/src/package_manager.rs

@@ -1,6 +1,6 @@
 use napi::{Error, anyhow, bindgen_prelude::*};
 use napi_derive::napi;
-use vite_error::Error::UnsupportedPackageManager;
+use vite_error::Error::{UnrecognizedPackageManager, UnsupportedPackageManager};
 use vite_install::{PackageManagerType, get_package_manager_type_and_version};
 use vite_path::AbsolutePathBuf;
 use vite_workspace::{Error::PackageJsonNotFound, WorkspaceFile, find_workspace_root};
@@ -150,12 +150,14 @@ pub async fn detect_workspace(cwd: String) -> Result<DetectWorkspaceResult> {
             is_monorepo,
             root: Some(workspace_root_path),
         }),
-        Err(UnsupportedPackageManager(_)) => Ok(DetectWorkspaceResult {
-            package_manager_name: None,
-            package_manager_version: None,
-            is_monorepo,
-            root: Some(workspace_root_path),
-        }),
+        Err(UnsupportedPackageManager(_) | UnrecognizedPackageManager) => {
+            Ok(DetectWorkspaceResult {
+                package_manager_name: None,
+                package_manager_version: None,
+                is_monorepo,
+                root: Some(workspace_root_path),
+            })
+        }
         Err(e) => {
             return Err(anyhow::Error::from(e).into());
         }

packages/global/package.json

@@ -36,11 +36,14 @@
     "@types/cross-spawn": "catalog:",
     "@types/validate-npm-package-name": "catalog:",
     "@voidzero-dev/vite-plus-tools": "workspace:",
+    "detect-indent": "catalog:",
+    "detect-newline": "catalog:",
     "glob": "catalog:",
     "minimatch": "catalog:",
     "mri": "catalog:",
     "picocolors": "catalog:",
-    "rolldown": "workspace:*"
+    "rolldown": "workspace:*",
+    "yaml": "catalog:"
   },
   "engines": {
     "node": "^20.19.0 || >=22.12.0"