@uniswap/ai-toolkit-nx-claude 0.5.7-next.10

package/dist/generators/addons/generator.cjs

@@ -0,0 +1,1285 @@
+"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 __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/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: {
+        addon: {
+          type: "string",
+          description: "The addon to install",
+          enum: ["spec-workflow-mcp"],
+          default: "spec-workflow-mcp",
+          "x-prompt": "Select addon 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)"
+        },
+        githubToken: {
+          type: "string",
+          description: "GitHub personal access token for private packages",
+          "prompt-message": "\u{1F511} GitHub personal access token (for private @uniswap packages)"
+        },
+        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
+        }
+      },
+      required: []
+    };
+  }
+});
+
+// packages/ai-toolkit-nx-claude/src/generators/addons/generator.ts
+var generator_exports = {};
+__export(generator_exports, {
+  default: () => generator
+});
+module.exports = __toCommonJS(generator_exports);
+var import_devkit = require("@nx/devkit");
+
+// 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 [field, operator, value] = property["prompt-when"].split(" ");
+      if (operator === "===" && result[field] !== value.replace(/['"]/g, "")) {
+        continue;
+      }
+    }
+    const promptResult = await promptForProperty(
+      key,
+      property,
+      context,
+      result
+    );
+    if (promptResult !== void 0) {
+      result[key] = promptResult;
+      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
+      );
+    }
+    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}:`;
+  }
+}
+
+// packages/ai-toolkit-nx-claude/src/utils/cli-parser.ts
+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/generators/addons/addon-registry.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+var 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",
+    registry: "--@uniswap:registry=https://npm.pkg.github.com",
+    requiresAuth: true,
+    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",
+      requiresAuth: false
+    },
+    requirements: {
+      node: ">=22.0.0",
+      commands: ["git", "npm"]
+    }
+  }
+  // Future addons can be added here
+];
+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 (command === addon.mcp?.command && args.some((arg) => arg.includes(addon.packageName))) {
+                return true;
+              }
+            }
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return false;
+}
+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: execSync4 } = require("child_process");
+    for (const cmd of addon.requirements.commands) {
+      try {
+        execSync4(`which ${cmd}`, { stdio: "ignore" });
+      } catch {
+        errors.push(`Required command '${cmd}' not found`);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// packages/ai-toolkit-nx-claude/src/generators/addons/github-auth.ts
+var import_child_process = require("child_process");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_os2 = require("os");
+async function checkGitHubAuth() {
+  if (process.env.NPM_TOKEN || process.env.GITHUB_TOKEN) {
+    const token = process.env.NPM_TOKEN || process.env.GITHUB_TOKEN;
+    const valid = await validateToken(token);
+    return {
+      authenticated: true,
+      method: "env",
+      registry: "https://npm.pkg.github.com",
+      valid
+    };
+  }
+  const npmrcPaths = [(0, import_path2.join)((0, import_os2.homedir)(), ".npmrc"), (0, import_path2.join)(process.cwd(), ".npmrc")];
+  for (const npmrcPath of npmrcPaths) {
+    if ((0, import_fs2.existsSync)(npmrcPath)) {
+      const content = (0, import_fs2.readFileSync)(npmrcPath, "utf-8");
+      if (content.includes("//npm.pkg.github.com/:_authToken=")) {
+        const tokenMatch = content.match(
+          /\/\/npm\.pkg\.github\.com\/:_authToken=(.+)/
+        );
+        if (tokenMatch) {
+          const token = tokenMatch[1].trim();
+          const valid = await validateToken(token);
+          return {
+            authenticated: true,
+            method: "npmrc",
+            registry: "https://npm.pkg.github.com",
+            valid
+          };
+        }
+      }
+    }
+  }
+  return {
+    authenticated: false,
+    method: "none"
+  };
+}
+async function validateToken(token) {
+  try {
+    const result = (0, import_child_process.execSync)(
+      `npm view @uniswap/ai-toolkit-nx-claude --@uniswap:registry=https://npm.pkg.github.com --//npm.pkg.github.com/:_authToken=${token} --json`,
+      {
+        encoding: "utf-8",
+        stdio: "pipe"
+      }
+    );
+    return result.includes('"name"');
+  } catch {
+    return false;
+  }
+}
+async function setupGitHubAuth(token, location = "global") {
+  const valid = await validateToken(token);
+  if (!valid) {
+    return {
+      authenticated: false,
+      method: "none",
+      error: "Invalid GitHub token. Please ensure you have a valid personal access token with read:packages scope."
+    };
+  }
+  const npmrcPath = location === "global" ? (0, import_path2.join)((0, import_os2.homedir)(), ".npmrc") : (0, import_path2.join)(process.cwd(), ".npmrc");
+  const registryLines = [`//npm.pkg.github.com/:_authToken=${token}`];
+  let npmrcContent = "";
+  if ((0, import_fs2.existsSync)(npmrcPath)) {
+    npmrcContent = (0, import_fs2.readFileSync)(npmrcPath, "utf-8");
+    const hasToken = npmrcContent.includes("//npm.pkg.github.com/:_authToken=");
+    if (hasToken) {
+      npmrcContent = npmrcContent.replace(
+        /\/\/npm\.pkg\.github\.com\/:_authToken=.*/,
+        `//npm.pkg.github.com/:_authToken=${token}`
+      );
+    } else {
+      if (!hasToken) {
+        npmrcContent += "\n" + registryLines[1];
+      }
+    }
+  } else {
+    npmrcContent = registryLines.join("\n") + "\n";
+  }
+  (0, import_fs2.writeFileSync)(npmrcPath, npmrcContent);
+  return {
+    authenticated: true,
+    method: "npmrc",
+    registry: "https://npm.pkg.github.com",
+    valid: true
+  };
+}
+async function validatePackageAccess(packageName = "@uniswap/spec-workflow-mcp") {
+  try {
+    const authStatus = await checkGitHubAuth();
+    if (!authStatus.authenticated) {
+      return {
+        accessible: false,
+        error: "No GitHub authentication configured. Please provide a personal access token."
+      };
+    }
+    let command = `npm view ${packageName} version --@uniswap:registry=https://npm.pkg.github.com`;
+    if (authStatus.method === "env" && (process.env.NPM_TOKEN || process.env.GITHUB_TOKEN)) {
+      const token = process.env.NPM_TOKEN || process.env.GITHUB_TOKEN;
+      command += ` --//npm.pkg.github.com/:_authToken=${token}`;
+    }
+    const version = (0, import_child_process.execSync)(command, {
+      encoding: "utf-8",
+      stdio: "pipe"
+    }).trim();
+    return {
+      accessible: true,
+      version
+    };
+  } catch (error) {
+    let errorMessage = "Failed to access package";
+    if (error.message?.includes("404")) {
+      errorMessage = `Package ${packageName} not found. Ensure you have access to the Uniswap organization.`;
+    } else if (error.message?.includes("401") || error.message?.includes("403")) {
+      errorMessage = "Authentication failed. Please check your GitHub token has read:packages scope.";
+    } else if (error.message?.includes("ENOTFOUND")) {
+      errorMessage = "Network error. Please check your internet connection.";
+    }
+    return {
+      accessible: false,
+      error: errorMessage
+    };
+  }
+}
+function getAuthInstructions() {
+  return `
+To access @uniswap packages from GitHub Packages, you need a personal access token:
+
+1. Go to https://github.com/settings/tokens/new
+2. Create a token with 'read:packages' scope
+3. Copy the generated token
+
+The token will be saved to your ~/.npmrc file for future use.
+
+For more information, see: https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-npm-registry
+  `.trim();
+}
+
+// packages/ai-toolkit-nx-claude/src/generators/addons/claude-mcp-installer.ts
+var import_child_process2 = require("child_process");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_os3 = require("os");
+async function installMcpServer(options) {
+  const { addon, additionalArgs = [], dryRun = false } = options;
+  try {
+    (0, import_child_process2.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 || addon.id;
+  let command = `claude mcp add ${serverName} --scope user --`;
+  if (addon.mcp?.command) {
+    command += ` ${addon.mcp.command}`;
+    if (addon.mcp.command === "npx") {
+      command += " -y";
+    }
+    if (addon.registry) {
+      command += ` ${addon.registry}`;
+    }
+    const packageSpec = addon.mcp.args?.[0] || `${addon.packageName}@latest`;
+    command += ` ${packageSpec}`;
+  }
+  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_process2.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"
+  };
+}
+async function verifyMcpInstallation(serverName) {
+  const configPaths = [
+    (0, import_path3.join)((0, import_os3.homedir)(), ".claude", "config.json"),
+    (0, import_path3.join)(process.cwd(), ".claude", "config.json")
+  ];
+  for (const configPath of configPaths) {
+    if ((0, import_fs3.existsSync)(configPath)) {
+      try {
+        const config = JSON.parse((0, import_fs3.readFileSync)(configPath, "utf-8"));
+        if (config.mcpServers && config.mcpServers[serverName]) {
+          return {
+            installed: true,
+            configured: true,
+            configPath,
+            serverConfig: config.mcpServers[serverName]
+          };
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return {
+    installed: false,
+    configured: false
+  };
+}
+async function updateMcpServer(serverName, argUpdates) {
+  const verification = await verifyMcpInstallation(serverName);
+  if (!verification.installed || !verification.configPath) {
+    return {
+      success: false,
+      message: "MCP server not found. Please install it first."
+    };
+  }
+  try {
+    const config = JSON.parse((0, import_fs3.readFileSync)(verification.configPath, "utf-8"));
+    const serverConfig = config.mcpServers[serverName];
+    if (serverConfig.args && Array.isArray(serverConfig.args)) {
+      if (argUpdates.remove && argUpdates.remove.length > 0) {
+        serverConfig.args = serverConfig.args.filter((arg) => {
+          return !argUpdates.remove.some((pattern) => arg.startsWith(pattern));
+        });
+      }
+      if (argUpdates.add && argUpdates.add.length > 0) {
+        const lastArg = serverConfig.args[serverConfig.args.length - 1];
+        serverConfig.args = [
+          ...serverConfig.args.slice(0, -1),
+          ...argUpdates.add,
+          lastArg
+        ];
+      }
+    }
+    const fs2 = require("fs");
+    fs2.writeFileSync(verification.configPath, JSON.stringify(config, null, 2));
+    return {
+      success: true,
+      message: "MCP server configuration updated successfully"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to update configuration: ${error.message}`
+    };
+  }
+}
+
+// packages/ai-toolkit-nx-claude/src/generators/addons/spec-workflow-setup.ts
+var import_child_process3 = require("child_process");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var import_os4 = require("os");
+var import_fs5 = require("fs");
+async function setupSpecWorkflow(projectPath, options) {
+  const targetPath = projectPath || process.cwd();
+  const targetDir = (0, import_path4.join)(targetPath, ".spec-workflow");
+  console.log(`
+\u{1F4C1} Setting up spec-workflow in: ${targetPath}`);
+  const isUpdate = (0, import_fs4.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_fs4.mkdirSync)(targetDir, { recursive: true });
+  }
+  const tempDir = (0, import_path4.join)((0, import_os4.tmpdir)(), `spec-workflow-${Date.now()}`);
+  console.log("\u{1F504} Cloning spec-workflow repository...");
+  const cloneResult = await cloneRepository(
+    "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_path4.join)(tempDir, "configs");
+  const copyResult = await copyConfigFiles(configSourcePath, targetDir);
+  console.log("\u{1F9F9} Cleaning up temporary files...");
+  (0, import_fs4.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 cloneRepository(repositoryUrl, targetDir) {
+  try {
+    if (!(0, import_fs4.existsSync)(targetDir)) {
+      (0, import_fs4.mkdirSync)(targetDir, { recursive: true });
+    }
+    (0, import_child_process3.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_path4.join)(projectPath, ".gitignore");
+  try {
+    let gitignoreContent = "";
+    if ((0, import_fs4.existsSync)(gitignorePath)) {
+      gitignoreContent = (0, import_fs4.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_fs4.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 = fs2.readdirSync(dir);
+      for (const file of files) {
+        const filePath = (0, import_path4.join)(dir, file);
+        const stat = fs2.statSync(filePath);
+        if (stat.isDirectory()) {
+          listFiles2(filePath, baseDir, sourceBase);
+        } else {
+          const relativePath = filePath.replace(baseDir + "/", "");
+          const sourceFile = (0, import_path4.join)(sourceBase, relativePath);
+          if ((0, import_fs4.existsSync)(sourceFile)) {
+            copiedFiles.push(relativePath);
+          }
+        }
+      }
+    };
+    var listFiles = listFiles2;
+    if (!(0, import_fs4.existsSync)(sourceDir)) {
+      return {
+        success: false,
+        message: "Source directory not found",
+        error: `The configs directory was not found in the cloned repository`
+      };
+    }
+    (0, import_fs5.cpSync)(sourceDir, targetDir, { recursive: true });
+    const fs2 = 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/generator.ts
+async function generator(tree, schema) {
+  console.log("\n\u{1F3AF} Claude Code Addons Installer");
+  console.log("================================\n");
+  let projectSetupCompleted = false;
+  const dryRunFlagProvided = isNxDryRunProvided();
+  const noInteractive = isNxNoInteractiveProvided();
+  let isDryRun = dryRunFlagProvided;
+  if (!dryRunFlagProvided && !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");
+  }
+  const options = await promptForMissingOptions(
+    schema,
+    require_schema()
+  );
+  options.dryRun = isDryRun;
+  const addon = getAddonById(options.addon || "spec-workflow-mcp");
+  if (!addon) {
+    throw new Error(`Unknown addon: ${options.addon}`);
+  }
+  console.log(`
+\u{1F4E6} Installing: ${addon.name}`);
+  console.log(`   ${addon.description}
+`);
+  if (!options.force && !options.dryRun) {
+    const installed = await isAddonInstalled(addon.id);
+    if (installed) {
+      console.log("\u2705 Addon is already installed");
+      const { confirm } = await require("enquirer").prompt({
+        type: "confirm",
+        name: "confirm",
+        message: "Would you like to update the configuration?",
+        initial: false
+      });
+      if (confirm) {
+        await updateConfiguration(addon.id, options);
+      }
+      return;
+    }
+  } else if (options.dryRun) {
+    const installed = await isAddonInstalled(addon.id);
+    if (installed && !options.force) {
+      console.log(
+        "\u2139\uFE0F  [DRY-RUN] Addon is already installed, would prompt for update"
+      );
+    }
+  }
+  console.log("\n\u{1F50D} Checking requirements...");
+  const validation = await validateAddonRequirements(addon.id);
+  if (!validation.valid) {
+    console.error("\n\u274C Requirements not met:");
+    validation.errors.forEach((error) => console.error(`   \u2022 ${error}`));
+    if (!options.force) {
+      throw new Error(
+        "Installation requirements not met. Use --force to override."
+      );
+    }
+    console.log("\n\u26A0\uFE0F  Continuing with --force flag...");
+  }
+  if (addon.requiresAuth) {
+    if (options.dryRun) {
+      console.log("\n\u{1F510} [DRY-RUN] Skipping GitHub authentication check");
+    } else {
+      console.log("\n\u{1F510} Checking GitHub authentication...");
+      const authStatus = await checkGitHubAuth();
+      if (!authStatus.authenticated || !authStatus.valid) {
+        console.log(
+          "\n\u{1F4DD} GitHub authentication required for private @uniswap packages"
+        );
+        console.log(getAuthInstructions());
+        if (!process.env.CI && !options.githubToken) {
+          const { token } = await require("enquirer").prompt({
+            type: "password",
+            name: "token",
+            message: "GitHub Personal Access Token:",
+            validate: (value) => value.length > 0
+          });
+          options.githubToken = token;
+        }
+        if (options.githubToken) {
+          console.log("\n\u{1F527} Setting up GitHub authentication...");
+          const setupResult = await setupGitHubAuth(options.githubToken);
+          if (!setupResult.valid) {
+            throw new Error(
+              setupResult.error || "Failed to setup GitHub authentication"
+            );
+          }
+          console.log("\u2705 Authentication configured successfully");
+        } else {
+          throw new Error(
+            "GitHub authentication required. Please provide a token."
+          );
+        }
+      } else {
+        console.log("\u2705 GitHub authentication found");
+      }
+      console.log(`
+\u{1F50D} Validating access to ${addon.packageName}...`);
+      const accessResult = await validatePackageAccess(addon.packageName);
+      if (!accessResult.accessible) {
+        throw new Error(accessResult.error || "Cannot access package");
+      }
+      console.log(`\u2705 Package accessible (version: ${accessResult.version})`);
+    }
+  }
+  if (addon.type === "mcp-server") {
+    await installMcpAddon(addon, options);
+    if (addon.projectSetup) {
+      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);
+        projectSetupCompleted = true;
+      } else if (options.dryRun) {
+        console.log(
+          "\n\u{1F4C1} [DRY-RUN] Skipping project configuration (user chose not to set up)"
+        );
+      }
+    }
+  } else {
+    throw new Error(`Addon type '${addon.type}' is not yet supported`);
+  }
+  if (!options.skipVerification && !options.dryRun) {
+    console.log("\n\u{1F50D} Verifying installation...");
+    const serverName = addon.mcp?.serverName || addon.id;
+    const verification = await verifyMcpInstallation(serverName);
+    if (verification.installed) {
+      console.log("\u2705 Installation verified successfully");
+      showUsageInstructions(addon, options, projectSetupCompleted);
+    } else {
+      console.log("\u26A0\uFE0F  Could not verify installation");
+      console.log("   The addon may still work correctly.");
+      showUsageInstructions(addon, options, projectSetupCompleted);
+    }
+  } else if (options.dryRun) {
+    console.log("\n\u{1F50D} [DRY-RUN] Skipping installation verification");
+    showUsageInstructions(addon, options, projectSetupCompleted);
+  }
+  if (options.dryRun) {
+    console.log("\n\u2728 Dry-run complete! No changes were made.\n");
+  } else {
+    console.log("\n\u2728 Installation complete!\n");
+  }
+  await (0, import_devkit.formatFiles)(tree);
+}
+async function installMcpAddon(addon, options) {
+  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
+  });
+  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}`);
+}
+async function updateConfiguration(addonId, options) {
+  console.log("\n\u{1F527} Updating configuration...");
+  const addon = getAddonById(addonId);
+  if (!addon) {
+    console.error(`\u274C Unknown addon: ${addonId}`);
+    return;
+  }
+  const serverName = addon.mcp?.serverName || addon.id;
+  const argUpdates = {
+    remove: [],
+    add: []
+  };
+  if (addon.id === "spec-workflow-mcp") {
+    if (options.dashboardMode) {
+      argUpdates.remove.push("--AutoStartDashboard");
+      if (options.dashboardMode === "always") {
+        argUpdates.add.push("--AutoStartDashboard");
+      }
+    }
+    if (options.port !== void 0) {
+      argUpdates.remove.push("--Port=");
+      if (options.port > 0) {
+        argUpdates.add.push(`--Port=${options.port}`);
+      }
+    }
+  }
+  const result = await updateMcpServer(serverName, argUpdates);
+  if (result.success) {
+    console.log(`\u2705 ${result.message}`);
+  } else {
+    console.error(`\u274C ${result.message}`);
+  }
+}
+function showUsageInstructions(addon, options, projectSetupCompleted = false) {
+  console.log("\n\u{1F4DA} Usage Instructions:");
+  console.log("====================\n");
+  if (addon.id === "spec-workflow-mcp") {
+    console.log(
+      "1. Start a new instance of Claude Code to load the new MCP server"
+    );
+    console.log("2. Open your project in Claude Code");
+    if (options.dashboardMode === "always") {
+      console.log("3. The spec-workflow dashboard will start automatically");
+      console.log(
+        `   Dashboard URL: http://localhost:${options.port || 50014}`
+      );
+    } else {
+      console.log(
+        "3. Start the dashboard manually with: npx --@uniswap:registry=https://npm.pkg.github.com @uniswap/spec-workflow-mcp@latest --dashboard"
+      );
+    }
+    console.log("\n\u{1F4CB} Available MCP Tools:");
+    console.log("  \u2022 spec-workflow-guide - Get workflow documentation");
+    console.log("  \u2022 create-spec-doc - Create spec documents");
+    console.log("  \u2022 spec-status - Check specification status");
+    console.log("  \u2022 manage-tasks - Manage implementation tasks");
+    console.log("  \u2022 request-approval - Request human approval for documents");
+    console.log("  \u2022 orchestrate-with-agents - Use AI agent orchestration");
+    console.log("  \u2022 And more...");
+    if (addon.projectSetup && projectSetupCompleted) {
+      console.log("\n\u{1F4C1} Project Configuration:");
+      console.log(
+        "  \u2705 Spec-workflow configuration has been added to your project"
+      );
+      console.log("  \u2022 .spec-workflow/ - Configuration directory");
+      console.log(
+        "  \u2022 .spec-workflow/orchestration.yaml - Agent orchestration config"
+      );
+      console.log("\n\u{1F916} Agent Orchestration:");
+      console.log("  Automatic agent orchestration is ENABLED by default");
+      console.log("  Edit .spec-workflow/orchestration.yaml to customize");
+    }
+    console.log("\n\u{1F680} Quick Start - start a new instance of Claude Code and:");
+    console.log('  1. Ask Claude: "Show me the spec workflow guide"');
+    console.log('  2. Ask Claude: "Help me create a new spec for [feature]"');
+    console.log("  3. Visit the dashboard to monitor progress");
+    console.log("  4. Start creating specs for your features!");
+  }
+}