@schemashift/core 0.3.0 → 0.7.0

package/dist/index.js

@@ -23,6 +23,27 @@ function detectSchemaLibrary(moduleSpecifier) {
   }
   return "unknown";
 }
+var FORM_LIBRARY_PATTERNS = {
+  "react-hook-form": [/^react-hook-form$/, /^@hookform\/resolvers/],
+  formik: [/^formik$/],
+  "mantine-form": [/^@mantine\/form$/]
+};
+function detectFormLibraries(sourceFile) {
+  const detections = [];
+  for (const imp of sourceFile.getImportDeclarations()) {
+    const moduleSpecifier = imp.getModuleSpecifierValue();
+    for (const [library, patterns] of Object.entries(FORM_LIBRARY_PATTERNS)) {
+      if (patterns.some((pattern) => pattern.test(moduleSpecifier))) {
+        detections.push({
+          library,
+          importPath: moduleSpecifier,
+          lineNumber: imp.getStartLineNumber()
+        });
+      }
+    }
+  }
+  return detections;
+}
 
 // src/analyzer.ts
 var SchemaAnalyzer = class {
@@ -109,8 +130,560 @@ var SchemaAnalyzer = class {
   }
 };
 
+// src/ast-utils.ts
+import { Node as NodeUtils } from "ts-morph";
+function parseCallChain(node) {
+  const methods = [];
+  let current = node;
+  while (true) {
+    const expression = current.getExpression();
+    if (NodeUtils.isPropertyAccessExpression(expression)) {
+      const methodName = expression.getName();
+      const args = current.getArguments().map((a) => a.getText());
+      const inner = expression.getExpression();
+      if (NodeUtils.isCallExpression(inner)) {
+        methods.unshift({ name: methodName, args, node: current });
+        current = inner;
+        continue;
+      }
+      if (NodeUtils.isPropertyAccessExpression(inner)) {
+        const factoryName = inner.getName();
+        const baseExpr = inner.getExpression();
+        if (NodeUtils.isIdentifier(baseExpr)) {
+          methods.unshift({ name: methodName, args, node: current });
+          return {
+            base: baseExpr.getText(),
+            factoryMethod: factoryName,
+            factoryArgs: current.getArguments().map((a) => a.getText()),
+            methods,
+            rootNode: node
+          };
+        }
+        methods.unshift({ name: methodName, args, node: current });
+        current = inner;
+        if (!NodeUtils.isCallExpression(current)) {
+          break;
+        }
+        continue;
+      }
+      if (NodeUtils.isIdentifier(inner)) {
+        return {
+          base: inner.getText(),
+          factoryMethod: methodName,
+          factoryArgs: current.getArguments().map((a) => a.getText()),
+          methods,
+          rootNode: node
+        };
+      }
+    }
+    break;
+  }
+  return void 0;
+}
+function buildCallChain(base, factoryMethod, factoryArgs, methods) {
+  let result = `${base}.${factoryMethod}(${factoryArgs.join(", ")})`;
+  for (const method of methods) {
+    result += `.${method.name}(${method.args.join(", ")})`;
+  }
+  return result;
+}
+function isInsideStringLiteral(node) {
+  let current = node.getParent();
+  while (current) {
+    if (NodeUtils.isStringLiteral(current) || NodeUtils.isNoSubstitutionTemplateLiteral(current) || NodeUtils.isTemplateExpression(current)) {
+      return true;
+    }
+    current = current.getParent();
+  }
+  return false;
+}
+function isInsideComment(node, sourceFile) {
+  const start = node.getStart();
+  const fullText = sourceFile.getFullText();
+  let i = 0;
+  while (i < fullText.length && i < start) {
+    if (fullText[i] === "/" && fullText[i + 1] === "/") {
+      const endOfLine = fullText.indexOf("\n", i);
+      const end = endOfLine === -1 ? fullText.length : endOfLine;
+      if (start >= i && start < end) return true;
+      i = end + 1;
+      continue;
+    }
+    if (fullText[i] === "/" && fullText[i + 1] === "*") {
+      const end = fullText.indexOf("*/", i + 2);
+      const commentEnd = end === -1 ? fullText.length : end + 2;
+      if (start >= i && start < commentEnd) return true;
+      i = commentEnd;
+      continue;
+    }
+    if (fullText[i] === "'" || fullText[i] === '"' || fullText[i] === "`") {
+      const quote = fullText[i];
+      i++;
+      while (i < fullText.length) {
+        if (fullText[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (fullText[i] === quote) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    i++;
+  }
+  return false;
+}
+function startsWithBase(node, ...bases) {
+  const chain = parseCallChain(node);
+  if (!chain) return false;
+  return bases.includes(chain.base);
+}
+function transformMethodChain(chain, newBase, factoryMapper, methodMapper) {
+  const mappedFactory = factoryMapper(chain.factoryMethod, chain.factoryArgs);
+  const factory = mappedFactory || {
+    name: chain.factoryMethod,
+    args: chain.factoryArgs
+  };
+  const mappedMethods = [];
+  for (const method of chain.methods) {
+    const mapped = methodMapper(method);
+    if (mapped === null) {
+      continue;
+    }
+    if (mapped === void 0) {
+      mappedMethods.push({ name: method.name, args: method.args });
+    } else if (Array.isArray(mapped)) {
+      mappedMethods.push(...mapped);
+    } else {
+      mappedMethods.push(mapped);
+    }
+  }
+  return buildCallChain(newBase, factory.name, factory.args, mappedMethods);
+}
+
+// src/chain.ts
+import { Project as Project2 } from "ts-morph";
+var MigrationChain = class {
+  parseChain(chain) {
+    const parts = chain.split("->");
+    if (parts.length < 2) return [];
+    const steps = [];
+    for (let i = 0; i < parts.length - 1; i++) {
+      const from = parts[i];
+      const to = parts[i + 1];
+      if (!from || !to) continue;
+      steps.push({
+        from,
+        to
+      });
+    }
+    return steps;
+  }
+  validateChain(steps, engine) {
+    const errors = [];
+    if (steps.length === 0) {
+      errors.push("No migration steps specified");
+      return { valid: false, errors, steps };
+    }
+    if (steps.length < 2) {
+      errors.push("Chain migration requires at least 2 steps. Use --from/--to for single step.");
+      return { valid: false, errors, steps };
+    }
+    for (const step of steps) {
+      if (!engine.hasHandler(step.from, step.to)) {
+        errors.push(`No handler for step ${step.from}->${step.to}`);
+      }
+    }
+    return { valid: errors.length === 0, errors, steps };
+  }
+  executeChain(sourceCode, filePath, steps, engine) {
+    const stepResults = [];
+    const errors = [];
+    let currentCode = sourceCode;
+    for (const step of steps) {
+      const project = new Project2({ useInMemoryFileSystem: true });
+      const sourceFile = project.createSourceFile(filePath, currentCode);
+      const result = engine.transform(sourceFile, step.from, step.to, {
+        from: step.from,
+        to: step.to,
+        preserveComments: true
+      });
+      stepResults.push({ step, result });
+      if (!result.success) {
+        errors.push(`Step ${step.from}->${step.to} failed: ${result.errors[0]?.message}`);
+        return { success: false, steps: stepResults, errors };
+      }
+      if (result.transformedCode) {
+        currentCode = result.transformedCode;
+      }
+    }
+    return {
+      success: true,
+      steps: stepResults,
+      finalCode: currentCode,
+      errors
+    };
+  }
+};
+
+// src/compatibility.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/ecosystem.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var ECOSYSTEM_RULES = [
+  // ORM integrations
+  {
+    package: "drizzle-zod",
+    category: "orm",
+    migrations: ["zod-v3->v4"],
+    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"
+    })
+  },
+  {
+    package: "zod-prisma",
+    category: "orm",
+    migrations: ["zod-v3->v4"],
+    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"
+    })
+  },
+  {
+    package: "zod-prisma-types",
+    category: "orm",
+    migrations: ["zod-v3->v4"],
+    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"
+    })
+  },
+  // API framework integrations
+  {
+    package: "@trpc/server",
+    category: "api",
+    migrations: ["zod-v3->v4"],
+    check: (version) => {
+      const majorMatch = version.match(/(\d+)/);
+      const major = majorMatch?.[1] ? Number.parseInt(majorMatch[1], 10) : 0;
+      if (major < 11) {
+        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"
+        };
+      }
+      return {
+        issue: "tRPC v11+ supports Zod v4 via Standard Schema.",
+        suggestion: "No action required \u2014 tRPC v11 is compatible with Zod v4.",
+        severity: "info"
+      };
+    }
+  },
+  {
+    package: "trpc-ui",
+    category: "ui",
+    migrations: ["zod-v3->v4"],
+    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"
+    })
+  },
+  // Validation utilities
+  {
+    package: "zod-validation-error",
+    category: "validation-util",
+    migrations: ["zod-v3->v4"],
+    check: (version) => {
+      const majorMatch = version.match(/(\d+)/);
+      const major = majorMatch?.[1] ? Number.parseInt(majorMatch[1], 10) : 0;
+      if (major < 4) {
+        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"
+        };
+      }
+      return null;
+    }
+  },
+  // Form library integrations
+  {
+    package: "@hookform/resolvers",
+    category: "form",
+    migrations: ["yup->zod", "joi->zod", "io-ts->zod", "zod-v3->v4"],
+    check: (_version, migration) => {
+      if (migration === "zod-v3->v4") {
+        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"
+        };
+      }
+      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"
+      };
+    }
+  },
+  {
+    package: "formik",
+    category: "form",
+    migrations: ["yup->zod", "joi->zod"],
+    check: () => ({
+      issue: "Formik has native Yup integration. Migrating to Zod requires a validation adapter or switching to React Hook Form.",
+      suggestion: "Consider switching from Formik to React Hook Form with zodResolver, as Formik is no longer actively maintained.",
+      severity: "warning"
+    })
+  },
+  {
+    package: "@mantine/form",
+    category: "form",
+    migrations: ["yup->zod", "joi->zod"],
+    check: () => ({
+      issue: "@mantine/form schema adapter will need updating after migration.",
+      suggestion: "Update @mantine/form validation to use the Zod adapter instead of the old library adapter.",
+      severity: "warning"
+    })
+  },
+  // OpenAPI integrations
+  {
+    package: "zod-openapi",
+    category: "openapi",
+    migrations: ["zod-v3->v4"],
+    check: () => ({
+      issue: "zod-openapi may not support Zod v4 yet.",
+      suggestion: "Check for a Zod v4-compatible version of zod-openapi.",
+      severity: "warning"
+    })
+  },
+  {
+    package: "@asteasolutions/zod-to-openapi",
+    category: "openapi",
+    migrations: ["zod-v3->v4"],
+    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"
+    })
+  }
+];
+var EcosystemAnalyzer = class {
+  analyze(projectPath, from, to) {
+    const migration = `${from}->${to}`;
+    const dependencies = [];
+    const warnings = [];
+    const blockers = [];
+    const pkgPath = join(projectPath, "package.json");
+    if (!existsSync(pkgPath)) {
+      return { dependencies, warnings, blockers };
+    }
+    let allDeps = {};
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    } catch {
+      return { dependencies, warnings, blockers };
+    }
+    for (const rule of ECOSYSTEM_RULES) {
+      if (!rule.migrations.includes(migration)) continue;
+      const installedVersion = allDeps[rule.package];
+      if (!installedVersion) continue;
+      const result = rule.check(installedVersion, migration);
+      if (!result) continue;
+      const issue = {
+        package: rule.package,
+        installedVersion,
+        migration,
+        issue: result.issue,
+        suggestion: result.suggestion,
+        severity: result.severity,
+        category: rule.category
+      };
+      dependencies.push(issue);
+      if (result.severity === "error") {
+        blockers.push(`${rule.package}@${installedVersion}: ${result.issue}`);
+      } else if (result.severity === "warning") {
+        warnings.push(`${rule.package}@${installedVersion}: ${result.issue}`);
+      }
+    }
+    return { dependencies, warnings, blockers };
+  }
+};
+
+// src/compatibility.ts
+var KNOWN_ISSUES = [
+  // Zod v3 -> v4 issues
+  {
+    library: "zod",
+    versionPattern: /^[~^]?3\./,
+    issue: "Zod v3 uses .errors property which is renamed to .issues in v4",
+    suggestion: "Use zod-v3->v4 migration path to handle API changes",
+    severity: "warning"
+  },
+  {
+    library: "zod",
+    versionPattern: /^[~^]?3\./,
+    issue: "z.record() key type behavior changed in v4",
+    suggestion: "Ensure z.record() calls explicitly specify key type",
+    severity: "info"
+  },
+  {
+    library: "zod",
+    versionPattern: /^[~^]?4\./,
+    issue: "Zod v4 detected \u2014 already on latest major version",
+    suggestion: "No migration needed for Zod version upgrades",
+    severity: "info"
+  },
+  // Yup issues
+  {
+    library: "yup",
+    versionPattern: /^[~^]?0\./,
+    issue: "Yup v0.x has different .transform() and .cast() behavior from v1.x",
+    suggestion: "Consider upgrading Yup to v1.x before migrating to Zod",
+    severity: "warning"
+  },
+  {
+    library: "yup",
+    versionPattern: /^[~^]?1\./,
+    issue: "Yup v1.x removed .transform() on mixed() and changed .cast() behavior",
+    suggestion: "Check for .transform() usage on mixed schemas \u2014 manual conversion may be needed",
+    severity: "info"
+  },
+  // Joi issues
+  {
+    library: "joi",
+    versionPattern: /^[~^]?17\./,
+    issue: "Joi v17 changed .pattern() semantics and deprecated .allow('')",
+    suggestion: "Review .pattern() and .allow() usages for v17-specific behavior",
+    severity: "info"
+  },
+  {
+    library: "joi",
+    versionPattern: /^[~^]?(1[0-6])\./,
+    issue: "Joi < v17 has significant API differences from modern versions",
+    suggestion: "Consider upgrading Joi before migrating to Zod",
+    severity: "warning"
+  },
+  // io-ts issues
+  {
+    library: "io-ts",
+    versionPattern: /^[~^]?2\./,
+    issue: "io-ts v2.x uses Either monad patterns requiring manual conversion",
+    suggestion: "fp-ts Either handling (isRight/isLeft) needs conversion to try/catch with Zod",
+    severity: "warning"
+  },
+  // Valibot issues
+  {
+    library: "valibot",
+    versionPattern: /^[~^]?0\./,
+    issue: "Valibot v0.x API may have breaking changes in v1.0",
+    suggestion: "Pin your Valibot version during migration to avoid API drift",
+    severity: "info"
+  }
+];
+var CompatibilityAnalyzer = class {
+  ecosystemAnalyzer = new EcosystemAnalyzer();
+  detectVersions(projectPath) {
+    const versions = [];
+    const pkgPath = join2(projectPath, "package.json");
+    if (!existsSync2(pkgPath)) return versions;
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      const knownLibs = ["zod", "yup", "joi", "io-ts", "valibot"];
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      for (const lib of knownLibs) {
+        const ver = allDeps[lib];
+        if (ver) {
+          versions.push({ library: lib, version: ver });
+        }
+      }
+    } catch {
+    }
+    return versions;
+  }
+  checkCompatibility(projectPath, from, to) {
+    const detectedVersions = this.detectVersions(projectPath);
+    const issues = [];
+    for (const detected of detectedVersions) {
+      for (const known of KNOWN_ISSUES) {
+        if (detected.library === known.library && known.versionPattern.test(detected.version)) {
+          issues.push({
+            library: detected.library,
+            detectedVersion: detected.version,
+            issue: known.issue,
+            suggestion: known.suggestion,
+            severity: known.severity
+          });
+        }
+      }
+    }
+    let ecosystemIssues = [];
+    if (from && to) {
+      const ecosystemReport = this.ecosystemAnalyzer.analyze(projectPath, from, to);
+      ecosystemIssues = ecosystemReport.dependencies;
+    }
+    const allIssues = [...issues.map((i) => i.severity), ...ecosystemIssues.map((i) => i.severity)];
+    const errorCount = allIssues.filter((s) => s === "error").length;
+    const warningCount = allIssues.filter((s) => s === "warning").length;
+    const overallScore = Math.max(0, 100 - errorCount * 30 - warningCount * 10);
+    return {
+      detectedVersions,
+      issues,
+      ecosystemIssues,
+      overallScore
+    };
+  }
+};
+
 // src/config.ts
 import { cosmiconfig } from "cosmiconfig";
