@kosdev-code/kos-ui-cli 2.0.33 → 2.0.34

package/package.json

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

package/src/lib/cli.mjs

@@ -30,11 +30,11 @@ const showBanner =
 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) => {
@@ -58,128 +58,153 @@ async function launch() {
   // 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");
+      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]) => {
+      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);
 
-        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':
+            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':
+            case "dryRun":
               return true;
             default:
               return `my-${argName}`;
           }
         };
-        
+
         // Create basic example with most important arguments
         const basicArgs = [];
-        const booleanArgs = ['container', 'singleton', 'parentAware', 'dataServices', 'dryRun'];
-        
+        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));
+          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));
+          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'
+          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 => {
+
+        relevantArgs.forEach((argName) => {
           const value = generateExampleValue(argName);
           basicArgs.push(`--${argName} ${value}`);
         });
-        
+
         // Create advanced example with boolean flags
         const advancedBooleanArgs = [];
-        booleanArgs.forEach(argName => {
+        booleanArgs.forEach((argName) => {
           if (args.includes(argName)) {
             advancedBooleanArgs.push(`--${argName}`);
           }
         });
-        
+
         // Show basic example
         if (basicArgs.length > 0) {
-          console.log(`  kosui ${command} ${basicArgs.join(' ')}`);
+          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} ${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)`);
+      console.log(
+        `  kosui ${command} -i             # Force interactive mode (short form)`
+      );
       return;
     }
   }
@@ -203,7 +228,7 @@ async function launch() {
     });
     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 ---`);
@@ -211,120 +236,145 @@ async function launch() {
 
       if (earlyMeta?.namedArguments) {
         console.log("\nNamed Arguments:");
-        Object.entries(earlyMeta.namedArguments).forEach(([cliArg, promptName]) => {
-          console.log(`  --${cliArg}    Maps to prompt: ${promptName}`);
-        });
+        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':
+            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':
+            case "dryRun":
               return true;
             default:
               return `my-${argName}`;
           }
         };
-        
+
         // Create basic example with most important arguments
         const basicArgs = [];
-        const booleanArgs = ['container', 'singleton', 'parentAware', 'dataServices', 'dryRun'];
-        
+        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));
+          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));
+          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'
+          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 => {
+
+        relevantArgs.forEach((argName) => {
           const value = generateExampleValue(argName);
           basicArgs.push(`--${argName} ${value}`);
         });
-        
+
         // Create advanced example with boolean flags
         const advancedBooleanArgs = [];
-        booleanArgs.forEach(argName => {
+        booleanArgs.forEach((argName) => {
           if (args.includes(argName)) {
             advancedBooleanArgs.push(`--${argName}`);
           }
         });
-        
+
         // Show basic example
         if (basicArgs.length > 0) {
-          console.log(`  kosui ${command} ${basicArgs.join(' ')}`);
+          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} ${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)`);
+      console.log(
+        `  kosui ${command} -i             # Force interactive mode (short form)`
+      );
       return;
     }
   }
@@ -345,7 +395,6 @@ async function launch() {
 
   const meta = await getGeneratorMetadata(command);
 
-
   if (showBanner) {
     console.log(`--- Running KOS Generator: ${meta?.name || command} ---`);
   }
@@ -359,6 +408,14 @@ async function launch() {
 
     // 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") {
@@ -421,114 +478,137 @@ async function launch() {
       }
 
       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':
+            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':
+            case "dryRun":
               return true;
             default:
               return `my-${argName}`;
           }
         };
-        
+
         // Create basic example with most important arguments
         const basicArgs = [];
-        const booleanArgs = ['container', 'singleton', 'parentAware', 'dataServices', 'dryRun'];
-        
+        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));
+          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));
+          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'
+          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 => {
+
+        relevantArgs.forEach((argName) => {
           const value = generateExampleValue(argName);
           basicArgs.push(`--${argName} ${value}`);
         });
-        
+
         // Create advanced example with boolean flags
         const advancedBooleanArgs = [];
-        booleanArgs.forEach(argName => {
+        booleanArgs.forEach((argName) => {
           if (args.includes(argName)) {
             advancedBooleanArgs.push(`--${argName}`);
           }
         });
-        
+
         // Show basic example
         if (basicArgs.length > 0) {
-          console.log(`  kosui ${command} ${basicArgs.join(' ')}`);
+          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} ${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)`);
+      console.log(
+        `  kosui ${command} -i             # Force interactive mode (short form)`
+      );
       return;
     }
 
@@ -547,14 +627,103 @@ async function launch() {
         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(prompt.default !== undefined ? prompt.default : "_");
+          bypassArgs.push(defaultValue !== undefined ? defaultValue : "_");
         }
       }
 
       // Only bypass if we have all non-conditional prompts
       const nonConditionalPrompts = prompts.filter((p) => !p.when);
