@xylabs/toolchain 7.10.0

package/dist/xy/common/index.mjs

@@ -0,0 +1,4654 @@
+// src/xy/common/checkCommand.ts
+import chalk35 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");
+function applyPackageManager(content, pm) {
+  return content.replaceAll("yarn xy", `${pm} xy`).replaceAll("yarn add", `${pm} add`);
+}
+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/concurrency.ts
+import { AsyncLocalStorage } from "async_hooks";
+var outputStorage = new AsyncLocalStorage();
+var captureInstalled = false;
+function installOutputCapture() {
+  if (captureInstalled) return;
+  captureInstalled = true;
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  function intercept(original) {
+    return function(chunk, ...args) {
+      const buffer = outputStorage.getStore();
+      if (buffer) {
+        buffer.push(typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk));
+        return true;
+      }
+      return original(chunk, ...args);
+    };
+  }
+  process.stdout.write = intercept(originalStdoutWrite);
+  process.stderr.write = intercept(originalStderrWrite);
+}
+async function runWithConcurrency(items, concurrency, fn) {
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const i = next++;
+      await fn(items[i]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+}
+
+// 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/pm/detectPackageManager.ts
+import { existsSync } from "fs";
+function detectPackageManager() {
+  if (existsSync("pnpm-lock.yaml") || existsSync("pnpm-workspace.yaml")) return "pnpm";
+  return "yarn";
+}
+
+// src/pm/registry.ts
+var implementations = /* @__PURE__ */ new Map();
+function getPackageManager(name) {
+  const pmName = name ?? detectPackageManager();
+  const pm = implementations.get(pmName);
+  if (!pm) {
+    throw new Error(
+      `No package manager implementation registered for "${pmName}". Ensure registerPackageManager() has been called before getPackageManager().`
+    );
+  }
+  return pm;
+}
+
+// src/lib/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);
+  }
+};
+
+// 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/fillTemplate.ts
+function fillTemplate(template, data) {
+  return template.replaceAll(/\{\{(.*?)\}\}/g, (_, key) => data[key.trim()] ?? "");
+}
+
+// src/lib/generateIgnoreFiles.ts
+import chalk3 from "chalk";
+
+// src/lib/initCwd.ts
+function INIT_CWD() {
+  return process.env.INIT_CWD ?? process.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(chalk3.green(`Generate ${filename2} Files`));
+  const cwd = 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(cwd), 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 { execFile } 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 { promisify } from "util";
+import chalk4 from "chalk";
+var execFileAsync = promisify(execFile);
+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 fillReadmeTemplate(template, data) {
+  const additionalData = { ...data, safeName: data.name.replaceAll("/", "__").replaceAll("@", "") };
+  return fillTemplate(template, additionalData);
+}
+async 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 {
+      await execFileAsync("npx", ["typedoc", "--options", typedocJsonPath], { cwd: process.cwd() });
+    } 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 cwd = INIT_CWD();
+  return templatePath ?? PATH2.join(cwd, ".xy", "README.template.md");
+}
+async function loadOrCreateTemplate(resolvedTemplatePath) {
+  try {
+    const template = await readFile(resolvedTemplatePath, "utf8");
+    return { created: false, template };
+  } catch {
+    console.log(chalk4.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(chalk4.green(`Created template: ${resolvedTemplatePath}`));
+  const bodyPath = PATH2.join(xyDir, "README.body.md");
+  await writeFile(bodyPath, DEFAULT_README_BODY);
+  console.log(chalk4.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, pm) {
+  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 ? await generateTypedoc(location, ["src/index*.ts"]) : "";
+    const readmeContent = fillReadmeTemplate(template, {
+      ...pkgJson,
+      body,
+      pm,
+      typedoc: typedocContent
+    });
+    await writeFile(PATH2.join(location, "README.md"), readmeContent);
+    if (verbose) console.log(chalk4.green(`  ${name}`));
+    return true;
+  } catch (ex) {
+    const error = ex;
+    console.warn(chalk4.yellow(`  Skipped ${location}: ${error.message}`));
+    return false;
+  }
+}
+async function loadDefaultBody(resolvedTemplatePath) {
+  const xyBodyPath = PATH2.join(PATH2.dirname(resolvedTemplatePath), "README.body.md");
+  try {
+    return await readFile(xyBodyPath, "utf8");
+  } catch {
+    return DEFAULT_README_BODY;
+  }
+}
+function flushResults(results) {
+  let failed = false;
+  for (const { output, success } of results) {
+    for (const line of output) {
+      process.stdout.write(line);
+    }
+    if (!success) failed = true;
+  }
+  return failed;
+}
+async function generateReadmeFiles({
+  jobs,
+  logoLinkUrl,
+  logoUrl,
+  pkg,
+  templatePath,
+  typedoc = false,
+  verbose = false
+}) {
+  console.log(chalk4.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(chalk4.green("Generating README files for all packages..."));
+  }
+  const defaultBody = await loadDefaultBody(resolvedTemplatePath);
+  const pmName = detectPackageManager();
+  const pm = getPackageManager();
+  const singleWorkspace = pkg && !templateCreated ? pm.findWorkspace(pkg) : void 0;
+  const workspaces = singleWorkspace ? [singleWorkspace] : pm.listWorkspaces();
+  const concurrency = jobs;
+  const results = Array.from({ length: workspaces.length }, () => ({ output: [], success: true }));
+  installOutputCapture();
+  const start = performance.now();
+  await runWithConcurrency(
+    workspaces.map((ws, i) => ({ i, ws })),
+    concurrency,
+    async ({ i, ws }) => {
+      const output = [];
+      await outputStorage.run(output, async () => {
+        const success = await generateReadmeForWorkspace(ws.location, ws.name, template, defaultBody, typedoc, verbose, pmName);
+        results[i] = { output, success };
+      });
+    }
+  );
+  const failed = flushResults(results);
+  const ms = performance.now() - start;
+  console.log(chalk4.blue(`Generated ${workspaces.length} README(s) in ${ms.toFixed(0)}ms`));
+  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/latestVersions.ts
+var latestVersions = {
+  node: "24.14.1",
+  nodeLtsCodename: "Krypton",
+  npm: "11.11.0",
+  pnpm: "10.33.0",
+  yarn: "4.13.0"
+};
+
+// src/lib/loadConfig.ts
+import chalk5 from "chalk";
+import { cosmiconfig } from "cosmiconfig";
+import { TypeScriptLoader } from "cosmiconfig-typescript-loader";
+import deepmerge from "deepmerge";
+var config;
+var rootConfigPath;
+var workspaceConfigCache = /* @__PURE__ */ new Map();
+var deprecationWarned = /* @__PURE__ */ new Set();
+function createExplorer() {
+  return cosmiconfig("xy", { cache: true, loaders: { ".ts": TypeScriptLoader() } });
+}
+var loadConfig = async (params) => {
+  if (config === void 0) {
+    const cosmicConfigResult = await createExplorer().search();
+    config = cosmicConfigResult?.config ?? {};
+    rootConfigPath = cosmicConfigResult?.filepath;
+    const configFilePath = cosmicConfigResult?.filepath;
+    if (configFilePath !== void 0) {
+      console.log(chalk5.green(`Loaded config from ${configFilePath}`));
+      if (config.verbose) {
+        console.log(chalk5.gray(`${JSON.stringify(config, null, 2)}`));
+      }
+    }
+  }
+  return deepmerge(config, params ?? {});
+};
+async function loadWorkspaceConfig(workspaceDir) {
+  const cached = workspaceConfigCache.get(workspaceDir);
+  if (cached !== void 0) return cached;
+  const result = await createExplorer().search(workspaceDir);
+  if (!result || result.filepath === rootConfigPath) {
+    workspaceConfigCache.set(workspaceDir, {});
+    return {};
+  }
+  const wsConfig = result.config ?? {};
+  workspaceConfigCache.set(workspaceDir, wsConfig);
+  return wsConfig;
+}
+var DEPRECATED_COMMAND_FIELDS = /* @__PURE__ */ new Set(["deplint", "publint"]);
+function resolveCommandField(cfg, commandName, configPath) {
+  const commands = cfg.commands;
+  const fromCommands = commands?.[commandName];
+  const fromTopLevel = cfg[commandName];
+  if (fromCommands !== void 0 && typeof fromCommands === "object") {
+    return fromCommands;
+  }
+  if (fromTopLevel !== void 0 && typeof fromTopLevel === "object" && DEPRECATED_COMMAND_FIELDS.has(commandName)) {
+    const key = `${configPath ?? "unknown"}:${commandName}`;
+    if (!deprecationWarned.has(key)) {
+      deprecationWarned.add(key);
+      console.warn(chalk5.yellow(
+        `[xy] Deprecated: top-level "${commandName}" in ${configPath ?? "xy.config"} \u2014 move to "commands.${commandName}"`
+      ));
+    }
+    return fromTopLevel;
+  }
+  return {};
+}
+async function loadWorkspaceCommandConfig(workspaceDir, commandName) {
+  const root = await loadConfig();
+  const rootCmd = resolveCommandField(root, commandName, rootConfigPath);
+  const wsConfig = await loadWorkspaceConfig(workspaceDir);
+  const wsConfigPath = workspaceConfigCache.has(workspaceDir) ? workspaceDir : void 0;
+  const wsCmd = resolveCommandField(wsConfig, commandName, wsConfigPath);
+  return deepmerge(rootCmd, wsCmd);
+}
+
+// src/lib/packageName.ts
+import { readFileSync as readFileSync5 } from "fs";
+import path from "path";
+function packageName() {
+  if (process.env.npm_package_name) {
+    return process.env.npm_package_name;
+  }
+  try {
+    const pkgPath = path.join(INIT_CWD(), "package.json");
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
+    return pkg.name;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/lib/repoTemplates.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { createRequire as createRequire4 } from "module";
+import PATH4 from "path";
+var require5 = createRequire4(import.meta.url);
+var packageRoot4 = PATH4.dirname(require5.resolve("@xylabs/ts-scripts-common/package.json"));
+var repoTemplatesDir = PATH4.resolve(packageRoot4, "templates", "repo");
+function collectFiles(dir, prefix) {
+  const results = [];
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(...collectFiles(PATH4.resolve(dir, entry.name), rel));
+    } else {
+      results.push({
+        content: readFileSync6(PATH4.resolve(dir, entry.name), "utf8"),
+        relativePath: rel
+      });
+    }
+  }
+  return results;
+}
+function loadRepoTemplateFiles(template, section) {
+  const dir = PATH4.resolve(repoTemplatesDir, template, section);
+  return collectFiles(dir, "");
+}
+
+// src/lib/runInstall.ts
+import { spawnSync } from "child_process";
+import chalk6 from "chalk";
+function runInstall(cwd) {
+  const pm = detectPackageManager();
+  console.log(chalk6.gray(`Running ${pm} install...`));
+  const result = spawnSync(pm, ["install"], {
+    cwd,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    console.warn(chalk6.yellow(`${pm} install failed`));
+    return false;
+  }
+  console.log(chalk6.green("Dependencies installed"));
+  return true;
+}
+
+// src/lib/runSteps.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import chalk7 from "chalk";
+var runSteps = (name, steps, exitOnFail = true, messages) => {
+  return safeExit(() => {
+    const pkgName = packageName();
+    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 = spawnSync2(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/actions/claude-check.ts
+import {
+  existsSync as existsSync4,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync7,
+  statSync as statSync2
+} from "fs";
+import PATH5 from "path";
+import chalk8 from "chalk";
+var checkCommands = (commandsDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeCommandTemplates();
+  const templates = {};
+  for (const [name, content] of Object.entries(rawTemplates)) {
+    templates[name] = applyPackageManager(content, pm);
+  }
+  const missing = [];
+  const outdated = [];
+  for (const [filename2, content] of Object.entries(templates)) {
+    const targetPath = PATH5.resolve(commandsDir, filename2);
+    if (!existsSync4(targetPath)) {
+      missing.push(filename2);
+    } else if (readFileSync7(targetPath, "utf8") !== content) {
+      outdated.push(filename2);
+    }
+  }
+  const templateNames = new Set(Object.keys(templates));
+  const stale = existsSync4(commandsDir) ? readdirSync3(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md") && !templateNames.has(f)) : [];
+  return {
+    missing,
+    outdated,
+    stale
+  };
+};
+var checkRules = (rulesDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeMdRuleTemplates();
+  const templates = {};
+  for (const [name, content] of Object.entries(rawTemplates)) {
+    templates[name] = applyPackageManager(content, pm);
+  }
+  const missing = [];
+  const outdated = [];
+  for (const [filename2, content] of Object.entries(templates)) {
+    const targetPath = PATH5.resolve(rulesDir, filename2);
+    if (!existsSync4(targetPath)) {
+      missing.push(filename2);
+    } else if (readFileSync7(targetPath, "utf8") !== content) {
+      outdated.push(filename2);
+    }
+  }
+  const templateNames = new Set(Object.keys(templates));
+  const stale = existsSync4(rulesDir) ? readdirSync3(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md") && !templateNames.has(f)) : [];
+  return {
+    missing,
+    outdated,
+    stale
+  };
+};
+var checkSkills = (skillsDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeSkillTemplates();
+  const missing = [];
+  const outdated = [];
+  for (const [skillName, files] of Object.entries(rawTemplates)) {
+    const skillDir = PATH5.resolve(skillsDir, skillName);
+    if (!existsSync4(skillDir)) {
+      missing.push(skillName);
+      continue;
+    }
+    for (const [filename2, rawContent] of Object.entries(files)) {
+      const content = applyPackageManager(rawContent, pm);
+      const targetPath = PATH5.resolve(skillDir, filename2);
+      if (!existsSync4(targetPath)) {
+        missing.push(`${skillName}/${filename2}`);
+      } else if (readFileSync7(targetPath, "utf8") !== content) {
+        outdated.push(`${skillName}/${filename2}`);
+      }
+    }
+  }
+  const templateNames = new Set(Object.keys(rawTemplates));
+  const stale = existsSync4(skillsDir) ? readdirSync3(skillsDir).filter(
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync2(PATH5.resolve(skillsDir, f)).isDirectory() && !templateNames.has(f)
+  ) : [];
+  return {
+    missing,
+    outdated,
+    stale
+  };
+};
+var logSection = (label, result) => {
+  const issues = [...result.missing, ...result.outdated, ...result.stale];
+  if (issues.length === 0) {
+    console.log(chalk8.green(`  \u2714 ${label}`));
+    return true;
+  }
+  console.log(chalk8.red(`  \u2718 ${label}`));
+  for (const file of result.missing) {
+    console.log(chalk8.yellow(`      missing: ${file}`));
+  }
+  for (const file of result.outdated) {
+    console.log(chalk8.yellow(`      outdated: ${file}`));
+  }
+  for (const file of result.stale) {
+    console.log(chalk8.yellow(`      stale: ${file}`));
+  }
+  return false;
+};
+function claudeCheck() {
+  const cwd = INIT_CWD();
+  const claudeDir = PATH5.resolve(cwd, ".claude");
+  console.log(chalk8.bold("Claude configuration check:"));
+  console.log();
+  const commandsResult = checkCommands(PATH5.resolve(claudeDir, "commands"));
+  const rulesResult = checkRules(PATH5.resolve(claudeDir, "rules"));
+  const skillsResult = checkSkills(PATH5.resolve(claudeDir, "skills"));
+  const commandsOk = logSection("commands", commandsResult);
+  const rulesOk = logSection("rules", rulesResult);
+  const skillsOk = logSection("skills", skillsResult);
+  console.log();
+  if (commandsOk && rulesOk && skillsOk) {
+    console.log(chalk8.green("All Claude configuration is up to date."));
+  } else {
+    console.log(chalk8.yellow("Run `xy claude init` to sync all configuration."));
+  }
+  return 0;
+}
+
+// src/actions/claude-clean.ts
+import {
+  existsSync as existsSync5,
+  readdirSync as readdirSync4,
+  rmSync,
+  unlinkSync
+} from "fs";
+import PATH6 from "path";
+import chalk9 from "chalk";
+function removeFile(filePath, label) {
+  if (existsSync5(filePath)) {
+    unlinkSync(filePath);
+    console.log(chalk9.yellow(`  Removed ${label}`));
+    return true;
+  }
+  return false;
+}
+function removeDir(dirPath, label) {
+  if (existsSync5(dirPath)) {
+    rmSync(dirPath, { recursive: true });
+    console.log(chalk9.yellow(`  Removed ${label}`));
+    return true;
+  }
+  return false;
+}
+function claudeClean() {
+  console.log(chalk9.green("Clean Claude configuration"));
+  const cwd = INIT_CWD();
+  let removed = 0;
+  const rootFiles = ["CLAUDE.md", "CLAUDE.local.md"];
+  for (const file of rootFiles) {
+    if (removeFile(PATH6.resolve(cwd, file), file)) removed++;
+  }
+  if (removeDir(PATH6.resolve(cwd, ".claude"), ".claude/")) removed++;
+  const packagesDir = PATH6.resolve(cwd, "packages");
+  if (existsSync5(packagesDir)) {
+    const findClaudeFiles = (dir, prefix) => {
+      const entries = readdirSync4(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = PATH6.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(chalk9.green(`  Removed ${removed} item(s)`));
+  } else {
+    console.log(chalk9.gray("  Nothing to clean"));
+  }
+  return 0;
+}
+
+// src/actions/claude-commands.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync8,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import PATH7 from "path";
+import chalk10 from "chalk";
+var syncCommandFiles = (commandsDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeCommandTemplates();
+  const templates = {};
+  for (const [name, content] of Object.entries(rawTemplates)) {
+    templates[name] = applyPackageManager(content, pm);
+  }
+  const templateNames = new Set(Object.keys(templates));
+  let updated = 0;
+  let created = 0;
+  for (const [filename2, content] of Object.entries(templates)) {
+    const targetPath = PATH7.resolve(commandsDir, filename2);
+    const existing = existsSync6(targetPath) ? readFileSync8(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 = readdirSync5(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md"));
+  let removed = 0;
+  for (const file of existingCommands) {
+    if (!templateNames.has(file)) {
+      unlinkSync2(PATH7.resolve(commandsDir, file));
+      removed++;
+    }
+  }
+  return removed;
+};
+var removeLegacyCommands = (commandsDir) => {
+  const legacyFiles = readdirSync5(commandsDir).filter((f) => f.startsWith(LEGACY_COMMANDS_PREFIX) && f.endsWith(".md"));
+  for (const file of legacyFiles) {
+    unlinkSync2(PATH7.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(chalk10.green(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: ${parts.join(", ")}`));
+  } else {
+    console.log(chalk10.gray(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: already up to date`));
+  }
+};
+var claudeCommands = () => {
+  const cwd = INIT_CWD();
+  const commandsDir = PATH7.resolve(cwd, ".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 spawnSync3 } from "child_process";
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync9,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import PATH8 from "path";
+import chalk11 from "chalk";
+var syncRuleFiles = (rulesDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeMdRuleTemplates();
+  const templates = {};
+  for (const [name, content] of Object.entries(rawTemplates)) {
+    templates[name] = applyPackageManager(content, pm);
+  }
+  const templateNames = new Set(Object.keys(templates));
+  let updated = 0;
+  let created = 0;
+  for (const [filename2, content] of Object.entries(templates)) {
+    const targetPath = PATH8.resolve(rulesDir, filename2);
+    const existing = existsSync7(targetPath) ? readFileSync9(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 = readdirSync6(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md"));
+  let removed = 0;
+  for (const file of existingRules) {
+    if (!templateNames.has(file)) {
+      unlinkSync3(PATH8.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(chalk11.green(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: ${parts.join(", ")}`));
+  } else {
+    console.log(chalk11.gray(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: already up to date`));
+  }
+};
+var ensureProjectClaudeMd = (cwd, force) => {
+  const projectPath = PATH8.resolve(cwd, "CLAUDE.md");
+  if (!existsSync7(projectPath) || force) {
+    if (force && existsSync7(projectPath)) {
+      console.log(chalk11.yellow("Regenerating CLAUDE.md"));
+    }
+    console.log(chalk11.green("Generating CLAUDE.md via claude /init..."));
+    const result = spawnSync3("claude", ["-p", "/init", "--allowedTools", "Read", "Write", "Glob", "Grep"], {
+      cwd,
+      shell: true,
+      stdio: "inherit"
+    });
+    if (result.status !== 0) {
+      console.error(chalk11.red("claude /init failed \u2014 is Claude Code installed?"));
+      return 1;
+    }
+  } else {
+    console.log(chalk11.gray("CLAUDE.md already exists (skipped, use --force to regenerate)"));
+  }
+  return 0;
+};
+var ensureLocalClaudeMd = (cwd) => {
+  const localPath = PATH8.resolve(cwd, "CLAUDE.local.md");
+  if (existsSync7(localPath)) {
+    console.log(chalk11.gray("CLAUDE.local.md already exists (skipped)"));
+  } else {
+    writeFileSync3(localPath, claudeMdLocalTemplate(), "utf8");
+    console.log(chalk11.green("Generated CLAUDE.local.md"));
+  }
+};
+var claudeRules = ({ force } = {}) => {
+  const cwd = INIT_CWD();
+  const rulesDir = PATH8.resolve(cwd, ".claude", "rules");
+  mkdirSync2(rulesDir, { recursive: true });
+  const {
+    created,
+    templateNames,
+    updated
+  } = syncRuleFiles(rulesDir);
+  const removed = removeStaleRules(rulesDir, templateNames);
+  logRulesResult(created, updated, removed);
+  const claudeMdResult = ensureProjectClaudeMd(cwd, force);
+  ensureLocalClaudeMd(cwd);
+  return claudeMdResult ?? 0;
+};
+
+// src/actions/claude-settings.ts
+import {
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync4
+} from "fs";
+import PATH9 from "path";
+import { createInterface as createInterface2 } from "readline";
+import chalk12 from "chalk";
+var DENY_LIST = [
+  "Bash(git push --force *)",
+  "Bash(git reset --hard *)",
+  "Bash(rm -rf /*)"
+];
+var RESTRICTIVE_ALLOW = [
+  "Bash(git *)",
+  "Bash(yarn *)",
+  "Bash(pnpm *)",
+  "Bash(npx *)",
+  "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(wc *)",
+  "Bash(npm view *)",
+  "Bash(gh *)",
+  "Read",
+  "Edit",
+  "Write",
+  "Glob",
+  "Grep",
+  "Skill"
+];
+var PERMISSIVE_ALLOW = [
+  ...RESTRICTIVE_ALLOW,
+  "Bash(node *)",
+  "Bash(python3 *)",
+  "Bash(claude *)",
+  "Bash(sed *)",
+  "Bash(xargs *)",
+  "Bash(tee *)"
+];
+function buildSettings(level) {
+  return {
+    permissions: {
+      allow: level === "restrictive" ? RESTRICTIVE_ALLOW : PERMISSIVE_ALLOW,
+      deny: DENY_LIST
+    }
+  };
+}
+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({ level = "permissive" } = {}) {
+  const cwd = INIT_CWD();
+  const claudeDir = PATH9.resolve(cwd, ".claude");
+  const settingsPath = PATH9.resolve(claudeDir, "settings.local.json");
+  mkdirSync3(claudeDir, { recursive: true });
+  if (existsSync8(settingsPath)) {
+    const confirmed = await askConfirmation2(
+      chalk12.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
+    );
+    if (!confirmed) {
+      console.log(chalk12.gray("Skipped \u2014 existing settings.local.json preserved"));
+      return 0;
+    }
+  }
+  const settings = buildSettings(level);
+  writeFileSync4(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+  console.log(chalk12.green(`Generated .claude/settings.local.json (${level})`));
+  return 0;
+}
+
+// src/actions/claude-skills.ts
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync10,
+  rmSync as rmSync2,
+  statSync as statSync3,
+  writeFileSync as writeFileSync5
+} from "fs";
+import PATH10 from "path";
+import chalk13 from "chalk";
+var syncSkillFiles = (skillsDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeSkillTemplates();
+  const templateNames = new Set(Object.keys(rawTemplates));
+  let updated = 0;
+  let created = 0;
+  for (const [skillName, files] of Object.entries(rawTemplates)) {
+    const skillDir = PATH10.resolve(skillsDir, skillName);
+    mkdirSync4(skillDir, { recursive: true });
+    for (const [filename2, rawContent] of Object.entries(files)) {
+      const content = applyPackageManager(rawContent, pm);
+      const targetPath = PATH10.resolve(skillDir, filename2);
+      mkdirSync4(PATH10.dirname(targetPath), { recursive: true });
+      const existing = existsSync9(targetPath) ? readFileSync10(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 = readdirSync7(skillsDir).filter(
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync3(PATH10.resolve(skillsDir, f)).isDirectory()
+  );
+  let removed = 0;
+  for (const dir of existingSkills) {
+    if (!templateNames.has(dir)) {
+      rmSync2(PATH10.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(chalk13.green(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: ${parts.join(", ")}`));
+  } else {
+    console.log(chalk13.gray(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: already up to date`));
+  }
+};
+var claudeSkills = () => {
+  const cwd = INIT_CWD();
+  const skillsDir = PATH10.resolve(cwd, ".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-docs.ts
+import path2 from "path";
+import chalk14 from "chalk";
+var cleanDocs = () => {
+  const pkgName = packageName();
+  console.log(chalk14.green(`Cleaning Docs [${pkgName}]`));
+  for (const { location } of getPackageManager().listWorkspaces()) deleteGlob(path2.join(location, "docs"));
+  return 0;
+};
+
+// src/actions/dead.ts
+var dead = () => {
+  return runSteps("Dead", [["ts-prune", ["-p", "tsconfig.json"]]]);
+};
+
+// src/actions/package-lint-deps.ts
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
+import PATH11 from "path";
+import chalk15 from "chalk";
+import semver from "semver";
+function readWorkspacePackageJson(cwd, location) {
+  const pkgPath = PATH11.resolve(cwd, location, "package.json");
+  try {
+    return JSON.parse(readFileSync11(pkgPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function writeWorkspacePackageJson(cwd, location, pkg) {
+  const pkgPath = PATH11.resolve(cwd, location, "package.json");
+  writeFileSync6(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function buildWorkspaceVersionMap(cwd, workspaces) {
+  const map = /* @__PURE__ */ new Map();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const version = pkg.version;
+    if (version) map.set(name, version);
+  }
+  return map;
+}
+function expectedPeerRange(devDepVersion, targetVersion) {
+  const parsed = semver.parse(targetVersion);
+  if (!parsed) return `~${targetVersion}`;
+  if (devDepVersion === "workspace:^") {
+    return `^${parsed.major}`;
+  }
+  return `~${parsed.major}.${parsed.minor}`;
+}
+function checkVersionConsistency(cwd, rootPkg, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  if (rootPkg.version !== void 0) {
+    result.fixable.push('Root package.json should not have a "version" field in a monorepo');
+  }
+  const versions = /* @__PURE__ */ new Map();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const version = pkg.version;
+    if (version) {
+      versions.set(name, version);
+    } else {
+      result.errors.push(`${name} (${location}) is missing a "version" field`);
+    }
+  }
+  const uniqueVersions = new Set(versions.values());
+  if (uniqueVersions.size > 1) {
+    const versionList = [...uniqueVersions].toSorted(semver.rcompare);
+    for (const [name, version] of versions) {
+      if (version !== versionList[0]) {
+        result.fixable.push(`${name} has version ${version} (expected ${versionList[0]})`);
+      }
+    }
+  }
+  return result;
+}
+function fixVersionConsistency(cwd, rootPkg, writeRootPackageJson2, workspaces) {
+  if (rootPkg.version !== void 0) {
+    delete rootPkg.version;
+    writeRootPackageJson2(cwd, rootPkg);
+    console.log(chalk15.green('  \u2714 Fixed: removed "version" from root package.json'));
+  }
+  const versions = [];
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const version = pkg.version;
+    if (version && semver.valid(version)) {
+      versions.push(version);
+    }
+  }
+  if (versions.length === 0) return;
+  const highest = versions.toSorted(semver.rcompare)[0];
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    if (pkg.version !== highest) {
+      pkg.version = highest;
+      writeWorkspacePackageJson(cwd, location, pkg);
+      console.log(chalk15.green(`  \u2714 Fixed: set version to ${highest} in ${name} (${location})`));
+    }
+  }
+}
+function expectedDepVersion(targetVersion) {
+  const parsed = semver.parse(targetVersion);
+  if (!parsed) return `~${targetVersion}`;
+  return `~${targetVersion}`;
+}
+function checkInternalDepVersions(cwd, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        const targetVersion = workspaceVersions.get(dep);
+        if (!targetVersion) continue;
+        const expected = expectedDepVersion(targetVersion);
+        if (version.startsWith("workspace:")) {
+          result.fixable.push(
+            `${name} (${location}) ${depField}.${dep} is "${version}" \u2014 should be "${expected}" (not workspace: protocol)`
+          );
+        } else if (version !== expected) {
+          result.fixable.push(
+            `${name} (${location}) ${depField}.${dep} is "${version}" \u2014 should be "${expected}"`
+          );
+        }
+      }
+    }
+  }
+  return result;
+}
+function fixInternalDepVersions(cwd, workspaces) {
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    let modified = false;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        const targetVersion = workspaceVersions.get(dep);
+        if (!targetVersion) continue;
+        const expected = expectedDepVersion(targetVersion);
+        if (version !== expected) {
+          deps[dep] = expected;
+          console.log(chalk15.green(`  \u2714 Fixed: set ${depField}.${dep} to "${expected}" in ${name} (${location})`));
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      writeWorkspacePackageJson(cwd, location, pkg);
+    }
+  }
+}
+function checkWorkspaceProtocol(cwd, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  const workspaceNames = new Set(workspaces.map((w) => w.name));
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        if (!workspaceNames.has(dep)) continue;
+        if (!version.startsWith("workspace:")) {
+          result.fixable.push(
+            `${name} (${location}) ${depField}.${dep} is "${version}" \u2014 should use workspace: protocol`
+          );
+        }
+      }
+    }
+  }
+  return result;
+}
+function fixWorkspaceProtocol(cwd, workspaces) {
+  const workspaceNames = new Set(workspaces.map((w) => w.name));
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    let modified = false;
+    for (const depField of ["dependencies", "devDependencies"]) {
+      const deps = pkg[depField];
+      if (!deps) continue;
+      for (const [dep, version] of Object.entries(deps)) {
+        if (!workspaceNames.has(dep)) continue;
+        if (!version.startsWith("workspace:")) {
+          deps[dep] = "workspace:~";
+          console.log(chalk15.green(`  \u2714 Fixed: set ${depField}.${dep} to "workspace:~" in ${name} (${location})`));
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      writeWorkspacePackageJson(cwd, location, pkg);
+    }
+  }
+}
+function checkInternalPeerVersions(cwd, workspaces) {
+  const result = {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const peerDeps = pkg.peerDependencies;
+    if (!peerDeps) continue;
+    const devDeps = pkg.devDependencies;
+    for (const [dep, version] of Object.entries(peerDeps)) {
+      const targetVersion = workspaceVersions.get(dep);
+      if (!targetVersion) continue;
+      if (version.startsWith("workspace:")) {
+        const expected2 = expectedPeerRange(devDeps?.[dep], targetVersion);
+        result.fixable.push(
+          `${name} (${location}) peerDependencies.${dep} uses workspace: protocol \u2014 should be "${expected2}"`
+        );
+        continue;
+      }
+      const expected = expectedPeerRange(devDeps?.[dep], targetVersion);
+      if (version !== expected && !semver.satisfies(targetVersion, version)) {
+        result.fixable.push(
+          `${name} (${location}) peerDependencies.${dep} is "${version}" \u2014 current version ${targetVersion} is not satisfied; expected "${expected}"`
+        );
+      }
+    }
+  }
+  return result;
+}
+function fixInternalPeerVersions(cwd, workspaces) {
+  const workspaceVersions = buildWorkspaceVersionMap(cwd, workspaces);
+  for (const { location, name } of workspaces) {
+    const pkg = readWorkspacePackageJson(cwd, location);
+    if (!pkg) continue;
+    const peerDeps = pkg.peerDependencies;
+    if (!peerDeps) continue;
+    const devDeps = pkg.devDependencies;
+    let modified = false;
+    for (const [dep, version] of Object.entries(peerDeps)) {
+      const targetVersion = workspaceVersions.get(dep);
+      if (!targetVersion) continue;
+      const expected = expectedPeerRange(devDeps?.[dep], targetVersion);
+      if (version !== expected) {
+        peerDeps[dep] = expected;
+        console.log(chalk15.green(`  \u2714 Fixed: set peerDependencies.${dep} to "${expected}" in ${name} (${location})`));
+        modified = true;
+      }
+    }
+    if (modified) {
+      writeWorkspacePackageJson(cwd, location, pkg);
+    }
+  }
+}
+
+// src/actions/gen-docs.ts
+var genDocs = ({
+  jobs,
+  pkg,
+  incremental
+}) => {
+  return pkg ? genDocsPackage({ pkg }) : genDocsAll({ incremental, jobs });
+};
+var genDocsPackage = ({ pkg }) => {
+  const pm = getPackageManager();
+  return runSteps(`GenDocs [${pkg}]`, [pm.runInWorkspace(pkg, "package-gen-docs")]);
+};
+var genDocsAll = ({ incremental, jobs }) => {
+  const pm = getPackageManager();
+  return runSteps(`GenDocs [All${incremental ? "-Incremental" : ""}]`, [
+    pm.foreachWorkspace("package-gen-docs", [], { incremental, jobs })
+  ]);
+};
+
+// src/actions/gitignore.ts
+import { unlinkSync as unlinkSync4 } from "fs";
+import chalk16 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(cwd) {
+  let removed = 0;
+  const workspaces = getPackageManager().listWorkspaces();
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const filePath = `${cwd}/${location}/.gitignore`;
+    try {
+      unlinkSync4(filePath);
+      console.log(chalk16.yellow(`  Removed ${location}/.gitignore`));
+      removed++;
+    } catch {
+    }
+  }
+  return removed;
+}
+function gitignore() {
+  console.log(chalk16.green("Generate .gitignore"));
+  const cwd = INIT_CWD();
+  const gitignorePath = `${cwd}/.gitignore`;
+  try {
+    const templateContent = gitignoreTemplate();
+    const existing = readNonEmptyLines(gitignorePath);
+    const merged = mergeWithTemplate(existing, templateContent);
+    writeLines(gitignorePath, merged);
+    console.log(chalk16.green("  Root .gitignore updated"));
+    const removed = removePackageGitignores(cwd);
+    if (removed > 0) {
+      console.log(chalk16.green(`  Removed ${removed} package .gitignore file(s)`));
+    }
+    return 0;
+  } catch (ex) {
+    const error = ex;
+    console.error(chalk16.red(`Generate .gitignore failed: ${error.message}`));
+    return 1;
+  }
+}
+
+// src/actions/gitlint.ts
+import chalk17 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(chalk17.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(chalk17.green(`Passed: ${valid}`));
+  }
+  if (warnings > 0) {
+    resultMessages.push(chalk17.yellow(`Warnings: ${warnings}`));
+  }
+  if (errors > 0) {
+    resultMessages.push(chalk17.red(` Errors: ${errors}`));
+  }
+  console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
+`);
+  return warnings + errors === 0 ? 0 : 1;
+};
+
+// src/actions/gitlint-fix.ts
+import { execSync } from "child_process";
+import chalk18 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) {
+    execSync("git config core.ignorecase false", { stdio: "inherit" });
+    console.warn(chalk18.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+  }
+  if (gitConfig.core.autocrlf !== false) {
+    execSync("git config core.autocrlf false", { stdio: "inherit" });
+    console.warn(chalk18.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+  }
+  if (gitConfig.core.eol !== "lf") {
+    execSync("git config core.eol lf", { stdio: "inherit" });
+    console.warn(chalk18.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+  }
+  return 1;
+};
+
+// src/actions/license.ts
+import chalk19 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(chalk19.green("License Checker"));
+  return (await Promise.all(
+    workspaceList.map(({ location, name }) => {
+      return new Promise((resolve) => {
+        init({ production: true, start: location }, (error, packages) => {
+          if (error) {
+            console.error(chalk19.red(`License Checker [${name}] Error`));
+            console.error(chalk19.gray(error));
+            console.log("\n");
+            resolve(1);
+          } else {
+            console.log(chalk19.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 (const license2 of licenses) {
+                if (license2) {
+                  const processedLicense = license2.startsWith("(") && 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(chalk19.yellow(`${name2}: Package License not allowed [${license2}]`));
+                  }
+                }
+              }
+            }
+            console.log("\n");
+            resolve(count);
+          }
+        });
+      });
+    })
+  )).reduce((prev, value) => prev || value, 0);
+};
+
+// src/actions/lint-init.ts
+import {
+  existsSync as existsSync10,
+  readFileSync as readFileSync12,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync7
+} from "fs";
+import PATH12 from "path";
+import { createInterface as createInterface3 } from "readline";
+import chalk20 from "chalk";
+import { globSync } from "glob";
+function detectReactInMonorepo(cwd, verbose) {
+  const packageJsonPaths = globSync("packages/**/package.json", {
+    cwd,
+    ignore: ["**/node_modules/**"]
+  });
+  for (const relPath of packageJsonPaths) {
+    const fullPath = PATH12.resolve(cwd, relPath);
+    try {
+      const content = readFileSync12(fullPath, "utf8");
+      const pkg = JSON.parse(content);
+      const deps = pkg.dependencies;
+      const peerDeps = pkg.peerDependencies;
+      if (deps?.react || peerDeps?.react) {
+        if (verbose) console.log(chalk20.gray(`  React detected in ${relPath}`));
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+
+// src/actions/lintlint.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import {
+  existsSync as existsSync11,
+  readFileSync as readFileSync13,
+  writeFileSync as writeFileSync8
+} from "fs";
+import PATH13 from "path";
+import chalk21 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 rules = /* @__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) {
+      rules.set(match[1], match[2]);
+    }
+  }
+  return rules;
+}
+function extractConfigBlocks(sharedModule) {
+  const config2 = sharedModule.config ?? sharedModule.default;
+  if (Array.isArray(config2)) return config2;
+  return [];
+}
+async function resolveSharedConfig(configDir, sharedPkg) {
+  try {
+    const sharedModule = await import(sharedPkg);
+    return extractConfigBlocks(sharedModule);
+  } catch {
+    const distPath = PATH13.resolve(configDir, "node_modules", sharedPkg, "dist", "node", "index.mjs");
+    try {
+      const sharedModule = await import(distPath);
+      return extractConfigBlocks(sharedModule);
+    } catch {
+      const neutralPath = PATH13.resolve(configDir, "node_modules", sharedPkg, "dist", "neutral", "index.mjs");
+      const sharedModule = await import(neutralPath);
+      return extractConfigBlocks(sharedModule);
+    }
+    return [];
+  }
+}
+async function loadSharedRules(configDir, sharedPkg, verbose) {
+  const sharedBlocks = await resolveSharedConfig(configDir, sharedPkg);
+  const sharedRules = mergeRulesFromBlocks(sharedBlocks);
+  if (verbose) {
+    console.log(chalk21.gray(`Shared config defines ${sharedRules.size} rules`));
+  }
+  if (sharedRules.size === 0) {
+    console.error(chalk21.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(chalk21.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(chalk21.yellow(`
+${redundant.length} redundant rule(s) (same as shared config \u2014 can be removed):`));
+    for (const { rule, local } of redundant) {
+      console.log(chalk21.yellow(`  ${rule}: ${formatRule(local)}`));
+    }
+  }
+  if (overrides.length > 0) {
+    console.log(chalk21.cyan(`
+${overrides.length} rule override(s) (different from shared config):`));
+    for (const {
+      rule,
+      local,
+      shared
+    } of overrides) {
+      console.log(chalk21.cyan(`  ${rule}:`));
+      console.log(chalk21.gray(`    shared: ${formatRule(shared)}`));
+      console.log(chalk21.white(`    local:  ${formatRule(local)}`));
+    }
+  }
+  if (additions.length > 0 && verbose) {
+    console.log(chalk21.gray(`
+${additions.length} local addition(s) (not in shared config):`));
+    for (const { rule, local } of additions) {
+      console.log(chalk21.gray(`  ${rule}: ${formatRule(local)}`));
+    }
+  }
+  if (redundant.length === 0 && overrides.length === 0) {
+    console.log(chalk21.green("No redundant or overridden rules found"));
+  }
+}
+function fixRedundantRules(eslintConfigPath, redundant) {
+  let updated = readFileSync13(eslintConfigPath, "utf8");
+  const original = updated;
+  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(/\{\s*rules\s*:\s*\{\s*\}\s*,?\s*\}\s*,?/g, "");
+  updated = updated.replaceAll(/\n{3,}/g, "\n\n");
+  if (updated !== original) {
+    writeFileSync8(eslintConfigPath, updated, "utf8");
+    console.log(chalk21.green(`
+Fixed: removed ${redundant.length} redundant rule(s)`));
+  }
+}
+function formatConfigFile(eslintConfigPath) {
+  spawnSync4("eslint", ["--fix", eslintConfigPath], { stdio: "inherit" });
+}
+function fixConfigMismatch(eslintConfigPath, configDir, source, sharedPkg, expectedPkg) {
+  const updated = source.replaceAll(sharedPkg, expectedPkg);
+  writeFileSync8(eslintConfigPath, updated, "utf8");
+  console.log(chalk21.green(`Fixed: replaced ${sharedPkg} with ${expectedPkg}`));
+  const packageJsonPath = PATH13.resolve(configDir, "package.json");
+  if (!existsSync11(packageJsonPath)) return;
+  const content = readFileSync13(packageJsonPath, "utf8");
+  const pkg = JSON.parse(content);
+  const devDeps = pkg.devDependencies ?? {};
+  const oldVersion = devDeps[sharedPkg];
+  if (!oldVersion) return;
+  delete devDeps[sharedPkg];
+  devDeps[expectedPkg] = oldVersion;
+  const sorted = Object.fromEntries(Object.entries(devDeps).toSorted(([a], [b]) => a.localeCompare(b)));
+  pkg.devDependencies = sorted;
+  writeFileSync8(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  console.log(chalk21.green(`Updated package.json: ${sharedPkg} \u2192 ${expectedPkg}`));
+  runInstall(configDir);
+}
+function checkConfigVariant(eslintConfigPath, configDir, source, sharedPkg, fix, verbose) {
+  const hasReact = detectReactInMonorepo(configDir, verbose);
+  const expectedPkg = hasReact ? "@xylabs/eslint-config-react-flat" : "@xylabs/eslint-config-flat";
+  if (sharedPkg === expectedPkg) return false;
+  console.log(chalk21.yellow(`
+Config mismatch: using ${sharedPkg} but ${hasReact ? "React packages detected" : "no React packages found"}`));
+  console.log(chalk21.yellow(`  Expected: ${expectedPkg}`));
+  if (fix) {
+    fixConfigMismatch(eslintConfigPath, configDir, source, sharedPkg, expectedPkg);
+  }
+  return true;
+}
+async function lintlint({ fix, verbose } = {}) {
+  const eslintConfigPath = await findUp(["eslint.config.ts", "eslint.config.mjs"]);
+  if (!eslintConfigPath) {
+    console.error(chalk21.red("No eslint.config.ts found"));
+    return 1;
+  }
+  const configDir = PATH13.dirname(eslintConfigPath);
+  if (verbose) {
+    console.log(chalk21.gray(`Found config: ${eslintConfigPath}`));
+  }
+  const source = readFileSync13(eslintConfigPath, "utf8");
+  const sharedPkg = detectSharedPackage(source);
+  if (!sharedPkg) {
+    console.log(chalk21.yellow("No @xylabs/eslint-config-flat or @xylabs/eslint-config-react-flat imports found"));
+    return 0;
+  }
+  if (verbose) {
+    console.log(chalk21.gray(`Shared package: ${sharedPkg}`));
+  }
+  const hasMismatch = checkConfigVariant(eslintConfigPath, configDir, source, sharedPkg, !!fix, !!verbose);
+  const currentSource = hasMismatch && fix ? readFileSync13(eslintConfigPath, "utf8") : source;
+  const sharedRules = await loadSharedRules(configDir, sharedPkg, !!verbose);
+  if (!sharedRules) return 1;
+  const { explicit, resolved } = await loadLocalRules(eslintConfigPath, currentSource, !!verbose);
+  const results = compareRules(explicit, resolved, sharedRules);
+  reportResults(results, !!verbose);
+  if (results.redundant.length > 0 && fix) {
+    fixRedundantRules(eslintConfigPath, results.redundant);
+  }
+  const didFix = fix && (hasMismatch || results.redundant.length > 0);
+  if (didFix) {
+    formatConfigFile(eslintConfigPath);
+  }
+  const hasUnfixedMismatch = hasMismatch && !fix;
+  const hasUnfixedRedundant = results.redundant.length > 0 && !fix;
+  return hasUnfixedMismatch || hasUnfixedRedundant ? 1 : 0;
+}
+
+// src/actions/npmignore-gen.ts
+var filename = ".npmignore";
+var npmignoreGen = (pkg) => generateIgnoreFiles(filename, pkg);
+
+// src/actions/orphan.ts
+import fs2 from "fs";
+import path3 from "path";
+import chalk22 from "chalk";
+import { glob as glob2 } from "glob";
+function isAncestorOfWorkspace(dir, workspaceLocations) {
+  const dirWithSep = dir.endsWith(path3.sep) ? dir : dir + path3.sep;
+  for (const ws of workspaceLocations) {
+    if (ws.startsWith(dirWithSep)) return true;
+  }
+  return false;
+}
+function findOrphans(cwd, verbose) {
+  const pm = getPackageManager();
+  const workspaces = pm.listWorkspaces();
+  const workspaceLocations = new Set(
+    workspaces.map((ws) => path3.resolve(cwd, ws.location))
+  );
+  const distDirs = glob2.sync("**/dist", {
+    cwd,
+    ignore: ["**/node_modules/**"]
+  });
+  const orphans = /* @__PURE__ */ new Set();
+  for (const distDir of distDirs) {
+    const parentRel = path3.dirname(distDir);
+    const parentAbs = path3.resolve(cwd, parentRel);
+    if (parentRel === ".") continue;
+    if (workspaceLocations.has(parentAbs)) continue;
+    if (fs2.existsSync(path3.join(parentAbs, "package.json"))) continue;
+    if (verbose) {
+      console.log(chalk22.gray(`  Found orphan: ${parentRel}`));
+    }
+    let topOrphan = parentRel;
+    let current = path3.dirname(parentRel);
+    while (current !== ".") {
+      const currentAbs = path3.resolve(cwd, current);
+      if (workspaceLocations.has(currentAbs)) break;
+      if (fs2.existsSync(path3.join(currentAbs, "package.json"))) break;
+      if (isAncestorOfWorkspace(currentAbs, workspaceLocations)) break;
+      topOrphan = current;
+      current = path3.dirname(current);
+    }
+    orphans.add(topOrphan);
+  }
+  return [...orphans].toSorted();
+}
+function orphanList({ verbose } = {}) {
+  const cwd = INIT_CWD();
+  console.log(chalk22.green("Orphan List"));
+  const orphans = findOrphans(cwd, verbose);
+  if (orphans.length === 0) {
+    console.log(chalk22.green("  No orphaned directories found"));
+    return 0;
+  }
+  for (const orphan of orphans) {
+    console.log(chalk22.yellow(`  ${orphan}`));
+  }
+  console.log(chalk22.yellow(`
+  Found ${orphans.length} orphaned director${orphans.length === 1 ? "y" : "ies"}`));
+  return 1;
+}
+function orphanClean({ verbose } = {}) {
+  const cwd = INIT_CWD();
+  console.log(chalk22.green("Orphan Clean"));
+  const orphans = findOrphans(cwd, verbose);
+  if (orphans.length === 0) {
+    console.log(chalk22.green("  No orphaned directories found"));
+    return 0;
+  }
+  for (const orphan of orphans) {
+    const absPath = path3.resolve(cwd, orphan);
+    fs2.rmSync(absPath, { force: true, recursive: true });
+    console.log(chalk22.yellow(`  Removed ${orphan}`));
+  }
+  console.log(chalk22.green(`
+  Cleaned ${orphans.length} orphaned director${orphans.length === 1 ? "y" : "ies"}`));
+  return 0;
+}
+
+// src/actions/package/compile/XyConfig.ts
+var ALL_PUBLINT_CHECKS = [
+  "files",
+  "importToDefault",
+  "main",
+  "module",
+  "peerDeps",
+  "publint",
+  "resolutions",
+  "rootSource",
+  "rootTypes",
+  "sideEffects",
+  "source",
+  "types"
+];
+var PUBLISH_ONLY_CHECKS = [
+  "files",
+  "importToDefault",
+  "main",
+  "module",
+  "publint",
+  "rootSource",
+  "rootTypes",
+  "sideEffects",
+  "source",
+  "types"
+];
+
+// src/actions/package/publint.ts
+import { promises as fs3 } from "fs";
+import path4 from "path";
+import chalk23 from "chalk";
+import { glob as glob3 } from "glob";
+import sortPackageJson from "sort-package-json";
+var removeSourceFromExports = (exports) => {
+  let removed = false;
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "source") {
+      delete exports[key];
+      removed = true;
+    } else if (typeof value === "object" && value !== null && removeSourceFromExports(value)) removed = true;
+  }
+  return removed;
+};
+var hasSourceInExports = (exports) => {
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "source") return true;
+    if (typeof value === "object" && value !== null && hasSourceInExports(value)) return true;
+  }
+  return false;
+};
+var hasImportKeyInExports = (exports) => {
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "import" && typeof value === "string" && value.endsWith(".mjs")) return true;
+    if (typeof value === "object" && value !== null && hasImportKeyInExports(value)) return true;
+  }
+  return false;
+};
+var replaceImportWithDefault = (exports) => {
+  let modified = false;
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "import" && typeof value === "string" && value.endsWith(".mjs")) {
+      if (exports.default === void 0) {
+        exports.default = value;
+      }
+      delete exports.import;
+      if (exports.types === void 0) {
+        exports.types = value.replace(/\.mjs$/, ".d.ts");
+      }
+      modified = true;
+    } else if (typeof value === "object" && value !== null && replaceImportWithDefault(value)) modified = true;
+  }
+  return modified;
+};
+var hasTypesInExports = (exports) => {
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "types") return true;
+    if (typeof value === "object" && value !== null && hasTypesInExports(value)) return true;
+  }
+  return false;
+};
+function ensureExportsPath(value) {
+  if (value.startsWith("./") || value.startsWith("../")) return value;
+  return `./${value}`;
+}
+function emptyCustomResult() {
+  return {
+    errors: 0,
+    modified: false,
+    warnings: 0
+  };
+}
+function mergeResults(target, source) {
+  target.errors += source.errors;
+  target.warnings += source.warnings;
+  target.modified = target.modified || source.modified;
+}
+function checkFiles(pkg, fix) {
+  const result = emptyCustomResult();
+  const files = pkg.files;
+  if (files === void 0) {
+    console.warn(chalk23.yellow('Publint [custom]: "files" field is missing'));
+    result.warnings++;
+  }
+  if (Array.isArray(files) && !files.includes("README.md")) {
+    files.push("README.md");
+    console.warn(chalk23.yellow('Publint [custom]: added "README.md" to "files"'));
+    result.modified = true;
+    result.warnings++;
+  }
+  if (Array.isArray(files) && files.includes("src")) {
+    if (fix) {
+      pkg.files = files.filter((f) => f !== "src");
+      console.warn(chalk23.yellow('Publint [custom]: removed "src" from "files"'));
+      result.modified = true;
+    } else {
+      console.warn(chalk23.yellow('Publint [custom]: "src" should not be in "files" (use --fix to remove)'));
+    }
+    result.warnings++;
+  }
+  return result;
+}
+function checkExportsSource(pkg, fix) {
+  const result = emptyCustomResult();
+  const exports = pkg.exports;
+  if (exports && typeof exports === "object" && hasSourceInExports(exports)) {
+    if (fix) {
+      removeSourceFromExports(exports);
+      console.warn(chalk23.yellow('Publint [custom]: removed "source" entries from "exports"'));
+      result.modified = true;
+    } else {
+      console.warn(chalk23.yellow('Publint [custom]: "source" entries should not be in "exports" (use --fix to remove)'));
+    }
+    result.warnings++;
+  }
+  return result;
+}
+function migrateFieldToExports(pkg, field, exportKey, fix) {
+  const result = emptyCustomResult();
+  if (pkg[field] === void 0) return result;
+  const fieldValue = pkg[field];
+  if (!fieldValue.endsWith(".js") && !fieldValue.endsWith(".mjs") && !fieldValue.endsWith(".cjs")) return result;
+  if (fix) {
+    const exportValue = ensureExportsPath(fieldValue);
+    const exports = pkg.exports;
+    if (exports && typeof exports === "object") {
+      const dot = exports["."];
+      if (dot && typeof dot === "object" && !dot[exportKey]) {
+        dot[exportKey] = exportValue;
+        console.warn(chalk23.yellow(`Publint [custom]: migrated "${field}" to "exports['.'].${exportKey}" (${fieldValue})`));
+      }
+    } else if (!pkg.exports) {
+      pkg.exports = { ".": { [exportKey]: exportValue } };
+      console.warn(chalk23.yellow(`Publint [custom]: migrated "${field}" to "exports" (.\u2192${fieldValue})`));
+    }
+    delete pkg[field];
+    console.warn(chalk23.yellow(`Publint [custom]: removed deprecated "${field}" field`));
+    result.modified = true;
+  } else {
+    console.warn(chalk23.yellow(`Publint [custom]: "${field}" field is deprecated, use "exports" instead (use --fix to remove)`));
+  }
+  result.warnings++;
+  return result;
+}
+function checkSideEffects(pkg) {
+  const result = emptyCustomResult();
+  if (pkg.sideEffects !== false) {
+    console.warn(chalk23.yellow('Publint [custom]: "sideEffects" field should be set to false'));
+    result.warnings++;
+  }
+  return result;
+}
+function checkRootSource(pkg, fix) {
+  const result = emptyCustomResult();
+  for (const field of ["source", "src"]) {
+    if (pkg[field] !== void 0) {
+      if (fix) {
+        delete pkg[field];
+        console.warn(chalk23.yellow(`Publint [custom]: removed root-level "${field}" field`));
+        result.modified = true;
+      } else {
+        console.warn(chalk23.yellow(`Publint [custom]: root-level "${field}" field should not be in package.json (use --fix to remove)`));
+      }
+      result.warnings++;
+    }
+  }
+  return result;
+}
+function checkResolutions(pkg) {
+  const result = emptyCustomResult();
+  if (pkg.resolutions !== void 0) {
+    console.warn(chalk23.yellow('Publint [custom]: "resolutions" in use'));
+    console.warn(chalk23.gray(JSON.stringify(pkg.resolutions, null, 2)));
+    result.warnings++;
+  }
+  return result;
+}
+function checkImportToDefault(pkg, fix) {
+  const result = emptyCustomResult();
+  const exports = pkg.exports;
+  if (!exports || typeof exports !== "object") return result;
+  if (!hasImportKeyInExports(exports)) return result;
+  if (fix) {
+    replaceImportWithDefault(exports);
+    console.warn(chalk23.yellow('Publint [custom]: renamed "import" to "default" in "exports" and ensured "types" siblings'));
+    result.modified = true;
+  } else {
+    console.warn(chalk23.yellow('Publint [custom]: "import" entries in "exports" should use "default" instead (use --fix to rename)'));
+  }
+  result.warnings++;
+  return result;
+}
+function checkRootTypes(pkg, fix) {
+  const result = emptyCustomResult();
+  if (pkg.types === void 0) return result;
+  const exports = pkg.exports;
+  if (!exports || typeof exports !== "object" || !hasTypesInExports(exports)) return result;
+  if (fix) {
+    delete pkg.types;
+    console.warn(chalk23.yellow('Publint [custom]: removed redundant root "types" field (already defined in "exports")'));
+    result.modified = true;
+  } else {
+    console.warn(chalk23.yellow('Publint [custom]: root "types" field is redundant when "exports" defines types (use --fix to remove)'));
+  }
+  result.warnings++;
+  return result;
+}
+function customPubLint(pkg, fix = false, exclude = /* @__PURE__ */ new Set()) {
+  const result = emptyCustomResult();
+  if (!exclude.has("files")) mergeResults(result, checkFiles(pkg, fix));
+  if (!exclude.has("source")) mergeResults(result, checkExportsSource(pkg, fix));
+  if (!exclude.has("rootSource")) mergeResults(result, checkRootSource(pkg, fix));
+  if (!exclude.has("main")) mergeResults(result, migrateFieldToExports(pkg, "main", "default", fix));
+  if (!exclude.has("types")) mergeResults(result, migrateFieldToExports(pkg, "types", "types", fix));
+  if (!exclude.has("module")) mergeResults(result, migrateFieldToExports(pkg, "module", "default", fix));
+  if (!exclude.has("importToDefault")) mergeResults(result, checkImportToDefault(pkg, fix));
+  if (!exclude.has("rootTypes")) mergeResults(result, checkRootTypes(pkg, fix));
+  if (!exclude.has("sideEffects")) mergeResults(result, checkSideEffects(pkg));
+  if (!exclude.has("resolutions")) mergeResults(result, checkResolutions(pkg));
+  return [result.errors, result.warnings, result.modified];
+}
+var ALWAYS_INCLUDED_PATTERNS = [
+  "package.json",
+  "README",
+  "README.*",
+  "LICENCE",
+  "LICENCE.*",
+  "LICENSE",
+  "LICENSE.*",
+  "CHANGELOG",
+  "CHANGELOG.*"
+];
+async function resolvePackFiles(pkgDir, filesField) {
+  const patterns = [...ALWAYS_INCLUDED_PATTERNS];
+  if (filesField) {
+    for (const pattern of filesField) {
+      if (pattern.startsWith("!")) {
+        patterns.push(pattern);
+      } else {
+        patterns.push(pattern, `${pattern}/**`);
+      }
+    }
+  }
+  const matched = await glob3(patterns, {
+    cwd: pkgDir,
+    nodir: true,
+    dot: false
+  });
+  const files = await Promise.all(
+    matched.map(async (rel) => {
+      const abs = path4.join(pkgDir, rel);
+      const data = await fs3.readFile(abs, "utf8").catch(() => "");
+      return { name: path4.join(pkgDir, rel), data };
+    })
+  );
+  return files;
+}
+async function runPublintLibrary(pkgDir, pkg, strict, pack) {
+  const { publint: publint2 } = await import("publint");
+  let packOption = false;
+  if (pack) {
+    const files = await resolvePackFiles(pkgDir, pkg.files);
+    packOption = { files };
+  }
+  const { messages } = await publint2({
+    level: "suggestion",
+    pack: packOption,
+    pkgDir,
+    strict
+  });
+  const { formatMessage } = await import("publint/utils");
+  for (const message of messages) {
+    switch (message.type) {
+      case "error": {
+        console.error(chalk23.red(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+      case "warning": {
+        console.warn(chalk23.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+      default: {
+        console.log(chalk23.white(`[${message.code}] ${formatMessage(message, pkg)}`));
+        break;
+      }
+    }
+  }
+  return {
+    errors: messages.filter((message) => message.type === "error").length,
+    total: messages.length
+  };
+}
+var packagePublint = async ({
+  exclude = /* @__PURE__ */ new Set(),
+  fix = false,
+  pack = true,
+  pkgDir: pkgDirParam,
+  strict = true,
+  verbose: _verbose = false
+} = {}) => {
+  const pkgDir = pkgDirParam ?? INIT_CWD();
+  const sortedPkg = sortPackageJson(await fs3.readFile(`${pkgDir}/package.json`, "utf8"));
+  await fs3.writeFile(`${pkgDir}/package.json`, sortedPkg);
+  const pkg = JSON.parse(await fs3.readFile(`${pkgDir}/package.json`, "utf8"));
+  const effectiveExclude = pkg.private ? /* @__PURE__ */ new Set([...exclude, ...PUBLISH_ONLY_CHECKS]) : exclude;
+  console.log(chalk23.green(`Publint: ${String(pkg.name)}${pkg.private ? chalk23.gray(" (private)") : ""}`));
+  console.log(chalk23.gray(pkgDir));
+  let libraryErrors = 0;
+  if (!effectiveExclude.has("publint")) {
+    const library = await runPublintLibrary(pkgDir, pkg, strict, pack);
+    libraryErrors = library.errors;
+  }
+  const [errorCount, _warningCount, modified] = customPubLint(pkg, fix, effectiveExclude);
+  if (modified) {
+    const sorted = sortPackageJson(JSON.stringify(pkg, null, 2));
+    await fs3.writeFile(`${pkgDir}/package.json`, sorted);
+  }
+  return libraryErrors + errorCount;
+};
+
+// src/actions/package-lint.ts
+import {
+  existsSync as existsSync12,
+  readFileSync as readFileSync14,
+  writeFileSync as writeFileSync9
+} from "fs";
+import PATH14 from "path";
+import chalk24 from "chalk";
+import picomatch from "picomatch";
+import semver2 from "semver";
+function emptyResult() {
+  return {
+    errors: [],
+    fixable: [],
+    warnings: []
+  };
+}
+function readRootPackageJson(cwd) {
+  const raw = readFileSync14(PATH14.resolve(cwd, "package.json"), "utf8");
+  return JSON.parse(raw);
+}
+function writeRootPackageJson(cwd, pkg) {
+  const path5 = PATH14.resolve(cwd, "package.json");
+  writeFileSync9(path5, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function readPnpmWorkspaceGlobs(cwd) {
+  const wsPath = PATH14.resolve(cwd, "pnpm-workspace.yaml");
+  if (!existsSync12(wsPath)) return void 0;
+  const raw = readFileSync14(wsPath, "utf8");
+  const globs = [];
+  let inPackages = false;
+  for (const line of raw.split("\n")) {
+    if (/^packages\s*:/.test(line)) {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages) {
+      const match = /^\s+-\s+['"]?([^'"]+)['"]?\s*$/.exec(line);
+      if (match) {
+        globs.push(match[1]);
+      } else if (/^\S/.test(line) && line.trim() !== "") {
+        break;
+      }
+    }
+  }
+  return globs.length > 0 ? globs : void 0;
+}
+function isMonorepo(pkg, cwd) {
+  const workspaces = pkg.workspaces;
+  if (Array.isArray(workspaces) && workspaces.length > 0) return true;
+  return readPnpmWorkspaceGlobs(cwd) !== void 0;
+}
+function checkPackagesFolder(workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    if (!location.startsWith("packages/") && !location.startsWith("packages\\")) {
+      result.errors.push(`${name} (${location}) is not inside a packages/ folder`);
+    }
+  }
+  return result;
+}
+function checkRootPrivate(pkg) {
+  const result = emptyResult();
+  if (!pkg.private) {
+    result.fixable.push("Root package.json must be private to prevent accidental publishing");
+  }
+  return result;
+}
+function fixRootPrivate(cwd, pkg) {
+  pkg.private = true;
+  writeRootPackageJson(cwd, pkg);
+  console.log(chalk24.green('  \u2714 Fixed: set "private": true in root package.json'));
+}
+function checkNoPublishConfigOnPrivate(pkg) {
+  const result = emptyResult();
+  if (pkg.private && pkg.publishConfig) {
+    result.fixable.push("Root package.json has publishConfig but is private \u2014 publishConfig is unnecessary");
+  }
+  return result;
+}
+function fixNoPublishConfigOnPrivate(cwd, pkg) {
+  delete pkg.publishConfig;
+  writeRootPackageJson(cwd, pkg);
+  console.log(chalk24.green("  \u2714 Fixed: removed publishConfig from private root package.json"));
+}
+function checkNoPackageManagerInWorkspaces(cwd, workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH14.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync14(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.packageManager) {
+        result.fixable.push(`${name} (${location}) has a packageManager field \u2014 only the root should define this`);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function fixNoPackageManagerInWorkspaces(cwd, _pkg, workspaces) {
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH14.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync14(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.packageManager) {
+        delete pkg.packageManager;
+        writeFileSync9(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk24.green(`  \u2714 Fixed: removed packageManager from ${location}/package.json`));
+      }
+    } catch {
+    }
+  }
+}
+function checkWorkspacesFieldPlacement(cwd, pm, workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (pm === "pnpm" ? true : location !== ".") {
+      const pkgPath = PATH14.resolve(cwd, location, "package.json");
+      try {
+        const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
+        if (pkg.workspaces) {
+          const label = location === "." ? "Root" : `${name} (${location})`;
+          const reason = pm === "pnpm" ? "pnpm uses pnpm-workspace.yaml instead" : "only the root should define workspaces";
+          result.fixable.push(`${label} has a workspaces field \u2014 ${reason}`);
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+function fixWorkspacesFieldPlacement(cwd, pm, workspaces) {
+  for (const { location } of workspaces) {
+    if (pm === "pnpm" ? true : location !== ".") {
+      const pkgPath = PATH14.resolve(cwd, location, "package.json");
+      try {
+        const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
+        if (pkg.workspaces) {
+          delete pkg.workspaces;
+          writeFileSync9(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+          const label = location === "." ? "root" : location;
+          console.log(chalk24.green(`  \u2714 Fixed: removed workspaces from ${label}/package.json`));
+        }
+      } catch {
+      }
+    }
+  }
+}
+function checkWorkspaceGlobCoverage(pkg, cwd, pm, workspaces) {
+  const result = emptyResult();
+  const globs = pm === "pnpm" ? readPnpmWorkspaceGlobs(cwd) ?? [] : Array.isArray(pkg.workspaces) ? pkg.workspaces : [];
+  if (globs.length === 0) {
+    const source = pm === "pnpm" ? "pnpm-workspace.yaml" : "root package.json workspaces";
+    result.errors.push(`No workspace globs found in ${source}`);
+    return result;
+  }
+  const matchers = globs.map((glob4) => picomatch(glob4));
+  const isMatch = (location) => matchers.some((m) => m(location));
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    if (!isMatch(location)) {
+      const source = pm === "pnpm" ? "pnpm-workspace.yaml" : "root package.json workspaces";
+      result.errors.push(`${name} (${location}) is not matched by any glob in ${source}`);
+    }
+  }
+  return result;
+}
+function logResults(label, result, fix) {
+  let errors = 0;
+  let fixed = 0;
+  for (const error of result.errors) {
+    console.log(chalk24.red(`  \u2717 ${error}`));
+    errors++;
+  }
+  for (const fixable of result.fixable) {
+    if (fix) {
+      fixed++;
+    } else {
+      console.log(chalk24.red(`  \u2717 ${fixable} (fixable)`));
+      errors++;
+    }
+  }
+  for (const warning of result.warnings) {
+    console.log(chalk24.yellow(`  \u26A0 ${warning}`));
+  }
+  if (errors === 0 && fixed === 0 && result.warnings.length === 0) {
+    console.log(chalk24.green(`  \u2713 ${label}`));
+  }
+  return { errors, fixed };
+}
+function runChecks(entries, cwd, pkg, fix) {
+  let totalErrors = 0;
+  let totalFixed = 0;
+  for (const entry of entries) {
+    const result = entry.check();
+    const log = logResults(entry.label, result, fix);
+    if (fix && entry.fix && result.fixable.length > 0) {
+      entry.fix(cwd, pkg);
+    }
+    totalErrors += log.errors;
+    totalFixed += log.fixed;
+  }
+  return { errors: totalErrors, fixed: totalFixed };
+}
+function checkVoltaOnlyInRoot(cwd, workspaces) {
+  const result = emptyResult();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH14.resolve(cwd, location, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
+      if (pkg.volta) {
+        result.fixable.push(`${name} (${location}) has a volta field \u2014 only the root should define this`);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function fixVoltaOnlyInRoot(cwd, _pkg, workspaces) {
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH14.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync14(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg.volta) {
+        delete pkg.volta;
+        writeFileSync9(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk24.green(`  \u2714 Fixed: removed volta from ${location}/package.json`));
+      }
+    } catch {
+    }
+  }
+}
+function isTerminalPackage(pkg) {
+  return pkg.private === true;
+}
+function checkEnginesOnlyInNonTerminal(cwd, workspaces) {
+  const result = emptyResult();
+  const rootPkg = JSON.parse(readFileSync14(PATH14.resolve(cwd, "package.json"), "utf8"));
+  if (rootPkg.engines) {
+    result.fixable.push("Root package.json has engines \u2014 terminal packages should not declare engines (use volta instead)");
+  }
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH14.resolve(cwd, location, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
+      if (isTerminalPackage(pkg) && pkg.engines) {
+        result.fixable.push(`${name} (${location}) is terminal (private) but has engines \u2014 terminal packages should not declare engines`);
+      }
+      if (!isTerminalPackage(pkg) && !pkg.engines) {
+        result.fixable.push(`${name} (${location}) is a library but has no engines field`);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function fixEnginesOnlyInNonTerminal(cwd, _pkg, workspaces) {
+  const rootPath = PATH14.resolve(cwd, "package.json");
+  const rootRaw = readFileSync14(rootPath, "utf8");
+  const rootPkg = JSON.parse(rootRaw);
+  if (rootPkg.engines) {
+    delete rootPkg.engines;
+    writeFileSync9(rootPath, `${JSON.stringify(rootPkg, null, 2)}
+`, "utf8");
+    console.log(chalk24.green("  \u2714 Fixed: removed engines from root package.json"));
+  }
+  const enginesTemplate = resolveEnginesTemplate(cwd, workspaces);
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH14.resolve(cwd, location, "package.json");
+    try {
+      const raw = readFileSync14(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      if (isTerminalPackage(pkg) && pkg.engines) {
+        delete pkg.engines;
+        writeFileSync9(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk24.green(`  \u2714 Fixed: removed engines from ${location}/package.json`));
+      }
+      if (!isTerminalPackage(pkg) && !pkg.engines && enginesTemplate) {
+        pkg.engines = enginesTemplate;
+        writeFileSync9(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+        console.log(chalk24.green(`  \u2714 Fixed: added engines to ${location}/package.json`));
+      }
+    } catch {
+    }
+  }
+}
+function resolveEnginesTemplate(cwd, workspaces) {
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    try {
+      const pkg = JSON.parse(readFileSync14(PATH14.resolve(cwd, location, "package.json"), "utf8"));
+      if (!isTerminalPackage(pkg) && pkg.engines) {
+        return pkg.engines;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function checkVersionsIncludeLts(cwd, workspaces) {
+  const result = emptyResult();
+  const toolVersions = {
+    node: latestVersions.node,
+    npm: latestVersions.npm,
+    pnpm: latestVersions.pnpm,
+    yarn: latestVersions.yarn
+  };
+  for (const { location, name } of workspaces) {
+    const pkgPath = location === "." ? PATH14.resolve(cwd, "package.json") : PATH14.resolve(cwd, location, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync14(pkgPath, "utf8"));
+      const label = location === "." ? "root" : `${name} (${location})`;
+      const engines = pkg.engines;
+      if (engines) {
+        for (const [tool, range] of Object.entries(engines)) {
+          const latest = toolVersions[tool];
+          if (latest && !semver2.satisfies(latest, range)) {
+            result.errors.push(
+              `${label} engines.${tool} "${range}" does not include latest ${tool === "node" ? "LTS " : ""}version ${latest}`
+            );
+          }
+        }
+      }
+      const volta = pkg.volta;
+      if (volta) {
+        for (const [tool, pinnedVersion] of Object.entries(volta)) {
+          const latest = toolVersions[tool];
+          if (latest && semver2.lt(pinnedVersion, latest)) {
+            result.warnings.push(
+              `${label} volta.${tool} "${pinnedVersion}" is older than latest ${tool === "node" ? "LTS " : ""}version ${latest}`
+            );
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function logSummary(errors, fixed) {
+  if (fixed > 0) {
+    console.log(chalk24.green(`
+  Fixed ${fixed} issue(s)`));
+  }
+  if (errors > 0) {
+    console.log(chalk24.red(`
+  ${errors} error(s) found`));
+  } else if (fixed === 0) {
+    console.log(chalk24.green("\n  All checks passed"));
+  }
+}
+function packageLintMonorepo(fix = false) {
+  const cwd = INIT_CWD();
+  let pkg;
+  try {
+    pkg = readRootPackageJson(cwd);
+  } catch {
+    console.error(chalk24.red("Could not read package.json"));
+    return 1;
+  }
+  if (!isMonorepo(pkg, cwd)) {
+    console.log(chalk24.gray("Not a monorepo \u2014 skipping repo lint checks"));
+    return 0;
+  }
+  console.log(chalk24.green("Repo Lint"));
+  const pm = detectPackageManager();
+  const workspaces = getPackageManager().listWorkspaces();
+  const internalDepCheck = pm === "pnpm" ? {
+    check: () => checkWorkspaceProtocol(cwd, workspaces),
+    fix: () => fixWorkspaceProtocol(cwd, workspaces),
+    label: "Internal deps/devDeps use workspace: protocol"
+  } : {
+    check: () => checkInternalDepVersions(cwd, workspaces),
+    fix: () => fixInternalDepVersions(cwd, workspaces),
+    label: "Internal deps/devDeps use correct version ranges"
+  };
+  const checks2 = [
+    {
+      check: () => checkRootPrivate(pkg),
+      fix: fixRootPrivate,
+      label: "Root package is private"
+    },
+    {
+      check: () => checkNoPublishConfigOnPrivate(pkg),
+      fix: fixNoPublishConfigOnPrivate,
+      label: "No publishConfig on private root"
+    },
+    { check: () => checkPackagesFolder(workspaces), label: "All packages are in packages/ folder" },
+    {
+      check: () => checkWorkspacesFieldPlacement(cwd, pm, workspaces),
+      fix: () => fixWorkspacesFieldPlacement(cwd, pm, workspaces),
+      label: pm === "pnpm" ? "No workspaces field in package.json (use pnpm-workspace.yaml)" : "Workspaces field only in root package.json"
+    },
+    {
+      check: () => checkWorkspaceGlobCoverage(pkg, cwd, pm, workspaces),
+      label: "Workspace globs cover all packages"
+    },
+    {
+      check: () => checkNoPackageManagerInWorkspaces(cwd, workspaces),
+      fix: () => fixNoPackageManagerInWorkspaces(cwd, pkg, workspaces),
+      label: "No packageManager in workspace packages"
+    },
+    {
+      check: () => checkVoltaOnlyInRoot(cwd, workspaces),
+      fix: () => fixVoltaOnlyInRoot(cwd, pkg, workspaces),
+      label: "Volta only in root package.json"
+    },
+    {
+      check: () => checkEnginesOnlyInNonTerminal(cwd, workspaces),
+      fix: () => fixEnginesOnlyInNonTerminal(cwd, pkg, workspaces),
+      label: "Engines only in non-terminal (library) packages"
+    },
+    {
+      check: () => checkVersionsIncludeLts(cwd, workspaces),
+      label: "Engine/volta versions include latest LTS"
+    },
+    {
+      check: () => checkVersionConsistency(cwd, pkg, workspaces),
+      fix: () => fixVersionConsistency(cwd, pkg, writeRootPackageJson, workspaces),
+      label: "Consistent versions across packages"
+    },
+    internalDepCheck,
+    {
+      check: () => checkInternalPeerVersions(cwd, workspaces),
+      fix: () => fixInternalPeerVersions(cwd, workspaces),
+      label: "Internal peerDeps use semver ranges (not workspace: protocol)"
+    }
+  ];
+  const { errors, fixed } = runChecks(checks2, cwd, pkg, fix);
+  logSummary(errors, fixed);
+  if (fix && fixed > 0) {
+    runInstall();
+  }
+  return errors > 0 ? 1 : 0;
+}
+
+// src/actions/packman/clean.ts
+import {
+  existsSync as existsSync18,
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync14
+} from "fs";
+import PATH19 from "path";
+import chalk30 from "chalk";
+
+// src/actions/packman/convert.ts
+import {
+  existsSync as existsSync17,
+  readdirSync as readdirSync8,
+  readFileSync as readFileSync19,
+  statSync as statSync4
+} from "fs";
+import PATH18 from "path";
+import chalk29 from "chalk";
+
+// src/actions/packman/convertToPnpm.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import {
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync17,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync12
+} from "fs";
+import PATH16 from "path";
+import chalk27 from "chalk";
+
+// src/actions/packman/rewriteScripts.ts
+function rewriteYarnToPnpm(script) {
+  let result = script;
+  result = result.replaceAll(/\byarn workspace (\S+) run /g, "pnpm --filter $1 run ");
+  result = result.replaceAll(/\byarn workspace (\S+) (package-\S+)/g, "pnpm --filter $1 run $2");
+  result = result.replaceAll(/\byarn workspaces foreach\s+(?:[^\s]*\s+)*run /g, "pnpm -r run ");
+  result = result.replaceAll(/\byarn workspaces foreach --all version (\S+) --deferred/g, "pnpm -r exec npm version $1 --no-git-tag-version");
+  result = result.replaceAll(/\byarn version apply --all/g, 'echo "versions applied"');
+  result = result.replaceAll(/\byarn xy\b/g, "pnpm xy");
+  result = result.replaceAll(/\byarn add\b/g, "pnpm add");
+  result = result.replaceAll(/\byarn remove\b/g, "pnpm remove");
+  result = result.replaceAll(/\byarn install\b/g, "pnpm install");
+  result = result.replaceAll(/\byarn dedupe\b/g, "pnpm dedupe");
+  result = result.replaceAll(/\byarn outdated\b/g, "pnpm outdated");
+  result = result.replaceAll(/\byarn run\b/g, "pnpm run");
+  result = result.replaceAll(/\byarn rimraf\b/g, "rimraf");
+  result = result.replaceAll(/\byarn npm\b/g, "npm");
+  result = result.replaceAll(/\byarn\b(?![@/.])/g, "pnpm");
+  return result;
+}
+function rewritePnpmToYarn(script) {
+  let result = script;
+  result = result.replaceAll(/\bpnpm --filter (\S+) run /g, "yarn workspace $1 run ");
+  result = result.replaceAll(/\bpnpm -r run /g, "yarn workspaces foreach -Apt run ");
+  result = result.replaceAll(/\bpnpm -r exec npm version (\S+) --no-git-tag-version/g, "yarn workspaces foreach --all version $1 --deferred");
+  result = result.replaceAll(/\bpnpm xy\b/g, "yarn xy");
+  result = result.replaceAll(/\bpnpm add\b/g, "yarn add");
+  result = result.replaceAll(/\bpnpm remove\b/g, "yarn remove");
+  result = result.replaceAll(/\bpnpm install\b/g, "yarn install");
+  result = result.replaceAll(/\bpnpm dedupe\b/g, "yarn dedupe");
+  result = result.replaceAll(/\bpnpm outdated\b/g, "yarn outdated");
+  result = result.replaceAll(/\bpnpm run\b/g, "yarn run");
+  result = result.replaceAll(/\bpnpm\b(?![@/.])/g, "yarn");
+  return result;
+}
+function rewriteScript(script, direction) {
+  return direction === "yarn-to-pnpm" ? rewriteYarnToPnpm(script) : rewritePnpmToYarn(script);
+}
+function rewriteScriptsInPackageJson(pkg, direction) {
+  const scripts = pkg.scripts;
+  if (!scripts) return pkg;
+  const rewritten = {};
+  for (const [name, script] of Object.entries(scripts)) {
+    rewritten[name] = rewriteScript(script, direction);
+  }
+  return { ...pkg, scripts: rewritten };
+}
+
+// src/actions/packman/rewriteSourceImports.ts
+import {
+  existsSync as existsSync13,
+  readFileSync as readFileSync15,
+  writeFileSync as writeFileSync10
+} from "fs";
+import chalk25 from "chalk";
+import { globSync as globSync2 } from "glob";
+var IMPORT_SWAP_MAP = {
+  "yarn-to-pnpm": [
+    ["@xylabs/ts-scripts-yarn3", "@xylabs/ts-scripts-pnpm"],
+    ["@xylabs/ts-scripts-react-yarn3", "@xylabs/ts-scripts-react-pnpm"]
+  ],
+  "pnpm-to-yarn": [
+    ["@xylabs/ts-scripts-pnpm", "@xylabs/ts-scripts-yarn3"],
+    ["@xylabs/ts-scripts-react-pnpm", "@xylabs/ts-scripts-react-yarn3"]
+  ]
+};
+var SOURCE_GLOBS = [
+  "**/*.ts",
+  "**/*.tsx",
+  "**/*.mts",
+  "**/*.cts",
+  "**/*.js",
+  "**/*.mjs"
+];
+var IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.yarn/**"
+];
+function rewriteSourceImports(cwd, direction) {
+  const swaps = IMPORT_SWAP_MAP[direction];
+  const files = globSync2(SOURCE_GLOBS, {
+    cwd,
+    absolute: true,
+    ignore: IGNORE_PATTERNS
+  });
+  let count = 0;
+  for (const file of files) {
+    if (!existsSync13(file)) continue;
+    const original = readFileSync15(file, "utf8");
+    let content = original;
+    for (const [from, to] of swaps) {
+      content = content.replaceAll(from, to);
+    }
+    if (content !== original) {
+      writeFileSync10(file, content, "utf8");
+      count++;
+    }
+  }
+  if (count > 0) {
+    console.log(chalk25.green(`  Rewrote ts-scripts imports in ${count} source file(s)`));
+  }
+}
+
+// src/actions/packman/swapTsScriptsDependency.ts
+import {
+  existsSync as existsSync14,
+  readFileSync as readFileSync16,
+  writeFileSync as writeFileSync11
+} from "fs";
+import PATH15 from "path";
+import chalk26 from "chalk";
+var SWAP_MAP = {
+  "yarn-to-pnpm": [
+    ["@xylabs/ts-scripts-yarn3", "@xylabs/ts-scripts-pnpm"]
+  ],
+  "pnpm-to-yarn": [
+    ["@xylabs/ts-scripts-pnpm", "@xylabs/ts-scripts-yarn3"]
+  ]
+};
+function swapInPackageJson(pkgPath, direction) {
+  if (!existsSync14(pkgPath)) return false;
+  const raw = readFileSync16(pkgPath, "utf8");
+  const pkg = JSON.parse(raw);
+  let changed = false;
+  for (const depField of ["dependencies", "devDependencies"]) {
+    const deps = pkg[depField];
+    if (!deps) continue;
+    for (const [from, to] of SWAP_MAP[direction]) {
+      if (deps[from]) {
+        deps[to] = deps[from];
+        delete deps[from];
+        changed = true;
+      }
+    }
+  }
+  if (changed) {
+    writeFileSync11(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  }
+  return changed;
+}
+function swapTsScriptsDependency(cwd, workspacePackageJsonPaths, direction) {
+  let count = 0;
+  if (swapInPackageJson(PATH15.join(cwd, "package.json"), direction)) {
+    count++;
+  }
+  for (const pkgPath of workspacePackageJsonPaths) {
+    const fullPath = PATH15.resolve(cwd, pkgPath, "package.json");
+    if (swapInPackageJson(fullPath, direction)) {
+      count++;
+    }
+  }
+  if (count > 0) {
+    const target = direction === "yarn-to-pnpm" ? "@xylabs/ts-scripts-pnpm" : "@xylabs/ts-scripts-yarn3";
+    console.log(chalk26.green(`  Swapped ts-scripts dependency to ${target} in ${count} package(s)`));
+  }
+}
+
+// src/actions/packman/convertToPnpm.ts
+var PNPM_VERSION = "10.12.1";
+function createPnpmWorkspaceYaml(cwd, workspacePatterns) {
+  const lines = ["packages:"];
+  for (const pattern of workspacePatterns) {
+    lines.push(`  - '${pattern}'`);
+  }
+  writeFileSync12(PATH16.join(cwd, "pnpm-workspace.yaml"), lines.join("\n") + "\n", "utf8");
+  console.log(chalk27.green("  Created pnpm-workspace.yaml"));
+}
+function readPnpmWorkspacePatterns(cwd) {
+  const wsPath = PATH16.join(cwd, "pnpm-workspace.yaml");
+  if (!existsSync15(wsPath)) return [];
+  const content = readFileSync17(wsPath, "utf8");
+  const patterns = [];
+  const lines = content.split("\n");
+  let inPackages = false;
+  for (const line of lines) {
+    if (line.trim() === "packages:") {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages && /^\s+-\s+/.test(line)) {
+      const pattern = line.replace(/^\s+-\s+/, "").replaceAll(/['"]/g, "").trim();
+      if (pattern) patterns.push(pattern);
+    } else if (inPackages && !/^\s/.test(line) && line.trim()) {
+      inPackages = false;
+    }
+  }
+  return patterns;
+}
+function updateRootPackageJson(cwd) {
+  const pkgPath = PATH16.join(cwd, "package.json");
+  const pkg = JSON.parse(readFileSync17(pkgPath, "utf8"));
+  const workspacePatterns = pkg.workspaces ?? readPnpmWorkspacePatterns(cwd);
+  delete pkg.workspaces;
+  pkg.packageManager = `pnpm@${PNPM_VERSION}`;
+  const updated = rewriteScriptsInPackageJson(pkg, "yarn-to-pnpm");
+  writeFileSync12(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  console.log(chalk27.green("  Updated root package.json"));
+  return workspacePatterns;
+}
+function updateGitignore(cwd) {
+  const gitignorePath = PATH16.join(cwd, ".gitignore");
+  if (!existsSync15(gitignorePath)) return;
+  let content = readFileSync17(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");
+  writeFileSync12(gitignorePath, content, "utf8");
+  console.log(chalk27.green("  Updated .gitignore"));
+}
+function deleteYarnArtifacts(cwd) {
+  const yarnLock = PATH16.join(cwd, "yarn.lock");
+  const yarnrc = PATH16.join(cwd, ".yarnrc.yml");
+  const yarnDir = PATH16.join(cwd, ".yarn");
+  if (existsSync15(yarnLock)) {
+    rmSync3(yarnLock);
+    console.log(chalk27.gray("  Deleted yarn.lock"));
+  }
+  if (existsSync15(yarnrc)) {
+    rmSync3(yarnrc);
+    console.log(chalk27.gray("  Deleted .yarnrc.yml"));
+  }
+  if (existsSync15(yarnDir)) {
+    rmSync3(yarnDir, { force: true, recursive: true });
+    console.log(chalk27.gray("  Deleted .yarn/"));
+  }
+}
+function createNpmrc(cwd) {
+  const npmrcPath = PATH16.join(cwd, ".npmrc");
+  if (existsSync15(npmrcPath)) return;
+  mkdirSync5(PATH16.dirname(npmrcPath), { recursive: true });
+  writeFileSync12(npmrcPath, "", "utf8");
+  console.log(chalk27.green("  Created .npmrc"));
+}
+function convertToPnpm(cwd, workspacePackageJsonPaths) {
+  console.log(chalk27.blue("\nConverting to pnpm...\n"));
+  const workspacePatterns = updateRootPackageJson(cwd);
+  createPnpmWorkspaceYaml(cwd, workspacePatterns);
+  for (const pkgPath of workspacePackageJsonPaths) {
+    const fullPath = PATH16.resolve(cwd, pkgPath, "package.json");
+    if (!existsSync15(fullPath)) continue;
+    const pkg = JSON.parse(readFileSync17(fullPath, "utf8"));
+    const updated = rewriteScriptsInPackageJson(pkg, "yarn-to-pnpm");
+    if (JSON.stringify(pkg) !== JSON.stringify(updated)) {
+      writeFileSync12(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    }
+  }
+  console.log(chalk27.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
+  updateGitignore(cwd);
+  createNpmrc(cwd);
+  swapTsScriptsDependency(cwd, workspacePackageJsonPaths, "yarn-to-pnpm");
+  rewriteSourceImports(cwd, "yarn-to-pnpm");
+  deleteYarnArtifacts(cwd);
+  console.log(chalk27.blue("\nRunning pnpm install..."));
+  const install = spawnSync5("pnpm", ["install"], {
+    cwd,
+    encoding: "utf8",
+    shell: true,
+    stdio: "inherit"
+  });
+  if (install.status !== 0) {
+    console.error(chalk27.red("pnpm install failed"));
+    return 1;
+  }
+  console.log(chalk27.blue("\nConversion complete.\n"));
+  return 0;
+}
+
+// src/actions/packman/convertToYarn.ts
+import { spawnSync as spawnSync6 } from "child_process";
+import {
+  existsSync as existsSync16,
+  readFileSync as readFileSync18,
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync13
+} from "fs";
+import PATH17 from "path";
+import chalk28 from "chalk";
+var YARN_VERSION = "4.13.0";
+var YARNRC_TEMPLATE = `compressionLevel: mixed
+
+enableGlobalCache: true
+
+enableInlineBuilds: true
+
+nmHoistingLimits: none
+
+nodeLinker: node-modules
+`;
+var YARN_GITIGNORE_ENTRIES = `
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+`;
+function readPnpmWorkspacePatterns2(cwd) {
+  const wsPath = PATH17.join(cwd, "pnpm-workspace.yaml");
+  if (!existsSync16(wsPath)) return [];
+  const content = readFileSync18(wsPath, "utf8");
+  const patterns = [];
+  const lines = content.split("\n");
+  let inPackages = false;
+  for (const line of lines) {
+    if (line.trim() === "packages:") {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages && /^\s+-\s+/.test(line)) {
+      const pattern = line.replace(/^\s+-\s+/, "").replaceAll(/['"]/g, "").trim();
+      if (pattern) patterns.push(pattern);
+    } else if (inPackages && !/^\s/.test(line) && line.trim()) {
+      inPackages = false;
+    }
+  }
+  return patterns;
+}
+function updateRootPackageJson2(cwd, workspacePatterns) {
+  const pkgPath = PATH17.join(cwd, "package.json");
+  const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
+  pkg.workspaces = workspacePatterns;
+  pkg.packageManager = `yarn@${YARN_VERSION}`;
+  const updated = rewriteScriptsInPackageJson(pkg, "pnpm-to-yarn");
+  writeFileSync13(pkgPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+  console.log(chalk28.green("  Updated root package.json"));
+}
+function updateGitignore2(cwd) {
+  const gitignorePath = PATH17.join(cwd, ".gitignore");
+  let content = existsSync16(gitignorePath) ? readFileSync18(gitignorePath, "utf8") : "";
+  if (!content.includes(".yarn/*")) {
+    content = content.trimEnd() + "\n" + YARN_GITIGNORE_ENTRIES;
+  }
+  writeFileSync13(gitignorePath, content, "utf8");
+  console.log(chalk28.green("  Updated .gitignore"));
+}
+function deletePnpmArtifacts(cwd) {
+  const lockfile = PATH17.join(cwd, "pnpm-lock.yaml");
+  const workspaceYaml = PATH17.join(cwd, "pnpm-workspace.yaml");
+  const npmrc = PATH17.join(cwd, ".npmrc");
+  if (existsSync16(lockfile)) {
+    rmSync4(lockfile);
+    console.log(chalk28.gray("  Deleted pnpm-lock.yaml"));
+  }
+  if (existsSync16(workspaceYaml)) {
+    rmSync4(workspaceYaml);
+    console.log(chalk28.gray("  Deleted pnpm-workspace.yaml"));
+  }
+  if (existsSync16(npmrc)) {
+    const content = readFileSync18(npmrc, "utf8");
+    if (content.trim() === "" || content.includes("shamefully-hoist") || content.includes("node-linker")) {
+      rmSync4(npmrc);
+      console.log(chalk28.gray("  Deleted .npmrc"));
+    }
+  }
+}
+function createYarnrc(cwd) {
+  const yarnrcPath = PATH17.join(cwd, ".yarnrc.yml");
+  if (existsSync16(yarnrcPath)) return;
+  writeFileSync13(yarnrcPath, YARNRC_TEMPLATE, "utf8");
+  console.log(chalk28.green("  Created .yarnrc.yml"));
+}
+function readWorkspacePatternsFromPackageJson(cwd) {
+  const pkgPath = PATH17.join(cwd, "package.json");
+  if (!existsSync16(pkgPath)) return [];
+  const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
+  return pkg.workspaces ?? [];
+}
+function convertToYarn(cwd, workspacePackageJsonPaths) {
+  console.log(chalk28.blue("\nConverting to yarn...\n"));
+  const workspacePatterns = readPnpmWorkspacePatterns2(cwd);
+  if (workspacePatterns.length === 0) {
+    const fromPkg = readWorkspacePatternsFromPackageJson(cwd);
+    if (fromPkg.length > 0) {
+      workspacePatterns.push(...fromPkg);
+    } else {
+      console.warn(chalk28.yellow("  No workspace patterns found"));
+    }
+  }
+  updateRootPackageJson2(cwd, workspacePatterns);
+  for (const pkgPath of workspacePackageJsonPaths) {
+    const fullPath = PATH17.resolve(cwd, pkgPath, "package.json");
+    if (!existsSync16(fullPath)) continue;
+    const pkg = JSON.parse(readFileSync18(fullPath, "utf8"));
+    const updated = rewriteScriptsInPackageJson(pkg, "pnpm-to-yarn");
+    if (JSON.stringify(pkg) !== JSON.stringify(updated)) {
+      writeFileSync13(fullPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    }
+  }
+  console.log(chalk28.green(`  Rewrote scripts in ${workspacePackageJsonPaths.length} workspace package(s)`));
+  updateGitignore2(cwd);
+  createYarnrc(cwd);
+  swapTsScriptsDependency(cwd, workspacePackageJsonPaths, "pnpm-to-yarn");
+  rewriteSourceImports(cwd, "pnpm-to-yarn");
+  deletePnpmArtifacts(cwd);
+  console.log(chalk28.blue("\nRunning yarn install..."));
+  const install = spawnSync6("yarn", ["install"], {
+    cwd,
+    encoding: "utf8",
+    shell: true,
+    stdio: "inherit"
+  });
+  if (install.status !== 0) {
+    console.error(chalk28.red("yarn install failed"));
+    return 1;
+  }
+  console.log(chalk28.blue("\nConversion complete.\n"));
+  return 0;
+}
+
+// src/actions/packman/convert.ts
+function detectCurrentPM(cwd) {
+  if (existsSync17(PATH18.join(cwd, "pnpm-lock.yaml")) || existsSync17(PATH18.join(cwd, "pnpm-workspace.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync17(PATH18.join(cwd, "yarn.lock")) || existsSync17(PATH18.join(cwd, ".yarnrc.yml"))) {
+    return "yarn";
+  }
+  return "unknown";
+}
+function findWorkspacePackagePaths(cwd) {
+  const pkgPath = PATH18.join(cwd, "package.json");
+  const pkg = JSON.parse(readFileSync19(pkgPath, "utf8"));
+  const patterns = pkg.workspaces ?? [];
+  if (patterns.length === 0) {
+    const wsPath = PATH18.join(cwd, "pnpm-workspace.yaml");
+    if (existsSync17(wsPath)) {
+      const content = readFileSync19(wsPath, "utf8");
+      const lines = content.split("\n");
+      let inPackages = false;
+      for (const line of lines) {
+        if (line.trim() === "packages:") {
+          inPackages = true;
+          continue;
+        }
+        if (inPackages && /^\s+-\s+/.test(line)) {
+          const pattern = line.replace(/^\s+-\s+/, "").replaceAll(/['"]/g, "").trim();
+          if (pattern) patterns.push(pattern);
+        } else if (inPackages && !/^\s/.test(line) && line.trim()) {
+          inPackages = false;
+        }
+      }
+    }
+  }
+  const dirs = [];
+  for (const pattern of patterns) {
+    const resolved = resolveWorkspaceGlob(cwd, pattern);
+    dirs.push(...resolved);
+  }
+  return dirs;
+}
+function resolveWorkspaceGlob(cwd, pattern) {
+  const parts = pattern.split("/");
+  return walkGlob(cwd, parts, "");
+}
+function walkGlob(basePath, parts, currentPath) {
+  if (parts.length === 0) {
+    const fullPath = PATH18.join(basePath, currentPath);
+    if (existsSync17(PATH18.join(fullPath, "package.json"))) {
+      return [currentPath];
+    }
+    return [];
+  }
+  const [part, ...rest] = parts;
+  const dirPath = PATH18.join(basePath, currentPath);
+  if (!existsSync17(dirPath) || !statSync4(dirPath).isDirectory()) {
+    return [];
+  }
+  if (part === "*" || part === "**") {
+    const entries = readdirSync8(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(chalk29.red(`Invalid target "${target}". Must be one of: ${validTargets.join(", ")}`));
+    return 1;
+  }
+  const cwd = process.cwd();
+  const currentPM = detectCurrentPM(cwd);
+  if (verbose) {
+    console.log(chalk29.gray(`Current package manager: ${currentPM}`));
+    console.log(chalk29.gray(`Target package manager: ${target}`));
+  }
+  if (currentPM === target) {
+    console.log(chalk29.yellow(`Already using ${target}. Re-applying conversion to fix any incomplete steps...`));
+  }
+  if (currentPM === "unknown") {
+    console.error(chalk29.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
+    return 1;
+  }
+  const workspacePaths = findWorkspacePackagePaths(cwd);
+  if (verbose) {
+    console.log(chalk29.gray(`Found ${workspacePaths.length} workspace packages`));
+  }
+  const result = target === "pnpm" ? convertToPnpm(cwd, workspacePaths) : convertToYarn(cwd, workspacePaths);
+  if (result !== 0) return result;
+  console.log(chalk29.green("\nRunning repo lint --fix..."));
+  packageLintMonorepo(true);
+  return result;
+}
+
+// src/actions/packman/clean.ts
+function removeNodeModules(dir, verbose) {
+  const nmPath = PATH19.join(dir, "node_modules");
+  if (existsSync18(nmPath)) {
+    if (verbose) console.log(chalk30.gray(`Removing ${nmPath}`));
+    rmSync5(nmPath, { force: true, recursive: true });
+    return true;
+  }
+  return false;
+}
+function packmanClean({ verbose }) {
+  const cwd = process.cwd();
+  const pm = detectCurrentPM(cwd);
+  if (pm === "unknown") {
+    console.error(chalk30.red("Could not detect current package manager. No yarn.lock or pnpm-lock.yaml found."));
+    return 1;
+  }
+  console.log(chalk30.blue(`Detected package manager: ${pm}`));
+  let removedCount = 0;
+  if (removeNodeModules(cwd, verbose)) removedCount++;
+  const workspacePaths = findWorkspacePackagePaths(cwd);
+  for (const wsPath of workspacePaths) {
+    const fullPath = PATH19.join(cwd, wsPath);
+    if (removeNodeModules(fullPath, verbose)) removedCount++;
+  }
+  console.log(chalk30.green(`Removed ${removedCount} node_modules folder${removedCount === 1 ? "" : "s"}`));
+  if (pm === "yarn") {
+    const lockPath = PATH19.join(cwd, "yarn.lock");
+    if (existsSync18(lockPath)) {
+      writeFileSync14(lockPath, "");
+      console.log(chalk30.green("Truncated yarn.lock"));
+    }
+  } else if (pm === "pnpm") {
+    const lockPath = PATH19.join(cwd, "pnpm-lock.yaml");
+    if (existsSync18(lockPath)) {
+      rmSync5(lockPath);
+      console.log(chalk30.green("Deleted pnpm-lock.yaml"));
+    }
+  }
+  console.log(chalk30.green("Ready for a clean install"));
+  return 0;
+}
+
+// src/actions/packman/lint.ts
+import {
+  existsSync as existsSync19,
+  readFileSync as readFileSync20,
+  writeFileSync as writeFileSync15
+} from "fs";
+import PATH20 from "path";
+import chalk31 from "chalk";
+function checkEnableScripts(cwd, verbose, silent) {
+  const yarnrcPath = PATH20.join(cwd, ".yarnrc.yml");
+  if (!existsSync19(yarnrcPath)) {
+    if (verbose) console.log(chalk31.gray("  No .yarnrc.yml found, skipping enableScripts check"));
+    return true;
+  }
+  const content = readFileSync20(yarnrcPath, "utf8");
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^enableScripts\s*:/.test(trimmed)) {
+      const value = trimmed.replace(/^enableScripts\s*:\s*/, "").trim();
+      if (value === "false") {
+        if (verbose) console.log(chalk31.green("  enableScripts is correctly set to false"));
+        return true;
+      }
+      if (!silent) console.log(chalk31.red("  enableScripts is set to", value, "(expected false)"));
+      return false;
+    }
+  }
+  if (!silent) console.log(chalk31.red("  enableScripts is not set in .yarnrc.yml (expected false)"));
+  return false;
+}
+function fixEnableScripts(cwd, verbose) {
+  const yarnrcPath = PATH20.join(cwd, ".yarnrc.yml");
+  if (!existsSync19(yarnrcPath)) {
+    if (verbose) console.log(chalk31.gray("  No .yarnrc.yml found, skipping enableScripts fix"));
+    return true;
+  }
+  const content = readFileSync20(yarnrcPath, "utf8");
+  const lines = content.split("\n");
+  let found = false;
+  const newLines = lines.map((line) => {
+    if (/^\s*enableScripts\s*:/.test(line)) {
+      found = true;
+      return "enableScripts: false";
+    }
+    return line;
+  });
+  if (!found) {
+    let inserted = false;
+    for (let i = 0; i < newLines.length; i++) {
+      const trimmed = newLines[i].trim();
+      if (trimmed && !trimmed.startsWith("#") && trimmed > "enableScripts:") {
+        newLines.splice(i, 0, "enableScripts: false", "");
+        inserted = true;
+        break;
+      }
+    }
+    if (!inserted) {
+      const lastLine = newLines.at(-1);
+      if (lastLine === "") {
+        newLines.splice(-1, 0, "enableScripts: false", "");
+      } else {
+        newLines.push("", "enableScripts: false");
+      }
+    }
+  }
+  writeFileSync15(yarnrcPath, newLines.join("\n"), "utf8");
+  console.log(chalk31.green("  Fixed: enableScripts set to false"));
+  return true;
+}
+var checks = [
+  {
+    name: "enableScripts should be false in .yarnrc.yml",
+    check: checkEnableScripts,
+    fix: fixEnableScripts
+  }
+];
+function packmanLint({ fix, verbose } = {}) {
+  const cwd = process.cwd();
+  let failures = 0;
+  for (const check of checks) {
+    if (verbose) console.log(chalk31.gray(`Checking: ${check.name}`));
+    const passed = check.check(cwd, verbose, fix);
+    if (!passed) {
+      if (fix) {
+        const fixed = check.fix(cwd, verbose);
+        if (!fixed) {
+          failures++;
+        }
+      } else {
+        failures++;
+      }
+    }
+  }
+  if (failures > 0) {
+    console.log(chalk31.red(`
+packman lint: ${failures} check(s) failed`));
+    if (!fix) {
+      console.log(chalk31.yellow("Run with --fix to auto-fix issues"));
+    }
+  } else {
+    console.log(chalk31.green("\npackman lint: all checks passed"));
+  }
+  return failures > 0 ? 1 : 0;
+}
+
+// src/actions/publint.ts
+import chalk32 from "chalk";
+function resolveExclude(publintConfig, cliExclude, cliInclude) {
+  const hasExclude = (publintConfig.exclude?.length ?? 0) > 0 || (cliExclude?.length ?? 0) > 0;
+  const hasInclude = (publintConfig.include?.length ?? 0) > 0 || (cliInclude?.length ?? 0) > 0;
+  if (hasExclude && hasInclude) {
+    console.error(chalk32.red("Publint: --include and --exclude cannot be used together"));
+    return void 0;
+  }
+  if (hasInclude) {
+    const include = /* @__PURE__ */ new Set([
+      ...publintConfig.include ?? [],
+      ...cliInclude ?? []
+    ]);
+    return new Set(ALL_PUBLINT_CHECKS.filter((c) => !include.has(c)));
+  }
+  return /* @__PURE__ */ new Set([
+    ...publintConfig.exclude ?? [],
+    ...cliExclude ?? []
+  ]);
+}
+function normalizePublintConfig(value) {
+  if (typeof value === "object") return value;
+  return {};
+}
+var publint = async ({
+  cliExclude,
+  cliInclude,
+  fix,
+  jobs,
+  pack,
+  verbose,
+  pkg
+}) => {
+  return pkg === void 0 ? await publintAll({
+    cliExclude,
+    cliInclude,
+    fix,
+    jobs,
+    pack,
+    verbose
+  }) : await publintSingle({
+    cliExclude,
+    cliInclude,
+    fix,
+    pack,
+    pkg,
+    verbose
+  });
+};
+function logPublintSummary(packages, errors, ms) {
+  const color = errors > 0 ? chalk32.red : chalk32.blue;
+  console.log(color(`Checked ${packages} package(s) in ${ms.toFixed(0)}ms with ${errors} issue(s) found.`));
+}
+var publintSingle = async ({
+  cliExclude,
+  cliInclude,
+  fix,
+  pack,
+  pkg,
+  verbose
+}) => {
+  const start = performance.now();
+  const pm = getPackageManager();
+  const workspace = pm.findWorkspace(pkg);
+  if (!workspace) {
+    console.error(chalk32.red(`Publint: workspace "${pkg}" not found`));
+    return 1;
+  }
+  const wsPublintConfig = normalizePublintConfig(
+    await loadWorkspaceCommandConfig(workspace.location, "publint")
+  );
+  const exclude = resolveExclude(wsPublintConfig, cliExclude, cliInclude);
+  if (!exclude) return 1;
+  const shouldPack = pack ?? wsPublintConfig.pack ?? true;
+  const errors = await packagePublint({
+    exclude,
+    fix,
+    pack: shouldPack,
+    pkgDir: workspace.location,
+    verbose
+  });
+  logPublintSummary(1, errors, performance.now() - start);
+  return errors;
+};
+var publintAll = async ({
+  cliExclude,
+  cliInclude,
+  fix,
+  jobs,
+  pack,
+  verbose
+}) => {
+  const start = performance.now();
+  const pm = getPackageManager();
+  const workspaces = pm.listWorkspaces();
+  const concurrency = jobs;
+  const results = Array.from({ length: workspaces.length }, () => ({ errors: 0, output: [] }));
+  installOutputCapture();
+  await runWithConcurrency(
+    workspaces.map((ws, i) => ({ i, ws })),
+    concurrency,
+    async ({ i, ws }) => {
+      const output = [];
+      await outputStorage.run(output, async () => {
+        try {
+          const wsPublintConfig = normalizePublintConfig(
+            await loadWorkspaceCommandConfig(ws.location, "publint")
+          );
+          const exclude = resolveExclude(wsPublintConfig, cliExclude, cliInclude) ?? /* @__PURE__ */ new Set();
+          const shouldPack = pack ?? wsPublintConfig.pack ?? true;
+          const errors = await packagePublint({
+            exclude,
+            fix,
+            pack: shouldPack,
+            pkgDir: ws.location,
+            verbose
+          });
+          results[i] = { errors, output };
+        } catch (ex) {
+          output.push(chalk32.red(`Publint failed for ${ws.name}: ${ex.message}
+`));
+          results[i] = { errors: 1, output };
+        }
+      });
+    }
+  );
+  let totalErrors = 0;
+  for (const { errors, output } of results) {
+    for (const line of output) {
+      process.stdout.write(line);
+    }
+    totalErrors += errors;
+  }
+  const allExclude = resolveExclude({}, cliExclude, cliInclude) ?? /* @__PURE__ */ new Set();
+  if (!allExclude.has("peerDeps")) {
+    const cwd = INIT_CWD();
+    const peerResult = checkInternalPeerVersions(cwd, workspaces);
+    if (peerResult.fixable.length > 0) {
+      if (fix) {
+        fixInternalPeerVersions(cwd, workspaces);
+        runInstall();
+      } else {
+        for (const msg of peerResult.fixable) {
+          console.log(chalk32.red(`  \u2717 ${msg} (fixable)`));
+        }
+        totalErrors += peerResult.fixable.length;
+      }
+    }
+    totalErrors += peerResult.errors.length;
+  }
+  logPublintSummary(workspaces.length, totalErrors, performance.now() - start);
+  return totalErrors;
+};
+
+// src/actions/readme-gen.ts
+async function readmeGen({
+  jobs,
+  pkg,
+  templatePath,
+  typedoc,
+  verbose
+}) {
+  const config2 = await loadConfig();
+  return await generateReadmeFiles({
+    jobs,
+    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/readme-lint.ts
+import { existsSync as existsSync20, readFileSync as readFileSync21 } from "fs";
+import PATH21 from "path";
+import chalk33 from "chalk";
+function lintTemplate(cwd) {
+  const result = { errors: [], warnings: [] };
+  const templatePath = resolveTemplatePath();
+  if (!existsSync20(templatePath)) {
+    result.errors.push('Missing .xy/README.template.md (run "xy readme init" to create)');
+    return result;
+  }
+  const template = readFileSync21(templatePath, "utf8");
+  if (!template.includes("{{body}}")) {
+    result.warnings.push(".xy/README.template.md does not contain a {{body}} placeholder");
+  }
+  if (!template.includes("{{description}}")) {
+    result.warnings.push(".xy/README.template.md does not contain a {{description}} placeholder");
+  }
+  const bodyPath = PATH21.join(cwd, ".xy", "README.body.md");
+  if (!existsSync20(bodyPath)) {
+    result.errors.push('Missing .xy/README.body.md (run "xy readme init" to create)');
+  }
+  return result;
+}
+function lintLogoConfig(cwd, config2) {
+  const result = { errors: [], warnings: [] };
+  const templatePath = resolveTemplatePath();
+  if (existsSync20(templatePath)) {
+    const template = readFileSync21(templatePath, "utf8");
+    const logoRef = /\[logo]: (.+)/.exec(template);
+    if (logoRef?.[1].includes("example.com")) {
+      result.warnings.push(".xy/README.template.md still has the example.com logo placeholder \u2014 update it or set readme.logoUrl in xy.config.ts");
+    } else if (!logoRef && !config2.readme?.logoUrl) {
+      result.warnings.push("No logo URL configured in xy.config.ts (readme.logoUrl) or template");
+    }
+  }
+  if (!config2.readme?.logoUrl && !config2.readme?.logoLinkUrl) {
+    result.warnings.push("No readme.logoUrl or readme.logoLinkUrl configured in xy.config.ts");
+  }
+  return result;
+}
+function lintPackages(cwd) {
+  const result = { errors: [], warnings: [] };
+  const pm = getPackageManager();
+  const workspaces = pm.listWorkspaces();
+  for (const { location, name } of workspaces) {
+    if (location === ".") continue;
+    const pkgPath = PATH21.join(cwd, location, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync21(pkgPath, "utf8"));
+      if (pkg.private) continue;
+      if (!pkg.description) {
+        result.warnings.push(`${name} is missing a "description" in package.json`);
+      }
+      const readmePath = PATH21.join(cwd, location, "README.md");
+      if (!existsSync20(readmePath)) {
+        result.errors.push(`${name} is missing README.md`);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function readmeLint({ config: config2, verbose }) {
+  const cwd = INIT_CWD();
+  console.log(chalk33.green("Readme Lint"));
+  const checks2 = [
+    lintTemplate(cwd),
+    lintLogoConfig(cwd, config2),
+    lintPackages(cwd)
+  ];
+  let errorCount = 0;
+  let warningCount = 0;
+  for (const { errors, warnings } of checks2) {
+    for (const error of errors) {
+      console.log(chalk33.red(`  \u2717 ${error}`));
+      errorCount++;
+    }
+    for (const warning of warnings) {
+      console.log(chalk33.yellow(`  \u26A0 ${warning}`));
+      warningCount++;
+    }
+  }
+  if (errorCount === 0 && warningCount === 0) {
+    console.log(chalk33.green("  All checks passed"));
+  } else {
+    if (verbose) {
+      console.log(chalk33.gray(`  ${errorCount} error(s), ${warningCount} warning(s)`));
+    }
+  }
+  return errorCount > 0 ? 1 : 0;
+}
+
+// src/actions/repo-init.ts
+import { spawnSync as spawnSync7 } from "child_process";
+import {
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync9,
+  readFileSync as readFileSync22,
+  writeFileSync as writeFileSync16
+} from "fs";
+import { createRequire as createRequire5 } from "module";
+import PATH22 from "path";
+import { createInterface as createInterface4 } from "readline";
+import chalk34 from "chalk";
+function askQuestion(question) {
+  const rl = createInterface4({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function getConfigVersion() {
+  const require6 = createRequire5(import.meta.url);
+  const pkgPath = require6.resolve("@xylabs/ts-scripts-common/package.json");
+  const pkg = JSON.parse(readFileSync22(pkgPath, "utf8"));
+  return pkg.version.replace(/\.\d+$/, "");
+}
+function mapOutputPath(relativePath, variables) {
+  let result = relativePath;
+  if (result.endsWith(".tmpl")) {
+    result = result.slice(0, -5);
+  }
+  if (result === "gitignore") {
+    result = ".gitignore";
+  }
+  if (result.startsWith("github/")) {
+    result = `.${result}`;
+  }
+  result = result.replaceAll("__packageName__", variables.packageName);
+  return result;
+}
+function isPmSpecificFile(relativePath, pm) {
+  if (relativePath === "pnpm-workspace.yaml" && pm === "yarn") return true;
+  if (relativePath.includes("build-pnpm") && pm !== "pnpm") return true;
+  if (relativePath.includes("build-yarn") && pm !== "yarn") return true;
+  return false;
+}
+function mapBuildWorkflowName(outputPath) {
+  return outputPath.replace(/build-(pnpm|yarn)\.yml/, "build.yml");
+}
+function buildVariables(params) {
+  const {
+    description,
+    githubOrg,
+    packageName: packageName2,
+    pm,
+    projectName,
+    scope
+  } = params;
+  const identifierName = packageName2.replaceAll(/-([a-z])/g, (_, c) => c.toUpperCase());
+  const pmPackage = pm === "pnpm" ? "@xylabs/ts-scripts-pnpm" : "@xylabs/ts-scripts-yarn3";
+  return {
+    configVersion: getConfigVersion(),
+    description,
+    githubOrg,
+    identifierName,
+    npmScope: scope,
+    packageName: packageName2,
+    pmName: pm,
+    pmPackage,
+    projectName
+  };
+}
+function ensureEmptyDir(projectDir, name) {
+  if (existsSync21(projectDir)) {
+    const entries = readdirSync9(projectDir);
+    if (entries.length > 0) {
+      console.error(chalk34.red(`Directory '${name}' already exists and is not empty`));
+      return false;
+    }
+  }
+  mkdirSync6(projectDir, { recursive: true });
+  return true;
+}
+function scaffoldFiles(templateName, layer, outputDir, pm, variables, verbose) {
+  const files = loadRepoTemplateFiles(templateName, layer);
+  let count = 0;
+  for (const file of files) {
+    if (isPmSpecificFile(file.relativePath, pm)) continue;
+    const content = fillTemplate(file.content, variables);
+    let outputPath = mapOutputPath(file.relativePath, variables);
+    if (!outputPath) continue;
+    if (layer === "root") outputPath = mapBuildWorkflowName(outputPath);
+    const fullPath = PATH22.resolve(outputDir, outputPath);
+    mkdirSync6(PATH22.dirname(fullPath), { recursive: true });
+    writeFileSync16(fullPath, content);
+    count++;
+    if (verbose) console.log(chalk34.gray(`  ${layer === "root" ? outputPath : `packages/${variables.packageName}/${outputPath}`}`));
+  }
+  return count;
+}
+function initGitRepo(projectDir, verbose) {
+  if (verbose) console.log(chalk34.gray("Initializing git repository..."));
+  const result = spawnSync7("git", ["init", "-b", "main"], {
+    cwd: projectDir,
+    stdio: verbose ? "inherit" : "pipe"
+  });
+  if (result.status === 0) {
+    console.log(chalk34.green("Initialized git repository"));
+  } else {
+    console.warn(chalk34.yellow("git init failed, skipping"));
+  }
+}
+function installDependencies(projectDir, pm) {
+  console.log(chalk34.gray(`Running ${pm} install...`));
+  const result = spawnSync7(pm, ["install"], {
+    cwd: projectDir,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    console.warn(chalk34.yellow(`${pm} install failed`));
+    return false;
+  }
+  console.log(chalk34.green("Dependencies installed"));
+  return true;
+}
+async function repoInit(params) {
+  const {
+    description,
+    pm,
+    scope,
+    skipGit,
+    skipInstall,
+    template,
+    verbose
+  } = params;
+  let name = params.name;
+  if (!name) {
+    name = await askQuestion(chalk34.cyan("Project name: "));
+    if (!name) {
+      console.error(chalk34.red("Project name is required"));
+      return 1;
+    }
+  }
+  const projectName = PATH22.basename(name);
+  const packageName2 = params.packageName ?? projectName;
+  const githubOrg = params.githubOrg ?? scope.replace(/^@/, "");
+  const variables = buildVariables({
+    description,
+    githubOrg,
+    packageName: packageName2,
+    pm,
+    projectName,
+    scope
+  });
+  if (verbose) {
+    console.log(chalk34.gray("Template variables:"));
+    for (const [key, value] of Object.entries(variables)) {
+      console.log(chalk34.gray(`  ${key}: ${value}`));
+    }
+  }
+  const projectDir = PATH22.resolve(process.cwd(), name);
+  if (!ensureEmptyDir(projectDir, name)) return 1;
+  const rootCount = scaffoldFiles(template, "root", projectDir, pm, variables, verbose);
+  const pkgDir = PATH22.resolve(projectDir, "packages", packageName2);
+  const pkgCount = scaffoldFiles(template, "package", pkgDir, pm, variables, verbose);
+  console.log(chalk34.green(`Scaffolded ${rootCount + pkgCount} files into ${name}/`));
+  if (!skipGit) initGitRepo(projectDir, verbose);
+  if (!skipInstall && !installDependencies(projectDir, pm)) return 1;
+  console.log("");
+  console.log(chalk34.cyan(`Project ${name} created successfully!`));
+  console.log("");
+  console.log(chalk34.gray("Next steps:"));
+  console.log(chalk34.gray(`  cd ${name}`));
+  if (skipInstall) console.log(chalk34.gray(`  ${pm} install`));
+  console.log(chalk34.gray(`  ${pm} xy build`));
+  return 0;
+}
+
+// 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 path5 = target ?? ".";
+  return runSteps("Re-Test", [
+    ["vitest", ["--clearCache"]],
+    ["vitest", [path5]]
+  ]);
+};
+
+// src/actions/test.ts
+var test = ({ target } = {}) => {
+  const pm = getPackageManager();
+  if (target && pm.findWorkspace(target)) {
+    return runSteps(`Test [${target}]`, [pm.runInWorkspace(target, "vitest", ["."])]);
+  }
+  const path5 = target ?? ".";
+  return runSteps("Test", [["vitest", [path5]]]);
+};
+
+// src/xy/common/checkCommand.ts
+var checkCommand = {
+  command: "check",
+  describe: "Check - Run gitlint, publint, repo lint, lintlint, and readme lint",
+  builder: (yargs) => {
+    return yargs.option("fix", {
+      default: false,
+      description: "Auto-fix fixable issues",
+      type: "boolean"
+    });
+  },
+  handler: async (argv) => {
+    const verbose = !!argv.verbose;
+    const fix = !!argv.fix;
+    const jobs = argv.jobs;
+    let errors = 0;
+    if (verbose) console.log("Check");
+    console.log(chalk35.blue("\n\u2014 gitlint \u2014"));
+    errors += fix ? gitlintFix() : gitlint();
+    console.log(chalk35.blue("\n\u2014 publint \u2014"));
+    errors += await publint({
+      fix,
+      jobs,
+      verbose
+    });
+    console.log(chalk35.blue("\n\u2014 repo lint \u2014"));
+    errors += packageLintMonorepo(fix);
+    console.log(chalk35.blue("\n\u2014 lintlint \u2014"));
+    errors += await lintlint({ fix, verbose });
+    console.log(chalk35.blue("\n\u2014 readme lint \u2014"));
+    const config2 = await loadConfig();
+    errors += readmeLint({ config: config2, verbose });
+    if (errors > 0) {
+      console.log(chalk35.red(`${errors} issue(s) found`));
+    } else {
+      console.log(chalk35.green("All checks passed"));
+    }
+    process.exitCode = errors > 0 ? 1 : 0;
+  }
+};
+
+// src/xy/common/claude/checkCommand.ts
+var checkCommand2 = {
+  command: "check",
+  describe: "Check if Claude configuration is up to date with templates",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Check");
+    process.exitCode = claudeCheck();
+  }
+};
+
+// src/xy/common/claude/cleanCommand.ts
+var cleanCommand = {
+  command: "clean",
+  describe: "Remove all Claude configuration files from the repo",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Clean");
+    process.exitCode = claudeClean();
+  }
+};
+
+// src/xy/common/claude/commandsCommand.ts
+var commandsCommand = {
+  command: "commands",
+  describe: "Sync XY Labs standard Claude slash commands to .claude/commands/",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Commands");
+    process.exitCode = claudeCommands();
+  }
+};
+
+// src/xy/common/claude/initCommand.ts
+var initCommand = {
+  builder: (yargs) => {
+    return yargs.option("force", {
+      alias: "f",
+      default: false,
+      description: "Overwrite existing CLAUDE.md",
+      type: "boolean"
+    }).option("level", {
+      choices: ["restrictive", "permissive"],
+      default: "permissive",
+      description: "Permission level for settings (restrictive omits node, python3, claude, sed, xargs, tee)",
+      type: "string"
+    });
+  },
+  command: "init",
+  describe: "Initialize all Claude configuration (commands, rules, skills, settings)",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Claude Init");
+    const commandsResult = claudeCommands();
+    const rulesResult = claudeRules({ force: argv.force });
+    const skillsResult = claudeSkills();
+    const settingsResult = await claudeSettings({ level: argv.level });
+    process.exitCode = commandsResult || rulesResult || skillsResult || settingsResult;
+  }
+};
+
+// src/xy/common/claude/rulesCommand.ts
+var rulesCommand = {
+  builder: (yargs) => {
+    return yargs.option("force", {
+      alias: "f",
+      default: false,
+      description: "Overwrite existing CLAUDE.md",
+      type: "boolean"
+    });
+  },
+  command: "rules",
+  describe: "Sync XY Labs standard Claude rules to .claude/rules/",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Rules");
+    process.exitCode = claudeRules({ force: argv.force });
+  }
+};
+
+// src/xy/common/claude/settingsCommand.ts
+var settingsCommand = {
+  builder: (yargs) => {
+    return yargs.option("level", {
+      choices: ["restrictive", "permissive"],
+      default: "permissive",
+      description: "Permission level (restrictive omits node, python3, claude, sed, xargs, tee)",
+      type: "string"
+    });
+  },
+  command: "settings",
+  describe: "Initialize .claude/settings.local.json with XY Labs defaults",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Claude Settings");
+    process.exitCode = await claudeSettings({ level: argv.level });
+  }
+};
+
+// src/xy/common/claude/skillsCommand.ts
+var skillsCommand = {
+  builder: (yargs) => yargs,
+  command: "skills",
+  describe: "Sync XY Labs standard Claude skills to .claude/skills/",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Skills");
+    process.exitCode = claudeSkills();
+  }
+};
+
+// src/xy/common/claude/index.ts
+var claudeCommand = {
+  builder: (yargs) => {
+    return yargs.command(checkCommand2).command(cleanCommand).command(commandsCommand).command(initCommand).command(rulesCommand).command(settingsCommand).command(skillsCommand).demandCommand(1, "Please specify a claude subcommand").strictCommands();
+  },
+  command: "claude",
+  describe: "Claude - Claude Code configuration utilities",
+  handler: () => {
+  }
+};
+
+// src/xy/common/cleanDocsCommand.ts
+var cleanDocsCommand = {
+  command: "clean-docs",
+  describe: "CleanDocs - Clean TypeDocs",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Cleaning TypeDocs: all");
+    process.exitCode = cleanDocs();
+  }
+};
+
+// src/xy/param.ts
+var packagePositionalParam = (yargs) => {
+  return yargs.positional("package", { describe: "Specific package to target", type: "string" });
+};
+
+// src/xy/common/deadCommand.ts
+var deadCommand = {
+  builder: (yargs) => {
+    return packagePositionalParam(yargs);
+  },
+  command: "dead [package]",
+  describe: "Dead - Check for dead code",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Dead");
+    process.exitCode = dead();
+  }
+};
+
+// src/xy/common/genDocsCommand.ts
+var genDocsCommand = {
+  builder: (yargs) => {
+    return packagePositionalParam(yargs);
+  },
+  command: "gen-docs [package]",
+  describe: "GenDocs - Generate TypeDocs",
+  handler: (argv) => {
+    if (argv.verbose) console.log(`Generating TypeDocs: ${argv.package ?? "all"}`);
+    process.exitCode = genDocs({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package
+    });
+  }
+};
+
+// src/xy/common/gitignoreCommand.ts
+var gitignoreCommand = {
+  command: "gitignore",
+  describe: "GitIgnore - Generate root .gitignore and remove package .gitignore files",
+  handler: (argv) => {
+    if (argv.verbose) console.log("GitIgnore");
+    process.exitCode = gitignore();
+  }
+};
+
+// src/xy/common/gitlintCommand.ts
+var gitlintCommand = {
+  builder: (yargs) => {
+    return yargs.option("fix", {
+      default: false,
+      description: "Auto-fix git config issues",
+      type: "boolean"
+    });
+  },
+  command: "gitlint",
+  describe: "Gitlint - Lint your git config",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Gitlint");
+    process.exitCode = argv.fix ? gitlintFix() : gitlint();
+  }
+};
+
+// src/xy/common/licenseCommand.ts
+var licenseCommand = {
+  builder: (yargs) => {
+    return packagePositionalParam(yargs);
+  },
+  command: "license [package]",
+  describe: "License - Check licenses of dependencies",
+  handler: async (argv) => {
+    if (argv.verbose) console.log(`License: ${argv.package ?? "all"}`);
+    process.exitCode = await license();
+  }
+};
+
+// src/xy/common/npmignoreGenCommand.ts
+var npmignoreGenCommand = {
+  command: "npmignore-gen",
+  describe: "NpmIgnore Gen - Generate .npmignore files",
+  handler: (argv) => {
+    if (argv.verbose) console.log("NpmIgnore Gen");
+    process.exitCode = npmignoreGen();
+  }
+};
+
+// src/xy/common/orphan/cleanCommand.ts
+var cleanCommand2 = {
+  command: "clean",
+  describe: "Remove orphaned directories containing only build artifacts",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Orphan Clean");
+    process.exitCode = orphanClean({ verbose: argv.verbose });
+  }
+};
+
+// src/xy/common/orphan/listCommand.ts
+var listCommand = {
+  command: "list",
+  describe: "List orphaned directories containing only build artifacts",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Orphan List");
+    process.exitCode = orphanList({ verbose: argv.verbose });
+  }
+};
+
+// src/xy/common/orphan/index.ts
+var orphanCommand = {
+  builder: (yargs) => {
+    return yargs.command(listCommand).command(cleanCommand2).demandCommand(1, "Please specify an orphan subcommand").strictCommands();
+  },
+  command: "orphan",
+  describe: "Orphan - Detect and clean orphaned build artifacts",
+  handler: () => {
+  }
+};
+
+// src/xy/common/packmanCommand.ts
+var convertCommand = {
+  command: "convert <target>",
+  describe: "Convert repo to a different package manager (pnpm or yarn)",
+  builder: (yargs) => {
+    return yargs.positional("target", {
+      choices: ["pnpm", "yarn"],
+      describe: "Target package manager",
+      type: "string"
+    });
+  },
+  handler: (argv) => {
+    process.exitCode = convert({
+      target: argv.target,
+      verbose: !!argv.verbose
+    });
+  }
+};
+var cleanCommand3 = {
+  command: "clean",
+  describe: "Remove node_modules and lock files for a clean install",
+  handler: (argv) => {
+    process.exitCode = packmanClean({ verbose: !!argv.verbose });
+  }
+};
+var lintCommand = {
+  command: "lint",
+  describe: "Check package manager configuration settings",
+  builder: (yargs) => {
+    return yargs.option("fix", {
+      alias: "f",
+      default: false,
+      description: "Auto-fix configuration issues",
+      type: "boolean"
+    });
+  },
+  handler: (argv) => {
+    process.exitCode = packmanLint({
+      fix: !!argv.fix,
+      verbose: !!argv.verbose
+    });
+  }
+};
+var packmanCommand = {
+  builder: (yargs) => {
+    return yargs.command(cleanCommand3).command(convertCommand).command(lintCommand).demandCommand(1, "Please specify a packman subcommand").strictCommands();
+  },
+  command: "packman",
+  describe: "Package Manager - Configuration and conversion utilities",
+  handler: () => {
+  }
+};
+
+// src/xy/common/readme/genCommand.ts
+var genCommand = {
+  builder: (yargs) => {
+    return packagePositionalParam(yargs).option("template", {
+      alias: "t",
+      description: "Path to README.template.md",
+      type: "string"
+    }).option("notypedoc", {
+      default: false,
+      description: "Disable TypeDoc reference sections",
+      type: "boolean"
+    });
+  },
+  aliases: ["$0"],
+  command: "gen [package]",
+  describe: "Generate README.md files from template",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Readme Gen");
+    process.exitCode = await readmeGen({
+      jobs: argv.jobs,
+      pkg: argv.package,
+      templatePath: argv.template,
+      typedoc: !argv.notypedoc,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/common/readme/initCommand.ts
+var initCommand2 = {
+  builder: (yargs) => {
+    return yargs.option("template", {
+      alias: "t",
+      description: "Path to README.template.md",
+      type: "string"
+    });
+  },
+  command: "init",
+  describe: "Initialize README template and logo files",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Readme Init");
+    process.exitCode = await readmeInit({
+      templatePath: argv.template,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/common/readme/lintCommand.ts
+var lintCommand2 = {
+  command: "lint",
+  describe: "Check for missing readme templates, body files, logos, and descriptions",
+  handler: async (argv) => {
+    const config2 = await loadConfig();
+    process.exitCode = readmeLint({ config: config2, verbose: !!argv.verbose });
+  }
+};
+
+// src/xy/common/readme/index.ts
+var readmeCommand = {
+  builder: (yargs) => {
+    return yargs.command(genCommand).command(initCommand2).command(lintCommand2).demandCommand(1, "Please specify a readme subcommand").strictCommands();
+  },
+  command: "readme",
+  describe: "Readme - README file utilities",
+  handler: () => {
+  }
+};
+
+// src/xy/common/repo/initCommand.ts
+var initCommand3 = {
+  command: "init <template> [name]",
+  describe: "Scaffold a new monorepo from a template",
+  builder: (yargs) => {
+    return yargs.positional("template", {
+      choices: ["cli"],
+      describe: "Template to use",
+      type: "string"
+    }).positional("name", {
+      describe: "Project name (also used as directory name)",
+      type: "string"
+    }).option("scope", {
+      default: "@xylabs",
+      describe: "npm scope for packages",
+      type: "string"
+    }).option("package", {
+      describe: "Package name within the monorepo (defaults to project name)",
+      type: "string"
+    }).option("description", {
+      default: "",
+      describe: "Project description",
+      type: "string"
+    }).option("github-org", {
+      describe: "GitHub organization (derived from scope if not set)",
+      type: "string"
+    }).option("pm", {
+      choices: ["pnpm", "yarn"],
+      default: "pnpm",
+      describe: "Package manager to configure",
+      type: "string"
+    }).option("skip-install", {
+      default: false,
+      describe: "Skip dependency installation after scaffolding",
+      type: "boolean"
+    }).option("skip-git", {
+      default: false,
+      describe: "Skip git init after scaffolding",
+      type: "boolean"
+    });
+  },
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Repo Init");
+    process.exitCode = await repoInit({
+      description: argv.description,
+      githubOrg: argv["github-org"],
+      name: argv.name,
+      packageName: argv.package,
+      pm: argv.pm,
+      scope: argv.scope,
+      skipGit: !!argv.skipGit,
+      skipInstall: !!argv.skipInstall,
+      template: argv.template,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/common/repo/lintCommand.ts
+var lintCommand3 = {
+  command: "lint",
+  describe: "Check monorepo package structure",
+  builder: (yargs) => {
+    return yargs.option("fix", {
+      default: false,
+      description: "Auto-fix fixable issues",
+      type: "boolean"
+    });
+  },
+  handler: (argv) => {
+    if (argv.verbose) console.log("Repo Lint");
+    process.exitCode = packageLintMonorepo(!!argv.fix);
+  }
+};
+
+// src/xy/common/repo/index.ts
+var repoCommand = {
+  builder: (yargs) => {
+    return yargs.command(initCommand3).command(lintCommand3).demandCommand(1, "Please specify a repo subcommand").strictCommands();
+  },
+  command: "repo",
+  describe: "Repo - Repository structure utilities",
+  handler: () => {
+  }
+};
+
+// src/xy/common/retestCommand.ts
+var retestCommand = {
+  command: "retest [target]",
+  describe: "Re-Test - Run Vitest Tests with cleaned cache",
+  builder: (yargs) => {
+    return yargs.positional("target", { describe: "Package name or file/folder path to test" });
+  },
+  handler: (argv) => {
+    if (argv.verbose) console.log(`Re-Testing: ${argv.target ?? "all"}`);
+    process.exitCode = retest({ target: argv.target });
+  }
+};
+
+// src/xy/common/testCommand.ts
+var testCommand = {
+  command: "test [target]",
+  describe: "Test - Run Vitest Tests",
+  builder: (yargs) => {
+    return yargs.positional("target", { describe: "Package name or file/folder path to test" });
+  },
+  handler: (argv) => {
+    if (argv.verbose) console.log(`Testing: ${argv.target ?? "all"}`);
+    process.exitCode = test({ target: argv.target });
+  }
+};
+
+// src/xy/common/index.ts
+var xyCommonCommands = (args) => {
+  return args.command(checkCommand).command(claudeCommand).command(licenseCommand).command(deadCommand).command(genDocsCommand).command(cleanDocsCommand).command(gitlintCommand).command(gitignoreCommand).command(npmignoreGenCommand).command(orphanCommand).command(packmanCommand).command(readmeCommand).command(repoCommand).command(retestCommand).command(testCommand);
+};
+export {
+  xyCommonCommands
+};
+//# sourceMappingURL=index.mjs.map