@botonic/nx-plugin 2.31.0 → 2.32.0-alpha.0

package/src/generators/action/generator.js

@@ -21,92 +21,7 @@ __export(generator_exports, {
   default: () => generator_default
 });
 module.exports = __toCommonJS(generator_exports);
-var import_devkit = require("@nx/devkit");
-var import_bot_app_utils = require("../shared/bot-app-utils");
-const MODULE_DIR = __dirname;
-function normalizeOptions(tree, options) {
-  const { projectRoot, sourceRoot } = (0, import_bot_app_utils.validateBotAppProject)(
-    tree,
-    options.project
-  );
-  const paths = (0, import_bot_app_utils.resolveStandardPaths)(sourceRoot);
-  const name = (0, import_devkit.names)(options.name);
-  const fileName = name.fileName;
-  const className = name.className;
-  return {
-    ...options,
-    projectName: options.project,
-    projectRoot,
-    fileName,
-    className,
-    actionsPath: paths.actionsPath,
-    routesPath: paths.routesPath,
-    resolvedRouteMatcher: options.routeMatcher ?? fileName
-  };
-}
-function addFilesToProject(tree, options) {
-  const name = (0, import_devkit.names)(options.name);
-  const templateOptions = {
-    ...options,
-    ...name,
-    name: name.fileName
-    // __name__ in filenames must be kebab-case
-  };
-  (0, import_devkit.generateFiles)(
-    tree,
-    (0, import_devkit.joinPathFragments)(MODULE_DIR, "files"),
-    options.actionsPath,
-    templateOptions
-  );
-  if (options.skipTests) {
-    const testFilePath = `${options.actionsPath}/${options.fileName}.spec.ts`;
-    if (tree.exists(testFilePath)) {
-      tree.delete(testFilePath);
-    }
-  }
-}
-function updateActionsIndex(tree, options) {
-  (0, import_bot_app_utils.addExportToIndex)(
-    tree,
-    `${options.actionsPath}/index.ts`,
-    `export * from './${options.fileName}'`
-  );
-}
-function updateRoutes(tree, options) {
-  if (options.skipRoute) {
-    return;
-  }
-  (0, import_bot_app_utils.addActionImportToRoutes)(tree, options.routesPath, options.className);
-  (0, import_bot_app_utils.insertRouteBeforeFlowBuilder)(tree, options.routesPath, [
-    `    {`,
-    `      text: '${options.resolvedRouteMatcher}',`,
-    `      action: async () => await ${options.className}(botonicContext),`,
-    `    },`
-  ]);
-}
+var import_delegate_generator = require("../../lib/delegate/delegate-generator");
 async function generator_default(tree, options) {
-  console.log(`Creating action: ${options.name}`);
-  const normalizedOptions = normalizeOptions(tree, options);
-  console.log(`Project: ${normalizedOptions.projectName}`);
-  console.log(`Location: ${normalizedOptions.actionsPath}`);
-  addFilesToProject(tree, normalizedOptions);
-  updateActionsIndex(tree, normalizedOptions);
-  updateRoutes(tree, normalizedOptions);
-  await (0, import_devkit.formatFiles)(tree);
-  console.log(`
-Successfully created action: ${normalizedOptions.className}`);
-  console.log(`Next steps:`);
-  console.log(
-    `  1. Implement the logic in: ${normalizedOptions.actionsPath}/${normalizedOptions.fileName}.ts`
-  );
-  if (!options.skipRoute) {
-    console.log(
-      `  2. Test by sending '${normalizedOptions.resolvedRouteMatcher}' in the webchat`
-    );
-  }
-  if (!options.skipTests) {
-    console.log(
-      `  3. Update the tests in: ${normalizedOptions.actionsPath}/${normalizedOptions.fileName}.spec.ts`
-    );
-  }
+  return (0, import_delegate_generator.runLocalGenerator)(__filename, "action", tree, options);
 }

package/src/generators/bot-app/files/vite/webchat.config.ts.template

@@ -1,8 +1,12 @@
 import { resolve } from 'path'
 import type { UserConfig } from 'vite'
+import {
+  createLogViewerPlugin,
+  createWebchatPanelPlugin,
+  createWhatsappPanelPlugin,
+} from '@botonic/nx-plugin'
 
 import { BUILD_CONFIG } from './build.config'
