feat: add migration command for global cli (#313)

### TL;DR

Refactored the package script migration system to be more flexible and support additional use cases like lint-staged configurations.

### What changed?

- Renamed `rewritePackageJsonScripts` to `rewriteScripts` with a more flexible API
  - Now accepts script content as a string instead of requiring file paths
  - Returns the updated content instead of writing to files directly
  - Returns `null` when no changes are needed
- Added support for migrating lint-staged configurations in package.json and .lintstagedrc.json
- Removed tokio dependency from vite_migration crate
- Added comprehensive test coverage for the new functionality
- Created a new migration command infrastructure in the global package
- Added snap tests to verify lint-staged migration works correctly

### How to test?

1. Test with a project that has lint-staged configuration:
   ```bash
   # Create a project with lint-staged config
   mkdir test-project && cd test-project
   echo '{"lint-staged":{"*.js":["oxlint --fix"]}}' > package.json
   
   # Run migration
   vite migration
   ```

2. Test with a standalone .lintstagedrc.json file:
   ```bash
   # Create a .lintstagedrc.json file
   echo '{"*.js":"oxlint --fix"}' > .lintstagedrc.json
   
   # Run migration
   vite migration
   ```

3. Verify that:
   - The lint-staged configurations are properly updated
   - Both array and string formats are handled correctly
   - The migration preserves the original structure

### Why make this change?

The previous implementation was limited to only migrating scripts in package.json and required file system access. This refactoring makes the script migration system more flexible and reusable across different contexts.

By supporting lint-staged configurations, we ensure that pre-commit hooks are properly migrated to use the unified vite-plus commands. This is particularly important for maintaining code quality workflows during migration.

The new design also follows better separation of concerns - the core migration logic doesn't need to know about file paths or perform I/O operations, making it easier to test and more composable.

Author: fengmk2

Cargo.lock

@@ -11,11 +11,7 @@ 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]
-tokio = { workspace = true, features = ["macros", "rt"] }
-
 [lints]
 workspace = true

crates/vite_migration/Cargo.toml

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

crates/vite_migration/src/lib.rs

@@ -1,25 +1,34 @@
-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)
 }
 
+// Marker to replace "cross-env " before ast-grep processing
+// Using a fake env var assignment that won't match our rules
+const CROSS_ENV_MARKER: &str = "__CROSS_ENV__=1 ";
+const CROSS_ENV_REPLACEMENT: &str = "cross-env ";
+
 /// rewrite a single script command string using rules
 fn rewrite_script(script: &str, rules: &[RuleConfig<SupportLang>]) -> String {
-    // current stores the current script text, and update it when the rule matches
-    let mut current = script.to_string();
+    // Only handle cross-env replacement if it's present in the script
+    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 {
+        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 {
@@ -56,102 +65,100 @@ fn rewrite_script(script: &str, rules: &[RuleConfig<SupportLang>]) -> String {
         }
     }
 
-    current
+    // 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 }
 }
 
-/// 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 {
+
+    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#"
-# vite => vite dev
+    const RULES_YAML: &str = r#"
+# vite => vite dev (handles all cases: with/without env var prefix and flag args)
+# Match command_name to preserve env var prefix and arguments
+# Excludes subcommands like "vite build", "vite test", etc.
 ---
-id: replace-vite-alone
+id: replace-vite
 language: bash
 rule:
-  kind: command
-  has:
-    kind: command_name
-    regex: '^vite$'
-  not:
-    has:
-      kind: word
-      field: argument
+  kind: command_name
+  regex: '^vite$'
+  inside:
+    kind: command
+    not:
+      # ignore non-flag arguments (subcommands like build, test, etc.)
+      regex: 'vite\s+[^-]'
 fix: vite dev
 
-# vite [OPTIONS] => vite dev [OPTIONS]
+# oxlint => vite lint (handles all cases: with/without env var prefix and args)
+# Match command_name to preserve env var prefix and arguments
 ---
-id: replace-vite-with-args
+id: replace-oxlint
 language: bash
-severity: info
 rule:
-  pattern: vite $$$ARGS
-  not:
-    # ignore non-flag arguments
-    regex: 'vite\s+[^-]'
-fix: vite dev $$$ARGS
-
-# oxlint => vite lint
----
-id: replace-oxlint-alone
-language: bash
-rule:
-  kind: command
-  has:
-    kind: command_name
-    regex: '^oxlint$'
-  not:
-    has:
-      kind: word
-      field: argument
+  kind: command_name
+  regex: '^oxlint$'
 fix: vite lint
 
-# oxlint [OPTIONS] => vite lint [OPTIONS]
+# vitest => vite test
 ---
-id: replace-oxlint-with-args
+id: replace-vitest
 language: bash
 rule:
-  pattern: oxlint $$$ARGS
-fix: vite lint $$$ARGS
-"#;
+  kind: command_name
+  regex: '^vitest$'
+fix: vite test
+    "#;
+
+    #[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");
@@ -217,6 +224,21 @@ fix: vite lint $$$ARGS
             ),
             "if [ -f file.txt ]; then vite dev --port 3000 && npm run lint; fi"
         );
