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

package/dist/generators/add-agent/generator.cjs

@@ -1,640 +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 __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/add-agent/generator.ts
-var generator_exports = {};
-__export(generator_exports, {
-  addAgentGenerator: () => addAgentGenerator,
-  default: () => generator_default
-});
-module.exports = __toCommonJS(generator_exports);
-var import_devkit = require("@nx/devkit");
-var path = __toESM(require("path"));
-
-// 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/generators/add-agent/generator.ts
-var import_js = require("@nx/js");
-async function addAgentGenerator(tree, options) {
-  console.log("\u{1F916} Add Agent Generator");
-  const agentPackages = discoverAgentPackages(tree);
-  const packageChoices = [...agentPackages, "__create_new__"];
-  const schemaPath = path.join(__dirname, "schema.json");
-  const context = {
-    availablePackages: packageChoices
-  };
-  if (options["no-interactive"] || options.noInteractive) {
-    if (!options.package && agentPackages.length > 0) {
-      options.package = agentPackages[0];
-    }
-  }
-  const normalizedOptions = await promptForMissingOptions(
-    options,
-    schemaPath,
-    context
-  );
-  let targetPackage;
-  if (normalizedOptions.package === "__create_new__" || normalizedOptions.createNewPackage) {
-    if (!normalizedOptions.newPackageName) {
-      throw new Error("New package name is required");
-    }
-    targetPackage = normalizedOptions.newPackageName;
-    console.log(`
-\u{1F4E6} Creating new agents package: agents-${targetPackage}`);
-    await (0, import_js.libraryGenerator)(tree, {
-      name: `agents-${targetPackage}`,
-      directory: `packages/agents/${targetPackage}`,
-      bundler: "tsc",
-      linter: "eslint",
-      unitTestRunner: "jest",
-      testEnvironment: "node",
-      skipFormat: true,
-      skipTsConfig: false,
-      strict: true,
-      publishable: true,
-      importPath: `@ai-toolkit/agents-${targetPackage}`
-    });
-    const packageJson = {
-      name: `@ai-toolkit/agents-${targetPackage}`,
-      version: "0.0.1",
-      description: normalizedOptions.newPackageDescription || `Agent configurations for ${targetPackage}`,
-      main: "dist/index.js",
-      types: "dist/index.d.ts",
-      scripts: {
-        build: "tsc",
-        "generate-index": "tsx scripts/generate.ts"
-      },
-      dependencies: {
-        "@ai-toolkit/utils": "*"
-      },
-      devDependencies: {
-        tsx: "^4.7.0",
-        typescript: "^5.3.3"
-      }
-    };
-    tree.write(
-      (0, import_devkit.joinPathFragments)("packages", "agents", targetPackage, "package.json"),
-      JSON.stringify(packageJson, null, 2)
-    );
-    const generateScript = `import { generateIndex } from '@ai-toolkit/utils';
-import * as path from 'path';
-
-generateIndex({
-  sourceDir: path.join(__dirname, '../src'),
-  outputFile: path.join(__dirname, '../src/index.ts'),
-  type: 'agents',
-});`;
-    tree.write(
-      (0, import_devkit.joinPathFragments)(
-        "packages",
-        "agents",
-        targetPackage,
-        "scripts",
-        "generate.ts"
-      ),
-      generateScript
-    );
-    const readme = `# @ai-toolkit/agents-${targetPackage}
-
-${normalizedOptions.newPackageDescription || `Agent configurations for ${targetPackage}`}
-
-## Overview
-
-This package contains agent configurations specific to ${targetPackage}.
-
-## Usage
-
-Install this package to access ${targetPackage}-specific agents in Claude Code:
-
-\`\`\`bash
-npx nx generate @uniswap/ai-toolkit-nx-claude:init
-\`\`\`
-
-Then select the agents from this package during the installation process.
-
-## Available Agents
-
-- \`${normalizedOptions.name}\`: ${normalizedOptions.description || "Description pending"}
-
-## Development
-
-To add new agents to this package:
-
-\`\`\`bash
-npx nx generate @uniswap/ai-toolkit-nx-claude:add-agent
-\`\`\`
-
-After adding or modifying agents, regenerate the index:
-
-\`\`\`bash
-npx nx run @ai-toolkit/agents-${targetPackage}:generate-index
-\`\`\``;
-    tree.write(
-      (0, import_devkit.joinPathFragments)("packages", "agents", targetPackage, "README.md"),
-      readme
-    );
-  } else {
-    targetPackage = normalizedOptions.package.replace("agents-", "");
-  }
-  const agentFileName = `${normalizedOptions.name}.md`;
-  const agentPath = (0, import_devkit.joinPathFragments)(
-    "packages",
-    "agents",
-    targetPackage,
-    "src"
-  );
-  if (tree.exists((0, import_devkit.joinPathFragments)(agentPath, agentFileName))) {
-    const overwrite = await promptForOverwrite(normalizedOptions.name);
-    if (!overwrite) {
-      console.log("\u274C Agent creation cancelled");
-      return;
-    }
-  }
-  (0, import_devkit.generateFiles)(tree, path.join(__dirname, "files"), agentPath, {
-    ...normalizedOptions,
-    name: normalizedOptions.name,
-    description: normalizedOptions.description || `${normalizedOptions.name} agent`,
-    model: normalizedOptions.model,
-    template: ""
-  });
-  await (0, import_devkit.formatFiles)(tree);
-  console.log(`
-\u2705 Agent file created at: ${agentPath}/${agentFileName}`);
-  console.log("\n\u{1F4DD} Next steps:");
-  console.log(
-    `1. Edit ${agentPath}/${agentFileName} and add your agent instructions`
-  );
-  console.log(
-    "\n\u{1F4A1} The agent file has TODO markers for you to fill in with your specific instructions."
-  );
-  const { spawn } = await import("child_process");
-  const runGenerateIndexTask = (tree2) => {
-    return () => {
-      console.log(`
-\u{1F504} Updating package index...`);
-      return new Promise((resolve) => {
-        const child = spawn(
-          "npx",
-          ["nx", "run", `@ai-toolkit/agents-${targetPackage}:generate-index`],
-          {
-            stdio: "inherit",
-            shell: true,
-            cwd: tree2.root
-          }
-        );
-        child.on("close", (code) => {
-          if (code === 0) {
-            console.log(`\u2705 Package index updated successfully`);
-            resolve();
-          } else {
-            console.warn(
-              `\u26A0\uFE0F  Failed to update package index. You may need to run manually:`
-            );
-            console.warn(
-              `   npx nx run @ai-toolkit/agents-${targetPackage}:generate-index`
-            );
-            resolve();
-          }
-        });
-        child.on("error", (error) => {
-          console.warn(`\u26A0\uFE0F  Failed to update package index: ${error.message}`);
-          console.warn(
-            `   Run manually: npx nx run @ai-toolkit/agents-${targetPackage}:generate-index`
-          );
-          resolve();
-        });
-      });
-    };
-  };
-  return runGenerateIndexTask(tree);
-}
-function discoverAgentPackages(tree) {
-  const packages = [];
-  const agentsDir = (0, import_devkit.joinPathFragments)("packages", "agents");
-  if (!tree.exists(agentsDir)) {
-    return packages;
-  }
-  const children = tree.children(agentsDir);
-  for (const child of children) {
-    const packagePath = (0, import_devkit.joinPathFragments)(agentsDir, child);
-    if (tree.exists((0, import_devkit.joinPathFragments)(packagePath, "package.json"))) {
-      packages.push(`agents-${child}`);
-    }
-  }
-  return packages;
-}
-async function promptForOverwrite(name) {
-  const { prompt: prompt2 } = await import("enquirer");
-  const response = await prompt2({
-    type: "confirm",
-    name: "overwrite",
-    message: `\u26A0\uFE0F  Agent "${name}" already exists. Overwrite?`,
-    initial: false
-  });
-  return response.overwrite;
-}
-var generator_default = addAgentGenerator;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  addAgentGenerator
-});

