@kosdev-code/kos-ui-cli 0.1.0-dev.5053

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

@@ -0,0 +1,18 @@
+import { clearCache } from "../../utils/cache.mjs";
+
+export const metadata = {
+  name: "cache:clear",
+  description: "Clear the generator context cache",
+  invalidateCache: false,
+  requiresModels: false,
+};
+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,55 @@
+// generators/component/index.mjs
+import { actionFactory } from "../../utils/action-factory.mjs";
+import { execute } from "../../utils/exec.mjs";
+import { getComponentCompatibleProjectsWithFallback } from "../../utils/nx-context.mjs";
+import { required } from "../../utils/validators.mjs";
+
+export const metadata = {
+  key: "component",
+  name: "KOS React Component",
+  namedArguments: {
+    name: "componentName",
+    componentName: "componentName",
+    project: "componentProject",
+    componentProject: "componentProject"
+  }
+};
+
+export default async function (plop) {
+  const componentProjects = await getComponentCompatibleProjectsWithFallback();
+
+  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: componentProjects,
+      },
+    ],
+    actions: actionFactory("createComponent", metadata),
+  });
+}

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

@@ -0,0 +1,42 @@
+// generators/env/index.mjs
+import fs from "fs";
+import directoryPrompt from "inquirer-directory";
+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",
+  namedArguments: { interactive: "interactive" },
+};
+export default async function (plop) {
+  plop.setPrompt("directory", directoryPrompt);
+
+  plop.setActionType("findEnv", async function () {
+    console.log("[kos-cli] Discovering Studio Environment Variables...");
+    const isWorkspace = await detectWorkspace();
+
+    if (!isWorkspace) {
+      console.warn(
+        "[kos-cli] Not inside an Nx workspace. Skipping env generator."
+      );
+      return "Skipped: Not a workspace";
+    }
+    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 `\nStudio Home: ${studioHome}\nJava Home: ${javaHome}`;
+  });
+
+  plop.setGenerator("env", {
+    description: "Discover Studio Environment Variables",
+    prompts: [],
+    actions: () => [{ type: "findEnv" }],
+  });
+}

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

@@ -0,0 +1,61 @@
+// generators/i18n/namespace.mjs
+import fs from "fs";
+import path from "path";
+import { actionFactory } from "../../utils/action-factory.mjs";
+import { getI18nProjectsWithFallback, getProjectDetails } from "../../utils/nx-context.mjs";
+import { required } from "../../utils/validators.mjs";
+
+export const metadata = {
+  key: "i18n:namespace",
+  name: "KOS i18n Project Namespace",
+  namedArguments: {
+    name: "name",
+    locale: "locale",
+    project: "project",
+  },
+};
+
+export default async function (plop) {
+  const i18nProjects = await getI18nProjectsWithFallback();
+
+  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: i18nProjects,
+      },
+    ],
+    actions: actionFactory("addNamespace", metadata),
+  });
+}

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

