@kosdev-code/kos-ui-cli 2.0.43 → 2.0.45

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

@@ -27,21 +27,39 @@ export const metadata = {
     parentAware: "parentAware",
     singleton: "singleton",
     dataServices: "dataServices",
+    autoRegister: "autoRegister",
     dryRun: "dryRun",
     interactive: "interactive",
   },
 };
 
 export default async function (plop) {
-  const allModels = await getAllModels();
   const libraryProjects = await getModelProjectsWithFallback();
-  const modelChoices = allModels.map((m) => ({
-    name: `${m.model} (${m.project})`,
-    value: m.model,
-  }));
+  
+  // 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("createCompanionModel", async function (answers) {
     const modelProject = await getProjectDetails(answers.modelProject);
+    const allModels = await getAllModels();
     const companionProject = allModels.find(
       (m) => m.model === answers.companionParent
     )?.project;
@@ -54,6 +72,7 @@ export default async function (plop) {
       --dataServices=${!!answers.dataServices} \
       --singleton=${!!answers.singleton} \
       --parentAware=${!!answers.parentAware} \
+      --autoRegister=${!!answers.autoRegister} \
       --companion=true \
       --companionModel=${answers.companionParent} \
       --companionModelProject=${companionProject} \

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

@@ -18,20 +18,38 @@ export const metadata = {
     parentAware: "parentAware",
     singleton: "singleton",
     dataServices: "dataServices",
+    autoRegister: "autoRegister",
     dryRun: "dryRun",
     interactive: "interactive",
   },
 };
 
 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,
-  }));
+  
+  // 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("createContainer", async function (answers) {
+    const allModels = await getAllModels();
     const modelProject = allModels.find(
       (m) => m.model === answers.modelName
     )?.project;
