@xylabs/ts-scripts-yarn3 7.4.20 → 7.4.22

package/dist/index.mjs

@@ -26,7 +26,8 @@ var require2 = createRequire(import.meta.url);
 var packageRoot = PATH.dirname(require2.resolve("@xylabs/ts-scripts-yarn3/package.json"));
 var templatesDir = PATH.resolve(packageRoot, "templates", "claude");
 var XYLABS_RULES_PREFIX = "xylabs-";
-var XYLABS_COMMANDS_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");
@@ -65,6 +66,7 @@ var claudeSkillTemplates = () => {
   return result;
 };
 var claudeMdProjectTemplate = () => readFileSync(PATH.resolve(templatesDir, "CLAUDE-project.md"), "utf8");
+var claudeMdLocalTemplate = () => readFileSync(PATH.resolve(templatesDir, "CLAUDE-local.md"), "utf8");
 
 // src/lib/createBuildConfig.ts
 import { readFileSync as readFileSync2 } from "fs";
@@ -382,19 +384,19 @@ var INIT_CWD = () => {
 // src/lib/generateIgnoreFiles.ts
 var localeCompare = (a, b) => a.localeCompare(b);
 var mergeEntries = (a, b) => [...union(a, b)].toSorted(localeCompare);
-var generateIgnoreFiles = (filename3, pkg) => {
-  console.log(chalk4.green(`Generate ${filename3} Files`));
+var generateIgnoreFiles = (filename2, pkg) => {
+  console.log(chalk4.green(`Generate ${filename2} Files`));
   const cwd5 = INIT_CWD() ?? ".";
   const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
-  const readEntries = (location) => readNonEmptyLines(`${location}/${filename3}`);
-  const writeEntries = (location, entries) => writeLines(`${location}/${filename3}`, entries);
+  const readEntries = (location) => readNonEmptyLines(`${location}/${filename2}`);
+  const writeEntries = (location, entries) => writeLines(`${location}/${filename2}`, entries);
   const results = workspaces.map(({ location, name }) => {
     try {
       writeEntries(location, mergeEntries(readEntries(cwd5), readEntries(location)));
       return 0;
     } catch (ex) {
       const error = ex;
-      console.error(`Generate ${filename3} Files [${name}] [${error.message}]`);
+      console.error(`Generate ${filename2} Files [${name}] [${error.message}]`);
       return 1;
     }
   });
@@ -624,6 +626,15 @@ async function generateReadmeFiles({
   return failed ? 1 : 0;
 }
 
+// src/lib/gitignoreTemplate.ts
+import { readFileSync as readFileSync6 } 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-yarn3/package.json"));
+var templatesDir2 = PATH3.resolve(packageRoot3, "templates", "gitignore");
+var gitignoreTemplate = () => readFileSync6(PATH3.resolve(templatesDir2, "template.gitignore"), "utf8");
+
 // src/lib/loadConfig.ts
 import chalk6 from "chalk";
 import { cosmiconfig } from "cosmiconfig";
@@ -646,10 +657,10 @@ var loadConfig = async (params) => {
 };
 
 // src/lib/parsedPackageJSON.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 var parsedPackageJSON = (path14) => {
   const pathToPackageJSON = path14 ?? process.env.npm_package_json ?? "";
-  const packageJSON = readFileSync6(pathToPackageJSON).toString();
+  const packageJSON = readFileSync7(pathToPackageJSON).toString();
   return JSON.parse(packageJSON);
 };
 
@@ -777,25 +788,85 @@ var build = async ({
   return result;
 };
 
-// src/actions/claude-commands.ts
+// src/actions/claude-clean.ts
 import {
   existsSync as existsSync5,
-  mkdirSync,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync7,
-  unlinkSync,
-  writeFileSync as writeFileSync2
+  rmSync,
+  unlinkSync
 } from "fs";
-import PATH3 from "path";
+import PATH4 from "path";
 import chalk11 from "chalk";
+function removeFile(filePath, label) {
+  if (existsSync5(filePath)) {
+    unlinkSync(filePath);
+    console.log(chalk11.yellow(`  Removed ${label}`));
+    return true;
+  }
+  return false;
+}
+function removeDir(dirPath, label) {
+  if (existsSync5(dirPath)) {
+    rmSync(dirPath, { recursive: true });
+    console.log(chalk11.yellow(`  Removed ${label}`));
+    return true;
+  }
+  return false;
+}
+function claudeClean() {
+  console.log(chalk11.green("Clean Claude configuration"));
+  const cwd5 = INIT_CWD() ?? process.cwd();
+  let removed = 0;
+  const rootFiles = ["CLAUDE.md", "CLAUDE.local.md"];
+  for (const file of rootFiles) {
+    if (removeFile(PATH4.resolve(cwd5, file), file)) removed++;
+  }
+  if (removeDir(PATH4.resolve(cwd5, ".claude"), ".claude/")) removed++;
+  const packagesDir = PATH4.resolve(cwd5, "packages");
+  if (existsSync5(packagesDir)) {
+    const findClaudeFiles = (dir, prefix) => {
+      const entries = readdirSync2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = PATH4.resolve(dir, entry.name);
+        const label = `${prefix}${entry.name}`;
+        if (entry.isFile() && (entry.name === "CLAUDE.md" || entry.name === "CLAUDE.local.md")) {
+          if (removeFile(fullPath, label)) removed++;
+        } else if (entry.isDirectory() && entry.name === ".claude") {
+          if (removeDir(fullPath, `${label}/`)) removed++;
+        } else if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist") {
+          findClaudeFiles(fullPath, `${label}/`);
+        }
+      }
+    };
+    findClaudeFiles(packagesDir, "packages/");
+  }
+  if (removed > 0) {
+    console.log(chalk11.green(`  Removed ${removed} item(s)`));
+  } else {
+    console.log(chalk11.gray("  Nothing to clean"));
+  }
+  return 0;
+}
+
+// src/actions/claude-commands.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync8,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import PATH5 from "path";
+import chalk12 from "chalk";
 var syncCommandFiles = (commandsDir) => {
   const templates = claudeCommandTemplates();
   const templateNames = new Set(Object.keys(templates));
   let updated = 0;
   let created = 0;
-  for (const [filename3, content] of Object.entries(templates)) {
-    const targetPath = PATH3.resolve(commandsDir, filename3);
-    const existing = existsSync5(targetPath) ? readFileSync7(targetPath, "utf8") : void 0;
+  for (const [filename2, content] of Object.entries(templates)) {
+    const targetPath = PATH5.resolve(commandsDir, filename2);
+    const existing = existsSync6(targetPath) ? readFileSync8(targetPath, "utf8") : void 0;
     if (existing === content) continue;
     writeFileSync2(targetPath, content, "utf8");
     if (existing) {
@@ -811,16 +882,23 @@ var syncCommandFiles = (commandsDir) => {
   };
 };
 var removeStaleCommands = (commandsDir, templateNames) => {
-  const existingCommands = readdirSync2(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md"));
+  const existingCommands = readdirSync3(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md"));
   let removed = 0;
   for (const file of existingCommands) {
     if (!templateNames.has(file)) {
-      unlinkSync(PATH3.resolve(commandsDir, file));
+      unlinkSync2(PATH5.resolve(commandsDir, file));
       removed++;
     }
   }
   return removed;
 };
+var removeLegacyCommands = (commandsDir) => {
+  const legacyFiles = readdirSync3(commandsDir).filter((f) => f.startsWith(LEGACY_COMMANDS_PREFIX) && f.endsWith(".md"));
+  for (const file of legacyFiles) {
+    unlinkSync2(PATH5.resolve(commandsDir, file));
+  }
+  return legacyFiles.length;
+};
 var logCommandsResult = (created, updated, removed) => {
   if (created || updated || removed) {
     const parts = [
@@ -828,44 +906,46 @@ var logCommandsResult = (created, updated, removed) => {
       updated ? `${updated} updated` : "",
       removed ? `${removed} removed` : ""
     ].filter(Boolean);
-    console.log(chalk11.green(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: ${parts.join(", ")}`));
+    console.log(chalk12.green(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: ${parts.join(", ")}`));
   } else {
-    console.log(chalk11.gray(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: already up to date`));
+    console.log(chalk12.gray(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: already up to date`));
   }
 };
 var claudeCommands = () => {
   const cwd5 = INIT_CWD() ?? process.cwd();
-  const commandsDir = PATH3.resolve(cwd5, ".claude", "commands");
+  const commandsDir = PATH5.resolve(cwd5, ".claude", "commands");
   mkdirSync(commandsDir, { recursive: true });
+  const legacy = removeLegacyCommands(commandsDir);
   const {
     created,
     templateNames,
     updated
   } = syncCommandFiles(commandsDir);
   const removed = removeStaleCommands(commandsDir, templateNames);
-  logCommandsResult(created, updated, removed);
+  logCommandsResult(created, updated, removed + legacy);
   return 0;
 };
 
 // src/actions/claude-rules.ts
+import { spawnSync as spawnSync4 } from "child_process";
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync2,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync8,
-  unlinkSync as unlinkSync2,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync9,
+  unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync3
 } from "fs";
-import PATH4 from "path";
-import chalk12 from "chalk";
+import PATH6 from "path";
+import chalk13 from "chalk";
 var syncRuleFiles = (rulesDir) => {
   const templates = claudeMdRuleTemplates();
   const templateNames = new Set(Object.keys(templates));
   let updated = 0;
   let created = 0;
-  for (const [filename3, content] of Object.entries(templates)) {
-    const targetPath = PATH4.resolve(rulesDir, filename3);
-    const existing = existsSync6(targetPath) ? readFileSync8(targetPath, "utf8") : void 0;
+  for (const [filename2, content] of Object.entries(templates)) {
+    const targetPath = PATH6.resolve(rulesDir, filename2);
+    const existing = existsSync7(targetPath) ? readFileSync9(targetPath, "utf8") : void 0;
     if (existing === content) continue;
     writeFileSync3(targetPath, content, "utf8");
     if (existing) {
@@ -881,11 +961,11 @@ var syncRuleFiles = (rulesDir) => {
   };
 };
 var removeStaleRules = (rulesDir, templateNames) => {
-  const existingRules = readdirSync3(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md"));
+  const existingRules = readdirSync4(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md"));
   let removed = 0;
   for (const file of existingRules) {
     if (!templateNames.has(file)) {
-      unlinkSync2(PATH4.resolve(rulesDir, file));
+      unlinkSync3(PATH6.resolve(rulesDir, file));
       removed++;
     }
   }
@@ -898,26 +978,44 @@ var logRulesResult = (created, updated, removed) => {
       updated ? `${updated} updated` : "",
       removed ? `${removed} removed` : ""
     ].filter(Boolean);
-    console.log(chalk12.green(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: ${parts.join(", ")}`));
+    console.log(chalk13.green(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: ${parts.join(", ")}`));
   } else {
-    console.log(chalk12.gray(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: already up to date`));
+    console.log(chalk13.gray(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: already up to date`));
   }
 };
 var ensureProjectClaudeMd = (cwd5, force) => {
-  const projectPath = PATH4.resolve(cwd5, "CLAUDE.md");
-  if (!existsSync6(projectPath) || force) {
-    if (force && existsSync6(projectPath)) {
-      console.log(chalk12.yellow("Overwriting existing CLAUDE.md"));
+  const projectPath = PATH6.resolve(cwd5, "CLAUDE.md");
+  if (!existsSync7(projectPath) || force) {
+    if (force && existsSync7(projectPath)) {
+      console.log(chalk13.yellow("Regenerating CLAUDE.md"));
+    }
+    console.log(chalk13.green("Generating CLAUDE.md via claude /init..."));
+    const result = spawnSync4("claude", ["-p", "/init", "--allowedTools", "Read", "Write", "Glob", "Grep"], {
+      cwd: cwd5,
+      shell: true,
+      stdio: "inherit"
+    });
+    if (result.status !== 0) {
+      console.error(chalk13.red("claude /init failed \u2014 is Claude Code installed?"));
+      return 1;
     }
-    writeFileSync3(projectPath, claudeMdProjectTemplate(), "utf8");
-    console.log(chalk12.green("Generated CLAUDE.md"));
   } else {
-    console.log(chalk12.gray("CLAUDE.md already exists (skipped)"));
+    console.log(chalk13.gray("CLAUDE.md already exists (skipped, use --force to regenerate)"));
+  }
+  return 0;
+};
+var ensureLocalClaudeMd = (cwd5) => {
+  const localPath = PATH6.resolve(cwd5, "CLAUDE.local.md");
+  if (existsSync7(localPath)) {
+    console.log(chalk13.gray("CLAUDE.local.md already exists (skipped)"));
+  } else {
+    writeFileSync3(localPath, claudeMdLocalTemplate(), "utf8");
+    console.log(chalk13.green("Generated CLAUDE.local.md"));
   }
 };
 var claudeRules = ({ force } = {}) => {
   const cwd5 = INIT_CWD() ?? process.cwd();
-  const rulesDir = PATH4.resolve(cwd5, ".claude", "rules");
+  const rulesDir = PATH6.resolve(cwd5, ".claude", "rules");
   mkdirSync2(rulesDir, { recursive: true });
   const {
     created,
@@ -926,19 +1024,20 @@ var claudeRules = ({ force } = {}) => {
   } = syncRuleFiles(rulesDir);
   const removed = removeStaleRules(rulesDir, templateNames);
   logRulesResult(created, updated, removed);
-  ensureProjectClaudeMd(cwd5, force);
-  return 0;
+  const claudeMdResult = ensureProjectClaudeMd(cwd5, force);
+  ensureLocalClaudeMd(cwd5);
+  return claudeMdResult ?? 0;
 };
 
 // src/actions/claude-settings.ts
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync3,
   writeFileSync as writeFileSync4
 } from "fs";
-import PATH5 from "path";
+import PATH7 from "path";
 import { createInterface as createInterface2 } from "readline";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 var DEFAULT_SETTINGS = {
   permissions: {
     allow: [
@@ -983,48 +1082,48 @@ function askConfirmation2(question) {
 }
 async function claudeSettings() {
   const cwd5 = INIT_CWD() ?? process.cwd();
-  const claudeDir = PATH5.resolve(cwd5, ".claude");
-  const settingsPath = PATH5.resolve(claudeDir, "settings.local.json");
+  const claudeDir = PATH7.resolve(cwd5, ".claude");
+  const settingsPath = PATH7.resolve(claudeDir, "settings.local.json");
   mkdirSync3(claudeDir, { recursive: true });
-  if (existsSync7(settingsPath)) {
+  if (existsSync8(settingsPath)) {
     const confirmed = await askConfirmation2(
-      chalk13.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
+      chalk14.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
     );
     if (!confirmed) {
-      console.log(chalk13.gray("Skipped \u2014 existing settings.local.json preserved"));
+      console.log(chalk14.gray("Skipped \u2014 existing settings.local.json preserved"));
       return 0;
     }
   }
   writeFileSync4(settingsPath, `${JSON.stringify(DEFAULT_SETTINGS, null, 2)}
 `, "utf8");
-  console.log(chalk13.green("Generated .claude/settings.local.json"));
+  console.log(chalk14.green("Generated .claude/settings.local.json"));
   return 0;
 }
 
 // src/actions/claude-skills.ts
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync9,
-  rmSync,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync10,
+  rmSync as rmSync2,
   statSync as statSync2,
   writeFileSync as writeFileSync5
 } from "fs";
-import PATH6 from "path";
-import chalk14 from "chalk";
+import PATH8 from "path";
+import chalk15 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);
+    const skillDir = PATH8.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 = existsSync8(targetPath) ? readFileSync9(targetPath, "utf8") : void 0;
+    for (const [filename2, content] of Object.entries(files)) {
+      const targetPath = PATH8.resolve(skillDir, filename2);
+      mkdirSync4(PATH8.dirname(targetPath), { recursive: true });
+      const existing = existsSync9(targetPath) ? readFileSync10(targetPath, "utf8") : void 0;
       if (existing === content) continue;
       writeFileSync5(targetPath, content, "utf8");
       if (existing) {
@@ -1041,13 +1140,13 @@ var syncSkillFiles = (skillsDir) => {
   };
 };
 var removeStaleSkills = (skillsDir, templateNames) => {
-  const existingSkills = readdirSync4(skillsDir).filter(
-    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync2(PATH6.resolve(skillsDir, f)).isDirectory()
+  const existingSkills = readdirSync5(skillsDir).filter(
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync2(PATH8.resolve(skillsDir, f)).isDirectory()
   );
   let removed = 0;
   for (const dir of existingSkills) {
     if (!templateNames.has(dir)) {
-      rmSync(PATH6.resolve(skillsDir, dir), { recursive: true });
+      rmSync2(PATH8.resolve(skillsDir, dir), { recursive: true });
       removed++;
     }
   }
@@ -1060,14 +1159,14 @@ var logSkillsResult = (created, updated, removed) => {
       updated ? `${updated} updated` : "",
       removed ? `${removed} removed` : ""
     ].filter(Boolean);
-    console.log(chalk14.green(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: ${parts.join(", ")}`));
+    console.log(chalk15.green(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: ${parts.join(", ")}`));
   } else {
-    console.log(chalk14.gray(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: already up to date`));
+    console.log(chalk15.gray(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: already up to date`));
   }
 };
 var claudeSkills = () => {
   const cwd5 = INIT_CWD() ?? process.cwd();
-  const skillsDir = PATH6.resolve(cwd5, ".claude", "skills");
+  const skillsDir = PATH8.resolve(cwd5, ".claude", "skills");
   mkdirSync4(skillsDir, { recursive: true });
   const {
     created,
@@ -1093,16 +1192,16 @@ var cleanAll = ({ verbose }) => {
 
 // src/actions/clean-docs.ts
 import path from "path";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 var cleanDocs = () => {
   const pkgName = process.env.npm_package_name;
-  console.log(chalk15.green(`Cleaning Docs [${pkgName}]`));
+  console.log(chalk16.green(`Cleaning Docs [${pkgName}]`));
   for (const { location } of yarnWorkspaces()) deleteGlob(path.join(location, "docs"));
   return 0;
 };
 
 // src/actions/compile.ts
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 var compile = ({
   verbose,
   target,
@@ -1143,7 +1242,7 @@ var compileAll = ({
   const incrementalOptions = incremental ? ["--since", "-Ap", "--topological-dev"] : ["--parallel", "-Ap", "--topological-dev"];
   const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
   if (jobs) {
-    console.log(chalk16.blue(`Jobs set to [${jobs}]`));
+    console.log(chalk17.blue(`Jobs set to [${jobs}]`));
   }
   const result = runSteps(`Compile${incremental ? "-Incremental" : ""} [All]`, [
     ["yarn", [
@@ -1157,13 +1256,13 @@ var compileAll = ({
       ...targetOptions
     ]]
   ]);
-  console.log(`${chalk16.gray("Compiled in")} [${chalk16.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk16.gray("seconds")}`);
+  console.log(`${chalk17.gray("Compiled in")} [${chalk17.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk17.gray("seconds")}`);
   return result;
 };
 
 // src/actions/copy-assets.ts
 import path2 from "path/posix";
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 import cpy from "cpy";
 var copyPackageTargetAssets = async (target, name, location) => {
   try {
@@ -1186,7 +1285,7 @@ var copyPackageTargetAssets = async (target, name, location) => {
 };
 var copyTargetAssets = async (target, pkg) => {
   const workspaces = yarnWorkspaces();
-  console.log(chalk17.green(`Copying Assets [${target.toUpperCase()}]`));
+  console.log(chalk18.green(`Copying Assets [${target.toUpperCase()}]`));
   const workspaceList = workspaces.filter(({ name }) => {
     return pkg === void 0 || name === pkg;
   });
@@ -1270,7 +1369,7 @@ var dead = () => {
 };
 
 // src/actions/deplint/deplint.ts
-import chalk23 from "chalk";
+import chalk24 from "chalk";
 
 // src/actions/deplint/findFiles.ts
 import fs2 from "fs";
@@ -1475,7 +1574,7 @@ function getExternalImportsFromFiles({
 
 // src/actions/deplint/checkPackage/getUnlistedDependencies.ts
 import { builtinModules } from "module";
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 function isRuntimeImportListed(imp, name, dependencies, peerDependencies) {
   return dependencies.includes(imp) || imp === name || peerDependencies.includes(imp) || builtinModules.includes(imp);
 }
@@ -1483,7 +1582,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(`[${chalk18.blue(name)}] Missing dependency in package.json: ${chalk18.red(imp)}`);
+  console.log(`[${chalk19.blue(name)}] Missing dependency in package.json: ${chalk19.red(imp)}`);
   if (importPaths[imp]) {
     console.log(`  ${importPaths[imp].join("\n ")}`);
   }
@@ -1512,7 +1611,7 @@ function getUnlistedDependencies({ name, location }, {
   }
   if (unlistedDependencies > 0) {
     const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk18.yellow(packageLocation)}
+    console.log(`  ${chalk19.yellow(packageLocation)}
 `);
   }
   return unlistedDependencies;
@@ -1520,7 +1619,7 @@ function getUnlistedDependencies({ name, location }, {
 
 // src/actions/deplint/checkPackage/getUnlistedDevDependencies.ts
 import { builtinModules as builtinModules2 } from "module";
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 function getUnlistedDevDependencies({ name, location }, {
   devDependencies,
   dependencies,
@@ -1534,7 +1633,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(`[${chalk19.blue(name)}] Missing devDependency in package.json: ${chalk19.red(imp)}`);
+      console.log(`[${chalk20.blue(name)}] Missing devDependency in package.json: ${chalk20.red(imp)}`);
       if (allImportPaths[imp]) {
         console.log(`  ${allImportPaths[imp].join("\n ")}`);
       }
@@ -1542,14 +1641,14 @@ function getUnlistedDevDependencies({ name, location }, {
   }
   if (unlistedDevDependencies > 0) {
     const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk19.yellow(packageLocation)}
+    console.log(`  ${chalk20.yellow(packageLocation)}
 `);
   }
   return unlistedDevDependencies;
 }
 
 // src/actions/deplint/checkPackage/getUnusedDependencies.ts
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 function getUnusedDependencies({ name, location }, { dependencies }, {
   externalDistImports,
   externalDistTypeImports,
@@ -1561,22 +1660,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(`[${chalk20.blue(name)}] dependency should be devDependency in package.json: ${chalk20.red(dep)}`);
+        console.log(`[${chalk21.blue(name)}] dependency should be devDependency in package.json: ${chalk21.red(dep)}`);
       } else {
-        console.log(`[${chalk20.blue(name)}] Unused dependency in package.json: ${chalk20.red(dep)}`);
+        console.log(`[${chalk21.blue(name)}] Unused dependency 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;
 }
 
 // src/actions/deplint/checkPackage/getUnusedDevDependencies.ts
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 
 // src/actions/deplint/getCliReferencedPackagesFromFiles.ts
 import fs8 from "fs";
@@ -1860,19 +1959,19 @@ function getUnusedDevDependencies({ name, location }, {
     if (dependencies.includes(dep) || peerDependencies.includes(dep)) continue;
     if (!isDevDepUsed(dep, allImports, implicitDeps, requiredPeers, scriptRefs, cliRefs)) {
       unusedDevDependencies++;
-      console.log(`[${chalk21.blue(name)}] Unused devDependency in package.json: ${chalk21.red(dep)}`);
+      console.log(`[${chalk22.blue(name)}] Unused devDependency in package.json: ${chalk22.red(dep)}`);
     }
   }
   if (unusedDevDependencies > 0) {
     const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk21.yellow(packageLocation)}
+    console.log(`  ${chalk22.yellow(packageLocation)}
 `);
   }
   return unusedDevDependencies;
 }
 
 // src/actions/deplint/checkPackage/getUnusedPeerDependencies.ts
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 function getUnusedPeerDependencies({ name, location }, { peerDependencies, dependencies }, { externalDistImports, externalDistTypeImports }, exclude) {
   let unusedDependencies = 0;
   for (const dep of peerDependencies) {
@@ -1880,15 +1979,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(`[${chalk22.blue(name)}] Unused peerDependency [already a dependency] in package.json: ${chalk22.red(dep)}`);
+        console.log(`[${chalk23.blue(name)}] Unused peerDependency [already a dependency] in package.json: ${chalk23.red(dep)}`);
       } else {
-        console.log(`[${chalk22.blue(name)}] Unused peerDependency in package.json: ${chalk22.red(dep)}`);
+        console.log(`[${chalk23.blue(name)}] Unused peerDependency in package.json: ${chalk23.red(dep)}`);
       }
     }
   }
   if (unusedDependencies > 0) {
     const packageLocation = `${location}/package.json`;
-    console.log(`  ${chalk22.yellow(packageLocation)}
+    console.log(`  ${chalk23.yellow(packageLocation)}
 `);
   }
   return unusedDependencies;
@@ -1983,19 +2082,19 @@ var deplint = async ({
     });
   }
   if (totalErrors > 0) {
-    console.warn(`Deplint: Found ${chalk23.red(totalErrors)} dependency problems. ${chalk23.red("\u2716")}`);
+    console.warn(`Deplint: Found ${chalk24.red(totalErrors)} dependency problems. ${chalk24.red("\u2716")}`);
   } else {
-    console.info(`Deplint: Found no dependency problems. ${chalk23.green("\u2714")}`);
+    console.info(`Deplint: Found no dependency problems. ${chalk24.green("\u2714")}`);
   }
   return 0;
 };
 
 // src/actions/deploy.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 var privatePackageExcludeList = () => {
   const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
     workspace,
-    JSON.parse(readFileSync10(`${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}`);
@@ -2015,11 +2114,11 @@ var deploy = () => {
 };
 
 // src/actions/deploy-major.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 var privatePackageExcludeList2 = () => {
   const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
     workspace,
-    JSON.parse(readFileSync11(`${workspace.location}/package.json`, { encoding: "utf8" }))
+    JSON.parse(readFileSync12(`${workspace.location}/package.json`, { encoding: "utf8" }))
   ]);
   const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
   const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
@@ -2039,11 +2138,11 @@ var deployMajor = () => {
 };
 
 // src/actions/deploy-minor.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 var privatePackageExcludeList3 = () => {
   const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
     workspace,
-    JSON.parse(readFileSync12(`${workspace.location}/package.json`, { encoding: "utf8" }))
+    JSON.parse(readFileSync13(`${workspace.location}/package.json`, { encoding: "utf8" }))
   ]);
   const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
   const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
@@ -2063,11 +2162,11 @@ var deployMinor = () => {
 };
 
 // src/actions/deploy-next.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 var privatePackageExcludeList4 = () => {
   const possibleDeployablePackages = yarnWorkspaces().map((workspace) => [
     workspace,
-    JSON.parse(readFileSync13(`${workspace.location}/package.json`, { encoding: "utf8" }))
+    JSON.parse(readFileSync14(`${workspace.location}/package.json`, { encoding: "utf8" }))
   ]);
   const privatePackages = possibleDeployablePackages.filter(([_, pkg]) => pkg.private).map(([workspace]) => workspace);
   const excludeList = privatePackages.map((workspace) => `--exclude ${workspace.name}`);
@@ -2087,22 +2186,23 @@ var deployNext = () => {
 };
 
 // src/actions/dupdeps.ts
-import chalk24 from "chalk";
+import chalk25 from "chalk";
 var dupdeps = () => {
-  console.log(chalk24.green("Checking all Dependencies for Duplicates"));
-  const allDependencies = parsedPackageJSON()?.dependencies;
-  const dependencies = Object.entries(allDependencies).map(([k]) => k);
+  console.log(chalk25.green("Checking all Dependencies for Duplicates"));
+  const pkg = parsedPackageJSON();
+  const allDependencies = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  const dependencies = Object.keys(allDependencies);
   return detectDuplicateDependencies(dependencies);
 };
 
 // src/actions/lint.ts
-import chalk25 from "chalk";
+import chalk26 from "chalk";
 var lintPackage = ({
   pkg,
   fix: fix2,
   verbose
 }) => {
-  console.log(chalk25.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
+  console.log(chalk26.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
   const start = Date.now();
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
     ["yarn", [
@@ -2112,7 +2212,7 @@ var lintPackage = ({
       fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint"
     ]]
   ]);
-  console.log(chalk25.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk25.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk25.gray("seconds")}`));
+  console.log(chalk26.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk26.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk26.gray("seconds")}`));
   return result;
 };
 var lint = ({
@@ -2132,13 +2232,13 @@ var lint = ({
   });
 };
 var lintAllPackages = ({ fix: fix2 = false } = {}) => {
-  console.log(chalk25.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
+  console.log(chalk26.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
   const start = Date.now();
   const fixOptions = fix2 ? ["--fix"] : [];
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [All-Packages]`, [
     ["yarn", ["eslint", "--cache", "--cache-location", ".eslintcache", "--cache-strategy", "content", ...fixOptions]]
   ]);
-  console.log(chalk25.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk25.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk25.gray("seconds")}`));
+  console.log(chalk26.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk26.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk26.gray("seconds")}`));
   return result;
 };
 
@@ -2161,12 +2261,97 @@ var genDocsAll = ({ incremental }) => {
   return runSteps(`GenDocs [All${incremental ? "-Incremental" : ""}]`, [...steps]);
 };
 
-// src/actions/gitignore-gen.ts
-var filename = ".gitignore";
-var gitignoreGen = (pkg) => generateIgnoreFiles(filename, pkg);
+// src/actions/gitignore.ts
+import { unlinkSync as unlinkSync4 } from "fs";
+import chalk27 from "chalk";
+var COMMENT_PREFIX = "#";
+var isComment = (line) => line.startsWith(COMMENT_PREFIX);
+var isNegation = (line) => line.startsWith("!");
+function parseTemplateSections(lines) {
+  const sections = [];
+  let current = [];
+  for (const line of lines) {
+    if (isComment(line)) {
+      if (current.length > 0) {
+        sections.push(current);
+      }
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  if (current.length > 0) {
+    sections.push(current);
+  }
+  return sections;
+}
+function mergeWithTemplate(existing, templateContent) {
+  const templateLines = templateContent.split("\n").filter((line) => line.trim().length > 0);
+  const sections = parseTemplateSections(templateLines);
+  const existingEntries = new Set(existing.filter((line) => !isComment(line)));
+  const templateEntries = new Set(templateLines.filter((line) => !isComment(line)));
+  const customEntries = [...existingEntries].filter((entry) => !templateEntries.has(entry));
+  const result = [];
+  for (const section of sections) {
+    for (const line of section) {
+      result.push(line);
+    }
+    result.push("");
+  }
+  if (customEntries.length > 0) {
+    result.push("# Custom");
+    const sorted = [...union(customEntries, [])].toSorted((a, b) => {
+      if (isNegation(a) && !isNegation(b)) return 1;
+      if (!isNegation(a) && isNegation(b)) return -1;
+      return a.localeCompare(b);
+    });
+    for (const entry of sorted) {
+      result.push(entry);
+    }
+    result.push("");
+  }
+  return result;
+}
+function removePackageGitignores(cwd5) {
+  let removed = 0;
+  const workspaces = yarnWorkspaces();
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const filePath = `${cwd5}/${location}/.gitignore`;
+    try {
+      unlinkSync4(filePath);
+      console.log(chalk27.yellow(`  Removed ${location}/.gitignore`));
+      removed++;
+    } catch {
+    }
+  }
+  return removed;
+}
+var gitignoreGen = gitignore;
+function gitignore() {
+  console.log(chalk27.green("Generate .gitignore"));
+  const cwd5 = INIT_CWD() ?? ".";
+  const gitignorePath = `${cwd5}/.gitignore`;
+  try {
+    const templateContent = gitignoreTemplate();
+    const existing = readNonEmptyLines(gitignorePath);
+    const merged = mergeWithTemplate(existing, templateContent);
+    writeLines(gitignorePath, merged);
+    console.log(chalk27.green("  Root .gitignore updated"));
+    const removed = removePackageGitignores(cwd5);
+    if (removed > 0) {
+      console.log(chalk27.green(`  Removed ${removed} package .gitignore file(s)`));
+    }
+    return 0;
+  } catch (ex) {
+    const error = ex;
+    console.error(chalk27.red(`Generate .gitignore failed: ${error.message}`));
+    return 1;
+  }
+}
 
 // src/actions/gitlint.ts
-import chalk26 from "chalk";
+import chalk28 from "chalk";
 import ParseGitConfig from "parse-git-config";
 var gitlint = () => {
   console.log(`
@@ -2177,7 +2362,7 @@ Gitlint Start [${process.cwd()}]
   const errors = 0;
   const gitConfig = ParseGitConfig.sync();
   const warn = (message) => {
-    console.warn(chalk26.yellow(`Warning: ${message}`));
+    console.warn(chalk28.yellow(`Warning: ${message}`));
     warnings++;
   };
   if (gitConfig.core.ignorecase) {
@@ -2197,13 +2382,13 @@ Gitlint Start [${process.cwd()}]
   }
   const resultMessages = [];
   if (valid > 0) {
-    resultMessages.push(chalk26.green(`Passed: ${valid}`));
+    resultMessages.push(chalk28.green(`Passed: ${valid}`));
   }
   if (warnings > 0) {
-    resultMessages.push(chalk26.yellow(`Warnings: ${warnings}`));
+    resultMessages.push(chalk28.yellow(`Warnings: ${warnings}`));
   }
   if (errors > 0) {
-    resultMessages.push(chalk26.red(` Errors: ${errors}`));
+    resultMessages.push(chalk28.red(` Errors: ${errors}`));
   }
   console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
 `);
@@ -2212,7 +2397,7 @@ Gitlint Start [${process.cwd()}]
 
 // src/actions/gitlint-fix.ts
 import { execSync as execSync3 } from "child_process";
-import chalk27 from "chalk";
+import chalk29 from "chalk";
 import ParseGitConfig2 from "parse-git-config";
 var gitlintFix = () => {
   console.log(`
@@ -2221,15 +2406,15 @@ Gitlint Fix Start [${process.cwd()}]
   const gitConfig = ParseGitConfig2.sync();
   if (gitConfig.core.ignorecase) {
     execSync3("git config core.ignorecase false", { stdio: "inherit" });
-    console.warn(chalk27.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+    console.warn(chalk29.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
   }
   if (gitConfig.core.autocrlf !== false) {
     execSync3("git config core.autocrlf false", { stdio: "inherit" });
-    console.warn(chalk27.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+    console.warn(chalk29.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
   }
   if (gitConfig.core.eol !== "lf") {
     execSync3("git config core.eol lf", { stdio: "inherit" });
-    console.warn(chalk27.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+    console.warn(chalk29.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
   }
   return 1;
 };
@@ -2240,7 +2425,7 @@ var knip = () => {
 };
 
 // src/actions/license.ts
-import chalk28 from "chalk";
+import chalk30 from "chalk";
 import { init } from "license-checker";
 var license = async (pkg) => {
   const workspaces = yarnWorkspaces();
@@ -2265,18 +2450,18 @@ var license = async (pkg) => {
     "LGPL-3.0-or-later",
     "Python-2.0"
   ]);
-  console.log(chalk28.green("License Checker"));
+  console.log(chalk30.green("License Checker"));
   return (await Promise.all(
     workspaceList.map(({ location, name }) => {
       return new Promise((resolve) => {
         init({ production: true, start: location }, (error, packages) => {
           if (error) {
-            console.error(chalk28.red(`License Checker [${name}] Error`));
-            console.error(chalk28.gray(error));
+            console.error(chalk30.red(`License Checker [${name}] Error`));
+            console.error(chalk30.gray(error));
             console.log("\n");
             resolve(1);
           } else {
-            console.log(chalk28.green(`License Checker [${name}]`));
+            console.log(chalk30.green(`License Checker [${name}]`));
             let count = 0;
             for (const [name2, info] of Object.entries(packages)) {
               const licenses = Array.isArray(info.licenses) ? info.licenses : [info.licenses];
@@ -2292,7 +2477,7 @@ var license = async (pkg) => {
                   }
                   if (!orLicenseFound) {
                     count++;
-                    console.warn(chalk28.yellow(`${name2}: Package License not allowed [${license2}]`));
+                    console.warn(chalk30.yellow(`${name2}: Package License not allowed [${license2}]`));
                   }
                 }
               }
@@ -2307,17 +2492,17 @@ var license = async (pkg) => {
 };
 
 // src/actions/npmignore-gen.ts
-var filename2 = ".npmignore";
-var npmignoreGen = (pkg) => generateIgnoreFiles(filename2, pkg);
+var filename = ".npmignore";
+var npmignoreGen = (pkg) => generateIgnoreFiles(filename, pkg);
 
 // src/actions/package/clean-outputs.ts
 import path8 from "path";
-import chalk29 from "chalk";
+import chalk31 from "chalk";
 var packageCleanOutputs = () => {
   const pkg = process.env.INIT_CWD ?? ".";
   const pkgName = process.env.npm_package_name;
   const folders = [path8.join(pkg, "dist"), path8.join(pkg, "build"), path8.join(pkg, "docs")];
-  console.log(chalk29.green(`Cleaning Outputs [${pkgName}]`));
+  console.log(chalk31.green(`Cleaning Outputs [${pkgName}]`));
   for (let folder of folders) {
     deleteGlob(folder);
   }
@@ -2326,11 +2511,11 @@ var packageCleanOutputs = () => {
 
 // src/actions/package/clean-typescript.ts
 import path9 from "path";
-import chalk30 from "chalk";
+import chalk32 from "chalk";
 var packageCleanTypescript = () => {
   const pkg = process.env.INIT_CWD ?? ".";
   const pkgName = process.env.npm_package_name;
-  console.log(chalk30.green(`Cleaning Typescript [${pkgName}]`));
+  console.log(chalk32.green(`Cleaning Typescript [${pkgName}]`));
   const files = [path9.join(pkg, "*.tsbuildinfo"), path9.join(pkg, ".tsconfig.*"), path9.join(pkg, ".eslintcache")];
   for (let file of files) {
     deleteGlob(file);
@@ -2344,26 +2529,26 @@ var packageClean = async () => {
 };
 
 // src/actions/package/compile/compile.ts
-import chalk35 from "chalk";
+import chalk37 from "chalk";
 
 // src/actions/package/compile/packageCompileTsup.ts
-import chalk34 from "chalk";
+import chalk36 from "chalk";
 import { build as build2, defineConfig } from "tsup";
 
 // src/actions/package/compile/inputs.ts
-import chalk31 from "chalk";
+import chalk33 from "chalk";
 import { glob as glob2 } from "glob";
 var getAllInputs = (srcDir, verbose = false) => {
   return [...glob2.sync(`${srcDir}/**/*.ts`, { posix: true }).map((file) => {
     const result = file.slice(Math.max(0, srcDir.length + 1));
     if (verbose) {
-      console.log(chalk31.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+      console.log(chalk33.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
     }
     return result;
   }), ...glob2.sync(`${srcDir}/**/*.tsx`, { posix: true }).map((file) => {
     const result = file.slice(Math.max(0, srcDir.length + 1));
     if (verbose) {
-      console.log(chalk31.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
+      console.log(chalk33.gray(`getAllInputs: ${JSON.stringify(result, null, 2)}`));
     }
     return result;
   })];
@@ -2425,7 +2610,7 @@ function deepMergeObjects(objects) {
 
 // src/actions/package/compile/packageCompileTsc.ts
 import { cwd as cwd2 } from "process";
-import chalk32 from "chalk";
+import chalk34 from "chalk";
 import { createProgramFromConfig } from "tsc-prog";
 import ts3, {
   DiagnosticCategory,
@@ -2447,7 +2632,7 @@ var getCompilerOptions = (options = {}, fileName = "tsconfig.json") => {
 var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", compilerOptionsParam, verbose = false) => {
   const pkg = process.env.INIT_CWD ?? cwd2();
   if (verbose) {
-    console.log(chalk32.cyan(`Validating code START: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(chalk34.cyan(`Validating code START: ${entries.length} files to ${outDir} from ${srcDir}`));
   }
   const configFilePath = ts3.findConfigFile(
     "./",
@@ -2470,10 +2655,10 @@ var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", com
     emitDeclarationOnly: true,
     noEmit: false
   };
-  console.log(chalk32.cyan(`Validating Files: ${entries.length}`));
+  console.log(chalk34.cyan(`Validating Files: ${entries.length}`));
   if (verbose) {
     for (const entry of entries) {
-      console.log(chalk32.grey(`Validating: ${entry}`));
+      console.log(chalk34.grey(`Validating: ${entry}`));
     }
   }
   try {
@@ -2509,7 +2694,7 @@ var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", com
     return 0;
   } finally {
     if (verbose) {
-      console.log(chalk32.cyan(`Validating code FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+      console.log(chalk34.cyan(`Validating code FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
     }
   }
 };
@@ -2517,7 +2702,7 @@ var packageCompileTsc = (platform, entries, srcDir = "src", outDir = "dist", com
 // src/actions/package/compile/packageCompileTscTypes.ts
 import path10 from "path";
 import { cwd as cwd3 } from "process";
-import chalk33 from "chalk";
+import chalk35 from "chalk";
 import { rollup } from "rollup";
 import dts from "rollup-plugin-dts";
 import nodeExternals from "rollup-plugin-node-externals";
@@ -2542,8 +2727,8 @@ async function bundleDts(inputPath, outputPath, platform, options, verbose = fal
         if (ignoredWarningCodes.has(warning.code ?? "")) {
           return;
         }
-        console.warn(chalk33.yellow(`[${warning.code}] ${warning.message}`));
-        console.warn(chalk33.gray(inputPath));
+        console.warn(chalk35.yellow(`[${warning.code}] ${warning.message}`));
+        console.warn(chalk35.gray(inputPath));
         warn(warning);
       }
     });
@@ -2553,8 +2738,8 @@ async function bundleDts(inputPath, outputPath, platform, options, verbose = fal
     });
   } catch (ex) {
     const error = ex;
-    console.warn(chalk33.red(error));
-    console.warn(chalk33.gray(inputPath));
+    console.warn(chalk35.red(error));
+    console.warn(chalk35.gray(inputPath));
   }
   if (verbose) {
     console.log(`Bundled declarations written to ${outputPath}`);
@@ -2562,7 +2747,7 @@ async function bundleDts(inputPath, outputPath, platform, options, verbose = fal
 }
 var packageCompileTscTypes = async (entries, outDir, platform, srcDir = "build", verbose = false) => {
   if (verbose) {
-    console.log(chalk33.cyan(`Compiling Types START [${platform}]: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(chalk35.cyan(`Compiling Types START [${platform}]: ${entries.length} files to ${outDir} from ${srcDir}`));
     console.log(`Entries: ${entries.join(", ")}`);
   }
   const pkg = process.env.INIT_CWD ?? cwd3();
@@ -2586,7 +2771,7 @@ var packageCompileTscTypes = async (entries, outDir, platform, srcDir = "build",
     await bundleDts(`${srcRoot}/${entryTypeName}`, `${outDir}/${entryTypeName}`, platform, { compilerOptions }, verbose);
   }));
   if (verbose) {
-    console.log(chalk33.cyan(`Compiling Types FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
+    console.log(chalk35.cyan(`Compiling Types FINISH: ${entries.length} files to ${outDir} from ${srcDir}`));
   }
   return 0;
 };
@@ -2598,15 +2783,15 @@ var compileFolder = async (srcDir, entries, buildDir, options, bundleTypes = fal
     console.log(`compileFolder [${srcDir}, ${options?.outDir}]`);
   }
   if (entries.length === 0) {
-    console.warn(chalk34.yellow(`No entries found in ${srcDir} to compile`));
+    console.warn(chalk36.yellow(`No entries found in ${srcDir} to compile`));
     return 0;
   }
   if (verbose) {
-    console.log(chalk34.gray(`buildDir [${buildDir}]`));
+    console.log(chalk36.gray(`buildDir [${buildDir}]`));
   }
   const validationResult = packageCompileTsc(options?.platform ?? "neutral", entries, srcDir, buildDir, void 0, verbose);
   if (validationResult !== 0) {
-    console.error(chalk34.red(`Compile:Validation had ${validationResult} errors`));
+    console.error(chalk36.red(`Compile:Validation had ${validationResult} errors`));
     return validationResult;
   }
   const optionsParams = tsupOptions([{
@@ -2631,12 +2816,12 @@ var compileFolder = async (srcDir, entries, buildDir, options, bundleTypes = fal
     })
   )).flat();
   if (verbose) {
-    console.log(chalk34.cyan(`TSUP:build:start [${srcDir}]`));
-    console.log(chalk34.gray(`TSUP:build:options [${JSON.stringify(optionsList, null, 2)}]`));
+    console.log(chalk36.cyan(`TSUP:build:start [${srcDir}]`));
+    console.log(chalk36.gray(`TSUP:build:options [${JSON.stringify(optionsList, null, 2)}]`));
   }
   await Promise.all(optionsList.map((options2) => build2(options2)));
   if (verbose) {
-    console.log(chalk34.cyan(`TSUP:build:stop [${srcDir}]`));
+    console.log(chalk36.cyan(`TSUP:build:stop [${srcDir}]`));
   }
   if (bundleTypes) {
     await packageCompileTscTypes(entries, outDir, options?.platform ?? "neutral", buildDir, verbose);
@@ -2747,14 +2932,14 @@ var packageCompileTsup = async (config2) => {
 // src/actions/package/compile/compile.ts
 var packageCompile = async (inConfig = {}) => {
   const pkg = process.env.INIT_CWD;
-  console.log(chalk35.green(`Compiling ${pkg}`));
+  console.log(chalk37.green(`Compiling ${pkg}`));
   const config2 = await loadConfig(inConfig);
   return await packageCompileTsup(config2);
 };
 
 // src/actions/package/copy-assets.ts
 import path11 from "path/posix";
-import chalk36 from "chalk";
+import chalk38 from "chalk";
 import cpy2 from "cpy";
 var copyTargetAssets2 = async (target, name, location) => {
   try {
@@ -2767,7 +2952,7 @@ var copyTargetAssets2 = async (target, name, location) => {
       }
     );
     if (values.length > 0) {
-      console.log(chalk36.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
+      console.log(chalk38.green(`Copying Assets [${target.toUpperCase()}] - ${name} - ${location}`));
     }
     for (const value of values) {
       console.log(`${value.split("/").pop()} => ./dist/${target}`);
@@ -2832,9 +3017,9 @@ var packageCycle = async () => {
 };
 
 // src/actions/package/gen-docs.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import path12 from "path";
-import chalk37 from "chalk";
+import chalk39 from "chalk";
 import {
   Application,
   ArgumentsReader,
@@ -2852,7 +3037,7 @@ var ExitCodes = {
 };
 var packageGenDocs = async () => {
   const pkg = process.env.INIT_CWD;
-  if (pkg !== void 0 && !existsSync9(path12.join(pkg, "typedoc.json"))) {
+  if (pkg !== void 0 && !existsSync10(path12.join(pkg, "typedoc.json"))) {
     return;
   }
   const app = await Application.bootstrap({
@@ -2938,16 +3123,16 @@ var runTypeDoc = async (app) => {
       return ExitCodes.OutputError;
     }
   }
-  console.log(chalk37.green(`${pkgName} - Ok`));
+  console.log(chalk39.green(`${pkgName} - Ok`));
   return ExitCodes.Ok;
 };
 
 // src/actions/package/lint.ts
-import { readdirSync as readdirSync5 } from "fs";
+import { readdirSync as readdirSync6 } from "fs";
 import path13 from "path";
 import { cwd as cwd4 } from "process";
 import { pathToFileURL } from "url";
-import chalk38 from "chalk";
+import chalk40 from "chalk";
 import { ESLint } from "eslint";
 import { findUp } from "find-up";
 import picomatch from "picomatch";
@@ -2956,14 +3141,14 @@ var dumpMessages = (lintResults) => {
   const severity = ["none", "warning", "error"];
   for (const lintResult of lintResults) {
     if (lintResult.messages.length > 0) {
-      console.log(chalk38.gray(`
+      console.log(chalk40.gray(`
 ${lintResult.filePath}`));
       for (const message of lintResult.messages) {
         console.log(
-          chalk38.gray(`	${message.line}:${message.column}`),
-          chalk38[colors[message.severity]](`	${severity[message.severity]}`),
-          chalk38.white(`	${message.message}`),
-          chalk38.gray(`	${message.ruleId}`)
+          chalk40.gray(`	${message.line}:${message.column}`),
+          chalk40[colors[message.severity]](`	${severity[message.severity]}`),
+          chalk40.white(`	${message.message}`),
+          chalk40.gray(`	${message.ruleId}`)
         );
       }
     }
@@ -2980,7 +3165,7 @@ function getFiles(dir, ignoreFolders) {
   const currentDirectory = cwd4();
   const subDirectory = dir.split(currentDirectory)[1]?.split("/")[1];
   if (ignoreFolders.includes(subDirectory)) return [];
-  return readdirSync5(dir, { withFileTypes: true }).flatMap((dirent) => {
+  return readdirSync6(dir, { withFileTypes: true }).flatMap((dirent) => {
     const res = path13.resolve(dir, dirent.name);
     const relativePath = subDirectory === void 0 ? dirent.name : `${subDirectory}/${dirent.name}`;
     const ignoreMatchers = ignoreFolders.map((pattern) => picomatch(pattern));
@@ -3001,10 +3186,10 @@ var packageLint = async (fix2 = false, verbose = false, cache = true) => {
     cache
   });
   const files = getFiles(cwd4(), ignoreFolders);
-  console.log(chalk38.green(`Linting ${pkg} [files = ${files.length}]`));
+  console.log(chalk40.green(`Linting ${pkg} [files = ${files.length}]`));
   if (verbose) {
     for (const file of files) {
-      console.log(chalk38.gray(`	${file}`));
+      console.log(chalk40.gray(`	${file}`));
     }
   }
   const lintResults = await engine.lintFiles(files);
@@ -3015,32 +3200,32 @@ var packageLint = async (fix2 = false, verbose = false, cache = true) => {
   const filesCountColor = files.length < 100 ? "green" : files.length < 1e3 ? "yellow" : "red";
   const lintTime = Date.now() - start;
   const lintTimeColor = lintTime < 1e3 ? "green" : lintTime < 3e3 ? "yellow" : "red";
-  console.log(chalk38.white(`Linted ${chalk38[filesCountColor](files.length)} files in ${chalk38[lintTimeColor](lintTime)}ms`));
+  console.log(chalk40.white(`Linted ${chalk40[filesCountColor](files.length)} files in ${chalk40[lintTimeColor](lintTime)}ms`));
   return lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0);
 };
 
 // src/actions/package/publint.ts
 import { promises as fs10 } from "fs";
-import chalk39 from "chalk";
+import chalk41 from "chalk";
 import sortPackageJson from "sort-package-json";
 var customPubLint = (pkg) => {
   let errorCount = 0;
   let warningCount = 0;
   if (pkg.files === void 0) {
-    console.warn(chalk39.yellow('Publint [custom]: "files" field is missing'));
+    console.warn(chalk41.yellow('Publint [custom]: "files" field is missing'));
     warningCount++;
   }
   if (pkg.main !== void 0) {
-    console.warn(chalk39.yellow('Publint [custom]: "main" field is deprecated, use "exports" instead'));
+    console.warn(chalk41.yellow('Publint [custom]: "main" field is deprecated, use "exports" instead'));
     warningCount++;
   }
   if (pkg.sideEffects !== false) {
-    console.warn(chalk39.yellow('Publint [custom]: "sideEffects" field should be set to false'));
+    console.warn(chalk41.yellow('Publint [custom]: "sideEffects" field should be set to false'));
     warningCount++;
   }
   if (pkg.resolutions !== void 0) {
-    console.warn(chalk39.yellow('Publint [custom]: "resolutions" in use'));
-    console.warn(chalk39.gray(JSON.stringify(pkg.resolutions, null, 2)));
+    console.warn(chalk41.yellow('Publint [custom]: "resolutions" in use'));
+    console.warn(chalk41.gray(JSON.stringify(pkg.resolutions, null, 2)));
     warningCount++;
   }
   return [errorCount, warningCount];
@@ -3050,8 +3235,8 @@ var packagePublint = async ({ strict = true, verbose = false } = {}) => {
   const sortedPkg = sortPackageJson(await fs10.readFile(`${pkgDir}/package.json`, "utf8"));
   await fs10.writeFile(`${pkgDir}/package.json`, sortedPkg);
   const pkg = JSON.parse(await fs10.readFile(`${pkgDir}/package.json`, "utf8"));
-  console.log(chalk39.green(`Publint: ${pkg.name}`));
-  console.log(chalk39.gray(pkgDir));
+  console.log(chalk41.green(`Publint: ${pkg.name}`));
+  console.log(chalk41.gray(pkgDir));
   const { publint: publint2 } = await import("publint");
   const { messages } = await publint2({
     level: "suggestion",
@@ -3062,22 +3247,22 @@ var packagePublint = async ({ strict = true, verbose = false } = {}) => {
   for (const message of messages) {
     switch (message.type) {
       case "error": {
-        console.error(chalk39.red(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.error(chalk41.red(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
       case "warning": {
-        console.warn(chalk39.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.warn(chalk41.yellow(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
       default: {
-        console.log(chalk39.white(`[${message.code}] ${formatMessage(message, pkg)}`));
+        console.log(chalk41.white(`[${message.code}] ${formatMessage(message, pkg)}`));
         break;
       }
     }
   }
   const [errorCount, warningCount] = customPubLint(pkg);
   if (verbose) {
-    console.log(chalk39.gray(`Publint [Finish]: ${pkgDir} [${messages.length + errorCount + warningCount} messages]`));
+    console.log(chalk41.gray(`Publint [Finish]: ${pkgDir} [${messages.length + errorCount + warningCount} messages]`));
   }
   return messages.filter((message) => message.type === "error").length + errorCount;
 };
@@ -3140,7 +3325,7 @@ var rebuild = ({ target }) => {
 };
 
 // src/actions/recompile.ts
-import chalk40 from "chalk";
+import chalk42 from "chalk";
 var recompile = async ({
   verbose,
   target,
@@ -3176,7 +3361,7 @@ var recompileAll = async ({
   const incrementalOptions = incremental ? ["--since", "-Apt", "--topological-dev"] : ["--parallel", "-Apt", "--topological-dev"];
   const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
   if (jobs) {
-    console.log(chalk40.blue(`Jobs set to [${jobs}]`));
+    console.log(chalk42.blue(`Jobs set to [${jobs}]`));
   }
   const result = await runStepsAsync(`Recompile${incremental ? "-Incremental" : ""} [All]`, [
     [
@@ -3207,7 +3392,7 @@ var recompileAll = async ({
     ]
   ]);
   console.log(
-    `${chalk40.gray("Recompiled in")} [${chalk40.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk40.gray("seconds")}`
+    `${chalk42.gray("Recompiled in")} [${chalk42.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk42.gray("seconds")}`
   );
   return result;
 };
@@ -3216,7 +3401,7 @@ var recompileAll = async ({
 import {
   closeSync,
   openSync,
-  rmSync as rmSync2
+  rmSync as rmSync3
 } from "fs";
 var reinstall = () => {
   console.log("Reinstall [Clear Lock File]");
@@ -3226,7 +3411,7 @@ var reinstall = () => {
   const result = workspaces.map(({ location, name }) => {
     const dist = `${location}/node_modules`;
     try {
-      rmSync2(dist, { force: true, recursive: true });
+      rmSync3(dist, { force: true, recursive: true });
       return 0;
     } catch (ex) {
       const error = ex;
@@ -3238,13 +3423,13 @@ var reinstall = () => {
 };
 
 // src/actions/relint.ts
-import chalk41 from "chalk";
+import chalk43 from "chalk";
 var relintPackage = ({
   pkg,
   fix: fix2,
   verbose
 }) => {
-  console.log(chalk41.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
+  console.log(chalk43.gray(`${fix2 ? "Fix" : "Lint"} [${pkg}]`));
   const start = Date.now();
   const result = runSteps(`${fix2 ? "Fix" : "Lint"}  [${pkg}]`, [
     ["yarn", [
@@ -3254,7 +3439,7 @@ var relintPackage = ({
       fix2 ? "package-fix" : verbose ? "package-lint-verbose" : "package-lint"
     ]]
   ]);
-  console.log(chalk41.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk41.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk41.gray("seconds")}`));
+  console.log(chalk43.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk43.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk43.gray("seconds")}`));
   return result;
 };
 var relint = ({
@@ -3274,13 +3459,13 @@ var relint = ({
   });
 };
 var relintAllPackages = ({ fix: fix2 = false } = {}) => {
-  console.log(chalk41.gray(`${fix2 ? "Fix" : "Lint"} [All-Packages]`));
+  console.log(chalk43.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(chalk41.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk41.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk41.gray("seconds")}`));
+  console.log(chalk43.gray(`${fix2 ? "Fixed in" : "Linted in"} [${chalk43.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk43.gray("seconds")}`));
   return result;
 };
 
@@ -3298,10 +3483,10 @@ var sonar = () => {
 };
 
 // src/actions/statics.ts
-import chalk42 from "chalk";
+import chalk44 from "chalk";
 var DefaultDependencies = ["axios", "@xylabs/pixel", "react", "graphql", "react-router", "@mui/material", "@mui/system"];
 var statics = () => {
-  console.log(chalk42.green("Check Required Static Dependencies"));
+  console.log(chalk44.green("Check Required Static Dependencies"));
   const statics2 = parsedPackageJSON()?.xy?.deps?.statics;
   return detectDuplicateDependencies(statics2, DefaultDependencies);
 };
@@ -3357,18 +3542,13 @@ var loadPackageConfig = async () => {
   return JSON.parse(pkgConfig);
 };
 
-// src/xy/param.ts
-var packagePositionalParam = (yargs2) => {
-  return yargs2.positional("package", { describe: "Specific package to target", type: "string" });
-};
-
-// src/xy/build-commands/build.ts
+// src/xy/build/buildCommand.ts
 var buildCommand = {
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
   command: "build [package]",
   describe: "Build - Compile & Lint",
+  builder: (yargs2) => {
+    return yargs2.positional("package", { describe: "Specific package to build" });
+  },
   handler: async (argv) => {
     if (argv.verbose) {
       console.log(`Building: ${argv.package ?? "all"}`);
@@ -3382,12 +3562,14 @@ var buildCommand = {
     });
   }
 };
+
+// src/xy/build/compileCommand.ts
 var compileCommand = {
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
   command: "compile [package]",
   describe: "Compile with Typescript & Copy Images",
+  builder: (yargs2) => {
+    return yargs2.positional("package", { describe: "Specific package to compile" });
+  },
   handler: (argv) => {
     if (argv.verbose) {
       console.log(`Compiling: ${argv.package ?? "all"}`);
@@ -3401,12 +3583,14 @@ var compileCommand = {
     });
   }
 };
+
+// src/xy/build/compileOnlyCommand.ts
 var compileOnlyCommand = {
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
   command: "compile-only [package]",
   describe: "Compile with Typescript & Copy Images (No Publint)",
+  builder: (yargs2) => {
+    return yargs2.positional("package", { describe: "Specific package to compile" });
+  },
   handler: (argv) => {
     if (argv.verbose) {
       console.log(`Compiling: ${argv.package ?? "all"}`);
@@ -3421,51 +3605,67 @@ var compileOnlyCommand = {
     });
   }
 };
-var recompileCommand = {
+
+// src/xy/build/copyAssetsCommand.ts
+var copyAssetsCommand = {
+  command: "copy-assets [package]",
+  describe: "Copy Assets - Copy the assets from src to dist",
   builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
+    return yargs2.positional("package", { describe: "Specific package to copy assets" });
   },
-  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
-    });
+    if (argv.verbose) console.log(`Copying Assets: ${argv.package ?? "all"}`);
+    process.exitCode = await copyAssets({ target: argv.target });
   }
 };
+
+// src/xy/build/rebuildCommand.ts
 var rebuildCommand = {
-  builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
-  },
   command: "rebuild [package]",
   describe: "Rebuild - Clean, Compile & Lint",
+  builder: (yargs2) => {
+    return yargs2.positional("package", { describe: "Specific package to rebuild" });
+  },
   handler: (argv) => {
     if (argv.verbose) console.log(`Rebuilding: ${argv.package ?? "all"}`);
     process.exitCode = rebuild({ target: argv.target });
   }
 };
-var copyAssetsCommand = {
+
+// src/xy/build/recompileCommand.ts
+var recompileCommand = {
+  command: "recompile [package]",
+  describe: "Re-compile with Typescript & Copy Images",
   builder: (yargs2) => {
-    return packagePositionalParam(yargs2);
+    return yargs2.positional("package", { describe: "Specific package to re-compile" });
   },
-  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 });
+    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
+    });
   }
 };
 
-// src/xy/build-commands/index.ts
+// src/xy/build/index.ts
 var xyBuildCommands = (args) => {
-  return args.command(buildCommand).command(compileCommand).command(compileOnlyCommand).command(rebuildCommand).command(recompileCommand).command(copyAssetsCommand);
+  return args.command(buildCommand).command(compileCommand).command(compileOnlyCommand).command(recompileCommand).command(rebuildCommand).command(copyAssetsCommand);
+};
+
+// 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
@@ -3498,14 +3698,6 @@ var initCommand = {
     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 = {
@@ -3535,10 +3727,21 @@ var settingsCommand = {
   }
 };
 
+// src/xy/common/claude/skillsCommand.ts
+var skillsCommand = {
+  builder: (yargs2) => yargs2,
+  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: (yargs2) => {
-    return yargs2.command(commandsCommand).command(initCommand).command(rulesCommand).command(settingsCommand).command(initClaudeSkillsCommand).demandCommand(1, "Please specify a claude subcommand");
+    return yargs2.command(cleanCommand).command(commandsCommand).command(initCommand).command(rulesCommand).command(settingsCommand).command(skillsCommand).demandCommand(1, "Please specify a claude subcommand");
   },
   command: "claude",
   describe: "Claude - Claude Code configuration utilities",
@@ -3556,6 +3759,11 @@ var cleanDocsCommand = {
   }
 };
 
+// src/xy/param.ts
+var packagePositionalParam = (yargs2) => {
+  return yargs2.positional("package", { describe: "Specific package to target", type: "string" });
+};
+
 // src/xy/common/deadCommand.ts
 var deadCommand = {
   builder: (yargs2) => {
@@ -3582,13 +3790,13 @@ var genDocsCommand = {
   }
 };
 
-// src/xy/common/gitignoreGenCommand.ts
-var gitignoreGenCommand = {
-  command: "gitignore-gen",
-  describe: "GitIgnore Gen - Generate .gitignore files",
+// 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 Gen");
-    process.exitCode = gitignoreGen();
+    if (argv.verbose) console.log("GitIgnore");
+    process.exitCode = gitignore();
   }
 };
 
@@ -3735,7 +3943,7 @@ var yarn3OnlyCommand = {
 
 // src/xy/common/index.ts
 var xyCommonCommands = (args) => {
-  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);
+  return args.command(claudeCommand).command(licenseCommand).command(deadCommand).command(genDocsCommand).command(cleanDocsCommand).command(gitlintCommand).command(gitignoreCommand).command(npmignoreGenCommand).command(readmeCommand).command(retestCommand).command(testCommand).command(upplugCommand).command(upyarnCommand).command(yarn3OnlyCommand);
 };
 
 // src/xy/deploy/deployCommand.ts
@@ -3794,7 +4002,7 @@ var xyDeployCommands = (args) => {
 };
 
 // src/xy/install/cleanCommand.ts
-var cleanCommand = {
+var cleanCommand2 = {
   command: "clean [package]",
   describe: "Clean",
   builder: (yargs2) => {
@@ -3863,11 +4071,11 @@ var updoCommand = {
 
 // src/xy/install/index.ts
 var xyInstallCommands = (args) => {
-  return args.command(cleanCommand).command(reinstallCommand).command(upCommand).command(updoCommand).command(staticsCommand).command(dupdepsCommand);
+  return args.command(cleanCommand2).command(reinstallCommand).command(upCommand).command(updoCommand).command(staticsCommand).command(dupdepsCommand);
 };
 
 // src/xy/lint/cycleCommand.ts
-import chalk43 from "chalk";
+import chalk45 from "chalk";
 var cycleCommand = {
   command: "cycle [package]",
   describe: "Cycle - Check for dependency cycles",
@@ -3878,12 +4086,12 @@ var cycleCommand = {
     const start = Date.now();
     if (argv.verbose) console.log("Cycle");
     process.exitCode = await cycle({ pkg: argv.package });
-    console.log(chalk43.blue(`Finished in ${Date.now() - start}ms`));
+    console.log(chalk45.blue(`Finished in ${Date.now() - start}ms`));
   }
 };
 
 // src/xy/lint/deplintCommand.ts
-import chalk44 from "chalk";
+import chalk46 from "chalk";
 var deplintCommand = {
   command: "deplint [package]",
   describe: "Deplint - Run Deplint",
@@ -3921,12 +4129,12 @@ var deplintCommand = {
       peerDeps: !!argv.peerDeps,
       verbose: !!argv.verbose
     });
-    console.log(chalk44.blue(`Finished in ${Date.now() - start}ms`));
+    console.log(chalk46.blue(`Finished in ${Date.now() - start}ms`));
   }
 };
 
 // src/xy/lint/fixCommand.ts
-import chalk45 from "chalk";
+import chalk47 from "chalk";
 var fixCommand = {
   command: "fix [package]",
   describe: "Fix - Run Eslint w/fix",
@@ -3937,12 +4145,12 @@ var fixCommand = {
     const start = Date.now();
     if (argv.verbose) console.log("Fix");
     process.exitCode = fix();
-    console.log(chalk45.blue(`Finished in ${Date.now() - start}ms`));
+    console.log(chalk47.blue(`Finished in ${Date.now() - start}ms`));
   }
 };
 
 // src/xy/lint/knipCommand.ts
-import chalk46 from "chalk";
+import chalk48 from "chalk";
 var knipCommand = {
   command: "knip",
   describe: "Knip - Run Knip",
@@ -3953,12 +4161,12 @@ var knipCommand = {
     if (argv.verbose) console.log("Knip");
     const start = Date.now();
     process.exitCode = knip();
-    console.log(chalk46.blue(`Knip finished in ${Date.now() - start}ms`));
+    console.log(chalk48.blue(`Knip finished in ${Date.now() - start}ms`));
   }
 };
 
 // src/xy/lint/lintCommand.ts
-import chalk47 from "chalk";
+import chalk49 from "chalk";
 var lintCommand = {
   command: "lint [package]",
   describe: "Lint - Run Eslint",
@@ -3987,12 +4195,12 @@ var lintCommand = {
       cache: argv.cache,
       verbose: !!argv.verbose
     });
-    console.log(chalk47.blue(`Finished in ${Date.now() - start}ms`));
+    console.log(chalk49.blue(`Finished in ${Date.now() - start}ms`));
   }
 };
 
 // src/xy/lint/publintCommand.ts
-import chalk48 from "chalk";
+import chalk50 from "chalk";
 var publintCommand = {
   command: "publint [package]",
   describe: "Publint - Run Publint",
@@ -4003,12 +4211,12 @@ var publintCommand = {
     if (argv.verbose) console.log("Publint");
     const start = Date.now();
     process.exitCode = await publint({ pkg: argv.package, verbose: !!argv.verbose });
-    console.log(chalk48.blue(`Finished in ${Date.now() - start}ms`));
+    console.log(chalk50.blue(`Finished in ${Date.now() - start}ms`));
   }
 };
 
 // src/xy/lint/relintCommand.ts
-import chalk49 from "chalk";
+import chalk51 from "chalk";
 var relintCommand = {
   command: "relint [package]",
   describe: "Relint - Clean & Lint",
@@ -4019,12 +4227,12 @@ var relintCommand = {
     if (argv.verbose) console.log("Relinting");
     const start = Date.now();
     process.exitCode = relint();
-    console.log(chalk49.blue(`Finished in ${Date.now() - start}ms`));
+    console.log(chalk51.blue(`Finished in ${Date.now() - start}ms`));
   }
 };
 
 // src/xy/lint/sonarCommand.ts
-import chalk50 from "chalk";
+import chalk52 from "chalk";
 var sonarCommand = {
   command: "sonar",
   describe: "Sonar - Run Sonar Check",
@@ -4035,7 +4243,7 @@ var sonarCommand = {
     const start = Date.now();
     if (argv.verbose) console.log("Sonar Check");
     process.exitCode = sonar();
-    console.log(chalk50.blue(`Finished in ${Date.now() - start}ms`));
+    console.log(chalk52.blue(`Finished in ${Date.now() - start}ms`));
   }
 };
 
@@ -4045,7 +4253,7 @@ var xyLintCommands = (args) => {
 };
 
 // src/xy/xy.ts
-import chalk51 from "chalk";
+import chalk53 from "chalk";
 
 // src/xy/xyParseOptions.ts
 import yargs from "yargs";
@@ -4078,8 +4286,8 @@ var xyParseOptions = () => {
 var xy = async () => {
   const options = xyParseOptions();
   return await xyBuildCommands(xyCommonCommands(xyInstallCommands(xyDeployCommands(xyLintCommands(options))))).demandCommand(1).command("*", "", () => {
-    console.error(chalk51.yellow(`Command not found [${chalk51.magenta(process.argv[2])}]`));
-    console.log(chalk51.gray("Try 'yarn xy --help' for list of commands"));
+    console.error(chalk53.yellow(`Command not found [${chalk53.magenta(process.argv[2])}]`));
+    console.log(chalk53.gray("Try 'yarn xy --help' for list of commands"));
   }).version().help().argv;
 };
 export {
@@ -4088,6 +4296,7 @@ export {
   DEFAULT_README_TEMPLATE,
   DuplicateDetector,
   INIT_CWD,
+  LEGACY_COMMANDS_PREFIX,
   WINDOWS_NEWLINE_REGEX,
   XYLABS_COMMANDS_PREFIX,
   XYLABS_RULES_PREFIX,
@@ -4096,8 +4305,10 @@ export {
   build,
   bundleDts,
   checkResult,
+  claudeClean,
   claudeCommandTemplates,
   claudeCommands,
+  claudeMdLocalTemplate,
   claudeMdProjectTemplate,
   claudeMdRuleTemplates,
   claudeRules,
@@ -4134,7 +4345,9 @@ export {
   genDocsPackage,
   generateIgnoreFiles,
   generateReadmeFiles,
+  gitignore,
   gitignoreGen,
+  gitignoreTemplate,
   gitlint,
   gitlintFix,
   isYarnVersionOrGreater,