@xylabs/toolchain 7.10.0

package/dist/actions/packman/index.mjs

@@ -0,0 +1,1493 @@
+// src/actions/packman/clean.ts
+import {
+  existsSync as existsSync8,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync7
+} from "fs";
+import PATH7 from "path";
+import chalk9 from "chalk";
+
+// src/actions/packman/convert.ts
+import {
+  existsSync as existsSync7,
+  readdirSync,
+  readFileSync as readFileSync7,
+  statSync
+} from "fs";
+import PATH6 from "path";
+import chalk8 from "chalk";
+
+// src/actions/package-lint.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import PATH2 from "path";
+import chalk3 from "chalk";
+import picomatch from "picomatch";
+import semver2 from "semver";
+
+// src/pm/detectPackageManager.ts
+import { existsSync } from "fs";
+function detectPackageManager() {
+  if (existsSync("pnpm-lock.yaml") || existsSync("pnpm-workspace.yaml")) return "pnpm";
+  return "yarn";
+}
+
+// src/pm/registry.ts
+var implementations = /* @__PURE__ */ new Map();
+function getPackageManager(name) {
+  const pmName = name ?? detectPackageManager();
+  const pm = implementations.get(pmName);
+  if (!pm) {
+    throw new Error(
+      `No package manager implementation registered for "${pmName}". Ensure registerPackageManager() has been called before getPackageManager().`
+    );
+  }
+  return pm;
+}
+
+// src/lib/initCwd.ts
+function INIT_CWD() {
+  return process.env.INIT_CWD ?? process.cwd();
+}
+
+// src/lib/latestVersions.ts
+var latestVersions = {
+  node: "24.14.1",
+  nodeLtsCodename: "Krypton",
+  npm: "11.11.0",
+  pnpm: "10.33.0",
+  yarn: "4.13.0"
+};
+
+// src/lib/runInstall.ts
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+function runInstall(cwd) {
+  const pm = detectPackageManager();
+  console.log(chalk.gray(`Running ${pm} install...`));
+  const result = spawnSync(pm, ["install"], {
+    cwd,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    console.warn(chalk.yellow(`${pm} install failed`));
+    return false;
+  }
+  console.log(chalk.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 semver from "semver";
+function readWorkspacePackageJson(cwd, location) {
+  const pkgPath = PATH.resolve(cwd, location, "package.json");
+  try {
+    return JSON.parse(readFileSync(pkgPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function writeWorkspacePackageJson(cwd, location, pkg) {
+  const pkgPath = PATH.resolve(cwd, location, "package.json");
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function buildWorkspaceVersionMap(cwd, workspaces) {
+  const map = /* @__PURE__ */ new Map();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const version = pkg.version;
+    if (version) map.set(name, version);
+  }
+  return map;
+}
+function expectedPeerRange(devDepVersion, targetVersion) {
+  const parsed = semver.parse(targetVersion);
+  if (!parsed) return `~${targetVersion}`;
+  if (devDepVersion === "workspace:^") {
+    return `^${parsed.major}`;
+  }
+  return `~${parsed.major}.${parsed.minor}`;
+}
+function checkVersionConsistency(cwd, rootPkg, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  if (rootPkg.version !== void 0) {
+    result.fixable.push('Root package.json should not have a "version" field in a monorepo');
+  }
+  const versions = /* @__PURE__ */ new Map();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const version = pkg.version;
+    if (version) {
+      versions.set(name, version);
+    } else {
+      result.errors.push(`${name} (${location}) is missing a "version" field`);
+    }
+  }
+  const uniqueVersions = new Set(versions.values());
+  if (uniqueVersions.size > 1) {
+    const versionList = [...uniqueVersions].toSorted(semver.rcompare);
+    for (const [name, version] of versions) {
+      if (version !== versionList[0]) {
+        result.fixable.push(`${name} has version ${version} (expected ${versionList[0]})`);
+      }
+    }
+  }
+  return result;
+}
+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'));
+  }
+  const versions = [];
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const version = pkg.version;
+    if (version && semver.valid(version)) {
+      versions.push(version);
+    }
+  }
+  if (versions.length === 0) return;
+  const highest = versions.toSorted(semver.rcompare)[0];
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    if (pkg.version !== highest) {
+      pkg.version = highest;
+      writeWorkspacePackageJson(cwd, location, pkg);
+      console.log(chalk2.green(`  \u2714 Fixed: set version to ${highest} in ${name} (${location})`));
+    }
+  }
+}
+function expectedDepVersion(targetVersion) {
+  const parsed = semver.parse(targetVersion);
+  if (!parsed) return `~${targetVersion}`;
+  return `~${targetVersion}`;
+}
+function checkInternalDepVersions(cwd, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        const targetVersion = workspaceVersions.get(dep);
+        if (!targetVersion) continue;
+        const expected = expectedDepVersion(targetVersion);
+        if (version.startsWith("workspace:")) {
+          result.fixable.push(
+            `${name} (${location}) ${depField}.${dep} is "${version}" \u2014 should be "${expected}" (not workspace: protocol)`
+          );
+        } else if (version !== expected) {
+          result.fixable.push(
+            `${name} (${location}) ${depField}.${dep} is "${version}" \u2014 should be "${expected}"`
+          );
+        }
+      }
+    }
+  }
+  return result;
+}
+function fixInternalDepVersions(cwd, workspaces) {
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    let modified = false;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        const targetVersion = workspaceVersions.get(dep);
+        if (!targetVersion) continue;
+        const expected = expectedDepVersion(targetVersion);
+        if (version !== expected) {
+          deps[dep] = expected;
+          console.log(chalk2.green(`  \u2714 Fixed: set ${depField}.${dep} to "${expected}" in ${name} (${location})`));
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      writeWorkspacePackageJson(cwd, location, pkg);
+    }
+  }
+}
+function checkWorkspaceProtocol(cwd, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  const workspaceNames = new Set(workspaces.map((w) => w.name));
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        if (!workspaceNames.has(dep)) continue;
+        if (!version.startsWith("workspace:")) {
+          result.fixable.push(
+            `${name} (${location}) ${depField}.${dep} is "${version}" \u2014 should use workspace: protocol`
+          );
+        }
+      }
+    }
+  }
+  return result;
+}
+function fixWorkspaceProtocol(cwd, workspaces) {
+  const workspaceNames = new Set(workspaces.map((w) => w.name));
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    let modified = false;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        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})`));
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      writeWorkspacePackageJson(cwd, location, pkg);
+    }
+  }
+}
+function checkInternalPeerVersions(cwd, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const peerDeps = pkg.peerDependencies;
+    if (!peerDeps) continue;
+    const devDeps = pkg.devDependencies;
+    for (const [dep, version] of Object.entries(peerDeps)) {
+      const targetVersion = workspaceVersions.get(dep);
+      if (!targetVersion) continue;
+      if (version.startsWith("workspace:")) {
+        const expected2 = expectedPeerRange(devDeps?.[dep], targetVersion);
+        result.fixable.push(
+          `${name} (${location}) peerDependencies.${dep} uses workspace: protocol \u2014 should be "${expected2}"`
+        );
+        continue;
+      }
+      const expected = expectedPeerRange(devDeps?.[dep], targetVersion);
+      if (version !== expected && !semver.satisfies(targetVersion, version)) {
+        result.fixable.push(
+          `${name} (${location}) peerDependencies.${dep} is "${version}" \u2014 current version ${targetVersion} is not satisfied; expected "${expected}"`
+        );
+      }
+    }
+  }
+  return result;
+}
+function fixInternalPeerVersions(cwd, workspaces) {
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const peerDeps = pkg.peerDependencies;
+    if (!peerDeps) continue;
+    const devDeps = pkg.devDependencies;
+    let modified = false;
+    for (const [dep, version] of Object.entries(peerDeps)) {
+      const targetVersion = workspaceVersions.get(dep);
+      if (!targetVersion) continue;
+      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})`));
+        modified = true;
+      }
+    }
+    if (modified) {
+      writeWorkspacePackageJson(cwd, location, pkg);
+    }
+  }
+}
+
+// src/actions/package-lint.ts
+function emptyResult() {
+  return {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+}
+function readRootPackageJson(cwd) {
+  const raw = readFileSync2(PATH2.resolve(cwd, "package.json"), "utf8");
+  return JSON.parse(raw);
+}
+function writeRootPackageJson(cwd, pkg) {
+  const path = PATH2.resolve(cwd, "package.json");
+  writeFileSync2(path, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function readPnpmWorkspaceGlobs(cwd) {
+  const wsPath = PATH2.resolve(cwd, "pnpm-workspace.yaml");
+  if (!existsSync2(wsPath)) return void 0;
+  const raw = readFileSync2(wsPath, "utf8");
+  const globs = [];
+  let inPackages = false;
+  for (const line of raw.split("\n")) {
+    if (/^packages\s*:/.test(line)) {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages) {
+      const match = /^\s+-\s+['"]?([^'"]+)['"]?\s*$/.exec(line);
+      if (match) {
+        globs.push(match[1]);
+      } else if (/^\S/.test(line) && line.trim() !== "") {
+        break;
+      }
+    }
+  }
+  return globs.length > 0 ? globs : void 0;
+}
+function isMonorepo(pkg, cwd) {
+  const workspaces = pkg.workspaces;
+  if (Array.isArray(workspaces) && workspaces.length > 0) return true;
+  return readPnpmWorkspaceGlobs(cwd) !== void 0;
+}
+function checkPackagesFolder(workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    if (!location.startsWith("packages/") && !location.startsWith("packages\\")) {
+      result.errors.push(`${name} (${location}) is not inside a packages/ folder`);
+    }
+  }
+  return result;
+}
+function checkRootPrivate(pkg) {
+  const result = emptyResult();
+  if (!pkg.private) {
+    result.fixable.push("Root package.json must be private to prevent accidental publishing");
+  }
+  return result;
+}
+function fixRootPrivate(cwd, pkg) {
+  pkg.private = true;
+  writeRootPackageJson(cwd, pkg);
+  console.log(chalk3.green('  \u2714 Fixed: set "private": true in root package.json'));
+}
+function checkNoPublishConfigOnPrivate(pkg) {
+  const result = emptyResult();
+  if (pkg.private && pkg.publishConfig) {
+    result.fixable.push("Root package.json has publishConfig but is private \u2014 publishConfig is unnecessary");
+  }
+  return result;
+}
+function fixNoPublishConfigOnPrivate(cwd, pkg) {
+  delete pkg.publishConfig;
+  writeRootPackageJson(cwd, pkg);
+  console.log(chalk3.green("  \u2714 Fixed: removed publishConfig from private root package.json"));
+}
+function checkNoPackageManagerInWorkspaces(cwd, workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH2.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync2(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.packageManager) {
+        result.fixable.push(`${name} (${location}) has a packageManager field \u2014 only the root should define this`);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function fixNoPackageManagerInWorkspaces(cwd, _pkg, workspaces) {
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH2.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync2(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.packageManager) {
+        delete pkg.packageManager;
+        writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk3.green(`  \u2714 Fixed: removed packageManager from ${location}/package.json`));
+      }
+    } catch {
+    }
+  }
+}
+function checkWorkspacesFieldPlacement(cwd, pm, workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (pm === "pnpm" ? true : location !== ".") {
+      const pkgPath = PATH2.resolve(cwd, location, "package.json");
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+        if (pkg.workspaces) {
+          const label = location === "." ? "Root" : `${name} (${location})`;
+          const reason = pm === "pnpm" ? "pnpm uses pnpm-workspace.yaml instead" : "only the root should define workspaces";
+          result.fixable.push(`${label} has a workspaces field \u2014 ${reason}`);
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+function fixWorkspacesFieldPlacement(cwd, pm, workspaces) {
+  for (const { location } of workspaces) {
+    if (pm === "pnpm" ? true : location !== ".") {
+      const pkgPath = PATH2.resolve(cwd, location, "package.json");
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+        if (pkg.workspaces) {
+          delete pkg.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`));
+        }
+      } catch {
+      }
+    }
+  }
+}
+function checkWorkspaceGlobCoverage(pkg, cwd, pm, workspaces) {
+  const result = emptyResult();
+  const globs = pm === "pnpm" ? readPnpmWorkspaceGlobs(cwd) ?? [] : Array.isArray(pkg.workspaces) ? pkg.workspaces : [];
+  if (globs.length === 0) {
+    const source = pm === "pnpm" ? "pnpm-workspace.yaml" : "root package.json workspaces";
+    result.errors.push(`No workspace globs found in ${source}`);
+    return result;
+  }
+  const matchers = globs.map((glob) => picomatch(glob));
+  const isMatch = (location) => matchers.some((m) => m(location));
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    if (!isMatch(location)) {
+      const source = pm === "pnpm" ? "pnpm-workspace.yaml" : "root package.json workspaces";
+      result.errors.push(`${name} (${location}) is not matched by any glob in ${source}`);
+    }
+  }
+  return result;
+}
+function logResults(label, result, fix) {
+  let errors = 0;
+  let fixed = 0;
+  for (const error of result.errors) {
+    console.log(chalk3.red(`  \u2717 ${error}`));
+    errors++;
+  }
+  for (const fixable of result.fixable) {
+    if (fix) {
+      fixed++;
+    } else {
+      console.log(chalk3.red(`  \u2717 ${fixable} (fixable)`));
+      errors++;
+    }
+  }
+  for (const warning of result.warnings) {
+    console.log(chalk3.yellow(`  \u26A0 ${warning}`));
+  }
+  if (errors === 0 && fixed === 0 && result.warnings.length === 0) {
+    console.log(chalk3.green(`  \u2713 ${label}`));
+  }
+  return { errors, fixed };
+}
+function runChecks(entries, cwd, pkg, fix) {
+  let totalErrors = 0;
+  let totalFixed = 0;
+  for (const entry of entries) {
+    const result = entry.check();
+    const log = logResults(entry.label, result, fix);
+    if (fix && entry.fix && result.fixable.length > 0) {
+      entry.fix(cwd, pkg);
+    }
+    totalErrors += log.errors;
+    totalFixed += log.fixed;
+  }
+  return { errors: totalErrors, fixed: totalFixed };
+}
+function checkVoltaOnlyInRoot(cwd, workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH2.resolve(cwd, location, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+      if (pkg.volta) {
+        result.fixable.push(`${name} (${location}) has a volta field \u2014 only the root should define this`);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function fixVoltaOnlyInRoot(cwd, _pkg, workspaces) {
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH2.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync2(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.volta) {
+        delete pkg.volta;
+        writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk3.green(`  \u2714 Fixed: removed volta from ${location}/package.json`));
+      }
+    } catch {
+    }
+  }
+}
+function isTerminalPackage(pkg) {
+  return pkg.private === true;
+}
+function checkEnginesOnlyInNonTerminal(cwd, workspaces) {
+  const result = emptyResult();
+  const rootPkg = JSON.parse(readFileSync2(PATH2.resolve(cwd, "package.json"), "utf8"));
+  if (rootPkg.engines) {
+    result.fixable.push("Root package.json has engines \u2014 terminal packages should not declare engines (use volta instead)");
+  }
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH2.resolve(cwd, location, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+      if (isTerminalPackage(pkg) && pkg.engines) {
+        result.fixable.push(`${name} (${location}) is terminal (private) but has engines \u2014 terminal packages should not declare engines`);
+      }
+      if (!isTerminalPackage(pkg) && !pkg.engines) {
+        result.fixable.push(`${name} (${location}) is a library but has no engines field`);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function fixEnginesOnlyInNonTerminal(cwd, _pkg, workspaces) {
+  const rootPath = PATH2.resolve(cwd, "package.json");
+  const rootRaw = readFileSync2(rootPath, "utf8");
+  const rootPkg = JSON.parse(rootRaw);
+  if (rootPkg.engines) {
+    delete rootPkg.engines;
+    writeFileSync2(rootPath, `${JSON.stringify(rootPkg, null, 2)}
+`, "utf8");
+    console.log(chalk3.green("  \u2714 Fixed: removed engines from root package.json"));
+  }
+  const enginesTemplate = resolveEnginesTemplate(cwd, workspaces);
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH2.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync2(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (isTerminalPackage(pkg) && pkg.engines) {
+        delete pkg.engines;
+        writeFileSync2(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk3.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`));
+      }
+    } catch {
+    }
+  }
+}
+function resolveEnginesTemplate(cwd, workspaces) {
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    try {
+      const pkg = JSON.parse(readFileSync2(PATH2.resolve(cwd, location, "package.json"), "utf8"));
+      if (!isTerminalPackage(pkg) && pkg.engines) {
+        return pkg.engines;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function checkVersionsIncludeLts(cwd, workspaces) {
+  const result = emptyResult();
+  const toolVersions = {
+    node: latestVersions.node,
+    npm: latestVersions.npm,
+    pnpm: latestVersions.pnpm,
+    yarn: latestVersions.yarn
+  };
+  for (const { location, name } of workspaces) {
+    const pkgPath = location === "." ? PATH2.resolve(cwd, "package.json") : PATH2.resolve(cwd, location, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+      const label = location === "." ? "root" : `${name} (${location})`;
+      const engines = pkg.engines;
+      if (engines) {
+        for (const [tool, range] of Object.entries(engines)) {
+          const latest = toolVersions[tool];
+          if (latest && !semver2.satisfies(latest, range)) {
+            result.errors.push(
+              `${label} engines.${tool} "${range}" does not include latest ${tool === "node" ? "LTS " : ""}version ${latest}`
+            );
+          }
+        }
+      }
+      const volta = pkg.volta;
+      if (volta) {
+        for (const [tool, pinnedVersion] of Object.entries(volta)) {
+          const latest = toolVersions[tool];
+          if (latest && semver2.lt(pinnedVersion, latest)) {
+            result.warnings.push(
+              `${label} volta.${tool} "${pinnedVersion}" is older than latest ${tool === "node" ? "LTS " : ""}version ${latest}`
+            );
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function logSummary(errors, fixed) {
+  if (fixed > 0) {
+    console.log(chalk3.green(`
+  Fixed ${fixed} issue(s)`));
+  }
+  if (errors > 0) {
+    console.log(chalk3.red(`
+  ${errors} error(s) found`));
+  } else if (fixed === 0) {
+    console.log(chalk3.green("\n  All checks passed"));
+  }
+}
+function packageLintMonorepo(fix = false) {
+  const cwd = INIT_CWD();
+  let pkg;
+  try {
+    pkg = readRootPackageJson(cwd);
+  } catch {
+    console.error(chalk3.red("Could not read package.json"));
+    return 1;
+  }
+  if (!isMonorepo(pkg, cwd)) {
+    console.log(chalk3.gray("Not a monorepo \u2014 skipping repo lint checks"));
+    return 0;
+  }
+  console.log(chalk3.green("Repo Lint"));
+  const pm = detectPackageManager();
+  const workspaces = getPackageManager().listWorkspaces();
+  const internalDepCheck = pm === "pnpm" ? {
+    check: () => checkWorkspaceProtocol(cwd, workspaces),
+    fix: () => fixWorkspaceProtocol(cwd, workspaces),
+    label: "Internal deps/devDeps use workspace: protocol"
+  } : {
+    check: () => checkInternalDepVersions(cwd, workspaces),
+    fix: () => fixInternalDepVersions(cwd, workspaces),
+    label: "Internal deps/devDeps use correct version ranges"
+  };
+  const checks2 = [
+    {
+      check: () => checkRootPrivate(pkg),
+      fix: fixRootPrivate,
+      label: "Root package is private"
+    },
+    {
+      check: () => checkNoPublishConfigOnPrivate(pkg),
+      fix: fixNoPublishConfigOnPrivate,
+      label: "No publishConfig on private root"
+    },
+    { check: () => checkPackagesFolder(workspaces), label: "All packages are in packages/ folder" },
+    {
+      check: () => checkWorkspacesFieldPlacement(cwd, pm, workspaces),
+      fix: () => fixWorkspacesFieldPlacement(cwd, pm, workspaces),
+      label: pm === "pnpm" ? "No workspaces field in package.json (use pnpm-workspace.yaml)" : "Workspaces field only in root package.json"
+    },
+    {
+      check: () => checkWorkspaceGlobCoverage(pkg, cwd, pm, workspaces),
+      label: "Workspace globs cover all packages"
+    },
+    {
+      check: () => checkNoPackageManagerInWorkspaces(cwd, workspaces),
+      fix: () => fixNoPackageManagerInWorkspaces(cwd, pkg, workspaces),
+      label: "No packageManager in workspace packages"
+    },
+    {
+      check: () => checkVoltaOnlyInRoot(cwd, workspaces),
+      fix: () => fixVoltaOnlyInRoot(cwd, pkg, workspaces),
+      label: "Volta only in root package.json"
+    },
+    {
+      check: () => checkEnginesOnlyInNonTerminal(cwd, workspaces),
+      fix: () => fixEnginesOnlyInNonTerminal(cwd, pkg, workspaces),
+      label: "Engines only in non-terminal (library) packages"
+    },
+    {
+      check: () => checkVersionsIncludeLts(cwd, workspaces),
+      label: "Engine/volta versions include latest LTS"
+    },
+    {
+      check: () => checkVersionConsistency(cwd, pkg, workspaces),
+      fix: () => fixVersionConsistency(cwd, pkg, writeRootPackageJson, workspaces),
+      label: "Consistent versions across packages"
+    },
+    internalDepCheck,
+    {
+      check: () => checkInternalPeerVersions(cwd, workspaces),
+      fix: () => fixInternalPeerVersions(cwd, workspaces),
+      label: "Internal peerDeps use semver ranges (not workspace: protocol)"
+    }
+  ];
+  const { errors, fixed } = runChecks(checks2, cwd, pkg, fix);
+  logSummary(errors, fixed);
+  if (fix && fixed > 0) {
+    runInstall();
+  }
+  return errors > 0 ? 1 : 0;
+}
+
+// src/actions/packman/convertToPnpm.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import {
+  existsSync as existsSync5,
+  mkdirSync,
+  readFileSync as readFileSync5,
+  rmSync,
+  writeFileSync as writeFileSync5
+} from "fs";
+import PATH4 from "path";
+import chalk6 from "chalk";
+
+// src/actions/packman/rewriteScripts.ts
+function rewriteYarnToPnpm(script) {
+  let result = script;
+  result = result.replaceAll(/\byarn workspace (\S+) run /g, "pnpm --filter $1 run ");
+  result = result.replaceAll(/\byarn workspace (\S+) (package-\S+)/g, "pnpm --filter $1 run $2");
+  result = result.replaceAll(/\byarn workspaces foreach\s+(?:[^\s]*\s+)*run /g, "pnpm -r run ");
+  result = result.replaceAll(/\byarn workspaces foreach --all version (\S+) --deferred/g, "pnpm -r exec npm version $1 --no-git-tag-version");
+  result = result.replaceAll(/\byarn version apply --all/g, 'echo "versions applied"');
+  result = result.replaceAll(/\byarn xy\b/g, "pnpm xy");
+  result = result.replaceAll(/\byarn add\b/g, "pnpm add");
+  result = result.replaceAll(/\byarn remove\b/g, "pnpm remove");
+  result = result.replaceAll(/\byarn install\b/g, "pnpm install");
+  result = result.replaceAll(/\byarn dedupe\b/g, "pnpm dedupe");
+  result = result.replaceAll(/\byarn outdated\b/g, "pnpm outdated");
+  result = result.replaceAll(/\byarn run\b/g, "pnpm run");
+  result = result.replaceAll(/\byarn rimraf\b/g, "rimraf");
+  result = result.replaceAll(/\byarn npm\b/g, "npm");
+  result = result.replaceAll(/\byarn\b(?![@/.])/g, "pnpm");
+  return result;
+}
+function rewritePnpmToYarn(script) {
+  let result = script;
+  result = result.replaceAll(/\bpnpm --filter (\S+) run /g, "yarn workspace $1 run ");
+  result = result.replaceAll(/\bpnpm -r run /g, "yarn workspaces foreach -Apt run ");
+  result = result.replaceAll(/\bpnpm -r exec npm version (\S+) --no-git-tag-version/g, "yarn workspaces foreach --all version $1 --deferred");
+  result = result.replaceAll(/\bpnpm xy\b/g, "yarn xy");
+  result = result.replaceAll(/\bpnpm add\b/g, "yarn add");
+  result = result.replaceAll(/\bpnpm remove\b/g, "yarn remove");
+  result = result.replaceAll(/\bpnpm install\b/g, "yarn install");
+  result = result.replaceAll(/\bpnpm dedupe\b/g, "yarn dedupe");
+  result = result.replaceAll(/\bpnpm outdated\b/g, "yarn outdated");
+  result = result.replaceAll(/\bpnpm run\b/g, "yarn run");
+  result = result.replaceAll(/\bpnpm\b(?![@/.])/g, "yarn");
+  return result;
+}
+function rewriteScript(script, direction) {
+  return direction === "yarn-to-pnpm" ? rewriteYarnToPnpm(script) : rewritePnpmToYarn(script);
+}
+function rewriteScriptsInPackageJson(pkg, direction) {
+  const scripts = pkg.scripts;
+  if (!scripts) return pkg;
+  const rewritten = {};
+  for (const [name, script] of Object.entries(scripts)) {
+    rewritten[name] = rewriteScript(script, direction);
+  }
+  return { ...pkg, scripts: rewritten };
+}
+
+// src/actions/packman/rewriteSourceImports.ts
+import {
+  existsSync as existsSync3,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import chalk4 from "chalk";
+import { globSync } from "glob";
+var IMPORT_SWAP_MAP = {
+  "yarn-to-pnpm": [
+    ["@xylabs/ts-scripts-yarn3", "@xylabs/ts-scripts-pnpm"],
+    ["@xylabs/ts-scripts-react-yarn3", "@xylabs/ts-scripts-react-pnpm"]
+  ],
+  "pnpm-to-yarn": [
+    ["@xylabs/ts-scripts-pnpm", "@xylabs/ts-scripts-yarn3"],
+    ["@xylabs/ts-scripts-react-pnpm", "@xylabs/ts-scripts-react-yarn3"]
+  ]
+};
+var SOURCE_GLOBS = [
+  "**/*.ts",
+  "**/*.tsx",
+  "**/*.mts",
+  "**/*.cts",
+  "**/*.js",
+  "**/*.mjs"
+];
+var IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.yarn/**"
+];
+function rewriteSourceImports(cwd, direction) {
+  const swaps = IMPORT_SWAP_MAP[direction];
+  const files = globSync(SOURCE_GLOBS, {
+    cwd,
+    absolute: true,
+    ignore: IGNORE_PATTERNS
+  });
+  let count = 0;
+  for (const file of files) {
+    if (!existsSync3(file)) continue;
+    const original = readFileSync3(file, "utf8");
+    let content = original;
+    for (const [from, to] of swaps) {
+      content = content.replaceAll(from, to);
+    }
+    if (content !== original) {
+      writeFileSync3(file, content, "utf8");
+      count++;
+    }
+  }
+  if (count > 0) {
+    console.log(chalk4.green(`  Rewrote ts-scripts imports in ${count} source file(s)`));
+  }
+}
+
+// src/actions/packman/swapTsScriptsDependency.ts
+import {
+  existsSync as existsSync4,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync4
+} from "fs";
+import PATH3 from "path";
+import chalk5 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 (!existsSync4(pkgPath)) return false;
+  const raw = readFileSync4(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) {
+    writeFileSync4(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  }
+  return changed;
+}
+function swapTsScriptsDependency(cwd, workspacePackageJsonPaths, direction) {
+  let count = 0;
+  if (swapInPackageJson(PATH3.join(cwd, "package.json"), direction)) {
+    count++;
+  }
+  for (const pkgPath of workspacePackageJsonPaths) {
+    const fullPath = PATH3.resolve(cwd, 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(chalk5.green(`  Swapped ts-scripts dependency to ${target} in ${count} package(s)`));
+  }
+}
+
+// src/actions/packman/convertToPnpm.ts
+var PNPM_VERSION = "10.12.1";
+function createPnpmWorkspaceYaml(cwd, workspacePatterns) {
+  const lines = ["packages:"];
+  for (const pattern of workspacePatterns) {
+    lines.push(`  - '${pattern}'`);
+  }
+  writeFileSync5(PATH4.join(cwd, "pnpm-workspace.yaml"), lines.join("\n") + "\n", "utf8");
+  console.log(chalk6.green("  Created pnpm-workspace.yaml"));
+}
+function readPnpmWorkspacePatterns(cwd) {
+  const wsPath = PATH4.join(cwd, "pnpm-workspace.yaml");
+  if (!existsSync5(wsPath)) return [];
+  const content = readFileSync5(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(cwd) {
+  const pkgPath = PATH4.join(cwd, "package.json");
+  const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
+  const workspacePatterns = pkg.workspaces ?? readPnpmWorkspacePatterns(cwd);
+  delete pkg.workspaces;
+  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"));
+  return workspacePatterns;
+}
+function updateGitignore(cwd) {
+  const gitignorePath = PATH4.join(cwd, ".gitignore");
+  if (!existsSync5(gitignorePath)) return;
+  let content = readFileSync5(gitignorePath, "utf8");
+  const yarnLines = [
+    ".pnp.*",
+    ".pnp",
+    ".yarn/*",
+    "!.yarn/patches",
+    "!.yarn/plugins",
+    "!.yarn/releases",
+    "!.yarn/sdks",
+    "!.yarn/versions"
+  ];
+  for (const line of yarnLines) {
+    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");
+  writeFileSync5(gitignorePath, content, "utf8");
+  console.log(chalk6.green("  Updated .gitignore"));
+}
+function deleteYarnArtifacts(cwd) {
+  const yarnLock = PATH4.join(cwd, "yarn.lock");
+  const yarnrc = PATH4.join(cwd, ".yarnrc.yml");
+  const yarnDir = PATH4.join(cwd, ".yarn");
+  if (existsSync5(yarnLock)) {
+    rmSync(yarnLock);
+    console.log(chalk6.gray("  Deleted yarn.lock"));
+  }
+  if (existsSync5(yarnrc)) {
+    rmSync(yarnrc);
+    console.log(chalk6.gray("  Deleted .yarnrc.yml"));
+  }
+  if (existsSync5(yarnDir)) {
+    rmSync(yarnDir, { force: true, recursive: true });
+    console.log(chalk6.gray("  Deleted .yarn/"));
+  }
+}
+function createNpmrc(cwd) {
+  const npmrcPath = PATH4.join(cwd, ".npmrc");
+  if (existsSync5(npmrcPath)) return;
+  mkdirSync(PATH4.dirname(npmrcPath), { recursive: true });
+  writeFileSync5(npmrcPath, "", "utf8");
+  console.log(chalk6.green("  Created .npmrc"));
+}
+function convertToPnpm(cwd, workspacePackageJsonPaths) {
+  console.log(chalk6.blue("\nConverting to pnpm...\n"));
+  const workspacePatterns = updateRootPackageJson(cwd);
+  createPnpmWorkspaceYaml(cwd, workspacePatterns);
+  for (const pkgPath of workspacePackageJsonPaths) {
+    const fullPath = PATH4.resolve(cwd, pkgPath, "package.json");
+    if (!existsSync5(fullPath)) continue;
+    const pkg = JSON.parse(readFileSync5(fullPath, "utf8"));
+    const updated = rewriteScriptsInPackageJson(pkg, "yarn-to-pnpm");
+    if (JSON.stringify(pkg) !== JSON.stringify(updated)) {
+      writeFileSync5(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    }
+  }
+  console.log(chalk6.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..."));
+  const install = spawnSync2("pnpm", ["install"], {
+    cwd,
+    encoding: "utf8",
+    shell: true,
+    stdio: "inherit"
+  });
+  if (install.status !== 0) {
+    console.error(chalk6.red("pnpm install failed"));
+    return 1;
+  }
+  console.log(chalk6.blue("\nConversion complete.\n"));
+  return 0;
+}
+
+// src/actions/packman/convertToYarn.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import {
+  existsSync as existsSync6,
+  readFileSync as readFileSync6,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync6
+} from "fs";
+import PATH5 from "path";
+import chalk7 from "chalk";
+var YARN_VERSION = "4.13.0";
+var YARNRC_TEMPLATE = `compressionLevel: mixed
+
+enableGlobalCache: true
+
+enableInlineBuilds: true
+
+nmHoistingLimits: none
+
+nodeLinker: node-modules
+`;
+var YARN_GITIGNORE_ENTRIES = `
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+`;
+function readPnpmWorkspacePatterns2(cwd) {
+  const wsPath = PATH5.join(cwd, "pnpm-workspace.yaml");
+  if (!existsSync6(wsPath)) return [];
+  const content = readFileSync6(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 updateRootPackageJson2(cwd, workspacePatterns) {
+  const pkgPath = PATH5.join(cwd, "package.json");
+  const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+  pkg.workspaces = 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"));
+}
+function updateGitignore2(cwd) {
+  const gitignorePath = PATH5.join(cwd, ".gitignore");
+  let content = existsSync6(gitignorePath) ? readFileSync6(gitignorePath, "utf8") : "";
+  if (!content.includes(".yarn/*")) {
+    content = content.trimEnd() + "\n" + YARN_GITIGNORE_ENTRIES;
+  }
+  writeFileSync6(gitignorePath, content, "utf8");
+  console.log(chalk7.green("  Updated .gitignore"));
+}
+function deletePnpmArtifacts(cwd) {
+  const lockfile = PATH5.join(cwd, "pnpm-lock.yaml");
+  const workspaceYaml = PATH5.join(cwd, "pnpm-workspace.yaml");
+  const npmrc = PATH5.join(cwd, ".npmrc");
+  if (existsSync6(lockfile)) {
+    rmSync2(lockfile);
+    console.log(chalk7.gray("  Deleted pnpm-lock.yaml"));
+  }
+  if (existsSync6(workspaceYaml)) {
+    rmSync2(workspaceYaml);
+    console.log(chalk7.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"));
+    }
+  }
+}
+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"));
+}
+function readWorkspacePatternsFromPackageJson(cwd) {
+  const pkgPath = PATH5.join(cwd, "package.json");
+  if (!existsSync6(pkgPath)) return [];
+  const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+  return pkg.workspaces ?? [];
+}
+function convertToYarn(cwd, workspacePackageJsonPaths) {
+  console.log(chalk7.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"));
+    }
+  }
+  updateRootPackageJson2(cwd, workspacePatterns);
+  for (const pkgPath of workspacePackageJsonPaths) {
+    const fullPath = PATH5.resolve(cwd, pkgPath, "package.json");
+    if (!existsSync6(fullPath)) continue;
+    const pkg = JSON.parse(readFileSync6(fullPath, "utf8"));
+    const updated = rewriteScriptsInPackageJson(pkg, "pnpm-to-yarn");
+    if (JSON.stringify(pkg) !== JSON.stringify(updated)) {
+      writeFileSync6(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    }
+  }
+  console.log(chalk7.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..."));
+  const install = spawnSync3("yarn", ["install"], {
+    cwd,
+    encoding: "utf8",
+    shell: true,
+    stdio: "inherit"
+  });
+  if (install.status !== 0) {
+    console.error(chalk7.red("yarn install failed"));
+    return 1;
+  }
+  console.log(chalk7.blue("\nConversion complete.\n"));
+  return 0;
+}
+
+// src/actions/packman/convert.ts
+function detectCurrentPM(cwd) {
+  if (existsSync7(PATH6.join(cwd, "pnpm-lock.yaml")) || existsSync7(PATH6.join(cwd, "pnpm-workspace.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync7(PATH6.join(cwd, "yarn.lock")) || existsSync7(PATH6.join(cwd, ".yarnrc.yml"))) {
+    return "yarn";
+  }
+  return "unknown";
+}
+function findWorkspacePackagePaths(cwd) {
+  const pkgPath = PATH6.join(cwd, "package.json");
+  const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
+  const patterns = pkg.workspaces ?? [];
+  if (patterns.length === 0) {
+    const wsPath = PATH6.join(cwd, "pnpm-workspace.yaml");
+    if (existsSync7(wsPath)) {
+      const content = readFileSync7(wsPath, "utf8");
+      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;
+        }
+      }
+    }
+  }
+  const dirs = [];
+  for (const pattern of patterns) {
+    const resolved = resolveWorkspaceGlob(cwd, pattern);
+    dirs.push(...resolved);
+  }
+  return dirs;
+}
+function resolveWorkspaceGlob(cwd, pattern) {
+  const parts = pattern.split("/");
+  return walkGlob(cwd, parts, "");
+}
+function walkGlob(basePath, parts, currentPath) {
+  if (parts.length === 0) {
+    const fullPath = PATH6.join(basePath, currentPath);
+    if (existsSync7(PATH6.join(fullPath, "package.json"))) {
+      return [currentPath];
+    }
+    return [];
+  }
+  const [part, ...rest] = parts;
+  const dirPath = PATH6.join(basePath, currentPath);
+  if (!existsSync7(dirPath) || !statSync(dirPath).isDirectory()) {
+    return [];
+  }
+  if (part === "*" || part === "**") {
+    const entries = readdirSync(dirPath, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules" && e.name !== "dist");
+    const results = [];
+    if (part === "**") {
+      results.push(...walkGlob(basePath, rest, currentPath));
+    }
+    for (const entry of entries) {
+      const subPath2 = currentPath ? `${currentPath}/${entry.name}` : entry.name;
+      if (part === "**") {
+        results.push(
+          ...walkGlob(basePath, rest, subPath2),
+          ...walkGlob(basePath, parts, subPath2)
+        );
+      } else {
+        results.push(...walkGlob(basePath, rest, subPath2));
+      }
+    }
+    return results;
+  }
+  const subPath = currentPath ? `${currentPath}/${part}` : part;
+  return walkGlob(basePath, rest, subPath);
+}
+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(", ")}`));
+    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}`));
+  }
+  if (currentPM === target) {
+    console.log(chalk8.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."));
+    return 1;
+  }
+  const workspacePaths = findWorkspacePackagePaths(cwd);
+  if (verbose) {
+    console.log(chalk8.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..."));
+  packageLintMonorepo(true);
+  return result;
+}
+
+// src/actions/packman/clean.ts
+function removeNodeModules(dir, verbose) {
+  const nmPath = PATH7.join(dir, "node_modules");
+  if (existsSync8(nmPath)) {
+    if (verbose) console.log(chalk9.gray(`Removing ${nmPath}`));
+    rmSync3(nmPath, { force: true, recursive: true });
+    return true;
+  }
+  return false;
+}
+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."));
+    return 1;
+  }
+  console.log(chalk9.blue(`Detected package manager: ${pm}`));
+  let removedCount = 0;
+  if (removeNodeModules(cwd, verbose)) removedCount++;
+  const workspacePaths = findWorkspacePackagePaths(cwd);
+  for (const wsPath of workspacePaths) {
+    const fullPath = PATH7.join(cwd, wsPath);
+    if (removeNodeModules(fullPath, verbose)) removedCount++;
+  }
+  console.log(chalk9.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"));
+    }
+  } 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(chalk9.green("Ready for a clean install"));
+  return 0;
+}
+
+// src/actions/packman/lint.ts
+import {
+  existsSync as existsSync9,
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync8
+} from "fs";
+import PATH8 from "path";
+import chalk10 from "chalk";
+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"));
+    return true;
+  }
+  const content = readFileSync8(yarnrcPath, "utf8");
+  const lines = content.split("\n");
+  for (const line of lines) {
+    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"));
+        return true;
+      }
+      if (!silent) console.log(chalk10.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)"));
+  return false;
+}
+function fixEnableScripts(cwd, verbose) {
+  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;
+  }
+  const content = readFileSync8(yarnrcPath, "utf8");
+  const lines = content.split("\n");
+  let found = false;
+  const newLines = lines.map((line) => {
+    if (/^\s*enableScripts\s*:/.test(line)) {
+      found = true;
+      return "enableScripts: false";
+    }
+    return line;
+  });
+  if (!found) {
+    let inserted = false;
+    for (let i = 0; i < newLines.length; i++) {
+      const trimmed = newLines[i].trim();
+      if (trimmed && !trimmed.startsWith("#") && trimmed > "enableScripts:") {
+        newLines.splice(i, 0, "enableScripts: false", "");
+        inserted = true;
+        break;
+      }
+    }
+    if (!inserted) {
+      const lastLine = newLines.at(-1);
+      if (lastLine === "") {
+        newLines.splice(-1, 0, "enableScripts: false", "");
+      } else {
+        newLines.push("", "enableScripts: false");
+      }
+    }
+  }
+  writeFileSync8(yarnrcPath, newLines.join("\n"), "utf8");
+  console.log(chalk10.green("  Fixed: enableScripts set to false"));
+  return true;
+}
+var checks = [
+  {
+    name: "enableScripts should be false in .yarnrc.yml",
+    check: checkEnableScripts,
+    fix: fixEnableScripts
+  }
+];
+function packmanLint({ fix, verbose } = {}) {
+  const cwd = process.cwd();
+  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++;
+      }
+    }
+  }
+  if (failures > 0) {
+    console.log(chalk10.red(`
+packman lint: ${failures} check(s) failed`));
+    if (!fix) {
+      console.log(chalk10.yellow("Run with --fix to auto-fix issues"));
+    }
+  } else {
+    console.log(chalk10.green("\npackman lint: all checks passed"));
+  }
+  return failures > 0 ? 1 : 0;
+}
+export {
+  convert,
+  detectCurrentPM,
+  findWorkspacePackagePaths,
+  packmanClean,
+  packmanLint,
+  rewriteScript,
+  rewriteScriptsInPackageJson
+};
+//# sourceMappingURL=index.mjs.map