@kosdev-code/kos-ui-cli 2.0.8 → 2.0.9

package/src/lib/routing-plopfile.mjs

@@ -1,65 +1,37 @@
 #!/usr/bin/env node
+import { spawn } from "child_process";
 import minimist from "minimist";
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { getAllGeneratorMetadata } from "./utils/generator-loader.mjs";
 
 const args = process.argv.slice(2);
 const argv = minimist(args);
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
 export default async function (plop) {
-  const generators = {
-    model: { name: "KOS Model", path: "plopfile.mjs" },
-    "model:companion": {
-      name: "KOS Companion Model",
-      path: "model-aware-plopfile.mjs",
-    },
-    hook: { name: "KOS Model Hook and HoC", path: "model-aware-plopfile.mjs" },
-    context: { name: "KOS Model Context", path: "model-aware-plopfile.mjs" },
-    container: {
-      name: "KOS Model Container",
-      path: "model-aware-plopfile.mjs",
-    },
+  const metadata = await getAllGeneratorMetadata();
 
-    workspace: {
-      name: "KOS Development Workspace",
-      path: "plopfile.mjs",
-    },
-    project: { name: "KOS UI App Project", path: "model-aware-plopfile.mjs" },
-    plugin: { name: "KOS UI Plugin Project", path: "plopfile.mjs" },
-    "plugin:utility": { name: "KOS UI Plugin Utility", path: "plopfile.mjs" },
-    "plugin:setup": { name: "KOS UI Plugin Setup Step", path: "plopfile.mjs" },
-    "plugin:cui": {
-      name: "KOS UI Plugin CUI Configuration",
-      path: "plopfile.mjs",
-    },
-    "plugin:setup": { name: "KOS UI Plugin Setup Step", path: "plopfile.mjs" },
-    "plugin:nav": {
-      name: "KOS UI Plugin Page Navigation",
-      path: "plopfile.mjs",
-    },
-    component: { name: "KOS UI Component", path: "plopfile.mjs" },
-    pluginComponent: { name: "KOS UI Plugin Component", path: "plopfile.mjs" },
-    i18n: {
-      name: "KOS Localization Project",
-      path: "plopfile.mjs",
-    },
-    "i18n:namespace": {
-      name: "KOS Localization Namespace",
-      path: "plopfile.mjs",
-    },
-    theme: { name: "KOS Theme Project", path: "plopfile.mjs" },
-    env: {
-      name: "Discover and Set Studio Environment Variables",
-      path: "env-plopfile.mjs",
-    },
-  };
-  plop.setActionType("execute", async (answers, config) => {
-    const template = answers.template;
-    argv._ = [template];
-    const pathName = generators[template].path;
+  const sorted = Object.entries(metadata).sort(([aKey, a], [bKey, b]) => {
+    if (a.category === b.category) return a.name.localeCompare(b.name);
+    return a.category.localeCompare(b.category);
+  });
+
+  const choices = sorted.map(([key, meta]) => ({
+    name: `[${meta.category}] ${meta.name}`,
+    value: `${key}`,
+  }));
+
+  plop.setActionType("execCLI", function (answers) {
+    return new Promise((resolve, reject) => {
+      const command = `kosui ${answers.template}`;
+      const child = spawn("npx", ["kosui", answers.template], {
+        stdio: "inherit",
+        shell: true,
+      });
 
-    console.warn(`---------   Please run kosui ${template}   ---------`);
+      child.on("exit", (code) => {
+        if (code === 0) resolve(`Executed kosui ${answers.template}`);
+        else reject(new Error(`Failed with code ${code}`));
+      });
+    });
   });
 
   plop.setGenerator("help", {
@@ -69,17 +41,13 @@ export default async function (plop) {
         type: "list",
         name: "template",
         message: "Choose a task to run:",
-        choices: Object.keys(generators).map((key) => ({
-          name: generators[key].name,
-          value: key,
-        })),
+        choices,
+      },
+    ],
+    actions: [
+      {
+        type: "execCLI",
       },
     ],
-    actions: function (data) {
-      const action = {
-        type: "execute",
-      };
-      return [action];
-    },
   });
 }

package/src/lib/scripts/generate-metadata.mjs

@@ -0,0 +1,39 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const generatorsRoot = path.join(__dirname, "..", "generators");
+const outputPath = path.join(generatorsRoot, "metadata.json");
+
+async function discoverGenerators() {
+  const categories = await fs.readdir(generatorsRoot, { withFileTypes: true });
+  const entries = [];
+
+  for (const category of categories) {
+    if (!category.isDirectory()) continue;
+
+    const categoryPath = path.join(generatorsRoot, category.name);
+    const files = await fs.readdir(categoryPath);
+
+    for (const file of files) {
+      if (!file.endsWith(".mjs")) continue;
+
+      const fullPath = path.join(categoryPath, file);
+      const module = await import(pathToFileURL(fullPath).href);
+
+      if (!module.metadata) continue;
+
+      entries.push({
+        category: category.name,
+        file,
+        metadata: module.metadata,
+      });
+    }
+  }
+
+  await fs.writeFile(outputPath, JSON.stringify(entries, null, 2));
+  console.log(`Generated metadata.json with ${entries.length} entries.`);
+}
+
+await discoverGenerators();

package/src/lib/utils/cache.mjs

@@ -0,0 +1,128 @@
+// utils/cache.mjs
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+// Default to project-local cache; can swap to global using `getGlobalCachePath()`
+const CACHE_PATH = path.resolve(".nx/cli-cache.json");
+const CACHE_TTL = 60 * 1000; // 1 minute
+const ARGS = process.argv;
+const DISABLE_CACHE =
+  process.env.DISABLE_CACHE === "true" || process.env.REFRESH === "true";
+
+let _cache = {}; // in-memory cache
+let _loaded = false;
+
+const DEFAULT_TRACKED_FILES = [
+  "workspace.json",
+  "nx.json",
+  "project.json",
+  "tsconfig.base.json",
+  "package.json",
+];
+
+function ensureCacheDir() {
+  const dir = path.dirname(CACHE_PATH);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function loadCacheFromDisk() {
+  if (_loaded) return;
+  _loaded = true;
+  try {
+    if (fs.existsSync(CACHE_PATH)) {
+      const data = fs.readFileSync(CACHE_PATH, "utf-8");
+      _cache = JSON.parse(data);
+    }
+  } catch (err) {
+    console.warn("Failed to load CLI cache:", err);
+    _cache = {};
+  }
+}
+
+function saveCacheToDisk() {
+  try {
+    ensureCacheDir();
+    fs.writeFileSync(CACHE_PATH, JSON.stringify(_cache, null, 2));
+  } catch (err) {
+    console.warn("Failed to save CLI cache:", err);
+  }
+}
+
+function isFresh(entry, ttl = CACHE_TTL) {
+  if (!entry || !entry.timestamp) return false;
+  return Date.now() - entry.timestamp < ttl;
+}
+
+export function getCached(key, ttl = CACHE_TTL) {
+  if (DISABLE_CACHE) return null;
+  loadCacheFromDisk();
+  const entry = _cache[key];
+  if (isFresh(entry, ttl)) return entry.data;
+  return null;
+}
+
+export function setCached(key, data) {
+  loadCacheFromDisk();
+  _cache[key] = {
+    data,
+    timestamp: Date.now(),
+  };
+  saveCacheToDisk();
+}
+
+export function clearCache(key) {
+  loadCacheFromDisk();
+  if (key) {
+    delete _cache[key];
+  } else {
+    _cache = {};
+  }
+  saveCacheToDisk();
+}
+
+export function getGlobalCachePath() {
+  return path.join(os.homedir(), ".kos-cli-cache.json");
+}
+
+export function hashFiles(filePaths = DEFAULT_TRACKED_FILES) {
+  const hash = crypto.createHash("sha256");
+  for (const file of filePaths) {
+    if (fs.existsSync(file)) {
+      hash.update(fs.readFileSync(file));
+    }
+  }
+  return hash.digest("hex");
+}
+
+export function getHashedCache(key, filePaths = DEFAULT_TRACKED_FILES) {
+  if (DISABLE_CACHE) return null;
+  loadCacheFromDisk();
+  const entry = _cache[key];
+  const currentHash = hashFiles(filePaths);
+  if (entry && entry.hash === currentHash) {
+    return entry.data;
+  }
+  return null;
+}
+
+export function setHashedCache(key, data, filePaths = DEFAULT_TRACKED_FILES) {
+  loadCacheFromDisk();
+  const hash = hashFiles(filePaths);
+  _cache[key] = { data, hash, timestamp: Date.now() };
+  saveCacheToDisk();
+}
+
+export function markCacheDirty(reason = "manual") {
+  _loaded = false;
+  _cache = {};
+  if (fs.existsSync(CACHE_PATH)) {
+    fs.unlinkSync(CACHE_PATH);
+    console.debug(`Cache invalidated due to ${reason}: ${CACHE_PATH} deleted`);
+  }
+}
+
+export function shouldInvalidateFromMeta(metadata = {}) {
+  return metadata?.invalidateCache === true;
+}

package/src/lib/utils/exec.mjs

@@ -0,0 +1,18 @@
+// utils/exec.mjs
+import { exec } from "child_process";
+
+/**
+ * Executes a shell command and returns a Promise.
+ * @param {string} command
+ * @returns {Promise<void>}
+ */
+export function execute(command) {
+  return new Promise((resolve, reject) => {
+    const child = exec(command, { shell: true }, (error, stdout, stderr) => {
+      if (stdout) process.stdout.write(stdout);
+      if (stderr) process.stderr.write(stderr);
+      if (error) return reject(error);
+      resolve();
+    });
+  });
+}

package/src/lib/utils/generator-loader.mjs

@@ -0,0 +1,65 @@
+// utils/generator-loader.mjs
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const GENERATOR_ROOT = path.join(__dirname, "../generators");
+
+/**
+ * Recursively finds generator metadata across all generator folders.
+ * @returns {Promise<Record<string, any>>} Mapping of generator key -> metadata
+ */
+export async function getAllGeneratorMetadata() {
+  const metadataMap = {};
+
+  const categories = await fs.readdir(GENERATOR_ROOT, { withFileTypes: true });
+  for (const category of categories) {
+    if (!category.isDirectory()) continue;
+
+    const categoryPath = path.join(GENERATOR_ROOT, category.name);
+    const files = await fs.readdir(categoryPath);
+
+    for (const file of files) {
+      if (!file.endsWith(".mjs")) continue;
+
+      const modulePath = path.join(categoryPath, file);
+
+      try {
+        const module = await import(modulePath);
+
+        if (Array.isArray(module.metadata)) {
+          for (const meta of module.metadata) {
+            if (meta?.key) {
+              metadataMap[meta.key] = {
+                ...meta,
+                path: modulePath,
+                category: category.name,
+              };
+            }
+          }
+        } else if (module.metadata?.key) {
+          metadataMap[module.metadata.key] = {
+            ...module.metadata,
+            path: modulePath,
+            category: category.name,
+          };
+        }
+      } catch (e) {
+        console.warn(`Failed to load metadata from ${modulePath}`, e);
+      }
+    }
+  }
+
+  return metadataMap;
+}
+
+/**
+ * Get metadata for a specific generator by key.
+ * @param {string} key
+ * @returns {Promise<any>}
+ */
+export async function getGeneratorMetadata(key) {
+  const all = await getAllGeneratorMetadata();
+  return all[key] || {};
+}

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

@@ -0,0 +1,97 @@
+// utils/nx-context.mjs
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { getCached, setCached } from "./cache.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function execJson(cmd) {
+  const output = execSync(cmd, { encoding: "utf-8" });
+  return JSON.parse(output);
+}
+
+let _workspaceDetected;
+
+export async function detectWorkspace(startDir = process.cwd()) {
+  if (_workspaceDetected !== undefined) return _workspaceDetected;
+
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    if (existsSync(path.join(dir, "nx.json"))) {
+      _workspaceDetected = true;
+      return true;
+    }
+    dir = path.dirname(dir);
+  }
+
+  _workspaceDetected = false;
+  return false;
+}
+export async function getAllProjects() {
+  const cached = getCached("allProjects");
+  if (cached) return cached;
+
+  const projects = execJson("npx nx show projects --all --json").map((p) => p);
+  setCached("allProjects", projects);
+  return projects;
+}
+
+export async function getLibraryProjects() {
+  const cached = getCached("libraryProjects");
+  if (cached) return cached;
+
+  const projects = execJson("npx nx show projects --type=lib --json").map(
+    (p) => p
+  );
+  setCached("libraryProjects", projects);
+  return projects;
+}
+
+export async function getPluginProjects() {
+  const cached = getCached("pluginProjects");
+  if (cached) return cached;
+
+  const all = await getAllProjects();
+  const filtered = all.filter(
+    (p) => p.includes("plugin") || p.includes("extension")
+  );
+  setCached("pluginProjects", filtered);
+  return filtered;
+}
+
+export async function getAllModels() {
+  const cached = getCached("allModels");
+  if (cached) return cached;
+
+  const json = execJson("npx nx show projects --all --json");
+  const allModels = [];
+
+  for (const proj of json) {
+    const modelPath = path.join(__dirname, `../../${proj.root}/models`);
+    if (existsSync(modelPath)) {
+      const models = execSync(`ls ${modelPath}`, { encoding: "utf-8" })
+        .split("\n")
+        .filter(Boolean)
+        .map((file) => ({
+          model: file.replace(/\.ts$/, ""),
+          project: proj.name,
+        }));
+      allModels.push(...models);
+    }
+  }
+
+  setCached("allModels", allModels);
+  return allModels;
+}
+
+export async function getProjectDetails(projectName) {
+  const cacheKey = `projectDetails:${projectName}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  const details = execJson(`npx nx show project ${projectName} --json`);
+  setCached(cacheKey, details);
+  return details;
+}

package/src/lib/utils/prompts.mjs

@@ -0,0 +1,46 @@
+// utils/prompts.mjs
+
+export const DEFAULT_PROMPTS = [
+  {
+    type: "confirm",
+    name: "interactive",
+    message: "Use interactive mode?",
+    default: false,
+    when: false,
+  },
+  {
+    type: "confirm",
+    name: "dryRun",
+    message: "Dry run the command?",
+    default: false,
+    when: false,
+  },
+];
+
+export const MODEL_PROMPTS = [
+  {
+    type: "confirm",
+    name: "container",
+    message: "Requires container model?",
+    default: false,
+  },
+  {
+    type: "confirm",
+    name: "parentAware",
+    message: "Aware of parent container?",
+    default: false,
+    when: (answers) => !!answers.container,
+  },
+  {
+    type: "confirm",
+    name: "singleton",
+    message: "Is singleton?",
+    default: false,
+  },
+  {
+    type: "confirm",
+    name: "dataServices",
+    message: "Create data services?",
+    default: true,
+  },
+];

package/src/lib/utils/validators.mjs

@@ -0,0 +1,10 @@
+// utils/validators.mjs
+
+/**
+ * Validator that ensures a value is not empty.
+ * @param {string} value
+ * @returns {true|string}
+ */
+export function required(value) {
+  return value && value.trim() !== "" ? true : "This field is required.";
+}