fix(migrate): report lint rules dropped during oxlint sanitization

`sanitizeMigratedOxlintConfig` removes rules whose namespace no surviving
plugin contributes. That removal is necessary — Oxlint refuses to start on a
rule naming a plugin it cannot resolve ("Plugin 'x' not found") — but it
happened silently, while dropped plugins and jsPlugins already warned.

A local jsPlugin makes this visible. Its real namespace comes from the
plugin's `meta.name`, which cannot be derived from a path specifier such as
`./lint/kumo.js`, so every `kumo/*` rule was filtered out of the migrated
config with no output at all.

Collect the removed rule keys and warn with them, pointing at the object
form (`{ name, specifier }`) that lets a user name the namespace explicitly.

Refs #2231

Author: m0g3r

packages/cli/src/migration/__tests__/migrator.spec.ts

@@ -1187,6 +1187,66 @@ describe('collectInstalledPackageNames', () => {
     sanitizeMigratedOxlintConfig(config, available);
     expect(config.jsPlugins).toEqual([]);
   });
+
+  // #2231: a local jsPlugin's real namespace comes from its `meta.name`,
+  // which can't be derived from the path, so its rules get filtered out.
+  // Dropping them is currently required (Oxlint refuses to start on a rule
+  // whose plugin it can't resolve), but it must not happen silently.
+  it('warns which rules it dropped when a local jsPlugin namespace is unresolvable', () => {
+    writeRootPkg({ devDependencies: { vite: '^7.0.0' } });
+    const available = collectInstalledPackageNames(tmpDir);
+    const report = createMigrationReport();
+    const config: import('oxlint').OxlintConfig = {
+      jsPlugins: ['./lint/kumo.js'],
+      rules: { 'kumo/no-foo': 'error', 'no-debugger': 'error' },
+    };
+
+    sanitizeMigratedOxlintConfig(config, available, report);
+
+    // The unbacked rule still has to go, and the native one stays.
+    expect(config.rules).toEqual({ 'no-debugger': 'error' });
+    // The local plugin itself is preserved — Oxlint resolves it by path.
+    expect(config.jsPlugins).toEqual(['./lint/kumo.js']);
+    // The drop is reported, names the rule, and points at the fix.
+    const warning = report.warnings.find((w) => w.includes('Stripped lint rule(s)'));
+    expect(warning).toBeDefined();
+    expect(warning).toContain('kumo/no-foo');
+    expect(warning).not.toContain('no-debugger');
+    expect(warning).toContain('specifier');
+  });
+
+  it('reports rules dropped from overrides, not just base rules', () => {
+    writeRootPkg({ devDependencies: { vite: '^7.0.0' } });
+    const available = collectInstalledPackageNames(tmpDir);
+    const report = createMigrationReport();
+    const config: import('oxlint').OxlintConfig = {
+      overrides: [{ files: ['**/*.ts'], rules: { 'kumo/no-bar': 'warn' } }],
+    };
+
+    sanitizeMigratedOxlintConfig(config, available, report);
+
+    expect(config.overrides?.[0]?.rules).toEqual({});
+    const warning = report.warnings.find((w) => w.includes('Stripped lint rule(s)'));
+    expect(warning).toBeDefined();
+    expect(warning).toContain('kumo/no-bar');
+  });
+
+  it('does not warn about rules when nothing was dropped', () => {
+    writeRootPkg({ devDependencies: { vite: '^7.0.0' } });
+    const available = collectInstalledPackageNames(tmpDir);
+    const report = createMigrationReport();
+    const config: import('oxlint').OxlintConfig = {
+      rules: { 'no-debugger': 'error', 'typescript/no-explicit-any': 'error' },
+    };
+
+    sanitizeMigratedOxlintConfig(config, available, report);
+
+    expect(config.rules).toEqual({
+      'no-debugger': 'error',
+      'typescript/no-explicit-any': 'error',
+    });
+    expect(report.warnings.some((w) => w.includes('Stripped lint rule(s)'))).toBe(false);
+  });
 });
 
 describe('ensureSvelteRuneGlobals', () => {

packages/cli/src/migration/migrator/eslint.ts

@@ -541,15 +541,23 @@ function ruleKeyMatchesNamespace(key: string, namespaces: Set<string>): boolean
   return false;
 }
 
-/** Filter a rules object to only entries whose namespace is recognized. */
+/**
+ * Filter a rules object to only entries whose namespace is recognized.
+ * Every removed key is recorded in `dropped` so the caller can tell the
+ * user which rules it lost — silently discarding a user's custom rules
+ * is the failure mode reported in #2231.
+ */
 function filterRulesAgainstNamespaces(
   rules: Record<string, unknown>,
   namespaces: Set<string>,
+  dropped?: Set<string>,
 ): Record<string, unknown> {
   const out: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(rules)) {
     if (ruleKeyMatchesNamespace(key, namespaces)) {
       out[key] = value;
+    } else {
+      dropped?.add(key);
     }
   }
   return out;
@@ -634,6 +642,7 @@ export function sanitizeMigratedOxlintConfig(
   // Track everything we strip so we can warn the user.
   const allDroppedJsPlugins = new Set<string>();
   const allDroppedPlugins = new Set<string>();
+  const allDroppedRules = new Set<string>();
 
   // 1. Sanitize base-level jsPlugins.
   const baseSplit = partitionJsPlugins(config.jsPlugins ?? [], availablePackages);
@@ -670,7 +679,7 @@ export function sanitizeMigratedOxlintConfig(
   // `rules: undefined` property that would shift downstream key
   // emission in the merged vite.config.ts.
   if (config.rules) {
-    const filtered = filterRulesAgainstNamespaces(config.rules, baseNamespaces);
+    const filtered = filterRulesAgainstNamespaces(config.rules, baseNamespaces, allDroppedRules);
     if (Object.keys(filtered).length !== Object.keys(config.rules).length) {
       config.rules = filtered as typeof config.rules;
     }
@@ -720,7 +729,11 @@ export function sanitizeMigratedOxlintConfig(
 
       // Override rules.
       if (override.rules) {
-        const filtered = filterRulesAgainstNamespaces(override.rules, overrideNamespaces);
+        const filtered = filterRulesAgainstNamespaces(
+          override.rules,
+          overrideNamespaces,
+          allDroppedRules,
+        );
         if (Object.keys(filtered).length !== Object.keys(override.rules).length) {
           override.rules = filtered as typeof override.rules;
         }
@@ -753,6 +766,19 @@ export function sanitizeMigratedOxlintConfig(
       report,
     );
   }
+  // Rules have to go when nothing backs their namespace: Oxlint refuses to
+  // start at all on a rule whose plugin it can't find ("Plugin 'x' not
+  // found"), so keeping them would break `vp lint` outright rather than
+  // degrade it. But losing a rule the user wrote should never be silent —
+  // dropped plugins already warn, and rules used to disappear quietly.
+  if (allDroppedRules.size > 0) {
+    warnMigration(
+      `Stripped lint rule(s) from the generated lint config: ${[...allDroppedRules].join(', ')}. ` +
+        'No plugin in the migrated config contributes their namespace, and Oxlint fails to start when a rule names a plugin it cannot find. ' +
+        "If a namespace comes from a local JS plugin, name it explicitly in `lint.jsPlugins` as `{ name: '<namespace>', specifier: './path/to/plugin.js' }` and add those rules back.",
+      report,
+    );
+  }
 }
 
 export function warnPackageLevelEslint() {