@reliverse/dler 1.7.152 → 2.0.0

package/bin/impl/migrate/codemods/commander-rempts.js

@@ -1,250 +0,0 @@
-import { glob } from "tinyglobby";
-import { ModuleKind, Node, Project, ScriptTarget, SyntaxKind } from "ts-morph";
-function parseCommanderFlags(flags) {
-  const parts = flags.split(/[\s,]+/).filter(Boolean);
-  let longName = "";
-  let shortName;
-  let takesValue = false;
-  for (const part of parts) {
-    if (part.startsWith("--")) {
-      longName = part.substring(2);
-    } else if (part.startsWith("-") && part.length === 2) {
-      shortName = part.substring(1);
-    }
-  }
-  if (flags.includes("<") || flags.includes("[")) {
-    takesValue = true;
-    longName = longName.replace(/[<[].*/, "").trim();
-  }
-  if (!longName && shortName) {
-    if (flags.includes(`<${shortName}>`)) takesValue = true;
-    longName = shortName;
-  }
-  if (!longName) {
-    throw new Error(`Could not parse flags: ${flags}`);
-  }
-  return { longName, shortName, takesValue };
-}
-function getDefaultValueText(node) {
-  if (!node) return;
-  if (Node.isLiteralExpression(node)) {
-    return node.getText();
-  }
-  if (Node.isIdentifier(node) || Node.isPropertyAccessExpression(node)) {
-    return node.getText();
-  }
-  if (Node.isCallExpression(node)) {
-    return node.getText();
-  }
-  if (Node.isPrefixUnaryExpression(node)) {
-    return node.getText();
-  }
-  console.warn(`Unhandled default value type: ${node.getKindName()}, text: ${node.getText()}`);
-  return node.getText();
-}
-async function transformCommand(varDecl, info, sourceFile) {
-  const commandName = info.commandName;
-  if (!commandName) {
-    console.warn("No command name found");
-    return;
-  }
-  let actionBodyText = "";
-  if (info.actionFunction) {
-    if (Node.isArrowFunction(info.actionFunction) || Node.isFunctionExpression(info.actionFunction) || Node.isFunctionDeclaration(info.actionFunction)) {
-      const body = info.actionFunction.getBody();
-      if (body) {
-        actionBodyText = body.getText();
-        if (Node.isBlock(body)) {
-          actionBodyText = actionBodyText.slice(1, -1).trim();
-        }
-      }
-    } else {
-      console.warn(`Unhandled action function type: ${info.actionFunction.getKindName()}`);
-    }
-  }
-  info.options.reverse();
-  if (info.actionFunctionParam) {
-    const paramRegex = new RegExp(`\\b${info.actionFunctionParam}\\b`, "g");
-    actionBodyText = actionBodyText.replace(paramRegex, "args");
-  }
-  const argsProperties = info.options.map((opt) => {
-    const defaultValueStr = opt.defaultValue ? `,
-      default: ${String(opt.defaultValue)}` : "";
-    const requiredStr = opt.required ? ",\n      required: true" : "";
-    return `    ${opt.name}: {
-      type: "${opt.type}",
-      description: "${opt.description}"${defaultValueStr}${requiredStr}
-    }`;
-  }).join(",\n");
-  const defineCommandText = `
-export const ${varDecl.getName()} = defineCommand({
-  meta: {
-    name: "${commandName}",
-    version: "${info.version || "1.0.0"}",
-    description: "${info.description || "Migrated from Commander"}",
-  },
-  args: {
-${argsProperties}
-  },
-  async run({ args }) {
-${actionBodyText}
-  },
-});
-// Add runMain at the end of the file
-await runMain(${varDecl.getName()});
-`;
-  varDecl.replaceWithText(defineCommandText);
-  if (info.actionFunction && Node.isIdentifier(info.actionFunction)) {
-    const funcName = info.actionFunction.getText();
-    const funcDecl = sourceFile.getFunction(funcName);
-    if (funcDecl) {
-      funcDecl.remove();
-    }
-  }
-  sourceFile.fixMissingImports();
-  await sourceFile.save();
-  console.log(`Transformed command in: ${sourceFile.getFilePath()}`);
-}
-function extractCommandInfo(node, sourceFile) {
-  const info = {
-    options: []
-  };
-  if (Node.isNewExpression(node)) {
-    const expr = node.getExpression();
-    if (expr && Node.isIdentifier(expr) && expr.getText() === "Command") {
-      const commandArg = node.getArguments()[0];
-      if (commandArg && Node.isStringLiteral(commandArg)) {
-        info.commandName = commandArg.getLiteralText();
-      }
-      return info;
-    }
-  }
-  if (Node.isCallExpression(node)) {
-    let tempExpr = node;
-    while (tempExpr && Node.isCallExpression(tempExpr)) {
-      const expression = tempExpr.getExpression();
-      if (Node.isPropertyAccessExpression(expression)) {
-        const methodName = expression.getName();
-        switch (methodName) {
-          case "action":
-            handleActionMethod(tempExpr, info, sourceFile);
-            break;
-          case "option":
-            handleOptionMethod(tempExpr, info);
-            break;
-          case "description":
-            handleDescriptionMethod(tempExpr, info);
-            break;
-          case "version":
-            handleVersionMethod(tempExpr, info);
-            break;
-        }
-      }
-      const parent = tempExpr.getParent();
-      tempExpr = Node.isCallExpression(parent) ? parent : void 0;
-    }
-    return info;
-  }
-  return;
-}
-function handleActionMethod(node, info, sourceFile) {
-  const [actionArg] = node.getArguments();
-  if (actionArg && Node.isIdentifier(actionArg)) {
-    const funcDef = sourceFile.getFunction(actionArg.getText()) || sourceFile.getVariableDeclaration(actionArg.getText())?.getInitializer();
-    if (funcDef && (Node.isArrowFunction(funcDef) || Node.isFunctionDeclaration(funcDef) || Node.isFunctionExpression(funcDef))) {
-      info.actionFunction = funcDef;
-      const firstParam = funcDef.getParameters()[0];
-      if (firstParam) {
-        info.actionFunctionParam = firstParam.getName();
-      }
-    }
-  }
-}
-function handleOptionMethod(node, info) {
-  const [flagsArg, descArg, defaultValueArg] = node.getArguments();
-  if (flagsArg && Node.isStringLiteral(flagsArg)) {
-    const { longName, shortName, takesValue } = parseCommanderFlags(flagsArg.getLiteralText());
-    info.options.push({
-      name: longName,
-      shortFlag: shortName,
-      type: takesValue ? "string" : "boolean",
-      description: Node.isStringLiteral(descArg) ? descArg.getLiteralText() : "TODO: Add description",
-      defaultValue: defaultValueArg ? getDefaultValueText(defaultValueArg) : void 0
-    });
-  }
-}
-function handleDescriptionMethod(node, info) {
-  const [descArg] = node.getArguments();
-  if (descArg && Node.isStringLiteral(descArg)) {
-    info.description = descArg.getLiteralText();
-  }
-}
-function handleVersionMethod(node, info) {
-  const [versionArg] = node.getArguments();
-  if (versionArg && Node.isStringLiteral(versionArg)) {
-    info.version = versionArg.getLiteralText();
-  }
-}
-export async function commanderToRempts(targetDirectory) {
-  if (!targetDirectory) {
-    throw new Error("Target directory is required");
-  }
-  const project = new Project({
-    compilerOptions: {
-      target: ScriptTarget.ESNext,
-      module: ModuleKind.ESNext,
-      esModuleInterop: true,
-      skipLibCheck: true
-    },
-    skipAddingFilesFromTsConfig: true
-  });
-  const filePaths = await glob(`${targetDirectory}/**/*.ts`, {
-    ignore: ["**/node_modules/**", "**/*.d.ts"],
-    absolute: true
-  });
-  for (const filePath of filePaths) {
-    console.log(`Processing: ${filePath}`);
-    project.addSourceFileAtPath(filePath);
-    try {
-      await transformFile(filePath, project);
-    } catch (error) {
-      console.error(`Error transforming file ${filePath}:`, error);
-    }
-  }
-  console.log("Migration completed successfully.");
-}
-async function transformFile(filePath, project) {
-  const sourceFile = project.getSourceFile(filePath);
-  if (!sourceFile) {
-    console.error(`Could not find source file: ${filePath}`);
-    return;
-  }
-  const commanderImport = sourceFile.getImportDeclaration("commander");
-  if (commanderImport) {
-    commanderImport.remove();
-  }
-  const remptsImport = sourceFile.getImportDeclaration("@reliverse/rempts");
-  const neededRemptsImports = ["defineCommand", "runMain"];
-  if (remptsImport) {
-    const existingNamedImports = remptsImport.getNamedImports().map((ni) => ni.getName());
-    for (const neededImport of neededRemptsImports) {
-      if (!existingNamedImports.includes(neededImport)) {
-        remptsImport.addNamedImport(neededImport);
-      }
-    }
-  } else {
-    sourceFile.addImportDeclaration({
-      moduleSpecifier: "@reliverse/rempts",
-      namedImports: neededRemptsImports
-    });
-  }
-  const variableDeclarations = sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration);
-  for (const varDecl of variableDeclarations) {
-    const initializer = varDecl.getInitializer();
-    if (!initializer) continue;
-    const commandInfo = extractCommandInfo(initializer, sourceFile);
-    if (commandInfo) {
-      await transformCommand(varDecl, commandInfo, sourceFile);
-    }
-  }
-}