@@ -43,6 +61,7 @@ export default async function (plop) {
       --skipRegistration=true \
       --dataServices=${!!answers.dataServices} \
       --singleton=${!!answers.singleton} \
+      --autoRegister=${!!answers.autoRegister} \
       --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
 
     try {

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

@@ -14,13 +14,30 @@ export const metadata = {
 
 export default async function (plop) {
   const allProjects = await getAllProjects();
-  const allModels = await getAllModels();
-  const modelChoices = allModels.map((m) => ({
-    name: `${m.model} (${m.project})`,
-    value: m.model,
-  }));
+  
+  // 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("createContext", async function (answers) {
+    const allModels = await getAllModels();
     const modelProject = allModels.find(
       (m) => m.model === answers.modelName
     )?.project;

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

@@ -14,13 +14,30 @@ export const metadata = {
 
 export default async function (plop) {
   const allProjects = await getAllProjects();
-  const allModels = await getAllModels();
-  const modelChoices = allModels.map((m) => ({
-    name: `${m.model} (${m.project})`,
-    value: m.model,
-  }));
+  
+  // 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("createHook", async function (answers) {
+    const allModels = await getAllModels();
     const modelProject = allModels.find(
       (m) => m.model === answers.modelName
     )?.project;

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

@@ -15,13 +15,14 @@ export const metadata = {
   namedArguments: {
     name: "modelName",
     modelName: "modelName",
-    project: "modelProject", 
+    project: "modelProject",
     modelProject: "modelProject",
     container: "container",
     parentAware: "parentAware",
     singleton: "singleton",
     dataServices: "dataServices",
     futureAware: "futureAware",
+    autoRegister: "autoRegister",
     dryRun: "dryRun",
     interactive: "interactive"
   }
@@ -41,6 +42,7 @@ export default async function (plop) {
       --singleton=${!!answers.singleton} \
       --parentAware=${!!answers.parentAware} \
       --futureAware=${answers.futureAware || 'none'} \
+      --autoRegister=${!!answers.autoRegister} \
       --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
 
     try {

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

@@ -66,8 +66,8 @@ export const metadata = [
       componentProject: "componentProject"
     }
   },
-  { 
-    key: "plugin:cp", 
+  {
+    key: "plugin:cp",
     name: "KOS UI Plugin Control Pour",
     namedArguments: {
       name: "componentName",
@@ -76,6 +76,17 @@ export const metadata = [
       componentProject: "componentProject"
     }
   },
+  {
+    key: "plugin:custom",
+    name: "KOS UI Plugin Custom (User-Specified Contribution)",
+    namedArguments: {
+      name: "componentName",
+      componentName: "componentName",
+      project: "componentProject",
+      componentProject: "componentProject",
+      contributionKey: "contributionKey"
+    }
+  },
 ];
 
 export default async function (plop) {
@@ -84,7 +95,12 @@ export default async function (plop) {
   plop.setActionType("createPluginComponent", async function (answers) {
     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`;
+    let 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`;
+
+    // Add contributionKey for custom plugin types
+    if (pluginType === 'custom' && answers.contributionKey) {
+      command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-component --name=${answers.componentName} --contributionKey=${answers.contributionKey} --appProject=${answers.componentProject} --pluginType=${pluginType} --type=components --no-interactive`;
+    }
 
     try {
       await execute(command);
@@ -116,6 +132,7 @@ export default async function (plop) {
     { key: "plugin:setting", name: "setting" },
     { key: "plugin:nav", name: "nav" },
     { key: "plugin:cp", name: "controlPour" },
+    { key: "plugin:custom", name: "custom" },
   ];
 
   // Generic plugin component
@@ -146,6 +163,16 @@ export default async function (plop) {
             },
           ]
         : []),
+      ...(name === "custom"
+        ? [
+            {
+              type: "input",
+              name: "contributionKey",
+              message: "What contribution key should be used in .kos.json? (e.g., 'menus', 'panels', 'commands', etc.)",
+              validate: required,
+            },
+          ]
+        : []),
       {
         type: "input",
         name: "extensionPoint",

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

@@ -0,0 +1,74 @@
+// generators/serve/index.mjs
+import { execSync } from "child_process";
+import { detectWorkspace } from "../../utils/nx-context.mjs";
+
+export const metadata = {
+  key: "serve",
+  name: "Run Serve 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("serve");
+
+  if (projects.length === 0) {
+    console.warn("[kos-cli] No projects found with serve target");
+    // Still register the generator but it will fail gracefully
+  }
+
+  plop.setActionType("runServe", async function (answers) {
+    const isWorkspace = await detectWorkspace();
+
+    if (!isWorkspace) {
+      console.warn(
+        "[kos-cli] Not inside an Nx workspace. Cannot run serve target."
+      );
+      return "Skipped: Not a workspace";
+    }
+
+    const { project } = answers;
+
+    console.log(`[kos-cli] Running serve on ${project}...`);
+    try {
+      // Run serve in foreground with stdio inherited so it stays alive
+      execSync(`npx nx run ${project}:serve`, {
+        stdio: "inherit",
+      });
+      return `Serve completed for ${project}`;
+    } catch (error) {
+      // Don't throw error for Ctrl+C or normal termination
+      if (error.signal === "SIGINT") {
+        return `Serve terminated for ${project}`;
+      }
+      throw new Error(`Failed to run serve on ${project}: ${error.message}`);
+    }
+  });
+
+  plop.setGenerator("serve", {
+    description: "Run the serve target on a project",
+    prompts: [
+      {
+        type: "list",
+        name: "project",
+        message: "Select a project to serve:",
+        choices: projects,
+      },
+    ],
+    actions: () => [{ type: "runServe" }],
+  });
+}

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

@@ -0,0 +1,182 @@
+// generators/version/index.mjs
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { detectWorkspace } from "../../utils/nx-context.mjs";
+
+export const metadata = {
+  key: "version",
+  name: "Display CLI and SDK Version Information",
+  namedArguments: { interactive: "interactive" },
+};
+
+function getPackageVersion(packagePath) {
+  try {
+    const packageJsonPath = path.join(packagePath, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      return packageJson.version || "unknown";
+    }
+  } catch (error) {
+    // Package not found
+  }
+  return null;
+}
+
+function findWorkspaceRoot(startDir = process.cwd()) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    if (existsSync(path.join(dir, "nx.json"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function getCliVersion() {
+  let version = null;
+
+  // Option 1: Check workspace root package.json for installed CLI
+  const workspaceRoot = findWorkspaceRoot();
+  if (workspaceRoot) {
+    try {
+      const output = execSync(
+        "npm list @kosdev-code/kos-ui-cli --depth=0 --json",
+        {
+          cwd: workspaceRoot,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }
+      );
+      const data = JSON.parse(output);
+      version = data?.dependencies?.["@kosdev-code/kos-ui-cli"]?.version;
+    } catch (error) {
+      // Not in workspace dependencies
+    }
+  }
+
+  // Option 2: Check global installation
+  if (!version) {
+    try {
+      const output = execSync(
+        "npm list -g @kosdev-code/kos-ui-cli --depth=0 --json",
+        {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }
+      );
+      const data = JSON.parse(output);
+      version = data?.dependencies?.["@kosdev-code/kos-ui-cli"]?.version;
+    } catch (error) {
+      // Not installed globally
+    }
+  }
+
+  return version || "unknown";
+}
+
+export default async function (plop) {
+  plop.setActionType("showVersions", async function () {
+    console.log("[kos-cli] Discovering version information...\n");
+
+    const isWorkspace = await detectWorkspace();
+    const workspaceRoot = findWorkspaceRoot();
+
+    const versions = {};
+
+    // Get CLI version
+    versions.cli = getCliVersion();
+
+    if (isWorkspace && workspaceRoot) {
+      // Get SDK versions from workspace dependencies
+      const sdkPackages = {
+        sdk: ["@kosdev-code/kos-ui-sdk", "@kosdev-code/kos-dispense-sdk"],
+        ddk: [
+          "@kosdev-code/kos-ddk-components",
+          "@kosdev-code/kos-ddk-model-components",
+        ],
+      };
+
+      for (const [type, packages] of Object.entries(sdkPackages)) {
+        for (const pkgName of packages) {
+          try {
+            const output = execSync(`npm list ${pkgName} --depth=0 --json`, {
+              cwd: workspaceRoot,
+              encoding: "utf-8",
+              stdio: ["pipe", "pipe", "ignore"],
+            });
+            const data = JSON.parse(output);
+            const version = data?.dependencies?.[pkgName]?.version;
+            if (version) {
+              // Store with short name (without @kosdev-code/ prefix)
+              const shortName = pkgName.replace("@kosdev-code/", "");
+              versions[shortName] = version;
+            }
+          } catch (error) {
+            // Package not installed in workspace
+          }
+        }
+      }
+    }
+
+    // Display results
+    console.log("Version Information:");
+    console.log("===================\n");
+
+    if (versions.cli) {
+      console.log(`kos-ui-cli: ${versions.cli}`);
+    } else {
+      console.log("kos-ui-cli: unknown");
+    }
+
+    if (isWorkspace) {
+      console.log("");
+      console.log("SDK Packages:");
+      console.log("-------------");
+
+      if (versions["kos-ui-sdk"]) {
+        console.log(`kos-ui-sdk: ${versions["kos-ui-sdk"]}`);
+      }
+
+      if (versions["kos-dispense-sdk"]) {
+        console.log(`kos-dispense-sdk: ${versions["kos-dispense-sdk"]}`);
+      }
+
+      console.log("");
+      console.log("DDK Packages:");
+      console.log("-------------");
+
+      if (versions["kos-ddk-components"]) {
+        console.log(`kos-ddk-components: ${versions["kos-ddk-components"]}`);
+      }
+
+      if (versions["kos-ddk-model-components"]) {
+        console.log(
+          `kos-ddk-model-components: ${versions["kos-ddk-model-components"]}`
+        );
+      }
+
+      if (!versions["kos-ui-sdk"] && !versions["kos-dispense-sdk"]) {
+        console.log("(No SDK packages found in workspace)");
+      }
+
+      if (
+        !versions["kos-ddk-components"] &&
+        !versions["kos-ddk-model-components"]
+      ) {
+        console.log("(No DDK packages found in workspace)");
+      }
+    } else {
+      console.log("\n(Not in workspace - SDK versions unavailable)");
+    }
+
+    return "\n";
+  });
+
+  plop.setGenerator("version", {
+    description: "Display CLI and SDK version information",
+    prompts: [],
+    actions: () => [{ type: "showVersions" }],
+  });
+}

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

@@ -1,5 +1,5 @@
 // generators/workspace/index.mjs
-import { createWorkspace } from "create-nx-workspace";
+// Note: create-nx-workspace is imported lazily to avoid dependency errors
 import { required } from "../../utils/validators.mjs";
 import registerListModels from "./list-models.mjs";
 import registerListProjects from "./list-projects.mjs";
@@ -9,14 +9,18 @@ export const metadata = {
   name: "Create a new KOS UI Workspace",
   namedArguments: {
     name: "workspaceName",
-    workspaceName: "workspaceName"
+    workspaceName: "workspaceName",
+    enablePlugins: "enablePlugins"
   }
 };
 export default async function (plop) {
   plop.setActionType("createWorkspace", async function (answers) {
+    // Lazy import to avoid dependency errors when not using workspace generator
+    const { createWorkspace } = await import("create-nx-workspace");
     await createWorkspace("@kosdev-code/kos-nx-plugin", {
       nxCloud: "skip",
       name: answers.workspaceName,
+      enablePlugins: answers.enablePlugins,
     });
     return `Workspace ${answers.workspaceName} created.`;
   });
@@ -30,10 +34,16 @@ export default async function (plop) {
         message: "Enter the workspace name",
         validate: required,
       },
+      {
+        type: "confirm",
+        name: "enablePlugins",
+        message: "Do you want to enable plugin support?",
+        default: true,
+      },
     ],
     actions: () => [{ type: "createWorkspace" }],
   });
-  
+
   // Register additional workspace generators
   await registerListModels(plop);
   await registerListProjects(plop);

package/src/lib/plopfile.mjs

@@ -12,8 +12,14 @@ import registerKosModel from "./generators/model/model.mjs";
 import registerComponent from "./generators/component/index.mjs";
 import registerPluginComponent from "./generators/plugin/index.mjs";
 
+import registerApiGenerate from "./generators/api/generate.mjs";
+import registerApiCompare from "./generators/api/compare.mjs";
 import registerCacheGenerators from "./generators/cache/index.mjs";
+import registerDev from "./generators/dev/index.mjs";
 import registerEnv from "./generators/env/index.mjs";
+import registerKab from "./generators/kab/index.mjs";
+import registerServe from "./generators/serve/index.mjs";
+import registerVersion from "./generators/version/index.mjs";
 import registerI18nNamespace from "./generators/i18n/namespace.mjs";
 import registerUiProject from "./generators/project/app.mjs";
 import registerContentProject from "./generators/project/content.mjs";
@@ -56,6 +62,12 @@ export default async function (plop) {
   await registerSplashProject(plop);
   await registerI18n(plop);
   await registerI18nNamespace(plop);
+  await registerApiGenerate(plop);
+  await registerApiCompare(plop);
+  await registerDev(plop);
   await registerEnv(plop);
+  await registerKab(plop);
+  await registerServe(plop);
+  await registerVersion(plop);
   await registerCacheGenerators(plop);
 }

package/src/lib/utils/cli-help-display.mjs

@@ -0,0 +1,84 @@
+/**
+ * CLI help display utilities
+ *
+ * High-level help display functions for the KOS CLI. Coordinates the display
+ * of generator-specific help and general CLI help using utilities from
+ * cli-help-utils.mjs.
+ *
+ * @module cli-help-display
+ */
+import { displayExamples, displayNamedArguments } from "./cli-help-utils.mjs";
+
+/**
+ * Display comprehensive help information for a specific generator.
+ *
+ * Shows the generator's name, description, named arguments mapping, and
+ * usage examples. This provides users with all the information needed to
+ * use a specific CLI command effectively.
+ *
+ * @param {string} command - The command name (e.g., 'model', 'api:generate')
+ * @param {Object} meta - Generator metadata from the generator's export
+ * @param {string} meta.name - Display name for the generator
+ * @param {string} meta.description - Brief description of what the generator does
+ * @param {Object} meta.namedArguments - Mapping of CLI args to prompt names
+ * @param {Object} [generator=null] - Optional plop generator object (fallback for metadata)
+ *
+ * @example
+ * displayGeneratorHelp('api:generate', {
+ *   name: 'Generate OpenAPI service types',
+ *   description: 'Generate typed service helpers from OpenAPI specifications',
+ *   namedArguments: { project: 'project', host: 'host' }
+ * })
+ */
+export function displayGeneratorHelp(command, meta, generator = null) {
+  console.log(`--- ${meta?.name || command} Help ---`);
+  console.log(
+    meta?.description || generator?.description || "No description available"
+  );
+
+  displayNamedArguments(meta?.namedArguments);
+  displayExamples(command, meta?.namedArguments);
+}
+
+/**
+ * Display general CLI help showing all available generators and global options.
+ *
+ * Outputs a comprehensive overview of the KOS CLI including:
+ * - List of all available generators with descriptions
+ * - General usage pattern
+ * - Global options that apply to all commands
+ * - Help invocation instructions
+ *
+ * This is displayed when users run `kosui --help` or `kosui` with no command.
+ *
+ * @param {Object} plop - The plop instance containing registered generators
+ *
+ * @example
+ * displayGeneralHelp(plopInstance)
+ * // Outputs:
+ * // --- KOS CLI Help ---
+ * //
+ * // Available Generators:
+ * // - model: Generate KOS models
+ * // - api:generate: Generate OpenAPI service types
+ * // ...
+ */
+export function displayGeneralHelp(plop) {
+  console.warn("--- KOS CLI Help ---");
+  console.log("\nAvailable Generators:");
+  plop.getGeneratorList().forEach((g) => {
+    console.log(`- ${g.name}: ${g.description}`);
+  });
+
+  console.log("\nUsage:");
+  console.log("  kosui <generator> [options]");
+  console.log("  kosui <generator> --help  # Show generator-specific help");
+  console.log("\nGlobal Options:");
+  console.log("  --no-cache      Disable cache");
+  console.log("  --refresh       Clear cache and refresh");
+  console.log("  --quiet         Suppress banner and debug output");
+  console.log(
+    "  --interactive, -i   Force interactive mode (ignore provided arguments)"
+  );
+  console.log("  --help          Show this help");
+}