@botonic/nx-plugin 2.23.0

package/src/migrations/remove-codeartifact-registry/schema.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "type": "object",
+  "properties": {}
+}

package/src/migrations/sync-pending-bot-migrations/schema.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "type": "object",
+  "properties": {}
+}

package/src/migrations/sync-pending-bot-migrations/sync-pending-bot-migrations.migration.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export default function syncPendingBotMigrations(tree: Tree): Promise<void>;

package/src/migrations/sync-pending-bot-migrations/sync-pending-bot-migrations.migration.js

@@ -0,0 +1,137 @@
+"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);
+var sync_pending_bot_migrations_migration_exports = {};
+__export(sync_pending_bot_migrations_migration_exports, {
+  default: () => syncPendingBotMigrations
+});
+module.exports = __toCommonJS(sync_pending_bot_migrations_migration_exports);
+var import_devkit = require("@nx/devkit");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_migration_utils = require("../utils/migration-utils");
+const MODULE_DIR = __dirname;
+const PENDING_FILE = ".botonic/pending-bot-migrations.json";
+function resolveMigrationGuide(relPath) {
+  if (!relPath) return null;
+  return `node_modules/@botonic/nx-plugin/${relPath}`;
+}
+function semverLt(a, b) {
+  const parse = (v) => v.replace(/^[\^~]/, "").split(".").map(Number);
+  const [aMaj, aMin, aPatch] = parse(a);
+  const [bMaj, bMin, bPatch] = parse(b);
+  if (aMaj !== bMaj) return aMaj < bMaj;
+  if (aMin !== bMin) return aMin < bMin;
+  return aPatch < bPatch;
+}
+function readBotAppGenerators(moduleDir, pluginVersion) {
+  try {
+    const generatorsJsonPath = path.resolve(
+      moduleDir,
+      "..",
+      "..",
+      "..",
+      "generators.json"
+    );
+    const generatorsJson = JSON.parse(
+      fs.readFileSync(generatorsJsonPath, "utf-8")
+    );
+    return Object.entries(generatorsJson.generators).filter(([, entry]) => entry["x-bot-app-migration"] === true).map(([name, entry]) => {
+      const rawIntroducedIn = entry["x-introduced-in"];
+      const introducedIn = rawIntroducedIn && rawIntroducedIn !== "{{WORKSPACE_VERSION}}" ? rawIntroducedIn : pluginVersion;
+      return {
+        generator: `@botonic/nx-plugin:${name}`,
+        description: entry.description,
+        introducedIn,
+        migrationGuideRelPath: entry["x-migration-guide"] ?? null
+      };
+    });
+  } catch {
+    import_devkit.logger.warn(
+      "\u26A0\uFE0F  Could not read generators.json \u2013 no bot-app generators queued."
+    );
+    return [];
+  }
+}
+async function syncPendingBotMigrations(tree) {
+  const pluginVersion = (0, import_migration_utils.getPluginVersion)(MODULE_DIR);
+  const BOT_APP_GENERATORS = readBotAppGenerators(MODULE_DIR, pluginVersion);
+  const botProjects = (0, import_migration_utils.findBotApps)(tree);
+  if (botProjects.length === 0) {
+    import_devkit.logger.info(
+      "\u2139\uFE0F  No Botonic bot apps found. Skipping pending migrations setup."
+    );
+    return;
+  }
+  let pendingMigrations = { pending: [] };
+  if (tree.exists(PENDING_FILE)) {
+    try {
+      pendingMigrations = (0, import_devkit.readJson)(tree, PENDING_FILE);
+    } catch {
+      import_devkit.logger.warn(`\u26A0\uFE0F  Could not parse ${PENDING_FILE}, creating fresh.`);
+    }
+  }
+  for (const generatorDef of BOT_APP_GENERATORS) {
+    const botsNeedingGenerator = botProjects.filter((projectPath) => {
+      const botVersion = (0, import_migration_utils.getCurrentBotonicCoreVersion)(tree, projectPath);
+      if (!botVersion) return true;
+      return semverLt(botVersion, generatorDef.introducedIn);
+    });
+    if (botsNeedingGenerator.length === 0) continue;
+    const existing = pendingMigrations.pending.find(
+      (e) => e.generator === generatorDef.generator
+    );
+    if (existing) {
+      import_devkit.logger.info(
+        `\u2139\uFE0F  ${generatorDef.generator} already in pending list \u2013 skipping.`
+      );
+    } else {
+      pendingMigrations.pending.push({
+        version: generatorDef.introducedIn,
+        generator: generatorDef.generator,
+        description: generatorDef.description,
+        migrationGuide: resolveMigrationGuide(
+          generatorDef.migrationGuideRelPath
+        ),
+        appliedTo: []
+      });
+      import_devkit.logger.info(
+        `\u2705 Queued ${generatorDef.generator} for ${botsNeedingGenerator.length} bot(s)`
+      );
+    }
+  }
+  if (!tree.exists(".botonic/.gitkeep")) {
+    tree.write(".botonic/.gitkeep", "");
+  }
+  tree.write(PENDING_FILE, JSON.stringify(pendingMigrations, null, 2));
+  import_devkit.logger.info("");
+  import_devkit.logger.info(
+    `\u{1F4CB} ${PENDING_FILE} updated with ${pendingMigrations.pending.length} pending generator(s).`
+  );
+  import_devkit.logger.info("   Run /update-bot in Cursor to apply them per bot.");
+}