package/bin/impl/migrate/codemods/console-relinka.d.ts

@@ -1,3 +0,0 @@
-type LogFormat = "console" | "consolaMethod" | "consolaObject" | "relinkaFunction" | "relinkaMethod" | "relinkaObject";
-export declare function consoleToRelinka(input?: string, from?: LogFormat, to?: LogFormat): Promise<void>;
-export {};

package/bin/impl/migrate/codemods/console-relinka.js

@@ -1,142 +0,0 @@
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { inputPrompt, selectPrompt } from "@reliverse/rempts";
-export async function consoleToRelinka(input, from, to) {
-  const finalInput = input ?? await inputPrompt({
-    title: "Enter input file or directory path",
-    placeholder: "e.g., src/**/*.ts"
-  });
-  const finalFrom = from ?? await selectPrompt({
-    title: "Select source format",
-    options: [
-      { label: "console", value: "console" },
-      { label: "consola method", value: "consolaMethod" },
-      { label: "consola object", value: "consolaObject" },
-      { label: "relinka function", value: "relinkaFunction" },
-      { label: "relinka method", value: "relinkaMethod" },
-      { label: "relinka object", value: "relinkaObject" }
-    ]
-  });
-  const finalTo = to ?? await selectPrompt({
-    title: "Select target format",
-    options: [
-      { label: "console", value: "console" },
-      { label: "consola method", value: "consolaMethod" },
-      { label: "consola object", value: "consolaObject" },
-      { label: "relinka function", value: "relinkaFunction" },
-      { label: "relinka method", value: "relinkaMethod" },
-      { label: "relinka object", value: "relinkaObject" }
-    ]
-  });
-  if (!finalInput || !finalFrom || !finalTo) {
-    relinka("error", "Missing required arguments for console-relinka migration");
-    return;
-  }
-  if (!await fs.pathExists(finalInput)) {
-    relinka("error", `\u274C Input path does not exist: ${finalInput}`);
-    return;
-  }
-  let content = await fs.readFile(finalInput, "utf8");
-  let changes = false;
-  const levels = [
-    "log",
-    "info",
-    "warn",
-    "error",
-    "debug",
-    "verbose",
-    "success",
-    "ready",
-    "start",
-    "box",
-    "trace"
-  ];
-  const getSourcePattern = (level, format) => {
-    switch (format) {
-      case "console":
-        return new RegExp(`console\\.${level}\\((.*?)(?:,\\s*(.*))?\\)`, "g");
-      case "consolaMethod":
-        if (level === "box") {
-          return /consola\.box\(\s*{\s*title:\s*"([^"]*)",\s*message:\s*"([^"]*)"\s*\}\s*\)/g;
-        }
-        return new RegExp(`consola\\.${level}\\((.*?)(?:,\\s*(.*))?\\)`, "g");
-      case "consolaObject":
-        return new RegExp(
-          `consola\\({level:\\s*"${level}",\\s*message:\\s*(.*?)(?:,\\s*title:\\s*"([^"]*)")?\\s*\\}\\)`,
-          "g"
-        );
-      case "relinkaFunction":
-        return new RegExp(`relinka\\("${level}",\\s*(.*?)(?:,\\s*(.*))?\\)`, "g");
-      case "relinkaMethod":
-        return new RegExp(`relinka\\.${level}\\((.*?)(?:,\\s*(.*))?\\)`, "g");
-      case "relinkaObject":
-        return new RegExp(
-          `relinka\\({level:\\s*"${level}",\\s*message:\\s*(.*?)(?:,\\s*title:\\s*"([^"]*)")?\\s*\\}\\)`,
-          "g"
-        );
-      default:
-        throw new Error(`Invalid source format: ${format}`);
-    }
-  };
-  const createReplacement = (level, message, title, args) => {
-    switch (finalTo) {
-      case "console":
-        return `console.${level}(${message}${args ? `, ${args}` : ""})`;
-      case "consolaMethod":
-        if (level === "box" && title) {
-          return `consola.box({ title: "${title}", message: "${message}" })`;
-        }
-        return `consola.${level}(${message}${args ? `, ${args}` : ""})`;
-      case "consolaObject": {
-        const obj = {
-          level: `"${level}"`,
-          message,
-          ...title && { title: `"${title}"` },
-          ...args && { args: `[${args}]` }
-        };
-        return `consola(${JSON.stringify(obj).replace(/"([^"]+)":/g, "$1:")})`;
-      }
-      case "relinkaFunction":
-        if (level === "box" && title) {
-          return `relinka("${level}", "${title}\\n${message}"${args ? `, ${args}` : ""})`;
-        }
-        return `relinka("${level}", ${message}${args ? `, ${args}` : ""})`;
-      case "relinkaMethod":
-        if (level === "box" && title) {
-          return `relinka.${level}("${title}\\n${message}"${args ? `, ${args}` : ""})`;
-        }
-        return `relinka.${level}(${message}${args ? `, ${args}` : ""})`;
-      case "relinkaObject": {
-        const obj = {
-          level: `"${level}"`,
-          message,
-          ...title && { title: `"${title}"` },
-          ...args && { args: `[${args}]` }
-        };
-        return `relinka(${JSON.stringify(obj).replace(/"([^"]+)":/g, "$1:")})`;
-      }
-      default:
-        throw new Error(`Invalid target format: ${finalTo}`);
-    }
-  };
-  for (const level of levels) {
-    const pattern = getSourcePattern(level, finalFrom);
-    const newContent = content.replace(pattern, (_, message, titleOrArgs, args) => {
-      changes = true;
-      if ((finalFrom === "consolaMethod" || finalFrom === "relinkaMethod") && level === "box") {
-        return createReplacement(level, message, titleOrArgs, args);
-      }
-      return createReplacement(level, message, void 0, titleOrArgs);
-    });
-    if (newContent !== content) {
-      content = newContent;
-      relinka("verbose", `\u2705 Converted ${level} calls from ${finalFrom} to ${finalTo} format`);
-    }
-  }
-  if (!changes) {
-    relinka("warn", "\u26A0\uFE0F No matching calls found to convert");
-  } else {
-    await fs.writeFile(finalInput, content, "utf8");
-    relinka("success", "\u2728 Successfully converted all logging calls to the target format");
-  }
-}