+function validateConfig(config) {
+  const errors = [];
+  if (config.include && !Array.isArray(config.include)) {
+    errors.push('"include" must be an array of glob patterns');
+  }
+  if (config.exclude && !Array.isArray(config.exclude)) {
+    errors.push('"exclude" must be an array of glob patterns');
+  }
+  if (config.customRules) {
+    for (const [i, rule] of config.customRules.entries()) {
+      if (!rule.name) errors.push(`customRules[${i}]: "name" is required`);
+      if (!rule.match?.library) errors.push(`customRules[${i}]: "match.library" is required`);
+      if (!rule.match?.method) errors.push(`customRules[${i}]: "match.method" is required`);
+      if (!rule.transform?.method) errors.push(`customRules[${i}]: "transform.method" is required`);
+    }
+  }
+  if (config.suppressWarnings) {
+    for (const [i, rule] of config.suppressWarnings.entries()) {
+      if (!rule.code) errors.push(`suppressWarnings[${i}]: "code" is required`);
+      if (rule.files && !Array.isArray(rule.files)) {
+        errors.push(`suppressWarnings[${i}]: "files" must be an array`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function shouldSuppressWarning(warning, filePath, rules) {
+  for (const rule of rules) {
+    if (!warning.includes(rule.code)) continue;
+    if (!rule.files || rule.files.length === 0) return true;
+    if (rule.files.some((pattern) => filePath.includes(pattern))) return true;
+  }
+  return false;
+}
 async function loadConfig(configPath) {
   const explorer = cosmiconfig("schemashift", {
     searchPlaces: [
@@ -135,6 +708,725 @@ async function loadConfig(configPath) {
   };
 }
 
+// src/dependency-graph.ts
+var SchemaDependencyResolver = class {
+  resolve(project, filePaths) {
+    const fileSet = new Set(filePaths);
+    const dependencies = /* @__PURE__ */ new Map();
+    let crossFileRefs = 0;
+    for (const filePath of filePaths) {
+      const sourceFile = project.getSourceFile(filePath);
+      if (!sourceFile) continue;
+      const deps = this.findDependencies(sourceFile, fileSet);
+      dependencies.set(filePath, deps);
+      crossFileRefs += deps.length;
+    }
+    const circularWarnings = this.detectCycles(dependencies);
+    const sortedFiles = this.topologicalSort(filePaths, dependencies);
+    return {
+      sortedFiles,
+      dependencies,
+      circularWarnings,
+      crossFileRefs
+    };
+  }
+  findDependencies(sourceFile, fileSet) {
+    const deps = [];
+    const filePath = sourceFile.getFilePath();
+    for (const imp of sourceFile.getImportDeclarations()) {
+      const moduleSpecifier = imp.getModuleSpecifierValue();
+      if (!moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) continue;
+      const resolvedSourceFile = imp.getModuleSpecifierSourceFile();
+      if (!resolvedSourceFile) continue;
+      const resolvedPath = resolvedSourceFile.getFilePath();
+      if (resolvedPath === filePath) continue;
+      if (!fileSet.has(resolvedPath)) continue;
+      if (!deps.includes(resolvedPath)) {
+        deps.push(resolvedPath);
+      }
+    }
+    return deps;
+  }
+  detectCycles(dependencies) {
+    const warnings = [];
+    const visited = /* @__PURE__ */ new Set();
+    const inStack = /* @__PURE__ */ new Set();
+    const dfs = (node, path) => {
+      if (inStack.has(node)) {
+        const cycleStart = path.indexOf(node);
+        const cycle = path.slice(cycleStart).concat(node);
+        warnings.push(`Circular dependency: ${cycle.map(this.shortenPath).join(" -> ")}`);
+        return;
+      }
+      if (visited.has(node)) return;
+      visited.add(node);
+      inStack.add(node);
+      const deps = dependencies.get(node) || [];
+      for (const dep of deps) {
+        dfs(dep, [...path, node]);
+      }
+      inStack.delete(node);
+    };
+    for (const node of dependencies.keys()) {
+      dfs(node, []);
+    }
+    return warnings;
+  }
+  topologicalSort(filePaths, dependencies) {
+    const visited = /* @__PURE__ */ new Set();
+    const sorted = [];
+    const visit = (node) => {
+      if (visited.has(node)) return;
+      visited.add(node);
+      const deps = dependencies.get(node) || [];
+      for (const dep of deps) {
+        visit(dep);
+      }
+      sorted.push(node);
+    };
+    for (const filePath of filePaths) {
+      visit(filePath);
+    }
+    return sorted;
+  }
+  shortenPath(filePath) {
+    const parts = filePath.split("/");
+    return parts.slice(-2).join("/");
+  }
+};
+
+// src/detailed-analyzer.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+var COMPLEXITY_CHAIN_WEIGHT = 2;
+var COMPLEXITY_DEPTH_WEIGHT = 3;
+var COMPLEXITY_VALIDATION_WEIGHT = 1;
+var COMPLEXITY_MAX = 100;
+var COMPLEXITY_LOW_THRESHOLD = 25;
+var COMPLEXITY_MEDIUM_THRESHOLD = 50;
+var COMPLEXITY_HIGH_THRESHOLD = 75;
+var DetailedAnalyzer = class {
+  analyzeComplexity(analyzer) {
+    const complexities = [];
+    for (const sourceFile of analyzer.getProject().getSourceFiles()) {
+      const library = this.detectFileLibrary(sourceFile);
+      if (library === "unknown") continue;
+      for (const varDecl of sourceFile.getVariableDeclarations()) {
+        const initializer = varDecl.getInitializer();
+        if (!initializer) continue;
+        if (!this.isSchemaExpression(initializer, library)) continue;
+        const complexity = this.computeComplexity(varDecl, sourceFile, library);
+        complexities.push(complexity);
+      }
+    }
+    return complexities;
+  }
+  analyzeReadiness(schemas, from, to, supportedMethods) {
+    let supportedSchemas = 0;
+    const unsupportedPatterns = [];
+    for (const schema of schemas) {
+      if (schema.library !== from && schema.library !== "unknown") continue;
+      const methods = this.extractMethodNames(schema.code);
+      const unsupported = methods.filter((m) => !supportedMethods.has(m));
+      if (unsupported.length === 0) {
+        supportedSchemas++;
+      } else {
+        for (const m of unsupported) {
+          const pattern = `.${m}()`;
+          if (!unsupportedPatterns.includes(pattern)) {
+            unsupportedPatterns.push(pattern);
+          }
+        }
+      }
+    }
+    const totalSchemas = schemas.filter(
+      (s) => s.library === from || s.library === "unknown"
+    ).length;
+    const readinessPercent = totalSchemas > 0 ? Math.round(supportedSchemas / totalSchemas * 100) : 100;
+    const estimatedManualFixes = totalSchemas - supportedSchemas;
+    let riskLevel;
+    if (readinessPercent >= 90) riskLevel = "low";
+    else if (readinessPercent >= 70) riskLevel = "medium";
+    else if (readinessPercent >= 50) riskLevel = "high";
+    else riskLevel = "critical";
+    return {
+      from,
+      to,
+      totalSchemas,
+      supportedSchemas,
+      unsupportedPatterns,
+      estimatedManualFixes,
+      readinessPercent,
+      riskLevel
+    };
+  }
+  detectLibraryVersions(projectPath) {
+    const versions = [];
+    const pkgPath = join3(projectPath, "package.json");
+    if (!existsSync3(pkgPath)) return versions;
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+      const knownLibs = ["zod", "yup", "joi", "io-ts", "valibot"];
+      const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+      for (const lib of knownLibs) {
+        const ver = allDeps[lib];
+        if (ver) {
+          versions.push({ library: lib, version: ver });
+        }
+      }
+    } catch {
+    }
+    return versions;
+  }
+  generateDetailedResult(complexities, projectPath, readiness) {
+    const scores = complexities.map((c) => c.score);
+    const averageComplexity = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) : 0;
+    const maxComplexity = scores.length > 0 ? Math.max(...scores) : 0;
+    return {
+      complexities,
+      averageComplexity,
+      maxComplexity,
+      libraryVersions: this.detectLibraryVersions(projectPath),
+      readiness
+    };
+  }
+  computeComplexity(varDecl, sourceFile, library) {
+    const initializer = varDecl.getInitializer();
+    if (!initializer) {
+      return {
+        schemaName: varDecl.getName(),
+        filePath: sourceFile.getFilePath(),
+        library,
+        lineNumber: varDecl.getStartLineNumber(),
+        chainLength: 0,
+        nestedDepth: 0,
+        validationCount: 0,
+        score: 0,
+        level: "low"
+      };
+    }
+    const text = initializer.getText();
+    const chainLength = this.countChainLength(text);
+    const nestedDepth = this.countNestedDepth(text, library);
+    const validationCount = this.countValidations(text);
+    const rawScore = chainLength * COMPLEXITY_CHAIN_WEIGHT + nestedDepth * COMPLEXITY_DEPTH_WEIGHT + validationCount * COMPLEXITY_VALIDATION_WEIGHT;
+    const score = Math.min(COMPLEXITY_MAX, rawScore);
+    let level;
+    if (score <= COMPLEXITY_LOW_THRESHOLD) level = "low";
+    else if (score <= COMPLEXITY_MEDIUM_THRESHOLD) level = "medium";
+    else if (score <= COMPLEXITY_HIGH_THRESHOLD) level = "high";
+    else level = "critical";
+    return {
+      schemaName: varDecl.getName(),
+      filePath: sourceFile.getFilePath(),
+      library,
+      lineNumber: varDecl.getStartLineNumber(),
+      chainLength,
+      nestedDepth,
+      validationCount,
+      score,
+      level
+    };
+  }
+  countChainLength(text) {
+    const methodPattern = /\.\w+\(/g;
+    const matches = text.match(methodPattern);
+    return matches ? matches.length : 0;
+  }
+  countNestedDepth(text, library) {
+    const prefix = this.getLibraryPrefix(library);
+    if (!prefix) return 0;
+    const pattern = new RegExp(`\\b${this.escapeRegex(prefix)}\\.`, "g");
+    const matches = text.match(pattern);
+    return matches ? Math.max(0, matches.length - 1) : 0;
+  }
+  countValidations(text) {
+    const validationMethods = [
+      "min",
+      "max",
+      "email",
+      "url",
+      "uuid",
+      "regex",
+      "trim",
+      "length",
+      "positive",
+      "negative",
+      "int",
+      "integer",
+      "finite",
+      "nonnegative",
+      "nonpositive",
+      "required",
+      "optional",
+      "nullable",
+      "nullish",
+      "refine",
+      "superRefine",
+      "transform",
+      "nonempty",
+      "ip",
+      "cuid",
+      "startsWith",
+      "endsWith",
+      "includes",
+      "datetime",
+      "date"
+    ];
+    let count = 0;
+    for (const method of validationMethods) {
+      const pattern = new RegExp(`\\.${method}\\(`, "g");
+      const matches = text.match(pattern);
+      if (matches) count += matches.length;
+    }
+    return count;
+  }
+  extractMethodNames(code) {
+    const methodPattern = /\.(\w+)\(/g;
+    const methods = [];
+    for (const match of code.matchAll(methodPattern)) {
+      if (match[1]) methods.push(match[1]);
+    }
+    return methods;
+  }
+  getLibraryPrefix(library) {
+    switch (library) {
+      case "zod":
+      case "zod-v3":
+        return "z";
+      case "yup":
+        return "yup";
+      case "joi":
+        return "Joi";
+      case "io-ts":
+        return "t";
+      case "valibot":
+        return "v";
+      default:
+        return "";
+    }
+  }
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  detectFileLibrary(sourceFile) {
+    for (const imp of sourceFile.getImportDeclarations()) {
+      const lib = detectSchemaLibrary(imp.getModuleSpecifierValue());
+      if (lib !== "unknown") return lib;
+    }
+    return "unknown";
+  }
+  isSchemaExpression(node, library) {
+    const text = node.getText();
+    switch (library) {
+      case "zod":
+        return text.includes("z.") || text.includes("zod.");
+      case "yup":
+        return text.includes("yup.") || text.includes("Yup.");
+      case "joi":
+        return text.includes("Joi.") || text.includes("joi.");
+      case "io-ts":
+        return text.includes("t.") && node.getSourceFile().getText().includes("from 'io-ts'");
+      case "valibot":
+        return text.includes("v.") || text.includes("valibot.");
+      default:
+        return false;
+    }
+  }
+};
+
+// src/governance.ts
+var GovernanceEngine = class {
+  rules = /* @__PURE__ */ new Map();
+  configure(rules) {
+    this.rules.clear();
+    for (const [name, config] of Object.entries(rules)) {
+      if (config.enabled !== false) {
+        this.rules.set(name, config);
+      }
+    }
+  }
+  analyze(project) {
+    const violations = [];
+    let schemasChecked = 0;
+    let filesScanned = 0;
+    for (const sourceFile of project.getSourceFiles()) {
+      const library = this.detectFileLibrary(sourceFile);
+      if (library === "unknown") continue;
+      filesScanned++;
+      for (const varDecl of sourceFile.getVariableDeclarations()) {
+        const initializer = varDecl.getInitializer();
+        if (!initializer) continue;
+        const text = initializer.getText();
+        if (!this.isSchemaExpression(text, library)) continue;
+        schemasChecked++;
+        const filePath = sourceFile.getFilePath();
+        const lineNumber = varDecl.getStartLineNumber();
+        const schemaName = varDecl.getName();
+        if (this.rules.has("naming-convention")) {
+          const config = this.rules.get("naming-convention") ?? {};
+          const pattern = config.pattern || ".*Schema$";
+          if (!new RegExp(pattern).test(schemaName)) {
+            violations.push({
+              rule: "naming-convention",
+              message: `Schema "${schemaName}" does not match naming pattern: ${pattern}`,
+              filePath,
+              lineNumber,
+              schemaName,
+              severity: "warning",
+              fixable: true
+            });
+          }
+        }
+        if (this.rules.has("max-complexity")) {
+          const config = this.rules.get("max-complexity") ?? {};
+          const threshold = config.threshold ?? 80;
+          const chainLength = (text.match(/\.\w+\(/g) || []).length;
+          const complexity = chainLength * 5;
+          if (complexity > threshold) {
+            violations.push({
+              rule: "max-complexity",
+              message: `Schema "${schemaName}" exceeds complexity threshold (${complexity} > ${threshold})`,
+              filePath,
+              lineNumber,
+              schemaName,
+              severity: "warning",
+              fixable: false
+            });
+          }
+        }
+        if (this.rules.has("no-any")) {
+          if (text.includes(".any()")) {
+            violations.push({
+              rule: "no-any",
+              message: `Schema "${schemaName}" uses .any() \u2014 consider using a specific type`,
+              filePath,
+              lineNumber,
+              schemaName,
+              severity: "error",
+              fixable: false
+            });
+          }
+        }
+        if (this.rules.has("required-validations")) {
+          if (text.includes(".string()") && !text.includes(".max(")) {
+            violations.push({
+              rule: "required-validations",
+              message: `Schema "${schemaName}" has string() without .max() \u2014 consider adding a max length`,
+              filePath,
+              lineNumber,
+              schemaName,
+              severity: "warning",
+              fixable: true
+            });
+          }
+        }
+      }
+    }
+    return {
+      violations,
+      filesScanned,
+      schemasChecked,
+      passed: violations.filter((v) => v.severity === "error").length === 0
+    };
+  }
+  detectFileLibrary(sourceFile) {
+    for (const imp of sourceFile.getImportDeclarations()) {
+      const lib = detectSchemaLibrary(imp.getModuleSpecifierValue());
+      if (lib !== "unknown") return lib;
+    }
+    return "unknown";
+  }
+  isSchemaExpression(text, library) {
+    switch (library) {
+      case "zod":
+        return text.includes("z.") || text.includes("zod.");
+      case "yup":
+        return text.includes("yup.") || text.includes("Yup.");
+      case "joi":
+        return text.includes("Joi.") || text.includes("joi.");
+      case "io-ts":
+        return text.includes("t.");
+      case "valibot":
+        return text.includes("v.") || text.includes("valibot.");
+      default:
+        return false;
+    }
+  }
+};
+
+// src/incremental.ts
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { join as join4 } from "path";
+var STATE_DIR = ".schemashift";
+var STATE_FILE = "incremental.json";
+var IncrementalTracker = class {
+  stateDir;
+  statePath;
+  constructor(projectPath) {
+    this.stateDir = join4(projectPath, STATE_DIR);
+    this.statePath = join4(this.stateDir, STATE_FILE);
+  }
+  start(files, from, to) {
+    const state = {
+      migrationId: `incremental-${Date.now()}`,
+      from,
+      to,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      completedFiles: [],
+      remainingFiles: [...files],
+      failedFiles: []
+    };
+    this.saveState(state);
+    return state;
+  }
+  markComplete(filePath) {
+    const state = this.getState();
+    if (!state) return;
+    state.remainingFiles = state.remainingFiles.filter((f) => f !== filePath);
+    state.failedFiles = state.failedFiles.filter((f) => f !== filePath);
+    if (!state.completedFiles.includes(filePath)) {
+      state.completedFiles.push(filePath);
+    }
+    this.saveState(state);
+  }
+  markFailed(filePath) {
+    const state = this.getState();
+    if (!state) return;
+    state.remainingFiles = state.remainingFiles.filter((f) => f !== filePath);
+    if (!state.failedFiles.includes(filePath)) {
+      state.failedFiles.push(filePath);
+    }
+    this.saveState(state);
+  }
+  getState() {
+    if (!existsSync4(this.statePath)) return null;
+    try {
+      return JSON.parse(readFileSync4(this.statePath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  resume() {
+    return this.getState();
+  }
+  getNextBatch(batchSize) {
+    const state = this.getState();
+    if (!state) return [];
+    return state.remainingFiles.slice(0, batchSize);
+  }
+  getProgress() {
+    const state = this.getState();
+    if (!state) return null;
+    const total = state.completedFiles.length + state.remainingFiles.length + state.failedFiles.length;
+    const percent = total > 0 ? Math.round(state.completedFiles.length / total * 100) : 0;
+    return {
+      completed: state.completedFiles.length,
+      remaining: state.remainingFiles.length,
+      failed: state.failedFiles.length,
+      total,
+      percent
+    };
+  }
+  clear() {
+    if (existsSync4(this.statePath)) {
+      writeFileSync(this.statePath, "");
+    }
+  }
+  saveState(state) {
+    if (!existsSync4(this.stateDir)) {
+      mkdirSync(this.stateDir, { recursive: true });
+    }
+    writeFileSync(this.statePath, JSON.stringify(state, null, 2));
+  }
+};
+
+// src/package-updater.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
+var TARGET_VERSIONS = {
+  "yup->zod": { zod: "^3.24.0" },
+  "joi->zod": { zod: "^3.24.0" },
+  "io-ts->zod": { zod: "^3.24.0" },
+  "zod-v3->v4": { zod: "^4.0.0" },
+  "zod->valibot": { valibot: "^1.0.0" }
+};
+var SOURCE_PACKAGES = {
+  "yup->zod": ["yup"],
+  "joi->zod": ["joi", "@hapi/joi"],
+  "io-ts->zod": ["io-ts", "fp-ts"],
+  "zod->valibot": []
+  // zod might still be used elsewhere
+};
+var PackageUpdater = class {
+  plan(projectPath, from, to) {
+    const migration = `${from}->${to}`;
+    const add = {};
+    const remove = [];
+    const warnings = [];
+    const pkgPath = join5(projectPath, "package.json");
+    if (!existsSync5(pkgPath)) {
+      warnings.push("No package.json found. Cannot plan dependency updates.");
+      return { add, remove, warnings };
+    }
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    } catch {
+      warnings.push("Could not parse package.json.");
+      return { add, remove, warnings };
+    }
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const targets = TARGET_VERSIONS[migration];
+    if (targets) {
+      for (const [name, version] of Object.entries(targets)) {
+        const existing = allDeps[name];
+        if (!existing) {
+          add[name] = version;
+        } else if (migration === "zod-v3->v4") {
+          add[name] = version;
+          warnings.push(`zod will be updated from ${existing} to ${version}.`);
+        }
+      }
+    }
+    const sources = SOURCE_PACKAGES[migration];
+    if (sources) {
+      for (const src of sources) {
+        if (allDeps[src]) {
+          remove.push(src);
+          warnings.push(`${src} can be removed after verifying all schemas have been migrated.`);
+        }
+      }
+    }
+    return { add, remove, warnings };
+  }
+  apply(projectPath, plan) {
+    const pkgPath = join5(projectPath, "package.json");
+    if (!existsSync5(pkgPath)) return;
+    const pkgText = readFileSync5(pkgPath, "utf-8");
+    const pkg = JSON.parse(pkgText);
+    if (!pkg.dependencies) pkg.dependencies = {};
+    for (const [name, version] of Object.entries(plan.add)) {
+      if (pkg.devDependencies?.[name]) {
+        pkg.devDependencies[name] = version;
+      } else {
+        pkg.dependencies[name] = version;
+      }
+    }
+    writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`);
+  }
+};
+
+// src/plugin-loader.ts
+var PluginLoader = class {
+  async loadPlugins(pluginPaths) {
+    const loaded = [];
+    const errors = [];
+    for (const pluginPath of pluginPaths) {
+      try {
+        const mod = await import(pluginPath);
+        const plugin = mod.default || mod;
+        const validationError = this.validatePlugin(plugin, pluginPath);
+        if (validationError) {
+          errors.push(validationError);
+          continue;
+        }
+        loaded.push(plugin);
+      } catch (err) {
+        errors.push(
+          `Failed to load plugin ${pluginPath}: ${err instanceof Error ? err.message : "Unknown error"}`
+        );
+      }
+    }
+    return { loaded, errors };
+  }
+  validatePlugin(plugin, path) {
+    if (!plugin || typeof plugin !== "object") {
+      return `Plugin ${path}: must export an object`;
+    }
+    const p = plugin;
+    if (typeof p.name !== "string" || !p.name) {
+      return `Plugin ${path}: missing "name" property`;
+    }
+    if (typeof p.version !== "string" || !p.version) {
+      return `Plugin ${path}: missing "version" property`;
+    }
+    if (p.handlers && !Array.isArray(p.handlers)) {
+      return `Plugin ${path}: "handlers" must be an array`;
+    }
+    if (p.rules && !Array.isArray(p.rules)) {
+      return `Plugin ${path}: "rules" must be an array`;
+    }
+    return void 0;
+  }
+};
+
+// src/standard-schema.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
+var STANDARD_SCHEMA_LIBRARIES = {
+  zod: { minMajor: 3, minMinor: 23 },
+  // Zod v3.23+ and v4+
+  valibot: { minMajor: 1, minMinor: 0 },
+  // Valibot v1.0+
+  arktype: { minMajor: 2, minMinor: 0 },
+  // ArkType v2.0+
+  "@effect/schema": { minMajor: 0, minMinor: 0 },
+  // Effect Schema (any version)
+  typebox: { minMajor: 0, minMinor: 34 }
+  // TypeBox v0.34+
+};
+function parseVersion(version) {
+  const match = version.match(/(\d+)\.(\d+)/);
+  if (!match?.[1] || !match[2]) return null;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10)
+  };
+}
+function isVersionCompatible(version, minMajor, minMinor) {
+  const parsed = parseVersion(version);
+  if (!parsed) return false;
+  if (parsed.major > minMajor) return true;
+  if (parsed.major === minMajor && parsed.minor >= minMinor) return true;
+  return false;
+}
+function detectStandardSchema(projectPath) {
+  const pkgPath = join6(projectPath, "package.json");
+  if (!existsSync6(pkgPath)) {
+    return { detected: false, compatibleLibraries: [], recommendation: "" };
+  }
+  let allDeps = {};
+  try {
+    const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+    allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+  } catch {
+    return { detected: false, compatibleLibraries: [], recommendation: "" };
+  }
+  const hasExplicitStandardSchema = "@standard-schema/spec" in allDeps;
+  const compatibleLibraries = [];
+  for (const [lib, { minMajor, minMinor }] of Object.entries(STANDARD_SCHEMA_LIBRARIES)) {
+    const version = allDeps[lib];
+    if (version && isVersionCompatible(version, minMajor, minMinor)) {
+      compatibleLibraries.push({ name: lib, version });
+    }
+  }
+  const detected = hasExplicitStandardSchema || compatibleLibraries.length > 0;
+  let recommendation = "";
+  if (detected && compatibleLibraries.length > 1) {
+    recommendation = "Multiple Standard Schema-compatible libraries detected. These can interoperate through the Standard Schema interface, reducing the need for library-specific adapters in tools like tRPC, TanStack Form, and TanStack Router.";
+  } else if (detected && compatibleLibraries.length === 1) {
+    recommendation = `${compatibleLibraries[0]?.name} supports Standard Schema, enabling interoperability with ecosystem tools that adopt the Standard Schema interface (tRPC, TanStack Form, etc.).`;
+  } else if (hasExplicitStandardSchema) {
+    recommendation = "Standard Schema spec detected. Ensure your validation library supports Standard Schema for maximum interoperability.";
+  }
+  return { detected, compatibleLibraries, recommendation };
+}
+
 // src/transform.ts
 var TransformEngine = class {
   handlers = /* @__PURE__ */ new Map();
@@ -168,9 +1460,28 @@ var TransformEngine = class {
   }
 };
 export {
+  CompatibilityAnalyzer,
+  DetailedAnalyzer,
+  EcosystemAnalyzer,
+  GovernanceEngine,
+  IncrementalTracker,
+  MigrationChain,
+  PackageUpdater,
+  PluginLoader,
   SchemaAnalyzer,
+  SchemaDependencyResolver,
   TransformEngine,
+  buildCallChain,
+  detectFormLibraries,
   detectSchemaLibrary,
-  loadConfig
+  detectStandardSchema,
+  isInsideComment,
+  isInsideStringLiteral,
+  loadConfig,
+  parseCallChain,
+  shouldSuppressWarning,
+  startsWithBase,
+  transformMethodChain,
+  validateConfig
 };
 //# sourceMappingURL=index.js.map