@uniswap/ai-toolkit-nx-claude 0.5.28 → 0.5.30-next.0

package/dist/generators/init/generator.cjs

@@ -1,3304 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// packages/ai-toolkit-nx-claude/src/generators/addons/addon-registry.ts
-var addon_registry_exports = {};
-__export(addon_registry_exports, {
-  getAddonById: () => getAddonById,
-  getAvailableAddons: () => getAvailableAddons,
-  getInstalledAddonConfig: () => getInstalledAddonConfig,
-  isAddonInstalled: () => isAddonInstalled,
-  isCommandMcpServer: () => isCommandMcpServer,
-  isRemoteHostedMcpServer: () => isRemoteHostedMcpServer,
-  validateAddonRequirements: () => validateAddonRequirements
-});
-function isCommandMcpServer(mcp) {
-  return "command" in mcp;
-}
-function isRemoteHostedMcpServer(mcp) {
-  return "transport" in mcp;
-}
-function getAvailableAddons() {
-  return ADDON_REGISTRY;
-}
-function getAddonById(id) {
-  return ADDON_REGISTRY.find((addon) => addon.id === id);
-}
-async function isAddonInstalled(addonId) {
-  const addon = getAddonById(addonId);
-  if (!addon) {
-    return false;
-  }
-  const configs = [
-    (0, import_path.join)((0, import_os.homedir)(), ".claude", "config.json"),
-    (0, import_path.join)(process.cwd(), ".claude", "config.json")
-  ];
-  for (const configPath of configs) {
-    if ((0, import_fs.existsSync)(configPath)) {
-      try {
-        const config = require(configPath);
-        if (addon.type === "mcp-server" && config.mcpServers) {
-          for (const [, serverConfig] of Object.entries(config.mcpServers)) {
-            if (serverConfig && typeof serverConfig === "object" && "command" in serverConfig) {
-              const command = serverConfig.command;
-              const args = serverConfig.args || [];
-              if (isCommandMcpServer(addon.mcp) && command === addon.mcp.command && args.some((arg) => arg.includes(addon.packageName))) {
-                return true;
-              }
-            }
-          }
-        }
-      } catch {
-        continue;
-      }
-    }
-  }
-  return false;
-}
-async function getInstalledAddonConfig(addonId) {
-  const addon = getAddonById(addonId);
-  if (!addon) {
-    return void 0;
-  }
-  const configs = [
-    (0, import_path.join)((0, import_os.homedir)(), ".claude", "config.json"),
-    (0, import_path.join)(process.cwd(), ".claude", "config.json")
-  ];
-  for (const configPath of configs) {
-    if ((0, import_fs.existsSync)(configPath)) {
-      try {
-        const config = require(configPath);
-        if (addon.type === "mcp-server" && config.mcpServers) {
-          for (const [, serverConfig] of Object.entries(config.mcpServers)) {
-            if (serverConfig && typeof serverConfig === "object" && "command" in serverConfig) {
-              const command = serverConfig.command;
-              const args = serverConfig.args || [];
-              if (isCommandMcpServer(addon.mcp) && command === addon.mcp.command && args.some((arg) => arg.includes(addon.packageName))) {
-                return serverConfig;
-              }
-            }
-          }
-        }
-      } catch {
-        continue;
-      }
-    }
-  }
-  return void 0;
-}
-async function validateAddonRequirements(addonId) {
-  const addon = getAddonById(addonId);
-  if (!addon) {
-    return { valid: false, errors: [`Unknown addon: ${addonId}`] };
-  }
-  const errors = [];
-  if (addon.requirements?.node) {
-    const nodeVersion = process.version;
-    if (!nodeVersion.match(/v1[89]\.\d+\.\d+/) && !nodeVersion.match(/v2\d+\.\d+\.\d+/)) {
-      errors.push(`Node.js ${addon.requirements.node} required, found ${nodeVersion}`);
-    }
-  }
-  if (addon.requirements?.commands) {
-    const { execSync: execSync8 } = require("child_process");
-    for (const cmd of addon.requirements.commands) {
-      try {
-        execSync8(`which ${cmd}`, { stdio: "ignore" });
-      } catch {
-        errors.push(`Required command '${cmd}' not found`);
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-var import_fs, import_path, import_os, ADDON_REGISTRY;
-var init_addon_registry = __esm({
-  "packages/ai-toolkit-nx-claude/src/generators/addons/addon-registry.ts"() {
-    "use strict";
-    import_fs = require("fs");
-    import_path = require("path");
-    import_os = require("os");
-    ADDON_REGISTRY = [
-      {
-        id: "spec-workflow-mcp",
-        name: "Spec Workflow MCP",
-        description: "MCP server for spec-driven development workflow with dashboard support",
-        type: "mcp-server",
-        packageName: "@uniswap/spec-workflow-mcp",
-        mcp: {
-          serverName: "spec-workflow",
-          command: "npx",
-          args: ["@uniswap/spec-workflow-mcp@latest"],
-          supportsDashboard: true,
-          defaultPort: 50014
-        },
-        projectSetup: {
-          repositoryUrl: "https://github.com/Uniswap/spec-workflow-mcp.git",
-          configSourcePath: "configs",
-          targetDirectory: ".spec-workflow"
-        },
-        requirements: {
-          node: ">=22.0.0",
-          commands: ["git", "npm"]
-        }
-      },
-      {
-        id: "graphite-mcp",
-        name: "Graphite MCP",
-        description: "MCP server for Graphite stacked pull request workflows",
-        type: "mcp-server",
-        packageName: "gt",
-        mcp: {
-          serverName: "graphite",
-          command: "gt",
-          args: ["mcp"]
-        }
-      },
-      {
-        id: "nx-mcp",
-        name: "Nx MCP",
-        description: "MCP server for Nx monorepo workspace management",
-        type: "mcp-server",
-        packageName: "nx-mcp",
-        mcp: {
-          serverName: "nx-mcp",
-          command: "npx",
-          args: ["-y", "nx-mcp@latest"]
-        }
-      },
-      {
-        id: "slack-mcp",
-        name: "Slack MCP",
-        description: "MCP server for Slack workspace integration",
-        type: "mcp-server",
-        packageName: "slack-mcp",
-        mcp: {
-          serverName: "slack",
-          command: "npx",
-          args: ["-y", "-p", "@zencoderai/slack-mcp-server", "slack-mcp"],
-          env: {
-            SLACK_BOT_TOKEN: "PROMPT_TO_INSERT_SLACK_BOT_TOKEN",
-            SLACK_TEAM_ID: "TKZBCKUJJ"
-          }
-        }
-      },
-      {
-        id: "notion-mcp",
-        name: "Notion MCP",
-        description: "MCP server for Notion workspace management (HTTP)",
-        type: "mcp-server",
-        packageName: "notion",
-        mcp: {
-          serverName: "notion",
-          transport: "http",
-          url: "https://mcp.notion.com/mcp"
-        }
-      },
-      {
-        id: "linear-mcp",
-        name: "Linear MCP",
-        description: "MCP server for Linear issue tracking (HTTP)",
-        type: "mcp-server",
-        packageName: "linear",
-        mcp: {
-          serverName: "linear",
-          transport: "http",
-          url: "https://mcp.linear.app/mcp"
-        }
-      },
-      {
-        id: "github-mcp",
-        name: "GitHub MCP",
-        description: "MCP server for GitHub repository access",
-        type: "mcp-server",
-        packageName: "@modelcontextprotocol/server-github",
-        mcp: {
-          serverName: "github",
-          command: "npx",
-          args: ["-y", "@modelcontextprotocol/server-github"],
-          env: {
-            GITHUB_PERSONAL_ACCESS_TOKEN: "PROMPT_TO_INSERT_GITHUB_PERSONAL_ACCESS_TOKEN"
-          }
-        }
-      },
-      {
-        id: "figma-mcp",
-        name: "Figma MCP",
-        description: "MCP server for Figma design file access",
-        type: "mcp-server",
-        packageName: "figma",
-        mcp: {
-          serverName: "figma",
-          transport: "http",
-          url: "https://mcp.figma.com/mcp"
-        }
-      },
-      {
-        id: "chrome-devtools-mcp",
-        name: "Chrome DevTools MCP",
-        description: "MCP server for Chrome DevTools Protocol",
-        type: "mcp-server",
-        packageName: "chrome-devtools-mcp",
-        mcp: {
-          serverName: "chrome-devtools",
-          command: "npx",
-          args: ["chrome-devtools-mcp@latest"],
-          env: {}
-        }
-      },
-      {
-        id: "vercel-mcp",
-        name: "Vercel MCP",
-        description: "MCP server for Vercel deployment management (HTTP)",
-        type: "mcp-server",
-        packageName: "vercel",
-        mcp: {
-          serverName: "vercel",
-          transport: "http",
-          url: "https://mcp.vercel.com"
-        }
-      },
-      {
-        id: "aws-log-analyzer-mcp",
-        name: "AWS Log Analyzer MCP",
-        description: "MCP server for AWS CloudWatch Logs analysis, searching, and correlation",
-        type: "mcp-server",
-        packageName: "Log-Analyzer-with-MCP",
-        mcp: {
-          serverName: "cw-mcp-server",
-          command: "uv",
-          args: []
-          // Note: args will be dynamically set during installation to include the cloned repo path
-        },
-        projectSetup: {
-          repositoryUrl: "https://github.com/awslabs/Log-Analyzer-with-MCP.git",
-          configSourcePath: "src/cw-mcp-server",
-          targetDirectory: ".aws-log-analyzer-mcp"
-        },
-        requirements: {
-          commands: ["git", "uv", "python3"]
-        }
-      },
-      {
-        id: "pulumi-mcp",
-        name: "Pulumi MCP",
-        description: "MCP server for Pulumi infrastructure as code management (HTTP)",
-        type: "mcp-server",
-        packageName: "pulumi",
-        mcp: {
-          serverName: "pulumi",
-          transport: "http",
-          url: "https://mcp.ai.pulumi.com/mcp"
-        }
-      }
-    ];
-  }
-});
-
-// packages/ai-toolkit-nx-claude/src/generators/addons/schema.json
-var require_schema = __commonJS({
-  "packages/ai-toolkit-nx-claude/src/generators/addons/schema.json"(exports2, module2) {
-    module2.exports = {
-      $schema: "https://json-schema.org/schema",
-      $id: "SchemaForAddons",
-      title: "Addons Installation",
-      type: "object",
-      description: "Install and configure Claude Code addons including MCP servers.",
-      properties: {
-        selectionMode: {
-          type: "string",
-          description: "Selection mode for which addons to install",
-          enum: ["all", "specific"],
-          default: "all",
-          "x-prompt": {
-            message: "\u{1F3AF} What would you like to install?",
-            type: "list",
-            items: [
-              {
-                value: "all",
-                label: "All recommended MCP servers (12 servers)"
-              },
-              {
-                value: "specific",
-                label: "Select specific MCP servers"
-              }
-            ]
-          }
-        },
-        addons: {
-          type: "array",
-          description: "The addons to install",
-          items: {
-            type: "string",
-            enum: [
-              "spec-workflow-mcp",
-              "graphite-mcp",
-              "nx-mcp",
-              "slack-mcp",
-              "universe-mcp",
-              "linear-mcp",
-              "notion-mcp",
-              "github-mcp",
-              "figma-mcp",
-              "chrome-devtools-mcp",
-              "vercel-mcp",
-              "supabase-mcp",
-              "aws-log-analyzer-mcp",
-              "pulumi-mcp"
-            ]
-          },
-          "prompt-when": "selectionMode === 'specific'",
-          "prompt-type": "multiselect",
-          "prompt-message": "\u{1F50C} Select MCP servers to install"
-        },
-        dashboardMode: {
-          type: "string",
-          description: "Dashboard startup mode",
-          enum: ["always", "manual"],
-          default: "always",
-          "prompt-message": "\u{1F4CA} When should the spec-workflow dashboard start?",
-          "prompt-type": "select",
-          "prompt-items": [
-            { value: "always", label: "Always (auto-start on Claude launch)" },
-            { value: "manual", label: "Manual (start via command only)" }
-          ]
-        },
-        port: {
-          type: "number",
-          description: "Dashboard port (default: auto)",
-          default: 0,
-          "prompt-message": "\u{1F50C} Dashboard port (0 for auto)"
-        },
-        force: {
-          type: "boolean",
-          description: "Force installation even if already exists",
-          default: false
-        },
-        skipVerification: {
-          type: "boolean",
-          description: "Skip installation verification",
-          default: false
-        },
-        projectPath: {
-          type: "string",
-          description: "Path to the project where spec-workflow should be installed",
-          "x-skip-prompt": true
-        },
-        dry: {
-          type: "boolean",
-          description: "Dry run mode",
-          default: false
-        },
-        installMode: {
-          type: "string",
-          description: "Installation mode from parent generator (default or custom)",
-          enum: ["default", "custom"],
-          hidden: true,
-          "x-skip-prompt": true
-        },
-        installationType: {
-          type: "string",
-          description: "Installation location for MCP servers",
-          enum: ["global", "local"],
-          "prompt-message": "\u{1F4CD} Where should MCP servers be installed?",
-          "prompt-type": "list",
-          "prompt-items": [
-            {
-              value: "global",
-              label: "Global (~/.claude) - Available in all projects"
-            },
-            {
-              value: "local",
-              label: "Local (./.claude) - Project-specific configuration"
-            }
-          ]
-        }
-      },
-      required: []
-    };
-  }
-});
-
-// packages/ai-toolkit-nx-claude/src/generators/init/generator.ts
-var generator_exports = {};
-__export(generator_exports, {
-  default: () => generator_default2,
-  initGenerator: () => initGenerator
-});
-module.exports = __toCommonJS(generator_exports);
-var import_devkit7 = require("@nx/devkit");
-var import_enquirer2 = require("enquirer");
-var path5 = __toESM(require("path"));
-var fs5 = __toESM(require("fs"));
-var os4 = __toESM(require("os"));
-var import_child_process7 = require("child_process");
-
-// packages/ai-toolkit-nx-claude/src/utils/prompt-utils.ts
-var import_enquirer = require("enquirer");
-var fs = __toESM(require("fs"));
-async function promptForMissingOptions(options, schemaPath, context = {}, explicitlyProvidedOptions) {
-  let schema;
-  if (typeof schemaPath === "string") {
-    const schemaContent = fs.readFileSync(schemaPath, "utf-8");
-    schema = JSON.parse(schemaContent);
-  } else {
-    schema = schemaPath;
-  }
-  const result = { ...options };
-  if (result["no-interactive"] || result.noInteractive || result["non-interactive"] || result.nonInteractive) {
-    for (const [key, property] of Object.entries(schema.properties)) {
-      if (result[key] === void 0 && property.default !== void 0) {
-        result[key] = property.default;
-      }
-    }
-    return result;
-  }
-  for (const [key, property] of Object.entries(schema.properties)) {
-    let wasExplicitlyProvided = false;
-    if (explicitlyProvidedOptions) {
-      if (explicitlyProvidedOptions instanceof Map) {
-        wasExplicitlyProvided = explicitlyProvidedOptions.has(key) || explicitlyProvidedOptions.has(key.replace(/-/g, ""));
-      } else {
-        wasExplicitlyProvided = explicitlyProvidedOptions.has(key) || explicitlyProvidedOptions.has(key.replace(/-/g, ""));
-      }
-    }
-    if (property["x-skip-prompt"]) {
-      if (result[key] === void 0 && property.default !== void 0) {
-        result[key] = property.default;
-      }
-      continue;
-    }
-    const shouldPrompt = property["always-prompt"] ? (
-      // For always-prompt fields, only skip if value was explicitly provided
-      !wasExplicitlyProvided
-    ) : (
-      // For regular fields (backward compatibility with x-prompt),
-      // skip if value exists at all (provided or defaulted)
-      (result[key] === void 0 || result[key] === null) && !wasExplicitlyProvided
-    );
-    if (!shouldPrompt) {
-      continue;
-    }
-    if (key === "confirmLocalPath") {
-      if (result.installationType !== "local") {
-        continue;
-      }
-    }
-    if (key === "nonInteractive" || key === "non-interactive" || key === "no-interactive" || key === "noInteractive") {
-      continue;
-    }
-    if (key === "force") {
-      continue;
-    }
-    if (property["prompt-when"]) {
-      const shouldShow = evaluatePromptCondition(property["prompt-when"], result);
-      if (!shouldShow) {
-        continue;
-      }
-    }
-    const promptResult = await promptForProperty(key, property, context, result);
-    if (promptResult !== void 0) {
-      result[key] = promptResult;
-      if (key === "installMode" && promptResult === "default") {
-        result.installationType = "global";
-        result.installCommands = true;
-        result.installAgents = true;
-        result.installHooks = true;
-        result.hooksMode = "sound";
-        result.installAddons = true;
-        result.dry = false;
-        result.commandSelectionMode = "all";
-        result.agentSelectionMode = "all";
-        result.addonSelectionMode = "all";
-        if (context.defaultCommands) {
-          result.commands = context.defaultCommands;
-        }
-        if (context.defaultAgents) {
-          result.agents = context.defaultAgents;
-        }
-        if (explicitlyProvidedOptions instanceof Map) {
-          explicitlyProvidedOptions.set("installMode", "default");
-          explicitlyProvidedOptions.set("installationType", "global");
-          explicitlyProvidedOptions.set("installCommands", true);
-          explicitlyProvidedOptions.set("installAgents", true);
-          explicitlyProvidedOptions.set("installHooks", true);
-          explicitlyProvidedOptions.set("hooksMode", "sound");
-          explicitlyProvidedOptions.set("installAddons", true);
-          explicitlyProvidedOptions.set("dry", false);
-          explicitlyProvidedOptions.set("commandSelectionMode", "all");
-          explicitlyProvidedOptions.set("agentSelectionMode", "all");
-          explicitlyProvidedOptions.set("addonSelectionMode", "all");
-          if (context.defaultCommands) {
-            explicitlyProvidedOptions.set("commands", context.defaultCommands);
-          }
-          if (context.defaultAgents) {
-            explicitlyProvidedOptions.set("agents", context.defaultAgents);
-          }
-        }
-      }
-      if (key === "confirmLocalPath" && result.installationType === "local" && promptResult === false) {
-        throw new Error("Installation cancelled - please run from your project root");
-      }
-    }
-  }
-  return result;
-}
-async function promptForProperty(key, property, context, currentValues) {
-  const promptMessage = getPromptMessage(key, property);
-  const promptType = property["prompt-type"] || (property.type === "boolean" ? "confirm" : property.enum ? "select" : property.type === "string" ? "input" : null);
-  if (promptType === "confirm" || property.type === "boolean") {
-    const { value } = await (0, import_enquirer.prompt)({
-      type: "confirm",
-      name: "value",
-      message: promptMessage,
-      initial: property.default ?? false
-    });
-    return value;
-  }
-  if (promptType === "list" && property["prompt-items"]) {
-    const { value } = await (0, import_enquirer.prompt)({
-      type: "select",
-      name: "value",
-      message: promptMessage,
-      choices: property["prompt-items"].map((item) => ({
-        name: item.value,
-        value: item.value,
-        message: item.label
-      }))
-    });
-    return value;
-  }
-  if (property.enum || key === "package" && context.availablePackages) {
-    const choices = property.enum || context.availablePackages || [];
-    const { value } = await (0, import_enquirer.prompt)({
-      type: "select",
-      name: "value",
-      message: promptMessage,
-      choices: choices.map((choice) => {
-        if (key === "package" && choice === "__create_new__") {
-          return {
-            name: "__create_new__",
-            value: "__create_new__",
-            message: "\u2795 Create new package"
-          };
-        }
-        if (key === "package") {
-          return { name: choice, value: choice, message: `\u{1F4E6} ${choice}` };
-        }
-        return { name: choice, value: choice };
-      })
-    });
-    return value;
-  }
-  if (property.type === "array") {
-    if (key === "commands" && context.availableCommands) {
-      const installationType = currentValues?.installationType;
-      let existingSet;
-      let otherLocationSet;
-      if (installationType === "global") {
-        existingSet = context.globalExistingCommands;
-        otherLocationSet = context.localExistingCommands;
-      } else if (installationType === "local") {
-        existingSet = context.localExistingCommands;
-        otherLocationSet = context.globalExistingCommands;
-      }
-      return await promptMultiSelectWithAll(
-        promptMessage,
-        context.availableCommands,
-        "commands",
-        context.commandDescriptions,
-        existingSet,
-        otherLocationSet,
-        installationType
-      );
-    }
-    if (key === "agents" && context.availableAgents) {
-      const installationType = currentValues?.installationType;
-      let existingSet;
-      let otherLocationSet;
-      if (installationType === "global") {
-        existingSet = context.globalExistingAgents;
-        otherLocationSet = context.localExistingAgents;
-      } else if (installationType === "local") {
-        existingSet = context.localExistingAgents;
-        otherLocationSet = context.globalExistingAgents;
-      }
-      return await promptMultiSelectWithAll(
-        promptMessage,
-        context.availableAgents,
-        "agents",
-        context.agentDescriptions,
-        existingSet,
-        otherLocationSet,
-        installationType
-      );
-    }
-    if (key === "skills" && context.availableSkills) {
-      const installationType = currentValues?.installationType;
-      let existingSet;
-      let otherLocationSet;
-      if (installationType === "global") {
-        existingSet = context.globalExistingSkills;
-        otherLocationSet = context.localExistingSkills;
-      } else if (installationType === "local") {
-        existingSet = context.localExistingSkills;
-        otherLocationSet = context.globalExistingSkills;
-      }
-      return await promptMultiSelectWithAll(
-        promptMessage,
-        context.availableSkills,
-        "skills",
-        context.skillDescriptions,
-        existingSet,
-        otherLocationSet,
-        installationType
-      );
-    }
-    if (key === "addons" && context.availableAddons) {
-      return await promptMultiSelectWithAll(
-        promptMessage,
-        context.availableAddons,
-        "addons",
-        context.addonDescriptions,
-        void 0,
-        // No existing set for addons
-        void 0,
-        // No other location set for addons
-        void 0
-        // No installation type for addons
-      );
-    }
-    return [];
-  }
-  if (property.type === "string") {
-    if (key === "targetPath") {
-      const { value: value2 } = await (0, import_enquirer.prompt)({
-        type: "input",
-        name: "value",
-        message: promptMessage,
-        initial: process.cwd()
-      });
-      return value2;
-    }
-    const { value } = await (0, import_enquirer.prompt)({
-      type: "input",
-      name: "value",
-      message: promptMessage,
-      initial: property.default ?? ""
-    });
-    return value;
-  }
-  return void 0;
-}
-async function promptMultiSelectWithAll(message, choices, type, descriptions, existingItems, otherLocationItems, installationType) {
-  const displayChoices = choices.map((choice) => {
-    let display = descriptions?.[choice] ? `${choice}: ${descriptions[choice]}` : choice;
-    const indicators = [];
-    if (existingItems?.has(choice)) {
-      indicators.push("will overwrite");
-    }
-    if (otherLocationItems?.has(choice)) {
-      const otherLocation = installationType === "global" ? "locally" : "globally";
-      indicators.push(`exists ${otherLocation}`);
-    }
-    if (indicators.length > 0) {
-      display += ` (${indicators.join(", ")})`;
-    }
-    return display;
-  });
-  const response = await (0, import_enquirer.prompt)({
-    type: "multiselect",
-    name: "selected",
-    message,
-    choices: displayChoices,
-    initial: displayChoices.map((_, index) => index),
-    // Select all by default
-    hint: "Use <space> to select, <a> to toggle all, <return> to submit",
-    validate: (value) => {
-      if (value.length === 0) {
-        return `Please select at least one ${type.slice(0, -1)}`;
-      }
-      return true;
-    }
-  });
-  const selected = response.selected || [];
-  const actualSelections = [];
-  for (const selection of selected) {
-    const colonIndex = selection.indexOf(":");
-    const parenIndex = selection.indexOf("(");
-    let endIndex = selection.length;
-    if (colonIndex > -1 && (parenIndex === -1 || colonIndex < parenIndex)) {
-      endIndex = colonIndex;
-    } else if (parenIndex > -1 && (colonIndex === -1 || parenIndex < colonIndex)) {
-      endIndex = parenIndex;
-    }
-    const name = selection.substring(0, endIndex).trim();
-    if (name && !actualSelections.includes(name)) {
-      actualSelections.push(name);
-    }
-  }
-  return actualSelections;
-}
-function getPromptMessage(key, property) {
-  if (property["prompt-message"]) {
-    return property["prompt-message"];
-  }
-  if (property["x-prompt"]) {
-    if (typeof property["x-prompt"] === "string") {
-      return property["x-prompt"];
-    }
-    if (property["x-prompt"].message) {
-      return property["x-prompt"].message;
-    }
-  }
-  const description = property.description || "";
-  switch (key) {
-    case "installationType":
-      return "Would you like to install agents and commands globally or locally?";
-    case "confirmLocalPath":
-      return "Are you running this from the root of your project?";
-    case "commands":
-      return "Select commands to install (use <space> to select, <a> to toggle all):";
-    case "agents":
-      return "Select agents to install (use <space> to select, <a> to toggle all):";
-    case "force":
-      return "Overwrite existing installation?";
-    default:
-      return description || `Enter value for ${key}:`;
-  }
-}
-function evaluatePromptCondition(condition, context) {
-  if (condition.includes(" && ")) {
-    const parts = condition.split(" && ");
-    return parts.every((part) => evaluateSingleCondition(part.trim(), context));
-  }
-  if (condition.includes(" || ")) {
-    const parts = condition.split(" || ");
-    return parts.some((part) => evaluateSingleCondition(part.trim(), context));
-  }
-  return evaluateSingleCondition(condition, context);
-}
-function evaluateSingleCondition(condition, context) {
-  const parts = condition.split(" ");
-  if (parts.length < 3) {
-    return false;
-  }
-  const field = parts[0];
-  const operator = parts[1];
-  const value = parts.slice(2).join(" ").replace(/['"]/g, "");
-  const fieldValue = context[field];
-  switch (operator) {
-    case "===":
-      if (value === "true") {
-        return fieldValue === true;
-      }
-      if (value === "false") {
-        return fieldValue === false;
-      }
-      return String(fieldValue) === value;
-    case "!==":
-      if (value === "true") {
-        return fieldValue !== true;
-      }
-      if (value === "false") {
-        return fieldValue !== false;
-      }
-      return String(fieldValue) !== value;
-    default:
-      return false;
-  }
-}
-
-// packages/ai-toolkit-nx-claude/src/utils/cli-parser.ts
-function getExplicitlyProvidedOptions(options) {
-  const providedOptions = /* @__PURE__ */ new Map();
-  const args = process.argv;
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith("--")) {
-      if (arg.includes("=")) {
-        const [flagPart, ...valueParts] = arg.split("=");
-        const flagName = flagPart.slice(2);
-        const value = valueParts.join("=");
-        const camelCaseName = flagName.replace(
-          /-([a-z])/g,
-          (_, letter) => letter.toUpperCase()
-        );
-        const parsedValue = parseValue(value);
-        providedOptions.set(flagName, parsedValue);
-        providedOptions.set(camelCaseName, parsedValue);
-      } else {
-        const flagName = arg.slice(2);
-        const camelCaseName = flagName.replace(
-          /-([a-z])/g,
-          (_, letter) => letter.toUpperCase()
-        );
-        if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
-          const value = args[i + 1];
-          const parsedValue = parseValue(value);
-          providedOptions.set(flagName, parsedValue);
-          providedOptions.set(camelCaseName, parsedValue);
-          i++;
-        } else {
-          providedOptions.set(flagName, true);
-          providedOptions.set(camelCaseName, true);
-        }
-      }
-    } else if (arg.startsWith("-") && !arg.startsWith("--") && arg.length === 2) {
-      const shortFlagMap = {
-        d: "dry-run",
-        v: "verbose",
-        f: "force",
-        h: "help"
-      };
-      const shortFlag = arg.slice(1);
-      if (shortFlagMap[shortFlag]) {
-        const longFlag = shortFlagMap[shortFlag];
-        const camelCaseName = longFlag.replace(
-          /-([a-z])/g,
-          (_, letter) => letter.toUpperCase()
-        );
-        providedOptions.set(longFlag, true);
-        providedOptions.set(camelCaseName, true);
-      }
-    }
-  }
-  if (options) {
-    for (const [key, value] of Object.entries(options)) {
-      providedOptions.set(key, value);
-    }
-  }
-  return providedOptions;
-}
-function parseValue(value) {
-  if (value === "true") return true;
-  if (value === "false") return false;
-  if (/^-?\d+$/.test(value)) {
-    return parseInt(value, 10);
-  }
-  if (/^-?\d*\.\d+$/.test(value)) {
-    return parseFloat(value);
-  }
-  if (value === "null") return null;
-  if (value === "undefined") return void 0;
-  return value;
-}
-function isNxDryRunProvided() {
-  const args = process.argv;
-  return (
-    // Check for --dry-run
-    args.some((a) => a === "--dry-run") || args.some((a) => a.startsWith("--dry-run=") && !a.endsWith("=false")) || // Check for --dryRun
-    args.some((a) => a === "--dryRun") || args.some((a) => a.startsWith("--dryRun=") && !a.endsWith("=false")) || // Check for short form -d
-    args.some((a) => a === "-d")
-  );
-}
-function isNxNoInteractiveProvided() {
-  const args = process.argv;
-  return (
-    // Check for --no-interactive
-    args.some((a) => a === "--no-interactive") || args.some(
-      (a) => a.startsWith("--no-interactive=") && !a.endsWith("=false")
-    ) || // Check for --noInteractive
-    args.some((a) => a === "--noInteractive") || args.some((a) => a.startsWith("--noInteractive=") && !a.endsWith("=false"))
-  );
-}
-
-// packages/ai-toolkit-nx-claude/src/utils/auto-update-utils.ts
-var fs2 = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var os = __toESM(require("os"));
-var import_devkit = require("@nx/devkit");
-function getCurrentToolkitVersion() {
-  try {
-    const packageJsonPath = path.join(__dirname, "..", "..", "package.json");
-    const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
-    return packageJson.version;
-  } catch (error) {
-    import_devkit.logger.info("checking parent directory for package.json");
-    const packageJsonPath = path.join(__dirname, "..", "..", "..", "package.json");
-    const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
-    return packageJson.version;
-  }
-}
-function detectShell() {
-  const shell = process.env.SHELL || "";
-  if (shell.includes("zsh")) return "zsh";
-  if (shell.includes("fish")) return "fish";
-  return "bash";
-}
-function getShellConfigPath(shell) {
-  const homeDir = os.homedir();
-  const configs = {
-    bash: path.join(homeDir, ".bashrc"),
-    zsh: path.join(homeDir, ".zshrc"),
-    fish: path.join(homeDir, ".config/fish/config.fish")
-  };
-  return configs[shell];
-}
-function generateAutoUpdateSnippet(version) {
-  return `# AUTOMATED BY AI_TOOLKIT_UPDATE_CHECK v${version}
-_ai_toolkit_check_updates() {
-  [ -n "$AI_TOOLKIT_SKIP_UPDATE_CHECK" ] && return
-
-  local cache="\${HOME}/.uniswap-ai-toolkit/.last-update-check"
-  local cache_dir="\${HOME}/.uniswap-ai-toolkit"
-
-  # Create cache directory if it doesn't exist
-  [ ! -d "$cache_dir" ] && mkdir -p "$cache_dir"
-
-  # Check once per week
-  if [ -f "$cache" ]; then
-    local last_check=$(cat "$cache" 2>/dev/null || echo 0)
-    local now=$(date +%s)
-    [ $((now - last_check)) -lt 604800 ] && return
-  fi
-
-  echo "\u23F3 Checking for AI Toolkit updates..."
-  echo "   Disable these checks with: export AI_TOOLKIT_SKIP_UPDATE_CHECK=1
-"
-
-  # Extract version from this script's comment
-  local current=$(grep --max-count=1 "# AUTOMATED BY AI_TOOLKIT_UPDATE_CHECK" "\${BASH_SOURCE[0]:-$HOME/.zshrc}" 2>/dev/null | sed 's/.*v\\([0-9][^ ]*\\).*/\\1/')
-
-  # Get latest version from npm registry and display a message if an update is available
-  if command -v npm >/dev/null 2>&1; then
-    if ! npm view @uniswap/ai-toolkit-nx-claude@latest version >/dev/null 2>&1; then
-      echo "\u26A0\uFE0F  Failed to check for AI Toolkit updates (npm registry unavailable)"
-      echo "\u{1F41E} Please report this bug at https://github.com/Uniswap/ai-toolkit/issues"
-      return
-    fi
-    
-    local latest=$(npm view @uniswap/ai-toolkit-nx-claude@latest version 2>/dev/null)
-
-    if [ -n "$latest" ] && [ -n "$current" ] && [ "$current" != "$latest" ]; then
-      echo "\u{1F4E6} AI Toolkit update available: $current \u2192 $latest"
-      echo "   Run: npx @uniswap/ai-toolkit-nx-claude@latest"
-      echo "   Disable these checks: export AI_TOOLKIT_SKIP_UPDATE_CHECK=1"
-    fi
-  fi
-
-  date +%s > "$cache" 2>/dev/null
-}
-
-_ai_toolkit_check_updates
-# END AI_TOOLKIT_UPDATE_CHECK`;
-}
-function generateFishAutoUpdateSnippet(version) {
-  return `# AUTOMATED BY AI_TOOLKIT_UPDATE_CHECK v${version}
-function _ai_toolkit_check_updates
-  if set -q AI_TOOLKIT_SKIP_UPDATE_CHECK
-    return
-  end
-
-  set -l cache "$HOME/.uniswap-ai-toolkit/.last-update-check"
-  set -l cache_dir "$HOME/.uniswap-ai-toolkit"
-
-  # Create cache directory if it doesn't exist
-  if not test -d "$cache_dir"
-    mkdir -p "$cache_dir"
-  end
-
-  # Check once per week
-  if test -f "$cache"
-    set -l last_check (cat "$cache" 2>/dev/null; or echo 0)
-    set -l now (date +%s)
-    if test (math "$now - $last_check") -lt 604800
-      return
-    end
-  end
-  
-  echo "\u23F3 Checking for AI Toolkit updates..."
-  echo "   Disable these checks with: export AI_TOOLKIT_SKIP_UPDATE_CHECK=1
-"
-
-  # Check the latest version of the toolkit in npmjs registry and
-  # display a message if an update is available
-  set -l current (grep --max-count=1 "# AUTOMATED BY AI_TOOLKIT_UPDATE_CHECK" ~/.config/fish/config.fish 2>/dev/null | sed "s/.*v\\([0-9][^ ]*\\).*/\\1/")
-
-  if command -v npm >/dev/null 2>&1
-    if not npm view @uniswap/ai-toolkit-nx-claude@latest version >/dev/null 2>&1
-      echo "\u26A0\uFE0F  Failed to check for AI Toolkit updates (npm registry unavailable)"
-      echo "\u{1F41E} Please report this bug at https://github.com/Uniswap/ai-toolkit/issues"
-      return
-    end
-    
-    set -l latest (npm view @uniswap/ai-toolkit-nx-claude@latest version 2>/dev/null)
-
-    if test -n "$latest" -a -n "$current" -a "$current" != "$latest"
-      echo "\u{1F4E6} AI Toolkit update available: $current \u2192 $latest"
-      echo "   Run: npx @uniswap/ai-toolkit-nx-claude@latest"
-      echo "   Disable these checks: set -x AI_TOOLKIT_SKIP_UPDATE_CHECK 1"
-    end
-  end
-
-  date +%s > "$cache" 2>/dev/null
-end
-
-_ai_toolkit_check_updates
-# END AI_TOOLKIT_UPDATE_CHECK`;
-}
-function installUpdateChecker(shell, version) {
-  const configPath = getShellConfigPath(shell);
-  if (fs2.existsSync(configPath)) {
-    const backupPath = `${configPath}.backup-${Date.now()}`;
-    fs2.copyFileSync(configPath, backupPath);
-    import_devkit.logger.info(`\u{1F4CB} Backed up ${configPath} to ${backupPath}`);
-  } else {
-    fs2.writeFileSync(configPath, "");
-    import_devkit.logger.info(`\u{1F4DD} Created ${configPath}`);
-  }
-  let configContent = fs2.readFileSync(configPath, "utf-8");
-  const startMarker = "# AUTOMATED BY AI_TOOLKIT_UPDATE_CHECK";
-  const endMarker = "# END AI_TOOLKIT_UPDATE_CHECK";
-  const blockRegex = new RegExp(`${startMarker}[\\s\\S]*?${endMarker}\\n?`, "g");
-  configContent = configContent.replace(blockRegex, "");
-  const snippet = shell === "fish" ? generateFishAutoUpdateSnippet(version) : generateAutoUpdateSnippet(version);
-  const prefix = configContent.trim() ? "\n\n" : "";
-  const updatedContent = configContent + prefix + snippet + "\n";
-  fs2.writeFileSync(configPath, updatedContent);
-  import_devkit.logger.info(`\u2705 Update checker installed to ${configPath}`);
-  import_devkit.logger.info(`   Checks once per week, disable with: export AI_TOOLKIT_SKIP_UPDATE_CHECK=1`);
-}
-
-// packages/commands/agnostic/dist/src/index.js
-var commands = {
-  "address-pr-issues": {
-    description: "Reviews a GitHub PR, addresses comments, and fixes CI issues",
-    filePath: "./address-pr-issues.md"
-  },
-  "auto-spec": {
-    description: "Autonomously create and implement a complete spec workflow with multi-agent collaboration, bypassing manual review steps through intelligent consensus-building",
-    filePath: "./auto-spec.md"
-  },
-  "claude-docs": {
-    description: "Initialize or update CLAUDE.md documentation files based on context and changes",
-    filePath: "./claude-docs.md"
-  },
-  "claude-init-plus": {
-    description: "Initialize or update CLAUDE.md files at all core nodes in the workspace",
-    filePath: "./claude-init-plus.md"
-  },
-  "create-pr": {
-    description: "Create or update a Graphite PR with auto-generated conventional commit messages and comprehensive descriptions based on code diffs.",
-    filePath: "./create-pr.md"
-  },
-  "daily-standup": {
-    description: "This provides a daily standup, checking GitHub and Linear over the past day and providing a summary of what you&#39;ve been working on and what you will continue to work on.",
-    filePath: "./daily-standup.md"
-  },
-  deploy: {
-    description: "Orchestrate deployment pipelines, infrastructure setup, and CI/CD configuration using specialized deployment agents.",
-    filePath: "./deploy.md"
-  },
-  "execute-plan": {
-    description: "Execute implementation plans step-by-step",
-    filePath: "./execute-plan.md"
-  },
-  "explain-file": {
-    description: "Comprehensive code explanation using multi-agent analysis for architecture, patterns, security, and performance insights.",
-    filePath: "./explain-file.md"
-  },
-  explore: {
-    description: "Deep dive into a codebase area to build comprehensive understanding before creating and implementing a plan.",
-    filePath: "./explore.md"
-  },
-  "fix-bug": {
-    description: "Comprehensively diagnose bugs with root cause analysis, systematic fixes, regression tests, and prevention strategies.",
-    filePath: "./fix-bug.md"
-  },
-  "gen-tests": {
-    description: "Generate comprehensive tests with advanced testing strategies, scenario generation, and edge case identification using the enhanced test-writer agent.",
-    filePath: "./gen-tests.md"
-  },
-  "generate-commit-message": {
-    description: "Generate a structured git commit message based on current changes and repository patterns",
-    filePath: "./generate-commit-message.md"
-  },
-  "git-worktree-orchestrator": {
-    description: "Create and manage a git worktree based on the current directory and a branch name, with optional spec-workflow setup, Graphite integration, and Linear task automation.",
-    filePath: "./git-worktree-orchestrator.md"
-  },
-  "implement-spec": {
-    description: "Orchestrate implementation of spec-workflow tasks using intelligent agent coordination, parallel execution, and quality gates.",
-    filePath: "./implement-spec.md"
-  },
-  monitor: {
-    description: "Set up comprehensive monitoring for applications with automated metrics identification, alerting, and dashboard configuration",
-    filePath: "./monitor.md"
-  },
-  "perf-analyze": {
-    description: "O(1) Chain-of-Thought Performance Analyzer - Systematic complexity analysis with optimization paths, bottleneck identification, and performance proofs",
-    filePath: "./perf-analyze.md"
-  },
-  plan: {
-    description: "Create clear, actionable implementation plans for any task, feature, refactor, or architectural change through collaborative multi-agent refinement",
-    filePath: "./plan.md"
-  },
-  refactor: {
-    description: "Orchestrate comprehensive refactoring with architectural analysis, pattern application, and incremental safety checks.",
-    filePath: "./refactor.md"
-  },
-  "refine-linear-task": {
-    description: "Refine and enhance Linear task descriptions for improved clarity, completeness, and actionability",
-    filePath: "./refine-linear-task.md"
-  },
-  research: {
-    description: "Research a topic by combining web search with codebase analysis for comprehensive understanding.",
-    filePath: "./research.md"
-  },
-  "review-code": {
-    description: "Comprehensive code review using multiple specialized agents for architecture, security, performance, and style analysis.",
-    filePath: "./review-code.md"
-  },
-  "review-plan": {
-    description: "Critically review an implementation plan for completeness, feasibility, and alignment with codebase patterns",
-    filePath: "./review-plan.md"
-  },
-  "review-pr": {
-    description: "Orchestrate comprehensive pull request review using specialized agents for architecture, security, performance, testing, and maintainability analysis.",
-    filePath: "./review-pr.md"
-  },
-  "split-stack": {
-    description: "Automatically split a monolithic branch with many changes into a logical, reviewable stack of PRs using semantic analysis and Graphite.",
-    filePath: "./split-stack.md"
-  },
-  "update-claude-md": {
-    description: "Intelligently update CLAUDE.md files based on detected code changes",
-    filePath: "./update-claude-md.md"
-  },
-  "work-through-pr-comments": {
-    description: "Methodically work through GitHub pull request comments in a conversational workflow, analyzing each comment, presenting solution options, gathering your decisions, and implementing approved changes.",
-    filePath: "./work-through-pr-comments.md"
-  }
-};
-
-// packages/agents/agnostic/dist/src/index.js
-var agents = {
-  "agent-capability-analyst": {
-    description: "Advanced specialist in AI agent capability analysis with enhanced scoring algorithms, semantic matching for natural language tasks, and team composition recommendations for complex workflows",
-    filePath: "./agent-capability-analyst.md"
-  },
-  "agent-optimizer": {
-    description: "Meta-agent that analyzes, optimizes, and continuously improves the performance of other AI agents through systematic refinement strategies",
-    filePath: "./agent-optimizer.md"
-  },
-  "agent-orchestrator": {
-    description: "Intelligent orchestrator that coordinates other AI agents for complex software development workflows, matching tasks to specialists based on capabilities",
-    filePath: "./agent-orchestrator.md"
-  },
-  "cicd-agent": {
-    description: "CI/CD pipeline specialist for automated deployment setup, workflow configuration, and release management",
-    filePath: "./cicd-agent.md"
-  },
-  "claude-agent-discovery": {
-    description: "Specialized agent for discovering and cataloging all available agents and commands from Claude Code directories, including local project and global user configurations",
-    filePath: "./claude-agent-discovery.md"
-  },
-  "claude-docs-fact-checker": {
-    description: "Verify CLAUDE.md documentation accuracy against actual codebase state. Use this agent proactively after claude-docs-manager or claude-docs-initializer generate documentation content to verify accuracy before files are written. This prevents hallucinations in CLAUDE.md files.",
-    filePath: "./claude-docs-fact-checker.md"
-  },
-  "claude-docs-initializer": {
-    description: "Discover repository structure and create initial CLAUDE.md documentation at all appropriate levels",
-    filePath: "./claude-docs-initializer.md"
-  },
-  "claude-docs-manager": {
-    description: "Analyze code changes and update all affected CLAUDE.md documentation files",
-    filePath: "./claude-docs-manager.md"
-  },
-  "code-explainer": {
-    description: "Advanced code analysis agent that explains purpose, architecture, dependencies, security vulnerabilities, and performance implications with deep pattern recognition",
-    filePath: "./code-explainer.md"
-  },
-  "code-generator": {
-    description: "Comprehensive code generation specialist that creates production-ready code with tests, following best practices and existing patterns",
-    filePath: "./code-generator.md"
-  },
-  "commit-message-generator": {
-    description: "Generate well-structured git commit messages that clearly communicate the WHAT and WHY of code changes. Your messages should help future developers (including the author) understand the purpose and context of the commit.",
-    filePath: "./commit-message-generator.md"
-  },
-  "context-loader": {
-    description: "Advanced context management system for deep codebase understanding, intelligent summarization, and cross-agent context sharing.",
-    filePath: "./context-loader.md"
-  },
-  "debug-assistant": {
-    description: "Advanced debugging specialist with root cause analysis, error pattern recognition, fix validation, and prevention recommendations",
-    filePath: "./debug-assistant.md"
-  },
-  "doc-writer": {
-    description: "Advanced documentation specialist for API docs, README generation, architecture documentation, and interactive examples with quality analysis",
-    filePath: "./doc-writer.md"
-  },
-  "feedback-collector": {
-    description: "A comprehensive agent for gathering, analyzing, and transforming execution feedback into actionable insights for continuous improvement",
-    filePath: "./feedback-collector.md"
-  },
-  "infrastructure-agent": {
-    description: "Infrastructure automation specialist for cloud architecture, scaling strategies, and cost optimization",
-    filePath: "./infrastructure-agent.md"
-  },
-  "migration-assistant": {
-    description: "Migration specialist for guiding version upgrades, compatibility checking, rollback strategies, and validation steps",
-    filePath: "./migration-assistant.md"
-  },
-  "pattern-learner": {
-    description: "Specializes in learning from agent executions, extracting reusable patterns, and providing recommendations for pattern application across different contexts",
-    filePath: "./pattern-learner.md"
-  },
-  "performance-analyzer": {
-    description: "Comprehensive performance analysis agent for identifying bottlenecks, analyzing complexity, and providing optimization strategies with measurable impact estimates",
-    filePath: "./performance-analyzer.md"
-  },
-  "plan-reviewer": {
-    description: "Critically analyze implementation plans for completeness, feasibility, and alignment with codebase patterns",
-    filePath: "./plan-reviewer.md"
-  },
-  planner: {
-    description: "Create clear, actionable implementation plans without writing code",
-    filePath: "./planner.md"
-  },
-  "pr-creator": {
-    description: "Creates or updates Graphite PRs with auto-generated conventional commit messages and comprehensive PR descriptions based on diffs",
-    filePath: "./pr-creator.md"
-  },
-  "pr-reviewer": {
-    description: "Reviews PRs, addresses comments with plans or code changes, and fixes CI pipeline issues",
-    filePath: "./pr-reviewer.md"
-  },
-  "prompt-engineer": {
-    description: "Expert in analyzing, optimizing, and testing prompts for AI agents and LLMs to maximize clarity, effectiveness, and efficiency",
-    filePath: "./prompt-engineer.md"
-  },
-  refactorer: {
-    description: "Advanced refactoring agent with architectural analysis, safe incremental strategies, and performance optimization capabilities.",
-    filePath: "./refactorer.md"
-  },
-  researcher: {
-    description: "Conduct comprehensive research including architectural patterns, technology comparison, security analysis, and codebase pattern extraction.",
-    filePath: "./researcher.md"
-  },
-  "security-analyzer": {
-    description: "Comprehensive security analysis agent for vulnerability assessment, threat modeling, and compliance checking",
-    filePath: "./security-analyzer.md"
-  },
-  "stack-splitter": {
-    description: "Semantic analysis agent for splitting monolithic branches into logical, reviewable PR stacks. Analyzes git history, file changes, and code semantics to propose optimal split boundaries.",
-    filePath: "./stack-splitter.md"
-  },
-  "style-enforcer": {
-    description: "Advanced style and convention enforcement with multi-language support, pattern detection, automated fixes, and comprehensive reporting.",
-    filePath: "./style-enforcer.md"
-  },
-  "test-runner": {
-    description: "Automated agent testing specialist that validates agent behaviors, tests prompt variations, detects regressions, and provides comprehensive test reporting with performance metrics.",
-    filePath: "./test-runner.md"
-  },
-  "test-writer": {
-    description: "Generate comprehensive, deterministic tests with advanced testing strategies, scenario generation, and edge case identification.",
-    filePath: "./test-writer.md"
-  }
-};
-
-// packages/ai-toolkit-nx-claude/src/generators/hooks/generator.ts
-var import_devkit5 = require("@nx/devkit");
-var path4 = __toESM(require("path"));
-
-// packages/ai-toolkit-nx-claude/src/generators/hooks/dependency-checker.ts
-var import_child_process = require("child_process");
-var import_devkit2 = require("@nx/devkit");
-function commandExists(command) {
-  try {
-    (0, import_child_process.execSync)(`which ${command}`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getCommandVersion(command, versionFlag = "--version") {
-  try {
-    const output = (0, import_child_process.execSync)(`${command} ${versionFlag}`, {
-      encoding: "utf-8",
-      stdio: "pipe"
-    }).trim();
-    const versionMatch = output.match(/(\d+\.\d+\.\d+)/);
-    return versionMatch ? versionMatch[1] : output.split("\n")[0];
-  } catch {
-    return void 0;
-  }
-}
-function checkDependencies() {
-  const status = {
-    hasNode: false,
-    hasNpm: false,
-    hasGit: false,
-    missingDependencies: []
-  };
-  if (commandExists("node")) {
-    status.hasNode = true;
-    status.nodeVersion = getCommandVersion("node");
-  } else {
-    status.missingDependencies.push("Node.js");
-  }
-  if (commandExists("npm")) {
-    status.hasNpm = true;
-    status.npmVersion = getCommandVersion("npm");
-  } else {
-    status.missingDependencies.push("npm");
-  }
-  if (commandExists("git")) {
-    status.hasGit = true;
-    status.gitVersion = getCommandVersion("git");
-  } else {
-    status.missingDependencies.push("Git");
-  }
-  return status;
-}
-function logDependencyStatus(status) {
-  import_devkit2.logger.info("\u{1F4CB} Dependency Check Results:");
-  if (status.hasNode) {
-    import_devkit2.logger.info(`  \u2705 Node.js: ${status.nodeVersion || "installed"}`);
-  } else {
-    import_devkit2.logger.error("  \u274C Node.js: not found");
-  }
-  if (status.hasNpm) {
-    import_devkit2.logger.info(`  \u2705 npm: ${status.npmVersion || "installed"}`);
-  } else {
-    import_devkit2.logger.error("  \u274C npm: not found");
-  }
-  if (status.hasGit) {
-    import_devkit2.logger.info(`  \u2705 Git: ${status.gitVersion || "installed"}`);
-  } else {
-    import_devkit2.logger.error("  \u274C Git: not found");
-  }
-}
-function hasAllDependencies(status) {
-  return status.missingDependencies.length === 0;
-}
-function getInstallInstructions(missingDeps) {
-  const instructions = [];
-  if (missingDeps.includes("Node.js") || missingDeps.includes("npm")) {
-    instructions.push(
-      "\u{1F4E6} Node.js and npm:",
-      "  \u2022 macOS: brew install node",
-      "  \u2022 Linux: sudo apt-get install nodejs npm",
-      "  \u2022 Windows: Download from https://nodejs.org/",
-      ""
-    );
-  }
-  if (missingDeps.includes("Git")) {
-    instructions.push(
-      "\u{1F4E6} Git:",
-      "  \u2022 macOS: brew install git",
-      "  \u2022 Linux: sudo apt-get install git",
-      "  \u2022 Windows: Download from https://git-scm.com/",
-      ""
-    );
-  }
-  return instructions.join("\n");
-}
-function validateVersions(status) {
-  const MIN_NODE_VERSION = "16.0.0";
-  const MIN_NPM_VERSION = "7.0.0";
-  const MIN_GIT_VERSION = "2.0.0";
-  const compareVersions = (current, minimum) => {
-    if (!current) return false;
-    const currentParts = current.split(".").map(Number);
-    const minimumParts = minimum.split(".").map(Number);
-    for (let i = 0; i < minimumParts.length; i++) {
-      if (currentParts[i] > minimumParts[i]) return true;
-      if (currentParts[i] < minimumParts[i]) return false;
-    }
-    return true;
-  };
-  if (status.hasNode && !compareVersions(status.nodeVersion, MIN_NODE_VERSION)) {
-    import_devkit2.logger.warn(
-      `\u26A0\uFE0F  Node.js version ${status.nodeVersion} is below minimum required version ${MIN_NODE_VERSION}`
-    );
-    return false;
-  }
-  if (status.hasNpm && !compareVersions(status.npmVersion, MIN_NPM_VERSION)) {
-    import_devkit2.logger.warn(
-      `\u26A0\uFE0F  npm version ${status.npmVersion} is below minimum required version ${MIN_NPM_VERSION}`
-    );
-    return false;
-  }
-  if (status.hasGit && !compareVersions(status.gitVersion, MIN_GIT_VERSION)) {
-    import_devkit2.logger.warn(
-      `\u26A0\uFE0F  Git version ${status.gitVersion} is below minimum required version ${MIN_GIT_VERSION}`
-    );
-    return false;
-  }
-  return true;
-}
-async function checkAndValidateDependencies() {
-  const status = checkDependencies();
-  logDependencyStatus(status);
-  if (!hasAllDependencies(status)) {
-    import_devkit2.logger.error("\n\u274C Missing required dependencies:");
-    import_devkit2.logger.info(getInstallInstructions(status.missingDependencies));
-    return false;
-  }
-  if (!validateVersions(status)) {
-    import_devkit2.logger.error(
-      "\n\u274C Some dependencies do not meet minimum version requirements"
-    );
-    import_devkit2.logger.info("Please update the affected tools to continue.");
-    return false;
-  }
-  import_devkit2.logger.info("\n\u2705 All dependencies satisfied!");
-  return true;
-}
-
-// packages/ai-toolkit-nx-claude/src/generators/hooks/repo-manager.ts
-var import_child_process2 = require("child_process");
-var import_devkit3 = require("@nx/devkit");
-var fs3 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
-var os2 = __toESM(require("os"));
-var DEFAULT_REPO_URL = "https://github.com/pascalporedda/awesome-claude-code.git";
-function getRepoPath(customPath) {
-  if (customPath) {
-    return customPath;
-  }
-  return path2.join(os2.tmpdir(), "claude-hooks-temp");
-}
-function isGitRepository(repoPath) {
-  try {
-    if (!fs3.existsSync(repoPath)) {
-      return false;
-    }
-    (0, import_child_process2.execSync)("git rev-parse --git-dir", {
-      cwd: repoPath,
-      stdio: "ignore"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getCurrentBranch(repoPath) {
-  try {
-    const branch = (0, import_child_process2.execSync)("git rev-parse --abbrev-ref HEAD", {
-      cwd: repoPath,
-      encoding: "utf-8"
-    }).trim();
-    return branch;
-  } catch {
-    return void 0;
-  }
-}
-function getLastCommit(repoPath) {
-  try {
-    const commit = (0, import_child_process2.execSync)("git rev-parse HEAD", {
-      cwd: repoPath,
-      encoding: "utf-8"
-    }).trim();
-    return commit.substring(0, 7);
-  } catch {
-    return void 0;
-  }
-}
-function isDirty(repoPath) {
-  try {
-    const status = (0, import_child_process2.execSync)("git status --porcelain", {
-      cwd: repoPath,
-      encoding: "utf-8"
-    }).trim();
-    return status.length > 0;
-  } catch {
-    return false;
-  }
-}
-function getRemoteUrl(repoPath) {
-  try {
-    const url = (0, import_child_process2.execSync)("git config --get remote.origin.url", {
-      cwd: repoPath,
-      encoding: "utf-8"
-    }).trim();
-    return url;
-  } catch {
-    return void 0;
-  }
-}
-function getRepoStatus(repoPath) {
-  const exists = fs3.existsSync(repoPath);
-  const isGit = exists && isGitRepository(repoPath);
-  const status = {
-    exists,
-    path: repoPath,
-    isGitRepo: isGit
-  };
-  if (isGit) {
-    status.currentBranch = getCurrentBranch(repoPath);
-    status.lastCommit = getLastCommit(repoPath);
-    status.isDirty = isDirty(repoPath);
-    status.remoteUrl = getRemoteUrl(repoPath);
-  }
-  return status;
-}
-async function cloneRepository(repoUrl = DEFAULT_REPO_URL, targetPath, verbose = false) {
-  const repoPath = getRepoPath(targetPath);
-  try {
-    if (fs3.existsSync(repoPath)) {
-      import_devkit3.logger.warn(`Directory already exists: ${repoPath}`);
-      if (isGitRepository(repoPath)) {
-        import_devkit3.logger.info("Existing git repository found");
-        return true;
-      } else {
-        import_devkit3.logger.info("Removing non-git directory...");
-        fs3.rmSync(repoPath, { recursive: true, force: true });
-      }
-    }
-    import_devkit3.logger.info(`\u{1F4E5} Downloading notification hooks...`);
-    try {
-      (0, import_child_process2.execSync)(`git clone ${repoUrl} "${repoPath}"`, {
-        stdio: verbose ? "inherit" : "ignore"
-      });
-      import_devkit3.logger.info("\u2705 Download complete");
-      return true;
-    } catch (httpsError) {
-      if (repoUrl === DEFAULT_REPO_URL) {
-        import_devkit3.logger.warn("HTTPS clone failed, trying SSH...");
-        const sshUrl = "git@github.com:pascalporedda/awesome-claude-code.git";
-        try {
-          (0, import_child_process2.execSync)(`git clone ${sshUrl} "${repoPath}"`, {
-            stdio: verbose ? "inherit" : "ignore"
-          });
-          import_devkit3.logger.info("\u2705 Download complete via SSH");
-          return true;
-        } catch (sshError) {
-          import_devkit3.logger.error("\u274C Both HTTPS and SSH clone attempts failed");
-          throw sshError;
-        }
-      } else {
-        throw httpsError;
-      }
-    }
-  } catch (error) {
-    import_devkit3.logger.error(`\u274C Failed to download hooks: ${error}`);
-    return false;
-  }
-}
-async function updateRepository(repoPath, verbose = false) {
-  try {
-    if (!isGitRepository(repoPath)) {
-      import_devkit3.logger.error("Not a git repository");
-      return false;
-    }
-    if (isDirty(repoPath)) {
-      import_devkit3.logger.warn("\u26A0\uFE0F  Repository has uncommitted changes");
-      import_devkit3.logger.info("Stashing changes...");
-      (0, import_child_process2.execSync)("git stash", {
-        cwd: repoPath,
-        stdio: verbose ? "inherit" : "ignore"
-      });
-    }
-    import_devkit3.logger.info("\u{1F4E5} Updating to latest version...");
-    (0, import_child_process2.execSync)("git fetch origin", {
-      cwd: repoPath,
-      stdio: verbose ? "inherit" : "ignore"
-    });
-    (0, import_child_process2.execSync)("git pull origin main", {
-      cwd: repoPath,
-      stdio: verbose ? "inherit" : "ignore"
-    });
-    import_devkit3.logger.info("\u2705 Update complete");
-    return true;
-  } catch (error) {
-    import_devkit3.logger.error(`\u274C Failed to update: ${error}`);
-    return false;
-  }
-}
-function cleanupRepository(repoPath) {
-  try {
-    if (fs3.existsSync(repoPath)) {
-      fs3.rmSync(repoPath, { recursive: true, force: true });
-      import_devkit3.logger.info("\u{1F9F9} Temporary files cleaned up");
-      return true;
-    }
-    return true;
-  } catch (error) {
-    import_devkit3.logger.error(`\u274C Failed to cleanup: ${error}`);
-    return false;
-  }
-}
-async function ensureRepository(options) {
-  const repoUrl = options.repoUrl || DEFAULT_REPO_URL;
-  const repoPath = getRepoPath(options.targetPath);
-  const status = getRepoStatus(repoPath);
-  if (options.verbose) {
-    import_devkit3.logger.info("Repository status:");
-    import_devkit3.logger.info(`  Path: ${status.path}`);
-    import_devkit3.logger.info(`  Exists: ${status.exists}`);
-    import_devkit3.logger.info(`  Is Git Repo: ${status.isGitRepo}`);
-    if (status.isGitRepo) {
-      import_devkit3.logger.info(`  Branch: ${status.currentBranch}`);
-      import_devkit3.logger.info(`  Last Commit: ${status.lastCommit}`);
-      import_devkit3.logger.info(`  Has Changes: ${status.isDirty}`);
-      import_devkit3.logger.info(`  Remote URL: ${status.remoteUrl}`);
-    }
-  }
-  if (status.exists && status.isGitRepo) {
-    if (status.remoteUrl && !status.remoteUrl.includes("awesome-claude-code")) {
-      cleanupRepository(repoPath);
-      const cloned2 = await cloneRepository(
-        DEFAULT_REPO_URL,
-        options.targetPath,
-        options.verbose
-      );
-      if (!cloned2) {
-        return null;
-      }
-      return repoPath;
-    }
-    const updated = await updateRepository(repoPath, options.verbose);
-    if (!updated) {
-      import_devkit3.logger.warn("\u26A0\uFE0F  Failed to update, using existing version");
-    }
-    return repoPath;
-  }
-  const cloned = await cloneRepository(
-    repoUrl,
-    options.targetPath,
-    options.verbose
-  );
-  if (!cloned) {
-    return null;
-  }
-  return repoPath;
-}
-
-// packages/ai-toolkit-nx-claude/src/generators/hooks/install-orchestrator.ts
-var import_child_process3 = require("child_process");
-var import_devkit4 = require("@nx/devkit");
-var path3 = __toESM(require("path"));
-var fs4 = __toESM(require("fs"));
-var os3 = __toESM(require("os"));
-var ROOT_CLAUDE_DIR = path3.join(os3.homedir(), ".claude");
-var HOOKS_DIR = path3.join(ROOT_CLAUDE_DIR, "hooks");
-function backupExistingHooks(verbose = false) {
-  if (!fs4.existsSync(HOOKS_DIR)) {
-    if (verbose) {
-      import_devkit4.logger.info("No existing hooks to backup");
-    }
-    return null;
-  }
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path3.join(ROOT_CLAUDE_DIR, `hooks-backup-${timestamp}`);
-  try {
-    if (verbose) {
-      import_devkit4.logger.info(`\u{1F4E6} Creating backup at: ${backupDir}`);
-    }
-    fs4.mkdirSync(backupDir, { recursive: true });
-    (0, import_child_process3.execSync)(`cp -r "${HOOKS_DIR}"/* "${backupDir}"/`, {
-      stdio: verbose ? "inherit" : "ignore"
-    });
-    const settingsPath = path3.join(ROOT_CLAUDE_DIR, "settings.json");
-    if (fs4.existsSync(settingsPath)) {
-      const backupSettingsPath = path3.join(backupDir, "settings.json.backup");
-      fs4.copyFileSync(settingsPath, backupSettingsPath);
-    }
-    import_devkit4.logger.info(`\u2705 Backup created at: ${backupDir}`);
-    return backupDir;
-  } catch (error) {
-    import_devkit4.logger.error(`\u274C Failed to create backup: ${error}`);
-    return null;
-  }
-}
-async function executeInstallScript(scriptPath, options) {
-  return new Promise((resolve) => {
-    try {
-      if (options.dryRun) {
-        import_devkit4.logger.info("\u{1F50D} DRY RUN: Would execute install script with defaults");
-        resolve(true);
-        return;
-      }
-      import_devkit4.logger.info("\u{1F680} Running hook installation...");
-      const repoDir = path3.dirname(scriptPath);
-      const child = (0, import_child_process3.spawn)("bash", [scriptPath], {
-        stdio: ["pipe", options.verbose ? "inherit" : "pipe", "inherit"],
-        shell: true,
-        cwd: repoDir
-        // Set working directory to the repo directory
-      });
-      if (child.stdin) {
-        child.stdin.write("1\n");
-        child.stdin.end();
-      }
-      child.on("close", (code) => {
-        if (code === 0) {
-          import_devkit4.logger.info("\u2705 Installation script completed successfully");
-          resolve(true);
-        } else {
-          import_devkit4.logger.error(`\u274C Installation script exited with code ${code}`);
-          resolve(false);
-        }
-      });
-      child.on("error", (error) => {
-        import_devkit4.logger.error(`\u274C Failed to execute install script: ${error}`);
-        resolve(false);
-      });
-    } catch (error) {
-      import_devkit4.logger.error(`\u274C Error executing install script: ${error}`);
-      resolve(false);
-    }
-  });
-}
-function fixHookPaths(verbose = false) {
-  const settingsPath = path3.join(ROOT_CLAUDE_DIR, "settings.json");
-  if (!fs4.existsSync(settingsPath)) {
-    if (verbose) {
-      import_devkit4.logger.warn("\u26A0\uFE0F  settings.json not found - cannot fix paths");
-    }
-    return false;
-  }
-  try {
-    const settings = JSON.parse(fs4.readFileSync(settingsPath, "utf-8"));
-    if (!settings.hooks) {
-      if (verbose) {
-        import_devkit4.logger.warn("\u26A0\uFE0F  No hooks configuration found in settings.json");
-      }
-      return false;
-    }
-    const homeDir = os3.homedir();
-    let modified = false;
-    const fixPathInHooks = (hookArray) => {
-      for (const hookConfig of hookArray) {
-        if (hookConfig.hooks && Array.isArray(hookConfig.hooks)) {
-          for (const hook of hookConfig.hooks) {
-            if (hook.command && typeof hook.command === "string") {
-              if (hook.command.includes(homeDir)) {
-                hook.command = hook.command.replace(homeDir, "~");
-                modified = true;
-              }
-              const pathMatch = hook.command.match(/\/(Users|home)\/[^/]+\/\.claude\/hooks\//);
-              if (pathMatch) {
-                hook.command = hook.command.replace(pathMatch[0], "~/.claude/hooks/");
-                modified = true;
-              }
-            }
-          }
-        }
-      }
-    };
-    const hookTypes = ["Notification", "Stop", "SubagentStop", "PreToolUse", "PostToolUse"];
-    for (const hookType of hookTypes) {
-      if (settings.hooks[hookType] && Array.isArray(settings.hooks[hookType])) {
-        fixPathInHooks(settings.hooks[hookType]);
-      }
-    }
-    if (modified) {
-      fs4.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-      if (verbose) {
-        import_devkit4.logger.info("\u2705 Fixed hook paths to use ~ expansion for Docker compatibility");
-      }
-      return true;
-    }
-    return true;
-  } catch (error) {
-    import_devkit4.logger.error(`\u274C Failed to fix hook paths: ${error}`);
-    return false;
-  }
-}
-function verifyInstallation() {
-  const expectedFiles = ["notification.ts", "stop.ts", "subagent_stop.ts"];
-  const installedFiles = [];
-  const missingFiles = [];
-  for (const file of expectedFiles) {
-    const filePath = path3.join(HOOKS_DIR, file);
-    if (fs4.existsSync(filePath)) {
-      installedFiles.push(filePath);
-    } else {
-      missingFiles.push(file);
-    }
-  }
-  if (missingFiles.length > 0) {
-    import_devkit4.logger.warn(`\u26A0\uFE0F  Missing expected files: ${missingFiles.join(", ")}`);
-    return null;
-  }
-  const settingsPath = path3.join(ROOT_CLAUDE_DIR, "settings.json");
-  if (!fs4.existsSync(settingsPath)) {
-    import_devkit4.logger.warn("\u26A0\uFE0F  settings.json not found");
-    return null;
-  }
-  try {
-    const settings = JSON.parse(fs4.readFileSync(settingsPath, "utf-8"));
-    if (!settings.hooks) {
-      import_devkit4.logger.warn("\u26A0\uFE0F  No hooks configuration found in settings.json");
-      return null;
-    }
-    import_devkit4.logger.info("\u2705 Installation verified successfully");
-    return installedFiles;
-  } catch (error) {
-    import_devkit4.logger.error(`\u274C Failed to verify settings.json: ${error}`);
-    return null;
-  }
-}
-async function runInstallation(repoPath, options) {
-  const result = {
-    success: false,
-    installedPath: HOOKS_DIR
-  };
-  try {
-    const installScriptPath = path3.join(repoPath, "install-global.sh");
-    if (!fs4.existsSync(installScriptPath)) {
-      throw new Error(`Install script not found at: ${installScriptPath}`);
-    }
-    (0, import_child_process3.execSync)(`chmod +x "${installScriptPath}"`, { stdio: "ignore" });
-    if (options.backupExisting) {
-      const backupPath = backupExistingHooks(options.verbose);
-      if (backupPath) {
-        result.backupPath = backupPath;
-      }
-    }
-    const installSuccess = await executeInstallScript(
-      installScriptPath,
-      options
-    );
-    if (!installSuccess) {
-      throw new Error("Installation script failed");
-    }
-    const installedFiles = verifyInstallation();
-    if (!installedFiles) {
-      throw new Error("Installation verification failed");
-    }
-    fixHookPaths(options.verbose);
-    result.success = true;
-    result.installedFiles = installedFiles;
-    import_devkit4.logger.info("\n\u{1F4CB} Installation Summary:");
-    import_devkit4.logger.info(`  \u2705 Hooks installed to: ${result.installedPath}`);
-    if (result.backupPath) {
-      import_devkit4.logger.info(`  \u2705 Backup created at: ${result.backupPath}`);
-    }
-    import_devkit4.logger.info(`  \u2705 Files installed: ${installedFiles.length}`);
-    return result;
-  } catch (error) {
-    result.error = error instanceof Error ? error.message : String(error);
-    import_devkit4.logger.error(`\u274C Installation failed: ${result.error}`);
-    if (result.backupPath && !options.dryRun) {
-      import_devkit4.logger.info("\u{1F504} Attempting to restore backup...");
-      await restoreBackup(result.backupPath);
-    }
-    return result;
-  }
-}
-async function restoreBackup(backupPath) {
-  try {
-    if (fs4.existsSync(HOOKS_DIR)) {
-      fs4.rmSync(HOOKS_DIR, { recursive: true, force: true });
-    }
-    fs4.mkdirSync(HOOKS_DIR, { recursive: true });
-    (0, import_child_process3.execSync)(`cp -r "${backupPath}"/* "${HOOKS_DIR}"/`, {
-      stdio: "ignore"
-    });
-    const backupSettingsPath = path3.join(backupPath, "settings.json.backup");
-    if (fs4.existsSync(backupSettingsPath)) {
-      const settingsPath = path3.join(ROOT_CLAUDE_DIR, "settings.json");
-      fs4.copyFileSync(backupSettingsPath, settingsPath);
-    }
-    import_devkit4.logger.info("\u2705 Backup restored successfully");
-    return true;
-  } catch (error) {
-    import_devkit4.logger.error(`\u274C Failed to restore backup: ${error}`);
-    return false;
-  }
-}
-async function testHooks() {
-  try {
-    import_devkit4.logger.info("\u{1F9EA} Testing installed hooks...");
-    const testPayload = {
-      hook_event_name: "Notification",
-      session_id: "test-session",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      cwd: process.cwd()
-    };
-    const notificationHook = path3.join(HOOKS_DIR, "notification.ts");
-    if (!fs4.existsSync(notificationHook)) {
-      import_devkit4.logger.error("\u274C Notification hook not found");
-      return false;
-    }
-    const command = `echo '${JSON.stringify(
-      testPayload
-    )}' | npx tsx "${notificationHook}" --notify`;
-    import_devkit4.logger.info("\u{1F514} Triggering test notification...");
-    (0, import_child_process3.execSync)(command, { stdio: "inherit" });
-    import_devkit4.logger.info("\u2705 Hook test completed successfully");
-    import_devkit4.logger.info("You should have heard a notification sound/speech");
-    return true;
-  } catch (error) {
-    import_devkit4.logger.error(`\u274C Hook test failed: ${error}`);
-    return false;
-  }
-}
-
-// packages/ai-toolkit-nx-claude/src/generators/hooks/generator.ts
-async function hooksGenerator(tree, options) {
-  import_devkit5.logger.info("\u{1F3AF} Claude Code Hooks Generator");
-  import_devkit5.logger.info("Installing notification hooks for Claude Code...\n");
-  import_devkit5.logger.info("\u{1F4CB} Step 1: Checking dependencies...");
-  const depsOk = await checkAndValidateDependencies();
-  if (!depsOk && !options.force) {
-    import_devkit5.logger.error(
-      "\u274C Missing required dependencies. Install them and try again."
-    );
-    import_devkit5.logger.info("Use --force to skip dependency checks (not recommended)");
-    return;
-  }
-  const schemaPath = path4.join(__dirname, "schema.json");
-  let normalizedOptions;
-  if (options.installMode === "default") {
-    normalizedOptions = {
-      backup: options.backup !== false,
-      // Default to true unless explicitly false
-      dry: options.dry || false,
-      force: options.force || false,
-      verbose: options.verbose || false,
-      installMode: "default"
-    };
-  } else {
-    const explicitlyProvided = getExplicitlyProvidedOptions(options);
-    const nxDryRunProvided = isNxDryRunProvided();
-    if (nxDryRunProvided) {
-      options.dry = true;
-      explicitlyProvided.set("dry", true);
-    }
-    const nxNoInteractiveProvided = isNxNoInteractiveProvided();
-    const optionsWithNoInteractive = {
-      ...options,
-      "no-interactive": nxNoInteractiveProvided
-    };
-    try {
-      normalizedOptions = await promptForMissingOptions(
-        optionsWithNoInteractive,
-        schemaPath,
-        {},
-        // context for multi-select (not used here)
-        explicitlyProvided
-        // pass the explicitly provided options
-      );
-    } catch (error) {
-      if (error.message?.includes("Installation cancelled")) {
-        import_devkit5.logger.warn(`\u274C ${error.message}`);
-        return;
-      }
-      throw error;
-    }
-  }
-  const isDryRun = normalizedOptions.dry;
-  if (isDryRun) {
-    import_devkit5.logger.info("\n\u{1F50D} DRY RUN MODE - No changes will be made");
-    import_devkit5.logger.info("The following would be performed:");
-    import_devkit5.logger.info(`  1. Download latest notification hooks`);
-    import_devkit5.logger.info(`  2. Configure notification hooks`);
-    import_devkit5.logger.info(`  3. Install hooks to ~/.claude/hooks/`);
-    import_devkit5.logger.info(`  4. Update ~/.claude/settings.json`);
-    if (normalizedOptions.backup) {
-      import_devkit5.logger.info(`  5. Create backup of existing configuration`);
-    }
-    return;
-  }
-  import_devkit5.logger.info("\n\u{1F4E6} Step 2: Downloading notification hooks...");
-  const repoPath = await ensureRepository({
-    update: true,
-    // Always update to latest
-    verbose: normalizedOptions.verbose
-  });
-  if (!repoPath) {
-    import_devkit5.logger.error("\u274C Failed to prepare repository");
-    return;
-  }
-  import_devkit5.logger.info(`\u2705 Repository ready at: ${repoPath}`);
-  import_devkit5.logger.info("\n\u{1F680} Step 3: Installing hooks...");
-  const installResult = await runInstallation(repoPath, {
-    backupExisting: normalizedOptions.backup !== false,
-    verbose: normalizedOptions.verbose || false,
-    dryRun: isDryRun
-  });
-  if (!installResult.success) {
-    import_devkit5.logger.error("\u274C Installation failed");
-    if (installResult.error) {
-      import_devkit5.logger.error(`Error: ${installResult.error}`);
-    }
-    if (!normalizedOptions.verbose) {
-      cleanupRepository(repoPath);
-    }
-    return;
-  }
-  const shouldTest = !isDryRun && normalizedOptions.verbose;
-  if (shouldTest) {
-    import_devkit5.logger.info("\n\u{1F9EA} Step 4: Testing installation...");
-    const { prompt: prompt3 } = await import("enquirer");
-    const { runTest } = await prompt3({
-      type: "confirm",
-      name: "runTest",
-      message: "Would you like to test the hooks now?",
-      initial: true
-    });
-    if (runTest) {
-      await testHooks();
-    }
-  }
-  if (!normalizedOptions.verbose) {
-    import_devkit5.logger.info("\n\u{1F9F9} Cleaning up temporary files...");
-    cleanupRepository(repoPath);
-  }
-  await (0, import_devkit5.formatFiles)(tree);
-  import_devkit5.logger.info("\n\u2728 SUCCESS! Claude Code hooks installed successfully!");
-  import_devkit5.logger.info("\n\u{1F4DA} Next Steps:");
-  import_devkit5.logger.info("  1. Start a Claude Code session");
-  import_devkit5.logger.info("  2. When Claude needs your input, you'll hear a notification");
-  import_devkit5.logger.info("  3. Check ~/.claude/logs/ for event logs (if enabled)");
-  if (installResult.backupPath) {
-    import_devkit5.logger.info(`
-\u{1F4BE} Backup saved at: ${installResult.backupPath}`);
-  }
-  import_devkit5.logger.info("\n\u{1F389} Happy coding with Claude!");
-}
-var generator_default = hooksGenerator;
-
-// packages/ai-toolkit-nx-claude/src/generators/addons/generator.ts
-var import_devkit6 = require("@nx/devkit");
-init_addon_registry();
-
-// packages/ai-toolkit-nx-claude/src/generators/addons/claude-mcp-installer.ts
-var import_child_process4 = require("child_process");
-init_addon_registry();
-async function installMcpServer(options) {
-  const { addon, additionalArgs = [], dryRun = false, installationType = "global" } = options;
-  try {
-    (0, import_child_process4.execSync)("claude --version", { stdio: "ignore" });
-  } catch {
-    return {
-      success: false,
-      message: "Claude CLI not found",
-      error: "Please install Claude CLI first. Visit https://claude.ai/download"
-    };
-  }
-  const serverName = addon.mcp?.serverName;
-  const scope = installationType === "local" ? "project" : "user";
-  let command = `claude mcp add ${serverName} --scope ${scope}`;
-  if (addon.mcp?.env && Object.keys(addon.mcp.env).length > 0) {
-    for (const [key, value] of Object.entries(addon.mcp.env)) {
-      command += ` --env ${key}=${value}`;
-    }
-  }
-  if (isCommandMcpServer(addon.mcp)) {
-    const mcpMetadata = addon.mcp;
-    command += " --";
-    if (mcpMetadata.command) {
-      command += ` ${mcpMetadata.command}`;
-      if (mcpMetadata.args && mcpMetadata.args.length > 0) {
-        command += ` ${mcpMetadata.args.join(" ")}`;
-      } else {
-        command += ` ${addon.packageName}@latest`;
-      }
-      if (addon.registry) {
-        command += ` ${addon.registry}`;
-      }
-    }
-  } else if (isRemoteHostedMcpServer(addon.mcp)) {
-    const mcpMetadata = addon.mcp;
-    command += ` --transport ${mcpMetadata.transport} ${mcpMetadata.url}`;
-  } else {
-    throw new Error(`Unsupported MCP addon with configuration: ${addon.mcp}`);
-  }
-  if (additionalArgs.length > 0) {
-    command += ` ${additionalArgs.join(" ")}`;
-  }
-  if (dryRun) {
-    console.log("\n\u{1F4CB} Would execute:");
-    console.log(command);
-    return {
-      success: true,
-      message: "Dry-run completed"
-    };
-  }
-  let attempts = 0;
-  const maxAttempts = 3;
-  let lastError;
-  while (attempts < maxAttempts) {
-    attempts++;
-    try {
-      console.log(`
-\u{1F527} Installing MCP server (attempt ${attempts}/${maxAttempts})...`);
-      const output = (0, import_child_process4.execSync)(command, {
-        encoding: "utf-8",
-        stdio: "pipe"
-      });
-      if (output.includes("successfully") || output.includes("added")) {
-        return {
-          success: true,
-          message: "MCP server installed successfully"
-        };
-      }
-      console.log("Output:", output);
-    } catch (error) {
-      lastError = error;
-      if (error.message?.includes("already exists")) {
-        return {
-          success: true,
-          message: "MCP server already installed",
-          error: "Use --force to overwrite existing installation"
-        };
-      }
-      if (error.message?.includes("permission denied")) {
-        return {
-          success: false,
-          message: "Permission denied",
-          error: "Try running with administrator privileges"
-        };
-      }
-      if (error.message?.includes("network") || error.message?.includes("ENOTFOUND")) {
-        if (attempts < maxAttempts) {
-          console.log("Network error, retrying...");
-          await new Promise((resolve) => setTimeout(resolve, 2e3));
-          continue;
-        }
-      }
-      break;
-    }
-  }
-  return {
-    success: false,
-    message: "Failed to install MCP server",
-    error: lastError?.message || "Unknown error occurred"
-  };
-}
-
-// packages/ai-toolkit-nx-claude/src/generators/addons/spec-workflow-setup.ts
-var import_child_process5 = require("child_process");
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-var import_os2 = require("os");
-var import_fs3 = require("fs");
-async function setupSpecWorkflow(projectPath, options) {
-  const targetPath = projectPath || process.cwd();
-  const targetDir = (0, import_path2.join)(targetPath, ".spec-workflow");
-  console.log(`
-\u{1F4C1} Setting up spec-workflow in: ${targetPath}`);
-  const isUpdate = (0, import_fs2.existsSync)(targetDir);
-  if (options.dryRun) {
-    console.log("[DRY-RUN] Would create/update directory: " + targetDir);
-    console.log("[DRY-RUN] Would clone repository: @uniswap/spec-workflow-mcp");
-    console.log("[DRY-RUN] Would copy/update configuration files");
-    console.log("[DRY-RUN] Would add .spec-workflow/ to .gitignore");
-    return {
-      success: true,
-      message: "[DRY-RUN] Spec-workflow setup simulated successfully",
-      projectPath: targetPath
-    };
-  }
-  if (isUpdate) {
-    if (!options.force) {
-      const { confirm } = await require("enquirer").prompt({
-        type: "confirm",
-        name: "confirm",
-        message: `.spec-workflow directory already exists. Update configuration files from repository?`,
-        initial: true
-      });
-      if (!confirm) {
-        return {
-          success: false,
-          message: "Installation cancelled by user",
-          projectPath: targetPath
-        };
-      }
-    }
-    console.log(
-      "\u{1F4DD} Updating configuration files in existing .spec-workflow directory..."
-    );
-  } else {
-    console.log("\u{1F4C1} Creating .spec-workflow directory...");
-    (0, import_fs2.mkdirSync)(targetDir, { recursive: true });
-  }
-  const tempDir = (0, import_path2.join)((0, import_os2.tmpdir)(), `spec-workflow-${Date.now()}`);
-  console.log("\u{1F504} Cloning spec-workflow repository...");
-  const cloneResult = await cloneRepository2(
-    "https://github.com/Uniswap/spec-workflow-mcp.git",
-    tempDir
-  );
-  if (!cloneResult.success) {
-    return {
-      success: false,
-      message: cloneResult.error || "Failed to clone repository",
-      projectPath: targetPath
-    };
-  }
-  console.log("\u{1F4CB} Copying configuration files...");
-  const configSourcePath = (0, import_path2.join)(tempDir, "configs");
-  const copyResult = await copyConfigFiles(configSourcePath, targetDir);
-  console.log("\u{1F9F9} Cleaning up temporary files...");
-  (0, import_fs2.rmSync)(tempDir, { recursive: true, force: true });
-  if (!copyResult.success) {
-    return {
-      success: false,
-      message: copyResult.error || "Failed to copy configuration files",
-      projectPath: targetPath
-    };
-  }
-  console.log("\u{1F4DD} Updating .gitignore...");
-  const gitignoreResult = await updateGitignore(targetPath, ".spec-workflow/");
-  if (!gitignoreResult.success) {
-    console.warn("\u26A0\uFE0F  Warning:", gitignoreResult.message);
-  } else {
-    console.log("\u2705", gitignoreResult.message);
-  }
-  return {
-    success: true,
-    message: isUpdate ? "The spec-workflow configuration has been updated with the latest templates and settings" : "The spec-workflow package has been added to the project with automatic agent orchestration enabled",
-    projectPath: targetPath,
-    createdFiles: copyResult.copiedFiles
-  };
-}
-async function cloneRepository2(repositoryUrl, targetDir) {
-  try {
-    if (!(0, import_fs2.existsSync)(targetDir)) {
-      (0, import_fs2.mkdirSync)(targetDir, { recursive: true });
-    }
-    (0, import_child_process5.execSync)(`git clone --depth 1 "${repositoryUrl}" "${targetDir}"`, {
-      stdio: "pipe",
-      encoding: "utf8"
-    });
-    return {
-      success: true,
-      message: "Repository cloned successfully",
-      clonePath: targetDir
-    };
-  } catch (error) {
-    console.error("\u274C Git clone failed:", error.message);
-    if (error.message.includes("not found")) {
-      return {
-        success: false,
-        message: "Repository not found",
-        error: "The repository URL may be incorrect or you may not have access"
-      };
-    } else if (error.message.includes("Authentication")) {
-      return {
-        success: false,
-        message: "Authentication failed",
-        error: "Please check your git credentials"
-      };
-    } else if (error.message.includes("network")) {
-      return {
-        success: false,
-        message: "Network error",
-        error: "Please check your internet connection"
-      };
-    }
-    return {
-      success: false,
-      message: "Git clone failed",
-      error: error.message
-    };
-  }
-}
-async function updateGitignore(projectPath, pattern) {
-  const gitignorePath = (0, import_path2.join)(projectPath, ".gitignore");
-  try {
-    let gitignoreContent = "";
-    if ((0, import_fs2.existsSync)(gitignorePath)) {
-      gitignoreContent = (0, import_fs2.readFileSync)(gitignorePath, "utf8");
-    }
-    const lines = gitignoreContent.split("\n");
-    const patternExists = lines.some((line) => {
-      const trimmedLine = line.trim();
-      return trimmedLine === pattern || trimmedLine === pattern.replace(/\/$/, "");
-    });
-    if (patternExists) {
-      return {
-        success: true,
-        message: `.gitignore already contains ${pattern}`
-      };
-    }
-    const updatedContent = gitignoreContent.trim() === "" ? pattern : `${gitignoreContent.trim()}
-
-# Spec workflow configuration
-${pattern}`;
-    (0, import_fs2.writeFileSync)(gitignorePath, updatedContent + "\n", "utf8");
-    return {
-      success: true,
-      message: `Added ${pattern} to .gitignore`
-    };
-  } catch (error) {
-    console.error("\u274C Failed to update .gitignore:", error.message);
-    return {
-      success: false,
-      message: `Failed to update .gitignore: ${error.message}`
-    };
-  }
-}
-async function copyConfigFiles(sourceDir, targetDir) {
-  try {
-    let listFiles2 = function(dir, baseDir = dir, sourceBase = sourceDir) {
-      const files = fs6.readdirSync(dir);
-      for (const file of files) {
-        const filePath = (0, import_path2.join)(dir, file);
-        const stat = fs6.statSync(filePath);
-        if (stat.isDirectory()) {
-          listFiles2(filePath, baseDir, sourceBase);
-        } else {
-          const relativePath = filePath.replace(baseDir + "/", "");
-          const sourceFile = (0, import_path2.join)(sourceBase, relativePath);
-          if ((0, import_fs2.existsSync)(sourceFile)) {
-            copiedFiles.push(relativePath);
-          }
-        }
-      }
-    };
-    var listFiles = listFiles2;
-    if (!(0, import_fs2.existsSync)(sourceDir)) {
-      return {
-        success: false,
-        message: "Source directory not found",
-        error: `The configs directory was not found in the cloned repository`
-      };
-    }
-    (0, import_fs3.cpSync)(sourceDir, targetDir, { recursive: true });
-    const fs6 = require("fs");
-    const copiedFiles = [];
-    listFiles2(targetDir, targetDir, sourceDir);
-    return {
-      success: true,
-      message: "Configuration files copied successfully",
-      copiedFiles
-    };
-  } catch (error) {
-    console.error("\u274C File copy failed:", error.message);
-    return {
-      success: false,
-      message: "Failed to copy configuration files",
-      error: error.message
-    };
-  }
-}
-
-// packages/ai-toolkit-nx-claude/src/generators/addons/aws-log-analyzer-setup.ts
-var import_child_process6 = require("child_process");
-var import_fs4 = require("fs");
-var import_path3 = require("path");
-var import_os3 = require("os");
-async function setupAwsLogAnalyzer(options) {
-  const targetPath = (0, import_path3.join)((0, import_os3.homedir)(), ".aws-log-analyzer-mcp");
-  const serverPath = (0, import_path3.join)(targetPath, "src", "cw-mcp-server");
-  console.log(`
-\u{1F4C1} Setting up AWS Log Analyzer MCP in: ${targetPath}`);
-  const isUpdate = (0, import_fs4.existsSync)(targetPath);
-  if (options.dryRun) {
-    console.log("[DRY-RUN] Would clone repository to: " + targetPath);
-    console.log("[DRY-RUN] MCP server would run from: " + serverPath);
-    console.log("[DRY-RUN] Would run: uv sync to install Python dependencies");
-    return {
-      success: true,
-      message: "[DRY-RUN] AWS Log Analyzer setup simulated successfully",
-      clonedPath: targetPath,
-      serverPath
-    };
-  }
-  if (isUpdate) {
-    if (!options.force) {
-      const { confirm } = await require("enquirer").prompt({
-        type: "confirm",
-        name: "confirm",
-        message: `AWS Log Analyzer repository already exists at ${targetPath}. Update to latest version?`,
-        initial: true
-      });
-      if (!confirm) {
-        console.log("\u2705 Using existing installation at:", targetPath);
-        return {
-          success: true,
-          message: "Using existing AWS Log Analyzer installation",
-          clonedPath: targetPath,
-          serverPath
-        };
-      }
-    }
-    console.log("\u{1F504} Updating AWS Log Analyzer repository...");
-    (0, import_fs4.rmSync)(targetPath, { recursive: true, force: true });
-  }
-  console.log("\u{1F4C1} Creating installation directory...");
-  (0, import_fs4.mkdirSync)(targetPath, { recursive: true });
-  console.log("\u{1F504} Cloning AWS Log Analyzer repository...");
-  const cloneResult = await cloneRepository2(
-    "https://github.com/awslabs/Log-Analyzer-with-MCP.git",
-    targetPath
-  );
-  if (!cloneResult.success) {
-    return {
-      success: false,
-      message: "Failed to clone AWS Log Analyzer repository",
-      error: cloneResult.error || cloneResult.message
-    };
-  }
-  console.log("\u{1F4E6} Installing Python dependencies with uv...");
-  try {
-    (0, import_child_process6.execSync)("uv sync", {
-      cwd: targetPath,
-      stdio: "inherit",
-      encoding: "utf8"
-    });
-    console.log("\u2705 Python dependencies installed successfully");
-  } catch (error) {
-    console.warn("\u26A0\uFE0F  Warning: Failed to install Python dependencies");
-    console.warn('   You may need to run "uv sync" manually in:', targetPath);
-    console.warn("   Error:", error.message);
-  }
-  return {
-    success: true,
-    message: isUpdate ? "AWS Log Analyzer has been updated to the latest version" : "AWS Log Analyzer has been installed successfully",
-    clonedPath: targetPath,
-    serverPath
-  };
-}
-function getAwsLogAnalyzerPath() {
-  return (0, import_path3.join)((0, import_os3.homedir)(), ".aws-log-analyzer-mcp");
-}
-function getAwsLogAnalyzerServerPath() {
-  return (0, import_path3.join)(getAwsLogAnalyzerPath(), "src", "cw-mcp-server");
-}
-
-// packages/ai-toolkit-nx-claude/src/generators/addons/generator.ts
-async function generator(tree, schema) {
-  console.log("\n\u{1F3AF} Claude Code Addons Installer");
-  console.log("================================\n");
-  const dryRunFlagProvided = isNxDryRunProvided() ?? schema.dry;
-  const noInteractive = isNxNoInteractiveProvided();
-  let isDryRun = dryRunFlagProvided;
-  if (isDryRun === void 0 && !noInteractive) {
-    const { runDryRun } = await require("enquirer").prompt({
-      type: "confirm",
-      name: "runDryRun",
-      message: "\u{1F50D} Would you like to run in dry-run mode (preview changes without making them)?",
-      initial: false
-    });
-    isDryRun = runDryRun;
-  }
-  if (isDryRun) {
-    console.log("\u{1F50D} Dry-run mode activated\n");
-  }
-  let options;
-  if (schema.installMode === "default") {
-    options = {
-      selectionMode: schema.selectionMode || "all",
-      force: schema.force || false,
-      skipVerification: schema.skipVerification || false,
-      dashboardMode: schema.dashboardMode || "always",
-      port: schema.port || 0,
-      dry: schema.dry || false,
-      installMode: "default",
-      installationType: schema.installationType || "global",
-      dryRun: isDryRun
-    };
-  } else {
-    const availableAddons = getAvailableAddons();
-    options = await promptForMissingOptions(schema, require_schema(), {
-      availableAddons: availableAddons.map((a) => a.id),
-      addonDescriptions: availableAddons.reduce((acc, a) => {
-        acc[a.id] = `${a.name}: ${a.description}`;
-        return acc;
-      }, {})
-    });
-    options.dryRun = isDryRun;
-  }
-  if (options.selectionMode === "all") {
-    await installAllAddons(tree, options);
-    return;
-  }
-  await installSelectedAddons(tree, options);
-  await (0, import_devkit6.formatFiles)(tree);
-}
-async function installSelectedAddons(tree, options) {
-  const selectedAddonIds = options.addons || [];
-  if (selectedAddonIds.length === 0) {
-    console.log("\n\u26A0\uFE0F  No addons selected for installation");
-    return;
-  }
-  const selectedAddons = selectedAddonIds.map((id) => getAddonById(id)).filter((addon) => addon !== void 0);
-  if (selectedAddons.length === 0) {
-    throw new Error("No valid addons found in selection");
-  }
-  console.log("\n\u{1F4E6} Installing Selected MCP Servers");
-  console.log("===================================\n");
-  console.log(`Installing ${selectedAddons.length} MCP server(s)
-`);
-  const results = [];
-  for (let i = 0; i < selectedAddons.length; i++) {
-    const addon = selectedAddons[i];
-    console.log(`
-[${i + 1}/${selectedAddons.length}] Installing: ${addon.name}`);
-    console.log(`   ${addon.description}`);
-    try {
-      if (!options.force && !options.dryRun) {
-        const installed = await isAddonInstalled(addon.id);
-        if (installed) {
-          console.log("   \u2705 Already installed, skipping");
-          results.push({ addon, success: true });
-          continue;
-        }
-      }
-      const validation = await validateAddonRequirements(addon.id);
-      if (!validation.valid && !options.force) {
-        console.log("   \u26A0\uFE0F  Requirements not met:");
-        validation.errors.forEach((error) => console.log(`      \u2022 ${error}`));
-        console.log("   \u23ED\uFE0F  Skipping (use --force to override)");
-        results.push({
-          addon,
-          success: false,
-          error: "Requirements not met"
-        });
-        continue;
-      }
-      await installMcpAddon(addon, options);
-      if (addon.id === "spec-workflow-mcp" && addon.projectSetup && i === selectedAddons.length - 1) {
-        const { setupProject } = await require("enquirer").prompt({
-          type: "confirm",
-          name: "setupProject",
-          message: "\u{1F4C1} Would you like to set up spec-workflow configuration for a particular project?",
-          initial: true
-        });
-        if (setupProject) {
-          const { projectPath } = await require("enquirer").prompt({
-            type: "input",
-            name: "projectPath",
-            message: "\u{1F4C1} Enter the project path where spec-workflow config should be added:",
-            initial: process.cwd(),
-            result: (value) => value || process.cwd()
-          });
-          options.projectPath = projectPath;
-          if (options.dryRun) {
-            console.log(`
-\u{1F4C1} [DRY-RUN] Would set up project configuration at: ${projectPath}`);
-          }
-          await installProjectSetup(addon, options);
-        } else if (options.dryRun) {
-          console.log("\n\u{1F4C1} [DRY-RUN] Skipping project configuration (user chose not to set up)");
-        }
-      }
-      results.push({ addon, success: true });
-    } catch (error) {
-      console.error(`   \u274C Failed: ${error instanceof Error ? error.message : String(error)}`);
-      results.push({
-        addon,
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  console.log("\n\n\u{1F4CA} Installation Summary");
-  console.log("======================\n");
-  const successful = results.filter((r) => r.success);
-  const failed = results.filter((r) => !r.success);
-  console.log(`\u2705 Successfully installed: ${successful.length}`);
-  successful.forEach((r) => console.log(`   \u2022 ${r.addon.name}`));
-  if (failed.length > 0) {
-    console.log(`
-\u274C Failed to install: ${failed.length}`);
-    failed.forEach((r) => console.log(`   \u2022 ${r.addon.name} - ${r.error || "Unknown error"}`));
-  }
-  if (options.dryRun) {
-    console.log("\n\u2728 Dry-run complete! No changes were made.\n");
-    showGeneralMcpInstructions(selectedAddons);
-  } else {
-    console.log("\n\u2728 Installation complete!\n");
-    showGeneralMcpInstructions(successful.map((r) => r.addon));
-  }
-}
-async function installAllAddons(tree, options) {
-  const allAddons = (init_addon_registry(), __toCommonJS(addon_registry_exports)).getAvailableAddons();
-  console.log("\n\u{1F4E6} Installing All Recommended MCP Servers");
-  console.log("==========================================\n");
-  console.log(`Found ${allAddons.length} MCP servers to install
-`);
-  const results = [];
-  for (let i = 0; i < allAddons.length; i++) {
-    const addon = allAddons[i];
-    console.log(`
-[${i + 1}/${allAddons.length}] Installing: ${addon.name}`);
-    console.log(`   ${addon.description}`);
-    try {
-      if (!options.force && !options.dryRun) {
-        const installed = await isAddonInstalled(addon.id);
-        if (installed) {
-          console.log("   \u2705 Already installed, skipping");
-          results.push({ addon, success: true });
-          continue;
-        }
-      }
-      const validation = await validateAddonRequirements(addon.id);
-      if (!validation.valid && !options.force) {
-        console.log("   \u26A0\uFE0F  Requirements not met:");
-        validation.errors.forEach((error) => console.log(`      \u2022 ${error}`));
-        console.log("   \u23ED\uFE0F  Skipping (use --force to override)");
-        results.push({
-          addon,
-          success: false,
-          error: "Requirements not met"
-        });
-        continue;
-      }
-      await installMcpAddon(addon, options);
-      results.push({ addon, success: true });
-    } catch (error) {
-      console.error(`   \u274C Failed: ${error instanceof Error ? error.message : String(error)}`);
-      results.push({
-        addon,
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  console.log("\n\n\u{1F4CA} Installation Summary");
-  console.log("======================\n");
-  const successful = results.filter((r) => r.success);
-  const failed = results.filter((r) => !r.success);
-  console.log(`\u2705 Successfully installed: ${successful.length}`);
-  successful.forEach((r) => console.log(`   \u2022 ${r.addon.name}`));
-  if (failed.length > 0) {
-    console.log(`
-\u274C Failed to install: ${failed.length}`);
-    failed.forEach((r) => console.log(`   \u2022 ${r.addon.name} - ${r.error || "Unknown error"}`));
-  }
-  if (options.dryRun) {
-    console.log("\n\u2728 Dry-run complete! No changes were made.\n");
-    showGeneralMcpInstructions(allAddons);
-  } else {
-    console.log("\n\u2728 Batch installation complete!\n");
-    showGeneralMcpInstructions(successful.map((r) => r.addon));
-  }
-}
-async function installMcpAddon(addon, options) {
-  if (addon.id === "aws-log-analyzer-mcp") {
-    console.log("\n\u{1F4E6} AWS Log Analyzer requires repository setup...");
-    const setupResult = await setupAwsLogAnalyzer(options);
-    if (!setupResult.success) {
-      throw new Error(setupResult.error || setupResult.message);
-    }
-    console.log(`\u2705 ${setupResult.message}`);
-    const serverPath = setupResult.serverPath || getAwsLogAnalyzerServerPath();
-    addon.mcp.args = ["--directory", serverPath, "run", "server.py"];
-    console.log(`\u{1F4CD} Server path: ${serverPath}`);
-  }
-  if (options.dryRun) {
-    console.log("\n\u{1F527} [DRY-RUN] Simulating MCP server installation...");
-  } else {
-    console.log("\n\u{1F527} Installing MCP server...");
-  }
-  const additionalArgs = [];
-  if (addon.id === "spec-workflow-mcp") {
-    if (options.dashboardMode === "always") {
-      additionalArgs.push("--AutoStartDashboard");
-    }
-    if (options.port && options.port > 0) {
-      additionalArgs.push(`--Port=${options.port}`);
-    }
-  }
-  const installResult = await installMcpServer({
-    addon,
-    additionalArgs,
-    dryRun: options.dryRun,
-    installationType: options.installationType || "global"
-  });
-  if (!installResult.success) {
-    throw new Error(installResult.error || installResult.message);
-  }
-  console.log(`\u2705 ${installResult.message}`);
-}
-async function installProjectSetup(addon, options) {
-  console.log("\n\u{1F527} Setting up project configuration...");
-  const projectPath = options.projectPath || process.cwd();
-  console.log(`\u{1F4CD} Using project directory: ${projectPath}`);
-  const result = await setupSpecWorkflow(projectPath, options);
-  if (!result.success) {
-    throw new Error(result.message);
-  }
-  console.log(`\u2705 ${result.message}`);
-}
-function showGeneralMcpInstructions(installedAddons) {
-  console.log("\n\u{1F4DA} Getting Started with Your MCPs");
-  console.log("==================================\n");
-  console.log("Most MCPs require authentication before use. Here's how:");
-  console.log("\n1. Start a new Claude Code session");
-  console.log("2. Run the `/mcp` slash command");
-  console.log("3. Select the MCP you want to configure");
-  console.log("4. Follow the authentication instructions");
-  console.log("5. Once authenticated, you can use the MCP in Claude Code\n");
-  console.log("\u{1F4D6} Example: Linear MCP Authentication");
-  console.log("   https://linear.app/docs/mcp#claude");
-  console.log("   (Most MCPs follow a similar authentication flow)\n");
-  const needsAuth = installedAddons.filter(
-    (addon) => addon.id === "slack-mcp" || addon.id === "github-mcp" || addon.id === "aws-log-analyzer-mcp" || addon.id === "linear-mcp" || addon.id === "notion-mcp" || addon.id === "supabase-mcp" || addon.id === "pulumi-mcp"
-  );
-  if (needsAuth.length > 0) {
-    console.log("\u{1F510} MCPs requiring authentication:");
-    needsAuth.forEach((addon) => {
-      console.log(`   \u2022 ${addon.name}`);
-    });
-    console.log("");
-  }
-  const hasSlack = installedAddons.some((addon) => addon.id === "slack-mcp");
-  const hasGithub = installedAddons.some((addon) => addon.id === "github-mcp");
-  const hasPulumi = installedAddons.some((addon) => addon.id === "pulumi-mcp");
-  const hasAws = installedAddons.some((addon) => addon.id === "aws-log-analyzer-mcp");
-  if (hasSlack || hasGithub || hasAws || hasPulumi) {
-    console.log("\u{1F4CB} Specific Authentication Instructions:\n");
-    if (hasSlack) {
-      console.log("\u{1F510} Slack MCP:");
-      console.log(
-        "   \u{1F4D6} Documentation: https://www.notion.so/uniswaplabs/Using-a-Slack-MCP-with-Claude-Claude-Code-249c52b2548b8052b901dc05d90e57fc"
-      );
-      console.log(
-        "   This guide contains detailed instructions on how to obtain your Slack bot token.\n"
-      );
-    }
-    if (hasGithub) {
-      console.log("\u{1F510} GitHub MCP:");
-      console.log("   You can obtain your GitHub Personal Access Token using:");
-      console.log("   $ gh auth token");
-      console.log("   (Requires GitHub CLI to be installed and authenticated)\n");
-    }
-    if (hasAws) {
-      console.log("\u{1F510} AWS Log Analyzer MCP:");
-      console.log("   Requires AWS credentials with CloudWatchLogsReadOnlyAccess");
-      console.log("   \u{1F4D6} Documentation: https://github.com/awslabs/Log-Analyzer-with-MCP\n");
-    }
-    if (hasPulumi) {
-      console.log("\u{1F510} Pulumi MCP:");
-      console.log(
-        "   When authenticating for the first time, you will need to create a Pulumi Personal Access Token (PAT)."
-      );
-      console.log(
-        "   \u{1F4D6} Documentation: https://www.pulumi.com/docs/iac/guides/ai-integration/mcp-server/"
-      );
-      console.log("   Create your PAT at: https://app.pulumi.com/account/tokens\n");
-    }
-  }
-}
-
-// packages/ai-toolkit-nx-claude/src/generators/init/generator.ts
-var DEFAULT_COMMANDS = ["explore", "plan", "review-plan", "execute-plan", "address-pr-issues"];
-var DEFAULT_AGENTS = [
-  "context-loader",
-  "planner",
-  "plan-reviewer",
-  "test-writer",
-  "doc-writer",
-  "pr-reviewer"
-];
-function checkExistingFiles(targetDir, subDir, items) {
-  const existing = /* @__PURE__ */ new Set();
-  const dir = path5.join(targetDir, subDir);
-  for (const item of items) {
-    const filePath = path5.join(dir, `${item}.md`);
-    if (fs5.existsSync(filePath)) {
-      existing.add(item);
-    }
-  }
-  return existing;
-}
-async function initGenerator(tree, options) {
-  const explicitlyProvided = getExplicitlyProvidedOptions();
-  const nxDryRunProvided = isNxDryRunProvided();
-  if (nxDryRunProvided) {
-    options.dry = true;
-    explicitlyProvided.set("dry", true);
-  }
-  const nxNoInteractiveProvided = isNxNoInteractiveProvided();
-  let isDryRun = options.dry;
-  if (!nxNoInteractiveProvided && !options.nonInteractive && !isDryRun) {
-    const isClaudeInstalled = checkClaudeInstalled();
-    if (!isClaudeInstalled) {
-      import_devkit7.logger.warn("\u26A0\uFE0F  Claude CLI is not installed");
-      const shouldInstall = await promptInstallClaude();
-      if (shouldInstall) {
-        await installClaude();
-      }
-    } else {
-      import_devkit7.logger.info("\u2705 Claude CLI is installed");
-    }
-  } else if (isDryRun && !checkClaudeInstalled()) {
-    import_devkit7.logger.info("\u{1F50D} DRY RUN: Claude CLI is not installed");
-    import_devkit7.logger.info("Would attempt installation in this order:");
-    import_devkit7.logger.info("  1. curl -fsSL https://claude.ai/install.sh | bash");
-    import_devkit7.logger.info("  2. npm install -g @anthropic-ai/claude-code (if curl fails)");
-    import_devkit7.logger.info("  3. Manual instructions (if both fail)");
-  }
-  const installMode = options.installMode;
-  if (installMode === "default") {
-    import_devkit7.logger.info("\u{1F4E6} Default Installation Mode");
-    import_devkit7.logger.info("   Installing recommended setup with pre-selected components\n");
-    options.installMode = "default";
-    options.installationType = "global";
-    options.commands = DEFAULT_COMMANDS;
-    options.agents = DEFAULT_AGENTS;
-    options.installCommands = true;
-    options.installAgents = true;
-    options.installHooks = true;
-    options.hooksMode = "sound";
-    options.installAddons = true;
-    options.dry = false;
-    import_devkit7.logger.info("\u{1F4CD} Location: Global (~/.claude)");
-    import_devkit7.logger.info(`\u{1F4DD} Commands: ${DEFAULT_COMMANDS.length} pre-selected`);
-    import_devkit7.logger.info(`\u{1F916} Agents: ${DEFAULT_AGENTS.length} pre-selected`);
-    import_devkit7.logger.info(`\u{1F50C} MCPs: All recommended servers will be installed
-`);
-    explicitlyProvided.set("installMode", "default");
-    explicitlyProvided.set("installationType", "global");
-    explicitlyProvided.set("installCommands", true);
-    explicitlyProvided.set("installAgents", true);
-    explicitlyProvided.set("installHooks", true);
-    explicitlyProvided.set("hooksMode", "sound");
-    explicitlyProvided.set("installAddons", true);
-    explicitlyProvided.set("dry", false);
-    explicitlyProvided.set("commands", DEFAULT_COMMANDS);
-    explicitlyProvided.set("agents", DEFAULT_AGENTS);
-  }
-  const schemaPath = path5.join(__dirname, "schema.json");
-  const commandDescriptions = Object.fromEntries(
-    Object.entries(commands).map(([key, value]) => [key, value.description])
-  );
-  const agentDescriptions = Object.fromEntries(
-    Object.entries(agents).map(([key, value]) => [key, value.description])
-  );
-  const homeDir = os4.homedir();
-  const globalDir = path5.join(homeDir, ".claude");
-  const localDir = path5.join(process.cwd(), ".claude");
-  const globalExistingCommands = checkExistingFiles(
-    globalDir,
-    "commands",
-    Object.keys(commands)
-  );
-  const globalExistingAgents = checkExistingFiles(globalDir, "agents", Object.keys(agents));
-  const localExistingCommands = checkExistingFiles(
-    localDir,
-    "commands",
-    Object.keys(commands)
-  );
-  const localExistingAgents = checkExistingFiles(localDir, "agents", Object.keys(agents));
-  const optionsWithNoInteractive = {
-    ...options,
-    "no-interactive": nxNoInteractiveProvided || options.nonInteractive
-  };
-  let normalizedOptions;
-  try {
-    normalizedOptions = await promptForMissingOptions(
-      optionsWithNoInteractive,
-      schemaPath,
-      {
-        availableCommands: Object.keys(commands),
-        availableAgents: Object.keys(agents),
-        commandDescriptions,
-        agentDescriptions,
-        globalExistingCommands,
-        globalExistingAgents,
-        localExistingCommands,
-        localExistingAgents,
-        defaultCommands: DEFAULT_COMMANDS,
-        defaultAgents: DEFAULT_AGENTS
-      },
-      explicitlyProvided
-    );
-  } catch (error) {
-    if (error.message?.includes("Installation cancelled")) {
-      import_devkit7.logger.warn(`\u274C ${error.message}`);
-      return;
-    }
-    throw error;
-  }
-  isDryRun = normalizedOptions.dry || false;
-  if (isDryRun) {
-    import_devkit7.logger.info("\u{1F50D} DRY RUN MODE - No files will be modified");
-  }
-  if (normalizedOptions.commandSelectionMode === "all") {
-    normalizedOptions.commands = Object.keys(commands);
-    import_devkit7.logger.info(`\u{1F4DD} All commands selected (${normalizedOptions.commands.length} total)`);
-  }
-  if (normalizedOptions.agentSelectionMode === "all") {
-    normalizedOptions.agents = Object.keys(agents);
-    import_devkit7.logger.info(`\u{1F916} All agents selected (${normalizedOptions.agents.length} total)`);
-  }
-  if (normalizedOptions.installCommands === false) {
-    normalizedOptions.commands = [];
-  }
-  if (normalizedOptions.installAgents === false) {
-    normalizedOptions.agents = [];
-  }
-  const isGlobalInstall = normalizedOptions.installationType === "global";
-  const workspaceRoot = process.cwd();
-  const targetDir = isGlobalInstall ? path5.join(homeDir, ".claude") : path5.join(workspaceRoot, ".claude");
-  const relativeTargetDir = isGlobalInstall ? path5.relative(workspaceRoot, targetDir) : ".claude";
-  const relativeManifestPath = path5.join(relativeTargetDir, "manifest.json");
-  if (!isDryRun) {
-    if (tree.exists(relativeManifestPath)) {
-      if (!normalizedOptions.force) {
-        if (normalizedOptions.nonInteractive) {
-          import_devkit7.logger.warn(
-            "Installation cancelled - existing Claude configuration found. Use --force to overwrite."
-          );
-          return;
-        }
-      }
-    }
-  }
-  const commandsDir = path5.join(targetDir, "commands");
-  const agentsDir = path5.join(targetDir, "agents");
-  const relativeCommandsDir = path5.join(relativeTargetDir, "commands");
-  const relativeAgentsDir = path5.join(relativeTargetDir, "agents");
-  const installedCommands = [];
-  const installedAgents = [];
-  const installedFiles = [];
-  const commandsToInstall = normalizedOptions.commands || [];
-  for (const commandName of commandsToInstall) {
-    let sourcePath = null;
-    const bundledContentDir = path5.join(__dirname, "..", "..", "content", "commands");
-    if (fs5.existsSync(bundledContentDir)) {
-      const contentSubDirs = fs5.readdirSync(bundledContentDir).filter((item) => {
-        const itemPath = path5.join(bundledContentDir, item);
-        return fs5.statSync(itemPath).isDirectory();
-      });
-      for (const subDir of contentSubDirs) {
-        const potentialPath = path5.join(bundledContentDir, subDir, `${commandName}.md`);
-        if (fs5.existsSync(potentialPath)) {
-          sourcePath = potentialPath;
-          break;
-        }
-      }
-    }
-    if (!sourcePath) {
-      const commandsBaseDir = path5.join(workspaceRoot, "packages/commands");
-      if (fs5.existsSync(commandsBaseDir)) {
-        const commandSubDirs = fs5.readdirSync(commandsBaseDir).filter((item) => {
-          const itemPath = path5.join(commandsBaseDir, item);
-          return fs5.statSync(itemPath).isDirectory();
-        });
-        for (const subDir of commandSubDirs) {
-          const potentialPath = path5.join(commandsBaseDir, subDir, "src", `${commandName}.md`);
-          if (fs5.existsSync(potentialPath)) {
-            sourcePath = potentialPath;
-            break;
-          }
-        }
-      }
-    }
-    const destPath = path5.join(commandsDir, `${commandName}.md`);
-    const relativeDestPath = path5.join(relativeCommandsDir, `${commandName}.md`);
-    try {
-      if (sourcePath && fs5.existsSync(sourcePath)) {
-        const content = fs5.readFileSync(sourcePath, "utf-8");
-        if (!isDryRun) {
-          tree.write(relativeDestPath, content);
-        }
-        installedCommands.push(commandName);
-        installedFiles.push(path5.relative(targetDir, destPath));
-      } else {
-        import_devkit7.logger.warn(`Command file not found: ${commandName}`);
-      }
-    } catch (error) {
-      import_devkit7.logger.warn(`Error reading command ${commandName}: ${error}`);
-    }
-  }
-  const agentsToInstall = normalizedOptions.agents || [];
-  for (const agentName of agentsToInstall) {
-    let sourcePath = null;
-    const bundledContentDir = path5.join(__dirname, "..", "..", "content", "agents");
-    if (fs5.existsSync(bundledContentDir)) {
-      const contentSubDirs = fs5.readdirSync(bundledContentDir).filter((item) => {
-        const itemPath = path5.join(bundledContentDir, item);
-        return fs5.statSync(itemPath).isDirectory();
-      });
-      for (const subDir of contentSubDirs) {
-        const potentialPath = path5.join(bundledContentDir, subDir, `${agentName}.md`);
-        if (fs5.existsSync(potentialPath)) {
-          sourcePath = potentialPath;
-          break;
-        }
-      }
-    }
-    if (!sourcePath) {
-      const agentsBaseDir = path5.join(workspaceRoot, "packages/agents");
-      if (fs5.existsSync(agentsBaseDir)) {
-        const agentSubDirs = fs5.readdirSync(agentsBaseDir).filter((item) => {
-          const itemPath = path5.join(agentsBaseDir, item);
-          return fs5.statSync(itemPath).isDirectory();
-        });
-        for (const subDir of agentSubDirs) {
-          const potentialPath = path5.join(agentsBaseDir, subDir, "src", `${agentName}.md`);
-          if (fs5.existsSync(potentialPath)) {
-            sourcePath = potentialPath;
-            break;
-          }
-        }
-      }
-    }
-    const destPath = path5.join(agentsDir, `${agentName}.md`);
-    const relativeDestPath = path5.join(relativeAgentsDir, `${agentName}.md`);
-    try {
-      if (sourcePath && fs5.existsSync(sourcePath)) {
-        const content = fs5.readFileSync(sourcePath, "utf-8");
-        if (!isDryRun) {
-          tree.write(relativeDestPath, content);
-        }
-        installedAgents.push(agentName);
-        installedFiles.push(path5.relative(targetDir, destPath));
-      } else {
-        import_devkit7.logger.warn(`Agent file not found: ${agentName}`);
-      }
-    } catch (error) {
-      import_devkit7.logger.warn(`Error reading agent ${agentName}: ${error}`);
-    }
-  }
-  import_devkit7.logger.info("\u{1F4E6} Installation Plan:");
-  import_devkit7.logger.info(
-    `  Location: ${normalizedOptions.installationType === "global" ? `Global (${targetDir})` : `Local (${targetDir})`}`
-  );
-  import_devkit7.logger.info(`  Commands: ${installedCommands.length} selected`);
-  import_devkit7.logger.info(`  Agents: ${installedAgents.length} selected`);
-  if (isDryRun) {
-    import_devkit7.logger.info("\n\u{1F4CB} Would install:");
-    installedFiles.forEach((file) => {
-      import_devkit7.logger.info(`  - ${file}`);
-    });
-    import_devkit7.logger.info("\n\u{1F504} Would also set up auto-update checker:");
-    import_devkit7.logger.info("  - Auto-detect your shell (bash, zsh, or fish)");
-    import_devkit7.logger.info("  - Add update check script to your shell configuration");
-    import_devkit7.logger.info("  - Checks once per week for new versions");
-    import_devkit7.logger.info("  - Runs in background (non-blocking)");
-    import_devkit7.logger.info("  - Can be disabled with: export AI_TOOLKIT_SKIP_UPDATE_CHECK=1");
-    return;
-  }
-  if (!isDryRun) {
-    const manifest = {
-      version: "1.0.0",
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      commands: installedCommands,
-      agents: installedAgents,
-      files: installedFiles
-    };
-    (0, import_devkit7.writeJson)(tree, relativeManifestPath, manifest);
-    await (0, import_devkit7.formatFiles)(tree);
-  }
-  if (!isDryRun) {
-    import_devkit7.logger.info("\u2705 Claude Code configuration installed successfully!");
-    import_devkit7.logger.info(`\u{1F4C1} Location: ${targetDir}`);
-    import_devkit7.logger.info(`\u{1F4DD} Use these in Claude Code immediately`);
-    try {
-      import_devkit7.logger.info("\n\u{1F504} Installing auto-update checker...");
-      const shell = detectShell();
-      const version = getCurrentToolkitVersion();
-      installUpdateChecker(shell, version);
-    } catch (error) {
-      import_devkit7.logger.warn(`\u26A0\uFE0F  Failed to install update checker: ${error}`);
-      import_devkit7.logger.info(
-        "This is a bug in ai-toolkit, please report it at https://github.com/Uniswap/ai-toolkit/issues"
-      );
-    }
-    if (normalizedOptions.installHooks) {
-      try {
-        import_devkit7.logger.info("\n\u{1F514} Installing notification hooks...");
-        if (!generator_default) {
-          throw new Error("hooksGenerator export not found");
-        }
-        await generator_default(tree, {
-          force: normalizedOptions.force || false,
-          dry: false,
-          backup: true,
-          verbose: false,
-          installMode: "default"
-          // Always use 'default' to prevent re-prompting
-        });
-        import_devkit7.logger.info("\u2705 Notification hooks installed successfully");
-      } catch (error) {
-        import_devkit7.logger.error("\u274C Failed to install notification hooks");
-        import_devkit7.logger.error(error.message);
-        import_devkit7.logger.info("   Continuing with installation...");
-      }
-    }
-    let addonsInstalled = false;
-    const shouldInstallAddons = normalizedOptions.installAddons === true;
-    if (shouldInstallAddons) {
-      try {
-        import_devkit7.logger.info("\n\u{1F50C} Installing addons...");
-        if (!generator) {
-          throw new Error("addonsGenerator export not found");
-        }
-        const addonInstallMode = normalizedOptions.installMode === "default" || normalizedOptions.addonSelectionMode === "all" ? "all" : "specific";
-        await generator(tree, {
-          dry: normalizedOptions.dry || false,
-          selectionMode: addonInstallMode,
-          force: normalizedOptions.force || false,
-          skipVerification: false,
-          dashboardMode: "always",
-          port: 0,
-          installMode: normalizedOptions.addonSelectionMode === "specific" ? "custom" : "default",
-          installationType: normalizedOptions.installationType || "global"
-        });
-        import_devkit7.logger.info("\u2705 Addons installed successfully");
-        addonsInstalled = true;
-      } catch (error) {
-        import_devkit7.logger.error("\u274C Failed to install addons");
-        import_devkit7.logger.error(error.message);
-        import_devkit7.logger.info("   Continuing with installation...");
-      }
-    }
-    import_devkit7.logger.info("\n\u2728 Installation complete!");
-    if (installedCommands.length > 0) {
-      import_devkit7.logger.info(`   Commands: ${installedCommands.join(", ")}`);
-    }
-    if (installedAgents.length > 0) {
-      import_devkit7.logger.info(`   Agents: ${installedAgents.join(", ")}`);
-    }
-    if (normalizedOptions.installHooks) {
-      import_devkit7.logger.info("   Hooks: \u2705 Installed");
-    }
-    if (addonsInstalled) {
-      import_devkit7.logger.info("   Addons: \u2705 Installed");
-    }
-  } else {
-    if (normalizedOptions.installHooks) {
-      import_devkit7.logger.info("\n\u{1F50D} DRY RUN: Would install notification hooks (sound mode)");
-    }
-    const installAddonsExplicit = explicitlyProvided.has("installAddons") || explicitlyProvided.has("install-addons");
-    if (normalizedOptions.installMode === "custom" && !installAddonsExplicit && !normalizedOptions.nonInteractive) {
-      import_devkit7.logger.info("\n\u{1F50D} DRY RUN: Would prompt to install spec-mcp-workflow addon after hooks");
-    } else if (normalizedOptions.installAddons) {
-      import_devkit7.logger.info("\n\u{1F50D} DRY RUN: Would install spec-mcp-workflow addon");
-    }
-  }
-}
-function checkClaudeInstalled() {
-  try {
-    (0, import_child_process7.execSync)("which claude", { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function promptInstallClaude() {
-  const { install } = await (0, import_enquirer2.prompt)({
-    type: "confirm",
-    name: "install",
-    message: "Would you like to install Claude CLI?",
-    initial: true
-  });
-  return install;
-}
-async function installClaude() {
-  const platform = process.platform;
-  if (platform !== "darwin") {
-    import_devkit7.logger.warn(
-      "\u26A0\uFE0F  Note: Claude CLI installation may require additional steps on non-macOS platforms"
-    );
-  }
-  import_devkit7.logger.info("\u{1F4E6} Installing Claude CLI...");
-  const curlSuccess = await installViaCurl();
-  if (curlSuccess) {
-    await verifyInstallation2("curl");
-    return;
-  }
-  import_devkit7.logger.info("Curl method failed, falling back to npm installation...");
-  const npmSuccess = await installViaNpm();
-  if (npmSuccess) {
-    await verifyInstallation2("npm");
-    return;
-  }
-  provideManualInstructions();
-}
-async function installViaCurl() {
-  import_devkit7.logger.info("Attempting installation via curl...");
-  try {
-    (0, import_child_process7.execSync)("which curl", { stdio: "ignore" });
-    (0, import_child_process7.execSync)("curl -fsSL https://claude.ai/install.sh | bash", {
-      stdio: "inherit",
-      shell: "/bin/bash",
-      timeout: 3e5
-      // 5 minute timeout
-    });
-    import_devkit7.logger.info("\u2705 Claude CLI installed successfully via curl!");
-    return true;
-  } catch (error) {
-    import_devkit7.logger.warn("Curl installation failed, attempting npm fallback...");
-    import_devkit7.logger.debug(`Curl error details: ${error.message}`);
-    return false;
-  }
-}
-async function installViaNpm() {
-  import_devkit7.logger.info("Installing via npm: npm install -g @anthropic-ai/claude-code");
-  try {
-    (0, import_child_process7.execSync)("which npm", { stdio: "ignore" });
-    (0, import_child_process7.execSync)("npm install -g @anthropic-ai/claude-code", {
-      stdio: "inherit",
-      timeout: 3e5
-      // 5 minute timeout
-    });
-    import_devkit7.logger.info("\u2705 Claude CLI installed successfully via npm!");
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      import_devkit7.logger.error("\u274C npm not found. Please install Node.js and npm first.");
-      import_devkit7.logger.info("Visit https://nodejs.org/ to install Node.js");
-    } else if (error.message?.includes("permission") || error.message?.includes("EACCES")) {
-      import_devkit7.logger.error("\u274C npm installation failed due to permissions.");
-      import_devkit7.logger.info("Try running: npm install -g @anthropic-ai/claude-code");
-      import_devkit7.logger.info("Then run: claude migrate-installer");
-    } else {
-      import_devkit7.logger.error(`\u274C npm installation failed: ${error.message}`);
-    }
-    return false;
-  }
-}
-async function verifyInstallation2(method) {
-  try {
-    (0, import_child_process7.execSync)("which claude", { stdio: "ignore" });
-    import_devkit7.logger.info(`\u2705 Claude CLI found (installed via ${method})`);
-    import_devkit7.logger.info('You can also run "claude --version" to verify');
-  } catch {
-    import_devkit7.logger.warn("\u26A0\uFE0F  Claude CLI not found in PATH");
-    import_devkit7.logger.info("You may need to restart your terminal or add Claude to your PATH");
-  }
-}
-function provideManualInstructions() {
-  import_devkit7.logger.error("\u274C Automatic installation failed");
-  import_devkit7.logger.info("\n\u{1F4DA} Manual Installation Instructions:");
-  import_devkit7.logger.info("1. Via curl: curl -fsSL https://claude.ai/install.sh | bash");
-  import_devkit7.logger.info("2. Via npm: npm install -g @anthropic-ai/claude-code");
-  import_devkit7.logger.info("3. Visit: https://claude.ai/download for platform-specific instructions");
-  import_devkit7.logger.info('\nFor troubleshooting, run "claude doctor" after manual installation');
-}
-var generator_default2 = initGenerator;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  initGenerator
-});