@kosdev-code/kos-ui-cli 2.0.8 → 2.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kosdev-code/kos-ui-cli",
-  "version": "2.0.8",
+  "version": "2.0.10",
   "bin": {
     "kosui": "./src/lib/cli.mjs"
   },
@@ -20,7 +20,7 @@
   "main": "./src/index.js",
   "kos": {
     "build": {
-      "gitHash": "8584fd420609fe114b6a0417595eb9b83bb1301a"
+      "gitHash": "3f829f56d0cb6147af6735c40f3f1f52734cf673"
     }
   },
   "publishConfig": {

package/src/lib/cli.mjs

@@ -4,122 +4,72 @@ import minimist from "minimist";
 import path, { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Plop, run } from "plop";
+import { clearCache } from "./utils/cache.mjs";
+import { getGeneratorMetadata } from "./utils/generator-loader.mjs";
 
-const args = process.argv.slice(2);
-const argv = minimist(args);
+// -- Step 1: Sanitize flags early and persist to env
+const originalArgs = process.argv.slice(2);
+const parsedArgs = minimist(originalArgs);
 
-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 customFlags = ["--no-cache", "--refresh"];
+const hasNoCache = originalArgs.includes("--no-cache");
+const hasRefresh = originalArgs.includes("--refresh");
 
-  const command = args.length > 0 ? args[0] : "help";
+if (hasNoCache || hasRefresh) {
+  process.env.DISABLE_CACHE = "true";
+  console.log("[kos-cli] Cache disabled or refresh forced. Clearing cache...");
+  clearCache();
+}
 
-  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);
-          })
-      );
+// -- Step 2: Strip custom flags from argv so Plop doesn't choke
+process.argv = [
+  ...process.argv.slice(0, 2),
+  ...originalArgs.filter((arg) => !customFlags.includes(arg)),
+];
 
-      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);
-          })
-      );
+// -- Step 3: Resolve generator
+const command = parsedArgs._[0] || "help";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const configPath = path.join(__dirname, "plopfile.mjs");
 
-      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);
-          })
-      );
+const showBanner =
+  command !== "help" &&
+  command !== "env" &&
+  process.env.DISABLE_CLI_BANNER !== "true";
+
+// -- Step 4: Optional figlet banner
+function launch() {
+  Plop.prepare(
+    {
+      cwd: parsedArgs.cwd,
+      configPath,
+      preload: parsedArgs.preload || [],
+      completion: parsedArgs.completion,
+    },
+    async (env) => {
+      if (command && command !== "help" && command !== "env") {
+        const meta = await getGeneratorMetadata(command);
+        console.log(`--- Running KOS Generator: ${meta?.name || command} ---`);
+      } else if (command === "env") {
+        console.warn("--- Discover Studio Environment Variables ---");
+      } else {
+        console.warn("--- KOS CLI Help ---");
+      }
 
-      break;
+      return run({ ...env, dest: process.cwd() }, undefined, true);
     }
-    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;
+if (showBanner) {
+  figlet("KOS CLI", function (err, data) {
+    if (err) {
+      console.error("Figlet failed:", err);
+      return launch();
     }
-  }
-});
+    console.log(data);
+    launch();
+  });
+} else {
+  launch();
+}

package/src/lib/generators/cache/index.mjs

@@ -0,0 +1,12 @@
+import { clearCache } from "../../utils/cache.mjs";
+
+export default function registerCacheGenerators(plop) {
+  plop.setGenerator("cache:clear", {
+    description: "Clear the generator context cache",
+    prompts: [],
+    actions: () => {
+      clearCache();
+      return ["[ok] CLI cache cleared successfully."];
+    },
+  });
+}

package/src/lib/generators/component/index.mjs

