legacy-modernizer 0.1.0

package/dist/index.mjs

@@ -0,0 +1,497 @@
+// src/utils/format.ts
+var SEVERITY_BADGE = {
+  critical: "\u{1F534}",
+  warning: "\u{1F7E1}",
+  info: "\u{1F535}"
+};
+var DIMENSION_LABELS = {
+  "vue2-to-vue3": { en: "Vue 2 \u2192 3", zh: "Vue 2 \u2192 3" },
+  "js-to-ts": { en: "JS \u2192 TS", zh: "JS \u2192 TS" },
+  "webpack-to-vite": { en: "Webpack \u2192 Vite", zh: "Webpack \u2192 Vite" },
+  "jest-to-vitest": { en: "Jest \u2192 Vitest", zh: "Jest \u2192 Vitest" },
+  "vuex-to-pinia": { en: "Vuex \u2192 Pinia", zh: "Vuex \u2192 Pinia" },
+  "eslint-modernize": { en: "ESLint Modernize", zh: "ESLint \u73B0\u4EE3\u5316" }
+};
+function patternToMarkdown(p) {
+  const badge = SEVERITY_BADGE[p.severity] ?? "\u2753";
+  const dim = DIMENSION_LABELS[p.dimension]?.zh ?? p.dimension;
+  const loc = p.line > 0 ? `:${p.line}` : "";
+  const line = `- ${badge} **${p.name}** [${dim}] \`${p.file}${loc}\``;
+  return p.suggestion ? `${line}
+  \u2192 ${p.suggestion}` : line;
+}
+function severityBadge(severity) {
+  return SEVERITY_BADGE[severity] ?? "\u2753";
+}
+function dimensionLabel(dimension, locale = "zh") {
+  return DIMENSION_LABELS[dimension]?.[locale] ?? dimension;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const secs = seconds % 60;
+  return secs > 0 ? `${minutes}m ${secs}s` : `${minutes}m`;
+}
+
+// src/reporters/locale.ts
+var LABELS = {
+  en: {
+    title: "# \u{1F50D} Legacy Modernizer Analysis Report",
+    overview: "## Overview",
+    projectRoot: "Project Root",
+    scannedAt: "Scanned At",
+    totalFiles: "Files Scanned",
+    totalPatterns: "Patterns Found",
+    duration: "Duration",
+    dimensions: "## Dimensions",
+    dimension: "Dimension",
+    count: "Count",
+    affectedFiles: "Files",
+    critical: "Critical",
+    warning: "Warning",
+    info: "Info",
+    topPatterns: "## Top Legacy Patterns",
+    riskAssessment: "## Risk Assessment",
+    riskLevel: "Risk Level",
+    reason: "Reason",
+    recommendedOrder: "Recommended Order",
+    estimatedEffort: "Estimated Effort",
+    personDays: "person-days",
+    suggestions: "## \u{1F4A1} Suggestions",
+    suggestion1: "Prioritize critical-severity legacy patterns",
+    suggestion2: "Follow the recommended migration order",
+    suggestion3: "Run tests after completing each dimension",
+    suggestion4: "Use `/modernize` to launch the interactive migration wizard"
+  },
+  zh: {
+    title: "# \u{1F50D} Legacy Modernizer \u5206\u6790\u62A5\u544A",
+    overview: "## \u9879\u76EE\u6982\u89C8",
+    projectRoot: "\u9879\u76EE\u8DEF\u5F84",
+    scannedAt: "\u626B\u63CF\u65F6\u95F4",
+    totalFiles: "\u626B\u63CF\u6587\u4EF6",
+    totalPatterns: "\u53D1\u73B0\u6A21\u5F0F",
+    duration: "\u626B\u63CF\u8017\u65F6",
+    dimensions: "## \u7EF4\u5EA6\u7EDF\u8BA1",
+    dimension: "\u7EF4\u5EA6",
+    count: "\u53D1\u73B0\u6570",
+    affectedFiles: "\u53D7\u5F71\u54CD\u6587\u4EF6",
+    critical: "\u4E25\u91CD",
+    warning: "\u8B66\u544A",
+    info: "\u5EFA\u8BAE",
+    topPatterns: "## Top \u9057\u7559\u6A21\u5F0F",
+    riskAssessment: "## \u98CE\u9669\u8BC4\u4F30",
+    riskLevel: "\u6574\u4F53\u98CE\u9669",
+    reason: "\u539F\u56E0",
+    recommendedOrder: "\u63A8\u8350\u8FC1\u79FB\u987A\u5E8F",
+    estimatedEffort: "\u9884\u4F30\u5DE5\u65F6",
+    personDays: "\u4EBA\u5929",
+    suggestions: "## \u{1F4A1} \u5EFA\u8BAE",
+    suggestion1: "\u4F18\u5148\u5904\u7406\u4E25\u91CD\u7EA7\u522B\u7684\u9057\u7559\u6A21\u5F0F",
+    suggestion2: "\u6309\u63A8\u8350\u8FC1\u79FB\u987A\u5E8F\u9010\u6B65\u63A8\u8FDB",
+    suggestion3: "\u6BCF\u4E2A\u7EF4\u5EA6\u5B8C\u6210\u540E\u8FD0\u884C\u6D4B\u8BD5\u9A8C\u8BC1",
+    suggestion4: "\u4F7F\u7528 `/modernize` \u547D\u4EE4\u542F\u52A8\u4EA4\u4E92\u5F0F\u8FC1\u79FB\u5411\u5BFC"
+  }
+};
+
+// src/reporters/analysis.ts
+function renderAnalysisReport(report, locale = "zh") {
+  const t = LABELS[locale];
+  const lines = [];
+  lines.push(t.title);
+  lines.push("");
+  lines.push(t.overview);
+  lines.push("");
+  lines.push(`- **${t.projectRoot}**: \`${report.projectRoot}\``);
+  lines.push(`- **${t.scannedAt}**: ${report.scannedAt}`);
+  lines.push(`- **${t.totalFiles}**: ${report.totalFiles}`);
+  lines.push(`- **${t.totalPatterns}**: ${report.totalPatterns}`);
+  lines.push(`- **${t.duration}**: ${formatDuration(report.duration)}`);
+  lines.push("");
+  lines.push(t.dimensions);
+  lines.push("");
+  lines.push(
+    `| ${t.dimension} | ${t.count} | ${t.affectedFiles} | \u{1F534}${t.critical} | \u{1F7E1}${t.warning} | \u{1F535}${t.info} |`
+  );
+  lines.push("|------|--------|-----------|--------|--------|--------|");
+  for (const d of report.dimensions) {
+    lines.push(
+      `| ${dimensionLabel(d.dimension, locale)} | ${d.count} | ${d.files} | ${d.bySeverity.critical} | ${d.bySeverity.warning} | ${d.bySeverity.info} |`
+    );
+  }
+  lines.push("");
+  lines.push(t.topPatterns);
+  lines.push("");
+  const sorted = [...report.patterns].sort((a, b) => {
+    const sev = { critical: 0, warning: 1, info: 2 };
+    return (sev[a.severity] ?? 9) - (sev[b.severity] ?? 9);
+  }).slice(0, 20);
+  for (const p of sorted) {
+    const badge = severityBadge(p.severity);
+    const dim = dimensionLabel(p.dimension, locale);
+    const loc = p.line > 0 ? `:${p.line}` : "";
+    lines.push(`${badge} **${p.name}** [${dim}] \`${p.file}${loc}\``);
+    if (p.suggestion) lines.push(`  \u2192 ${p.suggestion}`);
+  }
+  lines.push("");
+  lines.push(t.riskAssessment);
+  lines.push("");
+  lines.push(`- **${t.riskLevel}**: **${report.risk.level.toUpperCase()}**`);
+  lines.push(`- **${t.reason}**: ${report.risk.reason}`);
+  lines.push(
+    `- **${t.recommendedOrder}**: ${report.risk.recommendedOrder.map((d) => dimensionLabel(d, locale)).join(" \u2192 ")}`
+  );
+  lines.push(`- **${t.estimatedEffort}**: ${report.risk.estimatedEffort} ${t.personDays}`);
+  lines.push("");
+  lines.push(t.suggestions);
+  lines.push("");
+  lines.push(`1. ${t.suggestion1}`);
+  lines.push(`2. ${t.suggestion2}`);
+  lines.push(`3. ${t.suggestion3}`);
+  lines.push(`4. ${t.suggestion4}`);
+  return lines.join("\n");
+}
+
+// src/scanners/legacy-scanner.ts
+import { glob, readFile } from "fs/promises";
+import { join, relative, sep } from "path";
+
+// src/types.ts
+function createPatternLine(n) {
+  return n >= 0 ? n : 0;
+}
+var VERSION = "0.1.0";
+
+// src/scanners/rules/eslint-modernize.ts
+var eslintModernizeRules = [
+  {
+    id: "eslint-legacy-config",
+    name: "Legacy ESLint config format",
+    dimension: "eslint-modernize",
+    severity: "info",
+    regex: /module\.exports\s*=\s*\{[\s\S]*?(extends|parser|plugins|rules)\s*:/,
+    suggestion: "\u8FC1\u79FB\u4E3A ESLint 9 flat config (eslint.config.mjs)\uFF0C\u4F7F\u7528 export default \u66FF\u4EE3 module.exports"
+  },
+  {
+    id: "eslint-override-array",
+    name: "ESLint overrides array (flat config uses different pattern)",
+    dimension: "eslint-modernize",
+    severity: "info",
+    regex: /\boverrides\s*:\s*\[/,
+    suggestion: "ESLint flat config \u4E0D\u518D\u4F7F\u7528 overrides\uFF0C\u6539\u4E3A\u591A\u4E2A\u914D\u7F6E\u5BF9\u8C61\u7EC4\u5408"
+  }
+];
+
+// src/scanners/rules/jest-to-vitest.ts
+var jestToVitestRules = [
+  { id: "jest-config", name: "Jest config detected", dimension: "jest-to-vitest", severity: "info", regex: /jest\.config|from\s*['"]@jest|require\s*\(\s*['"]@jest/, suggestion: "\u8FC1\u79FB\u4E3A vitest.config.ts" },
+  { id: "jest-global", name: "Jest global functions", dimension: "jest-to-vitest", severity: "warning", regex: /\b(describe|it|test|expect|beforeEach|afterEach|jest)\s*\(/, suggestion: "\u6539\u4E3A vitest \u5BFC\u5165 (vi, describe, it, expect)" }
+];
+
+// src/scanners/rules/js-to-ts.ts
+var jsToTsRules = [
+  { id: "js-prop-types", name: "PropTypes validation", dimension: "js-to-ts", severity: "warning", regex: /PropTypes\./, suggestion: "\u4F7F\u7528 TypeScript interface \u66FF\u4EE3 PropTypes" },
+  { id: "js-jsdoc-types", name: "JSDoc type annotations", dimension: "js-to-ts", severity: "info", regex: /@type\s*\{/, suggestion: "\u5C06 JSDoc \u7C7B\u578B\u8FC1\u79FB\u4E3A\u5185\u8054 TypeScript \u7C7B\u578B" },
+  { id: "js-commonjs-export", name: "CommonJS exports", dimension: "js-to-ts", severity: "info", regex: /module\.exports\s*=|exports\.\w+\s*=/, suggestion: "\u4F7F\u7528 ES module export \u66FF\u4EE3 CommonJS" },
+  { id: "js-require-import", name: "require() import", dimension: "js-to-ts", severity: "info", regex: /\brequire\s*\(\s*['"][^'"]+['"]\s*\)/, suggestion: "\u4F7F\u7528 ES import \u66FF\u4EE3 require()" }
+];
+
+// src/scanners/rules/vue2-to-vue3.ts
+var vue2ToVue3Rules = [
+  { id: "vue2-options-api", name: "Options API component", dimension: "vue2-to-vue3", severity: "info", regex: /export\s+default\s*\{[\s\S]*?data\s*\(\)/, suggestion: "\u4F7F\u7528 <script setup> + Composition API \u91CD\u5199" },
+  { id: "vue2-data-function", name: "data() option", dimension: "vue2-to-vue3", severity: "info", regex: /\bdata\s*\(\)\s*\{/, suggestion: "\u4F7F\u7528 ref() / reactive() \u66FF\u4EE3" },
+  { id: "vue2-computed-option", name: "computed:{} option", dimension: "vue2-to-vue3", severity: "info", regex: /\bcomputed\s*:\s*\{/, suggestion: "\u4F7F\u7528 computed(() => ...) \u66FF\u4EE3" },
+  { id: "vue2-methods-option", name: "methods:{} option", dimension: "vue2-to-vue3", severity: "info", regex: /\bmethods\s*:\s*\{/, suggestion: "\u6539\u5199\u4E3A\u666E\u901A\u51FD\u6570" },
+  { id: "vue2-watch-option", name: "watch:{} option", dimension: "vue2-to-vue3", severity: "info", regex: /\bwatch\s*:\s*\{/, suggestion: "\u4F7F\u7528 watch() / watchEffect() \u66FF\u4EE3" },
+  { id: "vue2-this-refs", name: "this.$refs", dimension: "vue2-to-vue3", severity: "warning", regex: /this\.\$refs\./, suggestion: "\u4F7F\u7528 useTemplateRef() \u66FF\u4EE3" },
+  { id: "vue2-this-emit", name: "this.$emit", dimension: "vue2-to-vue3", severity: "warning", regex: /this\.\$emit/, suggestion: "\u4F7F\u7528 defineEmits() \u66FF\u4EE3" },
+  { id: "vue2-this-router", name: "this.$router / this.$route", dimension: "vue2-to-vue3", severity: "warning", regex: /this\.\$(router|route)\b/, suggestion: "\u4F7F\u7528 useRouter() / useRoute() \u66FF\u4EE3" },
+  { id: "vue2-this-store", name: "this.$store", dimension: "vue2-to-vue3", severity: "warning", regex: /this\.\$store/, suggestion: "\u4F7F\u7528 useStore() \u6216\u8FC1\u79FB\u5230 Pinia" },
+  { id: "vue2-filters", name: "filters:{} option", dimension: "vue2-to-vue3", severity: "critical", regex: /\bfilters\s*:\s*\{/, suggestion: "Vue 3 \u5DF2\u79FB\u9664 filters\uFF0C\u6539\u4E3A computed \u6216\u65B9\u6CD5" },
+  { id: "vue2-event-bus", name: "$on / $off / $once", dimension: "vue2-to-vue3", severity: "critical", regex: /\.\$(on|off|once)\s*\(/, suggestion: "Vue 3 \u5DF2\u79FB\u9664\u4E8B\u4EF6\u603B\u7EBF\uFF0C\u4F7F\u7528 mitt \u6216 tiny-emitter" },
+  { id: "vue2-destroyed", name: "destroyed / beforeDestroy", dimension: "vue2-to-vue3", severity: "warning", regex: /\b(destroyed|beforeDestroy)\s*[:(]/, suggestion: "\u6539\u4E3A unmounted / beforeUnmount" },
+  { id: "vue2-mixins", name: "mixins:[] option", dimension: "vue2-to-vue3", severity: "warning", regex: /\bmixins\s*:\s*\[/, suggestion: "\u4F7F\u7528 Composables \u66FF\u4EE3 mixins" },
+  { id: "vue2-v-bind-sync", name: "v-bind.sync modifier", dimension: "vue2-to-vue3", severity: "critical", regex: /v-bind\.\w+\.sync/, suggestion: "\u6539\u4E3A v-model:xxx (Vue 3 \u79FB\u9664\u4E86 .sync)" },
+  { id: "vue2-v-on-native", name: "v-on.native modifier", dimension: "vue2-to-vue3", severity: "warning", regex: /v-on\.native|@\.native/, suggestion: "Vue 3 \u79FB\u9664\u4E86 .native\uFF0C\u5728 emits \u4E2D\u58F0\u660E\u5373\u53EF" }
+];
+
+// src/scanners/rules/vuex-to-pinia.ts
+var vuexToPiniaRules = [
+  { id: "vuex-store", name: "Vuex store usage", dimension: "vuex-to-pinia", severity: "info", regex: /new\s+Vuex\.Store|from\s*['"]vuex['"]/, suggestion: "\u8FC1\u79FB\u4E3A Pinia defineStore()" },
+  { id: "vuex-map-state", name: "mapState / mapGetters", dimension: "vuex-to-pinia", severity: "warning", regex: /map(State|Getters|Mutations|Actions)\s*\(/, suggestion: "Pinia \u4F7F\u7528 storeToRefs() \u66FF\u4EE3 map \u8F85\u52A9\u51FD\u6570" }
+];
+
+// src/scanners/rules/webpack-to-vite.ts
+var webpackToViteRules = [
+  { id: "webpack-config", name: "webpack.config file", dimension: "webpack-to-vite", severity: "info", regex: /require\s*\(\s*['"]webpack['"]\s*\)/, suggestion: "\u8FC1\u79FB\u4E3A vite.config.ts" },
+  { id: "webpack-require-context", name: "require.context", dimension: "webpack-to-vite", severity: "warning", regex: /require\.context\s*\(/, suggestion: "Vite \u4F7F\u7528 import.meta.glob \u66FF\u4EE3" },
+  { id: "webpack-process-env", name: "process.env usage", dimension: "webpack-to-vite", severity: "info", regex: /process\.env\./, suggestion: "Vite \u4F7F\u7528 import.meta.env \u66FF\u4EE3" }
+];
+
+// src/scanners/rules/index.ts
+var PATTERN_RULES = [
+  ...vue2ToVue3Rules,
+  ...jsToTsRules,
+  ...webpackToViteRules,
+  ...jestToVitestRules,
+  ...vuexToPiniaRules,
+  ...eslintModernizeRules
+];
+
+// src/scanners/legacy-scanner.ts
+var DEFAULT_RISK_THRESHOLDS = {
+  criticalHigh: 20,
+  criticalMedium: 5,
+  warningMedium: 30,
+  filesHigh: 200,
+  filesMedium: 50,
+  effortHigh: 15,
+  effortMedium: 25,
+  effortLow: 40
+};
+var DEFAULT_MAX_MATCHES_PER_RULE = 10;
+var CONCURRENT_READ_LIMIT = 50;
+function isExcluded(rel, excludes) {
+  const segments = rel.split(sep);
+  for (const pattern of excludes) {
+    const parts = pattern.split("/");
+    if (matchGlobSegments(segments, parts, 0, 0)) return true;
+  }
+  return false;
+}
+function matchGlobSegments(pathSegs, patternParts, pi, ppi) {
+  if (ppi === patternParts.length) return pi === pathSegs.length;
+  const pat = patternParts[ppi];
+  if (pat === "**") {
+    let nextPPi = ppi + 1;
+    while (nextPPi < patternParts.length && patternParts[nextPPi] === "**") nextPPi++;
+    if (nextPPi === patternParts.length) return true;
+    for (let i = pi; i <= pathSegs.length; i++) {
+      if (matchGlobSegments(pathSegs, patternParts, i, nextPPi)) return true;
+    }
+    return false;
+  }
+  if (pi === pathSegs.length) return false;
+  const seg = pathSegs[pi];
+  if (pat === "*") {
+    return matchGlobSegments(pathSegs, patternParts, pi + 1, ppi + 1);
+  }
+  if (seg === pat) {
+    return matchGlobSegments(pathSegs, patternParts, pi + 1, ppi + 1);
+  }
+  return false;
+}
+function extractScriptContent(content, filePath) {
+  if (!filePath.endsWith(".vue")) return content;
+  let result = content.replace(/<template[\s\S]*?<\/template>/gi, "");
+  result = result.replace(/<style[\s\S]*?<\/style>/gi, "");
+  return result;
+}
+async function readFilesConcurrently(filePaths, root, limit) {
+  const results = /* @__PURE__ */ new Map();
+  const batch = [];
+  for (const rel of filePaths) {
+    const p = readFile(join(root, rel), "utf-8").then((content) => {
+      results.set(rel, content);
+    }).catch(() => {
+    });
+    batch.push(p);
+    if (batch.length >= limit) {
+      await Promise.allSettled(batch);
+      batch.length = 0;
+    }
+  }
+  if (batch.length > 0) {
+    await Promise.allSettled(batch);
+  }
+  return results;
+}
+function scanFileContent(content, filePath, maxMatchesPerRule = DEFAULT_MAX_MATCHES_PER_RULE) {
+  const scanContent = extractScriptContent(content, filePath);
+  const patterns = [];
+  for (const rule of PATTERN_RULES) {
+    if (rule.dimension === "js-to-ts" && /\.(ts|tsx)$/.test(filePath)) continue;
+    const flags = rule.regex.flags.includes("g") ? rule.regex.flags : `${rule.regex.flags}g`;
+    const regex = new RegExp(rule.regex.source, flags);
+    let match = regex.exec(scanContent), matchCount = 0;
+    while (match !== null && matchCount < maxMatchesPerRule) {
+      const line = scanContent.slice(0, match.index).split("\n").length;
+      patterns.push({
+        id: rule.id,
+        name: rule.name,
+        dimension: rule.dimension,
+        severity: rule.severity,
+        file: filePath,
+        line: createPatternLine(line),
+        snippet: match[0].slice(0, 120),
+        suggestion: rule.suggestion
+      });
+      matchCount++;
+      if (match[0].length === 0) regex.lastIndex++;
+      match = regex.exec(scanContent);
+    }
+  }
+  return patterns;
+}
+async function scanProject(options) {
+  const startTime = performance.now();
+  const root = options.root;
+  const include = options.include ?? ["**/*.{vue,js,ts,jsx,tsx}"];
+  const exclude = options.exclude ?? ["node_modules/**", "dist/**", "coverage/**", ".git/**"];
+  const maxPerRule = options.maxMatchesPerRule ?? DEFAULT_MAX_MATCHES_PER_RULE;
+  const thresholds = { ...DEFAULT_RISK_THRESHOLDS, ...options.riskThresholds };
+  const files = [];
+  for (const pattern of include) {
+    const globIter = glob(join(root, pattern));
+    for await (const file of globIter) {
+      const rel = relative(root, file);
+      if (!isExcluded(rel, exclude)) {
+        files.push(rel);
+      }
+    }
+  }
+  if (options.maxFiles && options.maxFiles > 0) {
+    files.splice(options.maxFiles);
+  }
+  const contents = await readFilesConcurrently(files, root, CONCURRENT_READ_LIMIT);
+  const allPatterns = [];
+  let totalFiles = 0, jsFiles = 0;
+  for (const [rel, content] of contents) {
+    const patterns = scanFileContent(content, rel, maxPerRule);
+    allPatterns.push(...patterns);
+    totalFiles++;
+    if (/\.(js|jsx|vue)$/.test(rel)) jsFiles++;
+  }
+  const dimensions = computeDimensionStats(allPatterns, jsFiles);
+  const risk = assessRisk(allPatterns, dimensions, totalFiles, thresholds);
+  return {
+    projectRoot: root,
+    scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalFiles,
+    totalPatterns: allPatterns.length,
+    patterns: allPatterns,
+    dimensions,
+    risk,
+    duration: Math.round(performance.now() - startTime)
+  };
+}
+function computeDimensionStats(patterns, jsFiles) {
+  const map = /* @__PURE__ */ new Map();
+  for (const p of patterns) {
+    let entry = map.get(p.dimension);
+    if (!entry) {
+      entry = { count: 0, files: /* @__PURE__ */ new Set(), bySeverity: { critical: 0, warning: 0, info: 0 } };
+      map.set(p.dimension, entry);
+    }
+    entry.count++;
+    entry.bySeverity[p.severity]++;
+    entry.files.add(p.file);
+  }
+  const result = Array.from(map, ([dimension, e]) => ({
+    dimension,
+    count: e.count,
+    files: e.files.size,
+    bySeverity: e.bySeverity
+  }));
+  if (jsFiles > 0) {
+    const existing = result.find((d) => d.dimension === "js-to-ts");
+    if (existing) {
+      existing.files = Math.max(existing.files, jsFiles);
+      existing.count = Math.max(existing.count, jsFiles);
+    } else {
+      result.push({
+        dimension: "js-to-ts",
+        count: jsFiles,
+        files: jsFiles,
+        bySeverity: { critical: 0, warning: 0, info: jsFiles }
+      });
+    }
+  }
+  return result;
+}
+function assessRisk(patterns, dimensions, totalFiles, thresholds) {
+  const criticalCount = patterns.filter((p) => p.severity === "critical").length;
+  const warningCount = patterns.filter((p) => p.severity === "warning").length;
+  let level, estimatedEffort;
+  if (criticalCount > thresholds.criticalHigh || totalFiles > thresholds.filesHigh) {
+    level = "high";
+    estimatedEffort = Math.ceil(totalFiles / thresholds.effortHigh);
+  } else if (criticalCount > thresholds.criticalMedium || warningCount > thresholds.warningMedium || totalFiles > thresholds.filesMedium) {
+    level = "medium";
+    estimatedEffort = Math.ceil(totalFiles / thresholds.effortMedium);
+  } else {
+    level = "low";
+    estimatedEffort = Math.max(1, Math.ceil(totalFiles / thresholds.effortLow));
+  }
+  const recommendedOrder = [...dimensions].sort((a, b) => {
+    const severityScore = (s) => s.bySeverity.critical * 3 + s.bySeverity.warning;
+    return severityScore(b) - severityScore(a);
+  }).map((d) => d.dimension);
+  const reason = criticalCount > 0 ? `\u53D1\u73B0 ${criticalCount} \u4E2A\u4E25\u91CD\u95EE\u9898\u9700\u8981\u4F18\u5148\u5904\u7406\uFF08\u5982\u5DF2\u5E9F\u5F03 API\u3001\u7834\u574F\u6027\u53D8\u66F4\uFF09\uFF0C${warningCount} \u4E2A\u8B66\u544A` : warningCount > 0 ? `\u53D1\u73B0 ${warningCount} \u4E2A\u8B66\u544A\u7EA7\u522B\u95EE\u9898\uFF0C\u5EFA\u8BAE\u9010\u6B65\u8FC1\u79FB` : "\u9879\u76EE\u73B0\u4EE3\u5316\u7A0B\u5EA6\u8F83\u597D\uFF0C\u4EC5\u9700\u5C11\u91CF\u8C03\u6574";
+  return { level, reason, recommendedOrder, estimatedEffort };
+}
+
+// src/utils/config.ts
+var DEFAULT_INCLUDES = {
+  "vue2-to-vue3": ["**/*.vue", "**/*.js", "**/*.ts"],
+  "js-to-ts": ["**/*.js", "**/*.jsx", "**/*.vue"],
+  "webpack-to-vite": ["webpack.config.*", "**/webpack.*.config.*"],
+  "jest-to-vitest": ["jest.config.*", "**/*.test.*", "**/*.spec.*"],
+  "vuex-to-pinia": ["**/store/**", "**/vuex/**", "**/*.vue"],
+  "eslint-modernize": [".eslintrc.*", "eslint.config.*"]
+};
+var DEFAULT_DIMENSION = {
+  enabled: true,
+  include: [],
+  exclude: ["node_modules/**", "dist/**", "coverage/**"]
+};
+var DEFAULT_CONFIG = {
+  dimensions: {
+    "vue2-to-vue3": { ...DEFAULT_DIMENSION, include: DEFAULT_INCLUDES["vue2-to-vue3"] },
+    "js-to-ts": { ...DEFAULT_DIMENSION, include: DEFAULT_INCLUDES["js-to-ts"] },
+    "webpack-to-vite": { ...DEFAULT_DIMENSION, include: DEFAULT_INCLUDES["webpack-to-vite"] },
+    "jest-to-vitest": { ...DEFAULT_DIMENSION, include: DEFAULT_INCLUDES["jest-to-vitest"] },
+    "vuex-to-pinia": { ...DEFAULT_DIMENSION, include: DEFAULT_INCLUDES["vuex-to-pinia"] },
+    "eslint-modernize": { ...DEFAULT_DIMENSION, include: DEFAULT_INCLUDES["eslint-modernize"] }
+  },
+  maxFiles: 0,
+  includeSuggestions: true
+};
+var VALID_DIMENSIONS = new Set(Object.keys(DEFAULT_CONFIG.dimensions));
+function mergeConfig(user) {
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...user,
+    dimensions: { ...DEFAULT_CONFIG.dimensions }
+  };
+  if (user.dimensions) {
+    for (const dim of Object.keys(user.dimensions)) {
+      if (!VALID_DIMENSIONS.has(dim)) {
+        console.warn(`[legacy-modernizer] Unknown dimension key "${dim}" in config \u2014 skipping`);
+        continue;
+      }
+      merged.dimensions[dim] = {
+        ...DEFAULT_CONFIG.dimensions[dim],
+        ...user.dimensions[dim]
+      };
+    }
+  }
+  return merged;
+}
+function getDefaultConfig() {
+  return structuredClone(DEFAULT_CONFIG);
+}
+export {
+  VERSION,
+  createPatternLine,
+  dimensionLabel,
+  formatDuration,
+  getDefaultConfig,
+  mergeConfig,
+  patternToMarkdown,
+  renderAnalysisReport,
+  scanFileContent,
+  scanProject,
+  severityBadge
+};

package/dist/reporters/analysis.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Analysis report renderer — produces full Markdown from an AnalysisReport
+ * Fix #3: locale parameter for i18n output
+ */
+import type { AnalysisReport } from '../types';
+import { type Locale } from './locale';
+/** Render a full AnalysisReport into Markdown */
+export declare function renderAnalysisReport(report: AnalysisReport, locale?: Locale): string;

package/dist/reporters/analysis.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/reporters/locale.d.ts

@@ -0,0 +1,2 @@
+export type Locale = 'en' | 'zh';
+export declare const LABELS: Record<Locale, Record<string, string>>;

package/dist/scanners/legacy-scanner.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Legacy pattern scanner — detects Vue 2 / JS / Webpack legacy patterns using AI-semantic rules
+ */
+import type { AnalysisReport, LegacyPattern, ScannerOptions } from '../types';
+/**
+ * Scan a single file for legacy patterns.
+ * Fix #5: strips <style>/<template> from .vue files before scanning.
+ */
+export declare function scanFileContent(content: string, filePath: string, maxMatchesPerRule?: number): LegacyPattern[];
+/**
+ * Scan a project directory and produce a full analysis report.
+ * Fix #7: concurrent file reads.
+ * Fix #4: simplified JS file counting.
+ * Fix #6: configurable risk thresholds.
+ */
+export declare function scanProject(options: ScannerOptions): Promise<AnalysisReport>;

package/dist/scanners/legacy-scanner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scanners/rules/eslint-modernize.d.ts

@@ -0,0 +1,3 @@
+import type { PatternRule } from '../../types';
+/** Detect legacy ESLint config patterns that should migrate to flat config */
+export declare const eslintModernizeRules: PatternRule[];

package/dist/scanners/rules/index.d.ts

@@ -0,0 +1,3 @@
+import type { PatternRule } from '../../types';
+/** All detection rules combined from per-dimension modules */
+export declare const PATTERN_RULES: PatternRule[];

package/dist/scanners/rules/jest-to-vitest.d.ts

@@ -0,0 +1,2 @@
+import type { PatternRule } from '../../types';
+export declare const jestToVitestRules: PatternRule[];

package/dist/scanners/rules/js-to-ts.d.ts

@@ -0,0 +1,3 @@
+import type { PatternRule } from '../../types';
+/** JS→TS rules — deliberately excludes js-no-type to avoid noise; JS file stats are computed separately */
+export declare const jsToTsRules: PatternRule[];

package/dist/scanners/rules/vue2-to-vue3.d.ts

@@ -0,0 +1,2 @@
+import type { PatternRule } from '../../types';
+export declare const vue2ToVue3Rules: PatternRule[];

package/dist/scanners/rules/vuex-to-pinia.d.ts

@@ -0,0 +1,2 @@
+import type { PatternRule } from '../../types';
+export declare const vuexToPiniaRules: PatternRule[];

package/dist/scanners/rules/webpack-to-vite.d.ts

@@ -0,0 +1,2 @@
+import type { PatternRule } from '../../types';
+export declare const webpackToViteRules: PatternRule[];