@xylabs/ts-scripts-yarn3 7.4.18 → 7.4.20

package/dist/xy/xy.mjs

@@ -1,5 +1,5 @@
 // src/xy/xy.ts
-import chalk31 from "chalk";
+import chalk39 from "chalk";
 
 // src/actions/build.ts
 import chalk9 from "chalk";
@@ -18,14 +18,19 @@ var checkResult = (name, result, level = "error", exitOnFail = false) => {
 };
 
 // src/lib/claudeMdTemplate.ts
-import { readdirSync, readFileSync } from "fs";
+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-yarn3/package.json"));
-var templatesDir = PATH.resolve(packageRoot, "templates");
+var templatesDir = PATH.resolve(packageRoot, "templates", "claude");
 var XYLABS_RULES_PREFIX = "xylabs-";
 var XYLABS_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"));
@@ -44,6 +49,24 @@ var claudeCommandTemplates = () => {
   }
   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 claudeMdProjectTemplate = () => readFileSync(PATH.resolve(templatesDir, "CLAUDE-project.md"), "utf8");
 
 // src/lib/deleteGlob.ts
@@ -326,10 +349,19 @@ var generateIgnoreFiles = (filename3, pkg) => {
 
 // src/lib/generateReadmeFiles.ts
 import { execSync as execSync2 } from "child_process";
-import FS from "fs";
-import { readFile, writeFile } from "fs/promises";
+import FS, { readFileSync as readFileSync3 } from "fs";
+import {
+  mkdir,
+  readFile,
+  writeFile
+} from "fs/promises";
+import { createRequire as createRequire2 } from "module";
 import PATH2 from "path";
+import { createInterface } from "readline";
 import chalk5 from "chalk";
+var require3 = createRequire2(import.meta.url);
+var packageRoot2 = PATH2.dirname(require3.resolve("@xylabs/ts-scripts-yarn3/package.json"));
+var readmeTemplatesDir = PATH2.resolve(packageRoot2, "templates", "readme");
 function fillTemplate(template, data) {
   const additionalData = { ...data, safeName: data.name.replaceAll("/", "__").replaceAll("@", "") };
   return template.replaceAll(/\{\{(.*?)\}\}/g, (_, key) => additionalData[key.trim()] ?? "");
@@ -419,37 +451,120 @@ ${indent}### ${item.name}
   }
   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(chalk5.yellow(`Template not found: ${resolvedTemplatePath}`));
+    const shouldCreate = await askConfirmation("Would you like to create a stock template? (y/N) ");
+    if (!shouldCreate) {
+      throw new Error("Template creation declined");
+    }
+    const template = DEFAULT_README_TEMPLATE;
+    await scaffoldTemplate(resolvedTemplatePath, template);
+    return { created: true, template };
+  }
+}
+async function scaffoldTemplate(resolvedTemplatePath, template) {
+  const xyDir = PATH2.dirname(resolvedTemplatePath);
+  await mkdir(xyDir, { recursive: true });
+  await writeFile(resolvedTemplatePath, template);
+  console.log(chalk5.green(`Created template: ${resolvedTemplatePath}`));
+  const bodyPath = PATH2.join(xyDir, "README.body.md");
+  await writeFile(bodyPath, DEFAULT_README_BODY);
+  console.log(chalk5.green(`Created body template: ${bodyPath}`));
+}
+async function resolveBody(location, defaultBody) {
+  const localBodyPath = PATH2.join(location, "README.body.md");
+  try {
+    return await readFile(localBodyPath, "utf8");
+  } catch {
+    return defaultBody;
+  }
+}
+async function generateReadmeForWorkspace(location, name, template, defaultBody, typedoc, verbose) {
+  try {
+    const pkgJsonPath = PATH2.join(location, "package.json");
+    const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf8"));
+    const body = await resolveBody(location, defaultBody);
+    const typedocContent = typedoc ? generateTypedoc(location, ["src/index*.ts"]) : "";
+    const readmeContent = fillTemplate(template, {
+      ...pkgJson,
+      body,
+      typedoc: typedocContent
+    });
+    await writeFile(PATH2.join(location, "README.md"), readmeContent);
+    if (verbose) console.log(chalk5.green(`  ${name}`));
+    return true;
+  } catch (ex) {
+    const error = ex;
+    console.warn(chalk5.yellow(`  Skipped ${location}: ${error.message}`));
+    return false;
+  }
+}
 async function generateReadmeFiles({
+  logoLinkUrl,
+  logoUrl,
   pkg,
   templatePath,
   typedoc = false,
-  verbose
+  verbose = false
 }) {
   console.log(chalk5.green("Generate README Files"));
-  const cwd = INIT_CWD() ?? ".";
-  const resolvedTemplatePath = templatePath ?? PATH2.join(cwd, "scripts", "README.template.md");
+  const resolvedTemplatePath = resolveTemplatePath(templatePath);
   let template;
+  let templateCreated;
   try {
-    template = await readFile(resolvedTemplatePath, "utf8");
+    ({ template, created: templateCreated } = await loadOrCreateTemplate(resolvedTemplatePath));
   } catch {
-    console.error(chalk5.red(`Template not found: ${resolvedTemplatePath}`));
     return 1;
   }
-  const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
+  template = applyLogoConfig(template, logoUrl, logoLinkUrl);
+  if (templateCreated) {
+    console.log(chalk5.green("Generating README files for all packages..."));
+  }
+  const xyDir = PATH2.dirname(resolvedTemplatePath);
+  const xyBodyPath = PATH2.join(xyDir, "README.body.md");
+  let defaultBody;
+  try {
+    defaultBody = await readFile(xyBodyPath, "utf8");
+  } catch {
+    defaultBody = DEFAULT_README_BODY;
+  }
+  const workspaces = pkg && !templateCreated ? [yarnWorkspace(pkg)] : yarnWorkspaces();
   let failed = false;
   for (const { location, name } of workspaces) {
-    try {
-      const pkgJsonPath = PATH2.join(location, "package.json");
-      const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf8"));
-      const typedocContent = typedoc ? generateTypedoc(location, ["src/index*.ts"]) : "";
-      const readmeContent = fillTemplate(template, { ...pkgJson, typedoc: typedocContent });
-      await writeFile(PATH2.join(location, "README.md"), readmeContent);
-      if (verbose) console.log(chalk5.green(`  ${name}`));
-    } catch (ex) {
-      const error = ex;
-      console.warn(chalk5.yellow(`  Skipped ${location}: ${error.message}`));
-      failed = true;
-    }
+    const success = await generateReadmeForWorkspace(location, name, template, defaultBody, typedoc, verbose);
+    if (!success) failed = true;
   }
   return failed ? 1 : 0;
 }
@@ -476,10 +591,10 @@ var loadConfig = async (params) => {
 };
 
 // src/lib/parsedPackageJSON.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 var parsedPackageJSON = (path8) => {
   const pathToPackageJSON = path8 ?? process.env.npm_package_json ?? "";
-  const packageJSON = readFileSync3(pathToPackageJSON).toString();
+  const packageJSON = readFileSync4(pathToPackageJSON).toString();
   return JSON.parse(packageJSON);
 };
 
