@kosdev-code/kos-ui-cli 2.0.41 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kosdev-code/kos-ui-cli",
-  "version": "2.0.41",
+  "version": "2.1.1",
   "bin": {
     "kosui": "./src/lib/cli.mjs"
   },
@@ -9,6 +9,7 @@
   ],
   "type": "module",
   "dependencies": {
+    "chalk": "^5.3.0",
     "prettier": "^2.6.2",
     "rimraf": "^5.0.1",
     "plop": "^3.1.2",
@@ -20,7 +21,7 @@
   "main": "./src/index.js",
   "kos": {
     "build": {
-      "gitHash": "82f501e94dcc050e3ec05bb9fd68f2671112823d"
+      "gitHash": "8f34a7c5827b814dc09dd2bcbf41c9195d8b3437"
     }
   },
   "publishConfig": {

package/src/lib/cli.mjs

@@ -1,10 +1,12 @@
 #!/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);
@@ -772,6 +774,15 @@ 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/model/add-future.mjs

@@ -20,13 +20,29 @@ export const metadata = {
 };
 
 export default async function (plop) {
-  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("addFutureToModel", async function (answers) {
+    const allModels = await getAllModels();
     const modelProject = allModels.find(
       (m) => m.model === answers.modelName
     )?.project;

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/utils/command-builder.mjs

@@ -0,0 +1,94 @@
+/**
+ * Builds a non-interactive command string from interactive session answers
+ * This helps users understand how to run the same command without prompts
+ */
+
+/**
+ * Converts interactive prompt answers back to CLI command arguments
+ * @param {string} command - The generator command name
+ * @param {Object} answers - The answers collected from prompts
+ * @param {Object} meta - Generator metadata including namedArguments mapping
+ * @returns {string|null} The equivalent CLI command string, or null if cannot be built
+ */
+export function buildNonInteractiveCommand(command, answers, meta) {
+  if (!meta?.namedArguments) {
+    return null;
+  }
+
+  const args = [`kosui ${command}`];
+  const reverseMap = {};
+
+  // Create reverse mapping from prompt names to CLI arguments
+  Object.entries(meta.namedArguments).forEach(([cliArg, promptName]) => {
+    // Skip special flags that don't map to prompts
+    if (cliArg !== "interactive" && cliArg !== "dryRun") {
+      reverseMap[promptName] = cliArg;
+    }
+  });
+
+  // Build command arguments from answers
+  Object.entries(answers).forEach(([promptName, value]) => {
+    const cliArg = reverseMap[promptName];
+    if (cliArg && value !== undefined && value !== null && value !== "") {
+      args.push(formatArgument(cliArg, value));
+    }
+  });
+
+  // Add dryRun if it was provided
+  if (answers.dryRun) {
+    args.push("--dryRun");
+  }
+
+  return args.join(" ");
+}
+
+/**
+ * Formats a single CLI argument based on its value type
+ * @param {string} argName - The CLI argument name
+ * @param {any} value - The value for the argument
+ * @returns {string} The formatted CLI argument string
+ */
+function formatArgument(argName, value) {
+  // Handle boolean values
+  if (typeof value === "boolean") {
+    if (value) {
+      return `--${argName}`;
+    } else {
+      // For false booleans, explicitly set to false
+      // This ensures the command can be replicated exactly
+      return `--${argName}=false`;
+    }
+  }
+
+  // Handle string/number values
+  const stringValue = String(value);
+
+  // Check if value needs escaping
+  if (needsEscaping(stringValue)) {
+    // Use double quotes and escape internal quotes
+    return `--${argName}="${stringValue.replace(/"/g, '\\"')}"`;
+  }
+
+  return `--${argName}=${stringValue}`;
+}
+
+/**
+ * Determines if a string value needs shell escaping
+ * @param {string} value - The value to check
+ * @returns {boolean} True if the value needs escaping
+ */
+function needsEscaping(value) {
+  // Check for characters that need escaping in shell
+  return /[\s'"$`\\!]/.test(value);
+}
+
+/**
+ * Determines if the CLI is running in interactive mode
+ * @param {Object} parsedArgs - Parsed command line arguments
+ * @param {boolean} hasAnyAnswers - Whether any answers were provided via CLI
+ * @returns {boolean} True if running in interactive mode
+ */
+export function isRunningInteractively(parsedArgs, hasAnyAnswers) {
+  const forceInteractive = parsedArgs.interactive || parsedArgs.i;
+  return forceInteractive || (!hasAnyAnswers && !parsedArgs.help);
+}