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

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

@@ -0,0 +1,117 @@
+// generators/model/companion.mjs
+import { actionFactory } from "../../utils/action-factory.mjs";
+import { execute } from "../../utils/exec.mjs";
+import {
+  getAllModels,
+  getModelProjectsWithFallback,
+  getProjectDetails,
+} from "../../utils/nx-context.mjs";
+import {
+  COMPANION_PROMPTS,
+  DEFAULT_PROMPTS,
+  MODEL_PROMPTS,
+} from "../../utils/prompts.mjs";
+import { required } from "../../utils/validators.mjs";
+
+export const metadata = {
+  key: "model:companion",
+  name: "KOS Companion Model",
+  namedArguments: {
+    name: "modelName",
+    modelName: "modelName",
+    project: "modelProject",
+    modelProject: "modelProject",
+    companionParent: "companionParent",
+    companionPattern: "companionPattern",
+    container: "container",
+    parentAware: "parentAware",
+    singleton: "singleton",
+    dataServices: "dataServices",
+    autoRegister: "autoRegister",
+    dryRun: "dryRun",
+    interactive: "interactive",
+  },
+};
+
+export default async function (plop) {
+  const libraryProjects = await getModelProjectsWithFallback();
+  
+  // 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;
+
+    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-model \
+      --name=${answers.modelName} \
+      --modelProject=${modelProject.name} \
+      --skipRegistration=true \
+      --container=${!!answers.container} \
+      --dataServices=${!!answers.dataServices} \
+      --singleton=${!!answers.singleton} \
+      --parentAware=${!!answers.parentAware} \
+      --autoRegister=${!!answers.autoRegister} \
+      --companion=true \
+      --companionModel=${answers.companionParent} \
+      --companionModelProject=${companionProject} \
+      --companionPattern=${answers.companionPattern} \
+      --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+  });
+
+  plop.setGenerator("model:companion", {
+    description: "Create a new KOS Companion Model",
+    prompts: [
+      ...DEFAULT_PROMPTS,
+      {
+        type: "input",
+        name: "modelName",
+        message: "Enter the name of the model",
+        validate: required,
+      },
+      {
+        type: "list",
+        name: "modelProject",
+        message: "Which model project to use?",
+        validate: required,
+        choices: libraryProjects,
+      },
+      {
+        type: "list",
+        name: "companionParent",
+        message: "Select the companion parent model",
+        choices: modelChoices,
+      },
+      ...COMPANION_PROMPTS,
+      ...MODEL_PROMPTS,
+    ],
+    actions: actionFactory("createCompanionModel", metadata),
+  });
+}

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

@@ -0,0 +1,96 @@
+// generators/model/container.mjs
+import { actionFactory } from "../../utils/action-factory.mjs";
+import { execute } from "../../utils/exec.mjs";
+import {
+  getAllModels,
+  getAllProjects,
+  getProjectDetails,
+} from "../../utils/nx-context.mjs";
+import { DEFAULT_PROMPTS, MODEL_PROMPTS } from "../../utils/prompts.mjs";
+
+export const metadata = {
+  key: "container",
+  name: "KOS Container Model",
+  namedArguments: {
+    modelName: "modelName",
+    registrationProject: "registrationProject",
+    container: "container",
+    parentAware: "parentAware",
+    singleton: "singleton",
+    dataServices: "dataServices",
+    autoRegister: "autoRegister",
+    dryRun: "dryRun",
+    interactive: "interactive",
+  },
+};
+
+export default async function (plop) {
+  const allProjects = await getAllProjects();
+  
+  // 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;
+    const projectDetails = await getProjectDetails(modelProject);
+
+    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-container-model \
+      --modelName=${answers.modelName} \
+      --modelProject=${projectDetails.name} \
+      --skipRegistration=true \
+      --dataServices=${!!answers.dataServices} \
+      --singleton=${!!answers.singleton} \
+      --autoRegister=${!!answers.autoRegister} \
+      --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `Container model created for ${answers.modelName}`;
+  });
+
+  plop.setGenerator("container", {
+    description: "Create a new KOS Container Model",
+    prompts: [
+      ...DEFAULT_PROMPTS,
+      {
+        type: "list",
+        name: "modelName",
+        message: "Which model to use?",
+        choices: modelChoices,
+      },
+      {
+        type: "list",
+        name: "registrationProject",
+        message: "Which project should the model be registered in?",
+        choices: allProjects,
+      },
+      ...MODEL_PROMPTS,
+    ],
+    actions: actionFactory("createContainer", metadata),
+  });
+}

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

