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

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

@@ -0,0 +1,167 @@
+import {
+  getAllProjects,
+  getLibraryProjects,
+  getModelProjects,
+  getModelComponentProjects,
+  getUIProjects,
+  getI18nProjects,
+  getPluginProjects,
+  getModelProjectsWithFallback,
+  getModelComponentProjectsWithFallback,
+  getI18nProjectsWithFallback,
+  getPluginProjectsWithFallback,
+} from "../../utils/nx-context.mjs";
+
+/**
+ * Generator for listing all projects in a workspace
+ */
+export default async function register(plop) {
+  plop.setGenerator("workspace:list-projects", {
+    description: "List all available projects in the workspace",
+    prompts: [
+      {
+        type: "list",
+        name: "projectType",
+        message: "Project type to filter by",
+        choices: [
+          { name: "All projects", value: "all" },
+          { name: "Model projects", value: "model" },
+          { name: "Model component projects", value: "model-component" },
+          { name: "UI projects", value: "ui" },
+          { name: "I18n projects", value: "i18n" },
+          { name: "Plugin projects", value: "plugin" },
+          { name: "Library projects", value: "library" },
+        ],
+        default: "all",
+      },
+      {
+        type: "list",
+        name: "outputFormat",
+        message: "Output format",
+        choices: ["json", "table", "simple"],
+        default: "json",
+      },
+      {
+        type: "confirm",
+        name: "includeFallback",
+        message: "Include fallback projects if no projects of specified type found?",
+        default: true,
+      },
+    ],
+    actions: function (answers) {
+      return [
+        async function listProjects() {
+          const includeFallback = answers.projectType === "all" ? false : (answers.includeFallback ?? true);
+          const projects = await getProjectsByType(
+            answers.projectType,
+            includeFallback
+          );
+          
+          formatProjectOutput(projects, answers.outputFormat, answers.projectType);
+          
+          return `[ok] Found ${projects.length} ${answers.projectType} projects`;
+        },
+      ];
+    },
+  });
+}
+
+// Zone 1: High-level orchestration
+async function getProjectsByType(projectType, includeFallback) {
+  switch (projectType) {
+    case "all":
+      return await getAllProjects();
+    case "model":
+      return includeFallback
+        ? await getModelProjectsWithFallback()
+        : await getModelProjects();
+    case "model-component":
+      return includeFallback
+        ? await getModelComponentProjectsWithFallback()
+        : await getModelComponentProjects();
+    case "ui":
+      return await getUIProjects();
+    case "i18n":
+      return includeFallback
+        ? await getI18nProjectsWithFallback()
+        : await getI18nProjects();
+    case "plugin":
+      return includeFallback
+        ? await getPluginProjectsWithFallback()
+        : await getPluginProjects();
+    case "library":
+      return await getLibraryProjects();
+    default:
+      throw new Error(`Unknown project type: ${projectType}`);
+  }
+}
+
+// Zone 3: Output formatting
+function formatProjectOutput(projects, format, projectType) {
+  const enrichedProjects = enrichProjectData(projects, projectType);
+  
+  switch (format) {
+    case "json":
+      console.log(JSON.stringify(enrichedProjects, null, 2));
+      break;
+      
+    case "table":
+      console.table(
+        enrichedProjects.map((p) => ({
+          Name: p.name,
+          Type: p.type || "unknown",
+        }))
+      );
+      break;
+      
+    case "simple":
+      for (const project of enrichedProjects) {
+        console.log(project.name);
+      }
+      break;
+  }
+}
+
+function enrichProjectData(projects, requestedType) {
+  return projects.map((projectName) => ({
+    name: projectName,
+    type: requestedType === "all" ? inferProjectType(projectName) : requestedType,
+  }));
+}
+
+function inferProjectType(projectName) {
+  const name = projectName.toLowerCase();
+  
+  if (name.includes("model") && !name.includes("component")) {
+    return "model";
+  }
+  if (name.includes("model") && name.includes("component")) {
+    return "model-component";
+  }
+  if (name.includes("ui") || name.includes("app")) {
+    return "ui";
+  }
+  if (name.includes("i18n") || name.includes("localization")) {
+    return "i18n";
+  }
+  if (name.includes("plugin") || name.includes("extension")) {
+    return "plugin";
+  }
+  if (name.includes("lib")) {
+    return "library";
+  }
+  
+  return "unknown";
+}
+
+// Export metadata for CLI integration
+export const metadata = {
+  key: "workspace:list-projects",
+  name: "List all available projects in the workspace",
+  description: "List all available projects in the workspace with optional type filtering",
+  namedArguments: {
+    type: "projectType",
+    format: "outputFormat",
+    fallback: "includeFallback",
+  },
+};

