@xylabs/toolchain 7.10.1 → 7.10.2

package/dist/actions/packman/index.mjs

@@ -5,7 +5,7 @@ import {
   writeFileSync as writeFileSync7
 } from "fs";
 import PATH7 from "path";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 
 // src/actions/packman/convert.ts
 import {
@@ -15,7 +15,7 @@ import {
   statSync
 } from "fs";
 import PATH6 from "path";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // src/actions/package-lint.ts
 import {
@@ -24,7 +24,7 @@ import {
   writeFileSync as writeFileSync2
 } from "fs";
 import PATH2 from "path";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import picomatch from "picomatch";
 import semver2 from "semver";
 
@@ -62,28 +62,54 @@ var latestVersions = {
   yarn: "4.13.0"
 };
 
+// src/lib/loadConfig.ts
+import chalk from "chalk";
+import { cosmiconfig } from "cosmiconfig";
+import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
+import deepmerge from "deepmerge";
+var config;
+var rootConfigPath;
+function createExplorer() {
+  return cosmiconfig("xy", { cache: true, loaders: { ".ts": TypeScriptLoader() } });
+}
+var loadConfig = async (params) => {
+  if (config === void 0) {
+    const cosmicConfigResult = await createExplorer().search();
+    config = cosmicConfigResult?.config ?? {};
+    rootConfigPath = cosmicConfigResult?.filepath;
+    const configFilePath = cosmicConfigResult?.filepath;
+    if (configFilePath !== void 0) {
+      console.log(chalk.green(`Loaded config from ${configFilePath}`));
+      if (config.verbose) {
+        console.log(chalk.gray(`${JSON.stringify(config, null, 2)}`));
+      }
+    }
+  }
+  return deepmerge(config, params ?? {});
+};
+
 // src/lib/runInstall.ts
 import { spawnSync } from "child_process";
-import chalk from "chalk";
+import chalk2 from "chalk";
 function runInstall(cwd) {
   const pm = detectPackageManager();
-  console.log(chalk.gray(`Running ${pm} install...`));
+  console.log(chalk2.gray(`Running ${pm} install...`));
   const result = spawnSync(pm, ["install"], {
     cwd,
     stdio: "inherit"
   });
   if (result.status !== 0) {
-    console.warn(chalk.yellow(`${pm} install failed`));
+    console.warn(chalk2.yellow(`${pm} install failed`));
     return false;
   }
-  console.log(chalk.green("Dependencies installed"));
+  console.log(chalk2.green("Dependencies installed"));
   return true;
 }
 
 // src/actions/package-lint-deps.ts
 import { readFileSync, writeFileSync } from "fs";
 import PATH from "path";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import semver from "semver";
 function readWorkspacePackageJson(cwd, location) {
   const pkgPath = PATH.resolve(cwd, location, "package.json");
@@ -153,7 +179,7 @@ function fixVersionConsistency(cwd, rootPkg, writeRootPackageJson2, workspaces)
   if (rootPkg.version !== void 0) {
     delete rootPkg.version;
     writeRootPackageJson2(cwd, rootPkg);
-    console.log(chalk2.green('  \u2714 Fixed: removed "version" from root package.json'));
+    console.log(chalk3.green('  \u2714 Fixed: removed "version" from root package.json'));
   }
   const versions = [];
   for (const { location } of workspaces) {
@@ -174,7 +200,7 @@ function fixVersionConsistency(cwd, rootPkg, writeRootPackageJson2, workspaces)
     if (pkg.version !== highest) {
       pkg.version = highest;
       writeWorkspacePackageJson(cwd, location, pkg);
-      console.log(chalk2.green(`  \u2714 Fixed: set version to ${highest} in ${name} (${location})`));
+      console.log(chalk3.green(`  \u2714 Fixed: set version to ${highest} in ${name} (${location})`));
     }
   }
 }
@@ -229,7 +255,7 @@ function fixInternalDepVersions(cwd, workspaces) {
         const expected = expectedDepVersion(targetVersion);
         if (version !== expected) {
           deps[dep] = expected;
-          console.log(chalk2.green(`  \u2714 Fixed: set ${depField}.${dep} to "${expected}" in ${name} (${location})`));
+          console.log(chalk3.green(`  \u2714 Fixed: set ${depField}.${dep} to "${expected}" in ${name} (${location})`));
           modified = true;
         }
       }
@@ -277,7 +303,7 @@ function fixWorkspaceProtocol(cwd, workspaces) {
         if (!workspaceNames.has(dep)) continue;
         if (!version.startsWith("workspace:")) {
           deps[dep] = "workspace:~";
-          console.log(chalk2.green(`  \u2714 Fixed: set ${depField}.${dep} to "workspace:~" in ${name} (${location})`));
+          console.log(chalk3.green(`  \u2714 Fixed: set ${depField}.${dep} to "workspace:~" in ${name} (${location})`));
           modified = true;
         }
       }
@@ -335,7 +361,7 @@ function fixInternalPeerVersions(cwd, workspaces) {
       const expected = expectedPeerRange(devDeps?.[dep], targetVersion);
       if (version !== expected) {
         peerDeps[dep] = expected;
-        console.log(chalk2.green(`  \u2714 Fixed: set peerDependencies.${dep} to "${expected}" in ${name} (${location})`));
+        console.log(chalk3.green(`  \u2714 Fixed: set peerDependencies.${dep} to "${expected}" in ${name} (${location})`));
         modified = true;
       }
     }
@@ -409,7 +435,7 @@ function checkRootPrivate(pkg) {
 function fixRootPrivate(cwd, pkg) {
   pkg.private = true;
   writeRootPackageJson(cwd, pkg);
-  console.log(chalk3.green('  \u2714 Fixed: set "private": true in root package.json'));
+  console.log(chalk4.green('  \u2714 Fixed: set "private": true in root package.json'));
 }
 function checkNoPublishConfigOnPrivate(pkg) {
   const result = emptyResult();
@@ -421,7 +447,7 @@ function checkNoPublishConfigOnPrivate(pkg) {
 function fixNoPublishConfigOnPrivate(cwd, pkg) {
   delete pkg.publishConfig;
   writeRootPackageJson(cwd, pkg);
-  console.log(chalk3.green("  \u2714 Fixed: removed publishConfig from private root package.json"));
+  console.log(chalk4.green("  \u2714 Fixed: removed publishConfig from private root package.json"));
 }
 function checkNoPackageManagerInWorkspaces(cwd, workspaces) {
   const result = emptyResult();
@@ -450,7 +476,7 @@ function fixNoPackageManagerInWorkspaces(cwd, _pkg, workspaces) {
         delete pkg.packageManager;
         writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
-        console.log(chalk3.green(`  \u2714 Fixed: removed packageManager from ${location}/package.json`));
+        console.log(chalk4.green(`  \u2714 Fixed: removed packageManager from ${location}/package.json`));
       }
     } catch {
     }
@@ -485,7 +511,7 @@ function fixWorkspacesFieldPlacement(cwd, pm, workspaces) {
           writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
           const label = location === "." ? "root" : location;
-          console.log(chalk3.green(`  \u2714 Fixed: removed workspaces from ${label}/package.json`));
+          console.log(chalk4.green(`  \u2714 Fixed: removed workspaces from ${label}/package.json`));
         }
       } catch {
       }
@@ -515,22 +541,22 @@ function logResults(label, result, fix) {
   let errors = 0;
   let fixed = 0;
   for (const error of result.errors) {
-    console.log(chalk3.red(`  \u2717 ${error}`));
+    console.log(chalk4.red(`  \u2717 ${error}`));
     errors++;
   }
   for (const fixable of result.fixable) {
     if (fix) {
       fixed++;
     } else {
-      console.log(chalk3.red(`  \u2717 ${fixable} (fixable)`));
+      console.log(chalk4.red(`  \u2717 ${fixable} (fixable)`));
       errors++;
     }
   }
   for (const warning of result.warnings) {
-    console.log(chalk3.yellow(`  \u26A0 ${warning}`));
+    console.log(chalk4.yellow(`  \u26A0 ${warning}`));
   }
   if (errors === 0 && fixed === 0 && result.warnings.length === 0) {
-    console.log(chalk3.green(`  \u2713 ${label}`));
+    console.log(chalk4.green(`  \u2713 ${label}`));
   }
   return { errors, fixed };
 }
@@ -574,7 +600,7 @@ function fixVoltaOnlyInRoot(cwd, _pkg, workspaces) {
         delete pkg.volta;
         writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
-        console.log(chalk3.green(`  \u2714 Fixed: removed volta from ${location}/package.json`));
+        console.log(chalk4.green(`  \u2714 Fixed: removed volta from ${location}/package.json`));
       }
     } catch {
     }
@@ -613,7 +639,7 @@ function fixEnginesOnlyInNonTerminal(cwd, _pkg, workspaces) {
     delete rootPkg.engines;
     writeFileSync2(rootPath, `${JSON.stringify(rootPkg, null, 2)}
 `, "utf8");
-    console.log(chalk3.green("  \u2714 Fixed: removed engines from root package.json"));
+    console.log(chalk4.green("  \u2714 Fixed: removed engines from root package.json"));
   }
   const enginesTemplate = resolveEnginesTemplate(cwd, workspaces);
   for (const { location } of workspaces) {
@@ -626,13 +652,13 @@ function fixEnginesOnlyInNonTerminal(cwd, _pkg, workspaces) {
         delete pkg.engines;
         writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
-        console.log(chalk3.green(`  \u2714 Fixed: removed engines from ${location}/package.json`));
+        console.log(chalk4.green(`  \u2714 Fixed: removed engines from ${location}/package.json`));
       }
       if (!isTerminalPackage(pkg) && !pkg.engines && enginesTemplate) {
         pkg.engines = enginesTemplate;
         writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
-        console.log(chalk3.green(`  \u2714 Fixed: added engines to ${location}/package.json`));
+        console.log(chalk4.green(`  \u2714 Fixed: added engines to ${location}/package.json`));
       }
     } catch {
     }
@@ -693,14 +719,14 @@ function checkVersionsIncludeLts(cwd, workspaces) {
 }
 function logSummary(errors, fixed) {
   if (fixed > 0) {
-    console.log(chalk3.green(`
+    console.log(chalk4.green(`
   Fixed ${fixed} issue(s)`));
   }
   if (errors > 0) {
-    console.log(chalk3.red(`
+    console.log(chalk4.red(`
   ${errors} error(s) found`));
   } else if (fixed === 0) {
-    console.log(chalk3.green("\n  All checks passed"));
+    console.log(chalk4.green("\n  All checks passed"));
   }
 }
 function packageLintMonorepo(fix = false) {
@@ -709,14 +735,14 @@ function packageLintMonorepo(fix = false) {
   try {
     pkg = readRootPackageJson(cwd);
   } catch {
-    console.error(chalk3.red("Could not read package.json"));
+    console.error(chalk4.red("Could not read package.json"));
     return 1;
   }
   if (!isMonorepo(pkg, cwd)) {
-    console.log(chalk3.gray("Not a monorepo \u2014 skipping repo lint checks"));
+    console.log(chalk4.gray("Not a monorepo \u2014 skipping repo lint checks"));
     return 0;
   }
-  console.log(chalk3.green("Repo Lint"));
+  console.log(chalk4.green("Repo Lint"));
   const pm = detectPackageManager();
   const workspaces = getPackageManager().listWorkspaces();
   const internalDepCheck = pm === "pnpm" ? {
@@ -728,7 +754,7 @@ function packageLintMonorepo(fix = false) {
     fix: () => fixInternalDepVersions(cwd, workspaces),
     label: "Internal deps/devDeps use correct version ranges"
   };
-  const checks2 = [
+  const checks = [
     {
       check: () => checkRootPrivate(pkg),
       fix: fixRootPrivate,
@@ -780,7 +806,7 @@ function packageLintMonorepo(fix = false) {
       label: "Internal peerDeps use semver ranges (not workspace: protocol)"
     }
   ];
-  const { errors, fixed } = runChecks(checks2, cwd, pkg, fix);
+  const { errors, fixed } = runChecks(checks, cwd, pkg, fix);
   logSummary(errors, fixed);
   if (fix && fixed > 0) {
     runInstall();
@@ -798,7 +824,7 @@ import {
   writeFileSync as writeFileSync5
 } from "fs";
 import PATH4 from "path";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 
 // src/actions/packman/rewriteScripts.ts
 function rewriteYarnToPnpm(script) {
@@ -854,7 +880,7 @@ import {
   readFileSync as readFileSync3,
   writeFileSync as writeFileSync3
 } from "fs";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import { globSync } from "glob";
 var IMPORT_SWAP_MAP = {
   "yarn-to-pnpm": [
@@ -901,7 +927,7 @@ function rewriteSourceImports(cwd, direction) {
     }
   }
   if (count > 0) {
-    console.log(chalk4.green(`  Rewrote ts-scripts imports in ${count} source file(s)`));
+    console.log(chalk5.green(`  Rewrote ts-scripts imports in ${count} source file(s)`));
   }
 }
 
@@ -912,7 +938,7 @@ import {
   writeFileSync as writeFileSync4
 } from "fs";
 import PATH3 from "path";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 var SWAP_MAP = {
   "yarn-to-pnpm": [
     ["@xylabs/ts-scripts-yarn3", "@xylabs/ts-scripts-pnpm"]
@@ -955,7 +981,7 @@ function swapTsScriptsDependency(cwd, workspacePackageJsonPaths, direction) {
   }
   if (count > 0) {
     const target = direction === "yarn-to-pnpm" ? "@xylabs/ts-scripts-pnpm" : "@xylabs/ts-scripts-yarn3";
-    console.log(chalk5.green(`  Swapped ts-scripts dependency to ${target} in ${count} package(s)`));
+    console.log(chalk6.green(`  Swapped ts-scripts dependency to ${target} in ${count} package(s)`));
   }
 }
 
@@ -967,7 +993,7 @@ function createPnpmWorkspaceYaml(cwd, workspacePatterns) {
     lines.push(`  - '${pattern}'`);
   }
   writeFileSync5(PATH4.join(cwd, "pnpm-workspace.yaml"), lines.join("\n") + "\n", "utf8");
-  console.log(chalk6.green("  Created pnpm-workspace.yaml"));
+  console.log(chalk7.green("  Created pnpm-workspace.yaml"));
 }
 function readPnpmWorkspacePatterns(cwd) {
   const wsPath = PATH4.join(cwd, "pnpm-workspace.yaml");
@@ -998,7 +1024,7 @@ function updateRootPackageJson(cwd) {
   pkg.packageManager = `pnpm@${PNPM_VERSION}`;
   const updated = rewriteScriptsInPackageJson(pkg, "yarn-to-pnpm");
   writeFileSync5(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
-  console.log(chalk6.green("  Updated root package.json"));
+  console.log(chalk7.green("  Updated root package.json"));
   return workspacePatterns;
 }
 function updateGitignore(cwd) {
@@ -1020,7 +1046,7 @@ function updateGitignore(cwd) {
   }
   content = content.replaceAll(/\n{3,}/g, "\n\n");
   writeFileSync5(gitignorePath, content, "utf8");
-  console.log(chalk6.green("  Updated .gitignore"));
+  console.log(chalk7.green("  Updated .gitignore"));
 }
 function deleteYarnArtifacts(cwd) {
   const yarnLock = PATH4.join(cwd, "yarn.lock");
@@ -1028,15 +1054,15 @@ function deleteYarnArtifacts(cwd) {
   const yarnDir = PATH4.join(cwd, ".yarn");
   if (existsSync5(yarnLock)) {
     rmSync(yarnLock);
-    console.log(chalk6.gray("  Deleted yarn.lock"));
+    console.log(chalk7.gray("  Deleted yarn.lock"));
   }
   if (existsSync5(yarnrc)) {
     rmSync(yarnrc);
-    console.log(chalk6.gray("  Deleted .yarnrc.yml"));
+    console.log(chalk7.gray("  Deleted .yarnrc.yml"));
   }
   if (existsSync5(yarnDir)) {
     rmSync(yarnDir, { force: true, recursive: true });
-    console.log(chalk6.gray("  Deleted .yarn/"));
+    console.log(chalk7.gray("  Deleted .yarn/"));
   }
 }
 function createNpmrc(cwd) {
@@ -1044,10 +1070,10 @@ function createNpmrc(cwd) {
   if (existsSync5(npmrcPath)) return;
   mkdirSync(PATH4.dirname(npmrcPath), { recursive: true });
   writeFileSync5(npmrcPath, "", "utf8");
-  console.log(chalk6.green("  Created .npmrc"));
+  console.log(chalk7.green("  Created .npmrc"));
 }
 function convertToPnpm(cwd, workspacePackageJsonPaths) {
-  console.log(chalk6.blue("\nConverting to pnpm...\n"));
+  console.log(chalk7.blue("\nConverting to pnpm...\n"));
   const workspacePatterns = updateRootPackageJson(cwd);
   createPnpmWorkspaceYaml(cwd, workspacePatterns);
   for (const pkgPath of workspacePackageJsonPaths) {
@@ -1059,13 +1085,13 @@ function convertToPnpm(cwd, workspacePackageJsonPaths) {
       writeFileSync5(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
     }
   }
-  console.log(chalk6.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
+  console.log(chalk7.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
   updateGitignore(cwd);
   createNpmrc(cwd);
   swapTsScriptsDependency(cwd, workspacePackageJsonPaths, "yarn-to-pnpm");
   rewriteSourceImports(cwd, "yarn-to-pnpm");
   deleteYarnArtifacts(cwd);
-  console.log(chalk6.blue("\nRunning pnpm install..."));
+  console.log(chalk7.blue("\nRunning pnpm install..."));
   const install = spawnSync2("pnpm", ["install"], {
     cwd,
     encoding: "utf8",
@@ -1073,10 +1099,10 @@ function convertToPnpm(cwd, workspacePackageJsonPaths) {
     stdio: "inherit"
   });
   if (install.status !== 0) {
-    console.error(chalk6.red("pnpm install failed"));
+    console.error(chalk7.red("pnpm install failed"));
     return 1;
   }
-  console.log(chalk6.blue("\nConversion complete.\n"));
+  console.log(chalk7.blue("\nConversion complete.\n"));
   return 0;
 }
 
@@ -1089,7 +1115,7 @@ import {
   writeFileSync as writeFileSync6
 } from "fs";
 import PATH5 from "path";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 var YARN_VERSION = "4.13.0";
 var YARNRC_TEMPLATE = `compressionLevel: mixed
 
@@ -1138,7 +1164,7 @@ function updateRootPackageJson2(cwd, workspacePatterns) {
   pkg.packageManager = `yarn@${YARN_VERSION}`;
   const updated = rewriteScriptsInPackageJson(pkg, "pnpm-to-yarn");
   writeFileSync6(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
-  console.log(chalk7.green("  Updated root package.json"));
+  console.log(chalk8.green("  Updated root package.json"));
 }
 function updateGitignore2(cwd) {
   const gitignorePath = PATH5.join(cwd, ".gitignore");
@@ -1147,7 +1173,7 @@ function updateGitignore2(cwd) {
     content = content.trimEnd() + "\n" + YARN_GITIGNORE_ENTRIES;
   }
   writeFileSync6(gitignorePath, content, "utf8");
-  console.log(chalk7.green("  Updated .gitignore"));
+  console.log(chalk8.green("  Updated .gitignore"));
 }
 function deletePnpmArtifacts(cwd) {
   const lockfile = PATH5.join(cwd, "pnpm-lock.yaml");
@@ -1155,17 +1181,17 @@ function deletePnpmArtifacts(cwd) {
   const npmrc = PATH5.join(cwd, ".npmrc");
   if (existsSync6(lockfile)) {
     rmSync2(lockfile);
-    console.log(chalk7.gray("  Deleted pnpm-lock.yaml"));
+    console.log(chalk8.gray("  Deleted pnpm-lock.yaml"));
   }
   if (existsSync6(workspaceYaml)) {
     rmSync2(workspaceYaml);
-    console.log(chalk7.gray("  Deleted pnpm-workspace.yaml"));
+    console.log(chalk8.gray("  Deleted pnpm-workspace.yaml"));
   }
   if (existsSync6(npmrc)) {
     const content = readFileSync6(npmrc, "utf8");
     if (content.trim() === "" || content.includes("shamefully-hoist") || content.includes("node-linker")) {
       rmSync2(npmrc);
-      console.log(chalk7.gray("  Deleted .npmrc"));
+      console.log(chalk8.gray("  Deleted .npmrc"));
     }
   }
 }
@@ -1173,7 +1199,7 @@ function createYarnrc(cwd) {
   const yarnrcPath = PATH5.join(cwd, ".yarnrc.yml");
   if (existsSync6(yarnrcPath)) return;
   writeFileSync6(yarnrcPath, YARNRC_TEMPLATE, "utf8");
-  console.log(chalk7.green("  Created .yarnrc.yml"));
+  console.log(chalk8.green("  Created .yarnrc.yml"));
 }
 function readWorkspacePatternsFromPackageJson(cwd) {
   const pkgPath = PATH5.join(cwd, "package.json");
@@ -1182,14 +1208,14 @@ function readWorkspacePatternsFromPackageJson(cwd) {
   return pkg.workspaces ?? [];
 }
 function convertToYarn(cwd, workspacePackageJsonPaths) {
-  console.log(chalk7.blue("\nConverting to yarn...\n"));
+  console.log(chalk8.blue("\nConverting to yarn...\n"));
   const workspacePatterns = readPnpmWorkspacePatterns2(cwd);
   if (workspacePatterns.length === 0) {
     const fromPkg = readWorkspacePatternsFromPackageJson(cwd);
     if (fromPkg.length > 0) {
       workspacePatterns.push(...fromPkg);
     } else {
-      console.warn(chalk7.yellow("  No workspace patterns found"));
+      console.warn(chalk8.yellow("  No workspace patterns found"));
     }
   }
   updateRootPackageJson2(cwd, workspacePatterns);
@@ -1202,13 +1228,13 @@ function convertToYarn(cwd, workspacePackageJsonPaths) {
       writeFileSync6(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
     }
   }
-  console.log(chalk7.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
+  console.log(chalk8.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
   updateGitignore2(cwd);
   createYarnrc(cwd);
   swapTsScriptsDependency(cwd, workspacePackageJsonPaths, "pnpm-to-yarn");
   rewriteSourceImports(cwd, "pnpm-to-yarn");
   deletePnpmArtifacts(cwd);
-  console.log(chalk7.blue("\nRunning yarn install..."));
+  console.log(chalk8.blue("\nRunning yarn install..."));
   const install = spawnSync3("yarn", ["install"], {
     cwd,
     encoding: "utf8",
@@ -1216,10 +1242,10 @@ function convertToYarn(cwd, workspacePackageJsonPaths) {
     stdio: "inherit"
   });
   if (install.status !== 0) {
-    console.error(chalk7.red("yarn install failed"));
+    console.error(chalk8.red("yarn install failed"));
     return 1;
   }
-  console.log(chalk7.blue("\nConversion complete.\n"));
+  console.log(chalk8.blue("\nConversion complete.\n"));
   return 0;
 }
 
@@ -1306,29 +1332,29 @@ function walkGlob(basePath, parts, currentPath) {
 function convert({ target, verbose }) {
   const validTargets = ["pnpm", "yarn"];
   if (!validTargets.includes(target)) {
-    console.error(chalk8.red(`Invalid target "${target}". Must be one of: ${validTargets.join(", ")}`));
+    console.error(chalk9.red(`Invalid target "${target}". Must be one of: ${validTargets.join(", ")}`));
     return 1;
   }
   const cwd = process.cwd();
   const currentPM = detectCurrentPM(cwd);
   if (verbose) {
-    console.log(chalk8.gray(`Current package manager: ${currentPM}`));
-    console.log(chalk8.gray(`Target package manager: ${target}`));
+    console.log(chalk9.gray(`Current package manager: ${currentPM}`));
+    console.log(chalk9.gray(`Target package manager: ${target}`));
   }
   if (currentPM === target) {
-    console.log(chalk8.yellow(`Already using ${target}. Re-applying conversion to fix any incomplete steps...`));
+    console.log(chalk9.yellow(`Already using ${target}. Re-applying conversion to fix any incomplete steps...`));
   }
   if (currentPM === "unknown") {
-    console.error(chalk8.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
+    console.error(chalk9.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
     return 1;
   }
   const workspacePaths = findWorkspacePackagePaths(cwd);
   if (verbose) {
-    console.log(chalk8.gray(`Found ${workspacePaths.length} workspace packages`));
+    console.log(chalk9.gray(`Found ${workspacePaths.length} workspace packages`));
   }
   const result = target === "pnpm" ? convertToPnpm(cwd, workspacePaths) : convertToYarn(cwd, workspacePaths);
   if (result !== 0) return result;
-  console.log(chalk8.green("\nRunning repo lint --fix..."));
+  console.log(chalk9.green("\nRunning repo lint --fix..."));
   packageLintMonorepo(true);
   return result;
 }
@@ -1337,7 +1363,7 @@ function convert({ target, verbose }) {
 function removeNodeModules(dir, verbose) {
   const nmPath = PATH7.join(dir, "node_modules");
   if (existsSync8(nmPath)) {
-    if (verbose) console.log(chalk9.gray(`Removing ${nmPath}`));
+    if (verbose) console.log(chalk10.gray(`Removing ${nmPath}`));
     rmSync3(nmPath, { force: true, recursive: true });
     return true;
   }
@@ -1347,10 +1373,10 @@ function packmanClean({ verbose }) {
   const cwd = process.cwd();
   const pm = detectCurrentPM(cwd);
   if (pm === "unknown") {
-    console.error(chalk9.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
+    console.error(chalk10.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
     return 1;
   }
-  console.log(chalk9.blue(`Detected package manager: ${pm}`));
+  console.log(chalk10.blue(`Detected package manager: ${pm}`));
   let removedCount = 0;
   if (removeNodeModules(cwd, verbose)) removedCount++;
   const workspacePaths = findWorkspacePackagePaths(cwd);
@@ -1358,21 +1384,21 @@ function packmanClean({ verbose }) {
     const fullPath = PATH7.join(cwd, wsPath);
     if (removeNodeModules(fullPath, verbose)) removedCount++;
   }
-  console.log(chalk9.green(`Removed ${removedCount} node_modules folder${removedCount === 1 ? "" : "s"}`));
+  console.log(chalk10.green(`Removed ${removedCount} node_modules folder${removedCount === 1 ? "" : "s"}`));
   if (pm === "yarn") {
     const lockPath = PATH7.join(cwd, "yarn.lock");
     if (existsSync8(lockPath)) {
       writeFileSync7(lockPath, "");
-      console.log(chalk9.green("Truncated yarn.lock"));
+      console.log(chalk10.green("Truncated yarn.lock"));
     }
   } else if (pm === "pnpm") {
     const lockPath = PATH7.join(cwd, "pnpm-lock.yaml");
     if (existsSync8(lockPath)) {
       rmSync3(lockPath);
-      console.log(chalk9.green("Deleted pnpm-lock.yaml"));
+      console.log(chalk10.green("Deleted pnpm-lock.yaml"));
     }
   }
-  console.log(chalk9.green("Ready for a clean install"));
+  console.log(chalk10.green("Ready for a clean install"));
   return 0;
 }
 
@@ -1383,36 +1409,67 @@ import {
   writeFileSync as writeFileSync8
 } from "fs";
 import PATH8 from "path";
-import chalk10 from "chalk";
+import chalk11 from "chalk";
+var DEFAULT_MINIMUM_RELEASE_AGE = 4320;
+var DEFAULT_RELEASE_AGE_EXCLUDES = ["'@xylabs/*'", "'@xyo-network/*'"];
+function resolvePackmanConfig(cfg) {
+  return {
+    minimumReleaseAge: cfg?.minimumReleaseAge ?? DEFAULT_MINIMUM_RELEASE_AGE,
+    minimumReleaseAgeExclude: cfg?.minimumReleaseAgeExclude ?? DEFAULT_RELEASE_AGE_EXCLUDES
+  };
+}
+function readPnpmWorkspaceYaml(cwd) {
+  const wsPath = PATH8.join(cwd, "pnpm-workspace.yaml");
+  if (!existsSync9(wsPath)) return void 0;
+  return readFileSync8(wsPath, "utf8");
+}
+function writePnpmWorkspaceYaml(cwd, content) {
+  writeFileSync8(PATH8.join(cwd, "pnpm-workspace.yaml"), content, "utf8");
+}
+function parseYamlListSection(content, sectionName) {
+  const items = [];
+  let inSection = false;
+  for (const line of content.split("\n")) {
+    if (new RegExp(String.raw`^${sectionName}\s*:`).test(line)) {
+      inSection = true;
+      continue;
+    }
+    if (inSection) {
+      const match = /^\s+-\s+(.+)$/.exec(line);
+      if (match) {
+        items.push(match[1].trim());
+      } else if (line.trim() && !/^\s/.test(line)) {
+        break;
+      }
+    }
+  }
+  return items;
+}
 function checkEnableScripts(cwd, verbose, silent) {
   const yarnrcPath = PATH8.join(cwd, ".yarnrc.yml");
   if (!existsSync9(yarnrcPath)) {
-    if (verbose) console.log(chalk10.gray("  No .yarnrc.yml found, skipping enableScripts check"));
+    if (verbose) console.log(chalk11.gray("  No .yarnrc.yml found, skipping enableScripts check"));
     return true;
   }
   const content = readFileSync8(yarnrcPath, "utf8");
-  const lines = content.split("\n");
-  for (const line of lines) {
+  for (const line of content.split("\n")) {
     const trimmed = line.trim();
     if (/^enableScripts\s*:/.test(trimmed)) {
       const value = trimmed.replace(/^enableScripts\s*:\s*/, "").trim();
       if (value === "false") {
-        if (verbose) console.log(chalk10.green("  enableScripts is correctly set to false"));
+        if (verbose) console.log(chalk11.green("  enableScripts is correctly set to false"));
         return true;
       }
-      if (!silent) console.log(chalk10.red("  enableScripts is set to", value, "(expected false)"));
+      if (!silent) console.log(chalk11.red("  enableScripts is set to", value, "(expected false)"));
       return false;
     }
   }
-  if (!silent) console.log(chalk10.red("  enableScripts is not set in .yarnrc.yml (expected false)"));
+  if (!silent) console.log(chalk11.red("  enableScripts is not set in .yarnrc.yml (expected false)"));
   return false;
 }
-function fixEnableScripts(cwd, verbose) {
+function fixEnableScripts(cwd) {
   const yarnrcPath = PATH8.join(cwd, ".yarnrc.yml");
-  if (!existsSync9(yarnrcPath)) {
-    if (verbose) console.log(chalk10.gray("  No .yarnrc.yml found, skipping enableScripts fix"));
-    return true;
-  }
+  if (!existsSync9(yarnrcPath)) return true;
   const content = readFileSync8(yarnrcPath, "utf8");
   const lines = content.split("\n");
   let found = false;
@@ -1443,41 +1500,142 @@ function fixEnableScripts(cwd, verbose) {
     }
   }
   writeFileSync8(yarnrcPath, newLines.join("\n"), "utf8");
-  console.log(chalk10.green("  Fixed: enableScripts set to false"));
+  console.log(chalk11.green("  Fixed: enableScripts set to false"));
   return true;
 }
-var checks = [
-  {
-    name: "enableScripts should be false in .yarnrc.yml",
-    check: checkEnableScripts,
-    fix: fixEnableScripts
+function checkMinimumReleaseAge(cwd, config2, verbose, silent) {
+  if (detectPackageManager() !== "pnpm") return true;
+  const content = readPnpmWorkspaceYaml(cwd);
+  if (!content) {
+    if (!silent) console.log(chalk11.red("  No pnpm-workspace.yaml found"));
+    return false;
   }
-];
-function packmanLint({ fix, verbose } = {}) {
+  const { minimumReleaseAge } = config2;
+  for (const line of content.split("\n")) {
+    const match = /^minimumReleaseAge\s*:\s*(\d+)/.exec(line.trim());
+    if (match) {
+      const value = Number.parseInt(match[1], 10);
+      if (value >= minimumReleaseAge) {
+        if (verbose) console.log(chalk11.green(`  minimumReleaseAge is ${value} (>= ${minimumReleaseAge})`));
+        return true;
+      }
+      if (!silent) console.log(chalk11.red(`  minimumReleaseAge is ${value} (expected >= ${minimumReleaseAge})`));
+      return false;
+    }
+  }
+  if (!silent) console.log(chalk11.red(`  minimumReleaseAge is not set in pnpm-workspace.yaml (expected >= ${minimumReleaseAge})`));
+  return false;
+}
+function fixMinimumReleaseAge(cwd, config2) {
+  if (detectPackageManager() !== "pnpm") return true;
+  const content = readPnpmWorkspaceYaml(cwd);
+  if (!content) return false;
+  const { minimumReleaseAge } = config2;
+  const lines = content.split("\n");
+  let found = false;
+  const newLines = lines.map((line) => {
+    if (/^minimumReleaseAge\s*:/.test(line)) {
+      found = true;
+      return `minimumReleaseAge: ${minimumReleaseAge}`;
+    }
+    return line;
+  });
+  if (!found) {
+    const lastLine = newLines.at(-1);
+    if (lastLine === "") {
+      newLines.splice(-1, 0, `minimumReleaseAge: ${minimumReleaseAge}`);
+    } else {
+      newLines.push(`minimumReleaseAge: ${minimumReleaseAge}`);
+    }
+  }
+  writePnpmWorkspaceYaml(cwd, newLines.join("\n"));
+  console.log(chalk11.green(`  Fixed: minimumReleaseAge set to ${minimumReleaseAge}`));
+  return true;
+}
+function checkMinimumReleaseAgeExclude(cwd, config2, verbose, silent) {
+  if (detectPackageManager() !== "pnpm") return true;
+  const content = readPnpmWorkspaceYaml(cwd);
+  if (!content) {
+    if (!silent) console.log(chalk11.red("  No pnpm-workspace.yaml found"));
+    return false;
+  }
+  const excludes = parseYamlListSection(content, "minimumReleaseAgeExclude");
+  const missing = config2.minimumReleaseAgeExclude.filter((scope) => !excludes.includes(scope));
+  if (missing.length === 0) {
+    if (verbose) console.log(chalk11.green("  minimumReleaseAgeExclude includes all required scopes"));
+    return true;
+  }
+  if (!silent) console.log(chalk11.red(`  minimumReleaseAgeExclude is missing: ${missing.join(", ")}`));
+  return false;
+}
+function fixMinimumReleaseAgeExclude(cwd, config2) {
+  if (detectPackageManager() !== "pnpm") return true;
+  const content = readPnpmWorkspaceYaml(cwd);
+  if (!content) return false;
+  const existingExcludes = parseYamlListSection(content, "minimumReleaseAgeExclude");
+  const toAdd = config2.minimumReleaseAgeExclude.filter((scope) => !existingExcludes.includes(scope));
+  if (toAdd.length === 0) return true;
+  const lines = content.split("\n");
+  const sectionIndex = lines.findIndex((line) => /^minimumReleaseAgeExclude\s*:/.test(line));
+  if (sectionIndex === -1) {
+    const newSection = ["minimumReleaseAgeExclude:", ...config2.minimumReleaseAgeExclude.map((s) => `  - ${s}`)];
+    const lastLine = lines.at(-1);
+    if (lastLine === "") {
+      lines.splice(-1, 0, ...newSection);
+    } else {
+      lines.push(...newSection);
+    }
+  } else {
+    let insertAt = sectionIndex + 1;
+    while (insertAt < lines.length && /^\s+-/.test(lines[insertAt])) {
+      insertAt++;
+    }
+    for (const scope of toAdd) {
+      lines.splice(insertAt, 0, `  - ${scope}`);
+      insertAt++;
+    }
+  }
+  writePnpmWorkspaceYaml(cwd, lines.join("\n"));
+  console.log(chalk11.green(`  Fixed: added ${toAdd.join(", ")} to minimumReleaseAgeExclude`));
+  return true;
+}
+async function packmanLint({ fix, verbose } = {}) {
   const cwd = process.cwd();
+  const rootConfig = await loadConfig();
+  const packmanConfig = resolvePackmanConfig(rootConfig.commands ? rootConfig.commands.packman : void 0);
   let failures = 0;
-  for (const check of checks) {
-    if (verbose) console.log(chalk10.gray(`Checking: ${check.name}`));
-    const passed = check.check(cwd, verbose, fix);
-    if (!passed) {
-      if (fix) {
-        const fixed = check.fix(cwd, verbose);
-        if (!fixed) {
-          failures++;
-        }
-      } else {
-        failures++;
-      }
+  const enableScriptsPassed = checkEnableScripts(cwd, verbose, fix);
+  if (!enableScriptsPassed) {
+    if (fix) {
+      if (!fixEnableScripts(cwd)) failures++;
+    } else {
+      failures++;
+    }
+  }
+  const agePassed = checkMinimumReleaseAge(cwd, packmanConfig, verbose, fix);
+  if (!agePassed) {
+    if (fix) {
+      if (!fixMinimumReleaseAge(cwd, packmanConfig)) failures++;
+    } else {
+      failures++;
+    }
+  }
+  const excludePassed = checkMinimumReleaseAgeExclude(cwd, packmanConfig, verbose, fix);
+  if (!excludePassed) {
+    if (fix) {
+      if (!fixMinimumReleaseAgeExclude(cwd, packmanConfig)) failures++;
+    } else {
+      failures++;
     }
   }
   if (failures > 0) {
-    console.log(chalk10.red(`
+    console.log(chalk11.red(`
 packman lint: ${failures} check(s) failed`));
     if (!fix) {
-      console.log(chalk10.yellow("Run with --fix to auto-fix issues"));
+      console.log(chalk11.yellow("Run with --fix to auto-fix issues"));
     }
   } else {
-    console.log(chalk10.green("\npackman lint: all checks passed"));
+    console.log(chalk11.green("\npackman lint: all checks passed"));
   }
   return failures > 0 ? 1 : 0;
 }