-      if (bypassArgs.length === nonConditionalPrompts.length) {
+      // 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);
 

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

@@ -1,7 +1,7 @@
 // generators/component/index.mjs
 import { actionFactory } from "../../utils/action-factory.mjs";
 import { execute } from "../../utils/exec.mjs";
-import { getAllProjects } from "../../utils/nx-context.mjs";
+import { getComponentCompatibleProjectsWithFallback } from "../../utils/nx-context.mjs";
 import { required } from "../../utils/validators.mjs";
 
 export const metadata = {
@@ -16,7 +16,7 @@ export const metadata = {
 };
 
 export default async function (plop) {
-  const allProjects = await getAllProjects();
+  const componentProjects = await getComponentCompatibleProjectsWithFallback();
 
   plop.setActionType("createComponent", async function (answers) {
     const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-component \
@@ -47,7 +47,7 @@ export default async function (plop) {
         type: "list",
         name: "componentProject",
         message: "Which project should the component be created in?",
-        choices: allProjects,
+        choices: componentProjects,
       },
     ],
     actions: actionFactory("createComponent", metadata),

package/src/lib/generators/i18n/namespace.mjs

@@ -2,7 +2,7 @@
 import fs from "fs";
 import path from "path";
 import { actionFactory } from "../../utils/action-factory.mjs";
-import { getAllProjects, getProjectDetails } from "../../utils/nx-context.mjs";
+import { getI18nProjectsWithFallback, getProjectDetails } from "../../utils/nx-context.mjs";
 import { required } from "../../utils/validators.mjs";
 
 export const metadata = {
@@ -16,7 +16,7 @@ export const metadata = {
 };
 
 export default async function (plop) {
-  const allProjects = await getAllProjects();
+  const i18nProjects = await getI18nProjectsWithFallback();
 
   plop.setActionType("addNamespace", async function (answers) {
     const i18nProject = await getProjectDetails(answers.project);
@@ -53,7 +53,7 @@ export default async function (plop) {
         type: "list",
         name: "project",
         message: "Which project should the namespace be created in?",
-        choices: allProjects,
+        choices: i18nProjects,
       },
     ],
     actions: actionFactory("addNamespace", metadata),

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

@@ -3,7 +3,7 @@ import { actionFactory } from "../../utils/action-factory.mjs";
 import { execute } from "../../utils/exec.mjs";
 import {
   getAllModels,
-  getLibraryProjects,
+  getModelProjectsWithFallback,
   getProjectDetails,
 } from "../../utils/nx-context.mjs";
 import {
@@ -34,7 +34,7 @@ export const metadata = {
 
 export default async function (plop) {
   const allModels = await getAllModels();
-  const libraryProjects = await getLibraryProjects();
+  const libraryProjects = await getModelProjectsWithFallback();
   const modelChoices = allModels.map((m) => ({
     name: `${m.model} (${m.project})`,
     value: m.model,

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

@@ -2,7 +2,7 @@
 import { actionFactory } from "../../utils/action-factory.mjs";
 import { execute } from "../../utils/exec.mjs";
 import {
-  getLibraryProjects,
+  getModelProjectsWithFallback,
   getProjectDetails,
 } from "../../utils/nx-context.mjs";
 import { DEFAULT_PROMPTS, MODEL_PROMPTS } from "../../utils/prompts.mjs";
@@ -28,7 +28,7 @@ export const metadata = {
 };
 
 export default async function (plop) {
-  const libraryProjects = await getLibraryProjects();
+  const libraryProjects = await getModelProjectsWithFallback();
 
   plop.setActionType("createModel", async function (answers) {
     const modelProject = await getProjectDetails(answers.modelProject);

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

@@ -1,7 +1,7 @@
 // generators/plugin/plugin.mjs
 
 import { execute } from "../../utils/exec.mjs";
-import { getAllProjects } from "../../utils/nx-context.mjs";
+import { getPluginProjectsWithFallback } from "../../utils/nx-context.mjs";
 import { required } from "../../utils/validators.mjs";
 export const metadata = [
   { 
@@ -79,7 +79,7 @@ export const metadata = [
 ];
 
 export default async function (plop) {
-  const allProjects = await getAllProjects();
+  const pluginProjects = await getPluginProjectsWithFallback();
 
   plop.setActionType("createPluginComponent", async function (answers) {
     const pluginType = answers.extensionPoint;
@@ -105,7 +105,7 @@ export default async function (plop) {
       type: "list",
       name: "componentProject",
       message: "Which project should the component be created in?",
-      choices: allProjects,
+      choices: pluginProjects,
     },
   ];
 

package/src/lib/utils/nx-context.mjs

@@ -1,6 +1,6 @@
 // utils/nx-context.mjs
 import { execSync } from "child_process";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { getCached, setCached } from "./cache.mjs";
@@ -12,6 +12,45 @@ function execJson(cmd) {
   return JSON.parse(output);
 }
 
+function findKosJsonFiles(dir = process.cwd(), files = []) {
+  try {
+    const entries = readdirSync(dir);
+    
+    for (const entry of entries) {
+      // Skip common directories that won't have .kos.json files
+      // BUT don't skip .kos.json files themselves!
+      if (entry === 'node_modules' || entry === '.git' || entry === '.nx' || 
+          entry === 'dist' || entry === 'coverage' || entry === '.vscode' ||
+          entry === '.idea' || (entry.startsWith('.') && entry !== '.kos.json')) {
+        continue;
+      }
+      
+      const fullPath = path.join(dir, entry);
+      
+      try {
+        const stat = statSync(fullPath);
+        
+        if (stat.isFile() && entry === '.kos.json') {
+          files.push(fullPath);
+        } else if (stat.isDirectory()) {
+          // Only recurse into directories that might contain projects
+          // Skip common build/temp directories
+          if (entry !== 'tmp' && entry !== 'temp' && entry !== 'build') {
+            findKosJsonFiles(fullPath, files);
+          }
+        }
+      } catch (error) {
+        // Skip files/directories we can't access
+        continue;
+      }
+    }
+  } catch (error) {
+    // Skip directories we can't read
+  }
+  
+  return files;
+}
+
 let _workspaceDetected;
 
 export async function detectWorkspace(startDir = process.cwd()) {
@@ -61,43 +100,270 @@ export async function getPluginProjects() {
   return filtered;
 }
 
-export async function getAllModels() {
-  const cached = getCached("allModels");
+export async function getAllKosProjects() {
+  const cached = getCached("allKosProjects");
   if (cached) return cached;
-  console.warn(`parsing projects for models...`);
-  const allProjects = await getAllProjects();
-  const models = await allProjects.reduce(async (acc, curr) => {
-    console.warn(`[kos-cli] Pulling modles from project: ${curr}`);
-    const project = await getProjectDetails(curr);
-    const list = await acc;
-
-    const kosConfigPath = path.join(project.root, ".kos.json");
-
-    if (!existsSync(kosConfigPath)) {
-      console.warn(
-        `[kos-cli] No .kos.json found in project ${curr}, skipping...`
-      );
-      return list;
-    }
-    const kosConfig = JSON.parse(readFileSync(kosConfigPath, "utf-8"));
-    if (kosConfig.models) {
-      Object.keys(kosConfig.models).forEach((model) => {
-        list.push({ model: model, project: project.name });
-      });
+
+  console.warn(`[kos-cli] Discovering KOS projects by scanning .kos.json files...`);
+  
+  // In an NX workspace, focus on common project directories first
+  const projectDirs = ['apps', 'libs', 'packages'];
+  const kosJsonFiles = [];
+  const workspaceRoot = process.cwd();
+  
+  // First scan common project directories
+  for (const dir of projectDirs) {
+    const dirPath = path.join(workspaceRoot, dir);
+    if (existsSync(dirPath)) {
+      findKosJsonFiles(dirPath, kosJsonFiles);
     }
+  }
+  
+  // Also check the workspace root for any .kos.json files
+  const rootKosJson = path.join(workspaceRoot, '.kos.json');
+  if (existsSync(rootKosJson)) {
+    kosJsonFiles.push(rootKosJson);
+  }
+  
+  // If we didn't find any in the common directories, fall back to full scan
+  if (kosJsonFiles.length === 0) {
+    console.warn(`[kos-cli] No .kos.json files found in common directories, performing full workspace scan...`);
+    findKosJsonFiles(workspaceRoot, kosJsonFiles);
+  }
+  
+  const kosProjects = [];
 
-    return list.sort((a, b) => {
-      if (a.project === b.project) {
-        return a.model.localeCompare(b.model);
+  for (const kosJsonPath of kosJsonFiles) {
+    try {
+      const kosConfig = JSON.parse(readFileSync(kosJsonPath, "utf-8"));
+      const projectDir = path.dirname(kosJsonPath);
+      
+      // Try to determine the project name by looking for project.json
+      let projectName = null;
+      const projectJsonPath = path.join(projectDir, 'project.json');
+      
+      if (existsSync(projectJsonPath)) {
+        try {
+          const projectJson = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+          projectName = projectJson.name;
+        } catch (error) {
+          // If we can't read project.json, use directory name as fallback
+          projectName = path.basename(projectDir);
+        }
       } else {
-        return a.project.localeCompare(b.project);
+        // Use directory name as fallback
+        projectName = path.basename(projectDir);
       }
+
+      // Skip root-type configurations as they are not projects
+      if (kosConfig.type === 'root') {
+        continue;
+      }
+
+      kosProjects.push({
+        name: projectName,
+        path: projectDir,
+        kosJsonPath,
+        config: kosConfig,
+        projectType: kosConfig.generator?.projectType
+      });
+    } catch (error) {
+      console.warn(`[kos-cli] Error reading ${kosJsonPath}: ${error.message}`);
+    }
+  }
+
+  setCached("allKosProjects", kosProjects);
+  return kosProjects;
+}
+
+export async function getProjectsByType(targetType) {
+  const cacheKey = `projectsByType:${targetType}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  console.warn(`[kos-cli] Filtering projects for ${targetType} projectType...`);
+  const allKosProjects = await getAllKosProjects();
+  const filteredProjects = [];
+
+  for (const kosProject of allKosProjects) {
+    const projectType = kosProject.projectType;
+    
+    // Handle both string and array formats for projectType
+    const hasTargetType = Array.isArray(projectType) 
+      ? projectType.includes(targetType)
+      : projectType === targetType;
+      
+    if (hasTargetType) {
+      filteredProjects.push(kosProject.name);
+    }
+  }
+
+  setCached(cacheKey, filteredProjects);
+  return filteredProjects;
+}
+
+export async function getModelProjects() {
+  return await getProjectsByType("model");
+}
+
+export async function getUIProjects() {
+  return await getProjectsByType("ui");
+}
+
+export async function getModelComponentProjects() {
+  return await getProjectsByType("model-component");
+}
+
+export async function getI18nProjects() {
+  return await getProjectsByType("i18n");
+}
+
+
+export async function getProjectsByTypeWithFallback(targetType, fallbackFunction = getLibraryProjects) {
+  const filteredProjects = await getProjectsByType(targetType);
+  
+  if (filteredProjects.length > 0) {
+    console.warn(`[kos-cli] Found ${filteredProjects.length} ${targetType} projects`);
+    return filteredProjects;
+  } else {
+    console.warn(`[kos-cli] No ${targetType} projects found, showing fallback projects`);
+    return await fallbackFunction();
+  }
+}
+
+export async function getModelProjectsWithFallback() {
+  return await getProjectsByTypeWithFallback("model", getLibraryProjects);
+}
+
+export async function getModelComponentProjectsWithFallback() {
+  return await getProjectsByTypeWithFallback("model-component", getAllProjects);
+}
+
+export async function getProjectsByMultipleTypes(targetTypes) {
+  const cacheKey = `projectsByMultipleTypes:${targetTypes.join(',')}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  console.warn(`[kos-cli] Filtering projects for projectTypes: ${targetTypes.join(', ')}...`);
+  const allKosProjects = await getAllKosProjects();
+  const filteredProjects = [];
+
+  for (const kosProject of allKosProjects) {
+    const projectType = kosProject.projectType;
+    
+    // Handle both string and array formats for projectType
+    const hasAnyTargetType = targetTypes.some(targetType => {
+      return Array.isArray(projectType) 
+        ? projectType.includes(targetType)
+        : projectType === targetType;
     });
-  }, []);
+      
+    if (hasAnyTargetType) {
+      filteredProjects.push(kosProject.name);
+    }
+  }
+
+  setCached(cacheKey, filteredProjects);
+  return filteredProjects;
+}
+
+export async function getComponentCompatibleProjects() {
+  return await getProjectsByMultipleTypes(["ui", "splash", "model-component"]);
+}
+
+export async function getComponentCompatibleProjectsWithFallback() {
+  const componentProjects = await getComponentCompatibleProjects();
+  
+  if (componentProjects.length > 0) {
+    console.warn(`[kos-cli] Found ${componentProjects.length} component-compatible projects`);
+    return componentProjects;
+  } else {
+    console.warn(`[kos-cli] No component-compatible projects found, showing all projects`);
+    return await getAllProjects();
+  }
+}
+
+export async function getI18nProjectsWithFallback() {
+  return await getProjectsByTypeWithFallback("i18n", getAllProjects);
+}
+
+export async function getPluginProjectsWithFallback() {
+  // First try type-based filtering
+  const pluginProjectsByType = await getProjectsByType("plugin");
+  if (pluginProjectsByType.length > 0) {
+    console.warn(`[kos-cli] Found ${pluginProjectsByType.length} plugin projects by type`);
+    return pluginProjectsByType;
+  }
+  
+  // Fall back to existing name-based filtering
+  const pluginProjectsByName = await getPluginProjects();
+  if (pluginProjectsByName.length > 0) {
+    console.warn(`[kos-cli] Found ${pluginProjectsByName.length} plugin projects by name`);
+    return pluginProjectsByName;
+  }
+  
+  // Final fallback to all projects
+  console.warn(`[kos-cli] No plugin projects found, showing all projects`);
+  return await getAllProjects();
+}
+
+export async function getAllModels() {
+  const cached = getCached("allModels");
+  if (cached) return cached;
+  
+  console.warn(`[kos-cli] Scanning for models in KOS projects...`);
+  const allKosProjects = await getAllKosProjects();
+  const models = [];
+
+  for (const kosProject of allKosProjects) {
+    if (kosProject.config.models) {
+      Object.keys(kosProject.config.models).forEach((model) => {
+        models.push({ model: model, project: kosProject.name });
+      });
+    }
+  }
+
+  // Sort models by project name first, then by model name
+  models.sort((a, b) => {
+    if (a.project === b.project) {
+      return a.model.localeCompare(b.model);
+    } else {
+      return a.project.localeCompare(b.project);
+    }
+  });
+
   setCached("allModels", models);
   return models;
 }
 
+export async function getWorkspaceDefaults() {
+  const cached = getCached("workspaceDefaults");
+  if (cached) return cached;
+
+  const workspaceRoot = process.cwd();
+  const rootKosJsonPath = path.join(workspaceRoot, '.kos.json');
+  
+  if (existsSync(rootKosJsonPath)) {
+    try {
+      const rootConfig = JSON.parse(readFileSync(rootKosJsonPath, "utf-8"));
+      if (rootConfig.type === 'root' && rootConfig.generator?.defaults) {
+        setCached("workspaceDefaults", rootConfig.generator.defaults);
+        return rootConfig.generator.defaults;
+      }
+    } catch (error) {
+      console.warn(`[kos-cli] Error reading workspace defaults: ${error.message}`);
+    }
+  }
+  
+  setCached("workspaceDefaults", {});
+  return {};
+}
+
+export async function getDefaultProjectForType(projectType) {
+  const defaults = await getWorkspaceDefaults();
+  return defaults[projectType] || null;
+}
+
 export async function getProjectDetails(projectName) {
   const cacheKey = `projectDetails:${projectName}`;
   const cached = getCached(cacheKey);