@xylabs/toolchain 7.10.0

package/dist/xy/common/claude/index.mjs

@@ -0,0 +1,734 @@
+// src/lib/claudeMdTemplate.ts
+import {
+  readdirSync,
+  readFileSync,
+  statSync
+} from "fs";
+import { createRequire } from "module";
+import PATH from "path";
+var require2 = createRequire(import.meta.url);
+var packageRoot = PATH.dirname(require2.resolve("@xylabs/ts-scripts-common/package.json"));
+var templatesDir = PATH.resolve(packageRoot, "templates", "claude");
+function applyPackageManager(content, pm) {
+  return content.replaceAll("yarn xy", `${pm} xy`).replaceAll("yarn add", `${pm} add`);
+}
+var XYLABS_RULES_PREFIX = "xylabs-";
+var XYLABS_COMMANDS_PREFIX = "xy-";
+var LEGACY_COMMANDS_PREFIX = "xylabs-";
+var XYLABS_SKILLS_PREFIX = "xylabs-";
+var claudeMdRuleTemplates = () => {
+  const rulesDir = PATH.resolve(templatesDir, "rules");
+  const files = readdirSync(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md"));
+  const result = {};
+  for (const file of files) {
+    result[file] = readFileSync(PATH.resolve(rulesDir, file), "utf8");
+  }
+  return result;
+};
+var claudeCommandTemplates = () => {
+  const commandsDir = PATH.resolve(templatesDir, "commands");
+  const files = readdirSync(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md"));
+  const result = {};
+  for (const file of files) {
+    result[file] = readFileSync(PATH.resolve(commandsDir, file), "utf8");
+  }
+  return result;
+};
+var claudeSkillTemplates = () => {
+  const skillsDir = PATH.resolve(templatesDir, "skills");
+  const dirs = readdirSync(skillsDir).filter(
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync(PATH.resolve(skillsDir, f)).isDirectory()
+  );
+  const result = {};
+  for (const dir of dirs) {
+    const dirPath = PATH.resolve(skillsDir, dir);
+    const files = readdirSync(dirPath, { recursive: true, encoding: "utf8" });
+    result[dir] = {};
+    for (const file of files) {
+      if (statSync(PATH.resolve(dirPath, file)).isFile()) {
+        result[dir][file] = readFileSync(PATH.resolve(dirPath, file), "utf8");
+      }
+    }
+  }
+  return result;
+};
+var claudeMdLocalTemplate = () => readFileSync(PATH.resolve(templatesDir, "CLAUDE-local.md"), "utf8");
+
+// src/pm/detectPackageManager.ts
+import { existsSync } from "fs";
+function detectPackageManager() {
+  if (existsSync("pnpm-lock.yaml") || existsSync("pnpm-workspace.yaml")) return "pnpm";
+  return "yarn";
+}
+
+// src/lib/initCwd.ts
+function INIT_CWD() {
+  return process.env.INIT_CWD ?? process.cwd();
+}
+
+// src/actions/claude-check.ts
+import {
+  existsSync as existsSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  statSync as statSync2
+} from "fs";
+import PATH2 from "path";
+import chalk from "chalk";
+var checkCommands = (commandsDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeCommandTemplates();
+  const templates = {};
+  for (const [name, content] of Object.entries(rawTemplates)) {
+    templates[name] = applyPackageManager(content, pm);
+  }
+  const missing = [];
+  const outdated = [];
+  for (const [filename, content] of Object.entries(templates)) {
+    const targetPath = PATH2.resolve(commandsDir, filename);
+    if (!existsSync2(targetPath)) {
+      missing.push(filename);
+    } else if (readFileSync2(targetPath, "utf8") !== content) {
+      outdated.push(filename);
+    }
+  }
+  const templateNames = new Set(Object.keys(templates));
+  const stale = existsSync2(commandsDir) ? readdirSync2(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md") && !templateNames.has(f)) : [];
+  return {
+    missing,
+    outdated,
+    stale
+  };
+};
+var checkRules = (rulesDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeMdRuleTemplates();
+  const templates = {};
+  for (const [name, content] of Object.entries(rawTemplates)) {
+    templates[name] = applyPackageManager(content, pm);
+  }
+  const missing = [];
+  const outdated = [];
+  for (const [filename, content] of Object.entries(templates)) {
+    const targetPath = PATH2.resolve(rulesDir, filename);
+    if (!existsSync2(targetPath)) {
+      missing.push(filename);
+    } else if (readFileSync2(targetPath, "utf8") !== content) {
+      outdated.push(filename);
+    }
+  }
+  const templateNames = new Set(Object.keys(templates));
+  const stale = existsSync2(rulesDir) ? readdirSync2(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md") && !templateNames.has(f)) : [];
+  return {
+    missing,
+    outdated,
+    stale
+  };
+};
+var checkSkills = (skillsDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeSkillTemplates();
+  const missing = [];
+  const outdated = [];
+  for (const [skillName, files] of Object.entries(rawTemplates)) {
+    const skillDir = PATH2.resolve(skillsDir, skillName);
+    if (!existsSync2(skillDir)) {
+      missing.push(skillName);
+      continue;
+    }
+    for (const [filename, rawContent] of Object.entries(files)) {
+      const content = applyPackageManager(rawContent, pm);
+      const targetPath = PATH2.resolve(skillDir, filename);
+      if (!existsSync2(targetPath)) {
+        missing.push(`${skillName}/${filename}`);
+      } else if (readFileSync2(targetPath, "utf8") !== content) {
+        outdated.push(`${skillName}/${filename}`);
+      }
+    }
+  }
+  const templateNames = new Set(Object.keys(rawTemplates));
+  const stale = existsSync2(skillsDir) ? readdirSync2(skillsDir).filter(
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync2(PATH2.resolve(skillsDir, f)).isDirectory() && !templateNames.has(f)
+  ) : [];
+  return {
+    missing,
+    outdated,
+    stale
+  };
+};
+var logSection = (label, result) => {
+  const issues = [...result.missing, ...result.outdated, ...result.stale];
+  if (issues.length === 0) {
+    console.log(chalk.green(`  \u2714 ${label}`));
+    return true;
+  }
+  console.log(chalk.red(`  \u2718 ${label}`));
+  for (const file of result.missing) {
+    console.log(chalk.yellow(`      missing: ${file}`));
+  }
+  for (const file of result.outdated) {
+    console.log(chalk.yellow(`      outdated: ${file}`));
+  }
+  for (const file of result.stale) {
+    console.log(chalk.yellow(`      stale: ${file}`));
+  }
+  return false;
+};
+function claudeCheck() {
+  const cwd = INIT_CWD();
+  const claudeDir = PATH2.resolve(cwd, ".claude");
+  console.log(chalk.bold("Claude configuration check:"));
+  console.log();
+  const commandsResult = checkCommands(PATH2.resolve(claudeDir, "commands"));
+  const rulesResult = checkRules(PATH2.resolve(claudeDir, "rules"));
+  const skillsResult = checkSkills(PATH2.resolve(claudeDir, "skills"));
+  const commandsOk = logSection("commands", commandsResult);
+  const rulesOk = logSection("rules", rulesResult);
+  const skillsOk = logSection("skills", skillsResult);
+  console.log();
+  if (commandsOk && rulesOk && skillsOk) {
+    console.log(chalk.green("All Claude configuration is up to date."));
+  } else {
+    console.log(chalk.yellow("Run `xy claude init` to sync all configuration."));
+  }
+  return 0;
+}
+
+// src/actions/claude-clean.ts
+import {
+  existsSync as existsSync3,
+  readdirSync as readdirSync3,
+  rmSync,
+  unlinkSync
+} from "fs";
+import PATH3 from "path";
+import chalk2 from "chalk";
+function removeFile(filePath, label) {
+  if (existsSync3(filePath)) {
+    unlinkSync(filePath);
+    console.log(chalk2.yellow(`  Removed ${label}`));
+    return true;
+  }
+  return false;
+}
+function removeDir(dirPath, label) {
+  if (existsSync3(dirPath)) {
+    rmSync(dirPath, { recursive: true });
+    console.log(chalk2.yellow(`  Removed ${label}`));
+    return true;
+  }
+  return false;
+}
+function claudeClean() {
+  console.log(chalk2.green("Clean Claude configuration"));
+  const cwd = INIT_CWD();
+  let removed = 0;
+  const rootFiles = ["CLAUDE.md", "CLAUDE.local.md"];
+  for (const file of rootFiles) {
+    if (removeFile(PATH3.resolve(cwd, file), file)) removed++;
+  }
+  if (removeDir(PATH3.resolve(cwd, ".claude"), ".claude/")) removed++;
+  const packagesDir = PATH3.resolve(cwd, "packages");
+  if (existsSync3(packagesDir)) {
+    const findClaudeFiles = (dir, prefix) => {
+      const entries = readdirSync3(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = PATH3.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(chalk2.green(`  Removed ${removed} item(s)`));
+  } else {
+    console.log(chalk2.gray("  Nothing to clean"));
+  }
+  return 0;
+}
+
+// src/actions/claude-commands.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync3,
+  unlinkSync as unlinkSync2,
+  writeFileSync
+} from "fs";
+import PATH4 from "path";
+import chalk3 from "chalk";
+var syncCommandFiles = (commandsDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeCommandTemplates();
+  const templates = {};
+  for (const [name, content] of Object.entries(rawTemplates)) {
+    templates[name] = applyPackageManager(content, pm);
+  }
+  const templateNames = new Set(Object.keys(templates));
+  let updated = 0;
+  let created = 0;
+  for (const [filename, content] of Object.entries(templates)) {
+    const targetPath = PATH4.resolve(commandsDir, filename);
+    const existing = existsSync4(targetPath) ? readFileSync3(targetPath, "utf8") : void 0;
+    if (existing === content) continue;
+    writeFileSync(targetPath, content, "utf8");
+    if (existing) {
+      updated++;
+    } else {
+      created++;
+    }
+  }
+  return {
+    created,
+    templateNames,
+    updated
+  };
+};
+var removeStaleCommands = (commandsDir, templateNames) => {
+  const existingCommands = readdirSync4(commandsDir).filter((f) => f.startsWith(XYLABS_COMMANDS_PREFIX) && f.endsWith(".md"));
+  let removed = 0;
+  for (const file of existingCommands) {
+    if (!templateNames.has(file)) {
+      unlinkSync2(PATH4.resolve(commandsDir, file));
+      removed++;
+    }
+  }
+  return removed;
+};
+var removeLegacyCommands = (commandsDir) => {
+  const legacyFiles = readdirSync4(commandsDir).filter((f) => f.startsWith(LEGACY_COMMANDS_PREFIX) && f.endsWith(".md"));
+  for (const file of legacyFiles) {
+    unlinkSync2(PATH4.resolve(commandsDir, file));
+  }
+  return legacyFiles.length;
+};
+var logCommandsResult = (created, updated, removed) => {
+  if (created || updated || removed) {
+    const parts = [
+      created ? `${created} created` : "",
+      updated ? `${updated} updated` : "",
+      removed ? `${removed} removed` : ""
+    ].filter(Boolean);
+    console.log(chalk3.green(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: ${parts.join(", ")}`));
+  } else {
+    console.log(chalk3.gray(`.claude/commands/${XYLABS_COMMANDS_PREFIX}*.md: already up to date`));
+  }
+};
+var claudeCommands = () => {
+  const cwd = INIT_CWD();
+  const commandsDir = PATH4.resolve(cwd, ".claude", "commands");
+  mkdirSync(commandsDir, { recursive: true });
+  const legacy = removeLegacyCommands(commandsDir);
+  const {
+    created,
+    templateNames,
+    updated
+  } = syncCommandFiles(commandsDir);
+  const removed = removeStaleCommands(commandsDir, templateNames);
+  logCommandsResult(created, updated, removed + legacy);
+  return 0;
+};
+
+// src/actions/claude-rules.ts
+import { spawnSync } from "child_process";
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync4,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync2
+} from "fs";
+import PATH5 from "path";
+import chalk4 from "chalk";
+var syncRuleFiles = (rulesDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeMdRuleTemplates();
+  const templates = {};
+  for (const [name, content] of Object.entries(rawTemplates)) {
+    templates[name] = applyPackageManager(content, pm);
+  }
+  const templateNames = new Set(Object.keys(templates));
+  let updated = 0;
+  let created = 0;
+  for (const [filename, content] of Object.entries(templates)) {
+    const targetPath = PATH5.resolve(rulesDir, filename);
+    const existing = existsSync5(targetPath) ? readFileSync4(targetPath, "utf8") : void 0;
+    if (existing === content) continue;
+    writeFileSync2(targetPath, content, "utf8");
+    if (existing) {
+      updated++;
+    } else {
+      created++;
+    }
+  }
+  return {
+    created,
+    templateNames,
+    updated
+  };
+};
+var removeStaleRules = (rulesDir, templateNames) => {
+  const existingRules = readdirSync5(rulesDir).filter((f) => f.startsWith(XYLABS_RULES_PREFIX) && f.endsWith(".md"));
+  let removed = 0;
+  for (const file of existingRules) {
+    if (!templateNames.has(file)) {
+      unlinkSync3(PATH5.resolve(rulesDir, file));
+      removed++;
+    }
+  }
+  return removed;
+};
+var logRulesResult = (created, updated, removed) => {
+  if (created || updated || removed) {
+    const parts = [
+      created ? `${created} created` : "",
+      updated ? `${updated} updated` : "",
+      removed ? `${removed} removed` : ""
+    ].filter(Boolean);
+    console.log(chalk4.green(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: ${parts.join(", ")}`));
+  } else {
+    console.log(chalk4.gray(`.claude/rules/${XYLABS_RULES_PREFIX}*.md: already up to date`));
+  }
+};
+var ensureProjectClaudeMd = (cwd, force) => {
+  const projectPath = PATH5.resolve(cwd, "CLAUDE.md");
+  if (!existsSync5(projectPath) || force) {
+    if (force && existsSync5(projectPath)) {
+      console.log(chalk4.yellow("Regenerating CLAUDE.md"));
+    }
+    console.log(chalk4.green("Generating CLAUDE.md via claude /init..."));
+    const result = spawnSync("claude", ["-p", "/init", "--allowedTools", "Read", "Write", "Glob", "Grep"], {
+      cwd,
+      shell: true,
+      stdio: "inherit"
+    });
+    if (result.status !== 0) {
+      console.error(chalk4.red("claude /init failed \u2014 is Claude Code installed?"));
+      return 1;
+    }
+  } else {
+    console.log(chalk4.gray("CLAUDE.md already exists (skipped, use --force to regenerate)"));
+  }
+  return 0;
+};
+var ensureLocalClaudeMd = (cwd) => {
+  const localPath = PATH5.resolve(cwd, "CLAUDE.local.md");
+  if (existsSync5(localPath)) {
+    console.log(chalk4.gray("CLAUDE.local.md already exists (skipped)"));
+  } else {
+    writeFileSync2(localPath, claudeMdLocalTemplate(), "utf8");
+    console.log(chalk4.green("Generated CLAUDE.local.md"));
+  }
+};
+var claudeRules = ({ force } = {}) => {
+  const cwd = INIT_CWD();
+  const rulesDir = PATH5.resolve(cwd, ".claude", "rules");
+  mkdirSync2(rulesDir, { recursive: true });
+  const {
+    created,
+    templateNames,
+    updated
+  } = syncRuleFiles(rulesDir);
+  const removed = removeStaleRules(rulesDir, templateNames);
+  logRulesResult(created, updated, removed);
+  const claudeMdResult = ensureProjectClaudeMd(cwd, force);
+  ensureLocalClaudeMd(cwd);
+  return claudeMdResult ?? 0;
+};
+
+// src/actions/claude-settings.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import PATH6 from "path";
+import { createInterface } from "readline";
+import chalk5 from "chalk";
+var DENY_LIST = [
+  "Bash(git push --force *)",
+  "Bash(git reset --hard *)",
+  "Bash(rm -rf /*)"
+];
+var RESTRICTIVE_ALLOW = [
+  "Bash(git *)",
+  "Bash(yarn *)",
+  "Bash(pnpm *)",
+  "Bash(npx *)",
+  "Bash(ls *)",
+  "Bash(mkdir *)",
+  "Bash(cp *)",
+  "Bash(mv *)",
+  "Bash(rm *)",
+  "Bash(cat *)",
+  "Bash(head *)",
+  "Bash(tail *)",
+  "Bash(echo *)",
+  "Bash(pwd)",
+  "Bash(which *)",
+  "Bash(grep *)",
+  "Bash(find *)",
+  "Bash(wc *)",
+  "Bash(npm view *)",
+  "Bash(gh *)",
+  "Read",
+  "Edit",
+  "Write",
+  "Glob",
+  "Grep",
+  "Skill"
+];
+var PERMISSIVE_ALLOW = [
+  ...RESTRICTIVE_ALLOW,
+  "Bash(node *)",
+  "Bash(python3 *)",
+  "Bash(claude *)",
+  "Bash(sed *)",
+  "Bash(xargs *)",
+  "Bash(tee *)"
+];
+function buildSettings(level) {
+  return {
+    permissions: {
+      allow: level === "restrictive" ? RESTRICTIVE_ALLOW : PERMISSIVE_ALLOW,
+      deny: DENY_LIST
+    }
+  };
+}
+function askConfirmation(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+async function claudeSettings({ level = "permissive" } = {}) {
+  const cwd = INIT_CWD();
+  const claudeDir = PATH6.resolve(cwd, ".claude");
+  const settingsPath = PATH6.resolve(claudeDir, "settings.local.json");
+  mkdirSync3(claudeDir, { recursive: true });
+  if (existsSync6(settingsPath)) {
+    const confirmed = await askConfirmation(
+      chalk5.yellow(`${settingsPath} already exists. Replace it? (y/N) `)
+    );
+    if (!confirmed) {
+      console.log(chalk5.gray("Skipped \u2014 existing settings.local.json preserved"));
+      return 0;
+    }
+  }
+  const settings = buildSettings(level);
+  writeFileSync3(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+  console.log(chalk5.green(`Generated .claude/settings.local.json (${level})`));
+  return 0;
+}
+
+// src/actions/claude-skills.ts
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync5,
+  rmSync as rmSync2,
+  statSync as statSync3,
+  writeFileSync as writeFileSync4
+} from "fs";
+import PATH7 from "path";
+import chalk6 from "chalk";
+var syncSkillFiles = (skillsDir) => {
+  const pm = detectPackageManager();
+  const rawTemplates = claudeSkillTemplates();
+  const templateNames = new Set(Object.keys(rawTemplates));
+  let updated = 0;
+  let created = 0;
+  for (const [skillName, files] of Object.entries(rawTemplates)) {
+    const skillDir = PATH7.resolve(skillsDir, skillName);
+    mkdirSync4(skillDir, { recursive: true });
+    for (const [filename, rawContent] of Object.entries(files)) {
+      const content = applyPackageManager(rawContent, pm);
+      const targetPath = PATH7.resolve(skillDir, filename);
+      mkdirSync4(PATH7.dirname(targetPath), { recursive: true });
+      const existing = existsSync7(targetPath) ? readFileSync5(targetPath, "utf8") : void 0;
+      if (existing === content) continue;
+      writeFileSync4(targetPath, content, "utf8");
+      if (existing) {
+        updated++;
+      } else {
+        created++;
+      }
+    }
+  }
+  return {
+    created,
+    templateNames,
+    updated
+  };
+};
+var removeStaleSkills = (skillsDir, templateNames) => {
+  const existingSkills = readdirSync6(skillsDir).filter(
+    (f) => f.startsWith(XYLABS_SKILLS_PREFIX) && statSync3(PATH7.resolve(skillsDir, f)).isDirectory()
+  );
+  let removed = 0;
+  for (const dir of existingSkills) {
+    if (!templateNames.has(dir)) {
+      rmSync2(PATH7.resolve(skillsDir, dir), { recursive: true });
+      removed++;
+    }
+  }
+  return removed;
+};
+var logSkillsResult = (created, updated, removed) => {
+  if (created || updated || removed) {
+    const parts = [
+      created ? `${created} created` : "",
+      updated ? `${updated} updated` : "",
+      removed ? `${removed} removed` : ""
+    ].filter(Boolean);
+    console.log(chalk6.green(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: ${parts.join(", ")}`));
+  } else {
+    console.log(chalk6.gray(`.claude/skills/${XYLABS_SKILLS_PREFIX}*/: already up to date`));
+  }
+};
+var claudeSkills = () => {
+  const cwd = INIT_CWD();
+  const skillsDir = PATH7.resolve(cwd, ".claude", "skills");
+  mkdirSync4(skillsDir, { recursive: true });
+  const {
+    created,
+    templateNames,
+    updated
+  } = syncSkillFiles(skillsDir);
+  const removed = removeStaleSkills(skillsDir, templateNames);
+  logSkillsResult(created, updated, removed);
+  return 0;
+};
+
+// src/xy/common/claude/checkCommand.ts
+var checkCommand = {
+  command: "check",
+  describe: "Check if Claude configuration is up to date with templates",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Check");
+    process.exitCode = claudeCheck();
+  }
+};
+
+// src/xy/common/claude/cleanCommand.ts
+var cleanCommand = {
+  command: "clean",
+  describe: "Remove all Claude configuration files from the repo",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Clean");
+    process.exitCode = claudeClean();
+  }
+};
+
+// src/xy/common/claude/commandsCommand.ts
+var commandsCommand = {
+  command: "commands",
+  describe: "Sync XY Labs standard Claude slash commands to .claude/commands/",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Commands");
+    process.exitCode = claudeCommands();
+  }
+};
+
+// src/xy/common/claude/initCommand.ts
+var initCommand = {
+  builder: (yargs) => {
+    return yargs.option("force", {
+      alias: "f",
+      default: false,
+      description: "Overwrite existing CLAUDE.md",
+      type: "boolean"
+    }).option("level", {
+      choices: ["restrictive", "permissive"],
+      default: "permissive",
+      description: "Permission level for settings (restrictive omits node, python3, claude, sed, xargs, tee)",
+      type: "string"
+    });
+  },
+  command: "init",
+  describe: "Initialize all Claude configuration (commands, rules, skills, settings)",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Claude Init");
+    const commandsResult = claudeCommands();
+    const rulesResult = claudeRules({ force: argv.force });
+    const skillsResult = claudeSkills();
+    const settingsResult = await claudeSettings({ level: argv.level });
+    process.exitCode = commandsResult || rulesResult || skillsResult || settingsResult;
+  }
+};
+
+// src/xy/common/claude/rulesCommand.ts
+var rulesCommand = {
+  builder: (yargs) => {
+    return yargs.option("force", {
+      alias: "f",
+      default: false,
+      description: "Overwrite existing CLAUDE.md",
+      type: "boolean"
+    });
+  },
+  command: "rules",
+  describe: "Sync XY Labs standard Claude rules to .claude/rules/",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Rules");
+    process.exitCode = claudeRules({ force: argv.force });
+  }
+};
+
+// src/xy/common/claude/settingsCommand.ts
+var settingsCommand = {
+  builder: (yargs) => {
+    return yargs.option("level", {
+      choices: ["restrictive", "permissive"],
+      default: "permissive",
+      description: "Permission level (restrictive omits node, python3, claude, sed, xargs, tee)",
+      type: "string"
+    });
+  },
+  command: "settings",
+  describe: "Initialize .claude/settings.local.json with XY Labs defaults",
+  handler: async (argv) => {
+    if (argv.verbose) console.log("Claude Settings");
+    process.exitCode = await claudeSettings({ level: argv.level });
+  }
+};
+
+// src/xy/common/claude/skillsCommand.ts
+var skillsCommand = {
+  builder: (yargs) => yargs,
+  command: "skills",
+  describe: "Sync XY Labs standard Claude skills to .claude/skills/",
+  handler: (argv) => {
+    if (argv.verbose) console.log("Claude Skills");
+    process.exitCode = claudeSkills();
+  }
+};
+
+// src/xy/common/claude/index.ts
+var claudeCommand = {
+  builder: (yargs) => {
+    return yargs.command(checkCommand).command(cleanCommand).command(commandsCommand).command(initCommand).command(rulesCommand).command(settingsCommand).command(skillsCommand).demandCommand(1, "Please specify a claude subcommand").strictCommands();
+  },
+  command: "claude",
+  describe: "Claude - Claude Code configuration utilities",
+  handler: () => {
+  }
+};
+export {
+  claudeCommand
+};
+//# sourceMappingURL=index.mjs.map