package/src/migrations/sync-pending-bot-migrations/sync-pending-bot-migrations.migration.md

@@ -0,0 +1,19 @@
+# Sync Pending Bot Migrations
+
+## Summary
+
+This migration sets up the per-bot migration tracking system. It writes `.botonic/pending-bot-migrations.json` listing all bot-app code generators that need to be applied to each bot in the workspace.
+
+After this migration runs, use the `/update-bot` Cursor command to apply pending generators to individual bots one at a time.
+
+## What the automated migration does
+
+- Finds all Botonic bot apps in the workspace (projects tagged `botonic:bot-app`)
+- Determines which bots are behind the current plugin version
+- Writes `.botonic/pending-bot-migrations.json` with the list of generators to apply
+- Does not modify any bot code — code transforms happen when you run `/update-bot`
+
+## Verification checklist
+
+- [ ] `.botonic/pending-bot-migrations.json` exists in the workspace root
+- [ ] Run `/update-bot` in Cursor and follow the prompts to update each bot

package/src/migrations/update-cursor-commands-to-stubs/schema.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "properties": {},
+  "required": []
+}

package/src/migrations/update-cursor-commands-to-stubs/update-cursor-commands-to-stubs.migration.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export default function updateCursorCommandsToStubs(tree: Tree): Promise<void>;

