@schemashift/core 0.7.0 → 0.8.0

package/dist/index.cjs

@@ -21,11 +21,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   CompatibilityAnalyzer: () => CompatibilityAnalyzer,
+  ComplexityEstimator: () => ComplexityEstimator,
   DetailedAnalyzer: () => DetailedAnalyzer,
   EcosystemAnalyzer: () => EcosystemAnalyzer,
+  FormResolverMigrator: () => FormResolverMigrator,
   GovernanceEngine: () => GovernanceEngine,
   IncrementalTracker: () => IncrementalTracker,
   MigrationChain: () => MigrationChain,
+  MonorepoResolver: () => MonorepoResolver,
   PackageUpdater: () => PackageUpdater,
   PluginLoader: () => PluginLoader,
   SchemaAnalyzer: () => SchemaAnalyzer,
@@ -393,7 +396,8 @@ var ECOSYSTEM_RULES = [
     check: () => ({
       issue: "drizzle-zod may not support Zod v4. Check for a compatible version before upgrading.",
       suggestion: "Upgrade drizzle-zod to the latest version that supports Zod v4, or use --legacy-peer-deps.",
-      severity: "warning"
+      severity: "warning",
+      upgradeCommand: "npm install drizzle-zod@latest"
     })
   },
   {
@@ -403,7 +407,8 @@ var ECOSYSTEM_RULES = [
     check: () => ({
       issue: "zod-prisma generates Zod v3 schemas. Generated files will need regeneration after upgrading to Zod v4.",
       suggestion: "Upgrade zod-prisma to a v4-compatible version and regenerate schemas.",
-      severity: "warning"
+      severity: "warning",
+      upgradeCommand: "npm install zod-prisma@latest"
     })
   },
   {
@@ -413,7 +418,8 @@ var ECOSYSTEM_RULES = [
     check: () => ({
       issue: "zod-prisma-types generates Zod v3 schemas. Generated files will need regeneration.",
       suggestion: "Check for a Zod v4-compatible version of zod-prisma-types.",
-      severity: "warning"
+      severity: "warning",
+      upgradeCommand: "npm install zod-prisma-types@latest"
     })
   },
   // API framework integrations
@@ -428,7 +434,8 @@ var ECOSYSTEM_RULES = [
         return {
           issue: `tRPC v${major} expects Zod v3 types. A v3 ZodType is not assignable to a v4 ZodType.`,
           suggestion: "Upgrade to tRPC v11+ which supports Zod v4 via Standard Schema.",
-          severity: "error"
+          severity: "error",
+          upgradeCommand: "npm install @trpc/server@latest"
         };
       }
       return {
@@ -445,7 +452,8 @@ var ECOSYSTEM_RULES = [
     check: () => ({
       issue: "trpc-ui breaks entirely with Zod v4 schemas.",
       suggestion: "Check for a Zod v4-compatible version of trpc-ui before upgrading.",
-      severity: "error"
+      severity: "error",
+      upgradeCommand: "npm install trpc-ui@latest"
     })
   },
   // Validation utilities
@@ -460,7 +468,8 @@ var ECOSYSTEM_RULES = [
         return {
           issue: `zod-validation-error v${major} is not compatible with Zod v4.`,
           suggestion: "Upgrade zod-validation-error to v5.0.0+ for Zod v4 support.",
-          severity: "error"
+          severity: "error",
+          upgradeCommand: "npm install zod-validation-error@^5.0.0"
         };
       }
       return null;
@@ -476,13 +485,15 @@ var ECOSYSTEM_RULES = [
         return {
           issue: "@hookform/resolvers zodResolver may need updating for Zod v4.",
           suggestion: "Upgrade @hookform/resolvers to the latest version with Zod v4 support.",
-          severity: "warning"
+          severity: "warning",
+          upgradeCommand: "npm install @hookform/resolvers@latest"
         };
       }
       return {
         issue: "@hookform/resolvers will need its resolver import updated for the new schema library.",
         suggestion: "Switch from the old resolver (e.g., yupResolver) to zodResolver from @hookform/resolvers/zod.",
-        severity: "warning"
+        severity: "warning",
+        upgradeCommand: "npm install @hookform/resolvers@latest"
       };
     }
   },
@@ -514,7 +525,8 @@ var ECOSYSTEM_RULES = [
     check: () => ({
       issue: "zod-openapi may not support Zod v4 yet.",
       suggestion: "Check for a Zod v4-compatible version of zod-openapi.",
-      severity: "warning"
+      severity: "warning",
+      upgradeCommand: "npm install zod-openapi@latest"
     })
   },
   {
@@ -524,7 +536,8 @@ var ECOSYSTEM_RULES = [
     check: () => ({
       issue: "@asteasolutions/zod-to-openapi may not support Zod v4 yet.",
       suggestion: "Check for a Zod v4-compatible version of @asteasolutions/zod-to-openapi.",
-      severity: "warning"
+      severity: "warning",
+      upgradeCommand: "npm install @asteasolutions/zod-to-openapi@latest"
     })
   }
 ];
@@ -558,7 +571,8 @@ var EcosystemAnalyzer = class {
         issue: result.issue,
         suggestion: result.suggestion,
         severity: result.severity,
-        category: rule.category
+        category: rule.category,
+        ...result.upgradeCommand ? { upgradeCommand: result.upgradeCommand } : {}
       };
       dependencies.push(issue);
       if (result.severity === "error") {
@@ -696,6 +710,120 @@ var CompatibilityAnalyzer = class {
   }
 };
 
+// src/complexity-estimator.ts
+var SCHEMA_FACTORY_PATTERN = /z\.(object|string|number|boolean|array|enum|union|discriminatedUnion|intersection|lazy|tuple|record|literal|nativeEnum|any|unknown|void|null|undefined|never|date|bigint|symbol|function|promise|map|set|custom|preprocess|pipeline|brand|coerce)\s*\(/g;
+var ADVANCED_PATTERNS = [
+  [/z\.discriminatedUnion\s*\(/g, "discriminatedUnion"],
+  [/z\.intersection\s*\(/g, "intersection"],
+  [/z\.lazy\s*\(/g, "recursive"],
+  [/\.brand\s*[<(]/g, "branded"],
+  [/\.superRefine\s*\(/g, "superRefine"],
+  [/\.transform\s*\(/g, "transform"],
+  [/\.pipe\s*\(/g, "pipe"],
+  [/\.refine\s*\(/g, "refine"]
+];
+function countMatches(text, pattern) {
+  pattern.lastIndex = 0;
+  let count = 0;
+  while (pattern.exec(text)) count++;
+  return count;
+}
+function getMaxChainDepth(text) {
+  let maxDepth = 0;
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const dotCalls = line.match(/\.\w+\s*\(/g);
+    if (dotCalls && dotCalls.length > maxDepth) {
+      maxDepth = dotCalls.length;
+    }
+  }
+  return maxDepth;
+}
+var ComplexityEstimator = class {
+  estimate(files) {
+    const fileResults = [];
+    const warnings = [];
+    const riskAreas = [];
+    let totalSchemas = 0;
+    let advancedPatternCount = 0;
+    let hasDeepDiscriminatedUnions = false;
+    for (const file of files) {
+      const text = file.getFullText();
+      const filePath = file.getFilePath();
+      const lineCount = file.getEndLineNumber();
+      const schemaCount = countMatches(text, new RegExp(SCHEMA_FACTORY_PATTERN.source, "g"));
+      totalSchemas += schemaCount;
+      const advancedPatterns = [];
+      for (const [pattern, name] of ADVANCED_PATTERNS) {
+        const count = countMatches(text, new RegExp(pattern.source, "g"));
+        if (count > 0) {
+          advancedPatterns.push(name);
+          advancedPatternCount += count;
+        }
+      }
+      const chainDepth = getMaxChainDepth(text);
+      fileResults.push({ filePath, schemaCount, advancedPatterns, chainDepth, lineCount });
+      if (lineCount > 500) {
+        warnings.push({
+          file: filePath,
+          message: `Large file (${lineCount} lines) may be difficult to migrate in one pass`,
+          severity: "warning"
+        });
+      }
+      if (schemaCount > 50) {
+        warnings.push({
+          file: filePath,
+          message: `High schema density (${schemaCount} schemas) \u2014 consider splitting before migration`,
+          severity: "warning"
+        });
+      }
+      if (chainDepth > 20) {
+        warnings.push({
+          file: filePath,
+          message: `Long method chain (${chainDepth} calls) \u2014 higher transformation risk`,
+          severity: "warning"
+        });
+      }
+      const duCount = countMatches(text, /z\.discriminatedUnion\s*\(/g);
+      if (duCount > 10) {
+        hasDeepDiscriminatedUnions = true;
+        warnings.push({
+          file: filePath,
+          message: `${duCount} discriminated unions \u2014 TypeScript TS2589 performance risk in Zod v4`,
+          severity: "error"
+        });
+      }
+      if (advancedPatterns.includes("recursive")) {
+        riskAreas.push(`Recursive schemas in ${filePath}`);
+      }
+      if (advancedPatterns.includes("branded")) {
+        riskAreas.push(`Branded types in ${filePath}`);
+      }
+    }
+    const effort = this.calculateEffort(
+      totalSchemas,
+      advancedPatternCount,
+      hasDeepDiscriminatedUnions
+    );
+    return {
+      effort,
+      totalSchemas,
+      totalFiles: files.length,
+      advancedPatternCount,
+      files: fileResults,
+      warnings,
+      riskAreas
+    };
+  }
+  calculateEffort(totalSchemas, advancedCount, hasDeepDU) {
+    if (totalSchemas >= 500 && hasDeepDU) return "extreme";
+    if (totalSchemas >= 200 || advancedCount >= 20) return "high";
+    if (totalSchemas >= 50 || advancedCount >= 5) return "moderate";
+    if (totalSchemas >= 10) return "low";
+    return "trivial";
+  }
+};
+
 // src/config.ts
 var import_cosmiconfig = require("cosmiconfig");
 function validateConfig(config) {
@@ -757,6 +885,8 @@ async function loadConfig(configPath) {
 }
 
 // src/dependency-graph.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
 var SchemaDependencyResolver = class {
   resolve(project, filePaths) {
     const fileSet = new Set(filePaths);
@@ -842,10 +972,105 @@ var SchemaDependencyResolver = class {
     return parts.slice(-2).join("/");
   }
 };
+var SCHEMA_PACKAGES = /* @__PURE__ */ new Set(["zod", "yup", "joi", "io-ts", "valibot", "@effect/schema"]);
+var MonorepoResolver = class {
+  detect(projectPath) {
+    const pkgPath = (0, import_node_path3.join)(projectPath, "package.json");
+    if (!(0, import_node_fs3.existsSync)(pkgPath)) return false;
+    try {
+      const pkg = JSON.parse((0, import_node_fs3.readFileSync)(pkgPath, "utf-8"));
+      return !!pkg.workspaces;
+    } catch {
+      return false;
+    }
+  }
+  analyze(projectPath) {
+    const pkgPath = (0, import_node_path3.join)(projectPath, "package.json");
+    if (!(0, import_node_fs3.existsSync)(pkgPath)) {
+      return { isMonorepo: false, packages: [], suggestedOrder: [] };
+    }
+    let workspaceGlobs;
+    try {
+      const pkg = JSON.parse((0, import_node_fs3.readFileSync)(pkgPath, "utf-8"));
+      if (!pkg.workspaces) {
+        return { isMonorepo: false, packages: [], suggestedOrder: [] };
+      }
+      workspaceGlobs = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages;
+    } catch {
+      return { isMonorepo: false, packages: [], suggestedOrder: [] };
+    }
+    const packages = [];
+    const resolvedDirs = this.resolveWorkspaceDirs(projectPath, workspaceGlobs);
+    for (const dir of resolvedDirs) {
+      const wsPkgPath = (0, import_node_path3.join)(dir, "package.json");
+      if (!(0, import_node_fs3.existsSync)(wsPkgPath)) continue;
+      try {
+        const wsPkg = JSON.parse((0, import_node_fs3.readFileSync)(wsPkgPath, "utf-8"));
+        if (!wsPkg.name) continue;
+        const allDeps = { ...wsPkg.dependencies, ...wsPkg.devDependencies };
+        const depNames = Object.keys(allDeps);
+        const schemaLibrary = depNames.find((d) => SCHEMA_PACKAGES.has(d));
+        packages.push({
+          name: wsPkg.name,
+          path: dir,
+          schemaLibrary,
+          dependencies: depNames
+        });
+      } catch {
+      }
+    }
+    const suggestedOrder = this.suggestOrder(packages);
+    return { isMonorepo: true, packages, suggestedOrder };
+  }
+  suggestOrder(packages) {
+    const nameSet = new Set(packages.map((p) => p.name));
+    const depMap = /* @__PURE__ */ new Map();
+    for (const pkg of packages) {
+      const internalDeps = pkg.dependencies.filter((d) => nameSet.has(d));
+      depMap.set(pkg.name, internalDeps);
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const sorted = [];
+    const visit = (name) => {
+      if (visited.has(name)) return;
+      visited.add(name);
+      for (const dep of depMap.get(name) ?? []) {
+        visit(dep);
+      }
+      sorted.push(name);
+    };
+    for (const pkg of packages) {
+      visit(pkg.name);
+    }
+    return sorted;
+  }
+  resolveWorkspaceDirs(projectPath, globs) {
+    const dirs = [];
+    for (const glob of globs) {
+      const clean = glob.replace(/\/?\*$/, "");
+      const base = (0, import_node_path3.resolve)(projectPath, clean);
+      if (!(0, import_node_fs3.existsSync)(base)) continue;
+      if (glob.endsWith("*")) {
+        try {
+          const entries = (0, import_node_fs3.readdirSync)(base, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              dirs.push((0, import_node_path3.join)(base, entry.name));
+            }
+          }
+        } catch {
+        }
+      } else {
+        dirs.push(base);
+      }
+    }
+    return dirs;
+  }
+};
 
 // src/detailed-analyzer.ts
-var import_node_fs3 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
 var COMPLEXITY_CHAIN_WEIGHT = 2;
 var COMPLEXITY_DEPTH_WEIGHT = 3;
 var COMPLEXITY_VALIDATION_WEIGHT = 1;
@@ -910,10 +1135,10 @@ var DetailedAnalyzer = class {
   }
   detectLibraryVersions(projectPath) {
     const versions = [];
-    const pkgPath = (0, import_node_path3.join)(projectPath, "package.json");
-    if (!(0, import_node_fs3.existsSync)(pkgPath)) return versions;
+    const pkgPath = (0, import_node_path4.join)(projectPath, "package.json");
+    if (!(0, import_node_fs4.existsSync)(pkgPath)) return versions;
     try {
-      const pkg = JSON.parse((0, import_node_fs3.readFileSync)(pkgPath, "utf-8"));
+      const pkg = JSON.parse((0, import_node_fs4.readFileSync)(pkgPath, "utf-8"));
       const knownLibs = ["zod", "yup", "joi", "io-ts", "valibot"];
       const allDeps = {
         ...pkg.dependencies,
@@ -1086,6 +1311,90 @@ var DetailedAnalyzer = class {
   }
 };
 
+// src/form-resolver-migrator.ts
+var RESOLVER_MAPPINGS = {
+  "yup->zod": [
+    {
+      fromImport: "@hookform/resolvers/yup",
+      toImport: "@hookform/resolvers/zod",
+      fromResolver: "yupResolver",
+      toResolver: "zodResolver"
+    }
+  ],
+  "joi->zod": [
+    {
+      fromImport: "@hookform/resolvers/joi",
+      toImport: "@hookform/resolvers/zod",
+      fromResolver: "joiResolver",
+      toResolver: "zodResolver"
+    }
+  ],
+  "zod->valibot": [
+    {
+      fromImport: "@hookform/resolvers/zod",
+      toImport: "@hookform/resolvers/valibot",
+      fromResolver: "zodResolver",
+      toResolver: "valibotResolver"
+    }
+  ]
+};
+var TODO_PATTERNS = [
+  {
+    pattern: /from\s+['"]formik['"]/,
+    comment: "/* TODO(schemashift): Formik is unmaintained. Consider migrating to React Hook Form with zodResolver */"
+  },
+  {
+    pattern: /from\s+['"]@mantine\/form['"]/,
+    comment: "/* TODO(schemashift): Update @mantine/form to use Zod schema adapter */"
+  }
+];
+var FormResolverMigrator = class {
+  migrate(sourceFile, from, to) {
+    const migration = `${from}->${to}`;
+    let code = sourceFile.getFullText();
+    const changes = [];
+    const warnings = [];
+    const mappings = RESOLVER_MAPPINGS[migration];
+    if (mappings) {
+      for (const mapping of mappings) {
+        if (code.includes(mapping.fromImport)) {
+          code = code.replaceAll(mapping.fromImport, mapping.toImport);
+          code = code.replaceAll(mapping.fromResolver, mapping.toResolver);
+          changes.push(
+            `Replaced ${mapping.fromResolver} import from '${mapping.fromImport}' with ${mapping.toResolver} from '${mapping.toImport}'`
+          );
+        }
+      }
+    }
+    const lines = code.split("\n");
+    const insertions = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] ?? "";
+      for (const { pattern, comment } of TODO_PATTERNS) {
+        if (pattern.test(line) && !code.includes(comment)) {
+          insertions.push({ index: i, comment });
+          warnings.push(comment.replace(/\/\*\s*|\s*\*\//g, "").trim());
+        }
+      }
+    }
+    for (let i = insertions.length - 1; i >= 0; i--) {
+      const insertion = insertions[i];
+      if (!insertion) continue;
+      lines.splice(insertion.index, 0, insertion.comment);
+      changes.push(`Added TODO comment for ${lines[insertion.index + 1]?.trim()}`);
+    }
+    if (insertions.length > 0) {
+      code = lines.join("\n");
+    }
+    return {
+      success: true,
+      transformedCode: code,
+      changes,
+      warnings
+    };
+  }
+};
+
 // src/governance.ts
 var GovernanceEngine = class {
   rules = /* @__PURE__ */ new Map();
@@ -1207,16 +1516,16 @@ var GovernanceEngine = class {
 };
 
 // src/incremental.ts
-var import_node_fs4 = require("fs");
-var import_node_path4 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
 var STATE_DIR = ".schemashift";
 var STATE_FILE = "incremental.json";
 var IncrementalTracker = class {
   stateDir;
   statePath;
   constructor(projectPath) {
-    this.stateDir = (0, import_node_path4.join)(projectPath, STATE_DIR);
-    this.statePath = (0, import_node_path4.join)(this.stateDir, STATE_FILE);
+    this.stateDir = (0, import_node_path5.join)(projectPath, STATE_DIR);
+    this.statePath = (0, import_node_path5.join)(this.stateDir, STATE_FILE);
   }
   start(files, from, to) {
     const state = {
@@ -1251,9 +1560,9 @@ var IncrementalTracker = class {
     this.saveState(state);
   }
   getState() {
-    if (!(0, import_node_fs4.existsSync)(this.statePath)) return null;
+    if (!(0, import_node_fs5.existsSync)(this.statePath)) return null;
     try {
-      return JSON.parse((0, import_node_fs4.readFileSync)(this.statePath, "utf-8"));
+      return JSON.parse((0, import_node_fs5.readFileSync)(this.statePath, "utf-8"));
     } catch {
       return null;
     }
@@ -1280,21 +1589,21 @@ var IncrementalTracker = class {
     };
   }
   clear() {
-    if ((0, import_node_fs4.existsSync)(this.statePath)) {
-      (0, import_node_fs4.writeFileSync)(this.statePath, "");
+    if ((0, import_node_fs5.existsSync)(this.statePath)) {
+      (0, import_node_fs5.writeFileSync)(this.statePath, "");
     }
   }
   saveState(state) {
-    if (!(0, import_node_fs4.existsSync)(this.stateDir)) {
-      (0, import_node_fs4.mkdirSync)(this.stateDir, { recursive: true });
+    if (!(0, import_node_fs5.existsSync)(this.stateDir)) {
+      (0, import_node_fs5.mkdirSync)(this.stateDir, { recursive: true });
     }
-    (0, import_node_fs4.writeFileSync)(this.statePath, JSON.stringify(state, null, 2));
+    (0, import_node_fs5.writeFileSync)(this.statePath, JSON.stringify(state, null, 2));
   }
 };
 
 // src/package-updater.ts
-var import_node_fs5 = require("fs");
-var import_node_path5 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
 var TARGET_VERSIONS = {
   "yup->zod": { zod: "^3.24.0" },
   "joi->zod": { zod: "^3.24.0" },
@@ -1315,14 +1624,14 @@ var PackageUpdater = class {
     const add = {};
     const remove = [];
     const warnings = [];
-    const pkgPath = (0, import_node_path5.join)(projectPath, "package.json");
-    if (!(0, import_node_fs5.existsSync)(pkgPath)) {
+    const pkgPath = (0, import_node_path6.join)(projectPath, "package.json");
+    if (!(0, import_node_fs6.existsSync)(pkgPath)) {
       warnings.push("No package.json found. Cannot plan dependency updates.");
       return { add, remove, warnings };
     }
     let pkg;
     try {
-      pkg = JSON.parse((0, import_node_fs5.readFileSync)(pkgPath, "utf-8"));
+      pkg = JSON.parse((0, import_node_fs6.readFileSync)(pkgPath, "utf-8"));
     } catch {
       warnings.push("Could not parse package.json.");
       return { add, remove, warnings };
@@ -1352,9 +1661,9 @@ var PackageUpdater = class {
     return { add, remove, warnings };
   }
   apply(projectPath, plan) {
-    const pkgPath = (0, import_node_path5.join)(projectPath, "package.json");
-    if (!(0, import_node_fs5.existsSync)(pkgPath)) return;
-    const pkgText = (0, import_node_fs5.readFileSync)(pkgPath, "utf-8");
+    const pkgPath = (0, import_node_path6.join)(projectPath, "package.json");
+    if (!(0, import_node_fs6.existsSync)(pkgPath)) return;
+    const pkgText = (0, import_node_fs6.readFileSync)(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgText);
     if (!pkg.dependencies) pkg.dependencies = {};
     for (const [name, version] of Object.entries(plan.add)) {
@@ -1364,7 +1673,7 @@ var PackageUpdater = class {
         pkg.dependencies[name] = version;
       }
     }
-    (0, import_node_fs5.writeFileSync)(pkgPath, `${JSON.stringify(pkg, null, 2)}
+    (0, import_node_fs6.writeFileSync)(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `);
   }
 };
@@ -1414,8 +1723,8 @@ var PluginLoader = class {
 };
 
 // src/standard-schema.ts
-var import_node_fs6 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path7 = require("path");
 var STANDARD_SCHEMA_LIBRARIES = {
   zod: { minMajor: 3, minMinor: 23 },
   // Zod v3.23+ and v4+
@@ -1444,13 +1753,13 @@ function isVersionCompatible(version, minMajor, minMinor) {
   return false;
 }
 function detectStandardSchema(projectPath) {
-  const pkgPath = (0, import_node_path6.join)(projectPath, "package.json");
-  if (!(0, import_node_fs6.existsSync)(pkgPath)) {
+  const pkgPath = (0, import_node_path7.join)(projectPath, "package.json");
+  if (!(0, import_node_fs7.existsSync)(pkgPath)) {
     return { detected: false, compatibleLibraries: [], recommendation: "" };
   }
   let allDeps = {};
   try {
-    const pkg = JSON.parse((0, import_node_fs6.readFileSync)(pkgPath, "utf-8"));
+    const pkg = JSON.parse((0, import_node_fs7.readFileSync)(pkgPath, "utf-8"));
     allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return { detected: false, compatibleLibraries: [], recommendation: "" };
@@ -1510,11 +1819,14 @@ var TransformEngine = class {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CompatibilityAnalyzer,
+  ComplexityEstimator,
   DetailedAnalyzer,
   EcosystemAnalyzer,
+  FormResolverMigrator,
   GovernanceEngine,
   IncrementalTracker,
   MigrationChain,
+  MonorepoResolver,
   PackageUpdater,
   PluginLoader,
   SchemaAnalyzer,