@xylabs/toolchain 7.10.0 → 7.10.1

package/dist/lib/index.mjs

@@ -483,15 +483,111 @@ function printWorkspaceCycles(cycles) {
   }
 }
 
+// src/lib/deprecationMigrate.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync4,
+  writeFileSync
+} from "fs";
+import PATH3 from "path";
+import { createInterface } from "readline";
+import chalk5 from "chalk";
+function findProjectRoot() {
+  return process.env.INIT_CWD ?? process.cwd();
+}
+function askYesNo(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase().startsWith("y"));
+    });
+  });
+}
+function replaceInFile(filePath, oldStr, newStr) {
+  if (!existsSync2(filePath)) return false;
+  const content = readFileSync4(filePath, "utf8");
+  if (!content.includes(oldStr)) return false;
+  writeFileSync(filePath, content.replaceAll(oldStr, newStr), "utf8");
+  return true;
+}
+function migrateRootPackageJson(pkg, pkgPath, oldPackage, depField) {
+  const version = pkg[depField][oldPackage];
+  delete pkg[depField][oldPackage];
+  pkg[depField]["@xylabs/toolchain"] = version;
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  console.warn(chalk5.green(`  \u2713 Replaced ${oldPackage} \u2192 @xylabs/toolchain in ${depField}`));
+}
+function migrateWorkspacePackageJson(wsPkgPath, dir, oldPackage) {
+  if (!existsSync2(wsPkgPath)) return;
+  const wsPkg = JSON.parse(readFileSync4(wsPkgPath, "utf8"));
+  let changed = false;
+  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+    if (wsPkg[field]?.[oldPackage]) {
+      const ver = wsPkg[field][oldPackage];
+      delete wsPkg[field][oldPackage];
+      wsPkg[field]["@xylabs/toolchain"] = ver;
+      changed = true;
+    }
+  }
+  if (changed) {
+    writeFileSync(wsPkgPath, `${JSON.stringify(wsPkg, null, 2)}
+`, "utf8");
+    console.warn(chalk5.green(`  \u2713 Updated ${dir}/package.json`));
+  }
+}
+async function migrateWorkspaces(root, workspacesGlob, oldPackage) {
+  if (!Array.isArray(workspacesGlob)) return;
+  const { globSync } = await import("glob");
+  for (const pattern of workspacesGlob) {
+    const dirs = globSync(pattern, { cwd: root });
+    for (const dir of dirs) {
+      if (replaceInFile(PATH3.join(root, dir, "xy.config.ts"), oldPackage, "@xylabs/toolchain")) {
+        console.warn(chalk5.green(`  \u2713 Updated ${dir}/xy.config.ts imports`));
+      }
+      migrateWorkspacePackageJson(PATH3.join(root, dir, "package.json"), dir, oldPackage);
+    }
+  }
+}
+function printManualInstructions(oldPackage) {
+  console.warn(chalk5.gray("  Skipped. To migrate manually:\n"));
+  console.warn(chalk5.gray(`    1. Replace "${oldPackage}" with "@xylabs/toolchain" in package.json`));
+  console.warn(chalk5.gray("    2. Update xy.config.ts imports"));
+  console.warn(chalk5.gray("    3. Run your package manager install\n"));
+}
+async function deprecationMigrate(oldPackage) {
+  const root = findProjectRoot();
+  const pkgPath = PATH3.join(root, "package.json");
+  if (!existsSync2(pkgPath)) return;
+  const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+  const depField = pkg.dependencies?.[oldPackage] ? "dependencies" : pkg.devDependencies?.[oldPackage] ? "devDependencies" : void 0;
+  if (!depField) return;
+  console.warn(chalk5.yellow(`
+\u26A0  ${oldPackage} is deprecated. Use @xylabs/toolchain instead.
+`));
+  const shouldMigrate = await askYesNo(chalk5.cyan("  Auto-migrate to @xylabs/toolchain? [y/N] "));
+  if (!shouldMigrate) {
+    printManualInstructions(oldPackage);
+    return;
+  }
+  migrateRootPackageJson(pkg, pkgPath, oldPackage, depField);
+  if (replaceInFile(PATH3.join(root, "xy.config.ts"), oldPackage, "@xylabs/toolchain")) {
+    console.warn(chalk5.green("  \u2713 Updated xy.config.ts imports"));
+  }
+  await migrateWorkspaces(root, pkg.workspaces, oldPackage);
+  console.warn(chalk5.yellow("\n  Run your package manager install to complete the migration.\n"));
+}
+
 // src/lib/file/constants.ts
 var WINDOWS_NEWLINE_REGEX = /\r\n/g;
 var CROSS_PLATFORM_NEWLINE = "\n";
 
 // src/lib/file/fileLines.ts
 import {
-  existsSync as existsSync2,
-  readFileSync as readFileSync4,
-  writeFileSync
+  existsSync as existsSync3,
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync2
 } from "fs";
 
 // src/lib/string/empty.ts
@@ -505,18 +601,18 @@ var union = (a, b) => /* @__PURE__ */ new Set([...new Set(a), ...new Set(b)]);
 var defaultReadFileSyncOptions = { encoding: "utf8" };
 
 // src/lib/file/fileLines.ts
