@kosdev-code/kos-ui-cli 1.6.0

package/README.md

@@ -0,0 +1,7 @@
+# sdk-kos-ui-cli
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build sdk-kos-ui-cli` to build the library.

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@kosdev-code/kos-ui-cli",
+  "version": "1.6.0",
+  "bin": {
+    "kosui": "./src/lib/cli.mjs"
+  },
+  "files": [
+    "src"
+  ],
+  "type": "module",
+  "dependencies": {
+    "prettier": "^2.6.2",
+    "rimraf": "^5.0.1",
+    "plop": "^3.1.2",
+    "inquirer-directory": "^2.2.0",
+    "figlet": "^1.6.0",
+    "create-nx-workspace": "18.0.3"
+  },
+  "module": "./src/index.js",
+  "main": "./src/index.js",
+  "kos": {
+    "build": {
+      "gitHash": "9a0e8bf2281366d70b509e1ba964955806ce6c69"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/sdk/kos-ui-cli/src/index.js"],"names":[],"mappings":""}

package/src/index.js

@@ -0,0 +1 @@
+export {};

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/sdk/kos-ui-cli/src/index.js"],"names":[],"mappings":""}

package/src/lib/cli.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import figlet from "figlet";
+import minimist from "minimist";
+import path, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Plop, run } from "plop";
+
+const args = process.argv.slice(2);
+const argv = minimist(args);
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+figlet("kOS CLI", function (err, data) {
+  if (err) {
+    console.log("Something went wrong...");
+    console.dir(err);
+    return;
+  }
+
+  const command = args.length > 0 ? args[0] : "help";
+
+  switch (command) {
+    case "workspace":
+    case "component":
+    case "pluginComponent":
+    case "plugin:cui":
+    case "plugin:utility":
+    case "plugin:setup":
+    case "plugin:setting":
+    case "plugin:nav":
+    case "plugin:troubleAction":
+    case "project":
+    case "project:splash":
+    case "theme":
+    case "plugin":
+    case "i18n":
+    case "i18n:namespace":
+    case "model": {
+      Plop.prepare(
+        {
+          cwd: argv.cwd,
+          configPath: path.join(__dirname, "plopfile.mjs"),
+          preload: argv.preload || [],
+          completion: argv.completion,
+        },
+        (env) =>
+          Plop.execute(env, (env) => {
+            const options = {
+              ...env,
+              dest: process.cwd(), // this will make the destination path to be based on the cwd when calling the wrapper
+            };
+            return run(options, undefined, true);
+          })
+      );
+
+      break;
+    }
+    case "hook":
+    case "container":
+    case "context":
+    case "model:companion": {
+      console.warn(`--- Create a new kOS Model - ${args[0]}  ---`);
+      Plop.prepare(
+        {
+          cwd: argv.cwd,
+          configPath: path.join(__dirname, "model-aware-plopfile.mjs"),
+          preload: argv.preload || [],
+          completion: argv.completion,
+        },
+        (env) =>
+          Plop.execute(env, (env) => {
+            const options = {
+              ...env,
+              dest: process.cwd(), // this will make the destination path to be based on the cwd when calling the wrapper
+            };
+            return run(options, undefined, true);
+          })
+      );
+
+      break;
+    }
+    case "env": {
+      console.warn("--- Discover Studio Environment Variables ---");
+      console.warn("The following will discover Studio Environment Variables.");
+      Plop.prepare(
+        {
+          cwd: argv.cwd,
+          configPath: path.join(__dirname, "env-plopfile.mjs"),
+          preload: argv.preload || [],
+          completion: argv.completion,
+        },
+        (env) =>
+          Plop.execute(env, (env) => {
+            const options = {
+              ...env,
+              dest: process.cwd(), // this will make the destination path to be based on the cwd when calling the wrapper
+            };
+            return run(options, undefined, true);
+          })
+      );
+
+      break;
+    }
+    default: {
+      console.warn("--- kOS CLI Help ---");
+      Plop.prepare(
+        {
+          cwd: argv.cwd,
+          configPath: path.join(__dirname, "routing-plopfile.mjs"),
+          preload: argv.preload || [],
+          completion: argv.completion,
+        },
+        (env) =>
+          Plop.execute(env, (env) => {
+            const options = {
+              ...env,
+              dest: process.cwd(), // this will make the destination path to be based on the cwd when calling the wrapper
+            };
+            return run(options, undefined, true);
+          })
+      );
+
+      break;
+    }
+  }
+});

package/src/lib/env-plopfile.mjs

@@ -0,0 +1,33 @@
+import fs from "fs";
+import directoryPrompt from "inquirer-directory";
+import { findJavaExecutable } from "./utils/java-home.mjs";
+import { findStudioHome } from "./utils/studio-home.mjs";
+import { detectWorkspace } from "./utils/utils.mjs";
+
+export default async function (plop) {
+  plop.setPrompt("directory", directoryPrompt);
+  const isWorkspace = await detectWorkspace();
+
+  plop.setActionType("findEnv", async function (answers, config, plop) {
+    const studioHome = findStudioHome();
+    const javaHome = findJavaExecutable();
+
+    fs.writeFileSync(
+      ".env.local",
+      `#  Path to the Java binary\nJAVA_CMD='${javaHome}'\n\n#  Path to the kos installation\nKOS_INSTALL_PATH='${studioHome}'\n`
+    );
+
+    return `Studio Home: ${studioHome}\nJava Home: ${javaHome}`;
+  });
+
+  plop.setGenerator("env", {
+    description: "Discover Studio Environment Variables",
+    prompts: [],
+    actions: function (data) {
+      const action = {
+        type: "findEnv",
+      };
+      return [action];
+    },
+  });
+}

