@xylabs/ts-scripts-yarn3 6.4.6 → 6.5.1

package/dist/index.mjs

@@ -371,8 +371,8 @@ var loadConfig = async (params) => {
 
 // src/lib/parsedPackageJSON.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-var parsedPackageJSON = (path9) => {
-  const pathToPackageJSON = path9 ?? process.env.npm_package_json ?? "";
+var parsedPackageJSON = (path10) => {
+  const pathToPackageJSON = path10 ?? process.env.npm_package_json ?? "";
   const packageJSON = readFileSync4(pathToPackageJSON).toString();
   return JSON.parse(packageJSON);
 };
@@ -747,12 +747,33 @@ var dead = () => {
   return runSteps("Dead", [["yarn", ["ts-prune", "-p", "tsconfig.json"]]]);
 };
 
-// src/actions/deplint.ts
+// src/actions/deplint/deplint.ts
+import chalk19 from "chalk";
+
+// src/actions/deplint/findFilesByGlob.ts
+import { globSync } from "glob";
+function findFilesByGlob(cwd4, pattern) {
+  return globSync(pattern, { cwd: cwd4, absolute: true });
+}
+
+// src/actions/deplint/findFiles.ts
+function findFiles(path10) {
+  const allSourceInclude = ["./src/**/*.{ts,tsx}", "./dist/**/*.d.ts"];
+  const prodExcludeEndswith = [".spec.ts", ".stories.tsx"];
+  const prodExcludeIncludes = ["/spec/", "/stories/", "/scripts/"];
+  const allSourceFiles = allSourceInclude.flatMap((pattern) => findFilesByGlob(path10, pattern));
+  const prodSourceFiles = allSourceFiles.filter((file) => !prodExcludeEndswith.some((ext) => file.endsWith(ext)) && !prodExcludeIncludes.some((excl) => file.includes(excl)));
+  const devSourceFiles = allSourceFiles.filter((file) => !prodSourceFiles.includes(file));
+  return {
+    allSourceFiles,
+    prodSourceFiles,
+    devSourceFiles
+  };
+}
+
+// src/actions/deplint/getDependenciesFromPackageJson.ts
 import fs2 from "node:fs";
 import path3 from "node:path";
-import chalk14 from "chalk";
-import { globSync } from "glob";
-import ts from "typescript";
 function getDependenciesFromPackageJson(packageJsonPath) {
   const packageJsonFullPath = path3.resolve(packageJsonPath);
   const rawContent = fs2.readFileSync(packageJsonFullPath, "utf8");
@@ -766,6 +787,13 @@ function getDependenciesFromPackageJson(packageJsonPath) {
     peerDependencies
   };
 }
+
+// src/actions/deplint/getImportsFromFile.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+import ts from "typescript";
+
+// src/actions/deplint/getBasePackageName.ts
 function getBasePackageName(importName) {
   if (importName.startsWith("@")) {
     const parts = importName.split("/");
@@ -773,10 +801,12 @@ function getBasePackageName(importName) {
   }
   return importName.split("/")[0];
 }
+
+// src/actions/deplint/getImportsFromFile.ts
 function getImportsFromFile(filePath, importPaths, typeImportPaths) {
-  const sourceCode = fs2.readFileSync(filePath, "utf8");
+  const sourceCode = fs3.readFileSync(filePath, "utf8");
   const sourceFile = ts.createSourceFile(
-    path3.basename(filePath),
+    path4.basename(filePath),
     sourceCode,
     ts.ScriptTarget.Latest,
     true
@@ -819,36 +849,26 @@ function getImportsFromFile(filePath, importPaths, typeImportPaths) {
   }
   return [cleanedImports, cleanedTypeImports];
 }
-function findFilesByGlob(cwd4, pattern) {
-  return globSync(pattern, { cwd: cwd4, absolute: true });
-}
-function findFiles(path9) {
-  const allSourceInclude = ["./src/**/*.{ts,tsx}", "./dist/**/*.d.ts"];
-  const prodExcludeEndswith = [".spec.ts", ".stories.tsx"];
-  const prodExcludeIncludes = ["/spec/", "/stories/", "/scripts/"];
-  const allSourceFiles = allSourceInclude.flatMap((pattern) => findFilesByGlob(path9, pattern));
-  const prodSourceFiles = allSourceFiles.filter((file) => !prodExcludeEndswith.some((ext) => file.endsWith(ext)) && !prodExcludeIncludes.some((excl) => file.includes(excl)));
-  const devSourceFiles = allSourceFiles.filter((file) => !prodSourceFiles.includes(file));
-  return {
-    allSourceFiles,
-    prodSourceFiles,
-    devSourceFiles
-  };
-}
+
+// src/actions/deplint/getExternalImportsFromFiles.ts
+var internalImportPrefixes = [".", "#", "node:"];
+var removeInternalImports = (imports) => {
+  return imports.filter((imp) => !internalImportPrefixes.some((prefix) => imp.startsWith(prefix)));
+};
 function getExternalImportsFromFiles({ prodSourceFiles, devSourceFiles }) {
   const prodImportPaths = {};
   const prodTypeImportPaths = {};
-  const prodImportPairs = prodSourceFiles.map((path9) => getImportsFromFile(path9, prodImportPaths, prodTypeImportPaths));
+  const prodImportPairs = prodSourceFiles.map((path10) => getImportsFromFile(path10, prodImportPaths, prodTypeImportPaths));
   const prodImports = prodImportPairs.flatMap((pair) => pair[0]);
   const prodTypeImports = prodImportPairs.flatMap((pair) => pair[1]);
   const devImportPaths = {};
   const devTypeImportPaths = {};
-  const devImportPairs = devSourceFiles.map((path9) => getImportsFromFile(path9, devImportPaths, devTypeImportPaths));
+  const devImportPairs = devSourceFiles.map((path10) => getImportsFromFile(path10, devImportPaths, devTypeImportPaths));
   const devImports = devImportPairs.flatMap((pair) => pair[0]);
   const devTypeImports = devImportPairs.flatMap((pair) => pair[1]);
-  const externalProdImports = prodImports.filter((imp) => !imp.startsWith(".") && !imp.startsWith("#") && !imp.startsWith("node:"));
-  const externalProdTypeImports = prodTypeImports.filter((imp) => !imp.startsWith(".") && !imp.startsWith("#") && !imp.startsWith("node:"));
-  const externalDevImports = devImports.filter((imp) => !imp.startsWith(".") && !imp.startsWith("#") && !imp.startsWith("node:"));
+  const externalProdImports = removeInternalImports(prodImports);
+  const externalProdTypeImports = removeInternalImports(prodTypeImports);
+  const externalDevImports = removeInternalImports(devImports);
   return {
     prodImports,
     devImports,
@@ -862,34 +882,40 @@ function getExternalImportsFromFiles({ prodSourceFiles, devSourceFiles }) {
     externalProdTypeImports
   };
 }
-function check({
-  name,
-  location,
-  devDeps = false,
-  peerDeps = false
+
+// src/actions/deplint/checkPackage/getTypesInDependencies.ts
+import chalk14 from "chalk";
+function getTypesInDependencies({ name, location }, { dependencies }, {}) {
+  let typesInDependencies = 0;
+  for (const dep of dependencies) {
+    if (dep.startsWith("@types/")) {
+      typesInDependencies++;
+      console.log(`[${chalk14.blue(name)}] @types in dependencies in package.json: ${chalk14.red(dep)}`);
+      console.log(`  ${location}/package.json
+`);
+      console.log("");
+    }
+  }
+  return typesInDependencies;
+}
+
+// src/actions/deplint/checkPackage/getUnlistedDependencies.ts
+import chalk15 from "chalk";
+function getUnlistedDependencies({ name }, {
+  dependencies,
+  devDependencies,
+  peerDependencies
+}, {
+  externalProdTypeImports,
+  prodTypeImportPaths,
+  externalProdImports,
+  prodImportPaths
 }) {
-  const { prodSourceFiles, devSourceFiles } = findFiles(location);
-  const {
-    prodTypeImportPaths,
-    prodImportPaths,
-    externalProdTypeImports,
-    devImportPaths,
-    externalProdImports,
-    externalDevImports
-  } = getExternalImportsFromFiles({ prodSourceFiles, devSourceFiles });
-  const {
-    dependencies,
-    devDependencies,
-    peerDependencies
-  } = getDependenciesFromPackageJson(`${location}/package.json`);
   let unlistedDependencies = 0;
-  let unlistedDevDependencies = 0;
-  let unusedDependencies = 0;
-  let typesInDependencies = 0;
   for (const imp of externalProdTypeImports) {
     if (!dependencies.includes(imp) && !peerDependencies.includes(imp) && !devDependencies.includes(imp) && !devDependencies.includes(`@types/${imp}`)) {
       unlistedDependencies++;
-      console.log(`[${chalk14.blue(name)}] Missing dependency in package.json: ${chalk14.red(imp)}`);
+      console.log(`[${chalk15.blue(name)}] Missing dependency in package.json: ${chalk15.red(imp)}`);
       console.log(`  ${prodTypeImportPaths[imp].join("\n")}`);
       console.log("");
     }
@@ -897,132 +923,237 @@ function check({
   for (const imp of externalProdImports) {
     if (!dependencies.includes(imp) && !peerDependencies.includes(imp)) {
       unlistedDependencies++;
-      console.log(`[${chalk14.blue(name)}] Missing dependency in package.json: ${chalk14.red(imp)}`);
+      console.log(`[${chalk15.blue(name)}] Missing dependency in package.json: ${chalk15.red(imp)}`);
       console.log(`  ${prodImportPaths[imp].join("\n")}`);
       console.log("");
     }
   }
+  return unlistedDependencies;
+}
+
+// src/actions/deplint/checkPackage/getUnlistedDevDependencies.ts
+import chalk16 from "chalk";
+function getUnlistedDevDependencies({ name }, { devDependencies }, { devImportPaths, externalDevImports }) {
+  let unlistedDevDependencies = 0;
+  for (const imp of externalDevImports) {
+    if (!devDependencies.includes(imp)) {
+      unlistedDevDependencies++;
+      console.log(`[${chalk16.blue(name)}] Missing devDependency in package.json: ${chalk16.red(imp)}`);
+      console.log(`  Found in: ${devImportPaths[imp].join(", ")}`);
+    }
+  }
+  return unlistedDevDependencies;
+}
+
+// src/actions/deplint/checkPackage/getUnusedDependencies.ts
+import chalk17 from "chalk";
+function getUnusedDependencies({ name, location }, { dependencies }, {
+  externalProdImports,
+  externalProdTypeImports
+}) {
+  let unusedDependencies = 0;
   for (const dep of dependencies) {
-    if (dep.startsWith("@types/")) {
-      typesInDependencies++;
-      console.log(`[${chalk14.blue(name)}] @types in dependencies in package.json: ${chalk14.red(dep)}`);
+    if (!externalProdImports.includes(dep) && !externalProdTypeImports.includes(dep)) {
+      unusedDependencies++;
+      console.log(`[${chalk17.blue(name)}] Unused dependency in package.json: ${chalk17.red(dep)}`);
       console.log(`  ${location}/package.json
 `);
       console.log("");
     }
-    if (!externalProdImports.includes(dep)) {
+  }
+  return unusedDependencies;
+}
+
+// src/actions/deplint/checkPackage/getUnusedPeerDependencies.ts
+import chalk18 from "chalk";
+function getUnusedPeerDependencies({ name, location }, { peerDependencies }, { externalProdImports, externalProdTypeImports }) {
+  let unusedDependencies = 0;
+  for (const dep of peerDependencies) {
+    if (!externalProdImports.includes(dep) && !externalProdTypeImports.includes(dep)) {
       unusedDependencies++;
-      console.log(`[${chalk14.blue(name)}] Unused dependency in package.json: ${chalk14.red(dep)}`);
+      console.log(`[${chalk18.blue(name)}] Unused peerDependency in package.json: ${chalk18.red(dep)}`);
       console.log(`  ${location}/package.json
 `);
       console.log("");
     }
   }
-  if (peerDeps) {
-    for (const dep of peerDependencies) {
-      if (!externalProdImports.includes(dep)) {
-        unusedDependencies++;
-        console.log(`[${chalk14.blue(name)}] Unused peerDependency in package.json: ${chalk14.red(dep)}`);
-        console.log(`  ${location}/package.json
-`);
-        console.log("");
-      }
-    }
-  }
-  if (devDeps) {
-    for (const imp of externalDevImports) {
-      if (!devDependencies.includes(imp)) {
-        unlistedDevDependencies++;
-        console.log(`[${chalk14.blue(name)}] Missing devDependency in package.json: ${chalk14.red(imp)}`);
-        console.log(`  Found in: ${devImportPaths[imp].join(", ")}`);
-      }
-    }
-  }
-  const totalErrors = unlistedDependencies + unlistedDevDependencies + unusedDependencies + typesInDependencies;
+  return unusedDependencies;
+}
+
+// src/actions/deplint/checkPackage/checkPackage.ts
+function checkPackage({
+  name,
+  location,
+  deps = false,
+  devDeps = false,
+  peerDeps = false
+}) {
+  const { prodSourceFiles, devSourceFiles } = findFiles(location);
+  const checkDeps = deps || !(deps || devDeps || peerDeps);
+  const checkDevDeps = devDeps || !(deps || devDeps || peerDeps);
+  const checkPeerDeps = peerDeps || !(deps || devDeps || peerDeps);
+  const sourceParams = getExternalImportsFromFiles({ prodSourceFiles, devSourceFiles });
+  const packageParams = getDependenciesFromPackageJson(`${location}/package.json`);
+  const unlistedDependencies = checkDeps ? getUnlistedDependencies({ name, location }, packageParams, sourceParams) : 0;
+  const unusedDependencies = checkDeps ? getUnusedDependencies({ name, location }, packageParams, sourceParams) : 0;
+  const typesInDependencies = checkDeps ? getTypesInDependencies({ name, location }, packageParams, sourceParams) : 0;
+  const unlistedDevDependencies = checkDevDeps ? getUnlistedDevDependencies({ name, location }, packageParams, sourceParams) : 0;
+  const unusedPeerDependencies = checkPeerDeps ? getUnusedPeerDependencies({ name, location }, packageParams, sourceParams) : 0;
+  const totalErrors = unlistedDependencies + unlistedDevDependencies + unusedDependencies + typesInDependencies + unusedPeerDependencies;
   return totalErrors;
 }
-var deplint = ({ pkg }) => {
+
+// src/actions/deplint/deplint.ts
+var deplint = ({
+  pkg,
+  deps,
+  devDeps,
+  peerDeps
+}) => {
   if (pkg) {
     const { location, name } = yarnWorkspace(pkg);
     console.log(`Running Deplint for ${name}`);
-    check({
+    checkPackage({
       name,
       location,
-      devDeps: true
+      devDeps,
+      deps,
+      peerDeps
     });
   } else {
     const workspaces = yarnWorkspaces();
     console.log("Deplint Started...");
     let totalErrors = 0;
     for (const workspace of workspaces) {
-      totalErrors += check(workspace);
+      totalErrors += checkPackage({
+        ...workspace,
+        deps,
+        devDeps,
+        peerDeps
+      });
     }
     if (totalErrors > 0) {
-      console.log(`Found ${chalk14.red(totalErrors)} unlisted imports.`);
+      console.log(`Deplint: Found ${chalk19.red(totalErrors)} dependency problems. ${chalk19.red("\u2716")}`);
     } else {
-      console.log(`No unlisted imports found. ${chalk14.green("\u2714")}`);
+      console.log(`Deplint: Found no dependency problems. ${chalk19.green("\u2714")}`);
     }
   }
   return 0;
 };
 
 // src/actions/deploy.ts
+import { readFileSync as readFileSync5 } from "node:fs";
+var privatePackageExcludeList = () => {
+  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
+    workspace,
+    JSON.parse(readFileSync5(`${workspace.location}/package.json`, { encoding: "utf8" }))
+  ]);
+  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
+  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
+  return excludeList;
+};
 var deploy = () => {
+  const excludeList = privatePackageExcludeList();
+  if (excludeList.length > 0) {
+    console.log("Excluding private packages from deployment:", excludeList);
+  }
   return runSteps("Deploy [Patch]", [
     ["yarn", "workspaces foreach --all version patch --deferred"],
     ["yarn", "xy clean"],
     ["yarn", "xy build"],
     ["yarn", "version apply --all"],
-    ["yarn", "workspaces foreach --all --parallel npm publish"]
+    ["yarn", `workspaces foreach --all ${excludeList.join(" ")} --parallel npm publish`]
   ]);
 };
 
 // src/actions/deploy-major.ts
+import { readFileSync as readFileSync6 } from "node:fs";
+var privatePackageExcludeList2 = () => {
+  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
+    workspace,
+    JSON.parse(readFileSync6(`${workspace.location}/package.json`, { encoding: "utf8" }))
+  ]);
+  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
+  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
+  return excludeList;
+};
 var deployMajor = () => {
+  const excludeList = privatePackageExcludeList2();
+  if (excludeList.length > 0) {
+    console.log("Excluding private packages from deployment:", excludeList);
+  }
   return runSteps("Deploy [Major]", [
     ["yarn", "workspaces foreach --all version major --deferred"],
     ["yarn", "xy clean"],
     ["yarn", "xy build"],
     ["yarn", "version apply --all"],
-    ["yarn", "workspaces foreach --all --parallel npm publish"]
+    ["yarn", `workspaces foreach --all ${excludeList.join(" ")} --parallel npm publish`]
   ]);
 };
 
 // src/actions/deploy-minor.ts
+import { readFileSync as readFileSync7 } from "node:fs";
+var privatePackageExcludeList3 = () => {
+  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
+    workspace,
+    JSON.parse(readFileSync7(`${workspace.location}/package.json`, { encoding: "utf8" }))
+  ]);
+  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
+  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
+  return excludeList;
+};
 var deployMinor = () => {
+  const excludeList = privatePackageExcludeList3();
+  if (excludeList.length > 0) {
+    console.log("Excluding private packages from deployment:", excludeList);
+  }
   return runSteps("Deploy [Minor]", [
     ["yarn", "workspaces foreach --all version minor --deferred"],
     ["yarn", "xy clean"],
     ["yarn", "xy build"],
     ["yarn", "version apply --all"],
-    ["yarn", "workspaces foreach --all --parallel npm publish"]
+    ["yarn", `workspaces foreach --all ${excludeList.join(" ")} --parallel npm publish`]
   ]);
 };
 
 // src/actions/deploy-next.ts
+import { readFileSync as readFileSync8 } from "node:fs";
+var privatePackageExcludeList4 = () => {
+  const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
+    workspace,
+    JSON.parse(readFileSync8(`${workspace.location}/package.json`, { encoding: "utf8" }))
+  ]);
+  const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
+  const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
+  return excludeList;
+};
 var deployNext = () => {
+  const excludeList = privatePackageExcludeList4();
+  if (excludeList.length > 0) {
+    console.log("Excluding private packages from deployment:", excludeList);
+  }
   return runSteps("Deploy [Next]", [
     ["yarn", "workspaces foreach --all version minor --deferred"],
     ["yarn", "xy clean"],
     ["yarn", "xy build"],
     ["yarn", "version apply --all --prerelease"],
-    ["yarn", "workspaces foreach --all --parallel npm publish --tag next"]
+    ["yarn", `workspaces foreach --all ${excludeList.join(" ")} --parallel npm publish --tag next`]
   ]);
 };
 
 // src/actions/dupdeps.ts
-import chalk15 from "chalk";
+import chalk20 from "chalk";
 var dupdeps = () => {
-  console.log(chalk15.green("Checking all Dependencies for Duplicates"));
+  console.log(chalk20.green("Checking all Dependencies for Duplicates"));
   const allDependencies = parsedPackageJSON()?.dependencies;
   const dependencies = Object.entries(allDependencies).map(([k]) => k);
   return detectDuplicateDependencies(dependencies);
 };
 
 // src/actions/lint.ts
-import chalk16 from "chalk";
+import chalk21 from "chalk";
 var lintPackage = ({ pkg, fix: fix2 }) => {
-  console.log(chalk16.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
+  console.log(chalk21.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
   const start = Date.now();
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
     ["yarn", [
@@ -1032,7 +1163,7 @@ var lintPackage = ({ pkg, fix: fix2 }) => {
       fix2 ? "package-fix" : "package-lint"
     ]]
   ]);
-  console.log(chalk16.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk16.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk16.gray("seconds")}`));
+  console.log(chalk21.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk21.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk21.gray("seconds")}`));
   return result;
 };
 var lint = ({
@@ -1048,13 +1179,13 @@ var lint = ({
   });
 };
 var lintAllPackages = ({ fix: fix2 = false } = {}) => {
-  console.log(chalk16.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
+  console.log(chalk21.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
   const start = Date.now();
   const fixOptions = fix2 ? ["--fix"] : [];
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
     ["yarn", ["eslint", ...fixOptions]]
   ]);
-  console.log(chalk16.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk16.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk16.gray("seconds")}`));
+  console.log(chalk21.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk21.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk21.gray("seconds")}`));
   return result;
 };
 
@@ -1082,7 +1213,7 @@ var filename = ".gitignore";
 var gitignoreGen = (pkg) => generateIgnoreFiles(filename, pkg);
 
 // src/actions/gitlint.ts
-import chalk17 from "chalk";
+import chalk22 from "chalk";
 import ParseGitConfig from "parse-git-config";
 var gitlint = () => {
   console.log(`
@@ -1093,7 +1224,7 @@ Gitlint Start [${process.cwd()}]
   const errors = 0;
   const gitConfig = ParseGitConfig.sync();
   const warn = (message) => {
-    console.warn(chalk17.yellow(`Warning: ${message}`));
+    console.warn(chalk22.yellow(`Warning: ${message}`));
     warnings++;
   };
   if (gitConfig.core.ignorecase) {
@@ -1113,13 +1244,13 @@ Gitlint Start [${process.cwd()}]
   }
   const resultMessages = [];
   if (valid > 0) {
-    resultMessages.push(chalk17.green(`Passed: ${valid}`));
+    resultMessages.push(chalk22.green(`Passed: ${valid}`));
   }
   if (warnings > 0) {
-    resultMessages.push(chalk17.yellow(`Warnings: ${warnings}`));
+    resultMessages.push(chalk22.yellow(`Warnings: ${warnings}`));
   }
   if (errors > 0) {
-    resultMessages.push(chalk17.red(` Errors: ${errors}`));
+    resultMessages.push(chalk22.red(` Errors: ${errors}`));
   }
   console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
 `);
@@ -1128,7 +1259,7 @@ Gitlint Start [${process.cwd()}]
 
 // src/actions/gitlint-fix.ts
 import { execSync as execSync2 } from "node:child_process";
-import chalk18 from "chalk";
+import chalk23 from "chalk";
 import ParseGitConfig2 from "parse-git-config";
 var gitlintFix = () => {
   console.log(`
@@ -1137,15 +1268,15 @@ Gitlint Fix Start [${process.cwd()}]
   const gitConfig = ParseGitConfig2.sync();
   if (gitConfig.core.ignorecase) {
     execSync2("git config core.ignorecase false", { stdio: "inherit" });
-    console.warn(chalk18.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+    console.warn(chalk23.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
   }
   if (gitConfig.core.autocrlf !== false) {
     execSync2("git config core.autocrlf false", { stdio: "inherit" });
-    console.warn(chalk18.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+    console.warn(chalk23.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
   }
   if (gitConfig.core.eol !== "lf") {
     execSync2("git config core.eol lf", { stdio: "inherit" });
-    console.warn(chalk18.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+    console.warn(chalk23.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
   }
   return 1;
 };
@@ -1156,7 +1287,7 @@ var knip = () => {
 };
 
 // src/actions/license.ts
-import chalk19 from "chalk";
+import chalk24 from "chalk";
 import { init } from "license-checker";
 var license = async (pkg) => {
   const workspaces = yarnWorkspaces();
@@ -1181,18 +1312,18 @@ var license = async (pkg) => {
     "LGPL-3.0-or-later",
     "Python-2.0"
   ]);
-  console.log(chalk19.green("License Checker"));
+  console.log(chalk24.green("License Checker"));
   return (await Promise.all(
     workspaceList.map(({ location, name }) => {
       return new Promise((resolve) => {
         init({ production: true, start: location }, (error, packages) => {
           if (error) {
-            console.error(chalk19.red(`License Checker [${name}] Error`));
-            console.error(chalk19.gray(error));
+            console.error(chalk24.red(`License Checker [${name}] Error`));
+            console.error(chalk24.gray(error));
             console.log("\n");
             resolve(1);
           } else {
-            console.log(chalk19.green(`License Checker [${name}]`));
+            console.log(chalk24.green(`License Checker [${name}]`));
             let count = 0;
             for (const [name2, info] of Object.entries(packages)) {
               const licenses = Array.isArray(info.licenses) ? info.licenses : [info.licenses];
@@ -1208,7 +1339,7 @@ var license = async (pkg) => {
                   }
                   if (!orLicenseFound) {
                     count++;
-                    console.warn(chalk19.yellow(`${name2}: Package License not allowed [${license2}]`));
+                    console.warn(chalk24.yellow(`${name2}: Package License not allowed [${license2}]`));
                   }
                 }
               }
@@ -1227,13 +1358,13 @@ var filename2 = ".npmignore";
 var npmignoreGen = (pkg) => generateIgnoreFiles(filename2, pkg);
 
 // src/actions/package/clean-outputs.ts
-import path4 from "node:path";
-import chalk20 from "chalk";
+import path5 from "node:path";
+import chalk25 from "chalk";
 var packageCleanOutputs = () => {
   const pkg = process.env.INIT_CWD ?? ".";
   const pkgName = process.env.npm_package_name;
-  const folders = [path4.join(pkg, "dist"), path4.join(pkg, "build"), path4.join(pkg, "docs")];
-  console.log(chalk20.green(`Cleaning Outputs [${pkgName}]`));
+  const folders = [path5.join(pkg, "dist"), path5.join(pkg, "build"), path5.join(pkg, "docs")];
+  console.log(chalk25.green(`Cleaning Outputs [${pkgName}]`));
   for (let folder of folders) {
     deleteGlob(folder);
   }
@@ -1241,13 +1372,13 @@ var packageCleanOutputs = () => {
 };
 
 // src/actions/package/clean-typescript.ts
-import path5 from "node:path";
-import chalk21 from "chalk";
+import path6 from "node:path";
+import chalk26 from "chalk";
 var packageCleanTypescript = () => {
   const pkg = process.env.INIT_CWD ?? ".";
   const pkgName = process.env.npm_package_name;
-  console.log(chalk21.green(`Cleaning Typescript [${pkgName}]`));
-  const files = [path5.join(pkg, "*.tsbuildinfo"), path5.join(pkg, ".tsconfig.*"), path5.join(pkg, ".eslintcache")];
+  console.log(chalk26.green(`Cleaning Typescript [${pkgName}]`));
+  const files = [path6.join(pkg, "*.tsbuildinfo"), path6.join(pkg, ".tsconfig.*"), path6.join(pkg, ".eslintcache")];
   for (let file of files) {
     deleteGlob(file);
   }
@@ -1260,19 +1391,19 @@ var packageClean = async () => {
 };
 
 // src/actions/package/compile/compile.ts
-import chalk25 from "chalk";
+import chalk30 from "chalk";
 
 // src/actions/package/publint.ts
-import { promises as fs3 } from "node:fs";
-import chalk22 from "chalk";
+import { promises as fs4 } from "node:fs";
+import chalk27 from "chalk";
 import sortPackageJson from "sort-package-json";
 var packagePublint = async (params) => {
   const pkgDir = process.env.INIT_CWD;
-  const sortedPkg = sortPackageJson(await fs3.readFile(`${pkgDir}/package.json`, "utf8"));
-  await fs3.writeFile(`${pkgDir}/package.json`, sortedPkg);
-  const pkg = JSON.parse(await fs3.readFile(`${pkgDir}/package.json`, "utf8"));
-  console.log(chalk22.green(`Publint: ${pkg.name}`));
-  console.log(chalk22.gray(pkgDir));
+  const sortedPkg = sortPackageJson(await fs4.readFile(`${pkgDir}/package.json`, "utf8"));
+  await fs4.writeFile(`${pkgDir}/package.json`, sortedPkg);
+  const pkg = JSON.parse(await fs4.readFile(`${pkgDir}/package.json`, "utf8"));
+  console.log(chalk27.green(`Publint: ${pkg.name}`));
+  console.log(chalk27.gray(pkgDir));
   const { publint: publint2 } = await import("publint");
   const { messages } = await publint2({
     level: "suggestion",
@@ -1287,21 +1418,21 @@ var packagePublint = async (params) => {
   for (const message of validMessages) {
     switch (message.type) {
       case "error": {
-        console.error(chalk22.red(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.error(chalk27.red(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
       case "warning": {
-        console.warn(chalk22.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.warn(chalk27.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
       default: {
-        console.log(chalk22.white(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.log(chalk27.white(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
     }
   }
   if (params?.verbose) {
-    console.log(chalk22.gray(`Publint [Finish]: ${pkgDir} [${validMessages.length}]`));
+    console.log(chalk27.gray(`Publint [Finish]: ${pkgDir} [${validMessages.length}]`));
   }
   return validMessages.filter((message) => message.type === "error").length;
 };
@@ -1338,7 +1469,7 @@ var buildEntries = (folder, entryMode = "single", excludeSpecAndStories = true,
 
 // src/actions/package/compile/packageCompileTscTypes.ts
 import { cwd } from "node:process";
-import chalk23 from "chalk";
+import chalk28 from "chalk";
 import { createProgramFromConfig } from "tsc-prog";
 import {
   DiagnosticCategory,
@@ -1393,7 +1524,7 @@ var packageCompileTscTypes = (folder = "src", config2 = {}, compilerOptionsParam
   const validTsExt = [".ts", ".tsx", ".d.ts", ".cts", ".d.cts", ".mts", ".d.mts"];
   const excludes = [".stories.", ".spec."];
   const files = buildEntries(folder, "all", verbose).filter((file) => validTsExt.find((ext) => file.endsWith(ext)) && !excludes.some((exclude) => file.includes(exclude)));
-  console.log(chalk23.green(`Compiling Types ${pkg}: ${files.length}`));
+  console.log(chalk28.green(`Compiling Types ${pkg}: ${files.length}`));
   if (files.length > 0) {
     const program = createProgramFromConfig({
       basePath: pkg ?? cwd(),
@@ -1450,7 +1581,7 @@ function deepMergeObjects(objects) {
 
 // src/actions/package/compile/packageCompileTsc.ts
 import { cwd as cwd2 } from "node:process";
-import chalk24 from "chalk";
+import chalk29 from "chalk";
 import { createProgramFromConfig as createProgramFromConfig2 } from "tsc-prog";
 import {
   DiagnosticCategory as DiagnosticCategory2,
@@ -1476,7 +1607,7 @@ var packageCompileTsc = (folder = "src", config2 = {}, compilerOptionsParam) =>
   const validTsExt = [".ts", ".tsx", ".d.ts", ".cts", ".d.cts", ".mts", ".d.mts"];
   const includes = [".stories.", ".spec.", ".d.ts", ".d.cts", ".d.mts"];
   const files = buildEntries(folder, "all", verbose).filter((file) => validTsExt.find((ext) => file.endsWith(ext)) && includes.find((include) => file.includes(include)));
-  console.log(chalk24.green(`Compiling Files ${pkg}: ${files.length}`));
+  console.log(chalk29.green(`Compiling Files ${pkg}: ${files.length}`));
   if (files.length > 0) {
     const program = createProgramFromConfig2({
       basePath: pkg ?? cwd2(),
@@ -1627,7 +1758,7 @@ var packageCompileTsup = async (config2) => {
 // src/actions/package/compile/compile.ts
 var packageCompile = async (inConfig = {}) => {
   const pkg = process.env.INIT_CWD;
-  console.log(chalk25.green(`Compiling ${pkg}`));
+  console.log(chalk30.green(`Compiling ${pkg}`));
   const config2 = await loadConfig(inConfig);
   const publint2 = config2.publint;
   const tsupResults = await packageCompileTsup(config2);
@@ -1638,8 +1769,8 @@ var packageCompile = async (inConfig = {}) => {
 };
 
 // src/actions/package/copy-assets.ts
-import path6 from "node:path/posix";
-import chalk26 from "chalk";
+import path7 from "node:path/posix";
+import chalk31 from "chalk";
 import cpy2 from "cpy";
 var copyTargetAssets2 = async (target, name, location) => {
   try {
@@ -1647,12 +1778,12 @@ var copyTargetAssets2 = async (target, name, location) => {
       ["**/*.jpg", "**/*.png", "**/*.gif", "**/*.svg", "**/*.webp", "**/*.sass", "**/*.scss", "**/*.gif", "**/*.css"],
       `../dist/${target}`,
       {
-        cwd: path6.join(location, "src"),
+        cwd: path7.join(location, "src"),
         flat: false
       }
     );
     if (values.length > 0) {
-      console.log(chalk26.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
+      console.log(chalk31.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
     }
     for (const value of values) {
       console.log(`${value.split("/").pop()} => ./dist/${target}`);
@@ -1720,8 +1851,8 @@ var packageCycle = async ({ verbose = false }) => {
 
 // src/actions/package/gen-docs.ts
 import { existsSync as existsSync5 } from "node:fs";
-import path7 from "node:path";
-import chalk27 from "chalk";
+import path8 from "node:path";
+import chalk32 from "chalk";
 import {
   Application,
   ArgumentsReader,
@@ -1739,7 +1870,7 @@ var ExitCodes = {
 };
 var packageGenDocs = async () => {
   const pkg = process.env.INIT_CWD;
-  if (pkg && !existsSync5(path7.join(pkg, "typedoc.json"))) {
+  if (pkg && !existsSync5(path8.join(pkg, "typedoc.json"))) {
     return;
   }
   const app = await Application.bootstrap({
@@ -1825,16 +1956,16 @@ var runTypeDoc = async (app) => {
       return ExitCodes.OutputError;
     }
   }
-  console.log(chalk27.green(`${pkgName} - Ok`));
+  console.log(chalk32.green(`${pkgName} - Ok`));
   return ExitCodes.Ok;
 };
 
 // src/actions/package/lint.ts
 import { readdirSync } from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 import { cwd as cwd3 } from "node:process";
 import { pathToFileURL } from "node:url";
-import chalk28 from "chalk";
+import chalk33 from "chalk";
 import { ESLint } from "eslint";
 import { findUp } from "find-up";
 import picomatch from "picomatch";
@@ -1843,14 +1974,14 @@ var dumpMessages = (lintResults) => {
   const severity = ["none", "warning", "error"];
   for (const lintResult of lintResults) {
     if (lintResult.messages.length > 0) {
-      console.log(chalk28.gray(`
+      console.log(chalk33.gray(`
 ${lintResult.filePath}`));
       for (const message of lintResult.messages) {
         console.log(
-          chalk28.gray(`	${message.line}:${message.column}`),
-          chalk28[colors[message.severity]](`	${severity[message.severity]}`),
-          chalk28.white(`	${message.message}`),
-          chalk28.gray(`	${message.ruleId}`)
+          chalk33.gray(`	${message.line}:${message.column}`),
+          chalk33[colors[message.severity]](`	${severity[message.severity]}`),
+          chalk33.white(`	${message.message}`),
+          chalk33.gray(`	${message.ruleId}`)
         );
       }
     }
@@ -1868,7 +1999,7 @@ function getFiles(dir, ignoreFolders) {
   const subDirectory = dir.split(currentDirectory)[1];
   if (ignoreFolders.includes(subDirectory)) return [];
   return readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
-    const res = path8.resolve(dir, dirent.name);
+    const res = path9.resolve(dir, dirent.name);
     const relativePath = subDirectory ? `${subDirectory}/${dirent.name}` : dirent.name;
     const ignoreMatchers = ignoreFolders.map((pattern) => picomatch(pattern));
     if (ignoreMatchers.some((isMatch) => isMatch(relativePath))) return [];
@@ -1889,7 +2020,7 @@ var packageLint = async (fix2 = false, verbose = false, cache = true) => {
   });
   const files = getFiles(cwd3(), ignoreFolders);
   if (verbose) {
-    console.log(chalk28.green(`Linting ${pkg} [files = ${files.length}]`));
+    console.log(chalk33.green(`Linting ${pkg} [files = ${files.length}]`));
   }
   const lintResults = await engine.lintFiles(files);
   dumpMessages(lintResults);
@@ -1899,7 +2030,7 @@ var packageLint = async (fix2 = false, verbose = false, cache = true) => {
   const filesCountColor = files.length < 100 ? "green" : files.length < 1e3 ? "yellow" : "red";
   const lintTime = Date.now() - start;
   const lintTimeColor = lintTime < 1e3 ? "green" : lintTime < 3e3 ? "yellow" : "red";
-  console.log(chalk28.white(`Linted ${chalk28[filesCountColor](files.length)} files in ${chalk28[lintTimeColor](lintTime)}ms`));
+  console.log(chalk33.white(`Linted ${chalk33[filesCountColor](files.length)} files in ${chalk33[lintTimeColor](lintTime)}ms`));
   return lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0);
 };
 
@@ -1929,7 +2060,7 @@ var rebuild = ({ target }) => {
 };
 
 // src/actions/recompile.ts
-import chalk29 from "chalk";
+import chalk34 from "chalk";
 var recompile = async ({
   verbose,
   target,
@@ -1965,7 +2096,7 @@ var recompileAll = async ({
   const incrementalOptions = incremental ? ["--since", "-Apt", "--topological-dev"] : ["--parallel", "-Apt", "--topological-dev"];
   const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
   if (jobs) {
-    console.log(chalk29.blue(`Jobs set to [${jobs}]`));
+    console.log(chalk34.blue(`Jobs set to [${jobs}]`));
   }
   const result = await runStepsAsync(`Recompile${incremental ? "-Incremental" : ""} [All]`, [
     [
@@ -1996,7 +2127,7 @@ var recompileAll = async ({
     ]
   ]);
   console.log(
-    `${chalk29.gray("Recompiled in")} [${chalk29.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk29.gray("seconds")}`
+    `${chalk34.gray("Recompiled in")} [${chalk34.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk34.gray("seconds")}`
   );
   return result;
 };
@@ -2027,9 +2158,9 @@ var reinstall = () => {
 };
 
 // src/actions/relint.ts
-import chalk30 from "chalk";
+import chalk35 from "chalk";
 var relintPackage = ({ pkg }) => {
-  console.log(chalk30.gray(`${"Relint"} [All-Packages]`));
+  console.log(chalk35.gray(`${"Relint"} [All-Packages]`));
   const start = Date.now();
   const result = runSteps("Relint [All-Packages]", [
     ["yarn", [
@@ -2039,7 +2170,7 @@ var relintPackage = ({ pkg }) => {
       "package-relint"
     ]]
   ]);
-  console.log(chalk30.gray(`${"Relinted in"} [${chalk30.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk30.gray("seconds")}`));
+  console.log(chalk35.gray(`${"Relinted in"} [${chalk35.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk35.gray("seconds")}`));
   return result;
 };
 var relint = ({
@@ -2050,7 +2181,7 @@ var relint = ({
   return pkg ? relintPackage({ pkg }) : relintAllPackages({ verbose, incremental });
 };
 var relintAllPackages = ({ verbose = true, incremental } = {}) => {
-  console.log(chalk30.gray(`${"Relint"} [All-Packages]`));
+  console.log(chalk35.gray(`${"Relint"} [All-Packages]`));
   const start = Date.now();
   const verboseOptions = verbose ? ["--verbose"] : ["--no-verbose"];
   const incrementalOptions = incremental ? ["--since", "-Ap"] : ["--parallel", "-Ap"];
@@ -2064,7 +2195,7 @@ var relintAllPackages = ({ verbose = true, incremental } = {}) => {
       "package-relint"
     ]]
   ]);
-  console.log(chalk30.gray(`Relinted in [${chalk30.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk30.gray("seconds")}`));
+  console.log(chalk35.gray(`Relinted in [${chalk35.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk35.gray("seconds")}`));
   return result;
 };
 
@@ -2082,10 +2213,10 @@ var sonar = () => {
 };
 
 // src/actions/statics.ts
-import chalk31 from "chalk";
+import chalk36 from "chalk";
 var DefaultDependencies = ["axios", "@xylabs/pixel", "react", "graphql", "react-router", "@mui/material", "@mui/system"];
 var statics = () => {
-  console.log(chalk31.green("Check Required Static Dependencies"));
+  console.log(chalk36.green("Check Required Static Dependencies"));
   const statics2 = parsedPackageJSON()?.xy?.deps?.statics;
   return detectDuplicateDependencies(statics2, DefaultDependencies);
 };
@@ -2142,7 +2273,7 @@ var loadPackageConfig = async () => {
 };
 
 // src/xy/xy.ts
-import chalk33 from "chalk";
+import chalk38 from "chalk";
 
 // src/xy/xyBuildCommands.ts
 var xyBuildCommands = (args) => {
@@ -2261,7 +2392,7 @@ var xyBuildCommands = (args) => {
 
 // src/xy/param.ts
 var packagePositionalParam = (yargs2) => {
-  return yargs2.positional("package", { describe: "Specific package to target" });
+  return yargs2.positional("package", { describe: "Specific package to target", type: "string" });
 };
 
 // src/xy/xyCommonCommands.ts
@@ -2503,7 +2634,7 @@ var xyInstallCommands = (args) => {
 };
 
 // src/xy/xyLintCommands.ts
-import chalk32 from "chalk";
+import chalk37 from "chalk";
 var xyLintCommands = (args) => {
   return args.command(
     "cycle [package]",
@@ -2515,31 +2646,61 @@ var xyLintCommands = (args) => {
       const start = Date.now();
       if (argv.verbose) console.log("Cycle");
       process.exitCode = await cycle({ pkg: argv.package });
-      console.log(chalk32.blue(`Finished in ${Date.now() - start}ms`));
+      console.log(chalk37.blue(`Finished in ${Date.now() - start}ms`));
     }
   ).command(
     "lint [package]",
     "Lint - Run Eslint",
     (yargs2) => {
-      return packagePositionalParam(yargs2);
+      return packagePositionalParam(yargs2).option("fix", {
+        alias: "f",
+        default: false,
+        description: "Fix fixable issues",
+        type: "boolean"
+      }).option("cache", {
+        alias: "c",
+        default: false,
+        description: "Use caching for performance",
+        type: "boolean"
+      });
     },
     (argv) => {
       if (argv.verbose) console.log("Lint");
       const start = Date.now();
-      process.exitCode = argv.fix ? fix({ pkg: argv.package }) : lint({ pkg: argv.package });
-      console.log(chalk32.blue(`Finished in ${Date.now() - start}ms`));
+      process.exitCode = argv.fix ? fix({ pkg: argv.package, cache: argv.cache }) : lint({ pkg: argv.package, cache: argv.cache });
+      console.log(chalk37.blue(`Finished in ${Date.now() - start}ms`));
     }
   ).command(
     "deplint [package]",
     "Deplint - Run Deplint",
     (yargs2) => {
-      return packagePositionalParam(yargs2);
+      return packagePositionalParam(yargs2).option("deps", {
+        alias: "d",
+        default: false,
+        description: "Check dependencies",
+        type: "boolean"
+      }).option("devDeps", {
+        alias: "v",
+        default: false,
+        description: "Check devDependencies",
+        type: "boolean"
+      }).option("peerDeps", {
+        alias: "p",
+        default: false,
+        description: "Check peerDependencies",
+        type: "boolean"
+      });
     },
     (argv) => {
       if (argv.verbose) console.log("Deplint");
       const start = Date.now();
-      process.exitCode = deplint({ pkg: argv.package });
-      console.log(chalk32.blue(`Finished in ${Date.now() - start}ms`));
+      process.exitCode = deplint({
+        pkg: argv.package,
+        deps: !!argv.deps,
+        devDeps: !!argv.devDeps,
+        peerDeps: !!argv.peerDeps
+      });
+      console.log(chalk37.blue(`Finished in ${Date.now() - start}ms`));
     }
   ).command(
     "fix [package]",
@@ -2551,7 +2712,7 @@ var xyLintCommands = (args) => {
       const start = Date.now();
       if (argv.verbose) console.log("Fix");
       process.exitCode = fix();
-      console.log(chalk32.blue(`Finished in ${Date.now() - start}ms`));
+      console.log(chalk37.blue(`Finished in ${Date.now() - start}ms`));
     }
   ).command(
     "relint [package]",
@@ -2563,7 +2724,7 @@ var xyLintCommands = (args) => {
       if (argv.verbose) console.log("Relinting");
       const start = Date.now();
       process.exitCode = relint();
-      console.log(chalk32.blue(`Finished in ${Date.now() - start}ms`));
+      console.log(chalk37.blue(`Finished in ${Date.now() - start}ms`));
     }
   ).command(
     "publint [package]",
@@ -2575,7 +2736,7 @@ var xyLintCommands = (args) => {
       if (argv.verbose) console.log("Publint");
       const start = Date.now();
       process.exitCode = await publint({ pkg: argv.package, verbose: !!argv.verbose });
-      console.log(chalk32.blue(`Finished in ${Date.now() - start}ms`));
+      console.log(chalk37.blue(`Finished in ${Date.now() - start}ms`));
     }
   ).command(
     "knip",
@@ -2587,7 +2748,7 @@ var xyLintCommands = (args) => {
       if (argv.verbose) console.log("Knip");
       const start = Date.now();
       process.exitCode = knip();
-      console.log(chalk32.blue(`Knip finished in ${Date.now() - start}ms`));
+      console.log(chalk37.blue(`Knip finished in ${Date.now() - start}ms`));
     }
   ).command(
     "sonar",
@@ -2599,7 +2760,7 @@ var xyLintCommands = (args) => {
       const start = Date.now();
       if (argv.verbose) console.log("Sonar Check");
       process.exitCode = sonar();
-      console.log(chalk32.blue(`Finished in ${Date.now() - start}ms`));
+      console.log(chalk37.blue(`Finished in ${Date.now() - start}ms`));
     }
   );
 };
@@ -2618,37 +2779,16 @@ var xyParseOptions = () => {
     default: false,
     description: "Run with verbose logging",
     type: "boolean"
-  }).option("target", {
-    alias: "t",
-    default: "esm",
-    choices: ["esm", "cjs"],
-    description: "Limit output to specific target",
-    type: "string"
   }).option("incremental", {
     alias: "i",
     default: false,
     description: "Attempt to perform the action only on changed packages",
     type: "boolean"
-  }).option("fix", {
-    alias: "f",
-    default: false,
-    description: "Try to fix errors",
-    type: "boolean"
-  }).option("cache", {
-    alias: "c",
-    default: false,
-    description: "Use caching for performance",
-    type: "boolean"
   }).option("profile", {
     alias: "p",
     default: false,
     description: "Profile action",
     type: "boolean"
-  }).option("types", {
-    default: "tsc",
-    choices: ["tsc", "tsup"],
-    description: "Tool to generate Typescript types",
-    type: "string"
   });
 };
 
@@ -2656,8 +2796,8 @@ var xyParseOptions = () => {
 var xy = async () => {
   const options = xyParseOptions();
   return await xyBuildCommands(xyCommonCommands(xyInstallCommands(xyDeployCommands(xyLintCommands(options))))).demandCommand(1).command("*", "", () => {
-    console.error(chalk33.yellow(`Command not found [${chalk33.magenta(process.argv[2])}]`));
-    console.log(chalk33.gray("Try 'yarn xy --help' for list of commands"));
+    console.error(chalk38.yellow(`Command not found [${chalk38.magenta(process.argv[2])}]`));
+    console.log(chalk38.gray("Try 'yarn xy --help' for list of commands"));
   }).version().help().argv;
 };
 export {