package/src/lib/plopfile.mjs

@@ -0,0 +1,67 @@
+// plopfile.mjs
+import { detectWorkspace } from "./utils/nx-context.mjs";
+
+// Generator registration
+import registerAddFuture from "./generators/model/add-future.mjs";
+import registerCompanion from "./generators/model/companion.mjs";
+import registerContainer from "./generators/model/container.mjs";
+import registerContext from "./generators/model/context.mjs";
+import registerHook from "./generators/model/hook.mjs";
+import registerKosModel from "./generators/model/model.mjs";
+
+import registerComponent from "./generators/component/index.mjs";
+import registerPluginComponent from "./generators/plugin/index.mjs";
+
+import registerCacheGenerators from "./generators/cache/index.mjs";
+import registerEnv from "./generators/env/index.mjs";
+import registerKab from "./generators/kab/index.mjs";
+import registerServe from "./generators/serve/index.mjs";
+import registerVersion from "./generators/version/index.mjs";
+import registerI18nNamespace from "./generators/i18n/namespace.mjs";
+import registerUiProject from "./generators/project/app.mjs";
+import registerContentProject from "./generators/project/content.mjs";
+import registerI18n from "./generators/project/i18n.mjs";
+import registerPluginProject from "./generators/project/plugin.mjs";
+import registerSplashProject from "./generators/project/splash.mjs";
+import registerTheme from "./generators/project/theme.mjs";
+import registerWorkspace from "./generators/workspace/index.mjs";
+
+import { clearCache } from "./utils/cache.mjs";
+
+export default async function (plop) {
+  plop.setActionType("clearCache", (answers, config, plop) => {
+    clearCache();
+    return "[ok] CLI cache cleared successfully.";
+  });
+
+  await registerWorkspace(plop);
+
+  const isWorkspace = await detectWorkspace();
+  if (!isWorkspace) {
+    console.warn(
+      "[kos-cli] Not inside an Nx workspace. Only a subset of generators are available."
+    );
+    return;
+  }
+
+  await registerKosModel(plop);
+  await registerAddFuture(plop);
+  await registerHook(plop);
+  await registerCompanion(plop);
+  await registerContainer(plop);
+  await registerContext(plop);
+  await registerComponent(plop);
+  await registerPluginComponent(plop);
+  await registerTheme(plop);
+  await registerContentProject(plop);
+  await registerUiProject(plop);
+  await registerPluginProject(plop);
+  await registerSplashProject(plop);
+  await registerI18n(plop);
+  await registerI18nNamespace(plop);
+  await registerEnv(plop);
+  await registerKab(plop);
+  await registerServe(plop);
+  await registerVersion(plop);
+  await registerCacheGenerators(plop);
+}

package/src/lib/routing-plopfile.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { spawn } from "child_process";
+import minimist from "minimist";
+import { getAllGeneratorMetadata } from "./utils/generator-loader.mjs";
+
+const args = process.argv.slice(2);
+const argv = minimist(args);
+
+export default async function (plop) {
+  const metadata = await getAllGeneratorMetadata();
+
+  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,
+      });
+
+      child.on("exit", (code) => {
+        if (code === 0) resolve(`Executed kosui ${answers.template}`);
+        else reject(new Error(`Failed with code ${code}`));
+      });
+    });
+  });
+
+  plop.setGenerator("help", {
+    description: "Select a task to run",
+    prompts: [
+      {
+        type: "list",
+        name: "template",
+        message: "Choose a task to run:",
+        choices,
+      },
+    ],
+    actions: [
+      {
+        type: "execCLI",
+      },
+    ],
+  });
+}

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/action-factory.mjs