@@ -0,0 +1,48 @@
+// generators/component/index.mjs
+import { execute } from "../../utils/exec.mjs";
+import { getAllProjects } from "../../utils/nx-context.mjs";
+import { required } from "../../utils/validators.mjs";
+
+export const metadata = {
+  key: "component",
+  name: "KOS React Component",
+};
+
+export default async function (plop) {
+  const allProjects = await getAllProjects();
+
+  plop.setActionType("createComponent", async function (answers) {
+    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-component \
+      --name=${answers.componentName} \
+      --appProject=${answers.componentProject} \
+      --type=components \
+      --no-interactive`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `Component ${answers.componentName} created in ${answers.componentProject}`;
+  });
+
+  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: () => [{ type: "createComponent" }],
+  });
+}

package/src/lib/{env-plopfile.mjs → generators/env/index.mjs}

@@ -1,14 +1,26 @@
+// generators/env/index.mjs
 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";
+import { findJavaExecutable } from "../../utils/java-home.mjs";
+import { detectWorkspace } from "../../utils/nx-context.mjs";
+import { findStudioHome } from "../../utils/studio-home.mjs";
 
+export const metadata = {
+  key: "env",
+  name: "Discover and Set Studio Environment Variables",
+};
 export default async function (plop) {
   plop.setPrompt("directory", directoryPrompt);
+
   const isWorkspace = await detectWorkspace();
+  if (!isWorkspace) {
+    console.warn(
+      "[kos-cli] Not inside an Nx workspace. Skipping env generator."
+    );
+    return;
+  }
 
-  plop.setActionType("findEnv", async function (answers, config, plop) {
+  plop.setActionType("findEnv", async function () {
     const studioHome = findStudioHome();
     const javaHome = findJavaExecutable();
 
@@ -23,11 +35,6 @@ export default async function (plop) {
   plop.setGenerator("env", {
     description: "Discover Studio Environment Variables",
     prompts: [],
-    actions: function (data) {
-      const action = {
-        type: "findEnv",
-      };
-      return [action];
-    },
+    actions: () => [{ type: "findEnv" }],
   });
 }

package/src/lib/generators/i18n/namespace.mjs

@@ -0,0 +1,55 @@
+// generators/i18n/namespace.mjs
+import fs from "fs";
+import path from "path";
+import { getAllProjects, getProjectDetails } from "../../utils/nx-context.mjs";
+import { required } from "../../utils/validators.mjs";
+
+export const metadata = {
+  key: "i18n:namespace",
+  name: "KOS i18n Project Namespace",
+};
+
+export default async function (plop) {
+  const allProjects = await getAllProjects();
+
+  plop.setActionType("addNamespace", async function (answers) {
+    const i18nProject = await getProjectDetails(answers.project);
+    const srcRoot = i18nProject.sourceRoot;
+    const locale = answers.locale;
+    const namespaceDir = path.join(srcRoot, "assets", "locales", locale);
+    const namespacePath = path.join(namespaceDir, `${answers.name}.json`);
+
+    fs.mkdirSync(namespaceDir, { recursive: true });
+    fs.writeFileSync(
+      namespacePath,
+      JSON.stringify({ name: answers.name }, null, 2)
+    );
+
+    return `Namespace ${answers.name}.json created for locale ${locale} in ${answers.project}`;
+  });
+
+  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: allProjects,
+      },
+    ],
+    actions: () => [{ type: "addNamespace" }],
+  });
+}

package/src/lib/generators/metadata.json

@@ -0,0 +1,150 @@
+[
+  {
+    "category": "component",
+    "file": "index.mjs",
+    "metadata": {
+      "key": "component",
+      "name": "KOS React Component"
+    }
+  },
+  {
+    "category": "env",
+    "file": "index.mjs",
+    "metadata": {
+      "key": "env",
+      "name": "Discover and Set Studio Environment Variables"
+    }
+  },
+  {
+    "category": "i18n",
+    "file": "namespace.mjs",
+    "metadata": {
+      "key": "i18n:namespace",
+      "name": "KOS i18n Project Namespace"
+    }
+  },
+  {
+    "category": "model",
+    "file": "companion.mjs",
+    "metadata": {
+      "key": "model:companion",
+      "name": "KOS Companion Model"
+    }
+  },
+  {
+    "category": "model",
+    "file": "container.mjs",
+    "metadata": {
+      "key": "container",
+      "name": "KOS Container Model"
+    }
+  },
+  {
+    "category": "model",
+    "file": "context.mjs",
+    "metadata": {
+      "key": "context",
+      "name": "KOS Model React Context"
+    }
+  },
+  {
+    "category": "model",
+    "file": "hook.mjs",
+    "metadata": {
+      "key": "hook",
+      "name": "KOS Model React Hook"
+    }
+  },
+  {
+    "category": "model",
+    "file": "model.mjs",
+    "metadata": {
+      "key": "model",
+      "name": "KOS Model",
+      "invalidateCache": true
+    }
+  },
+  {
+    "category": "plugin",
+    "file": "index.mjs",
+    "metadata": [
+      {
+        "key": "pluginComponent",
+        "name": "KOS UI Plugin Component"
+      },
+      {
+        "key": "plugin:cui",
+        "name": "KOS UI Plugin CUI Configuration"
+      },
+      {
+        "key": "plugin:setup",
+        "name": "KOS UI Plugin Setup Step"
+      },
+      {
+        "key": "plugin:utility",
+        "name": "KOS UI Plugin Utility"
+      },
+      {
+        "key": "plugin:setting",
+        "name": "KOS UI Plugin Setting"
+      },
+      {
+        "key": "plugin:nav",
+        "name": "KOS UI Plugin Navigation View"
+      }
+    ]
+  },
+  {
+    "category": "project",
+    "file": "app.mjs",
+    "metadata": {
+      "key": "project",
+      "name": "KOS UI App Project",
+      "invalidateCache": true
+    }
+  },
+  {
+    "category": "project",
+    "file": "i18n.mjs",
+    "metadata": {
+      "key": "i18n",
+      "name": "KOS Localization Project",
+      "invalidateCache": true
+    }
+  },
+  {
+    "category": "project",
+    "file": "plugin.mjs",
+    "metadata": {
+      "key": "plugin",
+      "name": "KOS Plugin Project",
+      "invalidateCache": true
+    }
+  },
+  {
+    "category": "project",
+    "file": "splash.mjs",
+    "metadata": {
+      "key": "project:splash",
+      "name": "KOS Splash Screen Project",
+      "invalidateCache": true
+    }
+  },
+  {
+    "category": "project",
+    "file": "theme.mjs",
+    "metadata": {
+      "key": "theme",
+      "name": "KOS Theme Project",
+      "invalidateCache": true
+    }
+  },
+  {
+    "category": "workspace",
+    "file": "index.mjs",
+    "metadata": {
+      "key": "workspace",
+      "name": "Create a new KOS UI Workspace"
+    }
+  }
+]

package/src/lib/generators/model/companion.mjs

@@ -0,0 +1,77 @@
+// generators/model/companion.mjs
+import { execute } from "../../utils/exec.mjs";
+import {
+  getAllModels,
+  getLibraryProjects,
+  getProjectDetails,
+} from "../../utils/nx-context.mjs";
+import { DEFAULT_PROMPTS, MODEL_PROMPTS } from "../../utils/prompts.mjs";
+import { required } from "../../utils/validators.mjs";
+
+export const metadata = {
+  key: "model:companion",
+  name: "KOS Companion Model",
+};
+
+export default async function (plop) {
+  const allModels = await getAllModels();
+  const libraryProjects = await getLibraryProjects();
+  const modelChoices = allModels.map((m) => ({
+    name: `${m.model} (${m.project})`,
+    value: m.model,
+  }));
+
+  plop.setActionType("createCompanionModel", async function (answers) {
+    const modelProject = await getProjectDetails(answers.modelProject);
+    const companionProject = allModels.find(
+      (m) => m.model === answers.companionParent
+    )?.project;
+
+    const command = `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=${companionProject} \
+      --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+  });
+
+  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: modelChoices,
+      },
+      ...MODEL_PROMPTS,
+    ],
+    actions: () => [{ type: "createCompanionModel" }],
+  });
+}