@@ -0,0 +1,82 @@
+// generators/kab/index.mjs
+import { execSync } from "child_process";
+import inquirer from "inquirer";
+import { detectWorkspace } from "../../utils/nx-context.mjs";
+
+export const metadata = {
+  key: "kab",
+  name: "Run Kab Target",
+  namedArguments: {
+    project: "project",
+    interactive: "interactive"
+  },
+};
+
+async function getProjectsWithTarget(target) {
+  try {
+    const output = execSync(`npx nx show projects --with-target ${target} --json`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return JSON.parse(output);
+  } catch (error) {
+    return [];
+  }
+}
+
+export default async function (plop) {
+  const projects = await getProjectsWithTarget("kab");
+
+  if (projects.length === 0) {
+    console.warn("[kos-cli] No projects found with kab target");
+    // Still register the generator but it will fail gracefully
+  }
+
+  plop.setActionType("runKab", async function (answers) {
+    const isWorkspace = await detectWorkspace();
+
+    if (!isWorkspace) {
+      console.warn(
+        "[kos-cli] Not inside an Nx workspace. Cannot run kab target."
+      );
+      return "Skipped: Not a workspace";
+    }
+
+    const { project } = answers;
+
+    if (project === "all") {
+      console.log("[kos-cli] Running kab on all projects with kab target...");
+      try {
+        execSync("npx nx run-many --target=kab", {
+          stdio: "inherit",
+        });
+        return "Successfully ran kab on all projects";
+      } catch (error) {
+        throw new Error(`Failed to run kab on all projects: ${error.message}`);
+      }
+    } else {
+      console.log(`[kos-cli] Running kab on ${project}...`);
+      try {
+        execSync(`npx nx run ${project}:kab`, {
+          stdio: "inherit",
+        });
+        return `Successfully ran kab on ${project}`;
+      } catch (error) {
+        throw new Error(`Failed to run kab on ${project}: ${error.message}`);
+      }
+    }
+  });
+
+  plop.setGenerator("kab", {
+    description: "Run the kab target on a project",
+    prompts: [
+      {
+        type: "list",
+        name: "project",
+        message: "Select a project to run kab:",
+        choices: [...projects, new inquirer.Separator(), { name: "Run on all projects", value: "all" }],
+      },
+    ],
+    actions: () => [{ type: "runKab" }],
+  });
+}

package/src/lib/generators/metadata.json

@@ -0,0 +1,341 @@
+[
+  {
+    "category": "cache",
+    "file": "index.mjs",
+    "metadata": {
+      "name": "cache:clear",
+      "description": "Clear the generator context cache",
+      "invalidateCache": false,
+      "requiresModels": false
+    }
+  },
+  {
+    "category": "component",
+    "file": "index.mjs",
+    "metadata": {
+      "key": "component",
+      "name": "KOS React Component",
+      "namedArguments": {
+        "name": "componentName",
+        "componentName": "componentName",
+        "project": "componentProject",
+        "componentProject": "componentProject"
+      }
+    }
+  },
+  {
+    "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",
+      "namedArguments": {
+        "name": "name",
+        "locale": "locale",
+        "project": "project"
+      }
+    }
+  },
+  {
+    "category": "model",
+    "file": "add-future.mjs",
+    "metadata": {
+      "key": "add-future",
+      "name": "Add Future Support to Model",
+      "invalidateCache": true,
+      "namedArguments": {
+        "modelName": "modelName",
+        "project": "modelProject",
+        "modelProject": "modelProject",
+        "futureType": "futureType",
+        "updateServices": "updateServices",
+        "dryRun": "dryRun",
+        "interactive": "interactive"
+      }
+    }
+  },
+  {
+    "category": "model",
+    "file": "companion.mjs",
+    "metadata": {
+      "key": "model:companion",
+      "name": "KOS Companion Model",
+      "namedArguments": {
+        "name": "modelName",
+        "modelName": "modelName",
+        "project": "modelProject",
+        "modelProject": "modelProject",
+        "companionParent": "companionParent",
+        "companionPattern": "companionPattern",
+        "container": "container",
+        "parentAware": "parentAware",
+        "singleton": "singleton",
+        "dataServices": "dataServices",
+        "dryRun": "dryRun",
+        "interactive": "interactive"
+      }
+    }
+  },
+  {
+    "category": "model",
+    "file": "container.mjs",
+    "metadata": {
+      "key": "container",
+      "name": "KOS Container Model",
+      "namedArguments": {
+        "modelName": "modelName",
+        "registrationProject": "registrationProject",
+        "container": "container",
+        "parentAware": "parentAware",
+        "singleton": "singleton",
+        "dataServices": "dataServices",
+        "dryRun": "dryRun",
+        "interactive": "interactive"
+      }
+    }
+  },
+  {
+    "category": "model",
+    "file": "context.mjs",
+    "metadata": {
+      "key": "context",
+      "name": "KOS Model React Context",
+      "namedArguments": {
+        "modelName": "modelName",
+        "componentProject": "componentProject",
+        "project": "componentProject"
+      }
+    }
+  },
+  {
+    "category": "model",
+    "file": "hook.mjs",
+    "metadata": {
+      "key": "hook",
+      "name": "KOS Model React Hook",
+      "namedArguments": {
+        "modelName": "modelName",
+        "componentProject": "componentProject",
+        "project": "componentProject"
+      }
+    }
+  },
+  {
+    "category": "model",
+    "file": "model.mjs",
+    "metadata": {
+      "key": "model",
+      "name": "KOS Model",
+      "invalidateCache": true,
+      "namedArguments": {
+        "name": "modelName",
+        "modelName": "modelName",
+        "project": "modelProject",
+        "modelProject": "modelProject",
+        "container": "container",
+        "parentAware": "parentAware",
+        "singleton": "singleton",
+        "dataServices": "dataServices",
+        "futureAware": "futureAware",
+        "dryRun": "dryRun",
+        "interactive": "interactive"
+      }
+    }
+  },
+  {
+    "category": "plugin",
+    "file": "index.mjs",
+    "metadata": [
+      {
+        "key": "pluginComponent",
+        "name": "KOS UI Plugin Component",
+        "namedArguments": {
+          "name": "componentName",
+          "componentName": "componentName",
+          "project": "componentProject",
+          "componentProject": "componentProject",
+          "extensionPoint": "extensionPoint"
+        }
+      },
+      {
+        "key": "plugin:cui",
+        "name": "KOS UI Plugin CUI Configuration",
+        "namedArguments": {
+          "name": "componentName",
+          "componentName": "componentName",
+          "project": "componentProject",
+          "componentProject": "componentProject"
+        }
+      },
+      {
+        "key": "plugin:setup",
+        "name": "KOS UI Plugin Setup Step",
+        "namedArguments": {
+          "name": "componentName",
+          "componentName": "componentName",
+          "project": "componentProject",
+          "componentProject": "componentProject"
+        }
+      },
+      {
+        "key": "plugin:utility",
+        "name": "KOS UI Plugin Utility",
+        "namedArguments": {
+          "name": "componentName",
+          "componentName": "componentName",
+          "project": "componentProject",
+          "componentProject": "componentProject"
+        }
+      },
+      {
+        "key": "plugin:setting",
+        "name": "KOS UI Plugin Setting",
+        "namedArguments": {
+          "name": "componentName",
+          "componentName": "componentName",
+          "project": "componentProject",
+          "componentProject": "componentProject",
+          "group": "group"
+        }
+      },
+      {
+        "key": "plugin:nav",
+        "name": "KOS UI Plugin Navigation View",
+        "namedArguments": {
+          "name": "componentName",
+          "componentName": "componentName",
+          "project": "componentProject",
+          "componentProject": "componentProject"
+        }
+      },
+      {
+        "key": "plugin:cp",
+        "name": "KOS UI Plugin Control Pour",
+        "namedArguments": {
+          "name": "componentName",
+          "componentName": "componentName",
+          "project": "componentProject",
+          "componentProject": "componentProject"
+        }
+      }
+    ]
+  },
+  {
+    "category": "project",
+    "file": "app.mjs",
+    "metadata": {
+      "key": "project",
+      "name": "KOS UI App Project",
+      "invalidateCache": true,
+      "namedArguments": {
+        "name": "name"
+      }
+    }
+  },
+  {
+    "category": "project",
+    "file": "content.mjs",
+    "metadata": {
+      "key": "content",
+      "name": "KOS Content Project",
+      "invalidateCache": true,
+      "namedArguments": {
+        "name": "name"
+      }
+    }
+  },
+  {
+    "category": "project",
+    "file": "i18n.mjs",
+    "metadata": {
+      "key": "i18n",
+      "name": "KOS Localization Project",
+      "invalidateCache": true,
+      "namedArguments": {
+        "name": "name"
+      }
+    }
+  },
+  {
+    "category": "project",
+    "file": "plugin.mjs",
+    "metadata": {
+      "key": "plugin",
+      "name": "KOS Plugin Project",
+      "invalidateCache": true,
+      "namedArguments": {
+        "name": "name"
+      }
+    }
+  },
+  {
+    "category": "project",
+    "file": "splash.mjs",
+    "metadata": {
+      "key": "project:splash",
+      "name": "KOS Splash Screen Project",
+      "invalidateCache": true,
+      "namedArguments": {
+        "name": "name"
+      }
+    }
+  },
+  {
+    "category": "project",
+    "file": "theme.mjs",
+    "metadata": {
+      "key": "theme",
+      "name": "KOS Theme Project",
+      "invalidateCache": true,
+      "namedArguments": {
+        "name": "name"
+      }
+    }
+  },
+  {
+    "category": "workspace",
+    "file": "index.mjs",
+    "metadata": {
+      "key": "workspace",
+      "name": "Create a new KOS UI Workspace",
+      "namedArguments": {
+        "name": "workspaceName",
+        "workspaceName": "workspaceName"
+      }
+    }
+  },
+  {
+    "category": "workspace",
+    "file": "list-models.mjs",
+    "metadata": {
+      "key": "workspace:list-models",
+      "name": "List all available models in the workspace",
+      "description": "List all available models in the workspace",
+      "namedArguments": {
+        "format": "outputFormat"
+      }
+    }
+  },
+  {
+    "category": "workspace",
+    "file": "list-projects.mjs",
+    "metadata": {
+      "key": "workspace:list-projects",
+      "name": "List all available projects in the workspace",
+      "description": "List all available projects in the workspace with optional type filtering",
+      "namedArguments": {
+        "type": "projectType",
+        "format": "outputFormat",
+        "fallback": "includeFallback"
+      }
+    }
+  }
+]