@@ -0,0 +1,77 @@
+// generators/model/context.mjs
+import { actionFactory } from "../../utils/action-factory.mjs";
+import { execute } from "../../utils/exec.mjs";
+import { getAllModels, getAllProjects } from "../../utils/nx-context.mjs";
+export const metadata = {
+  key: "context",
+  name: "KOS Model React Context",
+  namedArguments: {
+    modelName: "modelName",
+    componentProject: "componentProject",
+    project: "componentProject",
+  },
+};
+
+export default async function (plop) {
+  const allProjects = await getAllProjects();
+  
+  // 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;
+    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-context \
+      --appProject=${answers.componentProject} \
+      --modelProject=${modelProject} \
+      --name=${answers.modelName} \
+      --no-interactive ${answers.dryRun ? "--dryRun" : ""}`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `Context created for ${answers.modelName} in ${answers.componentProject}`;
+  });
+
+  plop.setGenerator("context", {
+    description: "Create a context for a KOS Model",
+    prompts: [
+      {
+        type: "list",
+        name: "modelName",
+        message: "Which model to use?",
+        choices: modelChoices,
+      },
+      {
+        type: "list",
+        name: "componentProject",
+        message: "Which project should the context be created in?",
+        choices: allProjects,
+      },
+    ],
+    actions: actionFactory("createContext", metadata),
+  });
+}

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

@@ -0,0 +1,77 @@
+// generators/model/hook.mjs
+import { actionFactory } from "../../utils/action-factory.mjs";
+import { execute } from "../../utils/exec.mjs";
+import { getAllModels, getAllProjects } from "../../utils/nx-context.mjs";
+export const metadata = {
+  key: "hook",
+  name: "KOS Model React Hook",
+  namedArguments: {
+    modelName: "modelName",
+    componentProject: "componentProject",
+    project: "componentProject"
+  }
+};
+
+export default async function (plop) {
+  const allProjects = await getAllProjects();
+  
+  // 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;
+    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-hook \
+      --appProject=${answers.componentProject} \
+      --modelProject=${modelProject} \
+      --name=${answers.modelName} \
+      --no-interactive ${answers.dryRun ? "--dryRun" : ""}`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `Hook created for ${answers.modelName} in ${answers.componentProject}`;
+  });
+
+  plop.setGenerator("hook", {
+    description: "Create a hook for a KOS Model",
+    prompts: [
+      {
+        type: "list",
+        name: "modelName",
+        message: "Which model to use?",
+        choices: modelChoices,
+      },
+      {
+        type: "list",
+        name: "componentProject",
+        message: "Which project should the hook be created in?",
+        choices: allProjects,
+      },
+    ],
+    actions: actionFactory("createHook", metadata),
+  });
+}

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