package/src/lib/generators/model/container.mjs

@@ -0,0 +1,66 @@
+// generators/model/container.mjs
+import { execute } from "../../utils/exec.mjs";
+import {
+  getAllModels,
+  getAllProjects,
+  getProjectDetails,
+} from "../../utils/nx-context.mjs";
+import { DEFAULT_PROMPTS, MODEL_PROMPTS } from "../../utils/prompts.mjs";
+
+export const metadata = {
+  key: "container",
+  name: "KOS Container Model",
+};
+
+export default async function (plop) {
+  const allModels = await getAllModels();
+  const allProjects = await getAllProjects();
+  const modelChoices = allModels.map((m) => ({
+    name: `${m.model} (${m.project})`,
+    value: m.model,
+  }));
+
+  plop.setActionType("createContainer", async function (answers) {
+    const modelProject = allModels.find(
+      (m) => m.model === answers.modelName
+    )?.project;
+    const projectDetails = await getProjectDetails(modelProject);
+
+    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-container-model \
+      --modelName=${answers.modelName} \
+      --modelProject=${projectDetails.name} \
+      --skipRegistration=true \
+      --dataServices=${!!answers.dataServices} \
+      --singleton=${!!answers.singleton} \
+      --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `Container model created for ${answers.modelName}`;
+  });
+
+  plop.setGenerator("container", {
+    description: "Create a new KOS Container Model",
+    prompts: [
+      ...DEFAULT_PROMPTS,
+      {
+        type: "list",
+        name: "modelName",
+        message: "Which model to use?",
+        choices: modelChoices,
+      },
+      {
+        type: "list",
+        name: "registrationProject",
+        message: "Which project should the model be registered in?",
+        choices: allProjects,
+      },
+      ...MODEL_PROMPTS,
+    ],
+    actions: () => [{ type: "createContainer" }],
+  });
+}