@xylabs/ts-scripts-common 7.5.0

package/dist/actions/index.mjs

@@ -0,0 +1,4129 @@
+// src/actions/build.ts
+import chalk9 from "chalk";
+
+// src/lib/checkResult.ts
+import chalk from "chalk";
+var checkResult = (name, result, level = "error", exitOnFail = false) => {
+  if (result) {
+    const exiting = exitOnFail ? "[Exiting Process]" : "[Continuing]";
+    const chalkFunc = level === "error" ? chalk.red : chalk.yellow;
+    console[level](chalkFunc(`${name} had ${result} failures ${exiting}`));
+    if (exitOnFail) {
+      process.exit(result);
+    }
+  }
+};
+
+// src/lib/claudeMdTemplate.ts
+import {
+  readdirSync,
+  readFileSync,
+  statSync
+} from "fs";
+import { createRequire } from "module";
+import PATH from "path";
+var require2 = createRequire(import.meta.url);
+var packageRoot = PATH.dirname(require2.resolve("@xylabs/ts-scripts-common/package.json"));
+var templatesDir = PATH.resolve(packageRoot, "templates", "claude");
+var XYLABS_RULES_PREFIX = "xylabs-";
+var XYLABS_COMMANDS_PREFIX = "xy-";
+var LEGACY_COMMANDS_PREFIX = "xylabs-";
+var XYLABS_SKILLS_PREFIX = "xylabs-";
+var claudeMdRuleTemplates = () => {
+  const rulesDir = PATH.resolve(templatesDir, "rules");
+  const files = readdirSync(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md"));
+  const result = {};
+  for (const file of files) {
+    result[file] = readFileSync(PATH.resolve(rulesDir, file), "utf8");
+  }
+  return result;
+};
+var claudeCommandTemplates = () => {
+  const commandsDir = PATH.resolve(templatesDir, "commands");
+  const files = readdirSync(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md"));
+  const result = {};
+  for (const file of files) {
+    result[file] = readFileSync(PATH.resolve(commandsDir, file), "utf8");
+  }
+  return result;
+};
+var claudeSkillTemplates = () => {
+  const skillsDir = PATH.resolve(templatesDir, "skills");
+  const dirs = readdirSync(skillsDir).filter(
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync(PATH.resolve(skillsDir, f)).isDirectory()
+  );
+  const result = {};
+  for (const dir of dirs) {
+    const dirPath = PATH.resolve(skillsDir, dir);
+    const files = readdirSync(dirPath, { recursive: true, encoding: "utf8" });
+    result[dir] = {};
+    for (const file of files) {
+      if (statSync(PATH.resolve(dirPath, file)).isFile()) {
+        result[dir][file] = readFileSync(PATH.resolve(dirPath, file), "utf8");
+      }
+    }
+  }
+  return result;
+};
+var claudeMdLocalTemplate = () => readFileSync(PATH.resolve(templatesDir, "CLAUDE-local.md"), "utf8");
+
+// src/lib/deleteGlob.ts
+import fs from "fs";
+import { glob } from "glob";
+var deleteGlob = (globPath) => {
+  const files = glob.sync(globPath);
+  for (const file of files) {
+    fs.rmSync(file, { recursive: true, force: true });
+  }
+};
+
+// src/lib/dependencies/detectDuplicateDependencies.ts
+import { execSync } from "child_process";
+
+// 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}". Install @xylabs/ts-scripts-${pmName === "yarn" ? "yarn3" : pmName} and ensure it is imported.`
+    );
+  }
+  return pm;
+}
+
+// src/lib/processEx.ts
+import chalk2 from "chalk";
+
+// src/lib/withError.ts
+var withError = (ex, closure, predicate = (ex2) => !!ex2.name && !!ex2.message) => {
+  return predicate(ex) ? closure(ex) : void 0;
+};
+
+// src/lib/withErrnoException.ts
+var withErrnoException = (ex, closure) => {
+  return withError(ex, closure, (ex2) => ex2.errno !== void 0);
+};
+
+// src/lib/processEx.ts
+var processEx = (ex) => {
+  const error = typeof ex === "string" ? new Error(ex) : ex;
+  const exitCode = withErrnoException(error, (error2) => {
+    if (error2.code === "ENOENT") {
+      console.error(chalk2.red(`'${error2.path}' not found.`));
+    } else {
+      console.error(chalk2.red(`Errno: ${error2.code}`));
+    }
+    return error2.errno ?? -1;
+  }) ?? withError(error, (error2) => {
+    console.error(chalk2.red(`${error2.name}: ${error2.message}`));
+    return -1;
+  }) ?? (() => {
+    console.error(chalk2.red(`Unexpected Error: ${JSON.stringify(ex, null, 2)}`));
+    return -1;
+  })();
+  process.exit(process.exitCode ?? exitCode);
+};
+
+// src/lib/safeExit.ts
+var safeExit = (func, exitOnFail = true) => {
+  try {
+    const result = func();
+    if (result && exitOnFail) {
+      process.exit(result);
+    }
+    return result;
+  } catch (ex) {
+    return processEx(ex);
+  }
+};
+var safeExitAsync = async (func, exitOnFail = true) => {
+  try {
+    const result = await func();
+    if (result && exitOnFail) {
+      process.exit(result);
+    }
+    return result;
+  } catch (ex) {
+    return processEx(ex);
+  }
+};
+
+// src/lib/dependencies/DuplicateDetector.ts
+import { EOL } from "os";
+import chalk3 from "chalk";
+
+// src/lib/jsonFormatters.ts
+var multiLineToJSONArray = (output) => {
+  const withCommas = output.replaceAll("\r\n", "").replaceAll("\n", ",");
+  const cleanCollection = withCommas.slice(0, Math.max(0, withCommas.length - 1));
+  const collection = `[${cleanCollection}]`;
+  return JSON.parse(collection);
+};
+
+// src/lib/dependencies/DuplicateDetector.ts
+var trimVirtualMeta = (value) => {
+  const virtualParts = value.split("virtual:");
+  if (virtualParts.length > 1) {
+    const hashParts = virtualParts[1].split("#");
+    return virtualParts[0] + hashParts[1];
+  } else {
+    return value;
+  }
+};
+var trimObjectDependencyVirtualMeta = (obj) => {
+  const resultObj = {};
+  for (const [key, value] of Object.entries(obj)) {
+    resultObj[trimVirtualMeta(key)] = {
+      descriptor: trimVirtualMeta(value.descriptor),
+      locator: trimVirtualMeta(value.locator)
+    };
+  }
+  return resultObj;
+};
+var trimDependencyVirtualMeta = (dependencies) => {
+  return dependencies.map((dependency) => {
+    return { children: trimObjectDependencyVirtualMeta(dependency.children), value: trimVirtualMeta(dependency.value) };
+  });
+};
+var DuplicateDetector = class {
+  dependency;
+  dependencyEntries;
+  constructor(output, dependency) {
+    this.dependency = dependency;
+    this.dependencyEntries = trimDependencyVirtualMeta(multiLineToJSONArray(output));
+  }
+  detect() {
+    const result = this.dependencyEntries.reduce(this.detectReducer, this.resultsFactory(this.dependency));
+    if (result.duplicateVersions.length > 0) {
+      console.log(chalk3.yellow(`${EOL}Duplicates found for: ${this.dependency}`));
+      const duplicateVersions = result.duplicateVersions.toString().replaceAll(",", `${EOL}  `);
+      console.log(chalk3.grey(`  ${duplicateVersions}`, EOL));
+      return 1;
+    } else {
+      console.log(`${this.dependency} - OK`);
+      return 0;
+    }
+  }
+  detectReducer(acc, entry) {
+    const version = Object.entries(entry.children).map(([k]) => k)[0];
+    if (!acc.currentVersion) {
+      acc.currentVersion = version;
+      return acc;
+    }
+    if (acc.currentVersion && acc.currentVersion !== version && !version.includes("@virtual:")) {
+      if (acc.duplicateVersions.length === 0) {
+        acc.duplicateVersions.push(acc.currentVersion);
+      }
+      acc.duplicateVersions.push(version);
+      acc.duplicateVersions = [...new Set(acc.duplicateVersions)];
+    }
+    return acc;
+  }
+  resultsFactory = (dependency) => ({
+    currentVersion: void 0,
+    dependency,
+    duplicateVersions: []
+  });
+};
+
+// src/lib/dependencies/detectDuplicateDependencies.ts
+var detectDuplicateDependencies = (depsFromPackageJSON, DefaultDependencies2) => {
+  let exitCode = 0;
+  const dependencies = depsFromPackageJSON?.length ? depsFromPackageJSON : DefaultDependencies2;
+  return safeExit(() => {
+    if (dependencies) {
+      for (const dependency of dependencies) {
+        let output;
+        try {
+          const pm = getPackageManager();
+          const cmd = `${pm.command} why ${dependency} --json`;
+          output = execSync(cmd).toString();
+        } catch (e) {
+          console.error(`Error running dependency check: ${e}`);
+          exitCode = 1;
+          continue;
+        }
+        if (output) {
+          exitCode = new DuplicateDetector(output, dependency).detect();
+        } else {
+          console.log(`${dependency} - N/A`);
+          if (depsFromPackageJSON) {
+            exitCode = 1;
+            console.log(`\u{1F6A8} Library ${dependency} was requested in package.json but not found`);
+          }
+        }
+      }
+      return exitCode;
+    } else {
+      console.log("\u{1F6A8} No dependencies where passed");
+      return exitCode;
+    }
+  });
+};
+
+// src/lib/file/constants.ts
+var WINDOWS_NEWLINE_REGEX = /\r\n/g;
+var CROSS_PLATFORM_NEWLINE = "\n";
+
+// src/lib/file/fileLines.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  writeFileSync
+} from "fs";
+
+// src/lib/string/empty.ts
+var empty = (value) => value?.trim().length === 0;
+var notEmpty = (value) => !empty(value);
+
+// src/lib/string/union.ts
+var union = (a, b) => /* @__PURE__ */ new Set([...new Set(a), ...new Set(b)]);
+
+// src/lib/file/ReadFileSyncOptions.ts
+var defaultReadFileSyncOptions = { encoding: "utf8" };
+
+// src/lib/file/fileLines.ts
+var readLines = (uri, options = defaultReadFileSyncOptions) => existsSync2(uri) ? readFileSync2(uri, options).replace(WINDOWS_NEWLINE_REGEX, CROSS_PLATFORM_NEWLINE).split(CROSS_PLATFORM_NEWLINE) : [];
+var readNonEmptyLines = (uri, options = defaultReadFileSyncOptions) => readLines(uri, options).filter(notEmpty);
+var writeLines = (uri, lines, options = defaultReadFileSyncOptions) => {
+  const existing = existsSync2(uri) ? readFileSync2(uri, options) : void 0;
+  const desired = lines.join(CROSS_PLATFORM_NEWLINE);
+  if (existing !== desired) writeFileSync(uri, desired, options);
+};
+
+// src/lib/generateIgnoreFiles.ts
+import chalk4 from "chalk";
+
+// src/lib/initCwd.ts
+function INIT_CWD() {
+  if (!process.env.INIT_CWD) console.error("Missing INIT_CWD");
+  return process.env.INIT_CWD;
+}
+
+// src/lib/generateIgnoreFiles.ts
+var localeCompare = (a, b) => a.localeCompare(b);
+var mergeEntries = (a, b) => [...union(a, b)].toSorted(localeCompare);
+var generateIgnoreFiles = (filename2, pkg) => {
+  console.log(chalk4.green(`Generate ${filename2} Files`));
+  const cwd5 = INIT_CWD() ?? ".";
+  const pm = getPackageManager();
+  const singleWorkspace = pkg ? pm.findWorkspace(pkg) : void 0;
+  const workspaces = singleWorkspace ? [singleWorkspace] : pm.listWorkspaces();
+  const readEntries = (location) => readNonEmptyLines(`${location}/${filename2}`);
+  const writeEntries = (location, entries) => writeLines(`${location}/${filename2}`, entries);
+  const results = workspaces.map(({ location, name }) => {
+    try {
+      writeEntries(location, mergeEntries(readEntries(cwd5), readEntries(location)));
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`Generate ${filename2} Files [${name}] [${error.message}]`);
+      return 1;
+    }
+  });
+  const succeeded = results.every((result) => result === 0);
+  return succeeded ? 0 : 1;
+};
+
+// src/lib/generateReadmeFiles.ts
+import { execSync as execSync2 } from "child_process";
+import FS, { readFileSync as readFileSync3 } from "fs";
+import {
+  mkdir,
+  readFile,
+  writeFile
+} from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import PATH2 from "path";
+import { createInterface } from "readline";
+import chalk5 from "chalk";
+var require3 = createRequire2(import.meta.url);
+var packageRoot2 = PATH2.dirname(require3.resolve("@xylabs/ts-scripts-common/package.json"));
+var readmeTemplatesDir = PATH2.resolve(packageRoot2, "templates", "readme");
+function fillTemplate(template, data) {
+  const additionalData = { ...data, safeName: data.name.replaceAll("/", "__").replaceAll("@", "") };
+  return template.replaceAll(/\{\{(.*?)\}\}/g, (_, key) => additionalData[key.trim()] ?? "");
+}
+function generateTypedoc(packageLocation, entryPoints) {
+  const tempDir = PATH2.join(packageLocation, ".temp-typedoc");
+  try {
+    if (!FS.existsSync(tempDir)) {
+      FS.mkdirSync(tempDir, { recursive: true });
+    }
+    const typedocConfig = {
+      disableSources: true,
+      entryPointStrategy: "expand",
+      entryPoints: entryPoints.map((ep) => PATH2.resolve(packageLocation, ep)),
+      excludeExternals: true,
+      excludeInternal: true,
+      excludePrivate: true,
+      githubPages: false,
+      hideBreadcrumbs: true,
+      hideGenerator: true,
+      hidePageTitle: true,
+      out: tempDir,
+      plugin: ["typedoc-plugin-markdown"],
+      readme: "none",
+      skipErrorChecking: true,
+      sort: ["source-order"],
+      theme: "markdown",
+      useCodeBlocks: true
+    };
+    const typedocJsonPath = PATH2.join(tempDir, "typedoc.json");
+    FS.writeFileSync(typedocJsonPath, JSON.stringify(typedocConfig, null, 2));
+    try {
+      execSync2(`npx typedoc --options ${typedocJsonPath}`, {
+        cwd: process.cwd(),
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch {
+      return "";
+    }
+    return consolidateMarkdown(tempDir);
+  } catch {
+    return "";
+  } finally {
+    try {
+      FS.rmSync(tempDir, { force: true, recursive: true });
+    } catch {
+    }
+  }
+}
+function consolidateMarkdown(tempDir) {
+  let consolidated = "## Reference\n\n";
+  const mainReadmePath = PATH2.join(tempDir, "README.md");
+  if (FS.existsSync(mainReadmePath)) {
+    const mainContent = FS.readFileSync(mainReadmePath, "utf8").replace(/^---(.|\n)*?---\n/, "").replace(/^# .+\n/, "").replaceAll(/\]\((.+?)\.md\)/g, "](#$1)");
+    consolidated += mainContent + "\n\n";
+  }
+  consolidated += processDirectory(tempDir);
+  return consolidated.replaceAll(/\n\n\n+/g, "\n\n").replaceAll(/^#### /gm, "### ").replaceAll(/^##### /gm, "#### ").replaceAll(/^###### /gm, "##### ");
+}
+function processDirectory(dir, level = 0) {
+  const indent = "  ".repeat(level);
+  let content = "";
+  try {
+    const items = FS.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+      if (item.isDirectory()) continue;
+      if (item.name === "README.md" || !item.name.endsWith(".md")) continue;
+      const fileContent = FS.readFileSync(PATH2.join(dir, item.name), "utf8").replace(/^---(.|\n)*?---\n/, "");
+      const moduleName = item.name.replace(".md", "");
+      content += `
+
+${indent}### <a id="${moduleName}"></a>${moduleName}
+
+`;
+      content += fileContent.replace(/^# .+\n/, "").replaceAll(/\]\((.+?)\.md\)/g, "](#$1)");
+    }
+    for (const item of items) {
+      if (!item.isDirectory()) continue;
+      if (item.name === "spec" || item.name.includes(".spec")) continue;
+      content += `
+
+${indent}### ${item.name}
+`;
+      content += processDirectory(PATH2.join(dir, item.name), level + 1);
+    }
+  } catch {
+  }
+  return content;
+}
+function askConfirmation(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+var DEFAULT_README_TEMPLATE = readFileSync3(PATH2.resolve(readmeTemplatesDir, "README.template.md"), "utf8");
+var DEFAULT_README_BODY = readFileSync3(PATH2.resolve(readmeTemplatesDir, "README.body.md"), "utf8");
+function applyLogoConfig(template, logoUrl, logoLinkUrl) {
+  let result = template;
+  if (logoUrl) {
+    result = result.replace(/\[logo]: .+/, `[logo]: ${logoUrl}`);
+    if (logoLinkUrl) {
+      result = result.replace(/\[!\[logo]\[]][^)]*\)/, `[![logo][]](${logoLinkUrl})`);
+    }
+  } else {
+    result = result.replace(/\[!\[logo]\[]][^\n]*\n*/, "");
+    result = result.replace(/\[logo]: [^\n]*\n?/, "");
+  }
+  return result;
+}
+function resolveTemplatePath(templatePath) {
+  const cwd5 = INIT_CWD() ?? ".";
+  return templatePath ?? PATH2.join(cwd5, ".xy", "README.template.md");
+}
+async function loadOrCreateTemplate(resolvedTemplatePath) {
+  try {
+    const template = await readFile(resolvedTemplatePath, "utf8");
+    return { created: false, template };
+  } catch {
+    console.log(chalk5.yellow(`Template not found: ${resolvedTemplatePath}`));
+    const shouldCreate = await askConfirmation("Would you like to create a stock template? (y/N) ");
+    if (!shouldCreate) {
+      throw new Error("Template creation declined");
+    }
+    const template = DEFAULT_README_TEMPLATE;
+    await scaffoldTemplate(resolvedTemplatePath, template);
+    return { created: true, template };
+  }
+}
+async function scaffoldTemplate(resolvedTemplatePath, template) {
+  const xyDir = PATH2.dirname(resolvedTemplatePath);
+  await mkdir(xyDir, { recursive: true });
+  await writeFile(resolvedTemplatePath, template);
+  console.log(chalk5.green(`Created template: ${resolvedTemplatePath}`));
+  const bodyPath = PATH2.join(xyDir, "README.body.md");
+  await writeFile(bodyPath, DEFAULT_README_BODY);
+  console.log(chalk5.green(`Created body template: ${bodyPath}`));
+}
+async function resolveBody(location, defaultBody) {
+  const localBodyPath = PATH2.join(location, "README.body.md");
+  try {
+    return await readFile(localBodyPath, "utf8");
+  } catch {
+    return defaultBody;
+  }
+}
+async function generateReadmeForWorkspace(location, name, template, defaultBody, typedoc, verbose) {
+  try {
+    const pkgJsonPath = PATH2.join(location, "package.json");
+    const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf8"));
+    const body = await resolveBody(location, defaultBody);
+    const typedocContent = typedoc ? generateTypedoc(location, ["src/index*.ts"]) : "";
+    const readmeContent = fillTemplate(template, {
+      ...pkgJson,
+      body,
+      typedoc: typedocContent
+    });
+    await writeFile(PATH2.join(location, "README.md"), readmeContent);
+    if (verbose) console.log(chalk5.green(`  ${name}`));
+    return true;
+  } catch (ex) {
+    const error = ex;
+    console.warn(chalk5.yellow(`  Skipped ${location}: ${error.message}`));
+    return false;
+  }
+}
+async function generateReadmeFiles({
+  logoLinkUrl,
+  logoUrl,
+  pkg,
+  templatePath,
+  typedoc = false,
+  verbose = false
+}) {
+  console.log(chalk5.green("Generate README Files"));
+  const resolvedTemplatePath = resolveTemplatePath(templatePath);
+  let template;
+  let templateCreated;
+  try {
+    ({ template, created: templateCreated } = await loadOrCreateTemplate(resolvedTemplatePath));
+  } catch {
+    return 1;
+  }
+  template = applyLogoConfig(template, logoUrl, logoLinkUrl);
+  if (templateCreated) {
+    console.log(chalk5.green("Generating README files for all packages..."));
+  }
+  const xyDir = PATH2.dirname(resolvedTemplatePath);
+  const xyBodyPath = PATH2.join(xyDir, "README.body.md");
+  let defaultBody;
+  try {
+    defaultBody = await readFile(xyBodyPath, "utf8");
+  } catch {
+    defaultBody = DEFAULT_README_BODY;
+  }
+  const pm = getPackageManager();
+  const singleWorkspace = pkg && !templateCreated ? pm.findWorkspace(pkg) : void 0;
+  const workspaces = singleWorkspace ? [singleWorkspace] : pm.listWorkspaces();
+  let failed = false;
+  for (const { location, name } of workspaces) {
+    const success = await generateReadmeForWorkspace(location, name, template, defaultBody, typedoc, verbose);
+    if (!success) failed = true;
+  }
+  return failed ? 1 : 0;
+}
+
+// src/lib/gitignoreTemplate.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { createRequire as createRequire3 } from "module";
+import PATH3 from "path";
+var require4 = createRequire3(import.meta.url);
+var packageRoot3 = PATH3.dirname(require4.resolve("@xylabs/ts-scripts-common/package.json"));
+var templatesDir2 = PATH3.resolve(packageRoot3, "templates", "gitignore");
+var gitignoreTemplate = () => readFileSync4(PATH3.resolve(templatesDir2, "template.gitignore"), "utf8");
+
+// src/lib/loadConfig.ts
+import chalk6 from "chalk";
+import { cosmiconfig } from "cosmiconfig";
+import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
+import deepmerge from "deepmerge";
+var config;
+var loadConfig = async (params) => {
+  if (config === void 0) {
+    const cosmicConfigResult = await cosmiconfig("xy", { cache: true, loaders: { ".ts": TypeScriptLoader() } }).search();
+    config = cosmicConfigResult?.config;
+    const configFilePath = cosmicConfigResult?.filepath;
+    if (configFilePath !== void 0) {
+      console.log(chalk6.green(`Loaded config from ${configFilePath}`));
+      if (config.verbose) {
+        console.log(chalk6.gray(`${JSON.stringify(config, null, 2)}`));
+      }
+    }
+  }
+  return deepmerge(config, params ?? {});
+};
+
+// src/lib/parsedPackageJSON.ts
+import { readFileSync as readFileSync5 } from "fs";
+var parsedPackageJSON = (path15) => {
+  const pathToPackageJSON = path15 ?? process.env.npm_package_json ?? "";
+  const packageJSON = readFileSync5(pathToPackageJSON).toString();
+  return JSON.parse(packageJSON);
+};
+
+// src/lib/runSteps.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import chalk7 from "chalk";
+var runSteps = (name, steps, exitOnFail = true, messages) => {
+  return safeExit(() => {
+    const pkgName = process.env.npm_package_name;
+    console.log(chalk7.green(`${name} [${pkgName}]`));
+    let totalStatus = 0;
+    for (const [i, [command, args, config2]] of steps.entries()) {
+      if (messages?.[i]) {
+        console.log(chalk7.gray(messages?.[i]));
+      }
+      const argList = Array.isArray(args) ? args : args.split(" ");
+      if (command === "node" && !existsSync3(argList[0])) {
+        throw new Error(`File not found [${argList[0]}]`);
+      }
+      const status = spawnSync(command, Array.isArray(args) ? args : args.split(" "), {
+        ...config2,
+        encoding: "utf8",
+        env: { FORCE_COLOR: "3", ...process.env },
+        shell: true,
+        stdio: "inherit"
+      }).status ?? 0;
+      checkResult(name, status, "error", exitOnFail);
+      totalStatus += status ?? 0;
+    }
+    return totalStatus;
+  }, !!exitOnFail);
+};
+
+// src/lib/runStepsAsync.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import chalk8 from "chalk";
+var runStepAsync = (name, step, exitOnFail = true, message) => {
+  return new Promise((resolve) => {
+    const [command, args, config2] = step;
+    if (message) {
+      console.log(chalk8.gray(message));
+    }
+    const argList = Array.isArray(args) ? args : args.split(" ");
+    if (command === "node" && !existsSync4(argList[0])) {
+      throw new Error(`File not found [${argList[0]}]`);
+    }
+    spawn(command, Array.isArray(args) ? args : args.split(" "), {
+      ...config2,
+      env: { FORCE_COLOR: "3", ...process.env },
+      shell: true,
+      stdio: "inherit"
+    }).on("close", (code) => {
+      if (code) {
+        console.error(
+          chalk8.red(
+            `Command Exited With Non-Zero Result [${chalk8.gray(code)}] | ${chalk8.yellow(command)} ${chalk8.white(
+              Array.isArray(args) ? args.join(" ") : args
+            )}`
+          )
+        );
+        checkResult(name, code, "error", exitOnFail);
+        resolve(code);
+      } else {
+        resolve(0);
+      }
+    });
+  });
+};
+var runStepsAsync = async (name, steps, exitOnFail = true, messages) => {
+  return await safeExitAsync(async () => {
+    const pkgName = process.env.npm_package_name;
+    console.log(chalk8.green(`${name} [${pkgName}]`));
+    let result = 0;
+    for (const [i, step] of steps.entries()) {
+      result += await runStepAsync(name, step, exitOnFail, messages?.[i]);
+    }
+    return result;
+  });
+};
+
+// src/actions/build.ts
+var build = async ({
+  incremental,
+  jobs,
+  target,
+  verbose,
+  pkg
+}) => {
+  const start = Date.now();
+  const pkgOptions = pkg === void 0 ? [] : [pkg];
+  const incrementalOptions = incremental ? ["-i"] : [];
+  const verboseOptions = verbose ? ["-v"] : [];
+  const targetOptions = target === void 0 ? [] : ["-t", target];
+  const jobsOptions = jobs === void 0 ? [] : ["-j", `${jobs}`];
+  if (jobs !== void 0) {
+    console.log(chalk9.blue(`Jobs set to [${jobs}]`));
+  }
+  const pm = getPackageManager();
+  const result = await runStepsAsync(`Build${incremental ? "-Incremental" : ""} [${pkg ?? "All"}]`, [
+    pm.runXy(["compile", ...pkgOptions, ...targetOptions, ...verboseOptions, ...jobsOptions, ...incrementalOptions, "--types", "tsup"]),
+    pm.runXy(["publint", ...pkgOptions, ...verboseOptions, ...jobsOptions, ...incrementalOptions]),
+    pm.runXy(["deplint", ...pkgOptions, ...verboseOptions, ...jobsOptions, ...incrementalOptions]),
+    pm.runXy(["lint", ...pkgOptions, ...verboseOptions, ...incrementalOptions])
+  ]);
+  console.log(`${chalk9.gray("Built in")} [${chalk9.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk9.gray("seconds")}`);
+  return result;
+};
+
+// src/actions/claude-clean.ts
+import {
+  existsSync as existsSync5,
+  readdirSync as readdirSync2,
+  rmSync,
+  unlinkSync
+} from "fs";
+import PATH4 from "path";
+import chalk10 from "chalk";
+function removeFile(filePath, label) {
+  if (existsSync5(filePath)) {
+    unlinkSync(filePath);
+    console.log(chalk10.yellow(`  Removed ${label}`));
+    return true;
+  }
+  return false;
+}
+function removeDir(dirPath, label) {
+  if (existsSync5(dirPath)) {
+    rmSync(dirPath, { recursive: true });
+    console.log(chalk10.yellow(`  Removed ${label}`));
+    return true;
+  }
+  return false;
+}
+function claudeClean() {
+  console.log(chalk10.green("Clean Claude configuration"));
+  const cwd5 = INIT_CWD() ?? process.cwd();
+  let removed = 0;
+  const rootFiles = ["CLAUDE.md", "CLAUDE.local.md"];
+  for (const file of rootFiles) {
+    if (removeFile(PATH4.resolve(cwd5, file), file)) removed++;
+  }
+  if (removeDir(PATH4.resolve(cwd5, ".claude"), ".claude/")) removed++;
+  const packagesDir = PATH4.resolve(cwd5, "packages");
+  if (existsSync5(packagesDir)) {
+    const findClaudeFiles = (dir, prefix) => {
+      const entries = readdirSync2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = PATH4.resolve(dir, entry.name);
+        const label = `${prefix}${entry.name}`;
+        if (entry.isFile() && (entry.name === "CLAUDE.md" || entry.name === "CLAUDE.local.md")) {
+          if (removeFile(fullPath, label)) removed++;
+        } else if (entry.isDirectory() && entry.name === ".claude") {
+          if (removeDir(fullPath, `${label}/`)) removed++;
+        } else if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist") {
+          findClaudeFiles(fullPath, `${label}/`);
+        }
+      }
+    };
+    findClaudeFiles(packagesDir, "packages/");
+  }
+  if (removed > 0) {
+    console.log(chalk10.green(`  Removed ${removed} item(s)`));
+  } else {
+    console.log(chalk10.gray("  Nothing to clean"));
+  }
+  return 0;
+}
+
+// src/actions/claude-commands.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync6,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import PATH5 from "path";
+import chalk11 from "chalk";
+var syncCommandFiles = (commandsDir) => {
+  const templates = claudeCommandTemplates();
+  const templateNames = new Set(Object.keys(templates));
+  let updated = 0;
+  let created = 0;
+  for (const [filename2, content] of Object.entries(templates)) {
+    const targetPath = PATH5.resolve(commandsDir, filename2);
+    const existing = existsSync6(targetPath) ? readFileSync6(targetPath, "utf8") : void 0;
+    if (existing === content) continue;
+    writeFileSync2(targetPath, content, "utf8");
+    if (existing) {
+      updated++;
+    } else {
+      created++;
+    }
+  }
+  return {
+    created,
+    templateNames,
+    updated
+  };
+};
+var removeStaleCommands = (commandsDir, templateNames) => {
+  const existingCommands = readdirSync3(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md"));
+  let removed = 0;
+  for (const file of existingCommands) {
+    if (!templateNames.has(file)) {
+      unlinkSync2(PATH5.resolve(commandsDir, file));
+      removed++;
+    }
+  }
+  return removed;
+};
+var removeLegacyCommands = (commandsDir) => {
+  const legacyFiles = readdirSync3(commandsDir).filter((f) => f.startsWith(LEGACY_COMMANDS_PREFIX) && f.endsWith(".md"));
+  for (const file of legacyFiles) {
+    unlinkSync2(PATH5.resolve(commandsDir, file));
+  }
+  return legacyFiles.length;
+};
+var logCommandsResult = (created, updated, removed) => {
+  if (created || updated || removed) {
+    const parts = [
+      created ? `${created} created` : "",
+      updated ? `${updated} updated` : "",
+      removed ? `${removed} removed` : ""
+    ].filter(Boolean);
+    console.log(chalk11.green(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: ${parts.join(", ")}`));
+  } else {
+    console.log(chalk11.gray(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: already up to date`));
+  }
+};
+var claudeCommands = () => {
+  const cwd5 = INIT_CWD() ?? process.cwd();
+  const commandsDir = PATH5.resolve(cwd5, ".claude", "commands");
+  mkdirSync(commandsDir, { recursive: true });
+  const legacy = removeLegacyCommands(commandsDir);
+  const {
+    created,
+    templateNames,
+    updated
+  } = syncCommandFiles(commandsDir);
+  const removed = removeStaleCommands(commandsDir, templateNames);
+  logCommandsResult(created, updated, removed + legacy);
+  return 0;
+};
+
+// src/actions/claude-rules.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync7,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import PATH6 from "path";
+import chalk12 from "chalk";
+var syncRuleFiles = (rulesDir) => {
+  const templates = claudeMdRuleTemplates();
+  const templateNames = new Set(Object.keys(templates));
+  let updated = 0;
+  let created = 0;
+  for (const [filename2, content] of Object.entries(templates)) {
+    const targetPath = PATH6.resolve(rulesDir, filename2);
+    const existing = existsSync7(targetPath) ? readFileSync7(targetPath, "utf8") : void 0;
+    if (existing === content) continue;
+    writeFileSync3(targetPath, content, "utf8");
+    if (existing) {
+      updated++;
+    } else {
+      created++;
+    }
+  }
+  return {
+    created,
+    templateNames,
+    updated
+  };
+};
+var removeStaleRules = (rulesDir, templateNames) => {
+  const existingRules = readdirSync4(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md"));
+  let removed = 0;
+  for (const file of existingRules) {
+    if (!templateNames.has(file)) {
+      unlinkSync3(PATH6.resolve(rulesDir, file));
+      removed++;
+    }
+  }
+  return removed;
+};
+var logRulesResult = (created, updated, removed) => {
+  if (created || updated || removed) {
+    const parts = [
+      created ? `${created} created` : "",
+      updated ? `${updated} updated` : "",
+      removed ? `${removed} removed` : ""
+    ].filter(Boolean);
+    console.log(chalk12.green(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: ${parts.join(", ")}`));
+  } else {
+    console.log(chalk12.gray(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: already up to date`));
+  }
+};
+var ensureProjectClaudeMd = (cwd5, force) => {
+  const projectPath = PATH6.resolve(cwd5, "CLAUDE.md");
+  if (!existsSync7(projectPath) || force) {
+    if (force && existsSync7(projectPath)) {
+      console.log(chalk12.yellow("Regenerating CLAUDE.md"));
+    }
+    console.log(chalk12.green("Generating CLAUDE.md via claude /init..."));
+    const result = spawnSync2("claude", ["-p", "/init", "--allowedTools", "Read", "Write", "Glob", "Grep"], {
+      cwd: cwd5,
+      shell: true,
+      stdio: "inherit"
+    });
+    if (result.status !== 0) {
+      console.error(chalk12.red("claude /init failed \u2014 is Claude Code installed?"));
+      return 1;
+    }
+  } else {
+    console.log(chalk12.gray("CLAUDE.md already exists (skipped, use --force to regenerate)"));
+  }
+  return 0;
+};
+var ensureLocalClaudeMd = (cwd5) => {
+  const localPath = PATH6.resolve(cwd5, "CLAUDE.local.md");
+  if (existsSync7(localPath)) {
+    console.log(chalk12.gray("CLAUDE.local.md already exists (skipped)"));
+  } else {
+    writeFileSync3(localPath, claudeMdLocalTemplate(), "utf8");
+    console.log(chalk12.green("Generated CLAUDE.local.md"));
+  }
+};
+var claudeRules = ({ force } = {}) => {
+  const cwd5 = INIT_CWD() ?? process.cwd();
+  const rulesDir = PATH6.resolve(cwd5, ".claude", "rules");
+  mkdirSync2(rulesDir, { recursive: true });
+  const {
+    created,
+    templateNames,
+    updated
+  } = syncRuleFiles(rulesDir);
+  const removed = removeStaleRules(rulesDir, templateNames);
+  logRulesResult(created, updated, removed);
+  const claudeMdResult = ensureProjectClaudeMd(cwd5, force);
+  ensureLocalClaudeMd(cwd5);
+  return claudeMdResult ?? 0;
+};
+
+// src/actions/claude-settings.ts
+import {
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync4
+} from "fs";
+import PATH7 from "path";
+import { createInterface as createInterface2 } from "readline";
+import chalk13 from "chalk";
+var DEFAULT_SETTINGS = {
+  permissions: {
+    allow: [
+      "Bash(git *)",
+      "Bash(yarn *)",
+      "Bash(npx *)",
+      "Bash(node *)",
+      "Bash(ls *)",
+      "Bash(mkdir *)",
+      "Bash(cp *)",
+      "Bash(mv *)",
+      "Bash(rm *)",
+      "Bash(cat *)",
+      "Bash(head *)",
+      "Bash(tail *)",
+      "Bash(echo *)",
+      "Bash(pwd)",
+      "Bash(which *)",
+      "Bash(grep *)",
+      "Bash(find *)",
+      "Bash(npm view *)",
+      "Bash(gh *)",
+      "Read",
+      "Edit",
+      "Write",
+      "Glob",
+      "Grep",
+      "Skill"
+    ],
+    deny: [
+      "Bash(git push --force *)",
+      "Bash(git reset --hard *)",
+      "Bash(rm -rf /*)"
+    ]
+  }
+};
+function askConfirmation2(question) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function claudeSettings() {
+  const cwd5 = INIT_CWD() ?? process.cwd();
+  const claudeDir = PATH7.resolve(cwd5, ".claude");
+  const settingsPath = PATH7.resolve(claudeDir, "settings.local.json");
+  mkdirSync3(claudeDir, { recursive: true });
+  if (existsSync8(settingsPath)) {
+    const confirmed = await askConfirmation2(
+      chalk13.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
+    );
+    if (!confirmed) {
+      console.log(chalk13.gray("Skipped \u2014 existing settings.local.json preserved"));
+      return 0;
+    }
+  }
+  writeFileSync4(settingsPath, `${JSON.stringify(DEFAULT_SETTINGS, null, 2)}
+`, "utf8");
+  console.log(chalk13.green("Generated .claude/settings.local.json"));
+  return 0;
+}
+
+// src/actions/claude-skills.ts
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync8,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync5
+} from "fs";
+import PATH8 from "path";
+import chalk14 from "chalk";
+var syncSkillFiles = (skillsDir) => {
+  const templates = claudeSkillTemplates();
+  const templateNames = new Set(Object.keys(templates));
+  let updated = 0;
+  let created = 0;
+  for (const [skillName, files] of Object.entries(templates)) {
+    const skillDir = PATH8.resolve(skillsDir, skillName);
+    mkdirSync4(skillDir, { recursive: true });
+    for (const [filename2, content] of Object.entries(files)) {
+      const targetPath = PATH8.resolve(skillDir, filename2);
+      mkdirSync4(PATH8.dirname(targetPath), { recursive: true });
+      const existing = existsSync9(targetPath) ? readFileSync8(targetPath, "utf8") : void 0;
+      if (existing === content) continue;
+      writeFileSync5(targetPath, content, "utf8");
+      if (existing) {
+        updated++;
+      } else {
+        created++;
+      }
+    }
+  }
+  return {
+    created,
+    templateNames,
+    updated
+  };
+};
+var removeStaleSkills = (skillsDir, templateNames) => {
+  const existingSkills = readdirSync5(skillsDir).filter(
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync2(PATH8.resolve(skillsDir, f)).isDirectory()
+  );
+  let removed = 0;
+  for (const dir of existingSkills) {
+    if (!templateNames.has(dir)) {
+      rmSync2(PATH8.resolve(skillsDir, dir), { recursive: true });
+      removed++;
+    }
+  }
+  return removed;
+};
+var logSkillsResult = (created, updated, removed) => {
+  if (created || updated || removed) {
+    const parts = [
+      created ? `${created} created` : "",
+      updated ? `${updated} updated` : "",
+      removed ? `${removed} removed` : ""
+    ].filter(Boolean);
+    console.log(chalk14.green(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: ${parts.join(", ")}`));
+  } else {
+    console.log(chalk14.gray(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: already up to date`));
+  }
+};
+var claudeSkills = () => {
+  const cwd5 = INIT_CWD() ?? process.cwd();
+  const skillsDir = PATH8.resolve(cwd5, ".claude", "skills");
+  mkdirSync4(skillsDir, { recursive: true });
+  const {
+    created,
+    templateNames,
+    updated
+  } = syncSkillFiles(skillsDir);
+  const removed = removeStaleSkills(skillsDir, templateNames);
+  logSkillsResult(created, updated, removed);
+  return 0;
+};
+
+// src/actions/clean.ts
+var clean = async ({ verbose, pkg }) => {
+  return pkg ? await cleanPackage({ pkg, verbose }) : cleanAll({ verbose });
+};
+var cleanPackage = ({ pkg }) => {
+  const pm = getPackageManager();
+  return runStepsAsync(`Clean [${pkg}]`, [pm.runInWorkspace(pkg, "package-clean")]);
+};
+var cleanAll = ({ verbose }) => {
+  const pm = getPackageManager();
+  return runStepsAsync("Clean", [pm.foreachWorkspace("package-clean", [], { jobs: 64, verbose })]);
+};
+
+// src/actions/clean-docs.ts
+import path from "path";
+import chalk15 from "chalk";
+var cleanDocs = () => {
+  const pkgName = process.env.npm_package_name;
+  console.log(chalk15.green(`Cleaning Docs [${pkgName}]`));
+  for (const { location } of getPackageManager().listWorkspaces()) deleteGlob(path.join(location, "docs"));
+  return 0;
+};
+
+// src/actions/clean-eslint.ts
+import path2 from "path";
+import chalk16 from "chalk";
+var cleanESLint = () => {
+  const pkg = process.env.INIT_CWD ?? ".";
+  const pkgName = process.env.npm_package_name;
+  console.log(chalk16.green(`Cleaning ESLint [${pkgName}]`));
+  deleteGlob(path2.join(pkg, ".eslintcache"));
+  return 0;
+};
+
+// src/actions/compile.ts
+import chalk17 from "chalk";
+var compile = ({
+  verbose,
+  target,
+  pkg,
+  incremental,
+  publint: publint2,
+  jobs
+}) => {
+  return pkg ? compilePackage({
+    pkg,
+    publint: publint2,
+    target,
+    verbose
+  }) : compileAll({
+    incremental,
+    jobs,
+    publint: publint2,
+    target,
+    verbose
+  });
+};
+var compilePackage = ({ target, pkg }) => {
+  const pm = getPackageManager();
+  const targetOptions = target ? ["-t", target] : [];
+  return runSteps(
+    `Compile [${pkg}]`,
+    [pm.runInWorkspace(pkg, "package-compile", targetOptions)]
+  );
+};
+var compileAll = ({
+  jobs,
+  verbose,
+  target,
+  incremental
+}) => {
+  const pm = getPackageManager();
+  const start = Date.now();
+  const targetOptions = target ? ["-t", target] : [];
+  if (jobs) {
+    console.log(chalk17.blue(`Jobs set to [${jobs}]`));
+  }
+  const result = runSteps(`Compile${incremental ? "-Incremental" : ""} [All]`, [
+    pm.foreachWorkspace("package-compile", targetOptions, {
+      incremental,
+      jobs,
+      topological: true,
+      verbose
+    })
+  ]);
+  console.log(`${chalk17.gray("Compiled in")} [${chalk17.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk17.gray("seconds")}`);
+  return result;
+};
+
+// src/actions/copy-assets.ts
+import path3 from "path/posix";
+import chalk18 from "chalk";
+import cpy from "cpy";
+var copyPackageTargetAssets = async (target, name, location) => {
+  try {
+    const values = await cpy(
+      ["**/*.jpg", "**/*.png", "**/*.gif", "**/*.svg", "**/*.webp", "**/*.sass", "**/*.scss", "**/*.gif", "**/*.css"],
+      `../dist/${target}`,
+      {
+        cwd: path3.join(process.cwd(), location, "src"),
+        flat: false
+      }
+    );
+    for (const value of values) {
+      console.log(`${value.split("/").pop()} => ./dist/${target}`);
+    }
+    return 0;
+  } catch (reason) {
+    console.log(`Copy Failed: ${name}: ${reason}`);
+    return 1;
+  }
+};
+var copyTargetAssets = async (target, pkg) => {
+  const workspaces = getPackageManager().listWorkspaces();
+  console.log(chalk18.green(`Copying Assets [${target.toUpperCase()}]`));
+  const workspaceList = workspaces.filter(({ name }) => {
+    return pkg === void 0 || name === pkg;
+  });
+  if (workspaceList.length === 0) {
+    console.error(`Package not found [${pkg}]`);
+  } else {
+    const results = await Promise.all(
+      workspaceList.map(async (workspace) => {
+        const { location, name } = workspace;
+        return await copyPackageTargetAssets(target, name, location);
+      })
+    );
+    return results.reduce((prev, result) => prev || result, 0);
+  }
+  return 0;
+};
+var copyAssets = async ({ target, pkg }) => {
+  switch (target) {
+    case "esm": {
+      return await copyTargetAssets("esm", pkg);
+    }
+    case "cjs": {
+      return await copyTargetAssets("cjs", pkg);
+    }
+    default: {
+      return await copyTargetAssets("esm", pkg) || await copyTargetAssets("cjs", pkg);
+    }
+  }
+};
+
+// src/actions/cycle.ts
+import { cruise } from "dependency-cruiser";
+var cycle = async ({ verbose, pkg } = {}) => {
+  return pkg ? cyclePackage({ pkg, verbose }) : await cycleAll({ verbose });
+};
+var cyclePackage = ({ pkg, verbose }) => {
+  const pm = getPackageManager();
+  const verboseOptions = verbose ? ["--verbose"] : ["--no-verbose"];
+  return runSteps(
+    `Cycle [${pkg}]`,
+    [pm.runInWorkspace(pkg, "package-cycle", verboseOptions)]
+  );
+};
+var cycleAll = async ({ verbose = false }) => {
+  const pkgName = process.env.npm_package_name;
+  const cruiseOptions = {
+    ruleSet: {
+      forbidden: [
+        {
+          name: "no-circular",
+          severity: "error",
+          comment: "This dependency creates a circular reference",
+          from: {},
+          to: { circular: true }
+        }
+      ]
+    },
+    exclude: "node_modules|packages/.*/packages",
+    validate: true,
+    doNotFollow: { path: "node_modules|packages/.*/packages" },
+    tsPreCompilationDeps: false,
+    combinedDependencies: true,
+    outputType: verbose ? "text" : "err"
+  };
+  const target = "**/packages/*/src";
+  console.log(`Checking for circular dependencies in ${target}...`);
+  const result = await cruise([target], cruiseOptions);
+  if (result.output) {
+    console.log(result.output);
+  }
+  if (result.exitCode === 0) {
+    console.log(`${pkgName} \u2705 No dependency violations`);
+  } else {
+    console.error(`${pkgName} \u274C Dependency violations found`);
+  }
+  return result.exitCode;
+};
+
+// src/actions/dead.ts
+var dead = () => {
+  return runSteps("Dead", [["ts-prune", ["-p", "tsconfig.json"]]]);
+};
+
+// src/actions/deplint/deplint.ts
+import chalk24 from "chalk";
+
+// src/actions/deplint/findFiles.ts
+import fs2 from "fs";
+
+// src/actions/deplint/findFilesByGlob.ts
+import { globSync } from "glob";
+function findFilesByGlob(cwd5, pattern, ignore) {
+  return globSync(pattern, {
+    cwd: cwd5,
+    absolute: true,
+    ignore,
+    nodir: true
+  });
+}
+
+// src/actions/deplint/findFiles.ts
+var codeExtensions = "*.{ts,tsx,mts,cts,js,mjs,cjs}";
+function getWorkspaceIgnores(location) {
+  try {
+    const raw = fs2.readFileSync(`${location}/package.json`, "utf8");
+    const pkg = JSON.parse(raw);
+    return pkg.workspaces ?? [];
+  } catch {
+    return [];
+  }
+}
+function findFiles(location) {
+  const workspaceIgnores = getWorkspaceIgnores(location).map((w) => `${w}/**`);
+  const ignore = ["**/node_modules/**", "dist/**", ...workspaceIgnores];
+  const allFiles = findFilesByGlob(location, `./**/${codeExtensions}`, ignore);
+  const distFiles = [
+    ...findFilesByGlob(location, "./dist/**/*.d.ts"),
+    ...findFilesByGlob(location, `./dist/**/${codeExtensions}`)
+  ];
+  return { allFiles, distFiles };
+}
+
+// src/actions/deplint/getDependenciesFromPackageJson.ts
+import fs3 from "fs";
+import path4 from "path";
+function getDependenciesFromPackageJson(packageJsonPath) {
+  const packageJsonFullPath = path4.resolve(packageJsonPath);
+  const rawContent = fs3.readFileSync(packageJsonFullPath, "utf8");
+  const packageJson = JSON.parse(rawContent);
+  const dependencies = packageJson.dependencies ? Object.keys(packageJson.dependencies) : [];
+  const devDependencies = packageJson.devDependencies ? Object.keys(packageJson.devDependencies) : [];
+  const peerDependencies = packageJson.peerDependencies ? Object.keys(packageJson.peerDependencies) : [];
+  return {
+    dependencies,
+    devDependencies,
+    peerDependencies
+  };
+}
+
+// src/actions/deplint/getExtendsFromTsconfigs.ts
+import fs4 from "fs";
+import { globSync as globSync2 } from "glob";
+
+// src/actions/deplint/getBasePackageName.ts
+function getBasePackageName(importName) {
+  const importNameScrubbed = importName.replaceAll('"', "").trim();
+  if (importNameScrubbed.startsWith("@")) {
+    const parts = importNameScrubbed.split("/");
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : importNameScrubbed;
+  }
+  return importNameScrubbed.split("/")[0];
+}
+
+// src/actions/deplint/getExtendsFromTsconfigs.ts
+var isExternalReference = (ref) => !ref.startsWith(".") && !ref.startsWith("/");
+function parseExtendsField(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+  return [];
+}
+function getExtendsFromTsconfigs(location) {
+  const tsconfigFiles = globSync2("./tsconfig*.json", { cwd: location, absolute: true });
+  const packages = /* @__PURE__ */ new Set();
+  for (const file of tsconfigFiles) {
+    try {
+      const content = fs4.readFileSync(file, "utf8");
+      const cleaned = content.replaceAll(/\/\/.*/g, "").replaceAll(/,\s*([}\]])/g, "$1");
+      const parsed = JSON.parse(cleaned);
+      const refs = parseExtendsField(parsed.extends);
+      for (const ref of refs) {
+        if (isExternalReference(ref)) {
+          packages.add(getBasePackageName(ref));
+        }
+      }
+    } catch {
+    }
+  }
+  return [...packages];
+}
+
+// src/actions/deplint/getImportsFromFile.ts
+import fs5 from "fs";
+import path5 from "path";
+import ts from "typescript";
+function isTypeOnlyImportClause(clause) {
+  if (clause === void 0) {
+    return false;
+  }
+  if ("phaseModifier" in clause) {
+    const mod = clause.phaseModifier;
+    const kind = typeof mod === "number" ? mod : mod?.kind;
+    return kind === ts.SyntaxKind.TypeKeyword;
+  }
+  return clause.isTypeOnly;
+}
+function getImportsFromFile(filePath, importPaths, typeImportPaths) {
+  const sourceCode = fs5.readFileSync(filePath, "utf8");
+  const isMjsFile = filePath.endsWith(".mjs");
+  const sourceFile = ts.createSourceFile(
+    path5.basename(filePath),
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    true,
+    isMjsFile ? ts.ScriptKind.JS : void 0
+  );
+  const imports = [];
+  const typeImports = [];
+  const isDeclarationFile2 = filePath.endsWith(".d.ts");
+  function visit(node) {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier?.getFullText();
+      const isTypeImport = ts.isImportDeclaration(node) ? isTypeOnlyImportClause(node.importClause) : false;
+      if (typeof moduleSpecifier === "string") {
+        const trimmed = moduleSpecifier.replaceAll("'", "").replaceAll('"', "").trim();
+        if (isTypeImport || isDeclarationFile2) {
+          typeImports.push(trimmed);
+        } else {
+          imports.push(trimmed);
+        }
+      }
+    } else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const [arg] = node.arguments;
+      if (ts.isStringLiteral(arg)) {
+        imports.push(arg.text);
+      }
+    } else if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length > 0 && ts.isStringLiteral(node.arguments[0])) {
+      imports.push(node.arguments[0].text);
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  for (const ref of sourceFile.typeReferenceDirectives) {
+    typeImports.push(ref.fileName);
+  }
+  const importsStartsWithExcludes = [".", "#", "node:"];
+  const isValidImport = (imp) => !importsStartsWithExcludes.some((exc) => imp.startsWith(exc)) && !imp.includes("*") && !imp.includes("!");
+  const cleanedImports = imports.filter(isValidImport).map(getBasePackageName);
+  const cleanedTypeImports = typeImports.filter(isValidImport).map(getBasePackageName);
+  for (const imp of cleanedImports) {
+    importPaths[imp] = importPaths[imp] ?? [];
+    importPaths[imp].push(filePath);
+  }
+  for (const imp of cleanedTypeImports) {
+    typeImportPaths[imp] = typeImportPaths[imp] ?? [];
+    typeImportPaths[imp].push(filePath);
+  }
+  return [cleanedImports, cleanedTypeImports];
+}
+
+// src/actions/deplint/getExternalImportsFromFiles.ts
+var internalImportPrefixes = [".", "#", "node:"];
+var removeInternalImports = (imports) => {
+  return imports.filter((imp) => !internalImportPrefixes.some((prefix) => imp.startsWith(prefix)));
+};
+var isDeclarationFile = (file) => file.endsWith(".d.ts") || file.endsWith(".d.cts") || file.endsWith(".d.mts");
+function getExternalImportsFromFiles({
+  allFiles,
+  distFiles,
+  tsconfigExtends = []
+}) {
+  const allImportPaths = {};
+  const distImportPaths = {};
+  const distTypeImportPaths = {};
+  for (const path15 of allFiles) getImportsFromFile(path15, allImportPaths, allImportPaths).flat();
+  const distTypeFiles = distFiles.filter(isDeclarationFile);
+  const distCodeFiles = distFiles.filter((file) => !isDeclarationFile(file));
+  for (const path15 of distCodeFiles) getImportsFromFile(path15, distImportPaths, distImportPaths).flat();
+  for (const path15 of distTypeFiles) getImportsFromFile(path15, distTypeImportPaths, distTypeImportPaths).flat();
+  const allImports = Object.keys(allImportPaths);
+  const distImports = Object.keys(distImportPaths);
+  const externalAllImports = removeInternalImports(allImports);
+  const externalDistImports = removeInternalImports(distImports);
+  const externalDistTypeImports = removeInternalImports(Object.keys(distTypeImportPaths));
+  for (const ext of tsconfigExtends) {
+    if (!externalAllImports.includes(ext)) externalAllImports.push(ext);
+  }
+  return {
+    allImportPaths,
+    allImports,
+    distImportPaths,
+    distImports,
+    externalAllImports,
+    externalDistImports,
+    externalDistTypeImports
+  };
+}
+
+// src/actions/deplint/checkPackage/getUnlistedDependencies.ts
+import { builtinModules } from "module";
+import chalk19 from "chalk";
+function isRuntimeImportListed(imp, name, dependencies, peerDependencies) {
+  return dependencies.includes(imp) || imp === name || peerDependencies.includes(imp) || builtinModules.includes(imp);
+}
+function isTypeImportListed(imp, name, dependencies, devDependencies, peerDependencies) {
+  return dependencies.includes(imp) || imp === name || dependencies.includes(`@types/${imp}`) || peerDependencies.includes(imp) || peerDependencies.includes(`@types/${imp}`) || devDependencies.includes(`@types/${imp}`) || builtinModules.includes(imp);
+}
+function logMissing(name, imp, importPaths) {
+  console.log(`[${chalk19.blue(name)}] Missing dependency in package.json: ${chalk19.red(imp)}`);
+  if (importPaths[imp]) {
+    console.log(`  ${importPaths[imp].join("\n ")}`);
+  }
+}
+function getUnlistedDependencies({ name, location }, {
+  dependencies,
+  devDependencies,
+  peerDependencies
+}, {
+  externalDistImports,
+  externalDistTypeImports,
+  distImportPaths
+}) {
+  let unlistedDependencies = 0;
+  for (const imp of externalDistImports) {
+    if (!isRuntimeImportListed(imp, name, dependencies, peerDependencies)) {
+      unlistedDependencies++;
+      logMissing(name, imp, distImportPaths);
+    }
+  }
+  for (const imp of externalDistTypeImports) {
+    if (!isTypeImportListed(imp, name, dependencies, devDependencies, peerDependencies)) {
+      unlistedDependencies++;
+      logMissing(name, imp, distImportPaths);
+    }
+  }
+  if (unlistedDependencies > 0) {
+    const packageLocation = `${location}/package.json`;
+    console.log(`  ${chalk19.yellow(packageLocation)}
+`);
+  }
+  return unlistedDependencies;
+}
+
+// src/actions/deplint/checkPackage/getUnlistedDevDependencies.ts
+import { builtinModules as builtinModules2 } from "module";
+import chalk20 from "chalk";
+function getUnlistedDevDependencies({ name, location }, {
+  devDependencies,
+  dependencies,
+  peerDependencies
+}, {
+  allImportPaths,
+  externalAllImports,
+  distImports
+}) {
+  let unlistedDevDependencies = 0;
+  for (const imp of externalAllImports) {
+    if (!distImports.includes(imp) && imp !== name && !dependencies.includes(imp) && !dependencies.includes(`@types/${imp}`) && !peerDependencies.includes(imp) && !peerDependencies.includes(`@types/${imp}`) && !devDependencies.includes(imp) && !devDependencies.includes(`@types/${imp}`) && !builtinModules2.includes(imp)) {
+      unlistedDevDependencies++;
+      console.log(`[${chalk20.blue(name)}] Missing devDependency in package.json: ${chalk20.red(imp)}`);
+      if (allImportPaths[imp]) {
+        console.log(`  ${allImportPaths[imp].join("\n ")}`);
+      }
+    }
+  }
+  if (unlistedDevDependencies > 0) {
+    const packageLocation = `${location}/package.json`;
+    console.log(`  ${chalk20.yellow(packageLocation)}
+`);
+  }
+  return unlistedDevDependencies;
+}
+
+// src/actions/deplint/checkPackage/getUnusedDependencies.ts
+import chalk21 from "chalk";
+function getUnusedDependencies({ name, location }, { dependencies }, {
+  externalDistImports,
+  externalDistTypeImports,
+  externalAllImports
+}, exclude) {
+  let unusedDependencies = 0;
+  for (const dep of dependencies) {
+    if (exclude?.has(dep)) continue;
+    if (!externalDistImports.includes(dep) && !externalDistImports.includes(dep.replace(/^@types\//, "")) && !externalDistTypeImports.includes(dep) && !externalDistTypeImports.includes(dep.replace(/^@types\//, ""))) {
+      unusedDependencies++;
+      if (externalAllImports.includes(dep)) {
+        console.log(`[${chalk21.blue(name)}] dependency should be devDependency in package.json: ${chalk21.red(dep)}`);
+      } else {
+        console.log(`[${chalk21.blue(name)}] Unused dependency in package.json: ${chalk21.red(dep)}`);
+      }
+    }
+  }
+  if (unusedDependencies > 0) {
+    const packageLocation = `${location}/package.json`;
+    console.log(`  ${chalk21.yellow(packageLocation)}
+`);
+  }
+  return unusedDependencies;
+}
+
+// src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
+import chalk22 from "chalk";
+
+// src/actions/deplint/getCliReferencedPackagesFromFiles.ts
+import fs8 from "fs";
+import path8 from "path";
+import ts2 from "typescript";
+
+// src/actions/deplint/getScriptReferencedPackages.ts
+import fs7 from "fs";
+import path7 from "path";
+
+// src/actions/deplint/getRequiredPeerDependencies.ts
+import fs6 from "fs";
+import path6 from "path";
+function findDepPackageJson(location, dep) {
+  let dir = location;
+  while (true) {
+    const candidate = path6.join(dir, "node_modules", dep, "package.json");
+    if (fs6.existsSync(candidate)) return candidate;
+    const parent = path6.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function getRequiredPeerDependencies(location, allDeps) {
+  const required = /* @__PURE__ */ new Set();
+  for (const dep of allDeps) {
+    const depPkgPath = findDepPackageJson(location, dep);
+    if (!depPkgPath) continue;
+    try {
+      const raw = fs6.readFileSync(depPkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.peerDependencies) {
+        for (const peer of Object.keys(pkg.peerDependencies)) {
+          required.add(peer);
+        }
+      }
+    } catch {
+    }
+  }
+  return required;
+}
+
+// src/actions/deplint/getScriptReferencedPackages.ts
+function getBinNames(location, dep) {
+  const depPkgPath = findDepPackageJson(location, dep);
+  if (!depPkgPath) return [];
+  try {
+    const raw = fs7.readFileSync(depPkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    if (!pkg.bin) return [];
+    if (typeof pkg.bin === "string") return [pkg.name?.split("/").pop() ?? dep];
+    return Object.keys(pkg.bin);
+  } catch {
+    return [];
+  }
+}
+function tokenizeScript(script) {
+  return script.split(/[&|;$()"`\s]+/).map((t) => t.trim()).filter(Boolean);
+}
+function getScriptReferencedPackages(location, allDeps) {
+  const pkgPath = path7.join(location, "package.json");
+  let scripts = {};
+  try {
+    const raw = fs7.readFileSync(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    scripts = pkg.scripts ?? {};
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  const scriptText = Object.values(scripts).join(" ");
+  const tokens = new Set(tokenizeScript(scriptText));
+  const binToPackage = /* @__PURE__ */ new Map();
+  for (const dep of allDeps) {
+    const bins = getBinNames(location, dep);
+    for (const bin of bins) {
+      binToPackage.set(bin, dep);
+    }
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    const baseName = getBasePackageName(token);
+    if (allDeps.includes(baseName)) {
+      referenced.add(baseName);
+    }
+    const pkg = binToPackage.get(token);
+    if (pkg) {
+      referenced.add(pkg);
+    }
+  }
+  return referenced;
+}
+
+// src/actions/deplint/getCliReferencedPackagesFromFiles.ts
+var shellCommandFunctions = /* @__PURE__ */ new Set(["execSync", "exec"]);
+var directExecFunctions = /* @__PURE__ */ new Set(["spawn", "spawnSync", "execFile", "execFileSync"]);
+var allExecFunctions = /* @__PURE__ */ new Set([...shellCommandFunctions, ...directExecFunctions]);
+function getCommandTokensFromFile(filePath) {
+  const tokens = /* @__PURE__ */ new Set();
+  let sourceCode;
+  try {
+    sourceCode = fs8.readFileSync(filePath, "utf8");
+  } catch {
+    return tokens;
+  }
+  const isMjsFile = filePath.endsWith(".mjs");
+  const sourceFile = ts2.createSourceFile(
+    path8.basename(filePath),
+    sourceCode,
+    ts2.ScriptTarget.Latest,
+    true,
+    isMjsFile ? ts2.ScriptKind.JS : void 0
+  );
+  function visit(node) {
+    if (ts2.isCallExpression(node) && node.arguments.length > 0) {
+      const fnName = getFunctionName(node.expression);
+      if (fnName && allExecFunctions.has(fnName)) {
+        const firstArg = node.arguments[0];
+        if (ts2.isStringLiteral(firstArg) || ts2.isNoSubstitutionTemplateLiteral(firstArg)) {
+          const value = firstArg.text;
+          if (shellCommandFunctions.has(fnName)) {
+            for (const token of tokenizeScript(value)) {
+              tokens.add(token);
+            }
+          } else {
+            tokens.add(value);
+          }
+        } else if (ts2.isTemplateExpression(firstArg)) {
+          const head = firstArg.head.text;
+          if (head) {
+            for (const token of tokenizeScript(head)) {
+              tokens.add(token);
+            }
+          }
+        }
+      }
+    }
+    ts2.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return tokens;
+}
+function getFunctionName(expr) {
+  if (ts2.isIdentifier(expr)) {
+    return expr.text;
+  }
+  if (ts2.isPropertyAccessExpression(expr) && ts2.isIdentifier(expr.name)) {
+    return expr.name.text;
+  }
+  return void 0;
+}
+function getCliReferencedPackagesFromFiles(allFiles, location, allDeps) {
+  const allTokens = /* @__PURE__ */ new Set();
+  for (const file of allFiles) {
+    for (const token of getCommandTokensFromFile(file)) {
+      allTokens.add(token);
+    }
+  }
+  if (allTokens.size === 0) return /* @__PURE__ */ new Set();
+  const binToPackage = /* @__PURE__ */ new Map();
+  for (const dep of allDeps) {
+    for (const bin of getBinNames(location, dep)) {
+      binToPackage.set(bin, dep);
+    }
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  for (const token of allTokens) {
+    const baseName = getBasePackageName(token);
+    if (allDeps.includes(baseName)) {
+      referenced.add(baseName);
+    }
+    const pkg = binToPackage.get(token);
+    if (pkg) {
+      referenced.add(pkg);
+    }
+  }
+  return referenced;
+}
+
+// src/actions/deplint/implicitDevDependencies.ts
+import fs9 from "fs";
+var hasFileWithExtension = (files, extensions) => files.some((f) => extensions.some((ext) => f.endsWith(ext)));
+var tsExtensions = [".ts", ".tsx", ".mts", ".cts"];
+var hasTypescriptFiles = ({ allFiles }) => hasFileWithExtension(allFiles, tsExtensions);
+var decoratorPattern = /^\s*@[a-zA-Z]\w*/m;
+var hasDecorators = ({ allFiles }) => allFiles.filter((f) => tsExtensions.some((ext) => f.endsWith(ext))).some((file) => {
+  try {
+    const content = fs9.readFileSync(file, "utf8");
+    return decoratorPattern.test(content);
+  } catch {
+    return false;
+  }
+});
+var importPlugins = /* @__PURE__ */ new Set(["eslint-plugin-import-x", "eslint-plugin-import"]);
+function hasImportPlugin({ location, allDependencies }) {
+  if (allDependencies.some((d) => importPlugins.has(d))) return true;
+  for (const dep of allDependencies) {
+    const pkgPath = findDepPackageJson(location, dep);
+    if (!pkgPath) continue;
+    try {
+      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf8"));
+      const transitiveDeps = [
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.peerDependencies ?? {})
+      ];
+      if (transitiveDeps.some((d) => importPlugins.has(d))) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var hasVitest = ({ allDependencies }) => allDependencies.includes("vitest");
+var rules = [
+  {
+    package: "typescript",
+    isNeeded: hasTypescriptFiles
+  },
+  {
+    package: "eslint-import-resolver-typescript",
+    isNeeded: (context) => hasTypescriptFiles(context) && context.allDependencies.includes("eslint") && hasImportPlugin(context)
+  },
+  {
+    package: "tslib",
+    isNeeded: hasDecorators
+  },
+  {
+    package: "@vitest/coverage-v8",
+    isNeeded: hasVitest
+  }
+];
+function getImplicitDevDependencies(context) {
+  const implicit = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (rule.isNeeded(context)) {
+      implicit.add(rule.package);
+    }
+  }
+  return implicit;
+}
+
+// src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
+var allExternalImports = ({
+  externalAllImports,
+  externalDistImports,
+  externalDistTypeImports
+}) => {
+  return /* @__PURE__ */ new Set([
+    ...externalAllImports,
+    ...externalDistImports,
+    ...externalDistTypeImports
+  ]);
+};
+function isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs, cliRefs) {
+  if (implicitDeps.has(dep)) return true;
+  if (requiredPeers.has(dep)) return true;
+  if (scriptRefs.has(dep)) return true;
+  if (cliRefs.has(dep)) return true;
+  if (dep.startsWith("@types/")) {
+    const baseName = dep.replace(/^@types\//, "");
+    return allImports.has(baseName) || allImports.has(dep) || implicitDeps.has(baseName);
+  }
+  return allImports.has(dep);
+}
+function getUnusedDevDependencies({ name, location }, {
+  devDependencies,
+  dependencies,
+  peerDependencies
+}, sourceParams, fileContext, exclude) {
+  const allImports = allExternalImports(sourceParams);
+  const allDeps = [...dependencies, ...devDependencies, ...peerDependencies];
+  const implicitDeps = getImplicitDevDependencies({
+    ...fileContext,
+    allDependencies: allDeps,
+    location
+  });
+  const requiredPeers = getRequiredPeerDependencies(location, allDeps);
+  const scriptRefs = getScriptReferencedPackages(location, allDeps);
+  const cliRefs = getCliReferencedPackagesFromFiles(fileContext.allFiles, location, allDeps);
+  let unusedDevDependencies = 0;
+  for (const dep of devDependencies) {
+    if (exclude?.has(dep)) continue;
+    if (dependencies.includes(dep) || peerDependencies.includes(dep)) continue;
+    if (!isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs, cliRefs)) {
+      unusedDevDependencies++;
+      console.log(`[${chalk22.blue(name)}] Unused devDependency in package.json: ${chalk22.red(dep)}`);
+    }
+  }
+  if (unusedDevDependencies > 0) {
+    const packageLocation = `${location}/package.json`;
+    console.log(`  ${chalk22.yellow(packageLocation)}
+`);
+  }
+  return unusedDevDependencies;
+}
+
+// src/actions/deplint/checkPackage/getUnusedPeerDependencies.ts
+import chalk23 from "chalk";
+function getUnusedPeerDependencies({ name, location }, { peerDependencies, dependencies }, { externalDistImports, externalDistTypeImports }, exclude) {
+  let unusedDependencies = 0;
+  for (const dep of peerDependencies) {
+    if (exclude?.has(dep)) continue;
+    if (!externalDistImports.includes(dep) && !externalDistImports.includes(dep.replace(/^@types\//, "")) && !externalDistTypeImports.includes(dep) && !externalDistTypeImports.includes(dep.replace(/^@types\//, ""))) {
+      unusedDependencies++;
+      if (dependencies.includes(dep)) {
+        console.log(`[${chalk23.blue(name)}] Unused peerDependency [already a dependency] in package.json: ${chalk23.red(dep)}`);
+      } else {
+        console.log(`[${chalk23.blue(name)}] Unused peerDependency in package.json: ${chalk23.red(dep)}`);
+      }
+    }
+  }
+  if (unusedDependencies > 0) {
+    const packageLocation = `${location}/package.json`;
+    console.log(`  ${chalk23.yellow(packageLocation)}
+`);
+  }
+  return unusedDependencies;
+}
+
+// src/actions/deplint/checkPackage/checkPackage.ts
+function logVerbose(name, location, allFiles, distFiles, tsconfigExtends) {
+  console.info(`Checking package: ${name} at ${location}`);
+  console.info(`All files: ${allFiles.length}, Distribution files: ${distFiles.length}`);
+  for (const file of allFiles) {
+    console.info(`File: ${file}`);
+  }
+  for (const file of distFiles) {
+    console.info(`Distribution file: ${file}`);
+  }
+  for (const ext of tsconfigExtends) {
+    console.info(`Tsconfig extends: ${ext}`);
+  }
+}
+function checkPackage({
+  name,
+  location,
+  deps = false,
+  devDeps = false,
+  exclude,
+  peerDeps = false,
+  verbose = false
+}) {
+  const { allFiles, distFiles } = findFiles(location);
+  const tsconfigExtends = getExtendsFromTsconfigs(location);
+  if (verbose) {
+    logVerbose(name, location, allFiles, distFiles, tsconfigExtends);
+  }
+  const checkDeps = deps || !(deps || devDeps || peerDeps);
+  const checkDevDeps = devDeps || !(deps || devDeps || peerDeps);
+  const checkPeerDeps = peerDeps;
+  const sourceParams = getExternalImportsFromFiles({
+    allFiles,
+    distFiles,
+    tsconfigExtends
+  });
+  const packageParams = getDependenciesFromPackageJson(`${location}/package.json`);
+  const unlistedDependencies = checkDeps ? getUnlistedDependencies({ name, location }, packageParams, sourceParams) : 0;
+  const unusedDependencies = checkDeps ? getUnusedDependencies({ name, location }, packageParams, sourceParams, exclude) : 0;
+  const unlistedDevDependencies = checkDevDeps ? getUnlistedDevDependencies({ name, location }, packageParams, sourceParams) : 0;
+  const fileContext = { allFiles, distFiles };
+  const unusedDevDependencies = checkDevDeps ? getUnusedDevDependencies({ name, location }, packageParams, sourceParams, fileContext, exclude) : 0;
+  const unusedPeerDependencies = checkPeerDeps ? getUnusedPeerDependencies({ name, location }, packageParams, sourceParams, exclude) : 0;
+  const totalErrors = unlistedDependencies + unlistedDevDependencies + unusedDependencies + unusedDevDependencies + unusedPeerDependencies;
+  return totalErrors;
+}
+
+// src/actions/deplint/deplint.ts
+var deplint = async ({
+  pkg,
+  deps,
+  devDeps,
+  peerDeps,
+  verbose,
+  cliExclude
+}) => {
+  const config2 = await loadConfig();
+  const exclude = /* @__PURE__ */ new Set([
+    ...config2.deplint?.exclude ?? [],
+    ...cliExclude ?? []
+  ]);
+  let totalErrors = 0;
+  if (pkg === void 0) {
+    const workspaces = getPackageManager().listWorkspaces();
+    console.info("Deplint Started...");
+    for (const workspace of workspaces) {
+      totalErrors += checkPackage({
+        ...workspace,
+        deps,
+        devDeps,
+        exclude,
+        peerDeps,
+        verbose
+      });
+    }
+  } else {
+    const workspace = getPackageManager().findWorkspace(pkg);
+    if (!workspace) {
+      console.error(chalk24.red(`Workspace not found: ${pkg}`));
+      return 1;
+    }
+    const { location, name } = workspace;
+    console.info(`Running Deplint for ${name}`);
+    totalErrors += checkPackage({
+      name,
+      location,
+      devDeps,
+      deps,
+      exclude,
+      peerDeps,
+      verbose
+    });
+  }
+  if (totalErrors > 0) {
+    console.warn(`Deplint: Found ${chalk24.red(totalErrors)} dependency problems. ${chalk24.red("\u2716")}`);
+  } else {
+    console.info(`Deplint: Found no dependency problems. ${chalk24.green("\u2714")}`);
+  }
+  return 0;
+};
+
+// src/actions/dupdeps.ts
+import chalk25 from "chalk";
+var dupdeps = () => {
+  console.log(chalk25.green("Checking all Dependencies for Duplicates"));
+  const pkg = parsedPackageJSON();
+  const allDependencies = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  const dependencies = Object.keys(allDependencies);
+  return detectDuplicateDependencies(dependencies);
+};
+
+// src/actions/lint.ts
+import chalk26 from "chalk";
+var lintPackage = ({
+  pkg,
+  fix: fix2,
+  verbose
+}) => {
+  console.log(chalk26.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
+  const start = Date.now();
+  const pm = getPackageManager();
+  const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
+    pm.runInWorkspace(pkg, fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint")
+  ]);
+  console.log(chalk26.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk26.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk26.gray("seconds")}`));
+  return result;
+};
+var lint = ({
+  pkg,
+  verbose,
+  incremental,
+  fix: fix2
+} = {}) => {
+  return pkg === void 0 ? lintAllPackages({
+    verbose,
+    incremental,
+    fix: fix2
+  }) : lintPackage({
+    pkg,
+    fix: fix2,
+    verbose
+  });
+};
+var lintAllPackages = ({ fix: fix2 = false } = {}) => {
+  console.log(chalk26.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
+  const start = Date.now();
+  const fixOptions = fix2 ? ["--fix"] : [];
+  const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
+    ["eslint", ["--cache", "--cache-location", ".eslintcache", "--cache-strategy", "content", ...fixOptions]]
+  ]);
+  console.log(chalk26.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk26.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk26.gray("seconds")}`));
+  return result;
+};
+
+// src/actions/fix.ts
+var fix = (params) => {
+  return lint({ ...params, fix: true });
+};
+
+// src/actions/gen-docs.ts
+var genDocs = ({ pkg, incremental }) => {
+  return pkg ? genDocsPackage({ pkg }) : genDocsAll({ incremental });
+};
+var genDocsPackage = ({ pkg }) => {
+  const pm = getPackageManager();
+  return runSteps(`GenDocs [${pkg}]`, [pm.runInWorkspace(pkg, "package-gen-docs")]);
+};
+var genDocsAll = ({ incremental }) => {
+  const pm = getPackageManager();
+  return runSteps(`GenDocs [All${incremental ? "-Incremental" : ""}]`, [
+    pm.foreachWorkspace("package-gen-docs", [], { incremental })
+  ]);
+};
+
+// src/actions/gitignore.ts
+import { unlinkSync as unlinkSync4 } from "fs";
+import chalk27 from "chalk";
+var COMMENT_PREFIX = "#";
+var isComment = (line) => line.startsWith(COMMENT_PREFIX);
+var isNegation = (line) => line.startsWith("!");
+function parseTemplateSections(lines) {
+  const sections = [];
+  let current = [];
+  for (const line of lines) {
+    if (isComment(line)) {
+      if (current.length > 0) {
+        sections.push(current);
+      }
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  if (current.length > 0) {
+    sections.push(current);
+  }
+  return sections;
+}
+function mergeWithTemplate(existing, templateContent) {
+  const templateLines = templateContent.split("\n").filter((line) => line.trim().length > 0);
+  const sections = parseTemplateSections(templateLines);
+  const existingEntries = new Set(existing.filter((line) => !isComment(line)));
+  const templateEntries = new Set(templateLines.filter((line) => !isComment(line)));
+  const customEntries = [...existingEntries].filter((entry) => !templateEntries.has(entry));
+  const result = [];
+  for (const section of sections) {
+    for (const line of section) {
+      result.push(line);
+    }
+    result.push("");
+  }
+  if (customEntries.length > 0) {
+    result.push("# Custom");
+    const sorted = [...union(customEntries, [])].toSorted((a, b) => {
+      if (isNegation(a) && !isNegation(b)) return 1;
+      if (!isNegation(a) && isNegation(b)) return -1;
+      return a.localeCompare(b);
+    });
+    for (const entry of sorted) {
+      result.push(entry);
+    }
+    result.push("");
+  }
+  return result;
+}
+function removePackageGitignores(cwd5) {
+  let removed = 0;
+  const workspaces = getPackageManager().listWorkspaces();
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const filePath = `${cwd5}/${location}/.gitignore`;
+    try {
+      unlinkSync4(filePath);
+      console.log(chalk27.yellow(`  Removed ${location}/.gitignore`));
+      removed++;
+    } catch {
+    }
+  }
+  return removed;
+}
+var gitignoreGen = gitignore;
+function gitignore() {
+  console.log(chalk27.green("Generate .gitignore"));
+  const cwd5 = INIT_CWD() ?? ".";
+  const gitignorePath = `${cwd5}/.gitignore`;
+  try {
+    const templateContent = gitignoreTemplate();
+    const existing = readNonEmptyLines(gitignorePath);
+    const merged = mergeWithTemplate(existing, templateContent);
+    writeLines(gitignorePath, merged);
+    console.log(chalk27.green("  Root .gitignore updated"));
+    const removed = removePackageGitignores(cwd5);
+    if (removed > 0) {
+      console.log(chalk27.green(`  Removed ${removed} package .gitignore file(s)`));
+    }
+    return 0;
+  } catch (ex) {
+    const error = ex;
+    console.error(chalk27.red(`Generate .gitignore failed: ${error.message}`));
+    return 1;
+  }
+}
+
+// src/actions/gitlint.ts
+import chalk28 from "chalk";
+import ParseGitConfig from "parse-git-config";
+var gitlint = () => {
+  console.log(`
+Gitlint Start [${process.cwd()}]
+`);
+  let valid = 0;
+  let warnings = 0;
+  const errors = 0;
+  const gitConfig = ParseGitConfig.sync();
+  const warn = (message) => {
+    console.warn(chalk28.yellow(`Warning: ${message}`));
+    warnings++;
+  };
+  if (gitConfig.core.ignorecase) {
+    warn("Please set core.ignorecase to FALSE in .git/config file [run yarn gitlint-fix]");
+  } else {
+    valid++;
+  }
+  if (gitConfig.core.autocrlf === false) {
+    valid++;
+  } else {
+    warn("Please set core.autocrlf to FALSE in .git/config file [run yarn gitlint-fix]");
+  }
+  if (gitConfig.core.eol === "lf") {
+    valid++;
+  } else {
+    warn('Please set core.eol to "lf" in .git/config file [run yarn gitlint-fix]');
+  }
+  const resultMessages = [];
+  if (valid > 0) {
+    resultMessages.push(chalk28.green(`Passed: ${valid}`));
+  }
+  if (warnings > 0) {
+    resultMessages.push(chalk28.yellow(`Warnings: ${warnings}`));
+  }
+  if (errors > 0) {
+    resultMessages.push(chalk28.red(` Errors: ${errors}`));
+  }
+  console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
+`);
+  return warnings + errors === 0 ? 1 : 0;
+};
+
+// src/actions/gitlint-fix.ts
+import { execSync as execSync3 } from "child_process";
+import chalk29 from "chalk";
+import ParseGitConfig2 from "parse-git-config";
+var gitlintFix = () => {
+  console.log(`
+Gitlint Fix Start [${process.cwd()}]
+`);
+  const gitConfig = ParseGitConfig2.sync();
+  if (gitConfig.core.ignorecase) {
+    execSync3("git config core.ignorecase false", { stdio: "inherit" });
+    console.warn(chalk29.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+  }
+  if (gitConfig.core.autocrlf !== false) {
+    execSync3("git config core.autocrlf false", { stdio: "inherit" });
+    console.warn(chalk29.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+  }
+  if (gitConfig.core.eol !== "lf") {
+    execSync3("git config core.eol lf", { stdio: "inherit" });
+    console.warn(chalk29.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+  }
+  return 1;
+};
+
+// src/actions/knip.ts
+var knip = () => {
+  return runSteps("Knip", [["knip", ["--dependencies", "--no-exit-code"]]]);
+};
+
+// src/actions/license.ts
+import chalk30 from "chalk";
+import { init } from "license-checker";
+var license = async (pkg) => {
+  const workspaces = getPackageManager().listWorkspaces();
+  const workspaceList = workspaces.filter(({ name }) => {
+    return pkg === void 0 || name === pkg;
+  });
+  const exclude = /* @__PURE__ */ new Set([
+    "MIT",
+    "MIT*",
+    "ISC",
+    "Apache-2.0",
+    "BSD",
+    "BSD*",
+    "BSD-2-Clause",
+    "BSD-3-Clause",
+    "CC-BY-4.0",
+    "Unlicense",
+    "CC-BY-3.0",
+    "CC0-1.0",
+    "LGPL-3.0-only",
+    "LGPL-3.0",
+    "LGPL-3.0-or-later",
+    "Python-2.0"
+  ]);
+  console.log(chalk30.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(chalk30.red(`License Checker [${name}] Error`));
+            console.error(chalk30.gray(error));
+            console.log("\n");
+            resolve(1);
+          } else {
+            console.log(chalk30.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];
+              for (let license2 of licenses) {
+                if (license2) {
+                  const processedLicense = license2[0] === "(" && license2.at(-1) === ")" ? license2.slice(1, -2) : license2;
+                  const orLicenses = processedLicense.split(" OR ");
+                  let orLicenseFound = false;
+                  for (const orLicense of orLicenses) {
+                    if (exclude.has(orLicense)) {
+                      orLicenseFound = true;
+                    }
+                  }
+                  if (!orLicenseFound) {
+                    count++;
+                    console.warn(chalk30.yellow(`${name2}: Package License not allowed [${license2}]`));
+                  }
+                }
+              }
+            }
+            console.log("\n");
+            resolve(count);
+          }
+        });
+      });
+    })
+  )).reduce((prev, value) => prev || value, 0);
+};
+
+// src/actions/lintlint.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import PATH9 from "path";
+import chalk31 from "chalk";
+import { findUp } from "find-up";
+function parseRuleValue(value) {
+  if (typeof value === "string") {
+    return { level: value };
+  }
+  if (typeof value === "number") {
+    return { level: String(value) };
+  }
+  if (Array.isArray(value) && value.length > 0) {
+    return {
+      level: String(value[0]),
+      options: value.length > 1 ? value.slice(1) : void 0
+    };
+  }
+  return void 0;
+}
+function normalizeLevel(level) {
+  if (level === "0" || level === "off") return "off";
+  if (level === "1" || level === "warn") return "warn";
+  if (level === "2" || level === "error") return "error";
+  return level;
+}
+function rulesMatch(a, b) {
+  if (normalizeLevel(a.level) !== normalizeLevel(b.level)) return false;
+  return JSON.stringify(a.options) === JSON.stringify(b.options);
+}
+function formatRule(entry) {
+  if (entry.options) {
+    return JSON.stringify([entry.level, ...entry.options]);
+  }
+  return JSON.stringify([entry.level]);
+}
+function mergeRulesFromBlocks(blocks) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (!block.rules) continue;
+    for (const [name, value] of Object.entries(block.rules)) {
+      const parsed = parseRuleValue(value);
+      if (parsed) merged.set(name, parsed);
+    }
+  }
+  return merged;
+}
+function detectSharedPackage(source) {
+  if (source.includes("@xylabs/eslint-config-react-flat")) return "@xylabs/eslint-config-react-flat";
+  if (source.includes("@xylabs/eslint-config-flat")) return "@xylabs/eslint-config-flat";
+  return void 0;
+}
+function extractLocalRuleBlocks(source) {
+  const blocks = [];
+  const ruleBlockRegex = /\{\s*(?:files\s*:\s*\[.*?\]\s*,\s*)?rules\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/g;
+  let match;
+  while ((match = ruleBlockRegex.exec(source)) !== null) {
+    blocks.push(match[1]);
+  }
+  return blocks;
+}
+function extractRulesFromSourceBlocks(blocks) {
+  const rules2 = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const ruleRegex = /['"]([^'"]+)['"]\s*:\s*(\[[\s\S]*?\](?=\s*,|\s*$))/gm;
+    let match;
+    while ((match = ruleRegex.exec(block)) !== null) {
+      rules2.set(match[1], match[2]);
+    }
+  }
+  return rules2;
+}
+async function resolveSharedConfig(configDir, sharedPkg) {
+  try {
+    const sharedModule = await import(sharedPkg);
+    const config2 = sharedModule.config ?? sharedModule.default;
+    if (Array.isArray(config2)) return config2;
+    return [];
+  } catch {
+    const distPath = PATH9.resolve(configDir, "node_modules", sharedPkg, "dist", "node", "index.mjs");
+    try {
+      const sharedModule = await import(distPath);
+      const config2 = sharedModule.config ?? sharedModule.default;
+      if (Array.isArray(config2)) return config2;
+    } catch {
+      const neutralPath = PATH9.resolve(configDir, "node_modules", sharedPkg, "dist", "neutral", "index.mjs");
+      const sharedModule = await import(neutralPath);
+      const config2 = sharedModule.config ?? sharedModule.default;
+      if (Array.isArray(config2)) return config2;
+    }
+    return [];
+  }
+}
+async function loadSharedRules(configDir, sharedPkg, verbose) {
+  const sharedBlocks = await resolveSharedConfig(configDir, sharedPkg);
+  const sharedRules = mergeRulesFromBlocks(sharedBlocks);
+  if (verbose) {
+    console.log(chalk31.gray(`Shared config defines ${sharedRules.size} rules`));
+  }
+  if (sharedRules.size === 0) {
+    console.error(chalk31.red("Could not load rules from shared config. Is it installed and built?"));
+    return void 0;
+  }
+  return sharedRules;
+}
+async function loadLocalRules(eslintConfigPath, source, verbose) {
+  const localModule = await import(eslintConfigPath);
+  const localConfig = localModule.default ?? localModule;
+  const localBlocks = Array.isArray(localConfig) ? localConfig : [localConfig];
+  const resolved = mergeRulesFromBlocks(localBlocks);
+  const localRuleBlocks = extractLocalRuleBlocks(source);
+  const explicit = extractRulesFromSourceBlocks(localRuleBlocks);
+  if (verbose) {
+    console.log(chalk31.gray(`Local config has ${explicit.size} explicit rule setting(s)`));
+  }
+  return { explicit, resolved };
+}
+function compareRules(explicitRuleNames, allResolvedRules, sharedRules) {
+  const redundant = [];
+  const overrides = [];
+  const additions = [];
+  for (const ruleName of explicitRuleNames.keys()) {
+    const resolvedEntry = allResolvedRules.get(ruleName);
+    const sharedEntry = sharedRules.get(ruleName);
+    if (!resolvedEntry) continue;
+    if (!sharedEntry) {
+      additions.push({ local: resolvedEntry, rule: ruleName });
+    } else if (rulesMatch(resolvedEntry, sharedEntry)) {
+      redundant.push({
+        local: resolvedEntry,
+        rule: ruleName,
+        shared: sharedEntry
+      });
+    } else {
+      overrides.push({
+        local: resolvedEntry,
+        rule: ruleName,
+        shared: sharedEntry
+      });
+    }
+  }
+  return {
+    additions,
+    overrides,
+    redundant
+  };
+}
+function reportResults({
+  additions,
+  overrides,
+  redundant
+}, verbose) {
+  if (redundant.length > 0) {
+    console.log(chalk31.yellow(`
+${redundant.length} redundant rule(s) (same as shared config \u2014 can be removed):`));
+    for (const { rule, local } of redundant) {
+      console.log(chalk31.yellow(`  ${rule}: ${formatRule(local)}`));
+    }
+  }
+  if (overrides.length > 0) {
+    console.log(chalk31.cyan(`
+${overrides.length} rule override(s) (different from shared config):`));
+    for (const {
+      rule,
+      local,
+      shared
+    } of overrides) {
+      console.log(chalk31.cyan(`  ${rule}:`));
+      console.log(chalk31.gray(`    shared: ${formatRule(shared)}`));
+      console.log(chalk31.white(`    local:  ${formatRule(local)}`));
+    }
+  }
+  if (additions.length > 0 && verbose) {
+    console.log(chalk31.gray(`
+${additions.length} local addition(s) (not in shared config):`));
+    for (const { rule, local } of additions) {
+      console.log(chalk31.gray(`  ${rule}: ${formatRule(local)}`));
+    }
+  }
+  if (redundant.length === 0 && overrides.length === 0) {
+    console.log(chalk31.green("No redundant or overridden rules found"));
+  }
+}
+function fixRedundantRules(eslintConfigPath, source, redundant) {
+  let updated = source;
+  for (const { rule } of redundant) {
+    const escaped = rule.replaceAll("/", String.raw`\/`);
+    const pattern = new RegExp(String.raw`[ \t]*['"]${escaped}['"]\s*:\s*\[[^\]]*\],?[ \t]*\n?`, "g");
+    updated = updated.replace(pattern, "");
+  }
+  updated = updated.replaceAll(/\n{3,}/g, "\n\n");
+  if (updated !== source) {
+    writeFileSync6(eslintConfigPath, updated, "utf8");
+    console.log(chalk31.green(`
+Fixed: removed ${redundant.length} redundant rule(s)`));
+  }
+}
+async function lintlint({ fix: fix2, verbose } = {}) {
+  const eslintConfigPath = await findUp("eslint.config.mjs");
+  if (!eslintConfigPath) {
+    console.error(chalk31.red("No eslint.config.mjs found"));
+    return 1;
+  }
+  const configDir = PATH9.dirname(eslintConfigPath);
+  if (verbose) {
+    console.log(chalk31.gray(`Found config: ${eslintConfigPath}`));
+  }
+  const source = readFileSync9(eslintConfigPath, "utf8");
+  const sharedPkg = detectSharedPackage(source);
+  if (!sharedPkg) {
+    console.log(chalk31.yellow("No @xylabs/eslint-config-flat or @xylabs/eslint-config-react-flat imports found"));
+    return 0;
+  }
+  if (verbose) {
+    console.log(chalk31.gray(`Shared package: ${sharedPkg}`));
+  }
+  const sharedRules = await loadSharedRules(configDir, sharedPkg, !!verbose);
+  if (!sharedRules) return 1;
+  const { explicit, resolved } = await loadLocalRules(eslintConfigPath, source, !!verbose);
+  const results = compareRules(explicit, resolved, sharedRules);
+  reportResults(results, !!verbose);
+  if (results.redundant.length > 0 && fix2) {
+    fixRedundantRules(eslintConfigPath, source, results.redundant);
+  }
+  return results.redundant.length > 0 && !fix2 ? 1 : 0;
+}
+
+// src/actions/npmignore-gen.ts
+var filename = ".npmignore";
+var npmignoreGen = (pkg) => generateIgnoreFiles(filename, pkg);
+
+// src/actions/package/clean-outputs.ts
+import path9 from "path";
+import chalk32 from "chalk";
+var packageCleanOutputs = () => {
+  const pkg = process.env.INIT_CWD ?? ".";
+  const pkgName = process.env.npm_package_name;
+  const folders = [path9.join(pkg, "dist"), path9.join(pkg, "build"), path9.join(pkg, "docs")];
+  console.log(chalk32.green(`Cleaning Outputs [${pkgName}]`));
+  for (let folder of folders) {
+    deleteGlob(folder);
+  }
+  return 0;
+};
+
+// src/actions/package/clean-typescript.ts
+import path10 from "path";
+import chalk33 from "chalk";
+var packageCleanTypescript = () => {
+  const pkg = process.env.INIT_CWD ?? ".";
+  const pkgName = process.env.npm_package_name;
+  console.log(chalk33.green(`Cleaning Typescript [${pkgName}]`));
+  const files = [path10.join(pkg, "*.tsbuildinfo"), path10.join(pkg, ".tsconfig.*"), path10.join(pkg, ".eslintcache")];
+  for (let file of files) {
+    deleteGlob(file);
+  }
+  return 0;
+};
+
+// src/actions/package/clean.ts
+var packageClean = async () => {
+  return (await Promise.all([packageCleanOutputs(), packageCleanTypescript()])).reduce((prev, value) => prev + value, 0);
+};
+
+// src/actions/package/compile/compile.ts
+import chalk38 from "chalk";
+
+// src/actions/package/compile/packageCompileTsup.ts
+import chalk37 from "chalk";
+import { build as build2, defineConfig } from "tsup";
+
+// src/actions/package/compile/inputs.ts
+import chalk34 from "chalk";
+import { glob as glob2 } from "glob";
+var getAllInputs = (srcDir, verbose = false) => {
+  return [...glob2.sync(`${srcDir}/**/*.ts`, { posix: true }).map((file) => {
+    const result = file.slice(Math.max(0, srcDir.length + 1));
+    if (verbose) {
+      console.log(chalk34.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+    }
+    return result;
+  }), ...glob2.sync(`${srcDir}/**/*.tsx`, { posix: true }).map((file) => {
+    const result = file.slice(Math.max(0, srcDir.length + 1));
+    if (verbose) {
+      console.log(chalk34.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+    }
+    return result;
+  })];
+};
+
+// src/actions/package/compile/buildEntries.ts
+var isSpecOrStory = (entry) => {
+  return entry.includes(".spec.") || entry.includes(".stories.") || entry.startsWith("spec/") || entry.includes("/spec/") || entry.startsWith("stories/") || entry.includes("/stories/") || entry === "spec.ts" || entry.endsWith("/spec.ts") || entry === "stories.ts" || entry.endsWith("/stories.ts");
+};
+var buildEntries = (srcDir, entryMode = "single", options, excludeSpecAndStories = true, verbose = false) => {
+  let entries = [];
+  switch (entryMode) {
+    case "platform": {
+      entries = ["index-node.ts", "index-browser.ts"];
+      break;
+    }
+    case "all": {
+      entries = (excludeSpecAndStories ? getAllInputs(srcDir).filter((entry) => !isSpecOrStory(entry)) : getAllInputs(srcDir)).filter((entry) => !entry.endsWith(".d.ts"));
+      break;
+    }
+    case "custom": {
+      entries = [];
+      break;
+    }
+    default: {
+      entries = ["index.ts"];
+      break;
+    }
+  }
+  if (typeof options !== "boolean" && Array.isArray(options?.entry)) {
+    entries.push(...options.entry);
+  }
+  if (verbose) console.log(`buildEntries [${entryMode}] ${entries.length}`);
+  return entries;
+};
+
+// src/actions/package/compile/deepMerge.ts
+function deepMerge(target, source) {
+  if (!source || typeof source !== "object") return target;
+  for (const key of Object.keys(source)) {
+    if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key])) {
+      if (!target[key] || typeof target[key] !== "object") {
+        target[key] = {};
+      }
+      deepMerge(target[key], source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function deepMergeObjects(objects) {
+  const result = {};
+  for (const obj of objects) {
+    deepMerge(result, obj);
+  }
+  return result;
+}
+
+// src/actions/package/compile/packageCompileTsc.ts
+import { cwd as cwd2 } from "process";
+import chalk35 from "chalk";
+import { createProgramFromConfig } from "tsc-prog";
+import ts3, {
+  DiagnosticCategory,
+  formatDiagnosticsWithColorAndContext,
+  getPreEmitDiagnostics,
+  sys
+} from "typescript";
+
+// src/actions/package/compile/getCompilerOptions.ts
+import { cwd } from "process";
+import deepmerge2 from "deepmerge";
+import { getTsconfig } from "get-tsconfig";
+var getCompilerOptions = (options = {}, fileName = "tsconfig.json") => {
+  const resolvedTsConfigCompilerOptions = getTsconfig(cwd(), fileName)?.config?.compilerOptions ?? {};
+  return deepmerge2(resolvedTsConfigCompilerOptions, options);
+};
+
+// src/actions/package/compile/packageCompileTsc.ts
+var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", compilerOptionsParam, verbose = false) => {
+  const pkg = process.env.INIT_CWD ?? cwd2();
+  if (verbose) {
+    console.log(chalk35.cyan(`Validating code START: ${entries.length} files to ${outDir} from ${srcDir}`));
+  }
+  const configFilePath = ts3.findConfigFile(
+    "./",
+    // search path
+    ts3.sys.fileExists,
+    "tsconfig.json"
+  );
+  if (configFilePath === void 0) {
+    throw new Error("Could not find tsconfig.json");
+  }
+  const compilerOptions = {
+    ...getCompilerOptions({
+      removeComments: false,
+      skipDefaultLibCheck: true,
+      skipLibCheck: true,
+      sourceMap: false
+    }),
+    ...compilerOptionsParam,
+    outDir: `${outDir}/${platform}`,
+    emitDeclarationOnly: true,
+    noEmit: false
+  };
+  console.log(chalk35.cyan(`Validating Files: ${entries.length}`));
+  if (verbose) {
+    for (const entry of entries) {
+      console.log(chalk35.grey(`Validating: ${entry}`));
+    }
+  }
+  try {
+    if (entries.length > 0) {
+      const program = createProgramFromConfig({
+        configFilePath,
+        basePath: pkg ?? cwd2(),
+        compilerOptions,
+        files: entries.map((entry) => `${srcDir}/${entry}`),
+        include: [`${srcDir}/**/*.*`]
+      });
+      const diagnostics = getPreEmitDiagnostics(program);
+      if (diagnostics.length > 0) {
+        const formattedDiagnostics = formatDiagnosticsWithColorAndContext(
+          diagnostics,
+          {
+            getCanonicalFileName: (fileName) => fileName,
+            getCurrentDirectory: () => srcDir,
+            getNewLine: () => sys.newLine
+          }
+        );
+        console.error(formattedDiagnostics);
+      }
+      const nonEmitPatterns = [".stories.", "/stories/", "/stories.", ".spec.", "/spec/", "/spec.", ".example."];
+      program.emit(void 0, (fileName, text, writeByteOrderMark) => {
+        if (nonEmitPatterns.some((pattern) => fileName.includes(pattern))) {
+          return;
+        }
+        ts3.sys.writeFile(fileName, text, writeByteOrderMark);
+      });
+      return diagnostics.reduce((acc, diag) => acc + (diag.category === DiagnosticCategory.Error ? 1 : 0), 0);
+    }
+    return 0;
+  } finally {
+    if (verbose) {
+      console.log(chalk35.cyan(`Validating code FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+    }
+  }
+};
+
+// src/actions/package/compile/packageCompileTscTypes.ts
+import path11 from "path";
+import { cwd as cwd3 } from "process";
+import chalk36 from "chalk";
+import { rollup } from "rollup";
+import dts from "rollup-plugin-dts";
+import nodeExternals from "rollup-plugin-node-externals";
+var ignoredWarningCodes = /* @__PURE__ */ new Set(["EMPTY_BUNDLE", "UNRESOLVED_IMPORT"]);
+async function bundleDts(inputPath, outputPath, platform, options, verbose = false) {
+  const pkg = process.env.INIT_CWD ?? cwd3();
+  const tsconfigPath = path11.resolve(pkg, "tsconfig.json");
+  const nodePlugIns = platform === "node" ? [nodeExternals()] : [];
+  try {
+    const bundle = await rollup({
+      input: inputPath,
+      plugins: [dts({
+        ...options,
+        tsconfig: tsconfigPath,
+        compilerOptions: {
+          emitDeclarationOnly: true,
+          noEmit: false,
+          declarationMap: true
+        }
+      }), ...nodePlugIns],
+      onwarn(warning, warn) {
+        if (ignoredWarningCodes.has(warning.code ?? "")) {
+          return;
+        }
+        console.warn(chalk36.yellow(`[${warning.code}] ${warning.message}`));
+        console.warn(chalk36.gray(inputPath));
+        warn(warning);
+      }
+    });
+    await bundle.write({
+      file: outputPath,
+      format: "es"
+    });
+  } catch (ex) {
+    const error = ex;
+    console.warn(chalk36.red(error));
+    console.warn(chalk36.gray(inputPath));
+  }
+  if (verbose) {
+    console.log(`Bundled declarations written to ${outputPath}`);
+  }
+}
+var packageCompileTscTypes = async (entries, outDir, platform, srcDir = "build", verbose = false) => {
+  if (verbose) {
+    console.log(chalk36.cyan(`Compiling Types START [${platform}]: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(`Entries: ${entries.join(", ")}`);
+  }
+  const pkg = process.env.INIT_CWD ?? cwd3();
+  const srcRoot = `${pkg}/${srcDir}/${platform}`;
+  const entryNameToTypeName = (entry) => {
+    const splitEntryName = entry.split(".");
+    const newEntryExtension = "d." + splitEntryName.at(-1);
+    return [...splitEntryName.slice(0, -1), newEntryExtension].join(".");
+  };
+  const compilerOptions = getCompilerOptions({
+    removeComments: false,
+    skipDefaultLibCheck: true,
+    skipLibCheck: true,
+    declarationMap: true,
+    emitDeclarationOnly: true,
+    noEmit: true
+  });
+  const entryNames = entries.map((entry) => entry.split(`${srcDir}/`).at(-1) ?? entry);
+  await Promise.all(entryNames.map(async (entryName) => {
+    const entryTypeName = entryNameToTypeName(entryName);
+    await bundleDts(`${srcRoot}/${entryTypeName}`, `${outDir}/${entryTypeName}`, platform, { compilerOptions }, verbose);
+  }));
+  if (verbose) {
+    console.log(chalk36.cyan(`Compiling Types FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+  }
+  return 0;
+};
+
+// src/actions/package/compile/packageCompileTsup.ts
+var compileFolder = async (srcDir, entries, buildDir, options, bundleTypes = false, verbose) => {
+  const outDir = options?.outDir ?? "dist";
+  if (verbose) {
+    console.log(`compileFolder [${srcDir}, ${options?.outDir}]`);
+  }
+  if (entries.length === 0) {
+    console.warn(chalk37.yellow(`No entries found in ${srcDir} to compile`));
+    return 0;
+  }
+  if (verbose) {
+    console.log(chalk37.gray(`buildDir [${buildDir}]`));
+  }
+  const validationResult = packageCompileTsc(options?.platform ?? "neutral", entries, srcDir, buildDir, void 0, verbose);
+  if (validationResult !== 0) {
+    console.error(chalk37.red(`Compile:Validation had ${validationResult} errors`));
+    return validationResult;
+  }
+  const optionsParams = tsupOptions([{
+    bundle: true,
+    cjsInterop: true,
+    clean: false,
+    dts: false,
+    format: ["esm"],
+    outDir,
+    silent: true,
+    sourcemap: true,
+    splitting: false,
+    tsconfig: "tsconfig.json",
+    ...options,
+    entry: entries.map((entry) => `${srcDir}/${entry}`)
+  }]);
+  const optionsResult = defineConfig(optionsParams);
+  const optionsList = (await Promise.all(
+    (Array.isArray(optionsResult) ? optionsResult : [optionsResult]).flatMap(async (options2) => {
+      const result = typeof options2 === "function" ? await options2({}) : [options2];
+      return Array.isArray(result) ? result : [result];
+    })
+  )).flat();
+  if (verbose) {
+    console.log(chalk37.cyan(`TSUP:build:start [${srcDir}]`));
+    console.log(chalk37.gray(`TSUP:build:options [${JSON.stringify(optionsList, null, 2)}]`));
+  }
+  await Promise.all(optionsList.map((options2) => build2(options2)));
+  if (verbose) {
+    console.log(chalk37.cyan(`TSUP:build:stop [${srcDir}]`));
+  }
+  if (bundleTypes) {
+    await packageCompileTscTypes(entries, outDir, options?.platform ?? "neutral", buildDir, verbose);
+  }
+  return 0;
+};
+var tsupOptions = (options = []) => {
+  const standardLoaders = {
+    ".gif": "copy",
+    ".html": "copy",
+    ".jpg": "copy",
+    ".json": "json",
+    ".png": "copy",
+    ".svg": "text",
+    ".webp": "copy"
+  };
+  const standardOptions = {
+    bundle: true,
+    format: ["esm"],
+    loader: standardLoaders,
+    outExtension: ({ format }) => format === "esm" ? { js: ".mjs" } : { js: ".cjs" },
+    skipNodeModulesBundle: true,
+    sourcemap: true,
+    target: "esnext"
+  };
+  return deepMergeObjects([standardOptions, ...options]);
+};
+var packageCompileTsup = async (config2) => {
+  const compile2 = config2?.compile;
+  const verbose = config2?.verbose ?? false;
+  const outDirAsBuildDir = compile2?.outDirAsBuildDir ?? true;
+  const bundleTypes = compile2?.bundleTypes ?? false;
+  if (verbose) {
+    console.log("Compiling with TSUP");
+  }
+  const compileForNode = compile2?.node ?? { src: {} };
+  const compileForBrowser = compile2?.browser ?? { src: {} };
+  const compileForNeutral = compile2?.neutral ?? { src: {} };
+  return (await Promise.all(
+    Object.entries(compileForNode).map(async ([srcDir, options]) => {
+      const optionsObject = typeof options === "object" ? options : {};
+      const inEsBuildOptions = typeof compile2?.node?.esbuildOptions === "object" ? compile2?.node?.esbuildOptions : {};
+      const entry = buildEntries(srcDir, compile2?.entryMode, options, true, verbose);
+      const platform = "node";
+      const rootOutDir = optionsObject.outDir ?? "dist";
+      const outDir = rootOutDir + "/" + platform;
+      return typeof srcDir === "string" ? await compileFolder(
+        srcDir,
+        entry,
+        outDirAsBuildDir ? rootOutDir : "build",
+        tsupOptions([
+          inEsBuildOptions,
+          compile2?.tsup?.options ?? {},
+          typeof options === "object" ? options : {},
+          { platform: "node", outDir }
+        ]),
+        bundleTypes,
+        verbose
+      ) : 0;
+    })
+  )).reduce((prev, value) => prev + value, 0) + (await Promise.all(
+    Object.entries(compileForBrowser).map(async ([srcDir, options]) => {
+      const optionsObject = typeof options === "object" ? options : {};
+      const inEsBuildOptions = typeof compile2?.browser?.esbuildOptions === "object" ? compile2?.browser?.esbuildOptions : {};
+      const entry = buildEntries(srcDir, compile2?.entryMode, options, true, verbose);
+      const platform = "browser";
+      const rootOutDir = optionsObject.outDir ?? "dist";
+      const outDir = rootOutDir + "/" + platform;
+      return typeof srcDir === "string" ? await compileFolder(
+        srcDir,
+        entry,
+        outDirAsBuildDir ? rootOutDir : "build",
+        tsupOptions([
+          inEsBuildOptions,
+          compile2?.tsup?.options ?? {},
+          typeof options === "object" ? options : {},
+          { platform: "browser", outDir }
+        ]),
+        bundleTypes,
+        verbose
+      ) : 0;
+    })
+  )).reduce((prev, value) => prev + value, 0) + (await Promise.all(
+    Object.entries(compileForNeutral).map(async ([srcDir, options]) => {
+      const optionsObject = typeof options === "object" ? options : {};
+      const inEsBuildOptions = typeof compile2?.neutral?.esbuildOptions === "object" ? compile2?.neutral?.esbuildOptions : {};
+      const entry = buildEntries(srcDir, compile2?.entryMode, options, true, verbose);
+      const platform = "neutral";
+      const rootOutDir = optionsObject.outDir ?? "dist";
+      const outDir = rootOutDir + "/" + platform;
+      return typeof srcDir === "string" ? await compileFolder(
+        srcDir,
+        entry,
+        outDirAsBuildDir ? rootOutDir : "build",
+        tsupOptions([
+          inEsBuildOptions,
+          compile2?.tsup?.options ?? {},
+          typeof options === "object" ? options : {},
+          { platform: "neutral", outDir }
+        ]),
+        bundleTypes,
+        verbose
+      ) : 0;
+    })
+  )).reduce((prev, value) => prev + value, 0) + 0;
+};
+
+// src/actions/package/compile/compile.ts
+var packageCompile = async (inConfig = {}) => {
+  const pkg = process.env.INIT_CWD;
+  console.log(chalk38.green(`Compiling ${pkg}`));
+  const config2 = await loadConfig(inConfig);
+  return await packageCompileTsup(config2);
+};
+
+// src/actions/package/copy-assets.ts
+import path12 from "path/posix";
+import chalk39 from "chalk";
+import cpy2 from "cpy";
+var copyTargetAssets2 = async (target, name, location) => {
+  try {
+    const values = await cpy2(
+      ["**/*.jpg", "**/*.png", "**/*.gif", "**/*.svg", "**/*.webp", "**/*.sass", "**/*.scss", "**/*.gif", "**/*.css"],
+      `../dist/${target}`,
+      {
+        cwd: path12.join(location, "src"),
+        flat: false
+      }
+    );
+    if (values.length > 0) {
+      console.log(chalk39.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
+    }
+    for (const value of values) {
+      console.log(`${value.split("/").pop()} => ./dist/${target}`);
+    }
+    return 0;
+  } catch (ex) {
+    const error = ex;
+    console.log(`Copy Assets Failed: ${name}: ${error.message}`);
+    return 1;
+  }
+};
+var packageCopyAssets = async ({ target }) => {
+  const pkg = process.env.INIT_CWD ?? "./";
+  const pkgName = process.env.npm_package_name ?? "Unknown";
+  switch (target) {
+    case "esm": {
+      return await copyTargetAssets2("esm", pkgName, pkg);
+    }
+    case "cjs": {
+      return await copyTargetAssets2("cjs", pkgName, pkg);
+    }
+    default: {
+      return await copyTargetAssets2("esm", pkgName, pkg) || await copyTargetAssets2("cjs", pkgName, pkg);
+    }
+  }
+};
+
+// src/actions/package/cycle.ts
+import { cruise as cruise2 } from "dependency-cruiser";
+var packageCycle = async () => {
+  const pkg = process.env.INIT_CWD;
+  const pkgName = process.env.npm_package_name;
+  const cruiseOptions = {
+    ruleSet: {
+      forbidden: [
+        {
+          name: "no-circular",
+          severity: "error",
+          comment: "This dependency creates a circular reference",
+          from: {},
+          to: { circular: true }
+        }
+      ]
+    },
+    exclude: "node_modules|packages/.*/packages",
+    validate: true,
+    doNotFollow: { path: "node_modules|packages/.*/packages" },
+    tsPreCompilationDeps: false,
+    combinedDependencies: true,
+    outputType: "err"
+  };
+  const target = `${pkg}/src`;
+  console.log(`Checking for circular dependencies in ${target}...`);
+  const result = await cruise2([target], cruiseOptions);
+  console.log(result.output);
+  if (result.exitCode === 0) {
+    console.log(`${pkgName} \u2705 No dependency violations`);
+  } else {
+    console.error(`${pkgName} \u274C Dependency violations found`);
+  }
+  return result.exitCode;
+};
+
+// src/actions/package/gen-docs.ts
+import { existsSync as existsSync10 } from "fs";
+import path13 from "path";
+import chalk40 from "chalk";
+import {
+  Application,
+  ArgumentsReader,
+  TSConfigReader,
+  TypeDocReader
+} from "typedoc";
+var ExitCodes = {
+  CompileError: 3,
+  ExceptionThrown: 6,
+  NoEntryPoints: 2,
+  Ok: 0,
+  OptionError: 1,
+  OutputError: 5,
+  ValidationError: 4
+};
+var packageGenDocs = async () => {
+  const pkg = process.env.INIT_CWD;
+  if (pkg !== void 0 && !existsSync10(path13.join(pkg, "typedoc.json"))) {
+    return;
+  }
+  const app = await Application.bootstrap({
+    entryPointStrategy: "merge",
+    entryPoints: [`${pkg}/src/**/*.ts`, `${pkg}/packages/*/dist/docs.json`],
+    excludeExternals: true,
+    json: `${pkg}/dist/docs.json`,
+    logLevel: "Error",
+    tsconfig: `${pkg}/tsconfig.json`
+  });
+  app.options.addReader(new ArgumentsReader(0));
+  app.options.addReader(new TypeDocReader());
+  app.options.addReader(new TSConfigReader());
+  app.options.addReader(new ArgumentsReader(300));
+  return await runTypeDoc(app);
+};
+var runTypeDoc = async (app) => {
+  const pkgName = process.env.npm_package_name;
+  if (app.options.getValue("version")) {
+    console.log(app.toString());
+    return ExitCodes.Ok;
+  }
+  if (app.options.getValue("showConfig")) {
+    console.log(app.options.getRawValues());
+    return ExitCodes.Ok;
+  }
+  if (app.logger.hasErrors()) {
+    return ExitCodes.OptionError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.OptionError;
+  }
+  if (app.options.getValue("entryPoints").length === 0) {
+    app.logger.error("No entry points provided");
+    return ExitCodes.NoEntryPoints;
+  }
+  if (app.options.getValue("watch")) {
+    await app.convertAndWatch(async (project2) => {
+      const out = app.options.getValue("out");
+      if (out) {
+        await app.generateDocs(project2, out);
+      }
+      const json = app.options.getValue("json");
+      if (json) {
+        await app.generateJson(project2, json);
+      }
+      if (!out && !json) {
+        await app.generateDocs(project2, "./docs");
+      }
+    });
+    return ExitCodes.Ok;
+  }
+  const project = await app.convert();
+  if (!project) {
+    return ExitCodes.CompileError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.CompileError;
+  }
+  app.validate(project);
+  if (app.logger.hasErrors()) {
+    return ExitCodes.ValidationError;
+  }
+  if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+    return ExitCodes.ValidationError;
+  }
+  if (app.options.getValue("emit") !== "none") {
+    const out = app.options.getValue("out");
+    if (out) {
+      await app.generateDocs(project, out);
+    }
+    const json = app.options.getValue("json");
+    if (json) {
+      await app.generateJson(project, json);
+    }
+    if (!out && !json) {
+      await app.generateDocs(project, "./docs");
+    }
+    if (app.logger.hasErrors()) {
+      return ExitCodes.OutputError;
+    }
+    if (app.options.getValue("treatWarningsAsErrors") && app.logger.hasWarnings()) {
+      return ExitCodes.OutputError;
+    }
+  }
+  console.log(chalk40.green(`${pkgName} - Ok`));
+  return ExitCodes.Ok;
+};
+
+// src/actions/package/lint.ts
+import { readdirSync as readdirSync6 } from "fs";
+import path14 from "path";
+import { cwd as cwd4 } from "process";
+import { pathToFileURL } from "url";
+import chalk41 from "chalk";
+import { ESLint } from "eslint";
+import { findUp as findUp2 } from "find-up";
+import picomatch from "picomatch";
+var dumpMessages = (lintResults) => {
+  const colors = ["white", "yellow", "red"];
+  const severity = ["none", "warning", "error"];
+  for (const lintResult of lintResults) {
+    if (lintResult.messages.length > 0) {
+      console.log(chalk41.gray(`
+${lintResult.filePath}`));
+      for (const message of lintResult.messages) {
+        console.log(
+          chalk41.gray(`	${message.line}:${message.column}`),
+          chalk41[colors[message.severity]](`	${severity[message.severity]}`),
+          chalk41.white(`	${message.message}`),
+          chalk41.gray(`	${message.ruleId}`)
+        );
+      }
+    }
+  }
+};
+async function getRootESLintConfig() {
+  const configPath = await findUp2("eslint.config.mjs");
+  if (configPath === void 0) {
+    throw new Error("eslint.config.mjs not found in the monorepo");
+  }
+  return pathToFileURL(configPath);
+}
+function getFiles(dir, ignoreFolders) {
+  const currentDirectory = cwd4();
+  const subDirectory = dir.split(currentDirectory)[1]?.split("/")[1];
+  if (ignoreFolders.includes(subDirectory)) return [];
+  return readdirSync6(dir, { withFileTypes: true }).flatMap((dirent) => {
+    const res = path14.resolve(dir, dirent.name);
+    const relativePath = subDirectory === void 0 ? dirent.name : `${subDirectory}/${dirent.name}`;
+    const ignoreMatchers = ignoreFolders.map((pattern) => picomatch(pattern));
+    if (ignoreMatchers.some((isMatch) => isMatch(relativePath))) return [];
+    return dirent.isDirectory() ? getFiles(res, ignoreFolders) : [res];
+  });
+}
+var packageLint = async (fix2 = false, verbose = false, cache = true) => {
+  const pkg = process.env.INIT_CWD;
+  const configPath = await getRootESLintConfig();
+  const { default: eslintConfig } = await import(configPath.href);
+  const start = Date.now();
+  const ignoreFolders = ["node_modules", "dist", "packages", ".git", "build", ".yarn", ".vscode", ".github"];
+  const engine = new ESLint({
+    baseConfig: [...eslintConfig],
+    fix: fix2,
+    warnIgnored: false,
+    cache
+  });
+  const files = getFiles(cwd4(), ignoreFolders);
+  console.log(chalk41.green(`Linting ${pkg} [files = ${files.length}]`));
+  if (verbose) {
+    for (const file of files) {
+      console.log(chalk41.gray(`	${file}`));
+    }
+  }
+  const lintResults = await engine.lintFiles(files);
+  dumpMessages(lintResults);
+  if (fix2) {
+    await ESLint.outputFixes(lintResults);
+  }
+  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(chalk41.white(`Linted ${chalk41[filesCountColor](files.length)} files in ${chalk41[lintTimeColor](lintTime)}ms`));
+  return lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0);
+};
+
+// src/actions/package/publint.ts
+import { promises as fs10 } from "fs";
+import chalk42 from "chalk";
+import sortPackageJson from "sort-package-json";
+var customPubLint = (pkg) => {
+  let errorCount = 0;
+  let warningCount = 0;
+  if (pkg.files === void 0) {
+    console.warn(chalk42.yellow('Publint [custom]: "files" field is missing'));
+    warningCount++;
+  }
+  if (pkg.main !== void 0) {
+    console.warn(chalk42.yellow('Publint [custom]: "main" field is deprecated, use "exports" instead'));
+    warningCount++;
+  }
+  if (pkg.sideEffects !== false) {
+    console.warn(chalk42.yellow('Publint [custom]: "sideEffects" field should be set to false'));
+    warningCount++;
+  }
+  if (pkg.resolutions !== void 0) {
+    console.warn(chalk42.yellow('Publint [custom]: "resolutions" in use'));
+    console.warn(chalk42.gray(JSON.stringify(pkg.resolutions, null, 2)));
+    warningCount++;
+  }
+  return [errorCount, warningCount];
+};
+var packagePublint = async ({ strict = true, verbose = false } = {}) => {
+  const pkgDir = process.env.INIT_CWD;
+  const sortedPkg = sortPackageJson(await fs10.readFile(`${pkgDir}/package.json`, "utf8"));
+  await fs10.writeFile(`${pkgDir}/package.json`, sortedPkg);
+  const pkg = JSON.parse(await fs10.readFile(`${pkgDir}/package.json`, "utf8"));
+  console.log(chalk42.green(`Publint: ${pkg.name}`));
+  console.log(chalk42.gray(pkgDir));
+  const { publint: publint2 } = await import("publint");
+  const { messages } = await publint2({
+    level: "suggestion",
+    pkgDir,
+    strict
+  });
+  const { formatMessage } = await import("publint/utils");
+  for (const message of messages) {
+    switch (message.type) {
+      case "error": {
+        console.error(chalk42.red(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+      case "warning": {
+        console.warn(chalk42.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+      default: {
+        console.log(chalk42.white(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+    }
+  }
+  const [errorCount, warningCount] = customPubLint(pkg);
+  if (verbose) {
+    console.log(chalk42.gray(`Publint [Finish]: ${pkgDir} [${messages.length + errorCount + warningCount} messages]`));
+  }
+  return messages.filter((message) => message.type === "error").length + errorCount;
+};
+
+// src/actions/package/recompile.ts
+var packageRecompile = async () => {
+  return await packageClean() || await packageCompile();
+};
+
+// src/actions/package-lint.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+import PATH10 from "path";
+import chalk43 from "chalk";
+import picomatch2 from "picomatch";
+function emptyResult() {
+  return {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+}
+function readRootPackageJson(cwd5) {
+  const raw = readFileSync10(PATH10.resolve(cwd5, "package.json"), "utf8");
+  return JSON.parse(raw);
+}
+function writeRootPackageJson(cwd5, pkg) {
+  const path15 = PATH10.resolve(cwd5, "package.json");
+  writeFileSync7(path15, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function isMonorepo(pkg) {
+  const workspaces = pkg.workspaces;
+  return Array.isArray(workspaces) && workspaces.length > 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(cwd5, pkg) {
+  pkg.private = true;
+  writeRootPackageJson(cwd5, pkg);
+  console.log(chalk43.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(cwd5, pkg) {
+  delete pkg.publishConfig;
+  writeRootPackageJson(cwd5, pkg);
+  console.log(chalk43.green("  \u2714 Fixed: removed publishConfig from private root package.json"));
+}
+function checkDiscoverable(pkg, workspaces) {
+  const result = emptyResult();
+  const globs = pkg.workspaces;
+  const matchers = globs.map((glob3) => picomatch2(glob3));
+  const isMatch = (location) => matchers.some((m) => m(location));
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    if (!isMatch(location)) {
+      result.errors.push(`${name} (${location}) is not matched by any workspace glob in package.json`);
+    }
+  }
+  return result;
+}
+function logResults(label, result, fix2) {
+  let errors = 0;
+  let fixed = 0;
+  for (const error of result.errors) {
+    console.log(chalk43.red(`  \u2717 ${error}`));
+    errors++;
+  }
+  for (const fixable of result.fixable) {
+    if (fix2) {
+      fixed++;
+    } else {
+      console.log(chalk43.red(`  \u2717 ${fixable} (fixable)`));
+      errors++;
+    }
+  }
+  for (const warning of result.warnings) {
+    console.log(chalk43.yellow(`  \u26A0 ${warning}`));
+  }
+  if (errors === 0 && fixed === 0 && result.warnings.length === 0) {
+    console.log(chalk43.green(`  \u2713 ${label}`));
+  }
+  return { errors, fixed };
+}
+function runChecks(entries, cwd5, pkg, fix2) {
+  let totalErrors = 0;
+  let totalFixed = 0;
+  for (const entry of entries) {
+    const result = entry.check();
+    const log = logResults(entry.label, result, fix2);
+    if (fix2 && entry.fix && result.fixable.length > 0) {
+      entry.fix(cwd5, pkg);
+    }
+    totalErrors += log.errors;
+    totalFixed += log.fixed;
+  }
+  return { errors: totalErrors, fixed: totalFixed };
+}
+function logSummary(errors, fixed) {
+  if (fixed > 0) {
+    console.log(chalk43.green(`
+  Fixed ${fixed} issue(s)`));
+  }
+  if (errors > 0) {
+    console.log(chalk43.red(`
+  ${errors} error(s) found`));
+  } else if (fixed === 0) {
+    console.log(chalk43.green("\n  All checks passed"));
+  }
+}
+function packageLintMonorepo(fix2 = false) {
+  const cwd5 = INIT_CWD() ?? process.cwd();
+  let pkg;
+  try {
+    pkg = readRootPackageJson(cwd5);
+  } catch {
+    console.error(chalk43.red("Could not read package.json"));
+    return 1;
+  }
+  if (!isMonorepo(pkg)) {
+    console.log(chalk43.gray("Not a monorepo \u2014 skipping package-lint checks"));
+    return 0;
+  }
+  console.log(chalk43.green("Package Lint"));
+  const workspaces = getPackageManager().listWorkspaces();
+  const checks = [
+    {
+      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: () => checkDiscoverable(pkg, workspaces), label: "All packages are discoverable from workspace globs" }
+  ];
+  const { errors, fixed } = runChecks(checks, cwd5, pkg, fix2);
+  logSummary(errors, fixed);
+  return errors > 0 ? 1 : 0;
+}
+
+// src/actions/packman/convert.ts
+import {
+  existsSync as existsSync13,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync13,
+  statSync as statSync3
+} from "fs";
+import PATH13 from "path";
+import chalk46 from "chalk";
+
+// src/actions/packman/convertToPnpm.ts
+import {
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync11,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync8
+} from "fs";
+import PATH11 from "path";
+import chalk44 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/convertToPnpm.ts
+var PNPM_VERSION = "10.12.1";
+function createPnpmWorkspaceYaml(cwd5, workspacePatterns) {
+  const lines = ["packages:"];
+  for (const pattern of workspacePatterns) {
+    lines.push(`  - '${pattern}'`);
+  }
+  writeFileSync8(PATH11.join(cwd5, "pnpm-workspace.yaml"), lines.join("\n") + "\n", "utf8");
+  console.log(chalk44.green("  Created pnpm-workspace.yaml"));
+}
+function updateRootPackageJson(cwd5) {
+  const pkgPath = PATH11.join(cwd5, "package.json");
+  const pkg = JSON.parse(readFileSync11(pkgPath, "utf8"));
+  const workspacePatterns = pkg.workspaces ?? [];
+  delete pkg.workspaces;
+  pkg.packageManager = `pnpm@${PNPM_VERSION}`;
+  const updated = rewriteScriptsInPackageJson(pkg, "yarn-to-pnpm");
+  writeFileSync8(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  console.log(chalk44.green("  Updated root package.json"));
+  return workspacePatterns;
+}
+function updateGitignore(cwd5) {
+  const gitignorePath = PATH11.join(cwd5, ".gitignore");
+  if (!existsSync11(gitignorePath)) return;
+  let content = readFileSync11(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");
+  writeFileSync8(gitignorePath, content, "utf8");
+  console.log(chalk44.green("  Updated .gitignore"));
+}
+function deleteYarnArtifacts(cwd5) {
+  const yarnLock = PATH11.join(cwd5, "yarn.lock");
+  const yarnrc = PATH11.join(cwd5, ".yarnrc.yml");
+  const yarnDir = PATH11.join(cwd5, ".yarn");
+  if (existsSync11(yarnLock)) {
+    rmSync3(yarnLock);
+    console.log(chalk44.gray("  Deleted yarn.lock"));
+  }
+  if (existsSync11(yarnrc)) {
+    rmSync3(yarnrc);
+    console.log(chalk44.gray("  Deleted .yarnrc.yml"));
+  }
+  if (existsSync11(yarnDir)) {
+    rmSync3(yarnDir, { force: true, recursive: true });
+    console.log(chalk44.gray("  Deleted .yarn/"));
+  }
+}
+function createNpmrc(cwd5) {
+  const npmrcPath = PATH11.join(cwd5, ".npmrc");
+  if (existsSync11(npmrcPath)) return;
+  mkdirSync5(PATH11.dirname(npmrcPath), { recursive: true });
+  writeFileSync8(npmrcPath, "", "utf8");
+  console.log(chalk44.green("  Created .npmrc"));
+}
+function convertToPnpm(cwd5, workspacePackageJsonPaths) {
+  console.log(chalk44.blue("\nConverting to pnpm...\n"));
+  const workspacePatterns = updateRootPackageJson(cwd5);
+  createPnpmWorkspaceYaml(cwd5, workspacePatterns);
+  for (const pkgPath of workspacePackageJsonPaths) {
+    const fullPath = PATH11.resolve(cwd5, pkgPath, "package.json");
+    if (!existsSync11(fullPath)) continue;
+    const pkg = JSON.parse(readFileSync11(fullPath, "utf8"));
+    const updated = rewriteScriptsInPackageJson(pkg, "yarn-to-pnpm");
+    if (JSON.stringify(pkg) !== JSON.stringify(updated)) {
+      writeFileSync8(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    }
+  }
+  console.log(chalk44.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
+  updateGitignore(cwd5);
+  createNpmrc(cwd5);
+  deleteYarnArtifacts(cwd5);
+  console.log(chalk44.blue("\nConversion complete. Run `pnpm install` to generate pnpm-lock.yaml.\n"));
+  return 0;
+}
+
+// src/actions/packman/convertToYarn.ts
+import {
+  existsSync as existsSync12,
+  readFileSync as readFileSync12,
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync9
+} from "fs";
+import PATH12 from "path";
+import chalk45 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 readPnpmWorkspacePatterns(cwd5) {
+  const wsPath = PATH12.join(cwd5, "pnpm-workspace.yaml");
+  if (!existsSync12(wsPath)) return [];
+  const content = readFileSync12(wsPath, "utf8");
+  const patterns = [];
+  const lines = content.split("\n");
+  let inPackages = false;
+  for (const line of lines) {
+    if (line.trim() === "packages:") {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages && /^\s+-\s+/.test(line)) {
+      const pattern = line.replace(/^\s+-\s+/, "").replaceAll(/['"]/g, "").trim();
+      if (pattern) patterns.push(pattern);
+    } else if (inPackages && !/^\s/.test(line) && line.trim()) {
+      inPackages = false;
+    }
+  }
+  return patterns;
+}
+function updateRootPackageJson2(cwd5, workspacePatterns) {
+  const pkgPath = PATH12.join(cwd5, "package.json");
+  const pkg = JSON.parse(readFileSync12(pkgPath, "utf8"));
+  pkg.workspaces = workspacePatterns;
+  pkg.packageManager = `yarn@${YARN_VERSION}`;
+  const updated = rewriteScriptsInPackageJson(pkg, "pnpm-to-yarn");
+  writeFileSync9(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  console.log(chalk45.green("  Updated root package.json"));
+}
+function updateGitignore2(cwd5) {
+  const gitignorePath = PATH12.join(cwd5, ".gitignore");
+  let content = existsSync12(gitignorePath) ? readFileSync12(gitignorePath, "utf8") : "";
+  if (!content.includes(".yarn/*")) {
+    content = content.trimEnd() + "\n" + YARN_GITIGNORE_ENTRIES;
+  }
+  writeFileSync9(gitignorePath, content, "utf8");
+  console.log(chalk45.green("  Updated .gitignore"));
+}
+function deletePnpmArtifacts(cwd5) {
+  const lockfile = PATH12.join(cwd5, "pnpm-lock.yaml");
+  const workspaceYaml = PATH12.join(cwd5, "pnpm-workspace.yaml");
+  const npmrc = PATH12.join(cwd5, ".npmrc");
+  if (existsSync12(lockfile)) {
+    rmSync4(lockfile);
+    console.log(chalk45.gray("  Deleted pnpm-lock.yaml"));
+  }
+  if (existsSync12(workspaceYaml)) {
+    rmSync4(workspaceYaml);
+    console.log(chalk45.gray("  Deleted pnpm-workspace.yaml"));
+  }
+  if (existsSync12(npmrc)) {
+    const content = readFileSync12(npmrc, "utf8");
+    if (content.trim() === "" || content.includes("shamefully-hoist") || content.includes("node-linker")) {
+      rmSync4(npmrc);
+      console.log(chalk45.gray("  Deleted .npmrc"));
+    }
+  }
+}
+function createYarnrc(cwd5) {
+  const yarnrcPath = PATH12.join(cwd5, ".yarnrc.yml");
+  if (existsSync12(yarnrcPath)) return;
+  writeFileSync9(yarnrcPath, YARNRC_TEMPLATE, "utf8");
+  console.log(chalk45.green("  Created .yarnrc.yml"));
+}
+function convertToYarn(cwd5, workspacePackageJsonPaths) {
+  console.log(chalk45.blue("\nConverting to yarn...\n"));
+  const workspacePatterns = readPnpmWorkspacePatterns(cwd5);
+  if (workspacePatterns.length === 0) {
+    console.warn(chalk45.yellow("  No workspace patterns found in pnpm-workspace.yaml"));
+  }
+  updateRootPackageJson2(cwd5, workspacePatterns);
+  for (const pkgPath of workspacePackageJsonPaths) {
+    const fullPath = PATH12.resolve(cwd5, pkgPath, "package.json");
+    if (!existsSync12(fullPath)) continue;
+    const pkg = JSON.parse(readFileSync12(fullPath, "utf8"));
+    const updated = rewriteScriptsInPackageJson(pkg, "pnpm-to-yarn");
+    if (JSON.stringify(pkg) !== JSON.stringify(updated)) {
+      writeFileSync9(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    }
+  }
+  console.log(chalk45.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
+  updateGitignore2(cwd5);
+  createYarnrc(cwd5);
+  deletePnpmArtifacts(cwd5);
+  console.log(chalk45.blue("\nConversion complete. Run `corepack enable yarn && yarn set version stable && yarn install` to finish setup.\n"));
+  return 0;
+}
+
+// src/actions/packman/convert.ts
+function detectCurrentPM(cwd5) {
+  if (existsSync13(PATH13.join(cwd5, "pnpm-lock.yaml")) || existsSync13(PATH13.join(cwd5, "pnpm-workspace.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync13(PATH13.join(cwd5, "yarn.lock")) || existsSync13(PATH13.join(cwd5, ".yarnrc.yml"))) {
+    return "yarn";
+  }
+  return "unknown";
+}
+function findWorkspacePackagePaths(cwd5) {
+  const pkgPath = PATH13.join(cwd5, "package.json");
+  const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
+  let patterns = pkg.workspaces ?? [];
+  if (patterns.length === 0) {
+    const wsPath = PATH13.join(cwd5, "pnpm-workspace.yaml");
+    if (existsSync13(wsPath)) {
+      const content = readFileSync13(wsPath, "utf8");
+      const 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(cwd5, pattern);
+    dirs.push(...resolved);
+  }
+  return dirs;
+}
+function resolveWorkspaceGlob(cwd5, pattern) {
+  const parts = pattern.split("/");
+  return walkGlob(cwd5, parts, "");
+}
+function walkGlob(basePath, parts, currentPath) {
+  if (parts.length === 0) {
+    const fullPath = PATH13.join(basePath, currentPath);
+    if (existsSync13(PATH13.join(fullPath, "package.json"))) {
+      return [currentPath];
+    }
+    return [];
+  }
+  const [part, ...rest] = parts;
+  const dirPath = PATH13.join(basePath, currentPath);
+  if (!existsSync13(dirPath) || !statSync3(dirPath).isDirectory()) {
+    return [];
+  }
+  if (part === "*" || part === "**") {
+    const entries = readdirSync7(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(chalk46.red(`Invalid target "${target}". Must be one of: ${validTargets.join(", ")}`));
+    return 1;
+  }
+  const cwd5 = process.cwd();
+  const currentPM = detectCurrentPM(cwd5);
+  if (verbose) {
+    console.log(chalk46.gray(`Current package manager: ${currentPM}`));
+    console.log(chalk46.gray(`Target package manager: ${target}`));
+  }
+  if (currentPM === target) {
+    console.error(chalk46.red(`Already using ${target}. No conversion needed.`));
+    return 1;
+  }
+  if (currentPM === "unknown") {
+    console.error(chalk46.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
+    return 1;
+  }
+  const workspacePaths = findWorkspacePackagePaths(cwd5);
+  if (verbose) {
+    console.log(chalk46.gray(`Found ${workspacePaths.length} workspace packages`));
+  }
+  if (target === "pnpm") {
+    return convertToPnpm(cwd5, workspacePaths);
+  }
+  return convertToYarn(cwd5, workspacePaths);
+}
+
+// src/actions/publint.ts
+var publint = async ({ verbose, pkg }) => {
+  return pkg === void 0 ? publintAll({ verbose }) : await publintPackage({ pkg, verbose });
+};
+var publintPackage = ({ pkg }) => {
+  const pm = getPackageManager();
+  return runStepsAsync(`Publint [${pkg}]`, [pm.runInWorkspace(pkg, "package-publint")]);
+};
+var publintAll = ({ verbose }) => {
+  const pm = getPackageManager();
+  return runSteps("Publint", [pm.foreachWorkspace("package-publint", [], { verbose })]);
+};
+
+// src/actions/readme-gen.ts
+async function readmeGen({
+  pkg,
+  templatePath,
+  typedoc,
+  verbose
+}) {
+  const config2 = await loadConfig();
+  return await generateReadmeFiles({
+    logoLinkUrl: config2.readme?.logoLinkUrl,
+    logoUrl: config2.readme?.logoUrl,
+    pkg,
+    templatePath,
+    typedoc,
+    verbose
+  });
+}
+
+// src/actions/readme-init.ts
+async function readmeInit({ templatePath }) {
+  const config2 = await loadConfig();
+  const template = applyLogoConfig(DEFAULT_README_TEMPLATE, config2.readme?.logoUrl, config2.readme?.logoLinkUrl);
+  const resolvedTemplatePath = resolveTemplatePath(templatePath);
+  await scaffoldTemplate(resolvedTemplatePath, template);
+  return 0;
+}
+
+// src/actions/rebuild.ts
+var rebuild = ({ target }) => {
+  const pm = getPackageManager();
+  return runSteps("Rebuild", [
+    pm.runXy(["clean"]),
+    pm.runXy(target ? ["build", "-t", target] : ["build"])
+  ]);
+};
+
+// src/actions/recompile.ts
+import chalk47 from "chalk";
+var recompile = async ({
+  verbose,
+  target,
+  pkg,
+  incremental
+}) => {
+  return pkg ? await recompilePackage({
+    pkg,
+    target,
+    verbose
+  }) : await recompileAll({
+    incremental,
+    target,
+    verbose
+  });
+};
+var recompilePackage = ({ target, pkg }) => {
+  const pm = getPackageManager();
+  const targetOptions = target ? ["-t", target] : [];
+  return runStepsAsync(
+    `Recompile [${pkg}]`,
+    [pm.runInWorkspace(pkg, "package-recompile", targetOptions)]
+  );
+};
+var recompileAll = async ({
+  jobs,
+  verbose,
+  target,
+  incremental
+}) => {
+  const pm = getPackageManager();
+  const start = Date.now();
+  const targetOptions = target ? ["-t", target] : [];
+  if (jobs) {
+    console.log(chalk47.blue(`Jobs set to [${jobs}]`));
+  }
+  const foreachOptions = {
+    incremental,
+    jobs,
+    topological: true,
+    verbose
+  };
+  const result = await runStepsAsync(`Recompile${incremental ? "-Incremental" : ""} [All]`, [
+    pm.foreachWorkspace("package-clean", targetOptions, foreachOptions),
+    pm.foreachWorkspace("package-compile", targetOptions, foreachOptions)
+  ]);
+  console.log(
+    `${chalk47.gray("Recompiled in")} [${chalk47.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk47.gray("seconds")}`
+  );
+  return result;
+};
+
+// src/actions/relint.ts
+import chalk48 from "chalk";
+var relintPackage = ({
+  pkg,
+  fix: fix2,
+  verbose
+}) => {
+  console.log(chalk48.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
+  const start = Date.now();
+  const pm = getPackageManager();
+  const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
+    pm.runInWorkspace(pkg, fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint")
+  ]);
+  console.log(chalk48.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk48.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk48.gray("seconds")}`));
+  return result;
+};
+var relint = ({
+  pkg,
+  verbose,
+  incremental,
+  fix: fix2
+} = {}) => {
+  return pkg === void 0 ? relintAllPackages({
+    verbose,
+    incremental,
+    fix: fix2
+  }) : relintPackage({
+    pkg,
+    fix: fix2,
+    verbose
+  });
+};
+var relintAllPackages = ({ fix: fix2 = false } = {}) => {
+  console.log(chalk48.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
+  const start = Date.now();
+  const fixOptions = fix2 ? ["--fix"] : [];
+  const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
+    ["eslint", fixOptions]
+  ]);
+  console.log(chalk48.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk48.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk48.gray("seconds")}`));
+  return result;
+};
+
+// src/actions/retest.ts
+var retest = ({ target } = {}) => {
+  const pm = getPackageManager();
+  if (target && pm.findWorkspace(target)) {
+    return runSteps(`Re-Test [${target}]`, [
+      pm.runInWorkspace(target, "vitest", ["--clearCache"]),
+      pm.runInWorkspace(target, "vitest", ["."])
+    ]);
+  }
+  const path15 = target ?? ".";
+  return runSteps("Re-Test", [
+    ["vitest", ["--clearCache"]],
+    ["vitest", [path15]]
+  ]);
+};
+
+// src/actions/sonar.ts
+var sonar = () => {
+  return runSteps("Sonar", [["eslint", ["-c", "sonar.eslintrc", "."]]]);
+};
+
+// src/actions/statics.ts
+import chalk49 from "chalk";
+var DefaultDependencies = ["axios", "@xylabs/pixel", "react", "graphql", "react-router", "@mui/material", "@mui/system"];
+var statics = () => {
+  console.log(chalk49.green("Check Required Static Dependencies"));
+  const statics2 = parsedPackageJSON()?.xy?.deps?.statics;
+  return detectDuplicateDependencies(statics2, DefaultDependencies);
+};
+
+// src/actions/test.ts
+var test = ({ target } = {}) => {
+  const pm = getPackageManager();
+  if (target && pm.findWorkspace(target)) {
+    return runSteps(`Test [${target}]`, [pm.runInWorkspace(target, "vitest", ["."])]);
+  }
+  const path15 = target ?? ".";
+  return runSteps("Test", [["vitest", [path15]]]);
+};
+export {
+  build,
+  claudeClean,
+  claudeCommands,
+  claudeRules,
+  claudeSettings,
+  claudeSkills,
+  clean,
+  cleanAll,
+  cleanDocs,
+  cleanESLint,
+  cleanPackage,
+  compile,
+  compileAll,
+  compilePackage,
+  convert,
+  copyAssets,
+  cycle,
+  cycleAll,
+  cyclePackage,
+  dead,
+  deplint,
+  dupdeps,
+  fix,
+  genDocs,
+  genDocsAll,
+  genDocsPackage,
+  gitignore,
+  gitignoreGen,
+  gitlint,
+  gitlintFix,
+  knip,
+  license,
+  lint,
+  lintAllPackages,
+  lintPackage,
+  lintlint,
+  npmignoreGen,
+  packageClean,
+  packageCleanOutputs,
+  packageCleanTypescript,
+  packageCompile,
+  packageCompileTsc,
+  packageCompileTsup,
+  packageCopyAssets,
+  packageCycle,
+  packageGenDocs,
+  packageLint,
+  packageLintMonorepo,
+  packagePublint,
+  packageRecompile,
+  publint,
+  publintAll,
+  publintPackage,
+  readmeGen,
+  readmeInit,
+  rebuild,
+  recompile,
+  recompileAll,
+  recompilePackage,
+  relint,
+  relintAllPackages,
+  relintPackage,
+  retest,
+  rewriteScript,
+  rewriteScriptsInPackageJson,
+  sonar,
+  statics,
+  test,
+  tsupOptions
+};
+//# sourceMappingURL=index.mjs.map