-var readLines = (uri, options = defaultReadFileSyncOptions) => existsSync2(uri) ? readFileSync4(uri, options).replace(WINDOWS_NEWLINE_REGEX, CROSS_PLATFORM_NEWLINE).split(CROSS_PLATFORM_NEWLINE) : [];
+var readLines = (uri, options = defaultReadFileSyncOptions) => existsSync3(uri) ? readFileSync5(uri, options).replace(WINDOWS_NEWLINE_REGEX, CROSS_PLATFORM_NEWLINE).split(CROSS_PLATFORM_NEWLINE) : [];
 var readNonEmptyLines = (uri, options = defaultReadFileSyncOptions) => readLines(uri, options).filter(notEmpty);
 var writeLines = (uri, lines, options = defaultReadFileSyncOptions) => {
-  const existing = existsSync2(uri) ? readFileSync4(uri, options) : void 0;
+  const existing = existsSync3(uri) ? readFileSync5(uri, options) : void 0;
   const desired = lines.join(CROSS_PLATFORM_NEWLINE);
-  if (existing !== desired) writeFileSync(uri, desired, options);
+  if (existing !== desired) writeFileSync2(uri, desired, options);
 };
 
 // src/lib/file/tryReadFileSync.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
 var tryReadFileSync = (uri, options = defaultReadFileSyncOptions) => {
-  return existsSync3(uri) ? readFileSync5(uri, options) : void 0;
+  return existsSync4(uri) ? readFileSync6(uri, options) : void 0;
 };
 
 // src/lib/fillTemplate.ts