package/src/lib/generators/model/add-future.mjs

@@ -0,0 +1,96 @@
+// generators/model/add-future.mjs
+import { actionFactory } from "../../utils/action-factory.mjs";
+import { execute } from "../../utils/exec.mjs";
+import { getAllModels } from "../../utils/nx-context.mjs";
+import { DEFAULT_PROMPTS } from "../../utils/prompts.mjs";
+
+export const metadata = {
+  key: "add-future",
+  name: "Add Future Support to Model",
+  invalidateCache: true,
+  namedArguments: {
+    modelName: "modelName",
+    project: "modelProject",
+    modelProject: "modelProject",
+    futureType: "futureType",
+    updateServices: "updateServices",
+    dryRun: "dryRun",
+    interactive: "interactive",
+  },
+};
+
+export default async function (plop) {
+  // Check if we're in interactive mode by looking at process args
+  const isInteractive = process.argv.includes('-i') || process.argv.includes('--interactive');
+  
+  // For interactive mode, use lazy loading. For non-interactive, load immediately.
+  let modelChoices;
+  if (isInteractive) {
+    modelChoices = async () => {
+      const allModels = await getAllModels();
+      return allModels.map((m) => ({
+        name: `${m.model} (${m.project})`,
+        value: m.model,
+      }));
+    };
+  } else {
+    const allModels = await getAllModels();
+    modelChoices = allModels.map((m) => ({
+      name: `${m.model} (${m.project})`,
+      value: m.model,
+    }));
+  }
+
+  plop.setActionType("addFutureToModel", async function (answers) {
+    const allModels = await getAllModels();
+    const modelProject = allModels.find(
+      (m) => m.model === answers.modelName
+    )?.project;
+    
+    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-add-future-to-model \\
+      --modelName=${answers.modelName} \\
+      --modelProject=${modelProject} \\
+      --futureType=${answers.futureType} \\
+      --updateServices=${!!answers.updateServices} \\
+      --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `Future support (${answers.futureType}) added to model ${answers.modelName} in ${modelProject}`;
+  });
+
+  plop.setGenerator("add-future", {
+    description: "Add Future support to an existing KOS Model",
+    prompts: [
+      ...DEFAULT_PROMPTS,
+      {
+        type: "list",
+        name: "modelName",
+        message: "Which model do you want to add Future support to?",
+        choices: modelChoices,
+      },
+      {
+        type: "list",
+        name: "futureType",
+        message: "What type of Future support?",
+        choices: [
+          { name: "Minimal (external access only)", value: "minimal" },
+          { name: "Complete (internal + external access)", value: "complete" },
+        ],
+        default: "minimal",
+      },
+      {
+        type: "confirm",
+        name: "updateServices",
+        message: "Update/create services file with Future operations?",
+        default: true,
+      },
+    ],
+
+    actions: actionFactory("addFutureToModel", metadata),
+  });
+}