@@ -0,0 +1,79 @@
+// generators/model/model.mjs
+import { actionFactory } from "../../utils/action-factory.mjs";
+import { execute } from "../../utils/exec.mjs";
+import {
+  getModelProjectsWithFallback,
+  getProjectDetails,
+} from "../../utils/nx-context.mjs";
+import { DEFAULT_PROMPTS, MODEL_PROMPTS } from "../../utils/prompts.mjs";
+import { required } from "../../utils/validators.mjs";
+
+export const metadata = {
+  key: "model",
+  name: "KOS Model",
+  invalidateCache: true,
+  namedArguments: {
+    name: "modelName",
+    modelName: "modelName",
+    project: "modelProject",
+    modelProject: "modelProject",
+    container: "container",
+    parentAware: "parentAware",
+    singleton: "singleton",
+    dataServices: "dataServices",
+    futureAware: "futureAware",
+    autoRegister: "autoRegister",
+    dryRun: "dryRun",
+    interactive: "interactive"
+  }
+};
+
+export default async function (plop) {
+  const libraryProjects = await getModelProjectsWithFallback();
+
+  plop.setActionType("createModel", async function (answers) {
+    const modelProject = await getProjectDetails(answers.modelProject);
+    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-model \
+      --name=${answers.modelName} \
+      --modelProject=${modelProject.name} \
+      --skipRegistration=true \
+      --container=${!!answers.container} \
+      --dataServices=${!!answers.dataServices} \
+      --singleton=${!!answers.singleton} \
+      --parentAware=${!!answers.parentAware} \
+      --futureAware=${answers.futureAware || 'none'} \
+      --autoRegister=${!!answers.autoRegister} \
+      --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `Model ${answers.modelName} created in ${answers.modelProject}`;
+  });
+
+  plop.setGenerator("model", {
+    description: "Create a new KOS Model",
+    prompts: [
+      ...DEFAULT_PROMPTS,
+      {
+        type: "input",
+        name: "modelName",
+        message: "Enter the name of the model",
+        validate: required,
+      },
+      {
+        type: "list",
+        name: "modelProject",
+        message: "Which model project to use?",
+        validate: required,
+        choices: libraryProjects,
+      },
+      ...MODEL_PROMPTS,
+    ],
+
+    actions: actionFactory("createModel", metadata),
+  });
+}

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

