@xylabs/ts-scripts-common 7.5.0 → 7.5.2

package/dist/actions/index.mjs

@@ -3488,24 +3488,24 @@ function packageLintMonorepo(fix2 = false) {
 
 // src/actions/packman/convert.ts
 import {
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   statSync as statSync3
 } from "fs";
-import PATH13 from "path";
-import chalk46 from "chalk";
+import PATH14 from "path";
+import chalk47 from "chalk";
 
 // src/actions/packman/convertToPnpm.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "fs";
-import PATH11 from "path";
-import chalk44 from "chalk";
+import PATH12 from "path";
+import chalk45 from "chalk";
 
 // src/actions/packman/rewriteScripts.ts
 function rewriteYarnToPnpm(script) {
@@ -3555,6 +3555,60 @@ function rewriteScriptsInPackageJson(pkg, direction) {
   return { ...pkg, scripts: rewritten };
 }
 
+// src/actions/packman/swapTsScriptsDependency.ts
+import {
+  existsSync as existsSync11,
+  readFileSync as readFileSync11,
+  writeFileSync as writeFileSync8
+} from "fs";
+import PATH11 from "path";
+import chalk44 from "chalk";
+var SWAP_MAP = {
+  "yarn-to-pnpm": [
+    ["@xylabs/ts-scripts-yarn3", "@xylabs/ts-scripts-pnpm"]
+  ],
+  "pnpm-to-yarn": [
+    ["@xylabs/ts-scripts-pnpm", "@xylabs/ts-scripts-yarn3"]
+  ]
+};
+function swapInPackageJson(pkgPath, direction) {
+  if (!existsSync11(pkgPath)) return false;
+  const raw = readFileSync11(pkgPath, "utf8");
+  const pkg = JSON.parse(raw);
+  let changed = false;
+  for (const depField of ["dependencies", "devDependencies"]) {
+    const deps = pkg[depField];
+    if (!deps) continue;
+    for (const [from, to] of SWAP_MAP[direction]) {
+      if (deps[from]) {
+        deps[to] = deps[from];
+        delete deps[from];
+        changed = true;
+      }
+    }
+  }
+  if (changed) {
+    writeFileSync8(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  }
+  return changed;
+}
+function swapTsScriptsDependency(cwd5, workspacePackageJsonPaths, direction) {
+  let count = 0;
+  if (swapInPackageJson(PATH11.join(cwd5, "package.json"), direction)) {
+    count++;
+  }
+  for (const pkgPath of workspacePackageJsonPaths) {
+    const fullPath = PATH11.resolve(cwd5, pkgPath, "package.json");
+    if (swapInPackageJson(fullPath, direction)) {
+      count++;
+    }
+  }
+  if (count > 0) {
+    const target = direction === "yarn-to-pnpm" ? "@xylabs/ts-scripts-pnpm" : "@xylabs/ts-scripts-yarn3";
+    console.log(chalk44.green(`  Swapped ts-scripts dependency to ${target} in ${count} package(s)`));
+  }
+}
+
 // src/actions/packman/convertToPnpm.ts
 var PNPM_VERSION = "10.12.1";
 function createPnpmWorkspaceYaml(cwd5, workspacePatterns) {
@@ -3562,24 +3616,45 @@ function createPnpmWorkspaceYaml(cwd5, workspacePatterns) {
   for (const pattern of workspacePatterns) {
     lines.push(`  - '${pattern}'`);
   }
-  writeFileSync8(PATH11.join(cwd5, "pnpm-workspace.yaml"), lines.join("\n") + "\n", "utf8");
-  console.log(chalk44.green("  Created pnpm-workspace.yaml"));
+  writeFileSync9(PATH12.join(cwd5, "pnpm-workspace.yaml"), lines.join("\n") + "\n", "utf8");
+  console.log(chalk45.green("  Created pnpm-workspace.yaml"));
+}
+function readPnpmWorkspacePatterns(cwd5) {
+  const wsPath = PATH12.join(cwd5, "pnpm-workspace.yaml");
+  if (!existsSync12(wsPath)) return [];
+  const content = readFileSync12(wsPath, "utf8");
+  const patterns = [];
+  const lines = content.split("\n");
+  let inPackages = false;
+  for (const line of lines) {
+    if (line.trim() === "packages:") {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages && /^\s+-\s+/.test(line)) {
+      const pattern = line.replace(/^\s+-\s+/, "").replaceAll(/['"]/g, "").trim();
+      if (pattern) patterns.push(pattern);
+    } else if (inPackages && !/^\s/.test(line) && line.trim()) {
+      inPackages = false;
+    }
+  }
+  return patterns;
 }
 function updateRootPackageJson(cwd5) {
-  const pkgPath = PATH11.join(cwd5, "package.json");
-  const pkg = JSON.parse(readFileSync11(pkgPath, "utf8"));
-  const workspacePatterns = pkg.workspaces ?? [];
+  const pkgPath = PATH12.join(cwd5, "package.json");
+  const pkg = JSON.parse(readFileSync12(pkgPath, "utf8"));
+  const workspacePatterns = pkg.workspaces ?? readPnpmWorkspacePatterns(cwd5);
   delete pkg.workspaces;
   pkg.packageManager = `pnpm@${PNPM_VERSION}`;
   const updated = rewriteScriptsInPackageJson(pkg, "yarn-to-pnpm");
-  writeFileSync8(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
-  console.log(chalk44.green("  Updated root package.json"));
+  writeFileSync9(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  console.log(chalk45.green("  Updated root package.json"));
   return workspacePatterns;
 }
 function updateGitignore(cwd5) {
-  const gitignorePath = PATH11.join(cwd5, ".gitignore");
-  if (!existsSync11(gitignorePath)) return;
-  let content = readFileSync11(gitignorePath, "utf8");
+  const gitignorePath = PATH12.join(cwd5, ".gitignore");
+  if (!existsSync12(gitignorePath)) return;
+  let content = readFileSync12(gitignorePath, "utf8");
   const yarnLines = [
     ".pnp.*",
     ".pnp",
@@ -3594,63 +3669,64 @@ function updateGitignore(cwd5) {
     content = content.replaceAll(new RegExp(String.raw`^${line.replaceAll(".", String.raw`\.`).replaceAll("*", String.raw`\*`).replaceAll("!", String.raw`\!`)}\s*$`, "gm"), "");
   }
   content = content.replaceAll(/\n{3,}/g, "\n\n");
-  writeFileSync8(gitignorePath, content, "utf8");
-  console.log(chalk44.green("  Updated .gitignore"));
+  writeFileSync9(gitignorePath, content, "utf8");
+  console.log(chalk45.green("  Updated .gitignore"));
 }
 function deleteYarnArtifacts(cwd5) {
-  const yarnLock = PATH11.join(cwd5, "yarn.lock");
-  const yarnrc = PATH11.join(cwd5, ".yarnrc.yml");
-  const yarnDir = PATH11.join(cwd5, ".yarn");
-  if (existsSync11(yarnLock)) {
+  const yarnLock = PATH12.join(cwd5, "yarn.lock");
+  const yarnrc = PATH12.join(cwd5, ".yarnrc.yml");
+  const yarnDir = PATH12.join(cwd5, ".yarn");
+  if (existsSync12(yarnLock)) {
     rmSync3(yarnLock);
-    console.log(chalk44.gray("  Deleted yarn.lock"));
+    console.log(chalk45.gray("  Deleted yarn.lock"));
   }
-  if (existsSync11(yarnrc)) {
+  if (existsSync12(yarnrc)) {
     rmSync3(yarnrc);
-    console.log(chalk44.gray("  Deleted .yarnrc.yml"));
+    console.log(chalk45.gray("  Deleted .yarnrc.yml"));
   }
-  if (existsSync11(yarnDir)) {
+  if (existsSync12(yarnDir)) {
     rmSync3(yarnDir, { force: true, recursive: true });
-    console.log(chalk44.gray("  Deleted .yarn/"));
+    console.log(chalk45.gray("  Deleted .yarn/"));
   }
 }
 function createNpmrc(cwd5) {
-  const npmrcPath = PATH11.join(cwd5, ".npmrc");
-  if (existsSync11(npmrcPath)) return;
-  mkdirSync5(PATH11.dirname(npmrcPath), { recursive: true });
-  writeFileSync8(npmrcPath, "", "utf8");
-  console.log(chalk44.green("  Created .npmrc"));
+  const npmrcPath = PATH12.join(cwd5, ".npmrc");
+  if (existsSync12(npmrcPath)) return;
+  mkdirSync5(PATH12.dirname(npmrcPath), { recursive: true });
+  writeFileSync9(npmrcPath, "", "utf8");
+  console.log(chalk45.green("  Created .npmrc"));
 }
 function convertToPnpm(cwd5, workspacePackageJsonPaths) {
-  console.log(chalk44.blue("\nConverting to pnpm...\n"));
+  console.log(chalk45.blue("\nConverting to pnpm...\n"));
   const workspacePatterns = updateRootPackageJson(cwd5);
   createPnpmWorkspaceYaml(cwd5, workspacePatterns);
   for (const pkgPath of workspacePackageJsonPaths) {
-    const fullPath = PATH11.resolve(cwd5, pkgPath, "package.json");
-    if (!existsSync11(fullPath)) continue;
-    const pkg = JSON.parse(readFileSync11(fullPath, "utf8"));
+    const fullPath = PATH12.resolve(cwd5, pkgPath, "package.json");
+    if (!existsSync12(fullPath)) continue;
+    const pkg = JSON.parse(readFileSync12(fullPath, "utf8"));
     const updated = rewriteScriptsInPackageJson(pkg, "yarn-to-pnpm");
     if (JSON.stringify(pkg) !== JSON.stringify(updated)) {
-      writeFileSync8(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+      writeFileSync9(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
     }
   }
-  console.log(chalk44.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
+  console.log(chalk45.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
   updateGitignore(cwd5);
   createNpmrc(cwd5);
+  swapTsScriptsDependency(cwd5, workspacePackageJsonPaths, "yarn-to-pnpm");
   deleteYarnArtifacts(cwd5);
-  console.log(chalk44.blue("\nConversion complete. Run `pnpm install` to generate pnpm-lock.yaml.\n"));
+  console.log(chalk45.blue("\nConversion complete. Run `pnpm install` to generate pnpm-lock.yaml.\n"));
   return 0;
 }
 
 // src/actions/packman/convertToYarn.ts
 import {
-  existsSync as existsSync12,
-  readFileSync as readFileSync12,
+  existsSync as existsSync13,
+  readFileSync as readFileSync13,
   rmSync as rmSync4,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
-import PATH12 from "path";
-import chalk45 from "chalk";
+import PATH13 from "path";
+import chalk46 from "chalk";
 var YARN_VERSION = "4.13.0";
 var YARNRC_TEMPLATE = `compressionLevel: mixed
 
@@ -3671,10 +3747,10 @@ var YARN_GITIGNORE_ENTRIES = `
 !.yarn/sdks
 !.yarn/versions
 `;
-function readPnpmWorkspacePatterns(cwd5) {
-  const wsPath = PATH12.join(cwd5, "pnpm-workspace.yaml");
-  if (!existsSync12(wsPath)) return [];
-  const content = readFileSync12(wsPath, "utf8");
+function readPnpmWorkspacePatterns2(cwd5) {
+  const wsPath = PATH13.join(cwd5, "pnpm-workspace.yaml");
+  if (!existsSync13(wsPath)) return [];
+  const content = readFileSync13(wsPath, "utf8");
   const patterns = [];
   const lines = content.split("\n");
   let inPackages = false;
@@ -3693,91 +3769,103 @@ function readPnpmWorkspacePatterns(cwd5) {
   return patterns;
 }
 function updateRootPackageJson2(cwd5, workspacePatterns) {
-  const pkgPath = PATH12.join(cwd5, "package.json");
-  const pkg = JSON.parse(readFileSync12(pkgPath, "utf8"));
+  const pkgPath = PATH13.join(cwd5, "package.json");
+  const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
   pkg.workspaces = workspacePatterns;
   pkg.packageManager = `yarn@${YARN_VERSION}`;
   const updated = rewriteScriptsInPackageJson(pkg, "pnpm-to-yarn");
-  writeFileSync9(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
-  console.log(chalk45.green("  Updated root package.json"));
+  writeFileSync10(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  console.log(chalk46.green("  Updated root package.json"));
 }
 function updateGitignore2(cwd5) {
-  const gitignorePath = PATH12.join(cwd5, ".gitignore");
-  let content = existsSync12(gitignorePath) ? readFileSync12(gitignorePath, "utf8") : "";
+  const gitignorePath = PATH13.join(cwd5, ".gitignore");
+  let content = existsSync13(gitignorePath) ? readFileSync13(gitignorePath, "utf8") : "";
   if (!content.includes(".yarn/*")) {
     content = content.trimEnd() + "\n" + YARN_GITIGNORE_ENTRIES;
   }
-  writeFileSync9(gitignorePath, content, "utf8");
-  console.log(chalk45.green("  Updated .gitignore"));
+  writeFileSync10(gitignorePath, content, "utf8");
+  console.log(chalk46.green("  Updated .gitignore"));
 }
 function deletePnpmArtifacts(cwd5) {
-  const lockfile = PATH12.join(cwd5, "pnpm-lock.yaml");
-  const workspaceYaml = PATH12.join(cwd5, "pnpm-workspace.yaml");
-  const npmrc = PATH12.join(cwd5, ".npmrc");
-  if (existsSync12(lockfile)) {
+  const lockfile = PATH13.join(cwd5, "pnpm-lock.yaml");
+  const workspaceYaml = PATH13.join(cwd5, "pnpm-workspace.yaml");
+  const npmrc = PATH13.join(cwd5, ".npmrc");
+  if (existsSync13(lockfile)) {
     rmSync4(lockfile);
-    console.log(chalk45.gray("  Deleted pnpm-lock.yaml"));
+    console.log(chalk46.gray("  Deleted pnpm-lock.yaml"));
   }
-  if (existsSync12(workspaceYaml)) {
+  if (existsSync13(workspaceYaml)) {
     rmSync4(workspaceYaml);
-    console.log(chalk45.gray("  Deleted pnpm-workspace.yaml"));
+    console.log(chalk46.gray("  Deleted pnpm-workspace.yaml"));
   }
-  if (existsSync12(npmrc)) {
-    const content = readFileSync12(npmrc, "utf8");
+  if (existsSync13(npmrc)) {
+    const content = readFileSync13(npmrc, "utf8");
     if (content.trim() === "" || content.includes("shamefully-hoist") || content.includes("node-linker")) {
       rmSync4(npmrc);
-      console.log(chalk45.gray("  Deleted .npmrc"));
+      console.log(chalk46.gray("  Deleted .npmrc"));
     }
   }
 }
 function createYarnrc(cwd5) {
-  const yarnrcPath = PATH12.join(cwd5, ".yarnrc.yml");
-  if (existsSync12(yarnrcPath)) return;
-  writeFileSync9(yarnrcPath, YARNRC_TEMPLATE, "utf8");
-  console.log(chalk45.green("  Created .yarnrc.yml"));
+  const yarnrcPath = PATH13.join(cwd5, ".yarnrc.yml");
+  if (existsSync13(yarnrcPath)) return;
+  writeFileSync10(yarnrcPath, YARNRC_TEMPLATE, "utf8");
+  console.log(chalk46.green("  Created .yarnrc.yml"));
+}
+function readWorkspacePatternsFromPackageJson(cwd5) {
+  const pkgPath = PATH13.join(cwd5, "package.json");
+  if (!existsSync13(pkgPath)) return [];
+  const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
+  return pkg.workspaces ?? [];
 }
 function convertToYarn(cwd5, workspacePackageJsonPaths) {
-  console.log(chalk45.blue("\nConverting to yarn...\n"));
-  const workspacePatterns = readPnpmWorkspacePatterns(cwd5);
+  console.log(chalk46.blue("\nConverting to yarn...\n"));
+  const workspacePatterns = readPnpmWorkspacePatterns2(cwd5);
   if (workspacePatterns.length === 0) {
-    console.warn(chalk45.yellow("  No workspace patterns found in pnpm-workspace.yaml"));
+    const fromPkg = readWorkspacePatternsFromPackageJson(cwd5);
+    if (fromPkg.length > 0) {
+      workspacePatterns.push(...fromPkg);
+    } else {
+      console.warn(chalk46.yellow("  No workspace patterns found"));
+    }
   }
   updateRootPackageJson2(cwd5, workspacePatterns);
   for (const pkgPath of workspacePackageJsonPaths) {
-    const fullPath = PATH12.resolve(cwd5, pkgPath, "package.json");
-    if (!existsSync12(fullPath)) continue;
-    const pkg = JSON.parse(readFileSync12(fullPath, "utf8"));
+    const fullPath = PATH13.resolve(cwd5, pkgPath, "package.json");
+    if (!existsSync13(fullPath)) continue;
+    const pkg = JSON.parse(readFileSync13(fullPath, "utf8"));
     const updated = rewriteScriptsInPackageJson(pkg, "pnpm-to-yarn");
     if (JSON.stringify(pkg) !== JSON.stringify(updated)) {
-      writeFileSync9(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+      writeFileSync10(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
     }
   }
-  console.log(chalk45.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
+  console.log(chalk46.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
   updateGitignore2(cwd5);
   createYarnrc(cwd5);
+  swapTsScriptsDependency(cwd5, workspacePackageJsonPaths, "pnpm-to-yarn");
   deletePnpmArtifacts(cwd5);
-  console.log(chalk45.blue("\nConversion complete. Run `corepack enable yarn && yarn set version stable && yarn install` to finish setup.\n"));
+  console.log(chalk46.blue("\nConversion complete. Run `corepack enable yarn && yarn set version stable && yarn install` to finish setup.\n"));
   return 0;
 }
 
 // src/actions/packman/convert.ts
 function detectCurrentPM(cwd5) {
-  if (existsSync13(PATH13.join(cwd5, "pnpm-lock.yaml")) || existsSync13(PATH13.join(cwd5, "pnpm-workspace.yaml"))) {
+  if (existsSync14(PATH14.join(cwd5, "pnpm-lock.yaml")) || existsSync14(PATH14.join(cwd5, "pnpm-workspace.yaml"))) {
     return "pnpm";
   }
-  if (existsSync13(PATH13.join(cwd5, "yarn.lock")) || existsSync13(PATH13.join(cwd5, ".yarnrc.yml"))) {
+  if (existsSync14(PATH14.join(cwd5, "yarn.lock")) || existsSync14(PATH14.join(cwd5, ".yarnrc.yml"))) {
     return "yarn";
   }
   return "unknown";
 }
 function findWorkspacePackagePaths(cwd5) {
-  const pkgPath = PATH13.join(cwd5, "package.json");
-  const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
+  const pkgPath = PATH14.join(cwd5, "package.json");
+  const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
   let patterns = pkg.workspaces ?? [];
   if (patterns.length === 0) {
-    const wsPath = PATH13.join(cwd5, "pnpm-workspace.yaml");
-    if (existsSync13(wsPath)) {
-      const content = readFileSync13(wsPath, "utf8");
+    const wsPath = PATH14.join(cwd5, "pnpm-workspace.yaml");
+    if (existsSync14(wsPath)) {
+      const content = readFileSync14(wsPath, "utf8");
       const lines = content.split("\n");
       let inPackages = false;
       for (const line of lines) {
@@ -3807,15 +3895,15 @@ function resolveWorkspaceGlob(cwd5, pattern) {
 }
 function walkGlob(basePath, parts, currentPath) {
   if (parts.length === 0) {
-    const fullPath = PATH13.join(basePath, currentPath);
-    if (existsSync13(PATH13.join(fullPath, "package.json"))) {
+    const fullPath = PATH14.join(basePath, currentPath);
+    if (existsSync14(PATH14.join(fullPath, "package.json"))) {
       return [currentPath];
     }
     return [];
   }
   const [part, ...rest] = parts;
-  const dirPath = PATH13.join(basePath, currentPath);
-  if (!existsSync13(dirPath) || !statSync3(dirPath).isDirectory()) {
+  const dirPath = PATH14.join(basePath, currentPath);
+  if (!existsSync14(dirPath) || !statSync3(dirPath).isDirectory()) {
     return [];
   }
   if (part === "*" || part === "**") {
@@ -3843,26 +3931,25 @@ function walkGlob(basePath, parts, currentPath) {
 function convert({ target, verbose }) {
   const validTargets = ["pnpm", "yarn"];
   if (!validTargets.includes(target)) {
-    console.error(chalk46.red(`Invalid target "${target}". Must be one of: ${validTargets.join(", ")}`));
+    console.error(chalk47.red(`Invalid target "${target}". Must be one of: ${validTargets.join(", ")}`));
     return 1;
   }
   const cwd5 = process.cwd();
   const currentPM = detectCurrentPM(cwd5);
   if (verbose) {
-    console.log(chalk46.gray(`Current package manager: ${currentPM}`));
-    console.log(chalk46.gray(`Target package manager: ${target}`));
+    console.log(chalk47.gray(`Current package manager: ${currentPM}`));
+    console.log(chalk47.gray(`Target package manager: ${target}`));
   }
   if (currentPM === target) {
-    console.error(chalk46.red(`Already using ${target}. No conversion needed.`));
-    return 1;
+    console.log(chalk47.yellow(`Already using ${target}. Re-applying conversion to fix any incomplete steps...`));
   }
   if (currentPM === "unknown") {
-    console.error(chalk46.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
+    console.error(chalk47.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
     return 1;
   }
   const workspacePaths = findWorkspacePackagePaths(cwd5);
   if (verbose) {
-    console.log(chalk46.gray(`Found ${workspacePaths.length} workspace packages`));
+    console.log(chalk47.gray(`Found ${workspacePaths.length} workspace packages`));
   }
   if (target === "pnpm") {
     return convertToPnpm(cwd5, workspacePaths);
@@ -3920,7 +4007,7 @@ var rebuild = ({ target }) => {
 };
 
 // src/actions/recompile.ts
-import chalk47 from "chalk";
+import chalk48 from "chalk";
 var recompile = async ({
   verbose,
   target,
@@ -3955,7 +4042,7 @@ var recompileAll = async ({
   const start = Date.now();
   const targetOptions = target ? ["-t", target] : [];
   if (jobs) {
-    console.log(chalk47.blue(`Jobs set to [${jobs}]`));
+    console.log(chalk48.blue(`Jobs set to [${jobs}]`));
   }
   const foreachOptions = {
     incremental,
@@ -3968,25 +4055,25 @@ var recompileAll = async ({
     pm.foreachWorkspace("package-compile", targetOptions, foreachOptions)
   ]);
   console.log(
-    `${chalk47.gray("Recompiled in")} [${chalk47.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk47.gray("seconds")}`
+    `${chalk48.gray("Recompiled in")} [${chalk48.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk48.gray("seconds")}`
   );
   return result;
 };
 
 // src/actions/relint.ts
-import chalk48 from "chalk";
+import chalk49 from "chalk";
 var relintPackage = ({
   pkg,
   fix: fix2,
   verbose
 }) => {
-  console.log(chalk48.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
+  console.log(chalk49.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
   const start = Date.now();
   const pm = getPackageManager();
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
     pm.runInWorkspace(pkg, fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint")
   ]);
-  console.log(chalk48.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk48.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk48.gray("seconds")}`));
+  console.log(chalk49.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk49.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk49.gray("seconds")}`));
   return result;
 };
 var relint = ({
@@ -4006,13 +4093,13 @@ var relint = ({
   });
 };
 var relintAllPackages = ({ fix: fix2 = false } = {}) => {
-  console.log(chalk48.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
+  console.log(chalk49.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
   const start = Date.now();
   const fixOptions = fix2 ? ["--fix"] : [];
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
     ["eslint", fixOptions]
   ]);
-  console.log(chalk48.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk48.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk48.gray("seconds")}`));
+  console.log(chalk49.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk49.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk49.gray("seconds")}`));
   return result;
 };
 
@@ -4038,10 +4125,10 @@ var sonar = () => {
 };
 
 // src/actions/statics.ts
-import chalk49 from "chalk";
+import chalk50 from "chalk";
 var DefaultDependencies = ["axios", "@xylabs/pixel", "react", "graphql", "react-router", "@mui/material", "@mui/system"];
 var statics = () => {
-  console.log(chalk49.green("Check Required Static Dependencies"));
+  console.log(chalk50.green("Check Required Static Dependencies"));
   const statics2 = parsedPackageJSON()?.xy?.deps?.statics;
   return detectDuplicateDependencies(statics2, DefaultDependencies);
 };