package/src/lib/model-aware-plopfile.mjs

@@ -0,0 +1,274 @@
+import directoryPrompt from "inquirer-directory";
+import {
+  detectWorkspace,
+  execute,
+  getAllModels,
+  getAllProjects,
+  getLibraryProjects,
+  getProjectDetails,
+  required,
+} from "./utils/utils.mjs";
+
+const DEFAULT_PROMPTS = [
+  {
+    type: "confirm",
+    name: "interactive",
+    message: "Do you want to use the interactive mode?",
+    default: false,
+    when: false,
+  },
+  {
+    type: "confirm",
+    name: "dryRun",
+    message: "Show the output of the command without running it?",
+    default: false,
+    when: false,
+  },
+];
+
+const MODEL_PROMPTS = [
+  {
+    type: "confirm",
+    name: "container",
+    default: false,
+    message: "Does this model require a container model?",
+  },
+  {
+    type: "confirm",
+    name: "parentAware",
+    when: (answers) => {
+      console.log(answers);
+      return !!answers.container;
+    },
+    default: false,
+    message: "Should the model be aware of it's parent container?",
+  },
+  {
+    type: "confirm",
+    name: "singleton",
+    default: false,
+    message: "Is this model a singleton?",
+  },
+
+  {
+    type: "confirm",
+    name: "dataServices",
+    default: true,
+    message: "Create data services for model?",
+  },
+];
+export default async function (plop) {
+  plop.setPrompt("directory", directoryPrompt);
+  const isWorkspace = await detectWorkspace();
+
+  const allProjects = isWorkspace ? await getAllProjects() : [];
+  const libraryProjects = isWorkspace ? await getLibraryProjects() : [];
+  const allModels = isWorkspace ? await getAllModels() : [];
+  const workspaceModels = allModels.map((model) => {
+    return { name: `${model.model} (${model.project})`, value: model.model };
+  });
+
+  plop.setActionType("createContainer", async function (answers, config, plop) {
+    const modelProjectName = allModels.find(
+      (model) => model.model === answers.modelName
+    )?.project;
+    const modelProject = await getProjectDetails(modelProjectName);
+
+    try {
+      await execute(
+        `npx nx generate @kosdev-code/kos-nx-plugin:kos-container-model --modelName=${
+          answers.modelName
+        } --modelProject=${
+          modelProject.name
+        } --skipRegistration=true  --dataServices=${!!answers.dataServices} --singleton=${!!answers.singleton} --no-interactive ${
+          answers.dryRun ? "--dryRun" : ""
+        } --verbose`
+      );
+    } catch (error) {
+      throw new Error(error);
+    }
+    return `model ${answers.modelName} created in ${answers.modelProject}`;
+  });
+
+  plop.setActionType("createHook", async function (answers, config, plop) {
+    const modelProject = allModels.find(
+      (model) => model.model === answers.modelName
+    )?.project;
+
+    try {
+      await execute(
+        `npx nx generate @kosdev-code/kos-nx-plugin:kos-hook --appProject=${
+          answers.componentProject
+        } --modelProject=${modelProject} --name=${
+          answers.modelName
+        } --no-interactive ${answers.dryRun ? "--dryRun" : ""}`
+      );
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `hook created for ${answers.modelName} in ${answers.componentProject}`;
+  });
+
+  plop.setActionType("createContext", async function (answers, config, plop) {
+    const modelProject = allModels.find(
+      (model) => model.model === answers.modelName
+    )?.project;
+
+    try {
+      await execute(
+        `npx nx generate @kosdev-code/kos-nx-plugin:kos-context --appProject=${
+          answers.componentProject
+        } --modelProject=${modelProject} --name=${
+          answers.modelName
+        } --no-interactive ${answers.dryRun ? "--dryRun" : ""}`
+      );
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `context created for ${answers.modelName} in ${answers.componentProject}`;
+  });
+
+  plop.setActionType(
+    "createCompanionModel",
+    async function (answers, config, plop) {
+      console.log(JSON.stringify(answers, null, 2));
+      const modelProject = await getProjectDetails(answers.modelProject);
+
+      const companionParentProjectName = allModels.find(
+        (model) => model.model === answers.companionParent
+      )?.project;
+      try {
+        await execute(
+          `npx nx generate @kosdev-code/kos-nx-plugin:kos-model --name=${
+            answers.modelName
+          } --modelProject=${
+            modelProject.name
+          } --skipRegistration=true --container=${!!answers.container} --dataServices=${!!answers.dataServices} --singleton=${!!answers.singleton} --parentAware=${!!answers.parentAware} --companion=true --companionModel=${
+            answers.companionParent
+          } --companionModelProject=${companionParentProjectName} --no-interactive ${
+            answers.dryRun ? "--dryRun" : ""
+          } --verbose`
+        );
+      } catch (error) {
+        throw new Error(error);
+      }
+    }
+  );
+
+  plop.setGenerator("container", {
+    description: "Create a new kOS Container Model",
+    prompts: [
+      ...DEFAULT_PROMPTS,
+      {
+        type: "list",
+        name: "modelName",
+        message: "Which model to use?",
+        choices: workspaceModels,
+      },
+      {
+        type: "list",
+        name: "registrationProject",
+        message: "Which project should the model be registered in?",
+        validate: required,
+        choices: allProjects,
+      },
+      ...MODEL_PROMPTS,
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createContainer",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("hook", {
+    description: "Create a hook for a kOS Model",
+    prompts: [
+      {
+        type: "list",
+        name: "modelName",
+        message: "Which model to use?",
+
+        choices: workspaceModels,
+      },
+
+      {
+        type: "list",
+        name: "componentProject",
+        message: "Which project should the hook be created in?",
+        when: (answers) => {
+          return !answers.componentProject;
+        },
+        choices: allProjects,
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createHook",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("context", {
+    description: "Create a context for a kOS Model",
+    prompts: [
+      {
+        type: "list",
+        name: "modelName",
+        message: "Which model to use?",
+        choices: workspaceModels,
+      },
+
+      {
+        type: "list",
+        name: "componentProject",
+        message: "Which project should the context be created in?",
+        choices: getAllProjects,
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createContext",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("model:companion", {
+    description: "Create a new kOS Companion Model",
+    prompts: [
+      ...DEFAULT_PROMPTS,
+      {
+        type: "input",
+        name: "modelName",
+        message: "Enter the name of the model",
+        validate: required,
+      },
+      {
+        type: "list",
+        name: "modelProject",
+        message: "Which model project to use?",
+        validate: required,
+        choices: libraryProjects,
+      },
+      {
+        type: "list",
+        name: "companionParent",
+        message: "Select the companion parent model?",
+        choices: workspaceModels,
+      },
+
+      ...MODEL_PROMPTS,
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createCompanionModel",
+      };
+      return [action];
+    },
+  });
+}

package/src/lib/plopfile.mjs

@@ -0,0 +1,586 @@
+import { spawn } from "child_process";
+import { createWorkspace } from "create-nx-workspace";
+import fs from "fs";
+import directoryPrompt from "inquirer-directory";
+import path from "path";
+import {
+  detectWorkspace,
+  execute,
+  getAllProjects,
+  getLibraryProjects,
+  getPluginProjects,
+  getProjectDetails,
+  required,
+} from "./utils/utils.mjs";
+
+const DEFAULT_PROMPTS = [
+  {
+    type: "confirm",
+    name: "interactive",
+    message: "Do you want to use the interactive mode?",
+    default: false,
+    when: false,
+  },
+  {
+    type: "confirm",
+    name: "dryRun",
+    message: "Show the output of the command without running it?",
+    default: false,
+    when: false,
+  },
+];
+
+const MODEL_PROMPTS = [
+  {
+    type: "confirm",
+    name: "container",
+    default: false,
+    message: "Does this model require a container model?",
+  },
+  {
+    type: "confirm",
+    name: "parentAware",
+    when: (answers) => {
+      return !!answers.container;
+    },
+    default: false,
+    message: "Should the model be aware of it's parent container?",
+  },
+  {
+    type: "confirm",
+    name: "singleton",
+    default: false,
+    message: "Is this model a singleton?",
+  },
+
+  {
+    type: "confirm",
+    name: "dataServices",
+    default: true,
+    message: "Create data services for model?",
+  },
+];
+export default async function (plop) {
+  plop.setPrompt("directory", directoryPrompt);
+  const isWorkspace = await detectWorkspace();
+  const libraryProjects = isWorkspace ? await getLibraryProjects() : [];
+  const allProjects = isWorkspace ? await getAllProjects() : [];
+
+  plop.setActionType("createWorkspace", async function (answers, config, plop) {
+    await createWorkspace("@kosdev-code/kos-nx-plugin", {
+      nxCloud: "skip",
+      name: answers.workspaceName,
+    });
+    return `workspace ${answers.workspaceName} created`;
+  });
+
+  plop.setActionType("createModel", async function (answers, config, plop) {
+    const modelProject = await getProjectDetails(answers.modelProject);
+
+    try {
+      await execute(
+        `npx nx generate @kosdev-code/kos-nx-plugin:kos-model --name=${
+          answers.modelName
+        } --modelProject=${
+          modelProject.name
+        } --skipRegistration=true --container=${!!answers.container} --dataServices=${!!answers.dataServices} --singleton=${!!answers.singleton} --parentAware=${!!answers.parentAware} --no-interactive ${
+          answers.dryRun ? "--dryRun" : ""
+        } --verbose`
+      );
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `*******************************************************
+    model ${answers.modelName} created in ${answers.modelProject}
+    
+    Please register the model in your app registration file
+    *******************************************************`;
+  });
+
+  plop.setActionType("addNamespace", async function (answers, config, plop) {
+    const i18nProject = await getProjectDetails(answers.project);
+    const locale = answers.locale;
+    const src = i18nProject.sourceRoot;
+    const namespaceDirPath = path.join(src, "assets", "locales", locale);
+
+    const namespacePath = path.join(namespaceDirPath, `${answers.name}.json`);
+
+    const defaultData = {
+      name: answers.name,
+    };
+
+    fs.mkdirSync(namespaceDirPath, { recursive: true });
+    fs.writeFileSync(namespacePath, JSON.stringify(defaultData, null, 2));
+  });
+
+  plop.setActionType("createSplashProject", function (answers, config, plop) {
+    return new Promise((resolve, reject) => {
+      const command =
+        `nx generate @kosdev-code/kos-nx-plugin:kos-splash-project --name=${answers.name} --no-interactive`.split(
+          " "
+        );
+
+      const child = spawn("npx", command, { shell: true });
+      child.stdout.on("data", (data) => {
+        console.log(`${data}`);
+      });
+
+      child.stderr.on("data", (data) => {
+        console.error(`ERROR:${data}`);
+      });
+      child.on("exit", function (code, signal) {
+        if (code === 0) {
+          resolve(`Splash page project ${answers.name} created`);
+        } else {
+          reject(`Splash page project ${answers.name} failed`);
+        }
+      });
+    });
+  });
+  plop.setActionType("createComponent", function (answers, config, plop) {
+    return new Promise((resolve, reject) => {
+      const command =
+        `npx nx generate @kosdev-code/kos-nx-plugin:kos-component --name=${answers.componentName} --appProject=${answers.componentProject} --type=components --no-interactive`.split(
+          " "
+        );
+      const child = spawn("npx", command, { shell: true });
+      child.stdout.on("data", (data) => {
+        console.log(`${data}`);
+      });
+
+      child.stderr.on("data", (data) => {
+        console.error(`ERROR:${data}`);
+      });
+      child.on("exit", function (code, signal) {
+        if (code === 0) {
+          resolve(`UI project ${answers.name} created`);
+        } else {
+          reject(`UI project ${answers.name} failed`);
+        }
+      });
+    });
+  });
+  plop.setActionType("createPluginComponent", function (answers, config, plop) {
+    return new Promise((resolve, reject) => {
+      const pluginType = answers.extensionPoint;
+      const command =
+        `npx nx generate @kosdev-code/kos-nx-plugin:kos-component --name=${answers.componentName} --group=${answers.group} --appProject=${answers.componentProject} --pluginType=${pluginType} --type=components --no-interactive`.split(
+          " "
+        );
+      const child = spawn("npx", command, { shell: true });
+      child.stdout.on("data", (data) => {
+        console.log(`${data}`);
+      });
+
+      child.stderr.on("data", (data) => {
+        console.error(`ERROR:${data}`);
+      });
+      child.on("exit", function (code, signal) {
+        if (code === 0) {
+          resolve(`UI project ${answers.name} created`);
+        } else {
+          reject(`UI project ${answers.name} failed`);
+        }
+      });
+    });
+  });
+  plop.setActionType("createUiProject", function (answers, config, plop) {
+    return new Promise((resolve, reject) => {
+      const command =
+        `npx nx generate @kosdev-code/kos-nx-plugin:kos-ui-project --name=${answers.name} --no-interactive`.split(
+          " "
+        );
+      const child = spawn("npx", command, { shell: true });
+      child.stdout.on("data", (data) => {
+        console.log(`${data}`);
+      });
+
+      child.stderr.on("data", (data) => {
+        console.error(`ERROR:${data}`);
+      });
+      child.on("exit", function (code, signal) {
+        if (code === 0) {
+          resolve(`UI project ${answers.name} created`);
+        } else {
+          reject(`UI project ${answers.name} failed`);
+        }
+      });
+    });
+  });
+
+  plop.setActionType("createI18nProject", function (answers, config, plop) {
+    return new Promise((resolve, reject) => {
+      const command =
+        `npx nx generate @kosdev-code/kos-nx-plugin:kos-i18n-project --name=${answers.name} --no-interactive`.split(
+          " "
+        );
+      const child = spawn("npx", command, { shell: true });
+      child.stdout.on("data", (data) => {
+        console.log(`${data}`);
+      });
+
+      child.stderr.on("data", (data) => {
+        console.error(`ERROR:${data}`);
+      });
+      child.on("exit", function (code, signal) {
+        if (code === 0) {
+          resolve(`i18n project ${answers.name} created`);
+        } else {
+          reject(`i18n project ${answers.name} failed`);
+        }
+      });
+    });
+  });
+  plop.setActionType("createThemeProject", function (answers, config, plop) {
+    return new Promise((resolve, reject) => {
+      const command =
+        `npx nx generate @kosdev-code/kos-nx-plugin:kos-theme-project --name=${answers.name} --no-interactive`.split(
+          " "
+        );
+      const child = spawn("npx", command, { shell: true });
+      child.stdout.on("data", (data) => {
+        console.log(`${data}`);
+      });
+
+      child.stderr.on("data", (data) => {
+        console.error(`ERROR:${data}`);
+      });
+      child.on("exit", function (code, signal) {
+        if (code === 0) {
+          resolve(`theme project ${answers.name} created`);
+        } else {
+          reject(`theme project ${answers.name} failed`);
+        }
+      });
+    });
+  });
+
+  plop.setActionType("createPluginProject", function (answers, config, plop) {
+    return new Promise((resolve, reject) => {
+      const command =
+        `npx nx generate @kosdev-code/kos-nx-plugin:kos-plugin-project --name=${answers.name} --no-interactive`.split(
+          " "
+        );
+      const child = spawn("npx", command, { shell: true });
+      child.stdout.on("data", (data) => {
+        console.log(`${data}`);
+      });
+
+      child.stderr.on("data", (data) => {
+        console.error(`ERROR:${data}`);
+      });
+      child.on("exit", function (code, signal) {
+        if (code === 0) {
+          resolve(`plugin project ${answers.name} created`);
+        } else {
+          reject(`plugin project ${answers.name} failed`);
+        }
+      });
+    });
+  });
+
+  plop.setGenerator("component", {
+    description: "Create a new kOS Component",
+    prompts: [
+      {
+        type: "input",
+        name: "componentName",
+        message: "Enter the name of the component",
+        validate: required,
+      },
+      {
+        type: "list",
+        name: "componentProject",
+        message: "Which project should the component be created in?",
+        choices: allProjects,
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createComponent",
+      };
+      return [action];
+    },
+  });
+
+  const pluginPrompts = [
+    {
+      type: "input",
+      name: "componentName",
+      message: "Enter the name of the component",
+      validate: required,
+    },
+    {
+      type: "list",
+      name: "componentProject",
+      message: "Which project should the component be created in?",
+      choices: getPluginProjects,
+    },
+  ];
+  plop.setGenerator("pluginComponent", {
+    description: "Create a new kOS Plugin Component",
+    prompts: [
+      ...pluginPrompts,
+      {
+        type: "list",
+        name: "extensionPoint",
+        message: "What type of extension point is the plugin supporting?",
+        choices: ["cui", "setup", "utility", "setting", "troubleAction"],
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createPluginComponent",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("plugin:cui", {
+    description: "Create a new kOS CUI Configuration Plugin Component",
+    prompts: [...pluginPrompts],
+    actions: function (data) {
+      data.extensionPoint = "cui";
+      const action = {
+        type: "createPluginComponent",
+        extensionPoint: "cui",
+      };
+      return [action];
+    },
+  });
+  plop.setGenerator("plugin:utility", {
+    description: "Create a new kOS Utility Plugin Component",
+    prompts: [...pluginPrompts],
+    actions: function (data) {
+      data.extensionPoint = "utility";
+      const action = {
+        type: "createPluginComponent",
+        extensionPoint: "utility",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("plugin:troubleAction", {
+    description: "Create a new kOS Trouble Action Plugin Component",
+    prompts: [...pluginPrompts],
+    actions: function (data) {
+      data.extensionPoint = "troubleAction";
+      const action = {
+        type: "createPluginComponent",
+        extensionPoint: "troubleAction",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("plugin:setup", {
+    description: "Create a new kOS Setup Step Plugin Component",
+    prompts: [...pluginPrompts],
+    actions: function (data) {
+      data.extensionPoint = "setup";
+      const action = {
+        type: "createPluginComponent",
+        extensionPoint: "setup",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("plugin:setting", {
+    description: "Create a new kOS Settings Plugin Component",
+    prompts: [
+      ...pluginPrompts,
+      {
+        type: "input",
+        name: "group",
+        message: "Which settings group should the setting be located?",
+      },
+    ],
+    actions: function (data) {
+      data.extensionPoint = "setting";
+      const action = {
+        type: "createPluginComponent",
+        extensionPoint: "setting",
+      };
+      return [action];
+    },
+  });
+  plop.setGenerator("plugin:nav", {
+    description: "Create a new kOS Navigation View Plugin Component",
+    prompts: [...pluginPrompts],
+    actions: function (data) {
+      data.extensionPoint = "nav";
+      const action = {
+        type: "createPluginComponent",
+        extensionPoint: "nav",
+      };
+      return [action];
+    },
+  });
+  plop.setGenerator("workspace", {
+    description: "kOS UI Workspace Setup",
+    prompts: [
+      {
+        type: "input",
+        name: "workspaceName",
+        message: "kOS UI Workspace Name",
+        validate: required,
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createWorkspace",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("model", {
+    description: "Create a new kOS Model",
+    prompts: [
+      ...DEFAULT_PROMPTS,
+      {
+        type: "input",
+        name: "modelName",
+        message: "Enter the name of the model",
+        validate: required,
+      },
+      {
+        type: "list",
+        name: "modelProject",
+        message: "Which model project to use?",
+        validate: required,
+        choices: libraryProjects,
+      },
+      ...MODEL_PROMPTS,
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createModel",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("theme", {
+    description: "Create a new kos UI Theme project",
+    prompts: [
+      {
+        type: "input",
+        name: "name",
+        message: "What is the name of the theme project?",
+        validate: required,
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createThemeProject",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("project", {
+    description: "Create a new kos UI App project",
+    prompts: [
+      {
+        type: "input",
+        name: "name",
+        message: "What is the name of the app project?",
+        validate: required,
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createUiProject",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("plugin", {
+    description: "Create a new kos UI Plugin project",
+    prompts: [
+      {
+        type: "input",
+        name: "name",
+        message: "What is the name of the plugin project?",
+        validate: required,
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createPluginProject",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("project:splash", {
+    description: "Create a new kos splash page project",
+    prompts: [
+      {
+        type: "input",
+        name: "name",
+        message: "What is the name of the splash project?",
+        validate: required,
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createSplashProject",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("i18n", {
+    description: "Create a new kos UI i18n project",
+    prompts: [
+      {
+        type: "input",
+        name: "name",
+        message: "What is the name of the i18n project?",
+        validate: required,
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "createI18nProject",
+      };
+      return [action];
+    },
+  });
+
+  plop.setGenerator("i18n:namespace", {
+    description: "Create a new kos UI i18n namespace",
+    prompts: [
+      {
+        type: "input",
+        name: "name",
+        message: "What is the name of the i18n namespace?",
+        validate: required,
+      },
+      {
+        type: "input",
+        name: "locale",
+        message: "What is the locale of the i18n namespace?",
+        validate: required,
+      },
+      {
+        type: "list",
+        name: "project",
+        message: "Which project should the namespace be created in?",
+        choices: getAllProjects,
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "addNamespace",
+      };
+      return [action];
+    },
+  });
+}

package/src/lib/routing-plopfile.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import minimist from "minimist";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const args = process.argv.slice(2);
+const argv = minimist(args);
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export default async function (plop) {
+  const generators = {
+    model: { name: "kOS Model", path: "plopfile.mjs" },
+    "model:companion": {
+      name: "kOS Companion Model",
+      path: "model-aware-plopfile.mjs",
+    },
+    hook: { name: "kOS Model Hook and HoC", path: "model-aware-plopfile.mjs" },
+    context: { name: "kOS Model Context", path: "model-aware-plopfile.mjs" },
+    container: {
+      name: "kOS Model Container",
+      path: "model-aware-plopfile.mjs",
+    },
+
+    workspace: {
+      name: "kOS Development Workspace",
+      path: "plopfile.mjs",
+    },
+    project: { name: "kOS UI App Project", path: "model-aware-plopfile.mjs" },
+    plugin: { name: "kOS UI Plugin Project", path: "plopfile.mjs" },
+    "plugin:utility": { name: "kOS UI Plugin Utility", path: "plopfile.mjs" },
+    "plugin:setup": { name: "kOS UI Plugin Setup Step", path: "plopfile.mjs" },
+    "plugin:cui": {
+      name: "kOS UI Plugin CUI Configuration",
+      path: "plopfile.mjs",
+    },
+    "plugin:setup": { name: "kOS UI Plugin Setup Step", path: "plopfile.mjs" },
+    "plugin:nav": {
+      name: "kOS UI Plugin Page Navigation",
+      path: "plopfile.mjs",
+    },
+    component: { name: "kOS UI Component", path: "plopfile.mjs" },
+    pluginComponent: { name: "kOS UI Plugin Component", path: "plopfile.mjs" },
+    i18n: {
+      name: "kOS Localization Project",
+      path: "plopfile.mjs",
+    },
+    "i18n:namespace": {
+      name: "kOS Localization Namespace",
+      path: "plopfile.mjs",
+    },
+    theme: { name: "kOS Theme Project", path: "plopfile.mjs" },
+    env: {
+      name: "Discover and Set Studio Environment Variables",
+      path: "env-plopfile.mjs",
+    },
+  };
+  plop.setActionType("execute", async (answers, config) => {
+    const template = answers.template;
+    argv._ = [template];
+    const pathName = generators[template].path;
+
+    console.warn(`---------   Please run kosui ${template}   ---------`);
+  });
+
+  plop.setGenerator("help", {
+    description: "Select a task to run",
+    prompts: [
+      {
+        type: "list",
+        name: "template",
+        message: "Choose a task to run:",
+        choices: Object.keys(generators).map((key) => ({
+          name: generators[key].name,
+          value: key,
+        })),
+      },
+    ],
+    actions: function (data) {
+      const action = {
+        type: "execute",
+      };
+      return [action];
+    },
+  });
+}

package/src/lib/utils/index.mjs

@@ -0,0 +1 @@
+export * from "./utils.mjs";

package/src/lib/utils/java-home.mjs

@@ -0,0 +1,55 @@
+import { execSync } from "child_process";
+import { platform } from "os";
+import { join } from "path";
+
+export function findJavaHome() {
+  const os = platform();
+
+  if (os === "win32") {
+    return findJavaHomeWindows();
+  } else if (os === "darwin" || os === "linux") {
+    return findJavaHomeUnix();
+  } else {
+    throw new Error("Unsupported operating system: " + os);
+  }
+}
+
+function findJavaHomeWindows() {
+  try {
+    const output = execSync(
+      'reg query "HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\JDK" /s /v JavaHome'
+    );
+    const match = /JavaHome\s+REG_SZ\s+(.*)/i.exec(output.toString());
+    if (match && match[1]) {
+      return match[1].trim();
+    }
+  } catch (error) {
+    console.error("Unable to find Java home directory:", error);
+  }
+
+  return undefined;
+}
+
+function findJavaHomeUnix() {
+  try {
+    const output = execSync(
+      "echo $(dirname $(dirname $(readlink -f $(which javac))))"
+    );
+    if (output) {
+      return output.toString().trim();
+    }
+  } catch (error) {
+    console.error("Unable to find Java home directory:", error);
+  }
+
+  return undefined;
+}
+
+export function findJavaExecutable() {
+  const javaHome = findJavaHome();
+  const javaExecutable =
+    platform() === "darwin"
+      ? join(javaHome || "", "bin", "java")
+      : join(javaHome || "", "bin", "java.exe");
+  return javaExecutable;
+}

package/src/lib/utils/studio-home.mjs

@@ -0,0 +1,12 @@
+import os from "os";
+import { join } from "path";
+export const findStudioHome = () => {
+  const homeDir = os.homedir();
+
+  const installDir =
+    os.platform() === "darwin"
+      ? join(homeDir, "Applications", "kosStudio.app")
+      : join(homeDir, "AppData", "Local", "kosStudio");
+
+  return installDir;
+};

package/src/lib/utils/utils.mjs

@@ -0,0 +1,126 @@
+import { exec, execSync, spawn } from "child_process";
+import { readFile, readdir } from "fs/promises";
+import path from "path";
+
+export async function getAllModels() {
+  console.log(`parsing projects for models...`);
+  const allProjects = await getAllProjects();
+  const models = await allProjects.reduce(async (acc, curr) => {
+    const project = await getProjectDetails(curr);
+    const list = await acc;
+
+    const config = await readdir(project.root, { withFileTypes: true });
+    if (config.find((dirent) => dirent.name === ".kos.json")) {
+      const kosConfig = JSON.parse(
+        await readFile(path.join(project.root, ".kos.json"), "utf-8")
+      );
+      if (kosConfig.models) {
+        Object.keys(kosConfig.models).forEach((model) => {
+          list.push({ model: model, project: project.name });
+        });
+      }
+    }
+    return list.sort((a, b) => {
+      if (a.project === b.project) {
+        return a.model.localeCompare(b.model);
+      } else {
+        return a.project.localeCompare(b.project);
+      }
+    });
+  }, []);
+  return models;
+}
+export async function getAllProjects() {
+  return new Promise((resolve, reject) => {
+    exec("npx nx show projects --json", (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      }
+      if (stderr) {
+        reject(stderr);
+      }
+      resolve(JSON.parse(stdout).sort((a, b) => a.localeCompare(b)));
+    });
+  });
+}
+
+export function getLibraryProjects() {
+  const projects = execSync("npx nx show projects --type lib --json");
+  return JSON.parse(projects).sort((a, b) => a.localeCompare(b));
+}
+
+export function getPluginProjects() {
+  const internal = !!process.env.INTERNAL;
+  const filter = internal ? "*plugin*" : "plugins/*";
+  const projects = execSync(
+    `npx nx show projects  --projects "${filter}" --json`
+  );
+  return JSON.parse(projects);
+}
+
+export async function getProjectDetails(project) {
+  return new Promise((resolve, reject) => {
+    exec(`npx nx show project ${project}  --json`, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      }
+      if (stderr) {
+        reject(stderr);
+      }
+      resolve(JSON.parse(stdout));
+    });
+  });
+}
+
+export function interactive(answers) {
+  return answers.interactive;
+}
+
+export function required(value) {
+  if (/.+/.test(value)) {
+    return true;
+  }
+  return false;
+}
+
+export async function execute(commandString) {
+  return new Promise((resolve, reject) => {
+    const [command, ...commandArguments] = commandString.split(" ");
+    const child = spawn(command, commandArguments, {
+      shell: true,
+    });
+
+    child.on("message", (message) => {
+      console.log(message);
+    });
+
+    child.stdout.on("data", (data) => {
+      console.log(`${data}`);
+    });
+
+    child.stderr.on("data", (data) => {
+      // console.info(`ERROR:${data}`);
+    });
+    child.on("exit", function (code, signal) {
+      console.log(`process exited with code ${code}`);
+      if (code === 0) {
+        resolve("success");
+      } else {
+        reject("failure");
+      }
+    });
+  });
+}
+
+export async function workspaceModels() {
+  const allModels = await getAllModels();
+  const workspaceModels = allModels.map((model) => {
+    return model.model;
+  });
+  return workspaceModels;
+}
+
+export async function detectWorkspace() {
+  const files = await readdir(process.cwd(), { withFileTypes: true });
+  return files.find((file) => file.name === "nx.json");
+}