-import { devLogViewerIndexHtmlPlugin } from './plugins/dev-log-viewer-html.plugin'
 import { moveHtmlToRootPlugin } from './plugins/move-html.plugin'
 
 const projectRoot = resolve(__dirname, '..')
@@ -83,7 +87,11 @@ export function getWebchatConfig(command: 'serve' | 'build'): UserConfig {
     },
 
     plugins: [
-      devLogViewerIndexHtmlPlugin(),
+      createLogViewerPlugin(),
+      createWhatsappPanelPlugin({
+        registeredPhone: process.env.WHATSAPP_PANEL_PHONE,
+      }),
+      createWebchatPanelPlugin(),
       moveHtmlToRootPlugin(projectRoot, BUILD_CONFIG.TARGET_APPS.WEBCHAT),
     ],
   }

package/src/generators/bot-app/generator-impl.d.ts

@@ -0,0 +1,4 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import type { BotAppGeneratorSchema } from './schema';
+export default function (tree: Tree, options: BotAppGeneratorSchema): Promise<GeneratorCallback>;
+export { BotAppGeneratorSchema };

package/src/generators/bot-app/generator-impl.js

@@ -0,0 +1,328 @@
+"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 generator_impl_exports = {};
+__export(generator_impl_exports, {
+  default: () => generator_impl_default
+});
+module.exports = __toCommonJS(generator_impl_exports);
+var import_devkit = require("@nx/devkit");
+var import_child_process = require("child_process");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+const MODULE_DIR = __dirname;
+function getLilaraVersion(options) {
+  const version = options.lilaraVersion;
+  if (version && version !== "latest") {
+    return version.replace(/^[\^~]/, "");
+  }
+  const jsonPath = path.join(MODULE_DIR, "lilara-version.json");
+  try {
+    if (fs.existsSync(jsonPath)) {
+      const data = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+      if (data.version && typeof data.version === "string") {
+        return data.version.replace(/^[\^~]/, "");
+      }
+    }
+  } catch {
+  }
+  try {
+    const tag = (0, import_child_process.execSync)('git describe --tags --match "lilara-v*" --abbrev=0', {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const v = tag.replace(/^lilara-v/, "");
+    if (v) return v;
+  } catch {
+  }
+  return "latest";
+}
+function getBotonicVersion(options) {
+  const version = options.botonicVersion;
+  if (version && version !== "{{WORKSPACE_VERSION}}" && version !== "latest") {
+    return version.replace(/^[\^~]/, "");
+  }
+  try {
+    const packageJsonPath = path.resolve(
+      MODULE_DIR,
+      "..",
+      "..",
+      "..",
+      "package.json"
+    );
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version || "latest";
+  } catch (error) {
+    console.warn("Could not read plugin version, using latest:", error);
+    return "latest";
+  }
+}
+function normalizeOptions(tree, options) {
+  let appName = options.name;
+  let directory = options.directory;
+  if (options.name.includes("/")) {
+    const parts = options.name.split("/");
+    appName = parts.pop();
+    if (!directory) {
+      directory = parts.join("/");
+    }
+  }
+  const name = (0, import_devkit.names)(appName).fileName;
+  if (!name) {
+    throw new Error(`Failed to normalize app name: ${appName}`);
+  }
+  let projectDirectory;
+  if (directory) {
+    const directoryName = (0, import_devkit.names)(directory).fileName;
+    if (!directoryName) {
+      throw new Error(`Failed to normalize directory name: ${directory}`);
+    }
+    projectDirectory = `${directoryName}/${name}`;
+  } else {
+    projectDirectory = name;
+  }
+  if (!projectDirectory) {
+    throw new Error(
+      `Failed to determine project directory for app name: ${appName}`
+    );
+  }
+  const projectName = projectDirectory.replace(new RegExp("/", "g"), "-");
+  const projectRoot = `${(0, import_devkit.getWorkspaceLayout)(tree).appsDir}/${projectDirectory}`;
+  return {
+    ...options,
+    name: appName,
+    // Use the parsed app name
+    directory,
+    // Use the parsed directory
+    projectName,
+    projectRoot,
+    projectDirectory
+  };
+}
+function createProjectConfiguration(tree, options) {
+  const projectConfig = {
+    name: options.projectName,
+    root: options.projectRoot,
+    sourceRoot: `${options.projectRoot}/src`,
+    projectType: "application",
+    tags: ["type:app", "botonic:bot-app"]
+    // Note: targets are now inferred by the @botonic/nx-plugin based on the 'botonic:bot-app' tag
+    // and the presence of configuration files (vite.config.ts, bot-config.ts, etc.)
+  };
+  (0, import_devkit.addProjectConfiguration)(tree, options.projectName, projectConfig);
+}
+function createPackageJson(tree, options, botonicVersion, lilaraVersion) {
+  const packageJson = {
+    name: options.projectName,
+    version: "1.0.0",
+    type: "module",
+    private: true,
+    description: `Botonic bot application: ${options.projectName}`,
+    main: "dist/src/index.js",
+    scripts: {},
+    dependencies: {
+      "@botonic/core": botonicVersion,
+      "@botonic/plugin-ai-agents": botonicVersion,
+      "@botonic/plugin-flow-builder": botonicVersion,
+      "@botonic/plugin-hubtype-analytics": botonicVersion,
+      "@botonic/shared": botonicVersion,
+      "@botonic/webchat-core": botonicVersion,
+      "@botonic/webchat-react": botonicVersion,
+      "@botonic/webviews": botonicVersion,
+      "@lilara/foundations": lilaraVersion,
+      "@lilara/ui-web": lilaraVersion,
+      "@lilara/ui-web-react": lilaraVersion,
+      react: "18.3.1",
+      "react-dom": "18.3.1",
+      zod: "^4.4.3"
+    },
+    devDependencies: {
+      "@botonic/nx-plugin": botonicVersion,
+      "@nx/vite": "21.6.11",
+      "@types/node": "22.13.0",
+      "@types/react": "18.3.1",
+      "@types/react-dom": "18.3.0",
+      "@vitejs/plugin-react": "^4.2.0",
+      "@vitejs/plugin-react-swc": "^3.5.0",
+      typescript: "5.7.3",
+      vite: "7.1.9",
+      vitest: "4.1.1"
+    }
+  };
+  (0, import_devkit.writeJson)(tree, `${options.projectRoot}/package.json`, packageJson);
+}
+function createTsConfigs(tree, options) {
+  const tsconfig = {
+    compilerOptions: {
+      jsx: "react-jsx",
+      allowJs: false,
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+      resolveJsonModule: true,
+      strict: true,
+      types: ["vite/client", "vitest"]
+    },
+    files: [],
+    include: ["src/**/*.ts", "src/**/*.tsx"],
+    references: [
+      { path: "./tsconfig.app.json" },
+      { path: "./tsconfig.spec.json" }
+    ],
+    extends: "../../tsconfig.base.json"
+  };
+  const tsconfigApp = {
+    extends: "./tsconfig.json",
+    compilerOptions: {
+      outDir: "./dist/out-tsc",
+      types: ["node", "vite/client"],
+      composite: true,
+      noEmit: false,
+      declaration: true
+    },
+    files: [
+      "../../node_modules/@nx/react/typings/cssmodule.d.ts",
+      "../../node_modules/@nx/react/typings/image.d.ts"
+    ],
+    exclude: [
+      "jest.config.ts",
+      "src/**/*.spec.ts",
+      "src/**/*.test.ts",
+      "src/**/*.spec.tsx",
+      "src/**/*.test.tsx",
+      "src/**/*.spec.js",
+      "src/**/*.test.js",
+      "src/**/*.spec.jsx",
+      "src/**/*.test.jsx"
+    ],
+    include: ["src/**/*.js", "src/**/*.jsx", "src/**/*.ts", "src/**/*.tsx"]
+  };
+  const tsconfigSpec = {
+    extends: "./tsconfig.json",
+    compilerOptions: {
+      outDir: "./dist/out-tsc",
+      module: "commonjs",
+      types: ["vitest/globals", "vitest/importMeta", "vite/client", "node"],
+      composite: true,
+      noEmit: false,
+      declaration: true
+    },
+    include: [
+      "vite.config.ts",
+      "vitest.config.ts",
+      "src/**/*.test.ts",
+      "src/**/*.spec.ts",
+      "src/**/*.test.tsx",
+      "src/**/*.spec.tsx",
+      "src/**/*.test.js",
+      "src/**/*.spec.js",
+      "src/**/*.test.jsx",
+      "src/**/*.spec.jsx",
+      "src/**/*.d.ts"
+    ]
+  };
+  (0, import_devkit.writeJson)(tree, `${options.projectRoot}/tsconfig.json`, tsconfig);
+  (0, import_devkit.writeJson)(tree, `${options.projectRoot}/tsconfig.app.json`, tsconfigApp);
+  (0, import_devkit.writeJson)(tree, `${options.projectRoot}/tsconfig.spec.json`, tsconfigSpec);
+}
+function addBotonicDependencies(tree, botonicVersion) {
+  return (0, import_devkit.addDependenciesToPackageJson)(
+    tree,
+    // dependencies
+    {
+      react: "18.3.1",
+      "react-dom": "18.3.1"
+    },
+    // devDependencies
+    {
+      "@nx/vite": "21.6.11",
+      "@types/node": "22.13.0",
+      "@types/react": "18.3.1",
+      "@types/react-dom": "18.3.0",
+      "@vitejs/plugin-react": "4.2.0",
+      "@vitejs/plugin-react-swc": "3.5.0",
+      typescript: "5.7.3",
+      vite: "7.1.9",
+      vitest: "4.1.1"
+    }
+  );
+}
+function addBotonicFiles(tree, options, botonicVersion) {
+  const templateOptions = {
+    ...options,
+    ...(0, import_devkit.names)(options.name),
+    botonicVersion
+  };
+  (0, import_devkit.generateFiles)(
+    tree,
+    (0, import_devkit.joinPathFragments)(MODULE_DIR, "files"),
+    options.projectRoot,
+    templateOptions
+  );
+}
+async function generator_impl_default(tree, options) {
+  const botonicVersion = getBotonicVersion(options);
+  const lilaraVersion = getLilaraVersion(options);
+  const tasks = [];
+  console.log(`\u{1F916} Using Botonic version: ${botonicVersion}`);
+  console.log(`\u{1F3A8} Using Lilara version: ${lilaraVersion}`);
+  console.log(`\u{1F50D} Creating project using programmatic configuration...`);
+  const normalizedOptions = normalizeOptions(tree, options);
+  console.log(`\u{1F50D} Normalized options:`, {
+    projectName: normalizedOptions.projectName,
+    projectRoot: normalizedOptions.projectRoot,
+    projectDirectory: normalizedOptions.projectDirectory
+  });
+  createProjectConfiguration(tree, normalizedOptions);
+  createPackageJson(tree, normalizedOptions, botonicVersion, lilaraVersion);
+  createTsConfigs(tree, normalizedOptions);
+  const depsTask = addBotonicDependencies(tree, botonicVersion);
+  tasks.push(depsTask);
+  tasks.push(() => (0, import_devkit.installPackagesTask)(tree));
+  tasks.push(
+    () => (0, import_devkit.installPackagesTask)(
+      tree,
+      true,
+      `${normalizedOptions.projectRoot}/src/server/lambda/`
+    )
+  );
+  addBotonicFiles(tree, normalizedOptions, botonicVersion);
+  await (0, import_devkit.formatFiles)(tree);
+  tasks.push(() => {
+    console.log(
+      `
+\u{1F389} Successfully created Botonic bot app: ${normalizedOptions.projectName}`
+    );
+    console.log(`\u{1F4C1} Project location: ${normalizedOptions.projectRoot}`);
+    console.log(`
+\u{1F4CB} Next step:`);
+    console.log(`   npx nx run ${normalizedOptions.projectName}:serve`);
+    console.log(`
+\u{1F680} Happy bot building!`);
+  });
+  return (0, import_devkit.runTasksInSerial)(...tasks);
+}

package/src/generators/bot-app/generator.d.ts

@@ -1,4 +1,2 @@
-import { GeneratorCallback, Tree } from '@nx/devkit';
-import type { BotAppGeneratorSchema } from './schema';
-export default function (tree: Tree, options: BotAppGeneratorSchema): Promise<GeneratorCallback>;
-export { BotAppGeneratorSchema };
+export { default } from './generator-impl';
+export type { BotAppGeneratorSchema } from './schema';