@wbern/claude-instructions 1.21.0 → 2.0.0

package/bin/cli.js

@@ -234,16 +234,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path3, added, removed, oldPosInc, options) {
-    const last = path3.lastComponent;
+  addToPath(path5, added, removed, oldPosInc, options) {
+    const last = path5.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path3.oldPos + oldPosInc,
+        oldPos: path5.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path3.oldPos + oldPosInc,
+        oldPos: path5.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -390,16 +390,232 @@ var import_picocolors = __toESM(require_picocolors(), 1);
 
 // scripts/cli-generator.ts
 init_esm_shims();
+import fs4 from "fs-extra";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import os from "os";
+
+// scripts/fragment-expander.ts
+init_esm_shims();
 import fs from "fs-extra";
 import path2 from "path";
+var TRANSFORM_BLOCK_REGEX = /<!--\s*docs\s+(\w+)([^>]*)-->([\s\S]*?)<!--\s*\/docs\s*-->/g;
+function parseOptions(attrString) {
+  const options = {};
+  const attrRegex = /(\w+)=['"]([^'"]*)['"]/g;
+  let match;
+  while ((match = attrRegex.exec(attrString)) !== null) {
+    options[match[1]] = match[2];
+  }
+  return options;
+}
+function expandContent(content, options) {
+  const { baseDir, flags } = options;
+  return content.replace(
+    TRANSFORM_BLOCK_REGEX,
+    (_match, transformName, attrString) => {
+      if (transformName !== "INCLUDE") {
+        return "";
+      }
+      const attrs = parseOptions(attrString);
+      const { path: includePath, featureFlag, elsePath } = attrs;
+      if (featureFlag && !flags.includes(featureFlag)) {
+        if (elsePath) {
+          const fullElsePath = path2.join(baseDir, elsePath);
+          try {
+            return fs.readFileSync(fullElsePath, "utf8");
+          } catch (err) {
+            throw new Error(
+              `Failed to read elsePath '${elsePath}': ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        return "";
+      }
+      if (!includePath) {
+        return "";
+      }
+      const fullPath = path2.join(baseDir, includePath);
+      try {
+        return fs.readFileSync(fullPath, "utf8");
+      } catch (err) {
+        throw new Error(
+          `Failed to read '${includePath}': ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  );
+}
+
+// scripts/generate-readme.ts
+init_esm_shims();
+import fs3 from "fs";
+import path3 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import os from "os";
+
+// scripts/cli-options.ts
+init_esm_shims();
+var CLI_OPTIONS = [
+  {
+    flag: "--scope",
+    key: "scope",
+    type: "string",
+    description: "Installation scope (project, user)",
+    example: "--scope=project",
+    requiredForNonInteractive: true
+  },
+  {
+    flag: "--prefix",
+    key: "prefix",
+    type: "string",
+    description: "Add prefix to command names",
+    example: "--prefix=my-"
+  },
+  {
+    flag: "--commands",
+    key: "commands",
+    type: "array",
+    description: "Install only specific commands",
+    example: "--commands=commit,red,green"
+  },
+  {
+    flag: "--skip-template-injection",
+    key: "skipTemplateInjection",
+    type: "boolean",
+    description: "Skip injecting project CLAUDE.md customizations"
+  },
+  {
+    flag: "--update-existing",
+    key: "updateExisting",
+    type: "boolean",
+    description: "Only update already-installed commands"
+  },
+  {
+    flag: "--overwrite",
+    key: "overwrite",
+    type: "boolean",
+    description: "Overwrite conflicting files without prompting"
+  },
+  {
+    flag: "--skip-on-conflict",
+    key: "skipOnConflict",
+    type: "boolean",
+    description: "Skip conflicting files without prompting"
+  },
+  {
+    flag: "--flags",
+    key: "flags",
+    type: "array",
+    description: "Enable feature flags (beads, github, gitlab, etc.)",
+    example: "--flags=beads,github"
+  }
+];
+function generateHelpText() {
+  const lines = [
+    "Usage: npx @wbern/claude-instructions [options]",
+    "",
+    "Options:"
+  ];
+  for (const opt of CLI_OPTIONS) {
+    const suffix = opt.type === "string" ? "=<value>" : opt.type === "array" ? "=<list>" : "";
+    const padding = 28 - (opt.flag.length + suffix.length);
+    lines.push(
+      `  ${opt.flag}${suffix}${" ".repeat(Math.max(1, padding))}${opt.description}`
+    );
+  }
+  lines.push("  --help, -h                  Show this help message");
+  lines.push("  --version, -v               Show version number");
+  return lines.join("\n");
+}
+
+// scripts/utils.ts
+init_esm_shims();
+import fs2 from "fs";
+function getMarkdownFiles(dir) {
+  return fs2.readdirSync(dir).filter((f) => f.endsWith(".md"));
+}
+
+// scripts/generate-readme.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var VARIANTS = {
-  WITH_BEADS: "with-beads",
-  WITHOUT_BEADS: "without-beads"
+var __dirname2 = path3.dirname(__filename2);
+var PROJECT_ROOT = path3.resolve(__dirname2, "..");
+var SOURCES_DIR = "src/sources";
+var FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---/;
+var CATEGORIES = {
+  PLANNING: "Planning",
+  TDD: "Test-Driven Development",
+  WORKFLOW: "Workflow",
+  SHIP_SHOW_ASK: "Ship / Show / Ask",
+  WORKTREE: "Worktree Management",
+  UTILITIES: "Utilities"
 };
+function parseFrontmatter(content) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match) return {};
+  const frontmatter = {};
+  const lines = match[1].split("\n");
+  let currentKey = null;
+  let currentArray = null;
+  for (const line of lines) {
+    if (line.match(/^\s+-\s+/) && currentKey && currentArray) {
+      const value2 = line.replace(/^\s+-\s+/, "").trim();
+      currentArray.push(value2);
+      continue;
+    }
+    if (currentKey && currentArray) {
+      frontmatter[currentKey] = currentArray;
+      currentKey = null;
+      currentArray = null;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value === "") {
+      currentKey = key;
+      currentArray = [];
+      continue;
+    }
+    if (key === "_order" && !isNaN(Number(value))) {
+      value = parseInt(value, 10);
+    }
+    if (key === "_selectedByDefault") {
+      frontmatter[key] = value === "true";
+      continue;
+    }
+    frontmatter[key] = value;
+  }
+  if (currentKey && currentArray) {
+    frontmatter[currentKey] = currentArray;
+  }
+  return frontmatter;
+}
+function getCategory(frontmatter) {
+  return frontmatter._category || CATEGORIES.UTILITIES;
+}
+function generateCommandsMetadata() {
+  const sourcesDir = path3.join(PROJECT_ROOT, SOURCES_DIR);
+  const files = getMarkdownFiles(sourcesDir);
+  const metadata = {};
+  for (const file of files) {
+    const content = fs3.readFileSync(path3.join(sourcesDir, file), "utf8");
+    const frontmatter = parseFrontmatter(content);
+    const requestedTools = frontmatter[REQUESTED_TOOLS_KEY];
+    metadata[file] = {
+      description: frontmatter.description || "No description",
+      hint: frontmatter._hint,
+      category: getCategory(frontmatter),
+      order: typeof frontmatter._order === "number" ? frontmatter._order : 999,
+      ...frontmatter._selectedByDefault === false ? { selectedByDefault: false } : {},
+      ...requestedTools ? { [REQUESTED_TOOLS_KEY]: requestedTools } : {}
+    };
+  }
+  return metadata;
+}
+
+// scripts/cli-generator.ts
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = path4.dirname(__filename3);
 var SCOPES = {
   PROJECT: "project",
   USER: "user"
@@ -407,7 +623,7 @@ var SCOPES = {
 var DIRECTORIES = {
   CLAUDE: ".claude",
   COMMANDS: "commands",
-  DOWNLOADS: "downloads"
+  SOURCES: "src/sources"
 };
 var TEMPLATE_SOURCE_FILES = ["CLAUDE.md", "AGENTS.md"];
 var REQUESTED_TOOLS_KEY = "_requested-tools";
@@ -423,25 +639,32 @@ function truncatePathFromLeft(pathStr, maxLength) {
   }
   return ELLIPSIS + truncated;
 }
-var VARIANT_OPTIONS = [
-  {
-    value: VARIANTS.WITH_BEADS,
-    label: "With Beads",
-    hint: "Includes Beads task tracking"
-  },
+var FLAG_OPTIONS = [
   {
-    value: VARIANTS.WITHOUT_BEADS,
-    label: "Without Beads",
-    hint: "Standard commands only"
+    value: "beads",
+    label: "Beads MCP",
+    hint: "Local issue tracking",
+    category: "Feature Flags"
   }
 ];
+function getFlagsGroupedByCategory() {
+  const grouped = {};
+  for (const flag of FLAG_OPTIONS) {
+    const { category, ...option } = flag;
+    if (!grouped[category]) {
+      grouped[category] = [];
+    }
+    grouped[category].push(option);
+  }
+  return grouped;
+}
 function getScopeOptions(terminalWidth = 80) {
-  const projectPath = path2.join(
+  const projectPath = path4.join(
     process.cwd(),
     DIRECTORIES.CLAUDE,
     DIRECTORIES.COMMANDS
   );
-  const userPath = path2.join(
+  const userPath = path4.join(
     os.homedir(),
     DIRECTORIES.CLAUDE,
     DIRECTORIES.COMMANDS
@@ -459,31 +682,32 @@ function getScopeOptions(terminalWidth = 80) {
     }
   ];
 }
-async function checkExistingFiles(outputPath, variant, scope, options) {
-  const sourcePath = path2.join(
-    __dirname2,
-    "..",
-    DIRECTORIES.DOWNLOADS,
-    variant || VARIANTS.WITH_BEADS
-  );
+async function checkExistingFiles(outputPath, scope, options) {
+  const sourcePath = path4.join(__dirname3, "..", DIRECTORIES.SOURCES);
   const destinationPath = outputPath || getDestinationPath(outputPath, scope);
-  const allFiles = await fs.readdir(sourcePath);
+  const flags = options?.flags ?? [];
+  const allFiles = await fs4.readdir(sourcePath);
   const files = options?.commands ? allFiles.filter((f) => options.commands.includes(f)) : allFiles;
   const existingFiles = [];
   const prefix = options?.commandPrefix || "";
   let metadata = null;
   let allowedToolsSet = null;
   if (options?.allowedTools && options.allowedTools.length > 0) {
-    metadata = await loadCommandsMetadata(variant || VARIANTS.WITH_BEADS);
+    metadata = await loadCommandsMetadata();
     allowedToolsSet = new Set(options.allowedTools);
   }
+  const baseDir = path4.join(__dirname3, "..");
   for (const file of files) {
     const destFileName = prefix + file;
-    const destFilePath = path2.join(destinationPath, destFileName);
-    const sourceFilePath = path2.join(sourcePath, file);
-    if (await fs.pathExists(destFilePath)) {
-      const existingContent = await fs.readFile(destFilePath, "utf-8");
-      let newContent = await fs.readFile(sourceFilePath, "utf-8");
+    const destFilePath = path4.join(destinationPath, destFileName);
+    const sourceFilePath = path4.join(sourcePath, file);
+    if (await fs4.pathExists(destFilePath)) {
+      const existingContent = await fs4.readFile(destFilePath, "utf-8");
+      const sourceContent = await fs4.readFile(sourceFilePath, "utf-8");
+      let newContent = expandContent(sourceContent, {
+        flags,
+        baseDir
+      });
       if (metadata && allowedToolsSet) {
         const commandMetadata = metadata[file];
         const requestedTools = commandMetadata?.[REQUESTED_TOOLS_KEY] || [];
@@ -518,19 +742,11 @@ var CATEGORY_ORDER = [
   "Utilities",
   "Ship / Show / Ask"
 ];
-async function loadCommandsMetadata(variant) {
-  const sourcePath = path2.join(
-    __dirname2,
-    "..",
-    DIRECTORIES.DOWNLOADS,
-    variant || VARIANTS.WITH_BEADS
-  );
-  const metadataPath = path2.join(sourcePath, "commands-metadata.json");
-  const metadataContent = await fs.readFile(metadataPath, "utf-8");
-  return JSON.parse(metadataContent);
+async function loadCommandsMetadata() {
+  return generateCommandsMetadata();
 }
-async function getCommandsGroupedByCategory(variant) {
-  const metadata = await loadCommandsMetadata(variant);
+async function getCommandsGroupedByCategory() {
+  const metadata = await loadCommandsMetadata();
   const grouped = {};
   for (const [filename, data] of Object.entries(metadata)) {
     const category = data.category;
@@ -577,8 +793,8 @@ function formatCommandsHint(commands) {
   const remaining = commands.length - 2;
   return `${first.join(", ")}, and ${remaining} ${remaining === 1 ? "other" : "others"}`;
 }
-async function getRequestedToolsOptions(variant) {
-  const metadata = await loadCommandsMetadata(variant);
+async function getRequestedToolsOptions() {
+  const metadata = await loadCommandsMetadata();
   const toolToCommands = /* @__PURE__ */ new Map();
   for (const [filename, data] of Object.entries(metadata)) {
     if (data[REQUESTED_TOOLS_KEY]) {
@@ -601,10 +817,10 @@ function getDestinationPath(outputPath, scope) {
     return outputPath;
   }
   if (scope === SCOPES.PROJECT) {
-    return path2.join(process.cwd(), DIRECTORIES.CLAUDE, DIRECTORIES.COMMANDS);
+    return path4.join(process.cwd(), DIRECTORIES.CLAUDE, DIRECTORIES.COMMANDS);
   }
   if (scope === SCOPES.USER) {
-    return path2.join(os.homedir(), DIRECTORIES.CLAUDE, DIRECTORIES.COMMANDS);
+    return path4.join(os.homedir(), DIRECTORIES.CLAUDE, DIRECTORIES.COMMANDS);
   }
   throw new Error("Either outputPath or scope must be provided");
 }
@@ -625,34 +841,35 @@ function extractTemplateBlocks(content) {
   }
   return blocks;
 }
-async function generateToDirectory(outputPath, variant, scope, options) {
-  const sourcePath = path2.join(
-    __dirname2,
-    "..",
-    DIRECTORIES.DOWNLOADS,
-    variant || VARIANTS.WITH_BEADS
-  );
+async function generateToDirectory(outputPath, scope, options) {
   const destinationPath = getDestinationPath(outputPath, scope);
-  const allFiles = await fs.readdir(sourcePath);
+  const sourcePath = path4.join(__dirname3, "..", DIRECTORIES.SOURCES);
+  const flags = options?.flags ?? [];
+  const allFiles = (await fs4.readdir(sourcePath)).filter(
+    (f) => f.endsWith(".md")
+  );
   let files = options?.commands ? allFiles.filter((f) => options.commands.includes(f)) : allFiles;
   if (options?.skipFiles) {
     const prefix2 = options?.commandPrefix || "";
     files = files.filter((f) => !options.skipFiles.includes(prefix2 + f));
   }
   const prefix = options?.commandPrefix || "";
-  if (options?.commands || options?.skipFiles || options?.commandPrefix) {
-    await fs.ensureDir(destinationPath);
-    for (const file of files) {
-      await fs.copy(
-        path2.join(sourcePath, file),
-        path2.join(destinationPath, prefix + file)
-      );
-    }
-  } else {
-    await fs.copy(sourcePath, destinationPath, {});
+  await fs4.ensureDir(destinationPath);
+  const baseDir = path4.join(__dirname3, "..");
+  for (const file of files) {
+    const sourceFilePath = path4.join(sourcePath, file);
+    const sourceContent = await fs4.readFile(sourceFilePath, "utf-8");
+    const expandedContent = expandContent(sourceContent, {
+      flags,
+      baseDir
+    });
+    await fs4.writeFile(
+      path4.join(destinationPath, prefix + file),
+      expandedContent
+    );
   }
   if (options?.allowedTools && options.allowedTools.length > 0) {
-    const metadata = await loadCommandsMetadata(variant || VARIANTS.WITH_BEADS);
+    const metadata = await loadCommandsMetadata();
     const allowedToolsSet = new Set(options.allowedTools);
     for (const file of files) {
       const commandMetadata = metadata[file];
@@ -661,8 +878,8 @@ async function generateToDirectory(outputPath, variant, scope, options) {
         (tool) => allowedToolsSet.has(tool)
       );
       if (toolsForCommand.length > 0) {
-        const filePath = path2.join(destinationPath, prefix + file);
-        const content = await fs.readFile(filePath, "utf-8");
+        const filePath = path4.join(destinationPath, prefix + file);
+        const content = await fs4.readFile(filePath, "utf-8");
         const allowedToolsYaml = `allowed-tools: ${toolsForCommand.join(", ")}`;
         const modifiedContent = content.replace(
           /^---\n/,
@@ -670,7 +887,7 @@ async function generateToDirectory(outputPath, variant, scope, options) {
 ${allowedToolsYaml}
 `
         );
-        await fs.writeFile(filePath, modifiedContent);
+        await fs4.writeFile(filePath, modifiedContent);
       }
     }
   }
@@ -678,21 +895,21 @@ ${allowedToolsYaml}
   if (!options?.skipTemplateInjection) {
     let templateSourcePath = null;
     for (const filename of TEMPLATE_SOURCE_FILES) {
-      const candidatePath = path2.join(process.cwd(), filename);
-      if (await fs.pathExists(candidatePath)) {
+      const candidatePath = path4.join(process.cwd(), filename);
+      if (await fs4.pathExists(candidatePath)) {
         templateSourcePath = candidatePath;
         break;
       }
     }
     if (templateSourcePath) {
-      const sourceContent = await fs.readFile(templateSourcePath, "utf-8");
+      const sourceContent = await fs4.readFile(templateSourcePath, "utf-8");
       const templates = extractTemplateBlocks(sourceContent);
       if (templates.length > 0) {
         for (const file of files) {
-          const commandName = path2.basename(file, ".md");
+          const commandName = path4.basename(file, ".md");
           const actualFileName = options?.commandPrefix ? options.commandPrefix + file : file;
-          const filePath = path2.join(destinationPath, actualFileName);
-          let content = await fs.readFile(filePath, "utf-8");
+          const filePath = path4.join(destinationPath, actualFileName);
+          let content = await fs4.readFile(filePath, "utf-8");
           let modified = false;
           for (const template of templates) {
             if (template.commands && !template.commands.includes(commandName)) {
@@ -702,7 +919,7 @@ ${allowedToolsYaml}
             modified = true;
           }
           if (modified) {
-            await fs.writeFile(filePath, content);
+            await fs4.writeFile(filePath, content);
           }
         }
         templateInjected = true;
@@ -712,88 +929,12 @@ ${allowedToolsYaml}
   return {
     success: true,
     filesGenerated: files.length,
-    variant,
     templateInjectionSkipped: options?.skipTemplateInjection,
-    templateInjected
+    templateInjected,
+    flags: options?.flags
   };
 }
 
-// scripts/cli-options.ts
-init_esm_shims();
-var CLI_OPTIONS = [
-  {
-    flag: "--variant",
-    key: "variant",
-    type: "string",
-    description: "Command variant (with-beads, without-beads)",
-    example: "--variant=with-beads",
-    requiredForNonInteractive: true
-  },
-  {
-    flag: "--scope",
-    key: "scope",
-    type: "string",
-    description: "Installation scope (project, user)",
-    example: "--scope=project",
-    requiredForNonInteractive: true
-  },
-  {
-    flag: "--prefix",
-    key: "prefix",
-    type: "string",
-    description: "Add prefix to command names",
-    example: "--prefix=my-"
-  },
-  {
-    flag: "--commands",
-    key: "commands",
-    type: "array",
-    description: "Install only specific commands",
-    example: "--commands=commit,red,green"
-  },
-  {
-    flag: "--skip-template-injection",
-    key: "skipTemplateInjection",
-    type: "boolean",
-    description: "Skip injecting project CLAUDE.md customizations"
-  },
-  {
-    flag: "--update-existing",
-    key: "updateExisting",
-    type: "boolean",
-    description: "Only update already-installed commands"
-  },
-  {
-    flag: "--overwrite",
-    key: "overwrite",
-    type: "boolean",
-    description: "Overwrite conflicting files without prompting"
-  },
-  {
-    flag: "--skip-on-conflict",
-    key: "skipOnConflict",
-    type: "boolean",
-    description: "Skip conflicting files without prompting"
-  }
-];
-function generateHelpText() {
-  const lines = [
-    "Usage: npx @wbern/claude-instructions [options]",
-    "",
-    "Options:"
-  ];
-  for (const opt of CLI_OPTIONS) {
-    const suffix = opt.type === "string" ? "=<value>" : opt.type === "array" ? "=<list>" : "";
-    const padding = 28 - (opt.flag.length + suffix.length);
-    lines.push(
-      `  ${opt.flag}${suffix}${" ".repeat(Math.max(1, padding))}${opt.description}`
-    );
-  }
-  lines.push("  --help, -h                  Show this help message");
-  lines.push("  --version, -v               Show version number");
-  return lines.join("\n");
-}
-
 // scripts/tty.ts
 init_esm_shims();
 function isInteractiveTTY() {
@@ -919,23 +1060,22 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 `;
 async function main(args) {
   intro(BATMAN_LOGO);
-  let variant;
   let scope;
   let commandPrefix;
   let selectedCommands;
   let selectedAllowedTools;
+  let selectedFlags;
   let cachedExistingFiles;
-  if (args?.variant && args?.scope) {
-    variant = args.variant;
+  if (args?.scope) {
     scope = args.scope;
     commandPrefix = args.prefix ?? "";
     selectedCommands = args.commands;
+    selectedFlags = args.flags;
     if (args.updateExisting) {
       cachedExistingFiles = await checkExistingFiles(
         void 0,
-        variant,
         scope,
-        { commandPrefix: commandPrefix || "" }
+        { commandPrefix: commandPrefix || "", flags: selectedFlags }
       );
       selectedCommands = cachedExistingFiles.map((f) => f.filename);
       if (selectedCommands.length === 0) {
@@ -951,13 +1091,6 @@ async function main(args) {
       log.warn(`Non-interactive mode requires ${requiredFlags} arguments`);
       return;
     }
-    variant = await select({
-      message: "Select variant",
-      options: [...VARIANT_OPTIONS]
-    });
-    if (isCancel(variant)) {
-      return;
-    }
     const terminalWidth = process.stdout.columns || 80;
     const uiOverhead = 25;
     scope = await select({
@@ -974,15 +1107,24 @@ async function main(args) {
     if (isCancel(commandPrefix)) {
       return;
     }
-    let groupedCommands = await getCommandsGroupedByCategory(
-      variant
-    );
+    const flagOptions = getFlagsGroupedByCategory();
+    selectedFlags = await groupMultiselect({
+      message: "Select feature flags (optional)",
+      options: flagOptions,
+      required: false
+    });
+    if (isCancel(selectedFlags)) {
+      return;
+    }
+    let groupedCommands = await getCommandsGroupedByCategory();
     if (args?.updateExisting) {
       cachedExistingFiles = await checkExistingFiles(
         void 0,
-        variant,
         scope,
-        { commandPrefix: commandPrefix || "" }
+        {
+          commandPrefix: commandPrefix || "",
+          flags: selectedFlags
+        }
       );
       const existingFilenames = new Set(
         cachedExistingFiles.map((f) => f.filename)
@@ -1011,9 +1153,7 @@ async function main(args) {
     if (isCancel(selectedCommands)) {
       return;
     }
-    const requestedToolsOptions = await getRequestedToolsOptions(
-      variant
-    );
+    const requestedToolsOptions = await getRequestedToolsOptions();
     if (requestedToolsOptions.length > 0) {
       selectedAllowedTools = await groupMultiselect({
         message: "Select allowed tools for commands (optional)",
@@ -1027,10 +1167,11 @@ async function main(args) {
       }
     }
   }
-  const existingFiles = cachedExistingFiles ?? await checkExistingFiles(void 0, variant, scope, {
+  const existingFiles = cachedExistingFiles ?? await checkExistingFiles(void 0, scope, {
     commandPrefix,
     commands: selectedCommands,
-    allowedTools: selectedAllowedTools
+    allowedTools: selectedAllowedTools,
+    flags: selectedFlags
   });
   const skipFiles = [];
   const shouldSkipConflicts = args?.skipOnConflict || !isInteractiveTTY();
@@ -1108,18 +1249,14 @@ async function main(args) {
       );
     }
   }
-  const result = await generateToDirectory(
-    void 0,
-    variant,
-    scope,
-    {
-      commandPrefix,
-      skipTemplateInjection: args?.skipTemplateInjection,
-      commands: selectedCommands,
-      skipFiles,
-      allowedTools: selectedAllowedTools
-    }
-  );
+  const result = await generateToDirectory(void 0, scope, {
+    commandPrefix,
+    skipTemplateInjection: args?.skipTemplateInjection,
+    commands: selectedCommands,
+    skipFiles,
+    allowedTools: selectedAllowedTools,
+    flags: selectedFlags
+  });
   const fullPath = scope === "project" ? `${process.cwd()}/.claude/commands` : `${os2.homedir()}/.claude/commands`;
   outro(
     `Installed ${result.filesGenerated} commands to ${fullPath}