@@ -0,0 +1,9 @@
+export const actionFactory = (action, metadata) => {
+  return () => {
+    const _actions = [{ type: action }];
+    if (metadata.invalidateCache) {
+      _actions.push({ type: "clearCache" });
+    }
+    return _actions;
+  };
+};

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 = 600 * 1000;
+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/command-builder.mjs

@@ -0,0 +1,94 @@
+/**
+ * Builds a non-interactive command string from interactive session answers
+ * This helps users understand how to run the same command without prompts
+ */
+
+/**
+ * Converts interactive prompt answers back to CLI command arguments
+ * @param {string} command - The generator command name
+ * @param {Object} answers - The answers collected from prompts
+ * @param {Object} meta - Generator metadata including namedArguments mapping
+ * @returns {string|null} The equivalent CLI command string, or null if cannot be built
+ */
+export function buildNonInteractiveCommand(command, answers, meta) {
+  if (!meta?.namedArguments) {
+    return null;
+  }
+
+  const args = [`kosui ${command}`];
+  const reverseMap = {};
+
+  // Create reverse mapping from prompt names to CLI arguments
+  Object.entries(meta.namedArguments).forEach(([cliArg, promptName]) => {
+    // Skip special flags that don't map to prompts
+    if (cliArg !== "interactive" && cliArg !== "dryRun") {
+      reverseMap[promptName] = cliArg;
+    }
+  });
+
+  // Build command arguments from answers
+  Object.entries(answers).forEach(([promptName, value]) => {
+    const cliArg = reverseMap[promptName];
+    if (cliArg && value !== undefined && value !== null && value !== "") {
+      args.push(formatArgument(cliArg, value));
+    }
+  });
+
+  // Add dryRun if it was provided
+  if (answers.dryRun) {
+    args.push("--dryRun");
+  }
+
+  return args.join(" ");
+}
+
+/**
+ * Formats a single CLI argument based on its value type
+ * @param {string} argName - The CLI argument name
+ * @param {any} value - The value for the argument
+ * @returns {string} The formatted CLI argument string
+ */
+function formatArgument(argName, value) {
+  // Handle boolean values
+  if (typeof value === "boolean") {
+    if (value) {
+      return `--${argName}`;
+    } else {
+      // For false booleans, explicitly set to false
+      // This ensures the command can be replicated exactly
+      return `--${argName}=false`;
+    }
+  }
+
+  // Handle string/number values
+  const stringValue = String(value);
+
+  // Check if value needs escaping
+  if (needsEscaping(stringValue)) {
+    // Use double quotes and escape internal quotes
+    return `--${argName}="${stringValue.replace(/"/g, '\\"')}"`;
+  }
+
+  return `--${argName}=${stringValue}`;
+}
+
+/**
+ * Determines if a string value needs shell escaping
+ * @param {string} value - The value to check
+ * @returns {boolean} True if the value needs escaping
+ */
+function needsEscaping(value) {
+  // Check for characters that need escaping in shell
+  return /[\s'"$`\\!]/.test(value);
+}
+
+/**
+ * Determines if the CLI is running in interactive mode
+ * @param {Object} parsedArgs - Parsed command line arguments
+ * @param {boolean} hasAnyAnswers - Whether any answers were provided via CLI
+ * @returns {boolean} True if running in interactive mode
+ */
+export function isRunningInteractively(parsedArgs, hasAnyAnswers) {
+  const forceInteractive = parsedArgs.interactive || parsedArgs.i;
+  return forceInteractive || (!hasAnyAnswers && !parsedArgs.help);
+}

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/index.mjs

@@ -0,0 +1 @@
+export * from "./utils.mjs";