@@ -525,7 +621,7 @@ function fillTemplate(template, data) {
 }
 
 // src/lib/generateIgnoreFiles.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 
 // src/lib/initCwd.ts
 function INIT_CWD() {
@@ -536,7 +632,7 @@ function INIT_CWD() {
 var localeCompare = (a, b) => a.localeCompare(b);
 var mergeEntries = (a, b) => [...union(a, b)].toSorted(localeCompare);
 var generateIgnoreFiles = (filename, pkg) => {
-  console.log(chalk5.green(`Generate ${filename} Files`));
+  console.log(chalk6.green(`Generate ${filename} Files`));
   const cwd = INIT_CWD();
   const pm = getPackageManager();
   const singleWorkspace = pkg ? pm.findWorkspace(pkg) : void 0;
@@ -559,27 +655,27 @@ var generateIgnoreFiles = (filename, pkg) => {
 
 // src/lib/generateReadmeFiles.ts
 import { execFile } from "child_process";
-import FS, { readFileSync as readFileSync6 } from "fs";
+import FS, { readFileSync as readFileSync7 } from "fs";
 import {
   mkdir,
   readFile,
   writeFile
 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-import PATH3 from "path";
-import { createInterface } from "readline";
+import PATH4 from "path";
+import { createInterface as createInterface2 } from "readline";
 import { promisify } from "util";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 var execFileAsync = promisify(execFile);
 var require3 = createRequire2(import.meta.url);
-var packageRoot2 = PATH3.dirname(require3.resolve("@xylabs/ts-scripts-common/package.json"));
-var readmeTemplatesDir = PATH3.resolve(packageRoot2, "templates", "readme");
+var packageRoot2 = PATH4.dirname(require3.resolve("@xylabs/ts-scripts-common/package.json"));
+var readmeTemplatesDir = PATH4.resolve(packageRoot2, "templates", "readme");
 function fillReadmeTemplate(template, data) {
   const additionalData = { ...data, safeName: data.name.replaceAll("/", "__").replaceAll("@", "") };
   return fillTemplate(template, additionalData);
 }
 async function generateTypedoc(packageLocation, entryPoints) {
-  const tempDir = PATH3.join(packageLocation, ".temp-typedoc");
+  const tempDir = PATH4.join(packageLocation, ".temp-typedoc");
   try {
     if (!FS.existsSync(tempDir)) {
       FS.mkdirSync(tempDir, { recursive: true });
@@ -587,7 +683,7 @@ async function generateTypedoc(packageLocation, entryPoints) {
     const typedocConfig = {
       disableSources: true,
       entryPointStrategy: "expand",
-      entryPoints: entryPoints.map((ep) => PATH3.resolve(packageLocation, ep)),
+      entryPoints: entryPoints.map((ep) => PATH4.resolve(packageLocation, ep)),
       excludeExternals: true,
       excludeInternal: true,
       excludePrivate: true,
@@ -603,7 +699,7 @@ async function generateTypedoc(packageLocation, entryPoints) {
       theme: "markdown",
       useCodeBlocks: true
     };
-    const typedocJsonPath = PATH3.join(tempDir, "typedoc.json");
+    const typedocJsonPath = PATH4.join(tempDir, "typedoc.json");
     FS.writeFileSync(typedocJsonPath, JSON.stringify(typedocConfig, null, 2));
     try {
       await execFileAsync("npx", ["typedoc", "--options", typedocJsonPath], { cwd: process.cwd() });
@@ -622,7 +718,7 @@ async function generateTypedoc(packageLocation, entryPoints) {
 }
 function consolidateMarkdown(tempDir) {
   let consolidated = "## Reference\n\n";
-  const mainReadmePath = PATH3.join(tempDir, "README.md");
+  const mainReadmePath = PATH4.join(tempDir, "README.md");
   if (FS.existsSync(mainReadmePath)) {
     const mainContent = FS.readFileSync(mainReadmePath, "utf8").replace(/^---(.|\n)*?---\n/, "").replace(/^# .+\n/, "").replaceAll(/\]\((.+?)\.md\)/g, "](#$1)");
     consolidated += mainContent + "\n\n";
@@ -638,7 +734,7 @@ function processDirectory(dir, level = 0) {
     for (const item of items) {
       if (item.isDirectory()) continue;
       if (item.name === "README.md" || !item.name.endsWith(".md")) continue;
-      const fileContent = FS.readFileSync(PATH3.join(dir, item.name), "utf8").replace(/^---(.|\n)*?---\n/, "");
+      const fileContent = FS.readFileSync(PATH4.join(dir, item.name), "utf8").replace(/^---(.|\n)*?---\n/, "");
       const moduleName = item.name.replace(".md", "");
       content += `
 
@@ -654,14 +750,14 @@ ${indent}### <a id="${moduleName}"></a>${moduleName}
 
 ${indent}### ${item.name}
 `;
-      content += processDirectory(PATH3.join(dir, item.name), level + 1);
+      content += processDirectory(PATH4.join(dir, item.name), level + 1);
     }
   } catch {
   }
   return content;
 }
 function askConfirmation(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -669,8 +765,8 @@ function askConfirmation(question) {
     });
   });
 }
-var DEFAULT_README_TEMPLATE = readFileSync6(PATH3.resolve(readmeTemplatesDir, "README.template.md"), "utf8");
-var DEFAULT_README_BODY = readFileSync6(PATH3.resolve(readmeTemplatesDir, "README.body.md"), "utf8");
+var DEFAULT_README_TEMPLATE = readFileSync7(PATH4.resolve(readmeTemplatesDir, "README.template.md"), "utf8");
+var DEFAULT_README_BODY = readFileSync7(PATH4.resolve(readmeTemplatesDir, "README.body.md"), "utf8");
 function applyLogoConfig(template, logoUrl, logoLinkUrl) {
   let result = template;
   if (logoUrl) {
@@ -686,14 +782,14 @@ function applyLogoConfig(template, logoUrl, logoLinkUrl) {
 }
 function resolveTemplatePath(templatePath) {
   const cwd = INIT_CWD();
-  return templatePath ?? PATH3.join(cwd, ".xy", "README.template.md");
+  return templatePath ?? PATH4.join(cwd, ".xy", "README.template.md");
 }
 async function loadOrCreateTemplate(resolvedTemplatePath) {
   try {
     const template = await readFile(resolvedTemplatePath, "utf8");
     return { created: false, template };
   } catch {
-    console.log(chalk6.yellow(`Template not found: ${resolvedTemplatePath}`));
+    console.log(chalk7.yellow(`Template not found: ${resolvedTemplatePath}`));
     const shouldCreate = await askConfirmation("Would you like to create a stock template? (y/N) ");
     if (!shouldCreate) {
       throw new Error("Template creation declined");
@@ -704,16 +800,16 @@ async function loadOrCreateTemplate(resolvedTemplatePath) {
   }
 }
 async function scaffoldTemplate(resolvedTemplatePath, template) {
-  const xyDir = PATH3.dirname(resolvedTemplatePath);
+  const xyDir = PATH4.dirname(resolvedTemplatePath);
   await mkdir(xyDir, { recursive: true });
   await writeFile(resolvedTemplatePath, template);
-  console.log(chalk6.green(`Created template: ${resolvedTemplatePath}`));
-  const bodyPath = PATH3.join(xyDir, "README.body.md");
+  console.log(chalk7.green(`Created template: ${resolvedTemplatePath}`));
+  const bodyPath = PATH4.join(xyDir, "README.body.md");
   await writeFile(bodyPath, DEFAULT_README_BODY);
-  console.log(chalk6.green(`Created body template: ${bodyPath}`));
+  console.log(chalk7.green(`Created body template: ${bodyPath}`));
 }
 async function resolveBody(location, defaultBody) {
-  const localBodyPath = PATH3.join(location, "README.body.md");
+  const localBodyPath = PATH4.join(location, "README.body.md");
   try {
     return await readFile(localBodyPath, "utf8");
   } catch {
@@ -722,7 +818,7 @@ async function resolveBody(location, defaultBody) {
 }
 async function generateReadmeForWorkspace(location, name, template, defaultBody, typedoc, verbose, pm) {
   try {
-    const pkgJsonPath = PATH3.join(location, "package.json");
+    const pkgJsonPath = PATH4.join(location, "package.json");
     const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf8"));
     const body = await resolveBody(location, defaultBody);
     const typedocContent = typedoc ? await generateTypedoc(location, ["src/index*.ts"]) : "";
@@ -732,17 +828,17 @@ async function generateReadmeForWorkspace(location, name, template, defaultBody,
       pm,
       typedoc: typedocContent
     });
-    await writeFile(PATH3.join(location, "README.md"), readmeContent);
-    if (verbose) console.log(chalk6.green(`  ${name}`));
+    await writeFile(PATH4.join(location, "README.md"), readmeContent);
+    if (verbose) console.log(chalk7.green(`  ${name}`));
     return true;
   } catch (ex) {
     const error = ex;
-    console.warn(chalk6.yellow(`  Skipped ${location}: ${error.message}`));
+    console.warn(chalk7.yellow(`  Skipped ${location}: ${error.message}`));
     return false;
   }
 }
 async function loadDefaultBody(resolvedTemplatePath) {
-  const xyBodyPath = PATH3.join(PATH3.dirname(resolvedTemplatePath), "README.body.md");
+  const xyBodyPath = PATH4.join(PATH4.dirname(resolvedTemplatePath), "README.body.md");
   try {
     return await readFile(xyBodyPath, "utf8");
   } catch {
@@ -768,7 +864,7 @@ async function generateReadmeFiles({
   typedoc = false,
   verbose = false
 }) {
-  console.log(chalk6.green("Generate README Files"));
+  console.log(chalk7.green("Generate README Files"));
   const resolvedTemplatePath = resolveTemplatePath(templatePath);
   let template;
   let templateCreated;
@@ -779,7 +875,7 @@ async function generateReadmeFiles({
   }
   template = applyLogoConfig(template, logoUrl, logoLinkUrl);
   if (templateCreated) {
-    console.log(chalk6.green("Generating README files for all packages..."));
+    console.log(chalk7.green("Generating README files for all packages..."));
   }
   const defaultBody = await loadDefaultBody(resolvedTemplatePath);
   const pmName = detectPackageManager();
@@ -803,18 +899,18 @@ async function generateReadmeFiles({
   );
   const failed = flushResults(results);
   const ms = performance.now() - start;
-  console.log(chalk6.blue(`Generated ${workspaces.length} README(s) in ${ms.toFixed(0)}ms`));
+  console.log(chalk7.blue(`Generated ${workspaces.length} README(s) in ${ms.toFixed(0)}ms`));
   return failed ? 1 : 0;
 }
 
 // src/lib/gitignoreTemplate.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import PATH4 from "path";
+import PATH5 from "path";
 var require4 = createRequire3(import.meta.url);
-var packageRoot3 = PATH4.dirname(require4.resolve("@xylabs/ts-scripts-common/package.json"));
-var templatesDir2 = PATH4.resolve(packageRoot3, "templates", "gitignore");
-var gitignoreTemplate = () => readFileSync7(PATH4.resolve(templatesDir2, "template.gitignore"), "utf8");
+var packageRoot3 = PATH5.dirname(require4.resolve("@xylabs/ts-scripts-common/package.json"));
+var templatesDir2 = PATH5.resolve(packageRoot3, "templates", "gitignore");
+var gitignoreTemplate = () => readFileSync8(PATH5.resolve(templatesDir2, "template.gitignore"), "utf8");
 
 // src/lib/latestVersions.ts
 var latestVersions = {
@@ -826,7 +922,7 @@ var latestVersions = {
 };
 
 // src/lib/loadConfig.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import { cosmiconfig } from "cosmiconfig";
 import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
 import deepmerge from "deepmerge";
@@ -844,9 +940,9 @@ var loadConfig = async (params) => {
     rootConfigPath = cosmicConfigResult?.filepath;
     const configFilePath = cosmicConfigResult?.filepath;
     if (configFilePath !== void 0) {
-      console.log(chalk7.green(`Loaded config from ${configFilePath}`));
+      console.log(chalk8.green(`Loaded config from ${configFilePath}`));
       if (config.verbose) {
-        console.log(chalk7.gray(`${JSON.stringify(config, null, 2)}`));
+        console.log(chalk8.gray(`${JSON.stringify(config, null, 2)}`));
       }
     }
   }
@@ -876,7 +972,7 @@ function resolveCommandField(cfg, commandName, configPath) {
     const key = `${configPath ?? "unknown"}:${commandName}`;
     if (!deprecationWarned.has(key)) {
       deprecationWarned.add(key);
-      console.warn(chalk7.yellow(
+      console.warn(chalk8.yellow(
         `[xy] Deprecated: top-level "${commandName}" in ${configPath ?? "xy.config"} \u2014 move to "commands.${commandName}"`
       ));
     }
@@ -894,7 +990,7 @@ async function loadWorkspaceCommandConfig(workspaceDir, commandName) {
 }
 
 // src/lib/packageName.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import path from "path";
 function packageName() {
   if (process.env.npm_package_name) {
@@ -902,7 +998,7 @@ function packageName() {
   }
   try {
     const pkgPath = path.join(INIT_CWD(), "package.json");
-    const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
     return pkg.name;
   } catch {
     return void 0;
@@ -910,29 +1006,29 @@ function packageName() {
 }
 
 // src/lib/parsedPackageJSON.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 var parsedPackageJSON = (path2) => {
   const pathToPackageJSON = path2 ?? process.env.npm_package_json ?? "";
-  const packageJSON = readFileSync9(pathToPackageJSON).toString();
+  const packageJSON = readFileSync10(pathToPackageJSON).toString();
   return JSON.parse(packageJSON);
 };
 
 // src/lib/repoTemplates.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync10 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync11 } from "fs";
 import { createRequire as createRequire4 } from "module";
-import PATH5 from "path";
+import PATH6 from "path";
 var require5 = createRequire4(import.meta.url);
-var packageRoot4 = PATH5.dirname(require5.resolve("@xylabs/ts-scripts-common/package.json"));
-var repoTemplatesDir = PATH5.resolve(packageRoot4, "templates", "repo");
+var packageRoot4 = PATH6.dirname(require5.resolve("@xylabs/ts-scripts-common/package.json"));
+var repoTemplatesDir = PATH6.resolve(packageRoot4, "templates", "repo");
 function collectFiles(dir, prefix) {
   const results = [];
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      results.push(...collectFiles(PATH5.resolve(dir, entry.name), rel));
+      results.push(...collectFiles(PATH6.resolve(dir, entry.name), rel));
     } else {
       results.push({
-        content: readFileSync10(PATH5.resolve(dir, entry.name), "utf8"),
+        content: readFileSync11(PATH6.resolve(dir, entry.name), "utf8"),
         relativePath: rel
       });
     }
@@ -940,7 +1036,7 @@ function collectFiles(dir, prefix) {
   return results;
 }
 function loadRepoTemplateFiles(template, section) {
-  const dir = PATH5.resolve(repoTemplatesDir, template, section);
+  const dir = PATH6.resolve(repoTemplatesDir, template, section);
   return collectFiles(dir, "");
 }
 function listRepoTemplates() {
@@ -949,37 +1045,37 @@ function listRepoTemplates() {
 
 // src/lib/runInstall.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 function runInstall(cwd) {
   const pm = detectPackageManager();
-  console.log(chalk8.gray(`Running ${pm} install...`));
+  console.log(chalk9.gray(`Running ${pm} install...`));
   const result = spawnSync3(pm, ["install"], {
     cwd,
     stdio: "inherit"
   });
   if (result.status !== 0) {
-    console.warn(chalk8.yellow(`${pm} install failed`));
+    console.warn(chalk9.yellow(`${pm} install failed`));
     return false;
   }
-  console.log(chalk8.green("Dependencies installed"));
+  console.log(chalk9.green("Dependencies installed"));
   return true;
 }
 
 // src/lib/runSteps.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import chalk9 from "chalk";
+import { existsSync as existsSync5 } from "fs";
+import chalk10 from "chalk";
 var runSteps = (name, steps, exitOnFail = true, messages) => {
   return safeExit(() => {
     const pkgName = packageName();
-    console.log(chalk9.green(`${name} [${pkgName}]`));
+    console.log(chalk10.green(`${name} [${pkgName}]`));
     let totalStatus = 0;
     for (const [i, [command, args, config2]] of steps.entries()) {
       if (messages?.[i]) {
-        console.log(chalk9.gray(messages?.[i]));
+        console.log(chalk10.gray(messages?.[i]));
       }
       const argList = Array.isArray(args) ? args : args.split(" ");
-      if (command === "node" && !existsSync4(argList[0])) {
+      if (command === "node" && !existsSync5(argList[0])) {
         throw new Error(`File not found [${argList[0]}]`);
       }
       const status = spawnSync4(command, Array.isArray(args) ? args : args.split(" "), {
@@ -998,16 +1094,16 @@ var runSteps = (name, steps, exitOnFail = true, messages) => {
 
 // src/lib/runStepsAsync.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync5 } from "fs";
-import chalk10 from "chalk";
+import { existsSync as existsSync6 } from "fs";
+import chalk11 from "chalk";
 var runStepAsync = (name, step, exitOnFail = true, message) => {
   return new Promise((resolve) => {
     const [command, args, config2] = step;
     if (message) {
-      console.log(chalk10.gray(message));
+      console.log(chalk11.gray(message));
     }
     const argList = Array.isArray(args) ? args : args.split(" ");
-    if (command === "node" && !existsSync5(argList[0])) {
+    if (command === "node" && !existsSync6(argList[0])) {
       throw new Error(`File not found [${argList[0]}]`);
     }
     spawn(command, Array.isArray(args) ? args : args.split(" "), {
@@ -1018,8 +1114,8 @@ var runStepAsync = (name, step, exitOnFail = true, message) => {
     }).on("close", (code) => {
       if (code) {
         console.error(
-          chalk10.red(
-            `Command Exited With Non-Zero Result [${chalk10.gray(code)}] | ${chalk10.yellow(command)} ${chalk10.white(
+          chalk11.red(
+            `Command Exited With Non-Zero Result [${chalk11.gray(code)}] | ${chalk11.yellow(command)} ${chalk11.white(
               Array.isArray(args) ? args.join(" ") : args
             )}`
           )
@@ -1035,7 +1131,7 @@ var runStepAsync = (name, step, exitOnFail = true, message) => {
 var runStepsAsync = async (name, steps, exitOnFail = true, messages) => {
   return await safeExitAsync(async () => {
     const pkgName = packageName();
-    console.log(chalk10.green(`${name} [${pkgName}]`));
+    console.log(chalk11.green(`${name} [${pkgName}]`));
     let result = 0;
     for (const [i, step] of steps.entries()) {
       result += await runStepAsync(name, step, exitOnFail, messages?.[i]);
@@ -1054,33 +1150,33 @@ var runXy = (command) => {
 };
 
 // src/lib/runXyWithWarning.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 var runXyWithWarning = (command) => {
   const pm = getPackageManager();
   const commandString = `${pm.command} ${command}`;
   const commandXyString = `${pm.command} xy ${command}`;
-  console.warn(chalk11.yellow(`WARNING: [${chalk11.white(commandString)}] is deprecated for XY Labs Scripts.`));
-  console.warn(chalk11.gray(`Did you mean [${chalk11.magenta(commandXyString)}]?`));
+  console.warn(chalk12.yellow(`WARNING: [${chalk12.white(commandString)}] is deprecated for XY Labs Scripts.`));
+  console.warn(chalk12.gray(`Did you mean [${chalk12.magenta(commandXyString)}]?`));
   return 1;
 };
 
 // src/lib/tryRunLocalScript.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { readFileSync as readFileSync11 } from "fs";
-import PATH6 from "path";
-import chalk12 from "chalk";
+import { readFileSync as readFileSync12 } from "fs";
+import PATH7 from "path";
+import chalk13 from "chalk";
 function tryRunLocalScript(commandName) {
   if (process.env.XY_LOCAL_SCRIPT === "1") return void 0;
-  const rootPkgPath = PATH6.resolve(process.cwd(), "package.json");
+  const rootPkgPath = PATH7.resolve(process.cwd(), "package.json");
   let rootPkg;
   try {
-    rootPkg = JSON.parse(readFileSync11(rootPkgPath, "utf8"));
+    rootPkg = JSON.parse(readFileSync12(rootPkgPath, "utf8"));
   } catch {
     return void 0;
   }
   if (!rootPkg.scripts?.[commandName]) return void 0;
   const extraArgs = process.argv.slice(process.argv.indexOf(commandName) + 1);
-  console.log(chalk12.blue(`Delegating "${commandName}" to local script`));
+  console.log(chalk13.blue(`Delegating "${commandName}" to local script`));
   const pm = getPackageManager();
   const result = spawnSync5(pm.command, ["run", commandName, ...extraArgs], {
     cwd: process.cwd(),
@@ -1097,17 +1193,17 @@ function tryRunLocalScript(commandName) {
 }
 
 // src/lib/updo/applyUpdates.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync2 } from "fs";
-import PATH7 from "path";
-import chalk13 from "chalk";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync3 } from "fs";
+import PATH8 from "path";
+import chalk14 from "chalk";
 function applyUpdates(cwd, workspaces, updates) {
   const updateMap = new Map(updates.map((u) => [u.name, u]));
   let modified = 0;
   for (const ws of workspaces) {
-    const pkgPath = PATH7.resolve(cwd, ws.location, "package.json");
+    const pkgPath = PATH8.resolve(cwd, ws.location, "package.json");
     let content;
     try {
-      content = readFileSync12(pkgPath, "utf8");
+      content = readFileSync13(pkgPath, "utf8");
     } catch {
       continue;
     }
@@ -1128,26 +1224,26 @@ function applyUpdates(cwd, workspaces, updates) {
       }
     }
     if (changed) {
-      writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+      writeFileSync3(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `);
       modified++;
-      console.log(chalk13.gray(`  Updated ${ws.name}`));
+      console.log(chalk14.gray(`  Updated ${ws.name}`));
     }
   }
   return modified;
 }
 
 // src/lib/updo/collectWorkspaceDeps.ts
-import { readFileSync as readFileSync13 } from "fs";
-import PATH8 from "path";
+import { readFileSync as readFileSync14 } from "fs";
+import PATH9 from "path";
 var DEP_FIELDS = ["dependencies", "devDependencies", "peerDependencies"];
 function collectWorkspaceDeps(cwd, workspaces, workspaceNames) {
   const depMap = /* @__PURE__ */ new Map();
   for (const ws of workspaces) {
-    const pkgPath = PATH8.resolve(cwd, ws.location, "package.json");
+    const pkgPath = PATH9.resolve(cwd, ws.location, "package.json");
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
+      pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
     } catch {
       continue;
     }
@@ -1229,51 +1325,51 @@ import {
   useRef,
   useState
 } from "@inquirer/core";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import semver from "semver";
 function versionColor(version, current) {
-  if (!version || !current) return chalk14.gray;
-  if (version === current) return chalk14.gray;
+  if (!version || !current) return chalk15.gray;
+  if (version === current) return chalk15.gray;
   const diff = semver.diff(current, version);
-  if (diff === "major" || diff === "premajor") return chalk14.red;
-  if (diff === "minor" || diff === "preminor") return chalk14.yellow;
-  return chalk14.green;
+  if (diff === "major" || diff === "premajor") return chalk15.red;
+  if (diff === "minor" || diff === "preminor") return chalk15.yellow;
+  return chalk15.green;
 }
 function pad(raw, colored, width) {
   return colored + " ".repeat(Math.max(0, width - raw.length));
 }
 function dot(selected) {
-  return selected ? chalk14.green("\u25CF") : chalk14.dim("\u25CB");
+  return selected ? chalk15.green("\u25CF") : chalk15.dim("\u25CB");
 }
 function renderHeader(w) {
   const header = [
     "  ",
-    chalk14.bold("Package".padEnd(w.name)),
-    chalk14.bold("Current".padEnd(w.current)),
-    chalk14.bold("  Wanted".padEnd(w.wanted + 2)),
-    chalk14.bold("  Latest".padEnd(w.latest + 2)),
-    chalk14.bold("  Next/RC".padEnd(w.next + 2))
+    chalk15.bold("Package".padEnd(w.name)),
+    chalk15.bold("Current".padEnd(w.current)),
+    chalk15.bold("  Wanted".padEnd(w.wanted + 2)),
+    chalk15.bold("  Latest".padEnd(w.latest + 2)),
+    chalk15.bold("  Next/RC".padEnd(w.next + 2))
   ].join("  ");
   const totalWidth = w.name + w.current + w.wanted + w.latest + w.next + 24;
   return `${header}
-${chalk14.gray("\u2500".repeat(totalWidth))}`;
+${chalk15.gray("\u2500".repeat(totalWidth))}`;
 }
 function renderRow(dep, selection, active, w) {
-  const pointer = active ? chalk14.cyan("\u276F") : " ";
+  const pointer = active ? chalk15.cyan("\u276F") : " ";
   const rawName = dep.name;
-  const name = active ? chalk14.white(rawName) : chalk14.gray(rawName);
+  const name = active ? chalk15.white(rawName) : chalk15.gray(rawName);
   const rawCurrent = dep.current ?? "-";
-  const current = chalk14.gray(rawCurrent);
+  const current = chalk15.gray(rawCurrent);
   const rawWanted = dep.wanted ?? "-";
-  const wantedColorFn = dep.wanted ? versionColor(dep.wanted, dep.current) : chalk14.gray;
+  const wantedColorFn = dep.wanted ? versionColor(dep.wanted, dep.current) : chalk15.gray;
   const wantedDot = dep.wanted ? dot(selection === 0) : " ";
   const wanted = `${wantedDot} ${pad(rawWanted, wantedColorFn(rawWanted), w.wanted)}`;
   const rawLatest = dep.latest ?? "-";
-  const latestColorFn = dep.latest ? versionColor(dep.latest, dep.current) : chalk14.gray;
+  const latestColorFn = dep.latest ? versionColor(dep.latest, dep.current) : chalk15.gray;
   const latestDot = dep.latest ? dot(selection === 1) : " ";
   const latest = `${latestDot} ${pad(rawLatest, latestColorFn(rawLatest), w.latest)}`;
   const rawNext = dep.next ?? "-";
-  const nextColorFn = dep.next ? versionColor(dep.next, dep.current) : chalk14.gray;
+  const nextColorFn = dep.next ? versionColor(dep.next, dep.current) : chalk15.gray;
   const nextDot = dep.next ? dot(selection === 2) : " ";
   const next = `${nextDot} ${pad(rawNext, nextColorFn(rawNext), w.next)}`;
   return `${pointer} ${pad(rawName, name, w.name)}  ${pad(rawCurrent, current, w.current)}  ${wanted}  ${latest}  ${next}`;
@@ -1324,8 +1420,8 @@ function renderPage(rows, cursor, selections, w, pageSize) {
     lines.push(renderRow(rows[i], selections[i], i === cursor, w));
   }
   if (total > pageSize) {
-    if (start > 0) lines.unshift(chalk14.dim("  \u2191 more"));
-    if (end < total) lines.push(chalk14.dim("  \u2193 more"));
+    if (start > 0) lines.unshift(chalk15.dim("  \u2191 more"));
+    if (end < total) lines.push(chalk15.dim("  \u2193 more"));
   }
   return lines.join("\n");
 }
@@ -1374,7 +1470,7 @@ var updoPrompt = createPrompt((config2, done) => {
   const header = renderHeader(w);
   const page = renderPage(rows, cursor, selections.current, w, 20);
   const selectedCount = selections.current.filter((s) => s >= 0).length;
-  const status = chalk14.gray(`  ${selectedCount} selected  \u2191/\u2193 navigate  space cycle version  enter confirm`);
+  const status = chalk15.gray(`  ${selectedCount} selected  \u2191/\u2193 navigate  space cycle version  enter confirm`);
   return `${header}
 ${page}
 ${status}`;
@@ -1382,11 +1478,11 @@ ${status}`;
 async function interactiveSelect(deps) {
   const updatable = deps.filter((d) => d.updateAvailable);
   if (updatable.length === 0) {
-    console.log(chalk14.green("\nAll packages are up to date!"));
+    console.log(chalk15.green("\nAll packages are up to date!"));
     return [];
   }
   if (!process.stdout.isTTY) {
-    console.log(chalk14.yellow("Non-interactive environment detected, skipping selection."));
+    console.log(chalk15.yellow("Non-interactive environment detected, skipping selection."));
     return [];
   }
   try {
@@ -1400,24 +1496,24 @@ async function interactiveSelect(deps) {
 }
 
 // src/lib/updo/renderTable.ts
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 import semver2 from "semver";
 function versionColor2(version, current) {
-  if (!version || !current) return chalk15.gray(version ?? "-");
-  if (version === current) return chalk15.gray(version);
+  if (!version || !current) return chalk16.gray(version ?? "-");
+  if (version === current) return chalk16.gray(version);
   const diff = semver2.diff(current, version);
-  if (diff === "major" || diff === "premajor") return chalk15.red(version);
-  if (diff === "minor" || diff === "preminor") return chalk15.yellow(version);
-  return chalk15.green(version);
+  if (diff === "major" || diff === "premajor") return chalk16.red(version);
+  if (diff === "minor" || diff === "preminor") return chalk16.yellow(version);
+  return chalk16.green(version);
 }
 var columns = [
   {
-    color: (_v, dep) => dep.updateAvailable ? chalk15.white(dep.name) : chalk15.gray(dep.name),
+    color: (_v, dep) => dep.updateAvailable ? chalk16.white(dep.name) : chalk16.gray(dep.name),
     header: "Package",
     value: (dep) => dep.name
   },
   {
-    color: (_v, dep) => chalk15.gray(dep.current ?? "-"),
+    color: (_v, dep) => chalk16.gray(dep.current ?? "-"),
     header: "Current",
     value: (dep) => dep.current ?? "-"
   },
@@ -1437,7 +1533,7 @@ var columns = [
     value: (dep) => dep.next ?? "-"
   },
   {
-    color: (_v, dep) => chalk15.gray(dep.depTypes.join(", ")),
+    color: (_v, dep) => chalk16.gray(dep.depTypes.join(", ")),
     header: "Type",
     value: (dep) => dep.depTypes.join(", ")
   }
@@ -1445,7 +1541,7 @@ var columns = [
 function renderTable(deps) {
   const updatable = deps.filter((d) => d.updateAvailable);
   if (updatable.length === 0) {
-    console.log(chalk15.green("\nAll packages are up to date!"));
+    console.log(chalk16.green("\nAll packages are up to date!"));
     return;
   }
   const widths = columns.map((col) => {
@@ -1455,14 +1551,14 @@ function renderTable(deps) {
     }
     return Math.max(col.header.length, maxData);
   });
-  const header = columns.map((col, i) => chalk15.bold(col.header.padEnd(widths[i]))).join("  ");
+  const header = columns.map((col, i) => chalk16.bold(col.header.padEnd(widths[i]))).join("  ");
   console.log(`
 ${header}`);
   let totalWidth = -2;
   for (const w of widths) {
     totalWidth += w + 2;
   }
-  console.log(chalk15.gray("\u2500".repeat(totalWidth)));
+  console.log(chalk16.gray("\u2500".repeat(totalWidth)));
   for (const dep of updatable) {
     const row = columns.map((col, i) => {
       const raw = col.value(dep);
@@ -1522,29 +1618,29 @@ function resolveVersions(deps, registry, installedVersions) {
 }
 
 // src/lib/updo/runUpdo.ts
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 async function runUpdo(pm, _options = {}) {
   const cwd = INIT_CWD();
   const workspaces = pm.listWorkspaces();
   const workspaceNames = new Set(workspaces.map((ws) => ws.name));
-  console.log(chalk16.gray("Scanning workspace dependencies..."));
+  console.log(chalk17.gray("Scanning workspace dependencies..."));
   const declaredDeps = collectWorkspaceDeps(cwd, workspaces, workspaceNames);
-  console.log(chalk16.gray(`  Found ${declaredDeps.size} unique dependencies across ${workspaces.length} workspaces`));
-  console.log(chalk16.gray("Fetching registry info..."));
+  console.log(chalk17.gray(`  Found ${declaredDeps.size} unique dependencies across ${workspaces.length} workspaces`));
+  console.log(chalk17.gray("Fetching registry info..."));
   const registryInfo = await fetchAllRegistryInfo([...declaredDeps.keys()]);
-  console.log(chalk16.gray("Reading installed versions..."));
+  console.log(chalk17.gray("Reading installed versions..."));
   const installedVersions = pm.listInstalledVersions();
   const resolved = resolveVersions(declaredDeps, registryInfo, installedVersions);
   const updates = await interactiveSelect(resolved);
   if (updates.length === 0) {
-    console.log(chalk16.gray("No updates selected."));
+    console.log(chalk17.gray("No updates selected."));
     return 0;
   }
-  console.log(chalk16.gray(`
+  console.log(chalk17.gray(`
 Applying ${updates.length} updates...`));
   const modified = applyUpdates(cwd, workspaces, updates);
-  console.log(chalk16.gray(`  Modified ${modified} package.json files`));
-  console.log(chalk16.gray("Installing updated dependencies..."));
+  console.log(chalk17.gray(`  Modified ${modified} package.json files`));
+  console.log(chalk17.gray("Installing updated dependencies..."));
   return runSteps("Updo", [
     pm.install(),
     pm.dedupe()
@@ -1575,6 +1671,7 @@ export {
   defaultBuildConfig,
   defaultReadFileSyncOptions,
   deleteGlob,
+  deprecationMigrate,
   detectDuplicateDependencies,
   detectWorkspaceCycles,
   empty,