@xylabs/ts-scripts-yarn3 7.4.20 → 7.4.22

package/dist/xy/common/index.mjs

@@ -23,7 +23,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");
@@ -61,7 +62,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/deleteGlob.ts
 import fs from "fs";
@@ -195,19 +196,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(chalk3.green(`Generate ${filename3} Files`));
+var generateIgnoreFiles = (filename2, pkg) => {
+  console.log(chalk3.green(`Generate ${filename2} Files`));
   const cwd = 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(cwd), 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;
     }
   });
@@ -437,6 +438,15 @@ async function generateReadmeFiles({
   return failed ? 1 : 0;
 }
 
+// src/lib/gitignoreTemplate.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { createRequire as createRequire3 } from "module";
+import PATH3 from "path";
+var require4 = createRequire3(import.meta.url);
+var packageRoot3 = PATH3.dirname(require4.resolve("@xylabs/ts-scripts-yarn3/package.json"));
+var templatesDir2 = PATH3.resolve(packageRoot3, "templates", "gitignore");
+var gitignoreTemplate = () => readFileSync4(PATH3.resolve(templatesDir2, "template.gitignore"), "utf8");
+
 // src/lib/loadConfig.ts
 import chalk5 from "chalk";
 import { cosmiconfig } from "cosmiconfig";
@@ -489,25 +499,85 @@ var runSteps = (name, steps, exitOnFail = true, messages) => {
   }, !!exitOnFail);
 };
 
-// src/actions/claude-commands.ts
+// src/actions/claude-clean.ts
 import {
   existsSync as existsSync3,
-  mkdirSync,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync4,
-  unlinkSync,
-  writeFileSync as writeFileSync2
+  rmSync,
+  unlinkSync
 } from "fs";
-import PATH3 from "path";
+import PATH4 from "path";
 import chalk7 from "chalk";