package/dist/generators/add-agent/schema.json

@@ -1,59 +0,0 @@
-{
-  "$schema": "https://json-schema.org/schema",
-  "$id": "AddAgent",
-  "title": "Add Agent Generator",
-  "type": "object",
-  "properties": {
-    "package": {
-      "type": "string",
-      "description": "Target package for the agent",
-      "prompt-message": "📦 Which package should this agent be added to?"
-    },
-    "createNewPackage": {
-      "type": "boolean",
-      "description": "Create a new package for this agent",
-      "default": false,
-      "prompt-message": "➕ Would you like to create a new package instead?",
-      "prompt-type": "confirm",
-      "prompt-when": "package === '__create_new__'"
-    },
-    "newPackageName": {
-      "type": "string",
-      "description": "Name of the new package (e.g., backend, frontend, typescript)",
-      "prompt-message": "📝 Enter the name for the new package (e.g., backend, frontend, typescript):",
-      "prompt-when": "createNewPackage === true",
-      "pattern": "^[a-z][a-z0-9-]*$"
-    },
-    "newPackageDescription": {
-      "type": "string",
-      "description": "Description of the new package",
-      "prompt-message": "📄 Enter a description for the new package:",
-      "prompt-when": "createNewPackage === true"
-    },
-    "name": {
-      "type": "string",
-      "description": "Name of the agent file (without extension)",
-      "$default": {
-        "$source": "argv",
-        "index": 0
-      },
-      "prompt-message": "🤖 What should the agent be called? (kebab-case, e.g., code-reviewer):",
-      "pattern": "^[a-z][a-z0-9-]*$"
-    },
-    "description": {
-      "type": "string",
-      "description": "Brief description of what the agent does",
-      "prompt-message": "💬 Brief description of what this agent does:"
-    },
-    "model": {
-      "type": "string",
-      "description": "The AI model to use for this agent",
-      "enum": ["sonnet-4.5", "opus-4.1", "haiku-4.5"],
-      "x-prompt": {
-        "message": "🧠 Which AI model should this agent use?",
-        "type": "list"
-      }
-    }
-  },
-  "required": []
-}