@kosdev-code/kos-ui-cli 2.1.39 → 3.0.1

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

@@ -1,97 +1,548 @@
-// utils/nx-context.mjs
-import { execSync } from "child_process";
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
-import path from "path";
+// src/lib/utils/nx-context.mjs
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import path3 from "path";
 import { fileURLToPath } from "url";
-import { getCached, setCached } from "./cache.mjs";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// src/lib/utils/cache.mjs
+import fs from "fs";
+import path from "path";
+var CACHE_PATH = path.resolve(".nx/cli-cache.json");
+var CACHE_TTL = 600 * 1e3;
+var ARGS = process.argv;
+var DISABLE_CACHE = process.env.DISABLE_CACHE === "true" || process.env.REFRESH === "true";
+var _cache = {};
+var _loaded = false;
+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;
+}
+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;
+}
+function setCached(key, data) {
+  loadCacheFromDisk();
+  _cache[key] = {
+    data,
+    timestamp: Date.now()
+  };
+  saveCacheToDisk();
+}
+
+// ../kos-codegen-core/src/lib/generate-files.ts
+import * as ejs from "ejs";
+
+// ../kos-codegen-core/src/lib/logger.ts
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var activeLogger = noopLogger;
+function getCodegenLogger() {
+  return activeLogger;
+}
 
