@kosdev-code/kos-ui-cli 2.0.31 → 2.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kosdev-code/kos-ui-cli",
-  "version": "2.0.31",
+  "version": "2.0.32",
   "bin": {
     "kosui": "./src/lib/cli.mjs"
   },
@@ -20,7 +20,7 @@
   "main": "./src/index.js",
   "kos": {
     "build": {
-      "gitHash": "d7b8c63a9bfe61bb6177f4e7628bbb17e3696c2b"
+      "gitHash": "ea8751ddd6a1c43f56f22bab3bf99a0e3bd3f824"
     }
   },
   "publishConfig": {

package/src/lib/cli.mjs

@@ -28,14 +28,13 @@ const showBanner =
   command !== "help" && process.env.DISABLE_CLI_BANNER !== "true";
 
 async function launch() {
-  const plop = await nodePlop(configPath);
-
-  plop.setActionType("clearCache", (answers, config, plop) => {
-    clearCache();
-    return "[ok] CLI cache cleared successfully.";
-  });
-
+  // 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) => {
@@ -56,139 +55,297 @@ async function launch() {
     return;
   }
 
-  const generator = plop.getGenerator(command);
-
-  if (!generator) {
-    console.error(`[kos-cli] Generator "${command}" not found.`);
-    process.exit(1);
-  }
-
-  const meta = await getGeneratorMetadata(command);
-
-  // Show generator-specific help if requested
-  if (parsedArgs.help) {
-    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:");
+  // For generator-specific help, check if we can show help without full plop initialization
+  if (shouldShowHelp) {
+    const earlyMeta = await getGeneratorMetadata(command);
     
-    // 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}`;
+    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}`);
+          });
         }
-      };
-      
-      // 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 = [];
+
+        console.log("\nExamples:");
         
-        // 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
-        }
+        // Generate examples dynamically from the generator's named arguments
+        if (earlyMeta?.namedArguments) {
+          const args = Object.keys(earlyMeta.namedArguments);
         
-        // 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
-        }
+        // 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}`;
+          }
+        };
         
-        // Add other specific arguments
-        const otherArgs = args.filter(arg => 
-          !nameArgs.includes(arg) && 
-          !projectArgs.includes(arg) && 
-          !booleanArgs.includes(arg) && 
-          arg !== 'interactive'
-        );
+        // Create basic example with most important arguments
+        const basicArgs = [];
+        const booleanArgs = ['container', 'singleton', 'parentAware', 'dataServices', 'dryRun'];
         
-        // Add up to 2 more relevant arguments
-        relevantArgs.push(...otherArgs.slice(0, 2));
+        // 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;
+        };
         
-        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}`);
+        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]`);
         }
-      });
-      
-      // 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(' ')}`);
+      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:");
       
-      // If no basic args, show a minimal example
-      if (basicArgs.length === 0) {
-        console.log(`  kosui ${command} [options]`);
+      // 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;
     }
-    
-    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) {
     console.log(`--- Running KOS Generator: ${meta?.name || command} ---`);
   }
@@ -251,6 +408,130 @@ async function launch() {
     // 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 = [];

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

@@ -0,0 +1,80 @@
+// 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) {
+  const allModels = await getAllModels();
+  const modelChoices = allModels.map((m) => ({
+    name: `${m.model} (${m.project})`,
+    value: m.model,
+  }));
+
+  plop.setActionType("addFutureToModel", async function (answers) {
+    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),
+  });
+}

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

@@ -6,7 +6,11 @@ import {
   getLibraryProjects,
   getProjectDetails,
 } from "../../utils/nx-context.mjs";
-import { DEFAULT_PROMPTS, MODEL_PROMPTS } from "../../utils/prompts.mjs";
+import {
+  COMPANION_PROMPTS,
+  DEFAULT_PROMPTS,
+  MODEL_PROMPTS,
+} from "../../utils/prompts.mjs";
 import { required } from "../../utils/validators.mjs";
 
 export const metadata = {
@@ -18,13 +22,14 @@ export const metadata = {
     project: "modelProject",
     modelProject: "modelProject",
     companionParent: "companionParent",
+    companionPattern: "companionPattern",
     container: "container",
     parentAware: "parentAware",
     singleton: "singleton",
     dataServices: "dataServices",
     dryRun: "dryRun",
-    interactive: "interactive"
-  }
+    interactive: "interactive",
+  },
 };
 
 export default async function (plop) {
@@ -52,6 +57,7 @@ export default async function (plop) {
       --companion=true \
       --companionModel=${answers.companionParent} \
       --companionModelProject=${companionProject} \
+      --companionPattern=${answers.companionPattern} \
       --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
 
     try {
@@ -84,6 +90,7 @@ export default async function (plop) {
         message: "Select the companion parent model",
         choices: modelChoices,
       },
+      ...COMPANION_PROMPTS,
       ...MODEL_PROMPTS,
     ],
     actions: actionFactory("createCompanionModel", metadata),

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

@@ -2,7 +2,6 @@
 import { actionFactory } from "../../utils/action-factory.mjs";
 import { execute } from "../../utils/exec.mjs";
 import {
-  getAllProjects,
   getLibraryProjects,
   getProjectDetails,
 } from "../../utils/nx-context.mjs";
@@ -22,13 +21,13 @@ export const metadata = {
     parentAware: "parentAware",
     singleton: "singleton",
     dataServices: "dataServices",
+    futureAware: "futureAware",
     dryRun: "dryRun",
     interactive: "interactive"
   }
 };
 
 export default async function (plop) {
-  const allProjects = await getAllProjects();
   const libraryProjects = await getLibraryProjects();
 
   plop.setActionType("createModel", async function (answers) {
@@ -41,6 +40,7 @@ export default async function (plop) {
       --dataServices=${!!answers.dataServices} \
       --singleton=${!!answers.singleton} \
       --parentAware=${!!answers.parentAware} \
+      --futureAware=${answers.futureAware || 'none'} \
       --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
 
     try {

package/src/lib/plopfile.mjs

@@ -2,6 +2,7 @@
 import { detectWorkspace } from "./utils/nx-context.mjs";
 
 // Generator registration
+import registerAddFuture from "./generators/model/add-future.mjs";
 import registerCompanion from "./generators/model/companion.mjs";
 import registerContainer from "./generators/model/container.mjs";
 import registerContext from "./generators/model/context.mjs";
@@ -40,6 +41,7 @@ export default async function (plop) {
   }
 
   await registerKosModel(plop);
+  await registerAddFuture(plop);
   await registerHook(plop);
   await registerCompanion(plop);
   await registerContainer(plop);

package/src/lib/utils/prompts.mjs

@@ -42,4 +42,34 @@ export const MODEL_PROMPTS = [
     message: "Create data services?",
     default: true,
   },
+  {
+    type: "list",
+    name: "futureAware",
+    message: "Include Future-aware capabilities?",
+    choices: [
+      { name: "No Future support", value: "none" },
+      { name: "Minimal (external access only)", value: "minimal" },
+      { name: "Complete (internal + external access)", value: "complete" },
+    ],
+    default: "none",
+  },
+];
+
+export const COMPANION_PROMPTS = [
+  {
+    type: "list",
+    name: "companionPattern",
+    message: "Which companion pattern to use?",
+    choices: [
+      {
+        name: "Composition (recommended) - explicit parent access via this.parent",
+        value: "composition",
+      },
+      {
+        name: "Decorator - transparent parent access, drop-in replacement",
+        value: "decorator",
+      },
+    ],
+    default: "composition",
+  },
 ];