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

package/src/lib/utils/java-home.mjs

@@ -0,0 +1,55 @@
+import { execSync } from "child_process";
+import { platform } from "os";
+import { join } from "path";
+
+export function findJavaHome() {
+  const os = platform();
+
+  if (os === "win32") {
+    return findJavaHomeWindows();
+  } else if (os === "darwin" || os === "linux") {
+    return findJavaHomeUnix();
+  } else {
+    throw new Error("Unsupported operating system: " + os);
+  }
+}
+
+function findJavaHomeWindows() {
+  try {
+    const output = execSync(
+      'reg query "HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\JDK" /s /v JavaHome'
+    );
+    const match = /JavaHome\s+REG_SZ\s+(.*)/i.exec(output.toString());
+    if (match && match[1]) {
+      return match[1].trim();
+    }
+  } catch (error) {
+    console.error("Unable to find Java home directory:", error);
+  }
+
+  return undefined;
+}
+
+function findJavaHomeUnix() {
+  try {
+    const output = execSync(
+      "echo $(dirname $(dirname $(readlink -f $(which javac))))"
+    );
+    if (output) {
+      return output.toString().trim();
+    }
+  } catch (error) {
+    console.error("Unable to find Java home directory:", error);
+  }
+
+  return undefined;
+}
+
+export function findJavaExecutable() {
+  const javaHome = findJavaHome();
+  const javaExecutable =
+    platform() === "darwin"
+      ? join(javaHome || "", "bin", "java")
+      : join(javaHome || "", "bin", "java.exe");
+  return javaExecutable;
+}

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