package/src/migrations/update-cursor-commands-to-stubs/update-cursor-commands-to-stubs.migration.js

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_cursor_commands_to_stubs_migration_exports = {};
+__export(update_cursor_commands_to_stubs_migration_exports, {
+  default: () => updateCursorCommandsToStubs
+});
+module.exports = __toCommonJS(update_cursor_commands_to_stubs_migration_exports);
+var import_devkit = require("@nx/devkit");
+const STUB_UPDATE_BOT = `# Update Botonic Bot
+
+Applies pending bot-app migrations from \`.botonic/pending-bot-migrations.json\` to a single bot.
+
+Follow the full workflow in: \`node_modules/@botonic/nx-plugin/src/cursor-commands/update-bot.md\`
+`;
+const STUB_UPDATE_BOTONIC = `# Update Botonic Workspace
+
+Updates the Botonic plugin to the latest version and queues pending bot-app migrations.
+
+Follow the full workflow in: \`node_modules/@botonic/nx-plugin/src/cursor-commands/update-botonic.md\`
+`;
+const UPDATE_BOT_MD = ".cursor/commands/update-bot.md";
+const UPDATE_BOTONIC_MD = ".cursor/commands/update-botonic.md";
+function isAlreadyStub(content, canonicalRef) {
+  return content.includes(canonicalRef);
+}
+async function updateCursorCommandsToStubs(tree) {
+  if (tree.exists(UPDATE_BOT_MD)) {
+    const content = tree.read(UPDATE_BOT_MD, "utf-8") ?? "";
+    if (isAlreadyStub(content, "cursor-commands/update-bot.md")) {
+      import_devkit.logger.info("\u2139\uFE0F  update-bot.md is already a stub \u2013 skipping");
+    } else {
+      tree.write(UPDATE_BOT_MD, STUB_UPDATE_BOT);
+      import_devkit.logger.info("\u2705 Replaced update-bot.md with stable stub");
+    }
+  }
+  if (tree.exists(UPDATE_BOTONIC_MD)) {
+    const content = tree.read(UPDATE_BOTONIC_MD, "utf-8") ?? "";
+    if (isAlreadyStub(content, "cursor-commands/update-botonic.md")) {
+      import_devkit.logger.info("\u2139\uFE0F  update-botonic.md is already a stub \u2013 skipping");
+    } else {
+      tree.write(UPDATE_BOTONIC_MD, STUB_UPDATE_BOTONIC);
+      import_devkit.logger.info("\u2705 Replaced update-botonic.md with stable stub");
+    }
+  }
+}

package/src/migrations/update-pnpm-workspace-scripts/schema.json

@@ -0,0 +1,4 @@
+{
+  "type": "object",
+  "properties": {}
+}

package/src/migrations/update-pnpm-workspace-scripts/update-pnpm-workspace-scripts.migration.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export default function updatePnpmWorkspaceScripts(tree: Tree): Promise<void>;

package/src/migrations/update-pnpm-workspace-scripts/update-pnpm-workspace-scripts.migration.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_pnpm_workspace_scripts_migration_exports = {};
+__export(update_pnpm_workspace_scripts_migration_exports, {
+  default: () => updatePnpmWorkspaceScripts
+});
+module.exports = __toCommonJS(update_pnpm_workspace_scripts_migration_exports);
+var import_devkit = require("@nx/devkit");
+const FIND_MIGRATION_GUIDES = ".cursor/scripts/update-bot/find-migration-guides.sh";
+async function updatePnpmWorkspaceScripts(tree) {
+  if (!tree.exists(FIND_MIGRATION_GUIDES)) {
+    import_devkit.logger.info(
+      `\u2139\uFE0F  ${FIND_MIGRATION_GUIDES} not found \u2013 skipping pnpm script update`
+    );
+    return;
+  }
+  const content = tree.read(FIND_MIGRATION_GUIDES, "utf-8");
+  if (!content || !content.includes("npm install")) {
+    import_devkit.logger.info(
+      `\u2139\uFE0F  ${FIND_MIGRATION_GUIDES} already references pnpm \u2013 skipping`
+    );
+    return;
+  }
+  tree.write(
+    FIND_MIGRATION_GUIDES,
+    content.replace(/npm install/g, "pnpm install")
+  );
+  import_devkit.logger.info(
+    `\u2705 Updated ${FIND_MIGRATION_GUIDES} to reference pnpm instead of npm`
+  );
+}

package/src/migrations/utils/migration-utils.d.ts