@@ -594,7 +709,7 @@ import {
   existsSync as existsSync4,
   mkdirSync,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
@@ -607,7 +722,7 @@ var syncCommandFiles = (commandsDir) => {
   let created = 0;
   for (const [filename3, content] of Object.entries(templates)) {
     const targetPath = PATH3.resolve(commandsDir, filename3);
-    const existing = existsSync4(targetPath) ? readFileSync4(targetPath, "utf8") : void 0;
+    const existing = existsSync4(targetPath) ? readFileSync5(targetPath, "utf8") : void 0;
     if (existing === content) continue;
     writeFileSync2(targetPath, content, "utf8");
     if (existing) {
@@ -664,7 +779,7 @@ import {
   existsSync as existsSync5,
   mkdirSync as mkdirSync2,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
@@ -677,7 +792,7 @@ var syncRuleFiles = (rulesDir) => {
   let created = 0;
   for (const [filename3, content] of Object.entries(templates)) {
     const targetPath = PATH4.resolve(rulesDir, filename3);
-    const existing = existsSync5(targetPath) ? readFileSync5(targetPath, "utf8") : void 0;
+    const existing = existsSync5(targetPath) ? readFileSync6(targetPath, "utf8") : void 0;
     if (existing === content) continue;
     writeFileSync3(targetPath, content, "utf8");
     if (existing) {
@@ -749,7 +864,7 @@ import {
   writeFileSync as writeFileSync4
 } from "fs";
 import PATH5 from "path";
-import { createInterface } from "readline";
+import { createInterface as createInterface2 } from "readline";
 import chalk12 from "chalk";
 var DEFAULT_SETTINGS = {
   permissions: {
@@ -784,8 +899,8 @@ var DEFAULT_SETTINGS = {
     ]
   }
 };
-function askConfirmation(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+function askConfirmation2(question) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -799,7 +914,7 @@ async function claudeSettings() {
   const settingsPath = PATH5.resolve(claudeDir, "settings.local.json");
   mkdirSync3(claudeDir, { recursive: true });
   if (existsSync6(settingsPath)) {
-    const confirmed = await askConfirmation(
+    const confirmed = await askConfirmation2(
       chalk12.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
     );
     if (!confirmed) {
@@ -813,6 +928,84 @@ async function claudeSettings() {
   return 0;
 }
 
+// src/actions/claude-skills.ts
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync7,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync as writeFileSync5
+} from "fs";
+import PATH6 from "path";
+import chalk13 from "chalk";
+var syncSkillFiles = (skillsDir) => {
+  const templates = claudeSkillTemplates();
+  const templateNames = new Set(Object.keys(templates));
+  let updated = 0;
+  let created = 0;
+  for (const [skillName, files] of Object.entries(templates)) {
+    const skillDir = PATH6.resolve(skillsDir, skillName);
+    mkdirSync4(skillDir, { recursive: true });
+    for (const [filename3, content] of Object.entries(files)) {
+      const targetPath = PATH6.resolve(skillDir, filename3);
+      mkdirSync4(PATH6.dirname(targetPath), { recursive: true });
+      const existing = existsSync7(targetPath) ? readFileSync7(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 = readdirSync4(skillsDir).filter(
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync2(PATH6.resolve(skillsDir, f)).isDirectory()
+  );
+  let removed = 0;
+  for (const dir of existingSkills) {
+    if (!templateNames.has(dir)) {
+      rmSync(PATH6.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() ?? process.cwd();
+  const skillsDir = PATH6.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.ts
 var clean = async ({ verbose, pkg }) => {
   return pkg ? await cleanPackage({ pkg, verbose }) : cleanAll({ verbose });
@@ -827,16 +1020,16 @@ var cleanAll = ({ verbose }) => {
 
 // src/actions/clean-docs.ts
 import path from "path";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 var cleanDocs = () => {
   const pkgName = process.env.npm_package_name;
-  console.log(chalk13.green(`Cleaning Docs [${pkgName}]`));
+  console.log(chalk14.green(`Cleaning Docs [${pkgName}]`));
   for (const { location } of yarnWorkspaces()) deleteGlob(path.join(location, "docs"));
   return 0;
 };
 
 // src/actions/compile.ts
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 var compile = ({
   verbose,
   target,
@@ -877,7 +1070,7 @@ var compileAll = ({
   const incrementalOptions = incremental ? ["--since", "-Ap", "--topological-dev"] : ["--parallel", "-Ap", "--topological-dev"];
   const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
   if (jobs) {
-    console.log(chalk14.blue(`Jobs set to [${jobs}]`));
+    console.log(chalk15.blue(`Jobs set to [${jobs}]`));
   }
   const result = runSteps(`Compile${incremental ? "-Incremental" : ""} [All]`, [
     ["yarn", [
@@ -891,13 +1084,13 @@ var compileAll = ({
       ...targetOptions
     ]]
   ]);
-  console.log(`${chalk14.gray("Compiled in")} [${chalk14.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk14.gray("seconds")}`);
+  console.log(`${chalk15.gray("Compiled in")} [${chalk15.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk15.gray("seconds")}`);
   return result;
 };
 
 // src/actions/copy-assets.ts
 import path2 from "path/posix";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 import cpy from "cpy";
 var copyPackageTargetAssets = async (target, name, location) => {
   try {
@@ -920,7 +1113,7 @@ var copyPackageTargetAssets = async (target, name, location) => {
 };
 var copyTargetAssets = async (target, pkg) => {
   const workspaces = yarnWorkspaces();
-  console.log(chalk15.green(`Copying Assets [${target.toUpperCase()}]`));
+  console.log(chalk16.green(`Copying Assets [${target.toUpperCase()}]`));
   const workspaceList = workspaces.filter(({ name }) => {
     return pkg === void 0 || name === pkg;
   });
@@ -1004,7 +1197,7 @@ var dead = () => {
 };
 
 // src/actions/deplint/deplint.ts
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 
 // src/actions/deplint/findFiles.ts
 import fs2 from "fs";
@@ -1209,7 +1402,7 @@ function getExternalImportsFromFiles({
 
 // src/actions/deplint/checkPackage/getUnlistedDependencies.ts
 import { builtinModules } from "module";
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 function isRuntimeImportListed(imp, name, dependencies, peerDependencies) {
   return dependencies.includes(imp) || imp === name || peerDependencies.includes(imp) || builtinModules.includes(imp);
 }
@@ -1217,7 +1410,7 @@ function isTypeImportListed(imp, name, dependencies, devDependencies, peerDepend
   return dependencies.includes(imp) || imp === name || dependencies.includes(`@types/${imp}`) || peerDependencies.includes(imp) || peerDependencies.includes(`@types/${imp}`) || devDependencies.includes(`@types/${imp}`) || builtinModules.includes(imp);
 }
 function logMissing(name, imp, importPaths) {
-  console.log(`[${chalk16.blue(name)}] Missing dependency in package.json: ${chalk16.red(imp)}`);
+  console.log(`[${chalk17.blue(name)}] Missing dependency in package.json: ${chalk17.red(imp)}`);
   if (importPaths[imp]) {
     console.log(`  ${importPaths[imp].join("\n ")}`);
   }
@@ -1246,7 +1439,7 @@ function getUnlistedDependencies({ name, location }, {
   }
   if (unlistedDependencies > 0) {
     const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk16.yellow(packageLocation)}
+    console.log(`  ${chalk17.yellow(packageLocation)}
 `);
   }
   return unlistedDependencies;
@@ -1254,7 +1447,7 @@ function getUnlistedDependencies({ name, location }, {
 
 // src/actions/deplint/checkPackage/getUnlistedDevDependencies.ts
 import { builtinModules as builtinModules2 } from "module";
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 function getUnlistedDevDependencies({ name, location }, {
   devDependencies,
   dependencies,
@@ -1268,7 +1461,7 @@ function getUnlistedDevDependencies({ name, location }, {
   for (const imp of externalAllImports) {
     if (!distImports.includes(imp) && imp !== name && !dependencies.includes(imp) && !dependencies.includes(`@types/${imp}`) && !peerDependencies.includes(imp) && !peerDependencies.includes(`@types/${imp}`) && !devDependencies.includes(imp) && !devDependencies.includes(`@types/${imp}`) && !builtinModules2.includes(imp)) {
       unlistedDevDependencies++;
-      console.log(`[${chalk17.blue(name)}] Missing devDependency in package.json: ${chalk17.red(imp)}`);
+      console.log(`[${chalk18.blue(name)}] Missing devDependency in package.json: ${chalk18.red(imp)}`);
       if (allImportPaths[imp]) {
         console.log(`  ${allImportPaths[imp].join("\n ")}`);
       }
@@ -1276,14 +1469,14 @@ function getUnlistedDevDependencies({ name, location }, {
   }
   if (unlistedDevDependencies > 0) {
     const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk17.yellow(packageLocation)}
+    console.log(`  ${chalk18.yellow(packageLocation)}
 `);
   }
   return unlistedDevDependencies;
 }
 
 // src/actions/deplint/checkPackage/getUnusedDependencies.ts
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 function getUnusedDependencies({ name, location }, { dependencies }, {
   externalDistImports,
   externalDistTypeImports,
@@ -1295,22 +1488,22 @@ function getUnusedDependencies({ name, location }, { dependencies }, {
     if (!externalDistImports.includes(dep) && !externalDistImports.includes(dep.replace(/^@types\//, "")) && !externalDistTypeImports.includes(dep) && !externalDistTypeImports.includes(dep.replace(/^@types\//, ""))) {
       unusedDependencies++;
       if (externalAllImports.includes(dep)) {
-        console.log(`[${chalk18.blue(name)}] dependency should be devDependency in package.json: ${chalk18.red(dep)}`);
+        console.log(`[${chalk19.blue(name)}] dependency should be devDependency in package.json: ${chalk19.red(dep)}`);
       } else {
-        console.log(`[${chalk18.blue(name)}] Unused dependency in package.json: ${chalk18.red(dep)}`);
+        console.log(`[${chalk19.blue(name)}] Unused dependency in package.json: ${chalk19.red(dep)}`);
       }
     }
   }
   if (unusedDependencies > 0) {
     const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk18.yellow(packageLocation)}
+    console.log(`  ${chalk19.yellow(packageLocation)}
 `);
   }
   return unusedDependencies;
 }
 
 // src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 
 // src/actions/deplint/getCliReferencedPackagesFromFiles.ts
 import fs8 from "fs";
@@ -1594,19 +1787,19 @@ function getUnusedDevDependencies({ name, location }, {
     if (dependencies.includes(dep) || peerDependencies.includes(dep)) continue;
     if (!isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs, cliRefs)) {
       unusedDevDependencies++;
-      console.log(`[${chalk19.blue(name)}] Unused devDependency in package.json: ${chalk19.red(dep)}`);
+      console.log(`[${chalk20.blue(name)}] Unused devDependency in package.json: ${chalk20.red(dep)}`);
     }
   }
   if (unusedDevDependencies > 0) {
     const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk19.yellow(packageLocation)}
+    console.log(`  ${chalk20.yellow(packageLocation)}
 `);
   }
   return unusedDevDependencies;
 }
 
 // src/actions/deplint/checkPackage/getUnusedPeerDependencies.ts
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 function getUnusedPeerDependencies({ name, location }, { peerDependencies, dependencies }, { externalDistImports, externalDistTypeImports }, exclude) {
   let unusedDependencies = 0;
   for (const dep of peerDependencies) {
@@ -1614,15 +1807,15 @@ function getUnusedPeerDependencies({ name, location }, { peerDependencies, depen
     if (!externalDistImports.includes(dep) && !externalDistImports.includes(dep.replace(/^@types\//, "")) && !externalDistTypeImports.includes(dep) && !externalDistTypeImports.includes(dep.replace(/^@types\//, ""))) {
       unusedDependencies++;
       if (dependencies.includes(dep)) {
-        console.log(`[${chalk20.blue(name)}] Unused peerDependency [already a dependency] in package.json: ${chalk20.red(dep)}`);
+        console.log(`[${chalk21.blue(name)}] Unused peerDependency [already a dependency] in package.json: ${chalk21.red(dep)}`);
       } else {
-        console.log(`[${chalk20.blue(name)}] Unused peerDependency in package.json: ${chalk20.red(dep)}`);
+        console.log(`[${chalk21.blue(name)}] Unused peerDependency in package.json: ${chalk21.red(dep)}`);
       }
     }
   }
   if (unusedDependencies > 0) {
     const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk20.yellow(packageLocation)}
+    console.log(`  ${chalk21.yellow(packageLocation)}
 `);
   }
   return unusedDependencies;
@@ -1717,19 +1910,19 @@ var deplint = async ({
     });
   }
   if (totalErrors > 0) {
-    console.warn(`Deplint: Found ${chalk21.red(totalErrors)} dependency problems. ${chalk21.red("\u2716")}`);
+    console.warn(`Deplint: Found ${chalk22.red(totalErrors)} dependency problems. ${chalk22.red("\u2716")}`);
   } else {
-    console.info(`Deplint: Found no dependency problems. ${chalk21.green("\u2714")}`);
+    console.info(`Deplint: Found no dependency problems. ${chalk22.green("\u2714")}`);
   }
   return 0;
 };
 
 // src/actions/deploy.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 var privatePackageExcludeList = () => {
   const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
     workspace,
-    JSON.parse(readFileSync6(`${workspace.location}/package.json`, { encoding: "utf8" }))
+    JSON.parse(readFileSync8(`${workspace.location}/package.json`, { encoding: "utf8" }))
   ]);
   const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
   const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
@@ -1749,11 +1942,11 @@ var deploy = () => {
 };
 
 // src/actions/deploy-major.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 var privatePackageExcludeList2 = () => {
   const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
     workspace,
-    JSON.parse(readFileSync7(`${workspace.location}/package.json`, { encoding: "utf8" }))
+    JSON.parse(readFileSync9(`${workspace.location}/package.json`, { encoding: "utf8" }))
   ]);
   const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
   const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
@@ -1773,11 +1966,11 @@ var deployMajor = () => {
 };
 
 // src/actions/deploy-minor.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 var privatePackageExcludeList3 = () => {
   const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
     workspace,
-    JSON.parse(readFileSync8(`${workspace.location}/package.json`, { encoding: "utf8" }))
+    JSON.parse(readFileSync10(`${workspace.location}/package.json`, { encoding: "utf8" }))
   ]);
   const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
   const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
@@ -1797,11 +1990,11 @@ var deployMinor = () => {
 };
 
 // src/actions/deploy-next.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 var privatePackageExcludeList4 = () => {
   const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
     workspace,
-    JSON.parse(readFileSync9(`${workspace.location}/package.json`, { encoding: "utf8" }))
+    JSON.parse(readFileSync11(`${workspace.location}/package.json`, { encoding: "utf8" }))
   ]);
   const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
   const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
@@ -1821,22 +2014,22 @@ var deployNext = () => {
 };
 
 // src/actions/dupdeps.ts
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 var dupdeps = () => {
-  console.log(chalk22.green("Checking all Dependencies for Duplicates"));
+  console.log(chalk23.green("Checking all Dependencies for Duplicates"));
   const allDependencies = parsedPackageJSON()?.dependencies;
   const dependencies = Object.entries(allDependencies).map(([k]) => k);
   return detectDuplicateDependencies(dependencies);
 };
 
 // src/actions/lint.ts
-import chalk23 from "chalk";
+import chalk24 from "chalk";
 var lintPackage = ({
   pkg,
   fix: fix2,
   verbose
 }) => {
-  console.log(chalk23.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
+  console.log(chalk24.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
   const start = Date.now();
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
     ["yarn", [
@@ -1846,7 +2039,7 @@ var lintPackage = ({
       fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint"
     ]]
   ]);
-  console.log(chalk23.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk23.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk23.gray("seconds")}`));
+  console.log(chalk24.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk24.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk24.gray("seconds")}`));
   return result;
 };
 var lint = ({
@@ -1866,13 +2059,13 @@ var lint = ({
   });
 };
 var lintAllPackages = ({ fix: fix2 = false } = {}) => {
-  console.log(chalk23.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
+  console.log(chalk24.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
   const start = Date.now();
   const fixOptions = fix2 ? ["--fix"] : [];
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
     ["yarn", ["eslint", "--cache", "--cache-location", ".eslintcache", "--cache-strategy", "content", ...fixOptions]]
   ]);
-  console.log(chalk23.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk23.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk23.gray("seconds")}`));
+  console.log(chalk24.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk24.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk24.gray("seconds")}`));
   return result;
 };
 
@@ -1900,7 +2093,7 @@ var filename = ".gitignore";
 var gitignoreGen = (pkg) => generateIgnoreFiles(filename, pkg);
 
 // src/actions/gitlint.ts
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 import ParseGitConfig from "parse-git-config";
 var gitlint = () => {
   console.log(`
@@ -1911,7 +2104,7 @@ Gitlint Start [${process.cwd()}]
   const errors = 0;
   const gitConfig = ParseGitConfig.sync();
   const warn = (message) => {
-    console.warn(chalk24.yellow(`Warning: ${message}`));
+    console.warn(chalk25.yellow(`Warning: ${message}`));
     warnings++;
   };
   if (gitConfig.core.ignorecase) {
@@ -1931,13 +2124,13 @@ Gitlint Start [${process.cwd()}]
   }
   const resultMessages = [];
   if (valid > 0) {
-    resultMessages.push(chalk24.green(`Passed: ${valid}`));
+    resultMessages.push(chalk25.green(`Passed: ${valid}`));
   }
   if (warnings > 0) {
-    resultMessages.push(chalk24.yellow(`Warnings: ${warnings}`));
+    resultMessages.push(chalk25.yellow(`Warnings: ${warnings}`));
   }
   if (errors > 0) {
-    resultMessages.push(chalk24.red(` Errors: ${errors}`));
+    resultMessages.push(chalk25.red(` Errors: ${errors}`));
   }
   console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
 `);
@@ -1946,7 +2139,7 @@ Gitlint Start [${process.cwd()}]
 
 // src/actions/gitlint-fix.ts
 import { execSync as execSync3 } from "child_process";
-import chalk25 from "chalk";
+import chalk26 from "chalk";
 import ParseGitConfig2 from "parse-git-config";
 var gitlintFix = () => {
   console.log(`
@@ -1955,15 +2148,15 @@ Gitlint Fix Start [${process.cwd()}]
   const gitConfig = ParseGitConfig2.sync();
   if (gitConfig.core.ignorecase) {
     execSync3("git config core.ignorecase false", { stdio: "inherit" });
-    console.warn(chalk25.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+    console.warn(chalk26.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
   }
   if (gitConfig.core.autocrlf !== false) {
     execSync3("git config core.autocrlf false", { stdio: "inherit" });
-    console.warn(chalk25.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+    console.warn(chalk26.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
   }
   if (gitConfig.core.eol !== "lf") {
     execSync3("git config core.eol lf", { stdio: "inherit" });
-    console.warn(chalk25.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+    console.warn(chalk26.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
   }
   return 1;
 };
@@ -1974,7 +2167,7 @@ var knip = () => {
 };
 
 // src/actions/license.ts
-import chalk26 from "chalk";
+import chalk27 from "chalk";
 import { init } from "license-checker";
 var license = async (pkg) => {
   const workspaces = yarnWorkspaces();
@@ -1999,18 +2192,18 @@ var license = async (pkg) => {
     "LGPL-3.0-or-later",
     "Python-2.0"
   ]);
-  console.log(chalk26.green("License Checker"));
+  console.log(chalk27.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(chalk26.red(`License Checker [${name}] Error`));
-            console.error(chalk26.gray(error));
+            console.error(chalk27.red(`License Checker [${name}] Error`));
+            console.error(chalk27.gray(error));
             console.log("\n");
             resolve(1);
           } else {
-            console.log(chalk26.green(`License Checker [${name}]`));
+            console.log(chalk27.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];
@@ -2026,7 +2219,7 @@ var license = async (pkg) => {
                   }
                   if (!orLicenseFound) {
                     count++;
-                    console.warn(chalk26.yellow(`${name2}: Package License not allowed [${license2}]`));
+                    console.warn(chalk27.yellow(`${name2}: Package License not allowed [${license2}]`));
                   }
                 }
               }
@@ -2068,7 +2261,10 @@ async function readmeGen({
   typedoc,
   verbose
 }) {
+  const config2 = await loadConfig();
   return await generateReadmeFiles({
+    logoLinkUrl: config2.readme?.logoLinkUrl,
+    logoUrl: config2.readme?.logoUrl,
     pkg,
     templatePath,
     typedoc,
@@ -2076,6 +2272,15 @@ async function readmeGen({
   });
 }
 
+// src/actions/readme-init.ts
+async function readmeInit({ templatePath }) {
+  const config2 = await loadConfig();
+  const template = applyLogoConfig(DEFAULT_README_TEMPLATE, config2.readme?.logoUrl, config2.readme?.logoLinkUrl);
+  const resolvedTemplatePath = resolveTemplatePath(templatePath);
+  await scaffoldTemplate(resolvedTemplatePath, template);
+  return 0;
+}
+
 // src/actions/rebuild.ts
 var rebuild = ({ target }) => {
   return runSteps("Rebuild", [
@@ -2085,7 +2290,7 @@ var rebuild = ({ target }) => {
 };
 
 // src/actions/recompile.ts
-import chalk27 from "chalk";
+import chalk28 from "chalk";
 var recompile = async ({
   verbose,
   target,
@@ -2121,7 +2326,7 @@ var recompileAll = async ({
   const incrementalOptions = incremental ? ["--since", "-Apt", "--topological-dev"] : ["--parallel", "-Apt", "--topological-dev"];
   const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
   if (jobs) {
-    console.log(chalk27.blue(`Jobs set to [${jobs}]`));
+    console.log(chalk28.blue(`Jobs set to [${jobs}]`));
   }
   const result = await runStepsAsync(`Recompile${incremental ? "-Incremental" : ""} [All]`, [
     [
@@ -2152,7 +2357,7 @@ var recompileAll = async ({
     ]
   ]);
   console.log(
-    `${chalk27.gray("Recompiled in")} [${chalk27.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk27.gray("seconds")}`
+    `${chalk28.gray("Recompiled in")} [${chalk28.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk28.gray("seconds")}`
   );
   return result;
 };
@@ -2161,7 +2366,7 @@ var recompileAll = async ({
 import {
   closeSync,
   openSync,
-  rmSync
+  rmSync as rmSync2
 } from "fs";
 var reinstall = () => {
   console.log("Reinstall [Clear Lock File]");
@@ -2171,7 +2376,7 @@ var reinstall = () => {
   const result = workspaces.map(({ location, name }) => {
     const dist = `${location}/node_modules`;
     try {
-      rmSync(dist, { force: true, recursive: true });
+      rmSync2(dist, { force: true, recursive: true });
       return 0;
     } catch (ex) {
       const error = ex;
@@ -2183,13 +2388,13 @@ var reinstall = () => {
 };
 
 // src/actions/relint.ts
-import chalk28 from "chalk";
+import chalk29 from "chalk";
 var relintPackage = ({
   pkg,
   fix: fix2,
   verbose
 }) => {
-  console.log(chalk28.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
+  console.log(chalk29.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
   const start = Date.now();
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
     ["yarn", [
@@ -2199,7 +2404,7 @@ var relintPackage = ({
       fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint"
     ]]
   ]);
-  console.log(chalk28.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk28.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk28.gray("seconds")}`));
+  console.log(chalk29.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk29.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk29.gray("seconds")}`));
   return result;
 };
 var relint = ({
@@ -2219,21 +2424,21 @@ var relint = ({
   });
 };
 var relintAllPackages = ({ fix: fix2 = false } = {}) => {
-  console.log(chalk28.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
+  console.log(chalk29.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
   const start = Date.now();
   const fixOptions = fix2 ? ["--fix"] : [];
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
     ["yarn", ["eslint", ...fixOptions]]
   ]);
-  console.log(chalk28.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk28.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk28.gray("seconds")}`));
+  console.log(chalk29.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk29.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk29.gray("seconds")}`));
   return result;
 };
 
 // src/actions/retest.ts
 var retest = () => {
   return runSteps("Test", [
-    ["yarn", ["jest", "--clearCache"]],
-    ["yarn", ["jest", "."]]
+    ["yarn", ["vitest", "--clearCache"]],
+    ["yarn", ["vitest", "."]]
   ]);
 };
 
@@ -2243,10 +2448,10 @@ var sonar = () => {
 };
 
 // src/actions/statics.ts
-import chalk29 from "chalk";
+import chalk30 from "chalk";
 var DefaultDependencies = ["axios", "@xylabs/pixel", "react", "graphql", "react-router", "@mui/material", "@mui/system"];
 var statics = () => {
-  console.log(chalk29.green("Check Required Static Dependencies"));
+  console.log(chalk30.green("Check Required Static Dependencies"));
   const statics2 = parsedPackageJSON()?.xy?.deps?.statics;
   return detectDuplicateDependencies(statics2, DefaultDependencies);
 };
@@ -2294,556 +2499,691 @@ var yarn3Only = () => {
   return 0;
 };
 
-// src/xy/xyBuildCommands.ts
-var xyBuildCommands = (args) => {
-  return args.command(
-    "build [package]",
-    "Build - Compile & Lint",
-    (yargs2) => {
-      return yargs2.positional("package", { describe: "Specific package to build" });
-    },
-    async (argv) => {
-      if (argv.verbose) {
-        console.log(`Building: ${argv.package ?? "all"}`);
-      }
-      process.exitCode = await build({
-        incremental: !!argv.incremental,
-        jobs: argv.jobs,
-        pkg: argv.package,
-        target: argv.target,
-        verbose: !!argv.verbose
-      });
-    }
-  ).command(
-    "compile [package]",
-    "Compile with Typescript & Copy Images",
-    (yargs2) => {
-      return yargs2.positional("package", { describe: "Specific package to compile" });
-    },
-    (argv) => {
-      if (argv.verbose) {
-        console.log(`Compiling: ${argv.package ?? "all"}`);
-      }
-      process.exitCode = compile({
-        incremental: !!argv.incremental,
-        jobs: argv.jobs,
-        pkg: argv.package,
-        target: argv.target,
-        verbose: !!argv.verbose
-      });
-    }
-  ).command(
-    "compile-only [package]",
-    "Compile with Typescript & Copy Images (No Publint)",
-    (yargs2) => {
-      return yargs2.positional("package", { describe: "Specific package to compile" });
-    },
-    (argv) => {
-      if (argv.verbose) {
-        console.log(`Compiling: ${argv.package ?? "all"}`);
-      }
-      process.exitCode = compile({
-        incremental: !!argv.incremental,
-        jobs: argv.jobs,
-        pkg: argv.package,
-        publint: false,
-        target: argv.target,
-        verbose: !!argv.verbose
-      });
-    }
-  ).command(
-    "recompile [package]",
-    "Re-compile with Typescript & Copy Images",
-    (yargs2) => {
-      return yargs2.positional("package", { describe: "Specific package to re-compile" });
-    },
-    async (argv) => {
-      if (argv.verbose) {
-        console.log(`Re-compiling: ${argv.package ?? "all"}`);
-      }
-      process.exitCode = await recompile({
-        incremental: !!argv.incremental,
-        jobs: argv.jobs,
-        pkg: argv.package,
-        target: argv.target,
-        verbose: !!argv.verbose
-      });
-    }
-  ).command(
-    "rebuild [package]",
-    "Rebuild - Clean, Compile & Lint",
-    (yargs2) => {
-      return yargs2.positional("package", { describe: "Specific package to rebuild" });
-    },
-    (argv) => {
-      if (argv.verbose) console.log(`Rebuilding: ${argv.package ?? "all"}`);
-      process.exitCode = rebuild({ target: argv.target });
-    }
-  ).command(
-    "copy-assets [package]",
-    "Copy Assets - Copy the assets from src to dist",
-    (yargs2) => {
-      return yargs2.positional("package", { describe: "Specific package to copy assets" });
-    },
-    async (argv) => {
-      if (argv.verbose) console.log(`Copying Assets: ${argv.package ?? "all"}`);
-      process.exitCode = await copyAssets({ target: argv.target });
-    }
-  );
-};
-
 // src/xy/param.ts
 var packagePositionalParam = (yargs2) => {
   return yargs2.positional("package", { describe: "Specific package to target", type: "string" });
 };
 
-// src/xy/xyCommonCommands.ts
+// src/xy/build-commands/build.ts
+var buildCommand = {
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  command: "build [package]",
+  describe: "Build - Compile & Lint",
+  handler: async (argv) => {
+    if (argv.verbose) {
+      console.log(`Building: ${argv.package ?? "all"}`);
+    }
+    process.exitCode = await build({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package,
+      target: argv.target,
+      verbose: !!argv.verbose
+    });
+  }
+};
+var compileCommand = {
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  command: "compile [package]",
+  describe: "Compile with Typescript & Copy Images",
+  handler: (argv) => {
+    if (argv.verbose) {
+      console.log(`Compiling: ${argv.package ?? "all"}`);
+    }
+    process.exitCode = compile({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package,
+      target: argv.target,
+      verbose: !!argv.verbose
+    });
+  }
+};
+var compileOnlyCommand = {
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  command: "compile-only [package]",
+  describe: "Compile with Typescript & Copy Images (No Publint)",
+  handler: (argv) => {
+    if (argv.verbose) {
+      console.log(`Compiling: ${argv.package ?? "all"}`);
+    }
+    process.exitCode = compile({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package,
+      publint: false,
+      target: argv.target,
+      verbose: !!argv.verbose
+    });
+  }
+};
+var recompileCommand = {
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  command: "recompile [package]",
+  describe: "Re-compile with Typescript & Copy Images",
+  handler: async (argv) => {
+    if (argv.verbose) {
+      console.log(`Re-compiling: ${argv.package ?? "all"}`);
+    }
+    process.exitCode = await recompile({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package,
+      target: argv.target,
+      verbose: !!argv.verbose
+    });
+  }
+};
+var rebuildCommand = {
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  command: "rebuild [package]",
+  describe: "Rebuild - Clean, Compile & Lint",
+  handler: (argv) => {
+    if (argv.verbose) console.log(`Rebuilding: ${argv.package ?? "all"}`);
+    process.exitCode = rebuild({ target: argv.target });
+  }
+};
+var copyAssetsCommand = {
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  command: "copy-assets [package]",
+  describe: "Copy Assets - Copy the assets from src to dist",
+  handler: async (argv) => {
+    if (argv.verbose) console.log(`Copying Assets: ${argv.package ?? "all"}`);
+    process.exitCode = await copyAssets({ target: argv.target });
+  }
+};
+
+// src/xy/build-commands/index.ts
+var xyBuildCommands = (args) => {
+  return args.command(buildCommand).command(compileCommand).command(compileOnlyCommand).command(rebuildCommand).command(recompileCommand).command(copyAssetsCommand);
+};
+
+// 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: (yargs2) => {
+    return yargs2.option("force", {
+      alias: "f",
+      default: false,
+      description: "Overwrite existing CLAUDE.md",
+      type: "boolean"
+    });
+  },
+  command: "init",
+  describe: "Initialize all Claude configuration (commands, rules, settings)",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Claude Init");
+    const commandsResult = claudeCommands();
+    const rulesResult = claudeRules({ force: argv.force });
+    const settingsResult = await claudeSettings();
+    process.exitCode = commandsResult || rulesResult || settingsResult;
+  }
+};
+var initClaudeSkillsCommand = {
+  command: "init:skills",
+  describe: "Initialize Claude skills configuration",
+  handler: () => {
+    const result = claudeSkills();
+    process.exitCode = result;
+  }
+};
+
+// src/xy/common/claude/rulesCommand.ts
+var rulesCommand = {
+  builder: (yargs2) => {
+    return yargs2.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 = {
+  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();
+  }
+};
+
+// src/xy/common/claude/index.ts
+var claudeCommand = {
+  builder: (yargs2) => {
+    return yargs2.command(commandsCommand).command(initCommand).command(rulesCommand).command(settingsCommand).command(initClaudeSkillsCommand).demandCommand(1, "Please specify a claude subcommand");
+  },
+  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/common/deadCommand.ts
+var deadCommand = {
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  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: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  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, pkg: argv.package });
+  }
+};
+
+// src/xy/common/gitignoreGenCommand.ts
+var gitignoreGenCommand = {
+  command: "gitignore-gen",
+  describe: "GitIgnore Gen - Generate .gitignore files",
+  handler: (argv) => {
+    if (argv.verbose) console.log("GitIgnore Gen");
+    process.exitCode = gitignoreGen();
+  }
+};
+
+// src/xy/common/gitlintCommand.ts
+var gitlintCommand = {
+  command: "gitlint [package]",
+  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: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  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/readme/genCommand.ts
+var genCommand = {
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2).option("template", {
+      alias: "t",
+      description: "Path to README.template.md",
+      type: "string"
+    }).option("typedoc", {
+      default: false,
+      description: "Generate 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({
+      pkg: argv.package,
+      templatePath: argv.template,
+      typedoc: argv.typedoc,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/common/readme/initCommand.ts
+var initCommand2 = {
+  builder: (yargs2) => {
+    return yargs2.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/index.ts
+var readmeCommand = {
+  builder: (yargs2) => {
+    return yargs2.command(genCommand).command(initCommand2);
+  },
+  command: "readme",
+  describe: "Readme - README file utilities",
+  handler: () => {
+  }
+};
+
+// src/xy/common/retestCommand.ts
+var retestCommand = {
+  command: "retest",
+  describe: "Re-Test - Run Jest Tests with cleaned cache",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Re-Testing");
+    process.exitCode = retest();
+  }
+};
+
+// src/xy/common/testCommand.ts
+var testCommand = {
+  command: "test",
+  describe: "Test - Run Jest Tests",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Testing");
+    process.exitCode = test();
+  }
+};
+
+// src/xy/common/upplugCommand.ts
+var upplugCommand = {
+  command: "upplug",
+  describe: "UpPlug - Update Yarn Plugins",
+  handler: (argv) => {
+    if (argv.verbose) console.log("UpPlug");
+    process.exitCode = updateYarnPlugins();
+  }
+};
+
+// src/xy/common/upyarnCommand.ts
+var upyarnCommand = {
+  command: "upyarn",
+  describe: "UpYarn - Update Yarn Version",
+  handler: (argv) => {
+    if (argv.verbose) console.log("UpYarn");
+    process.exitCode = updateYarnVersion();
+  }
+};
+
+// src/xy/common/yarn3OnlyCommand.ts
+var yarn3OnlyCommand = {
+  command: "yarn3only",
+  describe: "Yarn3Only - Check if using Yarn v3",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Yarn 3 Check");
+    process.exitCode = yarn3Only();
+  }
+};
+
+// src/xy/common/index.ts
 var xyCommonCommands = (args) => {
-  return args.command(
-    "claude-commands",
-    "Claude Commands - Sync XY Labs standard Claude slash commands to .claude/commands/",
-    (yargs2) => yargs2,
-    (argv) => {
-      if (argv.verbose) console.log("Claude Commands");
-      process.exitCode = claudeCommands();
-    }
-  ).command(
-    "claude-settings",
-    "Claude Settings - Initialize .claude/settings.local.json with XY Labs defaults",
-    (yargs2) => yargs2,
-    async (argv) => {
-      if (argv.verbose) console.log("Claude Settings");
-      process.exitCode = await claudeSettings();
-    }
-  ).command(
-    "claude-rules",
-    "Claude Rules - Sync XY Labs standard Claude rules to .claude/rules/",
-    (yargs2) => {
-      return yargs2.option("force", {
-        alias: "f",
-        default: false,
-        description: "Overwrite existing CLAUDE.md",
-        type: "boolean"
-      });
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Claude Rules");
-      process.exitCode = claudeRules({ force: argv.force });
-    }
-  ).command(
-    "license [package]",
-    "License - Check licenses of dependencies",
-    (yargs2) => {
-      return packagePositionalParam(yargs2);
-    },
-    async (argv) => {
-      if (argv.verbose) console.log(`License: ${argv.package ?? "all"}`);
-      process.exitCode = await license();
-    }
-  ).command(
-    "dead [package]",
-    "Dead - Check for dead code",
-    (yargs2) => {
-      return packagePositionalParam(yargs2);
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Dead");
-      process.exitCode = dead();
-    }
-  ).command(
-    "gen-docs [package]",
-    "GenDocs - Generate TypeDocs",
-    (yargs2) => {
-      return packagePositionalParam(yargs2);
-    },
-    (argv) => {
-      if (argv.verbose) console.log(`Generating TypeDocs: ${argv.package ?? "all"}`);
-      process.exitCode = genDocs({ incremental: !!argv.incremental, pkg: argv.package });
-    }
-  ).command(
-    "clean-docs",
-    "CleanDocs - Clean TypeDocs",
-    (yargs2) => yargs2,
-    (argv) => {
-      if (argv.verbose) console.log("Cleaning TypeDocs: all");
-      process.exitCode = cleanDocs();
-    }
-  ).command(
-    "gitlint [package]",
-    "Gitlint - Lint your git config",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Gitlint");
-      process.exitCode = argv.fix ? gitlintFix() : gitlint();
-    }
-  ).command(
-    "gitignore-gen",
-    "GitIgnore Gen - Generate .gitignore files",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("GitIgnore Gen");
-      process.exitCode = gitignoreGen();
-    }
-  ).command(
-    "npmignore-gen",
-    "NpmIgnore Gen - Generate .npmignore files",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("NpmIgnore Gen");
-      process.exitCode = npmignoreGen();
-    }
-  ).command(
-    "readme-gen [package]",
-    "Readme Gen - Generate README.md files from template",
-    (yargs2) => {
-      return packagePositionalParam(yargs2).option("template", {
-        alias: "t",
-        description: "Path to README.template.md",
-        type: "string"
-      }).option("typedoc", {
-        default: false,
-        description: "Generate TypeDoc reference sections",
-        type: "boolean"
-      });
-    },
-    async (argv) => {
-      if (argv.verbose) console.log("Readme Gen");
-      process.exitCode = await readmeGen({
-        pkg: argv.package,
-        templatePath: argv.template,
-        typedoc: argv.typedoc,
-        verbose: !!argv.verbose
-      });
-    }
-  ).command(
-    "retest",
-    "Re-Test - Run Jest Tests with cleaned cache",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Re-Testing");
-      process.exitCode = retest();
-    }
-  ).command(
-    "test",
-    "Test - Run Jest Tests",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Testing");
-      process.exitCode = test();
-    }
-  ).command(
-    "upplug",
-    "UpPlug - Update Yarn Plugins",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("UpPlug");
-      process.exitCode = updateYarnPlugins();
-    }
-  ).command(
-    "upyarn",
-    "UpYarn - Update Yarn Version",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("UpYarn");
-      process.exitCode = updateYarnVersion();
-    }
-  ).command(
-    "yarn3only",
-    "Yarn3Only - Check if using Yarn v3",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Yarn 3 Check");
-      process.exitCode = yarn3Only();
-    }
-  );
+  return args.command(claudeCommand).command(licenseCommand).command(deadCommand).command(genDocsCommand).command(cleanDocsCommand).command(gitlintCommand).command(gitignoreGenCommand).command(npmignoreGenCommand).command(readmeCommand).command(retestCommand).command(testCommand).command(upplugCommand).command(upyarnCommand).command(yarn3OnlyCommand);
+};
+
+// src/xy/deploy/deployCommand.ts
+var deployCommand = {
+  command: "deploy",
+  describe: "Deploy - Deploy patch",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Deploy patch");
+    process.exitCode = deploy();
+  }
+};
+
+// src/xy/deploy/deployMajorCommand.ts
+var deployMajorCommand = {
+  command: "deploy-major",
+  describe: "Deploy - Deploy major",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Deploy major");
+    process.exitCode = deployMajor();
+  }
+};
+
+// src/xy/deploy/deployMinorCommand.ts
+var deployMinorCommand = {
+  command: "deploy-minor",
+  describe: "Deploy - Deploy minor",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Deploy minor");
+    process.exitCode = deployMinor();
+  }
 };
 
-// src/xy/xyDeployCommands.ts
+// src/xy/deploy/deployNextCommand.ts
+var deployNextCommand = {
+  command: "deploy-next",
+  describe: "Deploy - Deploy next",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Deploy next");
+    process.exitCode = deployNext();
+  }
+};
+
+// src/xy/deploy/publishCommand.ts
+var publishCommand = {
+  command: "publish",
+  describe: "Publish - Publish packages to npmjs",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Publish packages to npmjs");
+    process.exitCode = publish();
+  }
+};
+
+// src/xy/deploy/index.ts
 var xyDeployCommands = (args) => {
-  return args.command(
-    "deploy",
-    "Deploy - Deploy patch",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Deploy patch");
-      process.exitCode = deploy();
-    }
-  ).command(
-    "deploy-minor",
-    "Deploy - Deploy minor",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Deploy minor");
-      process.exitCode = deployMinor();
-    }
-  ).command(
-    "deploy-major",
-    "Deploy - Deploy major",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Deploy major");
-      process.exitCode = deployMajor();
-    }
-  ).command(
-    "deploy-next",
-    "Deploy - Deploy next",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Deploy next");
-      process.exitCode = deployNext();
-    }
-  ).command(
-    "publish",
-    "Publish - Publish packages to npmjs",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Publish packages to npmjs");
-      process.exitCode = publish();
+  return args.command(deployCommand).command(deployMinorCommand).command(deployMajorCommand).command(deployNextCommand).command(publishCommand);
+};
+
+// src/xy/install/cleanCommand.ts
+var cleanCommand = {
+  command: "clean [package]",
+  describe: "Clean",
+  builder: (yargs2) => {
+    return yargs2.positional("package", { describe: "Specific package to clean" });
+  },
+  handler: async (argv) => {
+    if (argv.verbose) {
+      console.log(`Cleaning: ${argv.package ?? "all"}`);
     }
-  );
+    process.exitCode = await clean({
+      pkg: argv.package,
+      verbose: !!argv.verbose
+    });
+  }
+};
+
+// src/xy/install/dupdepsCommand.ts
+var dupdepsCommand = {
+  command: "dupdeps",
+  describe: "Dupdeps - Duplicate Dependencies in package.json",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Dupdeps");
+    process.exitCode = dupdeps();
+  }
+};
+
+// src/xy/install/reinstallCommand.ts
+var reinstallCommand = {
+  command: "reinstall",
+  describe: "Reinstall - Clean & Install",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Reinstalling");
+    process.exitCode = reinstall();
+  }
+};
+
+// src/xy/install/staticsCommand.ts
+var staticsCommand = {
+  command: "statics",
+  describe: "Statics - Confirming Static Packages",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Statics");
+    process.exitCode = statics();
+  }
+};
+
+// src/xy/install/upCommand.ts
+var upCommand = {
+  command: "up",
+  describe: "Up - Update dependencies",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Up");
+    process.exitCode = up();
+  }
 };
 
-// src/xy/xyInstallCommands.ts
+// src/xy/install/updoCommand.ts
+var updoCommand = {
+  command: "updo",
+  describe: "Updo - Update dependencies [Interactive]",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Updo");
+    process.exitCode = updo();
+  }
+};
+
+// src/xy/install/index.ts
 var xyInstallCommands = (args) => {
-  return args.command(
-    "clean [package]",
-    "Clean",
-    (yargs2) => {
-      return yargs2.positional("package", { describe: "Specific package to clean" });
-    },
-    async (argv) => {
-      if (argv.verbose) {
-        console.log(`Cleaning: ${argv.package ?? "all"}`);
-      }
-      process.exitCode = await clean({
-        pkg: argv.package,
-        verbose: !!argv.verbose
-      });
-    }
-  ).command(
-    "reinstall",
-    "Reinstall - Clean & Install",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Reinstalling");
-      process.exitCode = reinstall();
-    }
-  ).command(
-    "up",
-    "Up - Update dependencies",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Up");
-      process.exitCode = up();
-    }
-  ).command(
-    "updo",
-    "Updo - Update dependencies [Interactive]",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Updo");
-      process.exitCode = updo();
-    }
-  ).command(
-    "statics",
-    "Statics - Confirming Static Packages",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Statics");
-      process.exitCode = statics();
-    }
-  ).command(
-    "dupdeps",
-    "Dupdeps - Duplicate Dependencies in package.json",
-    (yargs2) => {
-      return yargs2;
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Dupdeps");
-      process.exitCode = dupdeps();
-    }
-  );
+  return args.command(cleanCommand).command(reinstallCommand).command(upCommand).command(updoCommand).command(staticsCommand).command(dupdepsCommand);
 };
 
-// src/xy/xyLintCommands.ts
-import chalk30 from "chalk";
+// src/xy/lint/cycleCommand.ts
+import chalk31 from "chalk";
+var cycleCommand = {
+  command: "cycle [package]",
+  describe: "Cycle - Check for dependency cycles",
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  handler: async (argv) => {
+    const start = Date.now();
+    if (argv.verbose) console.log("Cycle");
+    process.exitCode = await cycle({ pkg: argv.package });
+    console.log(chalk31.blue(`Finished in ${Date.now() - start}ms`));
+  }
+};
+
+// src/xy/lint/deplintCommand.ts
+import chalk32 from "chalk";
+var deplintCommand = {
+  command: "deplint [package]",
+  describe: "Deplint - Run Deplint",
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2).option("deps", {
+      alias: "d",
+      default: false,
+      description: "Check dependencies",
+      type: "boolean"
+    }).option("devDeps", {
+      alias: "v",
+      default: false,
+      description: "Check devDependencies",
+      type: "boolean"
+    }).option("peerDeps", {
+      alias: "p",
+      default: false,
+      description: "Check peerDependencies",
+      type: "boolean"
+    }).option("exclude", {
+      alias: "e",
+      description: "Package names to exclude from unused checks (comma-separated or repeated)",
+      type: "array"
+    });
+  },
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Deplint");
+    const start = Date.now();
+    const cliExclude = argv.exclude?.flatMap((v) => String(v).split(",")).map((v) => v.trim()).filter(Boolean);
+    process.exitCode = await deplint({
+      cliExclude,
+      pkg: argv.package,
+      deps: !!argv.deps,
+      devDeps: !!argv.devDeps,
+      peerDeps: !!argv.peerDeps,
+      verbose: !!argv.verbose
+    });
+    console.log(chalk32.blue(`Finished in ${Date.now() - start}ms`));
+  }
+};
+
+// src/xy/lint/fixCommand.ts
+import chalk33 from "chalk";
+var fixCommand = {
+  command: "fix [package]",
+  describe: "Fix - Run Eslint w/fix",
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  handler: (argv) => {
+    const start = Date.now();
+    if (argv.verbose) console.log("Fix");
+    process.exitCode = fix();
+    console.log(chalk33.blue(`Finished in ${Date.now() - start}ms`));
+  }
+};
+
+// src/xy/lint/knipCommand.ts
+import chalk34 from "chalk";
+var knipCommand = {
+  command: "knip",
+  describe: "Knip - Run Knip",
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  handler: (argv) => {
+    if (argv.verbose) console.log("Knip");
+    const start = Date.now();
+    process.exitCode = knip();
+    console.log(chalk34.blue(`Knip finished in ${Date.now() - start}ms`));
+  }
+};
+
+// src/xy/lint/lintCommand.ts
+import chalk35 from "chalk";
+var lintCommand = {
+  command: "lint [package]",
+  describe: "Lint - Run Eslint",
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2).option("fix", {
+      alias: "f",
+      default: false,
+      description: "Fix fixable issues",
+      type: "boolean"
+    }).option("cache", {
+      alias: "c",
+      default: false,
+      description: "Use caching for performance",
+      type: "boolean"
+    });
+  },
+  handler: (argv) => {
+    if (argv.verbose) console.log("Lint");
+    const start = Date.now();
+    process.exitCode = argv.fix ? fix({
+      pkg: argv.package,
+      cache: argv.cache,
+      verbose: !!argv.verbose
+    }) : lint({
+      pkg: argv.package,
+      cache: argv.cache,
+      verbose: !!argv.verbose
+    });
+    console.log(chalk35.blue(`Finished in ${Date.now() - start}ms`));
+  }
+};
+
+// src/xy/lint/publintCommand.ts
+import chalk36 from "chalk";
+var publintCommand = {
+  command: "publint [package]",
+  describe: "Publint - Run Publint",
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Publint");
+    const start = Date.now();
+    process.exitCode = await publint({ pkg: argv.package, verbose: !!argv.verbose });
+    console.log(chalk36.blue(`Finished in ${Date.now() - start}ms`));
+  }
+};
+
+// src/xy/lint/relintCommand.ts
+import chalk37 from "chalk";
+var relintCommand = {
+  command: "relint [package]",
+  describe: "Relint - Clean & Lint",
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  handler: (argv) => {
+    if (argv.verbose) console.log("Relinting");
+    const start = Date.now();
+    process.exitCode = relint();
+    console.log(chalk37.blue(`Finished in ${Date.now() - start}ms`));
+  }
+};
+
+// src/xy/lint/sonarCommand.ts
+import chalk38 from "chalk";
+var sonarCommand = {
+  command: "sonar",
+  describe: "Sonar - Run Sonar Check",
+  builder: (yargs2) => {
+    return packagePositionalParam(yargs2);
+  },
+  handler: (argv) => {
+    const start = Date.now();
+    if (argv.verbose) console.log("Sonar Check");
+    process.exitCode = sonar();
+    console.log(chalk38.blue(`Finished in ${Date.now() - start}ms`));
+  }
+};
+
+// src/xy/lint/index.ts
 var xyLintCommands = (args) => {
-  return args.command(
-    "cycle [package]",
-    "Cycle - Check for dependency cycles",
-    (yargs2) => {
-      return packagePositionalParam(yargs2);
-    },
-    async (argv) => {
-      const start = Date.now();
-      if (argv.verbose) console.log("Cycle");
-      process.exitCode = await cycle({ pkg: argv.package });
-      console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
-    }
-  ).command(
-    "lint [package]",
-    "Lint - Run Eslint",
-    (yargs2) => {
-      return packagePositionalParam(yargs2).option("fix", {
-        alias: "f",
-        default: false,
-        description: "Fix fixable issues",
-        type: "boolean"
-      }).option("cache", {
-        alias: "c",
-        default: false,
-        description: "Use caching for performance",
-        type: "boolean"
-      });
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Lint");
-      const start = Date.now();
-      process.exitCode = argv.fix ? fix({
-        pkg: argv.package,
-        cache: argv.cache,
-        verbose: !!argv.verbose
-      }) : lint({
-        pkg: argv.package,
-        cache: argv.cache,
-        verbose: !!argv.verbose
-      });
-      console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
-    }
-  ).command(
-    "deplint [package]",
-    "Deplint - Run Deplint",
-    (yargs2) => {
-      return packagePositionalParam(yargs2).option("deps", {
-        alias: "d",
-        default: false,
-        description: "Check dependencies",
-        type: "boolean"
-      }).option("devDeps", {
-        alias: "v",
-        default: false,
-        description: "Check devDependencies",
-        type: "boolean"
-      }).option("peerDeps", {
-        alias: "p",
-        default: false,
-        description: "Check peerDependencies",
-        type: "boolean"
-      }).option("exclude", {
-        alias: "e",
-        description: "Package names to exclude from unused checks (comma-separated or repeated)",
-        type: "array"
-      });
-    },
-    async (argv) => {
-      if (argv.verbose) console.log("Deplint");
-      const start = Date.now();
-      const cliExclude = argv.exclude?.flatMap((v) => String(v).split(",")).map((v) => v.trim()).filter(Boolean);
-      process.exitCode = await deplint({
-        cliExclude,
-        pkg: argv.package,
-        deps: !!argv.deps,
-        devDeps: !!argv.devDeps,
-        peerDeps: !!argv.peerDeps,
-        verbose: !!argv.verbose
-      });
-      console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
-    }
-  ).command(
-    "fix [package]",
-    "Fix - Run Eslint w/fix",
-    (yargs2) => {
-      return packagePositionalParam(yargs2);
-    },
-    (argv) => {
-      const start = Date.now();
-      if (argv.verbose) console.log("Fix");
-      process.exitCode = fix();
-      console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
-    }
-  ).command(
-    "relint [package]",
-    "Relint - Clean & Lint",
-    (yargs2) => {
-      return packagePositionalParam(yargs2);
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Relinting");
-      const start = Date.now();
-      process.exitCode = relint();
-      console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
-    }
-  ).command(
-    "publint [package]",
-    "Publint - Run Publint",
-    (yargs2) => {
-      return packagePositionalParam(yargs2);
-    },
-    async (argv) => {
-      if (argv.verbose) console.log("Publint");
-      const start = Date.now();
-      process.exitCode = await publint({ pkg: argv.package, verbose: !!argv.verbose });
-      console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
-    }
-  ).command(
-    "knip",
-    "Knip - Run Knip",
-    (yargs2) => {
-      return packagePositionalParam(yargs2);
-    },
-    (argv) => {
-      if (argv.verbose) console.log("Knip");
-      const start = Date.now();
-      process.exitCode = knip();
-      console.log(chalk30.blue(`Knip finished in ${Date.now() - start}ms`));
-    }
-  ).command(
-    "sonar",
-    "Sonar - Run Sonar Check",
-    (yargs2) => {
-      return packagePositionalParam(yargs2);
-    },
-    (argv) => {
-      const start = Date.now();
-      if (argv.verbose) console.log("Sonar Check");
-      process.exitCode = sonar();
-      console.log(chalk30.blue(`Finished in ${Date.now() - start}ms`));
-    }
-  );
+  return args.command(cycleCommand).command(lintCommand).command(deplintCommand).command(fixCommand).command(relintCommand).command(publintCommand).command(knipCommand).command(sonarCommand);
 };
 
 // src/xy/xyParseOptions.ts
@@ -2877,8 +3217,8 @@ var xyParseOptions = () => {
 var xy = async () => {
   const options = xyParseOptions();
   return await xyBuildCommands(xyCommonCommands(xyInstallCommands(xyDeployCommands(xyLintCommands(options))))).demandCommand(1).command("*", "", () => {
-    console.error(chalk31.yellow(`Command not found [${chalk31.magenta(process.argv[2])}]`));
-    console.log(chalk31.gray("Try 'yarn xy --help' for list of commands"));
+    console.error(chalk39.yellow(`Command not found [${chalk39.magenta(process.argv[2])}]`));
+    console.log(chalk39.gray("Try 'yarn xy --help' for list of commands"));
   }).version().help().argv;
 };
 export {