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

package/src/lib/cli.mjs

@@ -0,0 +1,803 @@
+#!/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";
+
+const originalArgs = process.argv.slice(2);
+const parsedArgs = minimist(originalArgs);
+const command = parsedArgs._[0] || "help";
+
+const customFlags = ["--no-cache", "--refresh", "--quiet"];
+const hasNoCache = originalArgs.includes("--no-cache");
+const hasRefresh = originalArgs.includes("--refresh");
+const hasQuiet = originalArgs.includes("--quiet");
+
+if (hasNoCache || hasRefresh) {
+  process.env.DISABLE_CACHE = "true";
+  if (!hasQuiet) {
+    console.log("[kos-cli] Cache disabled or refresh forced. Clearing cache...");
+  }
+  clearCache();
+}
+
+if (hasQuiet) {
+  process.env.DISABLE_CLI_BANNER = "true";
+  process.env.KOS_CLI_QUIET = "true";
+}
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const configPath = path.join(__dirname, "plopfile.mjs");
+
+const showBanner =
+  command !== "help" && process.env.DISABLE_CLI_BANNER !== "true";
+
+async function launch() {
+  // Check for help modes before initializing plop to avoid expensive model parsing
+  const shouldShowHelp = parsedArgs.help;
+
+  if (!command || command === "help") {
+    // For general help, we still need plop to list generators
+    const plop = await nodePlop(configPath);
+
+    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;
+  }
+
+  // For generator-specific help, check if we can show help without full plop initialization
+  if (shouldShowHelp) {
+    const earlyMeta = await getGeneratorMetadata(command);
+
+    if (earlyMeta && Object.keys(earlyMeta).length > 0) {
+      // 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;
+    }
+  }
+
+  // Also check for no-arguments case (when only global flags like --no-cache are present)
+  const earlyMeta = await getGeneratorMetadata(command);
+  if (earlyMeta?.namedArguments) {
+    const namedArgumentsMap = earlyMeta.namedArguments;
+    const providedAnswers = {};
+    Object.entries(namedArgumentsMap).forEach(([cliArg, promptName]) => {
+      if (cliArg === "interactive") return;
+      if (parsedArgs[cliArg] !== undefined) {
+        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;
+    const forceInteractive = parsedArgs.interactive || parsedArgs.i;
+
+    // Show help for no-arguments case
+    if (!hasAnyAnswers && !forceInteractive) {
+      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;
+    }
+  }
+
+  const plop = await nodePlop(configPath);
+
+  plop.setActionType("clearCache", (answers, config, plop) => {
+    clearCache();
+    return "[ok] CLI cache cleared successfully.";
+  });
+
+  const generator = plop.getGenerator(command);
+
+  if (!generator) {
+    console.error(`[kos-cli] Generator "${command}" not found.`);
+    process.exit(1);
+  }
+
+  const meta = await getGeneratorMetadata(command);
+
+  if (showBanner && !hasQuiet) {
+    console.log(`--- Running KOS Generator: ${meta?.name || command} ---`);
+  }
+
+  try {
+    // Extract positional arguments for prompt bypass
+    const positionalArgs = parsedArgs._.slice(1); // Remove command from args
+
+    // Get named arguments mapping from generator metadata
+    const namedArgumentsMap = meta?.namedArguments || {};
+
+    // Convert CLI args to answer format using generator's mapping
+    const providedAnswers = {};
+
+    // Ensure we have the metadata with named arguments
+    if (!namedArgumentsMap || Object.keys(namedArgumentsMap).length === 0) {
+      console.warn(
+        `[kos-cli] Warning: No named arguments mapping found for generator '${command}'`
+      );
+    }
+
+    Object.entries(namedArgumentsMap).forEach(([cliArg, promptName]) => {
+      // Skip 'interactive' - it's handled as a special CLI flag, not a prompt argument
+      if (cliArg === "interactive") {
+        return;
+      }
+
+      if (parsedArgs[cliArg] !== undefined) {
+        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;
+      }
+    });
+
+    // Also handle positional arguments
+    const prompts = generator.prompts || [];
+    positionalArgs.forEach((arg, index) => {
+      if (prompts[index] && !prompts[index].when) {
+        // Only non-conditional prompts
+        const promptName = prompts[index].name;
+        if (providedAnswers[promptName] === undefined) {
+          let value = arg;
+
+          // 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;
+        }
+      }
+    });
+
+    // Check if we have ANY provided answers
+    const hasAnyAnswers = Object.keys(providedAnswers).length > 0;
+
+    let answers;
+
+    // Check if user wants to force interactive mode
+    const forceInteractive = parsedArgs.interactive || parsedArgs.i;
+
+    // If no arguments provided and no interactive flag, show help
+    if (!hasAnyAnswers && !forceInteractive) {
+      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;
+    }
+
+    if (hasAnyAnswers && !forceInteractive) {
+      // Create bypass array for all prompts
+      const bypassArgs = [];
+
+      // Fill bypass array with provided values or defaults
+      for (const prompt of prompts) {
+        if (prompt.when) {
+          // Skip conditional prompts - they can't be bypassed
+          continue;
+        }
+
+        const providedValue = providedAnswers[prompt.name];
+        if (providedValue !== undefined) {
+          bypassArgs.push(providedValue);
+        } else {
+          // Check for workspace defaults for project-type prompts
+          let defaultValue = prompt.default;
+
+          // Use workspace defaults for project selection prompts
+          if (
+            prompt.name &&
+            (prompt.name.includes("Project") || prompt.name === "project")
+          ) {
+            const { getDefaultProjectForType } = await import(
+              "./utils/nx-context.mjs"
+            );
+
+            // Determine project type based on command
+            let projectType = null;
+            if (command === "model" || command.startsWith("model:")) {
+              projectType = "model";
+            } else if (command === "component") {
+              projectType = "model-component";
+            } else if (command === "i18n:namespace") {
+              projectType = "i18n";
+            } else if (command.startsWith("plugin")) {
+              projectType = "plugin";
+            }
+
+            if (projectType) {
+              const workspaceDefault = await getDefaultProjectForType(
+                projectType
+              );
+              if (workspaceDefault) {
+                defaultValue = workspaceDefault;
+              }
+            }
+          }
+
+          // For required project prompts without a default value, we can't bypass - need to show help
+          if (
+            defaultValue === undefined &&
+            (prompt.name === "modelProject" ||
+              prompt.name === "project" ||
+              prompt.name === "componentProject" ||
+              prompt.name === "registrationProject")
+          ) {
+            // Can't bypass required project prompts without a value - show help instead
+            console.log(
+              `\nError: Missing required argument '--project' (no default project configured)`
+            );
+            console.log(`\n--- ${meta?.name || command} Help ---`);
+            console.log(meta.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("\nTo fix this, you can:");
+            console.log(
+              "1. Specify a project: kosui " +
+                command +
+                " --name MyModel --project my-model-lib"
+            );
+            console.log(
+              "2. Configure a default in .kos.json at the workspace root:"
+            );
+            console.log(
+              '   { "type": "root", "generator": { "defaults": { "model": "my-default-project" } } }'
+            );
+            console.log(
+              "3. Run in interactive mode: kosui " + command + " --interactive"
+            );
+
+            process.exit(1);
+          }
+
+          // Use default value or skip with "_"
+          bypassArgs.push(defaultValue !== undefined ? defaultValue : "_");
+        }
+      }
+
+      // Only bypass if we have all non-conditional prompts
+      const nonConditionalPrompts = prompts.filter((p) => !p.when);
+      // Debug: Check if we're trying to bypass with "_" for required fields
+      const hasInvalidBypass = bypassArgs.includes("_");
+      if (hasInvalidBypass) {
+        console.log(
+          "[kos-cli] Cannot bypass prompts - missing required values"
+        );
+        // Fall back to interactive mode
+        console.log(
+          "Note: Running interactive mode. Your provided arguments will be applied automatically."
+        );
+        answers = await generator.runPrompts();
+        Object.assign(answers, providedAnswers);
+      } else if (bypassArgs.length === nonConditionalPrompts.length) {
+        // We can bypass all non-conditional prompts
+        answers = await generator.runPrompts(bypassArgs);
+
+        // Add any conditional prompt values that were provided
+        Object.assign(answers, providedAnswers);
+      } else {
+        // Fall back to interactive mode
+        console.log(
+          "Note: Running interactive mode. Your provided arguments will be applied automatically."
+        );
+        answers = await generator.runPrompts();
+        Object.assign(answers, providedAnswers);
+      }
+    } else {
+      // Run prompts interactively
+      if (forceInteractive) {
+        console.log(
+          "Note: Running in interactive mode. All prompts will be shown."
+        );
+
+        // In interactive mode, ignore provided arguments and run all prompts
+        answers = await generator.runPrompts();
+      } else {
+        answers = await generator.runPrompts();
+      }
+    }
+
+    const results = await generator.runActions(answers);
+
+    if (!hasQuiet) {
+      console.log("[kos-cli] Generator completed successfully!");
+      results.changes.forEach((result) => {
+        console.log(result.path || result.message);
+      });
+    }
+
+    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);
+  }
+}
+
+if (showBanner) {
+  figlet("KOS CLI", function (err, data) {
+    if (err) {
+      console.error("Figlet failed:", err);
+      return launch(); // even if figlet fails, run!
+    }
+    console.log(data);
+    launch();
+  });
+} else {
+  launch();
+}