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

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+// generators/project/splash.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:splash",
+  name: "KOS Splash Screen Project",
+  invalidateCache: true,
+  namedArguments: { name: "name" },
+};
+export default async function (plop) {
+  plop.setActionType("createSplashProject", async function (answers) {
+    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-splash-project \
+      --name=${answers.name} \
+      --no-interactive`;
+
+    try {
+      await execute(command);
+    } catch (error) {
+      throw new Error(error);
+    }
+
+    return `Splash page project ${answers.name} created.`;
+  });
+
+  plop.setGenerator("project:splash", {
+    description: "Create a new KOS Splash Page Project",
+    prompts: [
+      {
+        type: "input",
+        name: "name",
+        message: "What is the name of the splash project?",
+        validate: required,
+      },
+    ],
+    actions: actionFactory("createSplashProject", metadata),
+  });
+}

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

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

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

@@ -0,0 +1,74 @@
+// generators/serve/index.mjs
+import { execSync } from "child_process";
+import { detectWorkspace } from "../../utils/nx-context.mjs";
+
+export const metadata = {
+  key: "serve",
+  name: "Run Serve Target",
+  namedArguments: {
+    project: "project",
+    interactive: "interactive"
+  },
+};
+
+async function getProjectsWithTarget(target) {
+  try {
+    const output = execSync(`npx nx show projects --with-target ${target} --json`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return JSON.parse(output);
+  } catch (error) {
+    return [];
+  }
+}
+
+export default async function (plop) {
+  const projects = await getProjectsWithTarget("serve");
+
+  if (projects.length === 0) {
+    console.warn("[kos-cli] No projects found with serve target");
+    // Still register the generator but it will fail gracefully
+  }
+
+  plop.setActionType("runServe", async function (answers) {
+    const isWorkspace = await detectWorkspace();
+
+    if (!isWorkspace) {
+      console.warn(
+        "[kos-cli] Not inside an Nx workspace. Cannot run serve target."
+      );
+      return "Skipped: Not a workspace";
+    }
+
+    const { project } = answers;
+
+    console.log(`[kos-cli] Running serve on ${project}...`);
+    try {
+      // Run serve in foreground with stdio inherited so it stays alive
+      execSync(`npx nx run ${project}:serve`, {
+        stdio: "inherit",
+      });
+      return `Serve completed for ${project}`;
+    } catch (error) {
+      // Don't throw error for Ctrl+C or normal termination
+      if (error.signal === "SIGINT") {
+        return `Serve terminated for ${project}`;
+      }
+      throw new Error(`Failed to run serve on ${project}: ${error.message}`);
+    }
+  });
+
+  plop.setGenerator("serve", {
+    description: "Run the serve target on a project",
+    prompts: [
+      {
+        type: "list",
+        name: "project",
+        message: "Select a project to serve:",
+        choices: projects,
+      },
+    ],
+    actions: () => [{ type: "runServe" }],
+  });
+}

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

@@ -0,0 +1,182 @@
+// generators/version/index.mjs
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { detectWorkspace } from "../../utils/nx-context.mjs";
+
+export const metadata = {
+  key: "version",
+  name: "Display CLI and SDK Version Information",
+  namedArguments: { interactive: "interactive" },
+};
+
+function getPackageVersion(packagePath) {
+  try {
+    const packageJsonPath = path.join(packagePath, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      return packageJson.version || "unknown";
+    }
+  } catch (error) {
+    // Package not found
+  }
+  return null;
+}
+
+function findWorkspaceRoot(startDir = process.cwd()) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    if (existsSync(path.join(dir, "nx.json"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function getCliVersion() {
+  let version = null;
+
+  // Option 1: Check workspace root package.json for installed CLI
+  const workspaceRoot = findWorkspaceRoot();
+  if (workspaceRoot) {
+    try {
+      const output = execSync(
+        "npm list @kosdev-code/kos-ui-cli --depth=0 --json",
+        {
+          cwd: workspaceRoot,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }
+      );
+      const data = JSON.parse(output);
+      version = data?.dependencies?.["@kosdev-code/kos-ui-cli"]?.version;
+    } catch (error) {
+      // Not in workspace dependencies
+    }
+  }
+
+  // Option 2: Check global installation
+  if (!version) {
+    try {
+      const output = execSync(
+        "npm list -g @kosdev-code/kos-ui-cli --depth=0 --json",
+        {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }
+      );
+      const data = JSON.parse(output);
+      version = data?.dependencies?.["@kosdev-code/kos-ui-cli"]?.version;
+    } catch (error) {
+      // Not installed globally
+    }
+  }
+
+  return version || "unknown";
+}
+
+export default async function (plop) {
+  plop.setActionType("showVersions", async function () {
+    console.log("[kos-cli] Discovering version information...\n");
+
+    const isWorkspace = await detectWorkspace();
+    const workspaceRoot = findWorkspaceRoot();
+
+    const versions = {};
+
+    // Get CLI version
+    versions.cli = getCliVersion();
+
+    if (isWorkspace && workspaceRoot) {
+      // Get SDK versions from workspace dependencies
+      const sdkPackages = {
+        sdk: ["@kosdev-code/kos-ui-sdk", "@kosdev-code/kos-dispense-sdk"],
+        ddk: [
+          "@kosdev-code/kos-ddk-components",
+          "@kosdev-code/kos-ddk-model-components",
+        ],
+      };
+
+      for (const [type, packages] of Object.entries(sdkPackages)) {
+        for (const pkgName of packages) {
+          try {
+            const output = execSync(`npm list ${pkgName} --depth=0 --json`, {
+              cwd: workspaceRoot,
+              encoding: "utf-8",
+              stdio: ["pipe", "pipe", "ignore"],
+            });
+            const data = JSON.parse(output);
+            const version = data?.dependencies?.[pkgName]?.version;
+            if (version) {
+              // Store with short name (without @kosdev-code/ prefix)
+              const shortName = pkgName.replace("@kosdev-code/", "");
+              versions[shortName] = version;
+            }
+          } catch (error) {
+            // Package not installed in workspace
+          }
+        }
+      }
+    }
+
+    // Display results
+    console.log("Version Information:");
+    console.log("===================\n");
+
+    if (versions.cli) {
+      console.log(`kos-ui-cli: ${versions.cli}`);
+    } else {
+      console.log("kos-ui-cli: unknown");
+    }
+
+    if (isWorkspace) {
+      console.log("");
+      console.log("SDK Packages:");
+      console.log("-------------");
+
+      if (versions["kos-ui-sdk"]) {
+        console.log(`kos-ui-sdk: ${versions["kos-ui-sdk"]}`);
+      }
+
+      if (versions["kos-dispense-sdk"]) {
+        console.log(`kos-dispense-sdk: ${versions["kos-dispense-sdk"]}`);
+      }
+
+      console.log("");
+      console.log("DDK Packages:");
+      console.log("-------------");
+
+      if (versions["kos-ddk-components"]) {
+        console.log(`kos-ddk-components: ${versions["kos-ddk-components"]}`);
+      }
+
+      if (versions["kos-ddk-model-components"]) {
+        console.log(
+          `kos-ddk-model-components: ${versions["kos-ddk-model-components"]}`
+        );
+      }
+
+      if (!versions["kos-ui-sdk"] && !versions["kos-dispense-sdk"]) {
+        console.log("(No SDK packages found in workspace)");
+      }
+
+      if (
+        !versions["kos-ddk-components"] &&
+        !versions["kos-ddk-model-components"]
+      ) {
+        console.log("(No DDK packages found in workspace)");
+      }
+    } else {
+      console.log("\n(Not in workspace - SDK versions unavailable)");
+    }
+
+    return "\n";
+  });
+
+  plop.setGenerator("version", {
+    description: "Display CLI and SDK version information",
+    prompts: [],
+    actions: () => [{ type: "showVersions" }],
+  });
+}

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

@@ -0,0 +1,40 @@
+// generators/workspace/index.mjs
+import { createWorkspace } from "create-nx-workspace";
+import { required } from "../../utils/validators.mjs";
+import registerListModels from "./list-models.mjs";
+import registerListProjects from "./list-projects.mjs";
+
+export const metadata = {
+  key: "workspace",
+  name: "Create a new KOS UI Workspace",
+  namedArguments: {
+    name: "workspaceName",
+    workspaceName: "workspaceName"
+  }
+};
+export default async function (plop) {
+  plop.setActionType("createWorkspace", async function (answers) {
+    await createWorkspace("@kosdev-code/kos-nx-plugin", {
+      nxCloud: "skip",
+      name: answers.workspaceName,
+    });
+    return `Workspace ${answers.workspaceName} created.`;
+  });
+
+  plop.setGenerator("workspace", {
+    description: "KOS UI Workspace Setup",
+    prompts: [
+      {
+        type: "input",
+        name: "workspaceName",
+        message: "Enter the workspace name",
+        validate: required,
+      },
+    ],
+    actions: () => [{ type: "createWorkspace" }],
+  });
+  
+  // Register additional workspace generators
+  await registerListModels(plop);
+  await registerListProjects(plop);
+}

package/src/lib/generators/workspace/list-models.mjs

@@ -0,0 +1,64 @@
+import { getAllModels } from "../../utils/nx-context.mjs";
+
+/**
+ * Generator for listing all models in a workspace
+ */
+export default async function register(plop) {
+  plop.setGenerator("workspace:list-models", {
+    description: "List all available models in the workspace",
+    prompts: [
+      {
+        type: "list",
+        name: "outputFormat",
+        message: "Output format",
+        choices: ["json", "table", "simple"],
+        default: "json",
+      },
+    ],
+    actions: function (answers) {
+      return [
+        async function listModels() {
+          const models = await getAllModels();
+          
+          formatModelOutput(models, answers.outputFormat);
+          
+          return `[ok] Found ${models.length} models in workspace`;
+        },
+      ];
+    },
+  });
+}
+
+
+function formatModelOutput(models, format) {
+  switch (format) {
+    case "json":
+      console.log(JSON.stringify(models, null, 2));
+      break;
+      
+    case "table":
+      console.table(
+        models.map((m) => ({
+          Model: m.model,
+          Project: m.project,
+        }))
+      );
+      break;
+      
+    case "simple":
+      for (const model of models) {
+        console.log(`${model.project}/${model.model}`);
+      }
+      break;
+  }
+}
+
+// Export metadata for CLI integration
+export const metadata = {
+  key: "workspace:list-models",
+  name: "List all available models in the workspace",
+  description: "List all available models in the workspace",
+  namedArguments: {
+    format: "outputFormat",
+  },
+};