-function execJson(cmd) {
-  const output = execSync(cmd, { encoding: "utf-8" });
-  return JSON.parse(output);
+// ../kos-codegen-core/src/lib/project-discovery.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import fg from "fast-glob";
+function discoverProjects(workspaceRoot) {
+  const logger = getCodegenLogger();
+  const projects = /* @__PURE__ */ new Map();
+  const projectJsonPaths = fg.sync("**/project.json", {
+    cwd: workspaceRoot,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
+    absolute: false
+  });
+  for (const relPath of projectJsonPaths) {
+    const absPath = path2.join(workspaceRoot, relPath);
+    try {
+      const raw = fs2.readFileSync(absPath, "utf-8");
+      const json = JSON.parse(raw);
+      const projectRoot = path2.dirname(relPath);
+      const name = json.name ?? path2.basename(projectRoot);
+      const config = {
+        name,
+        root: projectRoot,
+        sourceRoot: json.sourceRoot ?? path2.join(projectRoot, "src"),
+        projectType: json.projectType,
+        targets: json.targets,
+        tags: json.tags
+      };
+      projects.set(name, config);
+      logger.debug(`Discovered project: ${name} at ${projectRoot}`);
+    } catch (err) {
+      logger.warn(`Failed to parse ${absPath}: ${err}`);
+    }
+  }
+  logger.info(`Discovered ${projects.size} projects`);
+  return projects;
+}
+function findProjectByName(workspaceRoot, projectName, projects) {
+  const map = projects ?? discoverProjects(workspaceRoot);
+  return map.get(projectName);
 }
 
+// ../kos-codegen-core/src/lib/format-files.ts
+import prettier from "prettier";
+
+// ../kos-codegen-core/src/lib/generators/update-model-index.ts
+import * as ts from "typescript";
+
+// ../kos-codegen-core/src/lib/generators/component/types.ts
+var PLUGIN_TYPES = {
+  CUI: "cui",
+  UTILITY: "utility",
+  TROUBLE_ACTION: "troubleAction",
+  SETUP: "setup",
+  SETTING: "setting",
+  NAV: "nav",
+  CONTROL_POUR: "controlPour",
+  CUSTOM: "custom"
+};
+var CONTRIBUTION_TYPE_MAP = {
+  [PLUGIN_TYPES.SETUP]: "setup",
+  [PLUGIN_TYPES.CUI]: "cui",
+  [PLUGIN_TYPES.UTILITY]: "utility",
+  [PLUGIN_TYPES.SETTING]: "setting",
+  [PLUGIN_TYPES.NAV]: "nav",
+  [PLUGIN_TYPES.TROUBLE_ACTION]: "trouble-action",
+  [PLUGIN_TYPES.CONTROL_POUR]: "control-pour",
+  [PLUGIN_TYPES.CUSTOM]: "custom"
+};
+var LOCALIZED_PLUGIN_TYPES = /* @__PURE__ */ new Set([
+  PLUGIN_TYPES.CUI,
+  PLUGIN_TYPES.UTILITY,
+  PLUGIN_TYPES.SETUP,
+  PLUGIN_TYPES.SETTING,
+  PLUGIN_TYPES.NAV,
+  PLUGIN_TYPES.CONTROL_POUR,
+  PLUGIN_TYPES.TROUBLE_ACTION,
+  PLUGIN_TYPES.CUSTOM
+]);
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/base.ts
+var BasePluginHandler = class {
+  getContributionKey() {
+    return this.contributionKey;
+  }
+  requiresLocalization() {
+    return this.requiresI18n;
+  }
+  getTemplatePath() {
+    return this.contributionKey;
+  }
+  /**
+   * Helper to create experience configuration
+   */
+  createExperience(options, experienceId) {
+    const compPath = this.getComponentPath(options);
+    return {
+      id: experienceId,
+      component: options.namePascalCase,
+      location: `./src/${compPath}`
+    };
+  }
+  /**
+   * Helper to get component path
+   */
+  getComponentPath(options) {
+    return `${options.appDirectory}/${this.contributionKey}/${options.nameDashCase}/${options.nameDashCase}.tsx`;
+  }
+  /**
+   * Helper to create config prefix
+   */
+  getConfigPrefix(options) {
+    return `${options.appProject}.${options.nameCamelCase}`;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/control-pour-handler.ts
+var ControlPourPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.CONTROL_POUR;
+  contributionKey = "control-pour";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.controlPour.experience`;
+    const contribution = {
+      id: `${configPrefix}.controlPour`,
+      title: `${configPrefix}.controlPour.title`,
+      namespace: options.appProject,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        controlPour: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/cui-handler.ts
+var CuiPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.CUI;
+  contributionKey = "cui";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.cui.experience`;
+    const contribution = {
+      id: configPrefix,
+      title: `${configPrefix}.cui.title`,
+      namespace: options.appProject,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        cui: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/custom-handler.ts
+var CustomPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.CUSTOM;
+  contributionKey = "custom";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.${options.contributionKey || "custom"}.experience`;
+    const userContributionKey = options.contributionKey || "custom";
+    const contribution = {
+      id: configPrefix,
+      title: `${configPrefix}.${userContributionKey}.title`,
+      namespace: options.appProject,
+      experienceId
+      // TODO: Add additional fields as required by the plugin-explorer specification
+      // Refer to the plugin-explorer documentation for your specific contribution type
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        [userContributionKey]: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+  getTemplatePath() {
+    return this.contributionKey || "custom";
+  }
+  getComponentPath(options) {
+    const pathKey = options.contributionKey || "custom";
+    return `${options.appDirectory}/${pathKey}/${options.nameDashCase}/${options.nameDashCase}.tsx`;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/default-handler.ts
+var DefaultComponentHandler = class extends BasePluginHandler {
+  pluginType = "component";
+  contributionKey = "components";
+  requiresI18n = false;
+  createConfiguration(options) {
+    const compPath = this.getComponentPath(options);
+    const viewConfig = {
+      id: `${options.appProject}.${options.nameCamelCase}`,
+      title: "ddk.ncui.config.title",
+      namespace: options.appProject,
+      component: options.namePascalCase,
+      location: `./src/${compPath}`
+    };
+    return {
+      contributions: {},
+      experiences: {},
+      views: {
+        [this.getTabViewKey()]: [viewConfig]
+      }
+    };
+  }
+  getTabViewKey() {
+    return "ddk.ncui.settings.tabView";
+  }
+  getTemplatePath() {
+    return "files";
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/nav-handler.ts
+var NavPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.NAV;
+  contributionKey = "nav";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.nav.experience`;
+    const contribution = {
+      id: `${configPrefix}.nav`,
+      title: `${configPrefix}.nav.title`,
+      namespace: options.appProject,
+      navDescriptor: options.nameLowerCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        navViews: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/setting-handler.ts
+var SettingPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.SETTING;
+  contributionKey = "setting";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.settings.experience`;
+    const contribution = {
+      id: `${configPrefix}.setting`,
+      title: `${configPrefix}.setting.title`,
+      namespace: options.appProject,
+      settingsGroup: options.group || "general",
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        settings: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/setup-handler.ts
+var SetupPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.SETUP;
+  contributionKey = "setup";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.setup.experience`;
+    const contribution = {
+      id: `${configPrefix}.setup`,
+      title: `${configPrefix}.setup.title`,
+      namespace: options.appProject,
+      setupDescriptor: options.nameCamelCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        setupStep: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/trouble-action-handler.ts
+var TroubleActionPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.TROUBLE_ACTION;
+  contributionKey = "trouble-action";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.troubleAction.experience`;
+    const contribution = {
+      id: `${configPrefix}.troubleAction`,
+      title: `${configPrefix}.troubleAction.title`,
+      namespace: options.appProject,
+      troubleType: options.nameCamelCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        troubleActions: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/utility-handler.ts
+var UtilityPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.UTILITY;
+  contributionKey = "utility";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.util.experience`;
+    const contribution = {
+      id: `${configPrefix}.util`,
+      title: `${configPrefix}.utility.title`,
+      namespace: options.appProject,
+      utilDescriptor: options.nameCamelCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        utilities: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/factory.ts
+var PluginHandlerFactory = class {
+  static handlers = /* @__PURE__ */ new Map([
+    [PLUGIN_TYPES.CUI, CuiPluginHandler],
+    [PLUGIN_TYPES.UTILITY, UtilityPluginHandler],
+    [PLUGIN_TYPES.SETTING, SettingPluginHandler],
+    [PLUGIN_TYPES.SETUP, SetupPluginHandler],
+    [PLUGIN_TYPES.NAV, NavPluginHandler],
+    [PLUGIN_TYPES.CONTROL_POUR, ControlPourPluginHandler],
+    [PLUGIN_TYPES.TROUBLE_ACTION, TroubleActionPluginHandler],
+    [PLUGIN_TYPES.CUSTOM, CustomPluginHandler]
+  ]);
+  static createHandler(pluginType) {
+    if (!pluginType) {
+      return new DefaultComponentHandler();
+    }
+    const HandlerClass = this.handlers.get(pluginType);
+    if (!HandlerClass) {
+      console.warn(
+        `No handler found for plugin type: ${pluginType}. Using default handler.`
+      );
+      return new DefaultComponentHandler();
+    }
+    return new HandlerClass();
+  }
+  static isValidPluginType(type) {
+    return this.handlers.has(type);
+  }
+};
+
+// src/lib/utils/nx-context.mjs
+var __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
 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')) {
+      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);
-      
+      const fullPath = path3.join(dir, entry);
       try {
         const stat = statSync(fullPath);
-        
-        if (stat.isFile() && entry === '.kos.json') {
+        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') {
+          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;
-
+var _workspaceDetected;
+async function detectWorkspace(startDir = process.cwd()) {
+  if (_workspaceDetected !== void 0)
+    return _workspaceDetected;
   let dir = startDir;
-  while (dir !== path.dirname(dir)) {
-    if (existsSync(path.join(dir, "nx.json"))) {
+  while (dir !== path3.dirname(dir)) {
+    if (existsSync2(path3.join(dir, "nx.json"))) {
       _workspaceDetected = true;
       return true;
     }
-    dir = path.dirname(dir);
+    dir = path3.dirname(dir);
   }
-
   _workspaceDetected = false;
   return false;
 }
-export async function getAllProjects() {
+async function getAllProjects() {
   const cached = getCached("allProjects");
-  if (cached) return cached;
-
-  const projects = execJson("npx nx show projects --all --json").map((p) => p);
+  if (cached)
+    return cached;
+  const projectMap = discoverProjects(process.cwd());
+  const projects = Array.from(projectMap.keys());
   setCached("allProjects", projects);
   return projects;
 }
-
-export async function getLibraryProjects() {
+async function getLibraryProjects() {
   const cached = getCached("libraryProjects");
-  if (cached) return cached;
-
-  const projects = execJson("npx nx show projects --type=lib --json").map(
-    (p) => p
-  );
+  if (cached)
+    return cached;
+  const projectMap = discoverProjects(process.cwd());
+  const projects = Array.from(projectMap.values()).filter((p) => p.projectType === "library").map((p) => p.name);
   setCached("libraryProjects", projects);
   return projects;
 }
-
-export async function getPluginProjects() {
+async function getPluginProjects() {
   const cached = getCached("pluginProjects");
-  if (cached) return cached;
-
+  if (cached)
+    return cached;
   const all = await getAllProjects();
   const filtered = all.filter(
     (p) => p.includes("plugin") || p.includes("extension")
@@ -99,71 +550,52 @@ export async function getPluginProjects() {
   setCached("pluginProjects", filtered);
   return filtered;
 }
-
-export async function getAllKosProjects() {
+async function getAllKosProjects() {
   const cached = getCached("allKosProjects");
-  if (cached) return cached;
-
+  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 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)) {
+    const dirPath = path3.join(workspaceRoot, dir);
+    if (existsSync2(dirPath)) {
       findKosJsonFiles(dirPath, kosJsonFiles);
     }
   }
-  
-  // Also check the workspace root for any .kos.json files
-  const rootKosJson = path.join(workspaceRoot, '.kos.json');
-  if (existsSync(rootKosJson)) {
+  const rootKosJson = path3.join(workspaceRoot, ".kos.json");
+  if (existsSync2(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
+      const kosConfig = JSON.parse(readFileSync2(kosJsonPath, "utf-8"));
+      const projectDir = path3.dirname(kosJsonPath);
       let projectName = null;
-      const projectJsonPath = path.join(projectDir, 'project.json');
-      
-      if (existsSync(projectJsonPath)) {
+      const projectJsonPath = path3.join(projectDir, "project.json");
+      if (existsSync2(projectJsonPath)) {
         try {
-          const projectJson = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+          const projectJson = JSON.parse(readFileSync2(projectJsonPath, "utf-8"));
           projectName = projectJson.name;
         } catch (error) {
-          // If we can't read project.json, use directory name as fallback
-          projectName = path.basename(projectDir);
+          projectName = path3.basename(projectDir);
         }
       } else {
-        // Use directory name as fallback
-        projectName = path.basename(projectDir);
+        projectName = path3.basename(projectDir);
       }
-
-      // Skip root-type configurations as they are not projects
-      if (kosConfig.type === 'root') {
+      if (kosConfig.type === "root") {
         continue;
       }
-
       kosProjects.push({
         name: projectName,
         path: projectDir,
@@ -175,59 +607,43 @@ export async function getAllKosProjects() {
       console.warn(`[kos-cli] Error reading ${kosJsonPath}: ${error.message}`);
     }
   }
-
   setCached("allKosProjects", kosProjects);
   return kosProjects;
 }
-
-export async function getProjectsByType(targetType) {
+async function getProjectsByType(targetType) {
   const cacheKey = `projectsByType:${targetType}`;
   const cached = getCached(cacheKey);
-  if (cached) return cached;
-
+  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;
-      
+    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() {
+async function getModelProjects() {
   return await getProjectsByType("model");
 }
-
-export async function getUIProjects() {
+async function getUIProjects() {
   return await getProjectsByType("ui");
 }
-
-export async function getModelComponentProjects() {
+async function getModelComponentProjects() {
   return await getProjectsByType("model-component");
 }
-
-export async function getI18nProjects() {
+async function getI18nProjects() {
   return await getProjectsByType("i18n");
 }
-
-
-export async function getProjectsByTypeWithFallback(targetType, fallbackFunction = getLibraryProjects) {
+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`);
@@ -240,50 +656,37 @@ export async function getProjectsByTypeWithFallback(targetType, fallbackFunction
     return await fallbackFunction();
   }
 }
-
-export async function getModelProjectsWithFallback() {
+async function getModelProjectsWithFallback() {
   return await getProjectsByTypeWithFallback("model", getLibraryProjects);
 }
-
-export async function getModelComponentProjectsWithFallback() {
+async function getModelComponentProjectsWithFallback() {
   return await getProjectsByTypeWithFallback("model-component", getAllProjects);
 }
-
-export async function getProjectsByMultipleTypes(targetTypes) {
-  const cacheKey = `projectsByMultipleTypes:${targetTypes.join(',')}`;
+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(', ')}...`);
+  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;
+    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() {
+async function getComponentCompatibleProjects() {
   return await getProjectsByMultipleTypes(["ui", "splash", "model-component"]);
 }
-
-export async function getComponentCompatibleProjectsWithFallback() {
+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`);
@@ -296,13 +699,10 @@ export async function getComponentCompatibleProjectsWithFallback() {
     return await getAllProjects();
   }
 }
-
-export async function getI18nProjectsWithFallback() {
+async function getI18nProjectsWithFallback() {
   return await getProjectsByTypeWithFallback("i18n", getAllProjects);
 }
-
-export async function getPluginProjectsWithFallback() {
-  // First try type-based filtering
+async function getPluginProjectsWithFallback() {
   const pluginProjectsByType = await getProjectsByType("plugin");
   if (pluginProjectsByType.length > 0) {
     if (process.env.KOS_CLI_QUIET !== "true") {
@@ -310,8 +710,6 @@ export async function getPluginProjectsWithFallback() {
     }
     return pluginProjectsByType;
   }
-  
-  // Fall back to existing name-based filtering
   const pluginProjectsByName = await getPluginProjects();
   if (pluginProjectsByName.length > 0) {
     if (process.env.KOS_CLI_QUIET !== "true") {
@@ -319,31 +717,25 @@ export async function getPluginProjectsWithFallback() {
     }
     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() {
+async function getAllModels() {
   const cached = getCached("allModels");
-  if (cached) return cached;
-  
+  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 });
+        models.push({ 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);
@@ -351,22 +743,19 @@ export async function getAllModels() {
       return a.project.localeCompare(b.project);
     }
   });
-
   setCached("allModels", models);
   return models;
 }
-
-export async function getWorkspaceDefaults() {
+async function getWorkspaceDefaults() {
   const cached = getCached("workspaceDefaults");
-  if (cached) return cached;
-
+  if (cached)
+    return cached;
   const workspaceRoot = process.cwd();
-  const rootKosJsonPath = path.join(workspaceRoot, '.kos.json');
-  
-  if (existsSync(rootKosJsonPath)) {
+  const rootKosJsonPath = path3.join(workspaceRoot, ".kos.json");
+  if (existsSync2(rootKosJsonPath)) {
     try {
-      const rootConfig = JSON.parse(readFileSync(rootKosJsonPath, "utf-8"));
-      if (rootConfig.type === 'root' && rootConfig.generator?.defaults) {
+      const rootConfig = JSON.parse(readFileSync2(rootKosJsonPath, "utf-8"));
+      if (rootConfig.type === "root" && rootConfig.generator?.defaults) {
         setCached("workspaceDefaults", rootConfig.generator.defaults);
         return rootConfig.generator.defaults;
       }
@@ -374,22 +763,47 @@ export async function getWorkspaceDefaults() {
       console.warn(`[kos-cli] Error reading workspace defaults: ${error.message}`);
     }
   }
-  
   setCached("workspaceDefaults", {});
   return {};
 }
-
-export async function getDefaultProjectForType(projectType) {
+async function getDefaultProjectForType(projectType) {
   const defaults = await getWorkspaceDefaults();
   return defaults[projectType] || null;
 }
-
-export async function getProjectDetails(projectName) {
+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`);
+  if (cached)
+    return cached;
+  const details = findProjectByName(process.cwd(), projectName);
+  if (!details) {
+    throw new Error(`Project "${projectName}" not found in workspace`);
+  }
   setCached(cacheKey, details);
   return details;
 }
+export {
+  detectWorkspace,
+  getAllKosProjects,
+  getAllModels,
+  getAllProjects,
+  getComponentCompatibleProjects,
+  getComponentCompatibleProjectsWithFallback,
+  getDefaultProjectForType,
+  getI18nProjects,
+  getI18nProjectsWithFallback,
+  getLibraryProjects,
+  getModelComponentProjects,
+  getModelComponentProjectsWithFallback,
+  getModelProjects,
+  getModelProjectsWithFallback,
+  getPluginProjects,
+  getPluginProjectsWithFallback,
+  getProjectDetails,
+  getProjectsByMultipleTypes,
+  getProjectsByType,
+  getProjectsByTypeWithFallback,
+  getUIProjects,
+  getWorkspaceDefaults
+};
+//# sourceMappingURL=nx-context.mjs.map