@@ -0,0 +1,109 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+/**
+ * Interface for file transformation results with renaming support
+ * This is a common pattern for migrations that transform files and potentially rename them
+ * Nx doesn't provide this pattern, so we create our own reusable interface
+ */
+export interface ActionTransformResult {
+    transformed: boolean;
+    newContent: string;
+    shouldRename?: boolean;
+    newFileName?: string;
+}
+/**
+ * Update Botonic dependencies to a specific version across the workspace or specific project
+ * @param tree - The file system tree
+ * @param targetVersion - The target version for Botonic dependencies
+ * @param projectPath - Optional project path, if not provided updates workspace root
+ * @returns GeneratorCallback for the dependency update task
+ */
+export declare function updateBotonicDependencies(tree: Tree, targetVersion: string, projectPath: string): void;
+/**
+ * Get the current @botonic/core version from a project's package.json
+ */
+export declare function getCurrentBotonicCoreVersion(tree: Tree, projectPath: string): string | null;
+/**
+ * Get the target migration version from migrations.json
+ */
+export declare function getMigrationTargetVersion(tree: Tree, migrationName: string): string | null;
+export declare function findBotApps(tree: Tree): string[];
+export interface ProjectSelectionOptions {
+    projects?: string[];
+    skipPrompt?: boolean;
+}
+export interface ProjectChoice {
+    name: string;
+    message: string;
+    hint?: string;
+}
+/**
+ * Interface for migration-specific project processing functions
+ */
+export interface ProjectProcessor {
+    (tree: Tree, projectPath: string, targetBotonicVersion: string): Promise<{
+        transformed: boolean;
+        filesChanged: number;
+    }>;
+}
+/**
+ * Configuration object for runBotonicMigration function
+ */
+export interface BotonicMigrationConfig {
+    /** The file system tree */
+    tree: Tree;
+    /** Project selection options (projects array, skipPrompt flag) */
+    options: ProjectSelectionOptions;
+    /** Migration key used in migrations.json (e.g., 'modernize-bot-actions') */
+    migrationKey: string;
+    /** Human-readable migration name for logging */
+    migrationName: string;
+    /** Function to process each project */
+    processProject: ProjectProcessor;
+    /** Function to generate success messages */
+    getSuccessMessage: (targetVersion: string) => string[];
+    /** Optional: Skip dependency updates (defaults to false) */
+    skipDependencyUpdates?: boolean;
+    /** Optional: Custom success message title (defaults to "Migration completed!") */
+    successTitle?: string;
+    /** Optional: Additional steps to show in the summary */
+    additionalSteps?: string[];
+}
+/**
+ * Helper function to create a BotonicMigrationConfig object with type safety
+ */
+export declare function createBotonicMigrationConfig(config: BotonicMigrationConfig): BotonicMigrationConfig;
+/**
+ * Helper function to create a simple project processor for file-based migrations
+ */
+export declare function createFileProcessor(fileProcessors: Array<{
+    filePath: (projectPath: string) => string;
+    shouldProcess: (tree: Tree, filePath: string) => boolean;
+    processFile: (tree: Tree, filePath: string, content: string, targetVersion: string) => {
+        transformed: boolean;
+        newContent?: string;
+        logMessage?: string;
+    };
+}>): ProjectProcessor;
+/**
+ * Common migration wrapper that handles the standard migration pattern:
+ * 1. Project selection
+ * 2. Version resolution
+ * 3. Project processing with dependency updates
+ * 4. Summary and task execution
+ */
+export declare function runBotonicMigration(config: BotonicMigrationConfig): Promise<GeneratorCallback | void>;
+/**
+ * Reusable function to select bot projects for migration with interactive prompts
+ * @param tree - The file system tree
+ * @param options - Project selection options (projects array, skipPrompt flag)
+ * @param migrationName - Name of the migration (for logging)
+ * @param migrationKey - Key used in migrations.json (e.g., 'modernize-bot-actions')
+ * @returns Array of selected project paths
+ */
+export declare function selectBotProjectsForMigration(tree: Tree, options: ProjectSelectionOptions, migrationName: string, migrationKey?: string): Promise<string[]>;
+/**
+ * Reads the nx-plugin's own version from its package.json.
+ * Pass __dirname (or MODULE_DIR) from the calling file so the path resolves
+ * correctly regardless of where in the source tree the caller lives.
+ */
+export declare function getPluginVersion(moduleDir: string): string;