+function removeFile(filePath, label) {
+  if (existsSync3(filePath)) {
+    unlinkSync(filePath);
+    console.log(chalk7.yellow(`  Removed ${label}`));
+    return true;
+  }
+  return false;
+}
+function removeDir(dirPath, label) {
+  if (existsSync3(dirPath)) {
+    rmSync(dirPath, { recursive: true });
+    console.log(chalk7.yellow(`  Removed ${label}`));
+    return true;
+  }
+  return false;
+}
+function claudeClean() {
+  console.log(chalk7.green("Clean Claude configuration"));
+  const cwd = INIT_CWD() ?? process.cwd();
+  let removed = 0;
+  const rootFiles = ["CLAUDE.md", "CLAUDE.local.md"];
+  for (const file of rootFiles) {
+    if (removeFile(PATH4.resolve(cwd, file), file)) removed++;
+  }
+  if (removeDir(PATH4.resolve(cwd, ".claude"), ".claude/")) removed++;
+  const packagesDir = PATH4.resolve(cwd, "packages");
+  if (existsSync3(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(chalk7.green(`  Removed ${removed} item(s)`));
+  } else {
+    console.log(chalk7.gray("  Nothing to clean"));
+  }
+  return 0;
+}
+
+// src/actions/claude-commands.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync5,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import PATH5 from "path";
+import chalk8 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 = existsSync3(targetPath) ? readFileSync4(targetPath, "utf8") : void 0;
+  for (const [filename2, content] of Object.entries(templates)) {
+    const targetPath = PATH5.resolve(commandsDir, filename2);
+    const existing = existsSync4(targetPath) ? readFileSync5(targetPath, "utf8") : void 0;
     if (existing === content) continue;
     writeFileSync2(targetPath, content, "utf8");
     if (existing) {
@@ -523,16 +593,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 = [
@@ -540,44 +617,46 @@ var logCommandsResult = (created, updated, removed) => {
       updated ? `${updated} updated` : "",
       removed ? `${removed} removed` : ""
     ].filter(Boolean);
-    console.log(chalk7.green(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: ${parts.join(", ")}`));
+    console.log(chalk8.green(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: ${parts.join(", ")}`));
   } else {
-    console.log(chalk7.gray(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: already up to date`));
+    console.log(chalk8.gray(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: already up to date`));
   }
 };
 var claudeCommands = () => {
   const cwd = INIT_CWD() ?? process.cwd();
-  const commandsDir = PATH3.resolve(cwd, ".claude", "commands");
+  const commandsDir = PATH5.resolve(cwd, ".claude", "commands");
   mkdirSync(commandsDir, { recursive: true });
+  const legacy = removeLegacyCommands(commandsDir);
   const {
     created,
     templateNames,
     updated
   } = syncCommandFiles(commandsDir);
   const removed = removeStaleCommands(commandsDir, templateNames);
-  logCommandsResult(created, updated, removed);
+  logCommandsResult(created, updated, removed + legacy);
   return 0;
 };
 
 // src/actions/claude-rules.ts
+import { spawnSync as spawnSync4 } from "child_process";
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync2,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync5,
-  unlinkSync as unlinkSync2,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync6,
+  unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync3
 } from "fs";
-import PATH4 from "path";
-import chalk8 from "chalk";
+import PATH6 from "path";
+import chalk9 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 = existsSync4(targetPath) ? readFileSync5(targetPath, "utf8") : void 0;
+  for (const [filename2, content] of Object.entries(templates)) {
+    const targetPath = PATH6.resolve(rulesDir, filename2);
+    const existing = existsSync5(targetPath) ? readFileSync6(targetPath, "utf8") : void 0;
     if (existing === content) continue;
     writeFileSync3(targetPath, content, "utf8");
     if (existing) {
@@ -593,11 +672,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++;
     }
   }
@@ -610,26 +689,44 @@ var logRulesResult = (created, updated, removed) => {
       updated ? `${updated} updated` : "",
       removed ? `${removed} removed` : ""
     ].filter(Boolean);
-    console.log(chalk8.green(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: ${parts.join(", ")}`));
+    console.log(chalk9.green(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: ${parts.join(", ")}`));
   } else {
-    console.log(chalk8.gray(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: already up to date`));
+    console.log(chalk9.gray(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: already up to date`));
   }
 };
 var ensureProjectClaudeMd = (cwd, force) => {
-  const projectPath = PATH4.resolve(cwd, "CLAUDE.md");
-  if (!existsSync4(projectPath) || force) {
-    if (force && existsSync4(projectPath)) {
-      console.log(chalk8.yellow("Overwriting existing CLAUDE.md"));
+  const projectPath = PATH6.resolve(cwd, "CLAUDE.md");
+  if (!existsSync5(projectPath) || force) {
+    if (force && existsSync5(projectPath)) {
+      console.log(chalk9.yellow("Regenerating CLAUDE.md"));
+    }
+    console.log(chalk9.green("Generating CLAUDE.md via claude /init..."));
+    const result = spawnSync4("claude", ["-p", "/init", "--allowedTools", "Read", "Write", "Glob", "Grep"], {
+      cwd,
+      shell: true,
+      stdio: "inherit"
+    });
+    if (result.status !== 0) {
+      console.error(chalk9.red("claude /init failed \u2014 is Claude Code installed?"));
+      return 1;
     }
-    writeFileSync3(projectPath, claudeMdProjectTemplate(), "utf8");
-    console.log(chalk8.green("Generated CLAUDE.md"));
   } else {
-    console.log(chalk8.gray("CLAUDE.md already exists (skipped)"));
+    console.log(chalk9.gray("CLAUDE.md already exists (skipped, use --force to regenerate)"));
+  }
+  return 0;
+};
+var ensureLocalClaudeMd = (cwd) => {
+  const localPath = PATH6.resolve(cwd, "CLAUDE.local.md");
+  if (existsSync5(localPath)) {
+    console.log(chalk9.gray("CLAUDE.local.md already exists (skipped)"));
+  } else {
+    writeFileSync3(localPath, claudeMdLocalTemplate(), "utf8");
+    console.log(chalk9.green("Generated CLAUDE.local.md"));
   }
 };
 var claudeRules = ({ force } = {}) => {
   const cwd = INIT_CWD() ?? process.cwd();
-  const rulesDir = PATH4.resolve(cwd, ".claude", "rules");
+  const rulesDir = PATH6.resolve(cwd, ".claude", "rules");
   mkdirSync2(rulesDir, { recursive: true });
   const {
     created,
@@ -638,19 +735,20 @@ var claudeRules = ({ force } = {}) => {
   } = syncRuleFiles(rulesDir);
   const removed = removeStaleRules(rulesDir, templateNames);
   logRulesResult(created, updated, removed);
-  ensureProjectClaudeMd(cwd, force);
-  return 0;
+  const claudeMdResult = ensureProjectClaudeMd(cwd, force);
+  ensureLocalClaudeMd(cwd);
+  return claudeMdResult ?? 0;
 };
 
 // src/actions/claude-settings.ts
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync3,
   writeFileSync as writeFileSync4
 } from "fs";
-import PATH5 from "path";
+import PATH7 from "path";
 import { createInterface as createInterface2 } from "readline";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 var DEFAULT_SETTINGS = {
   permissions: {
     allow: [
@@ -695,48 +793,48 @@ function askConfirmation2(question) {
 }
 async function claudeSettings() {
   const cwd = INIT_CWD() ?? process.cwd();
-  const claudeDir = PATH5.resolve(cwd, ".claude");
-  const settingsPath = PATH5.resolve(claudeDir, "settings.local.json");
+  const claudeDir = PATH7.resolve(cwd, ".claude");
+  const settingsPath = PATH7.resolve(claudeDir, "settings.local.json");
   mkdirSync3(claudeDir, { recursive: true });
-  if (existsSync5(settingsPath)) {
+  if (existsSync6(settingsPath)) {
     const confirmed = await askConfirmation2(
-      chalk9.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
+      chalk10.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
     );
     if (!confirmed) {
-      console.log(chalk9.gray("Skipped \u2014 existing settings.local.json preserved"));
+      console.log(chalk10.gray("Skipped \u2014 existing settings.local.json preserved"));
       return 0;
     }
   }
   writeFileSync4(settingsPath, `${JSON.stringify(DEFAULT_SETTINGS, null, 2)}
 `, "utf8");
-  console.log(chalk9.green("Generated .claude/settings.local.json"));
+  console.log(chalk10.green("Generated .claude/settings.local.json"));
   return 0;
 }
 
 // src/actions/claude-skills.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync6,
-  rmSync,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync7,
+  rmSync as rmSync2,
   statSync as statSync2,
   writeFileSync as writeFileSync5
 } from "fs";
-import PATH6 from "path";
-import chalk10 from "chalk";
+import PATH8 from "path";
+import chalk11 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 = existsSync6(targetPath) ? readFileSync6(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 = existsSync7(targetPath) ? readFileSync7(targetPath, "utf8") : void 0;
       if (existing === content) continue;
       writeFileSync5(targetPath, content, "utf8");
       if (existing) {
@@ -753,13 +851,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++;
     }
   }
@@ -772,14 +870,14 @@ var logSkillsResult = (created, updated, removed) => {
       updated ? `${updated} updated` : "",
       removed ? `${removed} removed` : ""
     ].filter(Boolean);
-    console.log(chalk10.green(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: ${parts.join(", ")}`));
+    console.log(chalk11.green(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: ${parts.join(", ")}`));
   } else {
-    console.log(chalk10.gray(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: already up to date`));
+    console.log(chalk11.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");
+  const skillsDir = PATH8.resolve(cwd, ".claude", "skills");
   mkdirSync4(skillsDir, { recursive: true });
   const {
     created,
@@ -793,10 +891,10 @@ var claudeSkills = () => {
 
 // src/actions/clean-docs.ts
 import path from "path";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 var cleanDocs = () => {
   const pkgName = process.env.npm_package_name;
-  console.log(chalk11.green(`Cleaning Docs [${pkgName}]`));
+  console.log(chalk12.green(`Cleaning Docs [${pkgName}]`));
   for (const { location } of yarnWorkspaces()) deleteGlob(path.join(location, "docs"));
   return 0;
 };
@@ -820,12 +918,96 @@ 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 chalk13 from "chalk";
+var COMMENT_PREFIX = "#";
+var isComment = (line) => line.startsWith(COMMENT_PREFIX);
+var isNegation = (line) => line.startsWith("!");
+function parseTemplateSections(lines) {
+  const sections = [];
+  let current = [];
+  for (const line of lines) {
+    if (isComment(line)) {
+      if (current.length > 0) {
+        sections.push(current);
+      }
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  if (current.length > 0) {
+    sections.push(current);
+  }
+  return sections;
+}
+function mergeWithTemplate(existing, templateContent) {
+  const templateLines = templateContent.split("\n").filter((line) => line.trim().length > 0);
+  const sections = parseTemplateSections(templateLines);
+  const existingEntries = new Set(existing.filter((line) => !isComment(line)));
+  const templateEntries = new Set(templateLines.filter((line) => !isComment(line)));
+  const customEntries = [...existingEntries].filter((entry) => !templateEntries.has(entry));
+  const result = [];
+  for (const section of sections) {
+    for (const line of section) {
+      result.push(line);
+    }
+    result.push("");
+  }
+  if (customEntries.length > 0) {
+    result.push("# Custom");
+    const sorted = [...union(customEntries, [])].toSorted((a, b) => {
+      if (isNegation(a) && !isNegation(b)) return 1;
+      if (!isNegation(a) && isNegation(b)) return -1;
+      return a.localeCompare(b);
+    });
+    for (const entry of sorted) {
+      result.push(entry);
+    }
+    result.push("");
+  }
+  return result;
+}
+function removePackageGitignores(cwd) {
+  let removed = 0;
+  const workspaces = yarnWorkspaces();
+  for (const { location } of workspaces) {
+    if (location === ".") continue;
+    const filePath = `${cwd}/${location}/.gitignore`;
+    try {
+      unlinkSync4(filePath);
+      console.log(chalk13.yellow(`  Removed ${location}/.gitignore`));
+      removed++;
+    } catch {
+    }
+  }
+  return removed;
+}
+function gitignore() {
+  console.log(chalk13.green("Generate .gitignore"));
+  const cwd = INIT_CWD() ?? ".";
+  const gitignorePath = `${cwd}/.gitignore`;
+  try {
+    const templateContent = gitignoreTemplate();
+    const existing = readNonEmptyLines(gitignorePath);
+    const merged = mergeWithTemplate(existing, templateContent);
+    writeLines(gitignorePath, merged);
+    console.log(chalk13.green("  Root .gitignore updated"));
+    const removed = removePackageGitignores(cwd);
+    if (removed > 0) {
+      console.log(chalk13.green(`  Removed ${removed} package .gitignore file(s)`));
+    }
+    return 0;
+  } catch (ex) {
+    const error = ex;
+    console.error(chalk13.red(`Generate .gitignore failed: ${error.message}`));
+    return 1;
+  }
+}
 
 // src/actions/gitlint.ts
-import chalk12 from "chalk";
+import chalk14 from "chalk";
 import ParseGitConfig from "parse-git-config";
 var gitlint = () => {
   console.log(`
@@ -836,7 +1018,7 @@ Gitlint Start [${process.cwd()}]
   const errors = 0;
   const gitConfig = ParseGitConfig.sync();
   const warn = (message) => {
-    console.warn(chalk12.yellow(`Warning: ${message}`));
+    console.warn(chalk14.yellow(`Warning: ${message}`));
     warnings++;
   };
   if (gitConfig.core.ignorecase) {
@@ -856,13 +1038,13 @@ Gitlint Start [${process.cwd()}]
   }
   const resultMessages = [];
   if (valid > 0) {
-    resultMessages.push(chalk12.green(`Passed: ${valid}`));
+    resultMessages.push(chalk14.green(`Passed: ${valid}`));
   }
   if (warnings > 0) {
-    resultMessages.push(chalk12.yellow(`Warnings: ${warnings}`));
+    resultMessages.push(chalk14.yellow(`Warnings: ${warnings}`));
   }
   if (errors > 0) {
-    resultMessages.push(chalk12.red(` Errors: ${errors}`));
+    resultMessages.push(chalk14.red(` Errors: ${errors}`));
   }
   console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
 `);
@@ -871,7 +1053,7 @@ Gitlint Start [${process.cwd()}]
 
 // src/actions/gitlint-fix.ts
 import { execSync as execSync2 } from "child_process";
-import chalk13 from "chalk";
+import chalk15 from "chalk";
 import ParseGitConfig2 from "parse-git-config";
 var gitlintFix = () => {
   console.log(`
@@ -880,21 +1062,21 @@ Gitlint Fix Start [${process.cwd()}]
   const gitConfig = ParseGitConfig2.sync();
   if (gitConfig.core.ignorecase) {
     execSync2("git config core.ignorecase false", { stdio: "inherit" });
-    console.warn(chalk13.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+    console.warn(chalk15.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
   }
   if (gitConfig.core.autocrlf !== false) {
     execSync2("git config core.autocrlf false", { stdio: "inherit" });
-    console.warn(chalk13.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+    console.warn(chalk15.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
   }
   if (gitConfig.core.eol !== "lf") {
     execSync2("git config core.eol lf", { stdio: "inherit" });
-    console.warn(chalk13.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+    console.warn(chalk15.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
   }
   return 1;
 };
 
 // src/actions/license.ts
-import chalk14 from "chalk";
+import chalk16 from "chalk";
 import { init } from "license-checker";
 var license = async (pkg) => {
   const workspaces = yarnWorkspaces();
@@ -919,18 +1101,18 @@ var license = async (pkg) => {
     "LGPL-3.0-or-later",
     "Python-2.0"
   ]);
-  console.log(chalk14.green("License Checker"));
+  console.log(chalk16.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(chalk14.red(`License Checker [${name}] Error`));
-            console.error(chalk14.gray(error));
+            console.error(chalk16.red(`License Checker [${name}] Error`));
+            console.error(chalk16.gray(error));
             console.log("\n");
             resolve(1);
           } else {
-            console.log(chalk14.green(`License Checker [${name}]`));
+            console.log(chalk16.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];
@@ -946,7 +1128,7 @@ var license = async (pkg) => {
                   }
                   if (!orLicenseFound) {
                     count++;
-                    console.warn(chalk14.yellow(`${name2}: Package License not allowed [${license2}]`));
+                    console.warn(chalk16.yellow(`${name2}: Package License not allowed [${license2}]`));
                   }
                 }
               }
@@ -961,8 +1143,8 @@ 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/readme-gen.ts
 async function readmeGen({
@@ -1028,6 +1210,16 @@ var yarn3Only = () => {
   return 0;
 };
 
+// src/xy/common/claude/cleanCommand.ts
+var cleanCommand = {
+  command: "clean",
+  describe: "Remove all Claude configuration files from the repo",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Clean");
+    process.exitCode = claudeClean();
+  }
+};
+
 // src/xy/common/claude/commandsCommand.ts
 var commandsCommand = {
   command: "commands",
@@ -1058,14 +1250,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 = {
@@ -1095,10 +1279,21 @@ var settingsCommand = {
   }
 };
 
+// src/xy/common/claude/skillsCommand.ts
+var skillsCommand = {
+  builder: (yargs) => yargs,
+  command: "skills",
+  describe: "Sync XY Labs standard Claude skills to .claude/skills/",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Skills");
+    process.exitCode = claudeSkills();
+  }
+};
+
 // src/xy/common/claude/index.ts
 var claudeCommand = {
   builder: (yargs) => {
-    return yargs.command(commandsCommand).command(initCommand).command(rulesCommand).command(settingsCommand).command(initClaudeSkillsCommand).demandCommand(1, "Please specify a claude subcommand");
+    return yargs.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",
@@ -1147,13 +1342,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();
   }
 };
 
@@ -1300,7 +1495,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);
 };
 export {
   xyCommonCommands