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

package/src/lib/cli.mjs

@@ -1,14 +1,11 @@
 #!/usr/bin/env node
-import chalk from "chalk";
 import figlet from "figlet";
 import minimist from "minimist";
 import nodePlop from "node-plop";
 import path, { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { clearCache } from "./utils/cache.mjs";
-import { buildNonInteractiveCommand, isRunningInteractively } from "./utils/command-builder.mjs";
 import { getGeneratorMetadata } from "./utils/generator-loader.mjs";
-import { displayGeneralHelp, displayGeneratorHelp } from "./utils/cli-help-display.mjs";
 
 const originalArgs = process.argv.slice(2);
 const parsedArgs = minimist(originalArgs);
@@ -38,47 +35,6 @@ const configPath = path.join(__dirname, "plopfile.mjs");
 const showBanner =
   command !== "help" && process.env.DISABLE_CLI_BANNER !== "true";
 
-/**
- * Parse CLI argument values, handling booleans, JSON, key=value pairs, and repeated arguments
- * @param {*} value - The raw argument value from minimist
- * @returns {*} - The parsed value (boolean, object, or original value)
- */
-function parseArgumentValue(value) {
-  // Convert string boolean values to actual booleans
-  if (value === "true" || value === "y" || value === "yes") {
-    return true;
-  } else if (value === "false" || value === "n" || value === "no") {
-    return false;
-  } else if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
-    // Try to parse JSON for complex arguments like --app-version='{"ice-app":"v2"}'
-    try {
-      return JSON.parse(value);
-    } catch (e) {
-      // If JSON parsing fails, keep as string
-      return value;
-    }
-  } else if (Array.isArray(value)) {
-    // Handle repeated arguments like --app-version ice-app=v2 --app-version apc=v3
-    // Minimist stores repeated args as arrays
-    const parsedObject = {};
-    value.forEach(item => {
-      if (typeof item === 'string' && item.includes('=')) {
-        const [key, val] = item.split('=');
-        parsedObject[key.trim()] = val.trim();
-      }
-    });
-    return Object.keys(parsedObject).length > 0 ? parsedObject : value;
-  } else if (typeof value === "string" && value.includes("=")) {
-    // Handle single key=value format like --app-version ice-app=v2
-    const parsedObject = {};
-    const [key, val] = value.split('=');
-    parsedObject[key.trim()] = val.trim();
-    return parsedObject;
-  }
-
-  return value;
-}
-
 async function launch() {
   // Check for help modes before initializing plop to avoid expensive model parsing
   const shouldShowHelp = parsedArgs.help;
@@ -86,7 +42,25 @@ async function launch() {
   if (!command || command === "help") {
     // For general help, we still need plop to list generators
     const plop = await nodePlop(configPath);
-    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");
+
     return;
   }
 
@@ -95,7 +69,151 @@ async function launch() {
     const earlyMeta = await getGeneratorMetadata(command);
 
     if (earlyMeta && Object.keys(earlyMeta).length > 0) {
-      displayGeneratorHelp(command, earlyMeta);
+      // Show help immediately for --help flag
+      console.log(`--- ${earlyMeta?.name || command} Help ---`);
+      console.log(earlyMeta.description || "No description available");
+
+      if (earlyMeta?.namedArguments) {
+        console.log("\nNamed Arguments:");
+        Object.entries(earlyMeta.namedArguments).forEach(
+          ([cliArg, promptName]) => {
+            console.log(`  --${cliArg}    Maps to prompt: ${promptName}`);
+          }
+        );
+      }
+
+      console.log("\nExamples:");
+
+      // Generate examples dynamically from the generator's named arguments
+      if (earlyMeta?.namedArguments) {
+        const args = Object.keys(earlyMeta.namedArguments);
+
+        // Generate example values based on argument names
+        const generateExampleValue = (argName) => {
+          switch (argName) {
+            case "name":
+            case "componentName":
+              return command.includes("plugin") ? "MyPlugin" : "MyComponent";
+            case "modelName":
+              return "my-model";
+            case "workspaceName":
+              return "my-workspace";
+            case "project":
+            case "componentProject":
+            case "modelProject":
+              return "my-ui-lib";
+            case "registrationProject":
+              return "my-lib";
+            case "companionParent":
+              return "parent-model";
+            case "extensionPoint":
+              return "utility";
+            case "group":
+              return "appearance";
+            case "locale":
+              return "en";
+            case "container":
+            case "singleton":
+            case "parentAware":
+            case "dataServices":
+              return true;
+            case "dryRun":
+              return true;
+            default:
+              return `my-${argName}`;
+          }
+        };
+
+        // Create basic example with most important arguments
+        const basicArgs = [];
+        const booleanArgs = [
+          "container",
+          "singleton",
+          "parentAware",
+          "dataServices",
+          "dryRun",
+        ];
+
+        // Pick the most relevant arguments for each generator type
+        const getRelevantArgs = (args, command) => {
+          const relevantArgs = [];
+
+          // Always prefer name-type arguments first
+          const nameArgs = [
+            "name",
+            "componentName",
+            "modelName",
+            "workspaceName",
+          ].filter((arg) => args.includes(arg));
+          if (nameArgs.length > 0) {
+            relevantArgs.push(nameArgs[0]); // Take the first name argument
+          }
+
+          // Then add project-type arguments
+          const projectArgs = [
+            "project",
+            "componentProject",
+            "modelProject",
+            "registrationProject",
+          ].filter((arg) => args.includes(arg));
+          if (projectArgs.length > 0) {
+            relevantArgs.push(projectArgs[0]); // Take the first project argument
+          }
+
+          // Add other specific arguments
+          const otherArgs = args.filter(
+            (arg) =>
+              !nameArgs.includes(arg) &&
+              !projectArgs.includes(arg) &&
+              !booleanArgs.includes(arg) &&
+              arg !== "interactive"
+          );
+
+          // Add up to 2 more relevant arguments
+          relevantArgs.push(...otherArgs.slice(0, 2));
+
+          return relevantArgs;
+        };
+
+        const relevantArgs = getRelevantArgs(args, command);
+
+        relevantArgs.forEach((argName) => {
+          const value = generateExampleValue(argName);
+          basicArgs.push(`--${argName} ${value}`);
+        });
+
+        // Create advanced example with boolean flags
+        const advancedBooleanArgs = [];
+        booleanArgs.forEach((argName) => {
+          if (args.includes(argName)) {
+            advancedBooleanArgs.push(`--${argName}`);
+          }
+        });
+
+        // Show basic example
+        if (basicArgs.length > 0) {
+          console.log(`  kosui ${command} ${basicArgs.join(" ")}`);
+        }
+
+        // Show advanced example with boolean flags if any exist
+        if (basicArgs.length > 0 && advancedBooleanArgs.length > 0) {
+          console.log(
+            `  kosui ${command} ${basicArgs
+              .slice(0, 2)
+              .join(" ")} ${advancedBooleanArgs.join(" ")}`
+          );
+        }
+
+        // If no basic args, show a minimal example
+        if (basicArgs.length === 0) {
+          console.log(`  kosui ${command} [options]`);
+        }
+      }
+
+      console.log(`  kosui ${command} --interactive  # Force interactive mode`);
+      console.log(
+        `  kosui ${command} -i             # Force interactive mode (short form)`
+      );
       return;
     }
   }
@@ -108,7 +226,13 @@ async function launch() {
     Object.entries(namedArgumentsMap).forEach(([cliArg, promptName]) => {
       if (cliArg === "interactive") return;
       if (parsedArgs[cliArg] !== undefined) {
-        providedAnswers[promptName] = parseArgumentValue(parsedArgs[cliArg]);
+        let value = parsedArgs[cliArg];
+        if (value === "true" || value === "y" || value === "yes") {
+          value = true;
+        } else if (value === "false" || value === "n" || value === "no") {
+          value = false;
+        }
+        providedAnswers[promptName] = value;
       }
     });
     const hasAnyAnswers = Object.keys(providedAnswers).length > 0;
@@ -116,7 +240,150 @@ async function launch() {
 
     // Show help for no-arguments case
     if (!hasAnyAnswers && !forceInteractive) {
-      displayGeneratorHelp(command, earlyMeta);
+      console.log(`--- ${earlyMeta?.name || command} Help ---`);
+      console.log(earlyMeta.description || "No description available");
+
+      if (earlyMeta?.namedArguments) {
+        console.log("\nNamed Arguments:");
+        Object.entries(earlyMeta.namedArguments).forEach(
+          ([cliArg, promptName]) => {
+            console.log(`  --${cliArg}    Maps to prompt: ${promptName}`);
+          }
+        );
+      }
+
+      console.log("\nExamples:");
+
+      // Generate examples dynamically from the generator's named arguments
+      if (earlyMeta?.namedArguments) {
+        const args = Object.keys(earlyMeta.namedArguments);
+
+        // Generate example values based on argument names
+        const generateExampleValue = (argName) => {
+          switch (argName) {
+            case "name":
+            case "componentName":
+              return command.includes("plugin") ? "MyPlugin" : "MyComponent";
+            case "modelName":
+              return "my-model";
+            case "workspaceName":
+              return "my-workspace";
+            case "project":
+            case "componentProject":
+            case "modelProject":
+              return "my-ui-lib";
+            case "registrationProject":
+              return "my-lib";
+            case "companionParent":
+              return "parent-model";
+            case "extensionPoint":
+              return "utility";
+            case "group":
+              return "appearance";
+            case "locale":
+              return "en";
+            case "container":
+            case "singleton":
+            case "parentAware":
+            case "dataServices":
+              return true;
+            case "dryRun":
+              return true;
+            default:
+              return `my-${argName}`;
+          }
+        };
+
+        // Create basic example with most important arguments
+        const basicArgs = [];
+        const booleanArgs = [
+          "container",
+          "singleton",
+          "parentAware",
+          "dataServices",
+          "dryRun",
+        ];
+
+        // Pick the most relevant arguments for each generator type
+        const getRelevantArgs = (args, command) => {
+          const relevantArgs = [];
+
+          // Always prefer name-type arguments first
+          const nameArgs = [
+            "name",
+            "componentName",
+            "modelName",
+            "workspaceName",
+          ].filter((arg) => args.includes(arg));
+          if (nameArgs.length > 0) {
+            relevantArgs.push(nameArgs[0]); // Take the first name argument
+          }
+
+          // Then add project-type arguments
+          const projectArgs = [
+            "project",
+            "componentProject",
+            "modelProject",
+            "registrationProject",
+          ].filter((arg) => args.includes(arg));
+          if (projectArgs.length > 0) {
+            relevantArgs.push(projectArgs[0]); // Take the first project argument
+          }
+
+          // Add other specific arguments
+          const otherArgs = args.filter(
+            (arg) =>
+              !nameArgs.includes(arg) &&
+              !projectArgs.includes(arg) &&
+              !booleanArgs.includes(arg) &&
+              arg !== "interactive"
+          );
+
+          // Add up to 2 more relevant arguments
+          relevantArgs.push(...otherArgs.slice(0, 2));
+
+          return relevantArgs;
+        };
+
+        const relevantArgs = getRelevantArgs(args, command);
+
+        relevantArgs.forEach((argName) => {
+          const value = generateExampleValue(argName);
+          basicArgs.push(`--${argName} ${value}`);
+        });
+
+        // Create advanced example with boolean flags
+        const advancedBooleanArgs = [];
+        booleanArgs.forEach((argName) => {
+          if (args.includes(argName)) {
+            advancedBooleanArgs.push(`--${argName}`);
+          }
+        });
+
+        // Show basic example
+        if (basicArgs.length > 0) {
+          console.log(`  kosui ${command} ${basicArgs.join(" ")}`);
+        }
+
+        // Show advanced example with boolean flags if any exist
+        if (basicArgs.length > 0 && advancedBooleanArgs.length > 0) {
+          console.log(
+            `  kosui ${command} ${basicArgs
+              .slice(0, 2)
+              .join(" ")} ${advancedBooleanArgs.join(" ")}`
+          );
+        }
+
+        // If no basic args, show a minimal example
+        if (basicArgs.length === 0) {
+          console.log(`  kosui ${command} [options]`);
+        }
+      }
+
+      console.log(`  kosui ${command} --interactive  # Force interactive mode`);
+      console.log(
+        `  kosui ${command} -i             # Force interactive mode (short form)`
+      );
       return;
     }
   }
@@ -165,7 +432,16 @@ async function launch() {
       }
 
       if (parsedArgs[cliArg] !== undefined) {
-        providedAnswers[promptName] = parseArgumentValue(parsedArgs[cliArg]);
+        let value = parsedArgs[cliArg];
+
+        // Convert string boolean values to actual booleans
+        if (value === "true" || value === "y" || value === "yes") {
+          value = true;
+        } else if (value === "false" || value === "n" || value === "no") {
+          value = false;
+        }
+
+        providedAnswers[promptName] = value;
       }
     });
 
@@ -200,7 +476,148 @@ async function launch() {
 
     // If no arguments provided and no interactive flag, show help
     if (!hasAnyAnswers && !forceInteractive) {
-      displayGeneratorHelp(command, meta, generator);
+      console.log(`--- ${meta?.name || command} Help ---`);
+      console.log(generator.description || "No description available");
+
+      if (meta?.namedArguments) {
+        console.log("\nNamed Arguments:");
+        Object.entries(meta.namedArguments).forEach(([cliArg, promptName]) => {
+          console.log(`  --${cliArg}    Maps to prompt: ${promptName}`);
+        });
+      }
+
+      console.log("\nExamples:");
+
+      // Generate examples dynamically from the generator's named arguments
+      if (meta?.namedArguments) {
+        const args = Object.keys(meta.namedArguments);
+
+        // Generate example values based on argument names
+        const generateExampleValue = (argName) => {
+          switch (argName) {
+            case "name":
+            case "componentName":
+              return command.includes("plugin") ? "MyPlugin" : "MyComponent";
+            case "modelName":
+              return "my-model";
+            case "workspaceName":
+              return "my-workspace";
+            case "project":
+            case "componentProject":
+            case "modelProject":
+              return "my-ui-lib";
+            case "registrationProject":
+              return "my-lib";
+            case "companionParent":
+              return "parent-model";
+            case "extensionPoint":
+              return "utility";
+            case "group":
+              return "appearance";
+            case "locale":
+              return "en";
+            case "container":
+            case "singleton":
+            case "parentAware":
+            case "dataServices":
+              return true;
+            case "dryRun":
+              return true;
+            default:
+              return `my-${argName}`;
+          }
+        };
+
+        // Create basic example with most important arguments
+        const basicArgs = [];
+        const booleanArgs = [
+          "container",
+          "singleton",
+          "parentAware",
+          "dataServices",
+          "dryRun",
+        ];
+
+        // Pick the most relevant arguments for each generator type
+        const getRelevantArgs = (args, command) => {
+          const relevantArgs = [];
+
+          // Always prefer name-type arguments first
+          const nameArgs = [
+            "name",
+            "componentName",
+            "modelName",
+            "workspaceName",
+          ].filter((arg) => args.includes(arg));
+          if (nameArgs.length > 0) {
+            relevantArgs.push(nameArgs[0]); // Take the first name argument
+          }
+
+          // Then add project-type arguments
+          const projectArgs = [
+            "project",
+            "componentProject",
+            "modelProject",
+            "registrationProject",
+          ].filter((arg) => args.includes(arg));
+          if (projectArgs.length > 0) {
+            relevantArgs.push(projectArgs[0]); // Take the first project argument
+          }
+
+          // Add other specific arguments
+          const otherArgs = args.filter(
+            (arg) =>
+              !nameArgs.includes(arg) &&
+              !projectArgs.includes(arg) &&
+              !booleanArgs.includes(arg) &&
+              arg !== "interactive"
+          );
+
+          // Add up to 2 more relevant arguments
+          relevantArgs.push(...otherArgs.slice(0, 2));
+
+          return relevantArgs;
+        };
+
+        const relevantArgs = getRelevantArgs(args, command);
+
+        relevantArgs.forEach((argName) => {
+          const value = generateExampleValue(argName);
+          basicArgs.push(`--${argName} ${value}`);
+        });
+
+        // Create advanced example with boolean flags
+        const advancedBooleanArgs = [];
+        booleanArgs.forEach((argName) => {
+          if (args.includes(argName)) {
+            advancedBooleanArgs.push(`--${argName}`);
+          }
+        });
+
+        // Show basic example
+        if (basicArgs.length > 0) {
+          console.log(`  kosui ${command} ${basicArgs.join(" ")}`);
+        }
+
+        // Show advanced example with boolean flags if any exist
+        if (basicArgs.length > 0 && advancedBooleanArgs.length > 0) {
+          console.log(
+            `  kosui ${command} ${basicArgs
+              .slice(0, 2)
+              .join(" ")} ${advancedBooleanArgs.join(" ")}`
+          );
+        }
+
+        // If no basic args, show a minimal example
+        if (basicArgs.length === 0) {
+          console.log(`  kosui ${command} [options]`);
+        }
+      }
+
+      console.log(`  kosui ${command} --interactive  # Force interactive mode`);
+      console.log(
+        `  kosui ${command} -i             # Force interactive mode (short form)`
+      );
       return;
     }
 
@@ -355,15 +772,6 @@ async function launch() {
     results.failures.forEach((fail) => {
       console.error(fail.error || fail.message);
     });
-
-    // Output equivalent non-interactive command when running interactively
-    if (isRunningInteractively(parsedArgs, hasAnyAnswers) && results.failures.length === 0 && !hasQuiet) {
-      const commandString = buildNonInteractiveCommand(command, answers, meta);
-      if (commandString) {
-        console.log(chalk.cyan("\n[kos-cli] Equivalent non-interactive command:"));
-        console.log(chalk.green(`  ${commandString}`));
-      }
-    }
   } catch (err) {
     console.error("[kos-cli] Generator run failed:", err.message);
     process.exit(1);

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

@@ -8,7 +8,6 @@ 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);