+        // env variable commands
+        assert_eq!(
+            rewrite_script("NODE_ENV=test VITE_CJS_IGNORE_WARNING=true vite", &rules),
+            "NODE_ENV=test VITE_CJS_IGNORE_WARNING=true vite dev"
+        );
+        assert_eq!(
+            rewrite_script("FOO=bar vite --port 3000", &rules),
+            "FOO=bar vite dev --port 3000"
+        );
+        // env variable with oxlint commands
+        assert_eq!(rewrite_script("DEBUG=1 oxlint", &rules), "DEBUG=1 vite lint");
+        assert_eq!(
+            rewrite_script("NODE_ENV=test oxlint --type-aware", &rules),
+            "NODE_ENV=test vite lint --type-aware"
+        );
         // oxlint commands
         assert_eq!(rewrite_script("oxlint", &rules), "vite lint");
         assert_eq!(rewrite_script("oxlint --type-aware", &rules), "vite lint --type-aware");
@@ -230,4 +252,111 @@ 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_with_env_variable_success() {
+        let package_json_scripts = r#"
+{
+  "dev:cjs": "VITE_CJS_IGNORE_WARNING=true vite",
+  "lint": "VITE_CJS_IGNORE_WARNING=true FOO=bar oxlint --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#"
+{
+  "dev:cjs": "VITE_CJS_IGNORE_WARNING=true vite dev",
+  "lint": "VITE_CJS_IGNORE_WARNING=true FOO=bar vite lint --fix"
+}
+        "#
+            .trim()
+        );
+    }
+
+    #[test]
+    fn test_rewrite_package_json_scripts_using_cross_env() {
+        let package_json_scripts = r#"
+{
+  "dev:cjs": "cross-env VITE_CJS_IGNORE_WARNING=true vite && cross-env FOO=bar vitest run",
+  "lint": "cross-env VITE_CJS_IGNORE_WARNING=true FOO=bar oxlint --fix",
+  "test": "vite build && cross-env FOO=bar vitest run && echo ' cross-env test done ' || echo ' cross-env test failed '"
+}
+        "#;
+        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:cjs": "cross-env VITE_CJS_IGNORE_WARNING=true vite dev && cross-env FOO=bar vite test run",
+  "lint": "cross-env VITE_CJS_IGNORE_WARNING=true FOO=bar vite lint --fix",
+  "test": "vite build && cross-env FOO=bar vite test run && echo ' cross-env test done ' || echo ' cross-env test failed '"
+}
+        "#
+            .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());
+    }
 }

crates/vite_migration/src/package.rs

@@ -138,28 +138,25 @@ 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.