@@ -0,0 +1,195 @@
+// generators/plugin/plugin.mjs
+
+import { execute } from "../../utils/exec.mjs";
+import { getPluginProjectsWithFallback } from "../../utils/nx-context.mjs";
+import { required } from "../../utils/validators.mjs";
+export const metadata = [
+  { 
+    key: "pluginComponent", 
+    name: "KOS UI Plugin Component",
+    namedArguments: {
+      name: "componentName",
+      componentName: "componentName",
+      project: "componentProject",
+      componentProject: "componentProject",
+      extensionPoint: "extensionPoint"
+    }
+  },
+  { 
+    key: "plugin:cui", 
+    name: "KOS UI Plugin CUI Configuration",
+    namedArguments: {
+      name: "componentName",
+      componentName: "componentName",
+      project: "componentProject",
+      componentProject: "componentProject"
+    }
+  },
+  { 
+    key: "plugin:setup", 
+    name: "KOS UI Plugin Setup Step",
+    namedArguments: {
+      name: "componentName",
+      componentName: "componentName",
+      project: "componentProject",
+      componentProject: "componentProject"
+    }
+  },
+  { 
+    key: "plugin:utility", 
+    name: "KOS UI Plugin Utility",
+    namedArguments: {
+      name: "componentName",
+      componentName: "componentName",
+      project: "componentProject",
+      componentProject: "componentProject"
+    }
+  },
+  { 
+    key: "plugin:setting", 
+    name: "KOS UI Plugin Setting",
+    namedArguments: {
+      name: "componentName",
+      componentName: "componentName",
+      project: "componentProject",
+      componentProject: "componentProject",
+      group: "group"
+    }
+  },
+  { 
+    key: "plugin:nav", 
+    name: "KOS UI Plugin Navigation View",
+    namedArguments: {
+      name: "componentName",
+      componentName: "componentName",
+      project: "componentProject",
+      componentProject: "componentProject"
+    }
+  },
+  {
+    key: "plugin:cp",
+    name: "KOS UI Plugin Control Pour",
+    namedArguments: {
+      name: "componentName",
+      componentName: "componentName",
+      project: "componentProject",
+      componentProject: "componentProject"
+    }
+  },
+  {
+    key: "plugin:custom",
+    name: "KOS UI Plugin Custom (User-Specified Contribution)",
+    namedArguments: {
+      name: "componentName",
+      componentName: "componentName",
+      project: "componentProject",
+      componentProject: "componentProject",
+      contributionKey: "contributionKey"
+    }
+  },
+];
+
+export default async function (plop) {
+  const pluginProjects = await getPluginProjectsWithFallback();
+
+  plop.setActionType("createPluginComponent", async function (answers) {
+    const pluginType = answers.extensionPoint;
+
+    let command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-component --name=${answers.componentName} --group=${answers.group} --appProject=${answers.componentProject} --pluginType=${pluginType} --type=components --no-interactive`;
+
+    // Add contributionKey for custom plugin types
+    if (pluginType === 'custom' && answers.contributionKey) {
+      command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-component --name=${answers.componentName} --contributionKey=${answers.contributionKey} --appProject=${answers.componentProject} --pluginType=${pluginType} --type=components --no-interactive`;
+    }
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `Component ${answers.componentName} created in ${answers.componentProject}`;
+  });
+  const pluginPrompts = [
+    {
+      type: "input",
+      name: "componentName",
+      message: "Enter the name of the component",
+      validate: required,
+    },
+    {
+      type: "list",
+      name: "componentProject",
+      message: "Which project should the component be created in?",
+      choices: pluginProjects,
+    },
+  ];
+
+  const pluginTypes = [
+    { key: "plugin:cui", name: "cui" },
+    { key: "plugin:setup", name: "setup" },
+    { key: "plugin:utility", name: "utility" },
+    { key: "plugin:setting", name: "setting" },
+    { key: "plugin:nav", name: "nav" },
+    { key: "plugin:cp", name: "controlPour" },
+    { key: "plugin:custom", name: "custom" },
+  ];
+
+  // Generic plugin component
+  plop.setGenerator("pluginComponent", {
+    description: "Create a new KOS Plugin Component",
+    prompts: [
+      ...pluginPrompts,
+      {
+        type: "list",
+        name: "extensionPoint",
+        message: "What type of extension point is the plugin supporting?",
+        choices: pluginTypes.map((pt) => pt.name),
+      },
+    ],
+    actions: [{ type: "createPluginComponent" }],
+  });
+
+  // Specific plugin type aliases
+  for (const { key, name } of pluginTypes) {
+    const prompts = [
+      ...pluginPrompts,
+      ...(name === "setting"
+        ? [
+            {
+              type: "input",
+              name: "group",
+              message: "Which settings group should the setting be located?",
+            },
+          ]
+        : []),
+      ...(name === "custom"
+        ? [
+            {
+              type: "input",
+              name: "contributionKey",
+              message: "What contribution key should be used in .kos.json? (e.g., 'menus', 'panels', 'commands', etc.)",
+              validate: required,
+            },
+          ]
+        : []),
+      {
+        type: "input",
+        name: "extensionPoint",
+        message: "Hidden extensionPoint",
+        default: name,
+        when: false, // hide from CLI
+      },
+    ];
+
+    plop.setGenerator(key, {
+      description: `Create a new KOS ${
+        name[0].toUpperCase() + name.slice(1)
+      } Plugin Component`,
+      prompts,
+      actions: [
+        { type: "createPluginComponent", data: { extensionPoint: name } },
+      ],
+    });
+  }
+}

package/src/lib/generators/project/app.mjs

@@ -0,0 +1,39 @@
+// generators/project/app.mjs
+import { actionFactory } from "../../utils/action-factory.mjs";
+import { execute } from "../../utils/exec.mjs";
+import { required } from "../../utils/validators.mjs";
+
+export const metadata = {
+  key: "project",
+  name: "KOS UI App Project",
+  invalidateCache: true,
+  namedArguments: { name: "name" },
+};
+export default async function (plop) {
+  plop.setActionType("createUiProject", async function (answers) {
+    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-ui-project \
+      --name=${answers.name} \
+      --no-interactive`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `UI project ${answers.name} created.`;
+  });
+
+  plop.setGenerator("project", {
+    description: "Create a new KOS UI App project",
+    prompts: [
+      {
+        type: "input",
+        name: "name",
+        message: "What is the name of the app project?",
+        validate: required,
+      },
+    ],
+    actions: actionFactory("createUiProject", metadata),
+  });
+}