@@ -0,0 +1,395 @@
+// utils/nx-context.mjs
+import { execSync } from "child_process";
+import { existsSync, readFileSync, readdirSync, statSync } 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);
+}
+
+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()) {
+  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 getAllKosProjects() {
+  const cached = getCached("allKosProjects");
+  if (cached) return cached;
+
+  if (process.env.KOS_CLI_QUIET !== "true") {
+    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) {
+    if (process.env.KOS_CLI_QUIET !== "true") {
+      console.warn(`[kos-cli] No .kos.json files found in common directories, performing full workspace scan...`);
+    }
+    findKosJsonFiles(workspaceRoot, kosJsonFiles);
+  }
+  
+  const kosProjects = [];
+
+  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 {
+        // 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;
+
+  if (process.env.KOS_CLI_QUIET !== "true") {
+    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) {
+    if (process.env.KOS_CLI_QUIET !== "true") {
+      console.warn(`[kos-cli] Found ${filteredProjects.length} ${targetType} projects`);
+    }
+    return filteredProjects;
+  } else {
+    if (process.env.KOS_CLI_QUIET !== "true") {
+      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) {
+    if (process.env.KOS_CLI_QUIET !== "true") {
+      console.warn(`[kos-cli] Found ${componentProjects.length} component-compatible projects`);
+    }
+    return componentProjects;
+  } else {
+    if (process.env.KOS_CLI_QUIET !== "true") {
+      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) {
+    if (process.env.KOS_CLI_QUIET !== "true") {
+      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) {
+    if (process.env.KOS_CLI_QUIET !== "true") {
+      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;
+  
+  if (process.env.KOS_CLI_QUIET !== "true") {
+    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);
+  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,75 @@
+// 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,
+  },
+  {
+    type: "confirm",
+    name: "singleton",
+    message: "Is singleton?",
+    default: false,
+  },
+  {
+    type: "confirm",
+    name: "dataServices",
+    message: "Create data services?",
+    default: true,
+  },
+  {
+    type: "list",
+    name: "futureAware",
+    message: "Include Future-aware capabilities?",
+    choices: [
+      { name: "No Future support", value: "none" },
+      { name: "Minimal (external access only)", value: "minimal" },
+      { name: "Complete (internal + external access)", value: "complete" },
+    ],
+    default: "none",
+  },
+];
+
+export const COMPANION_PROMPTS = [
+  {
+    type: "list",
+    name: "companionPattern",
+    message: "Which companion pattern to use?",
+    choices: [
+      {
+        name: "Composition (recommended) - explicit parent access via this.parent",
+        value: "composition",
+      },
+      {
+        name: "Decorator - transparent parent access, drop-in replacement",
+        value: "decorator",
+      },
+    ],
+    default: "composition",
+  },
+];

package/src/lib/utils/studio-home.mjs

@@ -0,0 +1,12 @@
+import os from "os";
+import { join } from "path";
+export const findStudioHome = () => {
+  const homeDir = os.homedir();
+
+  const installDir =
+    os.platform() === "darwin"
+      ? join(homeDir, "Applications", "kosStudio.app")
+      : join(homeDir, "AppData", "Local", "kosStudio");
+
+  return installDir;
+};

package/src/lib/utils/utils.mjs

@@ -0,0 +1,126 @@
+import { exec, execSync, spawn } from "child_process";
+import { readFile, readdir } from "fs/promises";
+import path from "path";
+
+export async function getAllModels() {
+  console.log(`parsing projects for models...`);
+  const allProjects = await getAllProjects();
+  const models = await allProjects.reduce(async (acc, curr) => {
+    const project = await getProjectDetails(curr);
+    const list = await acc;
+
+    const config = await readdir(project.root, { withFileTypes: true });
+    if (config.find((dirent) => dirent.name === ".kos.json")) {
+      const kosConfig = JSON.parse(
+        await readFile(path.join(project.root, ".kos.json"), "utf-8")
+      );
+      if (kosConfig.models) {
+        Object.keys(kosConfig.models).forEach((model) => {
+          list.push({ model: model, project: project.name });
+        });
+      }
+    }
+    return list.sort((a, b) => {
+      if (a.project === b.project) {
+        return a.model.localeCompare(b.model);
+      } else {
+        return a.project.localeCompare(b.project);
+      }
+    });
+  }, []);
+  return models;
+}
+export async function getAllProjects() {
+  return new Promise((resolve, reject) => {
+    exec("npx nx show projects --json", (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      }
+      if (stderr) {
+        reject(stderr);
+      }
+      resolve(JSON.parse(stdout).sort((a, b) => a.localeCompare(b)));
+    });
+  });
+}
+
+export function getLibraryProjects() {
+  const projects = execSync("npx nx show projects --type lib --json");
+  return JSON.parse(projects).sort((a, b) => a.localeCompare(b));
+}
+
+export function getPluginProjects() {
+  const internal = !!process.env.INTERNAL;
+  const filter = internal ? "*plugin*" : "plugins/*";
+  const projects = execSync(
+    `npx nx show projects  --projects "${filter}" --json`
+  );
+  return JSON.parse(projects);
+}
+
+export async function getProjectDetails(project) {
+  return new Promise((resolve, reject) => {
+    exec(`npx nx show project ${project}  --json`, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      }
+      if (stderr) {
+        reject(stderr);
+      }
+      resolve(JSON.parse(stdout));
+    });
+  });
+}
+
+export function interactive(answers) {
+  return answers.interactive;
+}
+
+export function required(value) {
+  if (/.+/.test(value)) {
+    return true;
+  }
+  return false;
+}
+
+export async function execute(commandString) {
+  return new Promise((resolve, reject) => {
+    const [command, ...commandArguments] = commandString.split(" ");
+    const child = spawn(command, commandArguments, {
+      shell: true,
+    });
+
+    child.on("message", (message) => {
+      console.log(message);
+    });
+
+    child.stdout.on("data", (data) => {
+      console.log(`${data}`);
+    });
+
+    child.stderr.on("data", (data) => {
+      // console.info(`ERROR:${data}`);
+    });
+    child.on("exit", function (code, signal) {
+      console.log(`process exited with code ${code}`);
+      if (code === 0) {
+        resolve("success");
+      } else {
+        reject("failure");
+      }
+    });
+  });
+}
+
+export async function workspaceModels() {
+  const allModels = await getAllModels();
+  const workspaceModels = allModels.map((model) => {
+    return model.model;
+  });
+  return workspaceModels;
+}
+
+export async function detectWorkspace() {
+  const files = await readdir(process.cwd(), { withFileTypes: true });
+  return files.find((file) => file.name === "nx.json");
+}

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.";
+}