package/bin/impl/migrate/codemods/fs-relifso.d.ts

@@ -1,8 +0,0 @@
-interface MigrationResult {
-    file: string;
-    success: boolean;
-    message: string;
-    changes?: string[];
-}
-export declare function migrateFsToRelifso(dryRun?: boolean): Promise<MigrationResult[]>;
-export {};

package/bin/impl/migrate/codemods/fs-relifso.js

@@ -1,156 +0,0 @@
-import { existsSync } from "node:fs";
-import { readdir, readFile, stat, writeFile } from "node:fs/promises";
-import { extname, join } from "@reliverse/pathkit";
-async function getAllTsFiles(dir) {
-  const files = [];
-  try {
-    const entries = await readdir(dir);
-    for (const entry of entries) {
-      const fullPath = join(dir, entry);
-      const stats = await stat(fullPath);
-      if (stats.isDirectory() && !entry.startsWith(".") && entry !== "node_modules") {
-        const subFiles = await getAllTsFiles(fullPath);
-        files.push(...subFiles);
-      } else if (stats.isFile()) {
-        const ext = extname(entry);
-        if ([".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte"].includes(ext)) {
-          files.push(fullPath);
-        }
-      }
-    }
-  } catch {
-  }
-  return files;
-}
-export async function migrateFsToRelifso(dryRun = false) {
-  const results = [];
-  const files = await getAllTsFiles(".");
-  for (const file of files) {
-    try {
-      const content = await readFile(file, "utf8");
-      let modified = content;
-      const changes = [];
-      const nodeFsImportRegex = /import\s+(?:(\{[^}]*\})|(\w+))\s+from\s+["']node:fs["']/g;
-      if (nodeFsImportRegex.test(content)) {
-        modified = modified.replace(nodeFsImportRegex, (_match, namedExports, defaultExport) => {
-          if (namedExports) {
-            return `import ${namedExports} from "@reliverse/relifso"`;
-          }
-          return `import ${defaultExport} from "@reliverse/relifso"`;
-        });
-        changes.push("Updated node:fs imports to @reliverse/relifso");
-      }
-      const nodeFsPromisesImportRegex = /import\s+(?:(\{[^}]*\})|(\w+))\s+from\s+["']node:fs\/promises["']/g;
-      if (nodeFsPromisesImportRegex.test(content)) {
-        modified = modified.replace(
-          nodeFsPromisesImportRegex,
-          (_match, namedExports, defaultExport) => {
-            if (namedExports) {
-              return `import ${namedExports} from "@reliverse/relifso"`;
-            }
-            return `import ${defaultExport} from "@reliverse/relifso"`;
-          }
-        );
-        changes.push("Updated node:fs/promises imports to @reliverse/relifso");
-      }
-      const fsExtraImportRegex = /import\s+(?:(\{[^}]*\})|(\w+))\s+from\s+["']fs-extra["']/g;
-      if (fsExtraImportRegex.test(content)) {
-        modified = modified.replace(fsExtraImportRegex, (_match, namedExports, defaultExport) => {
-          if (namedExports) {
-            return `import ${namedExports} from "@reliverse/relifso"`;
-          }
-          return `import ${defaultExport} from "@reliverse/relifso"`;
-        });
-        changes.push("Updated fs-extra imports to @reliverse/relifso");
-      }
-      const nodeFsRequireRegex = /require\s*\(\s*["']node:fs["']\s*\)/g;
-      if (nodeFsRequireRegex.test(content)) {
-        modified = modified.replace(nodeFsRequireRegex, 'require("@reliverse/relifso")');
-        changes.push("Updated node:fs require to @reliverse/relifso");
-      }
-      const nodeFsPromisesRequireRegex = /require\s*\(\s*["']node:fs\/promises["']\s*\)/g;
-      if (nodeFsPromisesRequireRegex.test(content)) {
-        modified = modified.replace(nodeFsPromisesRequireRegex, 'require("@reliverse/relifso")');
-        changes.push("Updated node:fs/promises require to @reliverse/relifso");
-      }
-      const fsExtraRequireRegex = /require\s*\(\s*["']fs-extra["']\s*\)/g;
-      if (fsExtraRequireRegex.test(content)) {
-        modified = modified.replace(fsExtraRequireRegex, 'require("@reliverse/relifso")');
-        changes.push("Updated fs-extra require to @reliverse/relifso");
-      }
-      if (changes.length > 0) {
-        if (!dryRun) {
-          await writeFile(file, modified, "utf8");
-        }
-        results.push({
-          file,
-          success: true,
-          message: `${changes.length} change(s) made`,
-          changes
-        });
-      }
-    } catch (error) {
-      results.push({
-        file,
-        success: false,
-        message: `Failed to process: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-  }
-  await updatePackageJson(results, dryRun, {
-    remove: ["fs-extra"],
-    add: { "@reliverse/relifso": "^latest" }
-  });
-  return results;
-}
-async function updatePackageJson(results, dryRun, config) {
-  try {
-    const packageJsonPath = "./package.json";
-    if (existsSync(packageJsonPath)) {
-      const packageContent = await readFile(packageJsonPath, "utf8");
-      const packageJson = JSON.parse(packageContent);
-      let packageChanged = false;
-      const packageChanges = [];
-      for (const pkg of config.remove) {
-        if (packageJson.dependencies?.[pkg]) {
-          packageJson.dependencies = Object.fromEntries(
-            Object.entries(packageJson.dependencies).filter(([key]) => key !== pkg)
-          );
-          packageChanged = true;
-          packageChanges.push(`Removed ${pkg} from dependencies`);
-        }
-        if (packageJson.devDependencies?.[pkg]) {
-          packageJson.devDependencies = Object.fromEntries(
-            Object.entries(packageJson.devDependencies).filter(([key]) => key !== pkg)
-          );
-          packageChanged = true;
-          packageChanges.push(`Removed ${pkg} from devDependencies`);
-        }
-      }
-      for (const [pkg, version] of Object.entries(config.add)) {
-        if (packageChanged && !packageJson.dependencies?.[pkg]) {
-          if (!packageJson.dependencies) packageJson.dependencies = {};
-          packageJson.dependencies[pkg] = version;
-          packageChanges.push(`Added ${pkg} to dependencies`);
-        }
-      }
-      if (packageChanged) {
-        if (!dryRun) {
-          await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
-        }
-        results.push({
-          file: packageJsonPath,
-          success: true,
-          message: `${packageChanges.length} change(s) made`,
-          changes: packageChanges
-        });
-      }
-    }
-  } catch (error) {
-    results.push({
-      file: "./package.json",
-      success: false,
-      message: `Failed to update package.json: ${error instanceof Error ? error.message : String(error)}`
-    });
-  }
-}

package/bin/impl/migrate/codemods/monorepo-catalog.d.ts

@@ -1,96 +0,0 @@
-export interface MigrationResult {
-    package: string;
-    action: "added-to-catalog" | "replaced-with-catalog" | "restored-from-catalog" | "version-bumped";
-    oldVersion?: string;
-    newVersion?: string;
-    location: string;
-    packageJsonPath?: string;
-}
-export interface DependencyEntry {
-    name: string;
-    version: string;
-    locations: Set<string>;
-    packageJsonPath: string;
-    oldVersion?: string;
-}
-export interface CatalogMergeResult {
-    added: DependencyEntry[];
-    bumped: DependencyEntry[];
-    skipped: DependencyEntry[];
-}
-export interface PackageJson {
-    name?: string;
-    version?: string;
-    dependencies?: Record<string, string>;
-    devDependencies?: Record<string, string>;
-    peerDependencies?: Record<string, string>;
-    optionalDependencies?: Record<string, string>;
-    workspaces?: {
-        packages?: string[];
-        catalog?: Record<string, string>;
-        catalogs?: Record<string, Record<string, string>>;
-    } | string[];
-    catalog?: Record<string, string>;
-    catalogs?: Record<string, Record<string, string>>;
-    scripts?: Record<string, string>;
-}
-/**
- * Check if a dependency is a catalog reference (e.g., "catalog:", "catalog:foo")
- */
-export declare function isCatalogReference(versionSpec: string): boolean;
-/**
- * Check if a dependency is a workspace dependency (e.g., "workspace:*")
- */
-export declare function isWorkspaceDependency(versionSpec: string): boolean;
-/**
- * Check if a dependency is an npm alias (e.g., "npm:package-name@version")
- */
-export declare function isNpmAlias(versionSpec: string): boolean;
-/**
- * Check if a dependency should be skipped (non-semver or special specifier)
- */
-export declare function shouldSkipDependency(versionSpec: string): boolean;
-/**
- * Find all workspace package.json paths from root cwd. Supports workspaces array or { packages: [] }.
- */
-export declare function findWorkspacePackageJsons(cwd: string): Promise<string[]>;
-/**
- * Check if we're in a monorepo by detecting workspace configuration
- */
-export declare function isMonorepo(cwd: string): Promise<boolean>;
-/**
- * Extract dependencies from package.json (dependencies and devDependencies)
- */
-export declare function extractDependencies(packageJson: PackageJson, packageJsonPath: string): DependencyEntry[];
-/**
- * Merge dependencies into catalog, handling version conflicts intelligently
- */
-export declare function mergeToCatalog(existingCatalog: Record<string, string>, newDependencies: DependencyEntry[]): CatalogMergeResult;
-/**
- * Replace dependencies with catalog references in package.json
- */
-export declare function replaceDependenciesWithCatalogRefs(packageJsonPath: string, dependenciesToReplace: DependencyEntry[]): Promise<number>;
-/**
- * Restore catalog references to actual versions
- */
-export declare function restoreCatalogReferences(packageJsonPath: string, catalog: Record<string, string>): Promise<number>;
-/**
- * Update root package.json with catalog
- */
-export declare function updateRootWithCatalog(rootPackageJsonPath: string, catalog: Record<string, string>): Promise<void>;
-/**
- * Remove catalog from root package.json
- */
-export declare function removeCatalogFromRoot(rootPackageJsonPath: string): Promise<void>;
-/**
- * Migrate TO catalog: centralize dependencies to workspaces.catalog
- */
-export declare function migrateToCatalog(rootPath: string, dryRun?: boolean, interactive?: boolean): Promise<MigrationResult[]>;
-/**
- * Migrate FROM catalog: restore catalog references to actual versions
- */
-export declare function migrateFromCatalog(rootPath: string, removeCatalog?: boolean, dryRun?: boolean, interactive?: boolean): Promise<MigrationResult[]>;
-/**
- * Display migration results
- */
-export declare function displayMigrationResults(results: MigrationResult[]): void;