@kosdev-code/kos-ui-cli 2.1.38 → 3.0.0

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

@@ -1,11 +1,1215 @@
-// generators/plugin/plugin.mjs
-
-import { execute } from "../../utils/exec.mjs";
-import { getPluginProjectsWithFallback } from "../../utils/nx-context.mjs";
-import { required } from "../../utils/validators.mjs";
-export const metadata = [
-  { 
-    key: "pluginComponent", 
+// ../kos-codegen-core/src/lib/codegen-filesystem.ts
+import * as fs from "fs";
+import * as path from "path";
+var TrackingFileSystem = class {
+  inner;
+  _writtenPaths = [];
+  constructor(inner) {
+    this.inner = inner;
+  }
+  get root() {
+    return this.inner.root;
+  }
+  get writtenPaths() {
+    return [...this._writtenPaths];
+  }
+  read(filePath) {
+    return this.inner.read(filePath);
+  }
+  write(filePath, content) {
+    this.inner.write(filePath, content);
+    this._writtenPaths.push(
+      path.isAbsolute(filePath) ? filePath : path.join(this.inner.root, filePath)
+    );
+  }
+  exists(filePath) {
+    return this.inner.exists(filePath);
+  }
+  delete(filePath) {
+    this.inner.delete(filePath);
+  }
+  listFiles(dirPath) {
+    return this.inner.listFiles(dirPath);
+  }
+};
+var DirectFileSystem = class {
+  root;
+  constructor(workspaceRoot) {
+    this.root = path.resolve(workspaceRoot);
+  }
+  read(filePath) {
+    const abs = this.resolve(filePath);
+    try {
+      return fs.readFileSync(abs, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  write(filePath, content) {
+    const abs = this.resolve(filePath);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, content, "utf-8");
+  }
+  exists(filePath) {
+    return fs.existsSync(this.resolve(filePath));
+  }
+  delete(filePath) {
+    const abs = this.resolve(filePath);
+    try {
+      fs.unlinkSync(abs);
+    } catch {
+    }
+  }
+  listFiles(dirPath) {
+    const abs = this.resolve(dirPath);
+    if (!fs.existsSync(abs)) {
+      return [];
+    }
+    return this.walkDir(abs).map((file) => path.relative(this.root, file));
+  }
+  resolve(filePath) {
+    if (path.isAbsolute(filePath)) {
+      return filePath;
+    }
+    return path.join(this.root, filePath);
+  }
+  walkDir(dir) {
+    const results = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...this.walkDir(full));
+      } else {
+        results.push(full);
+      }
+    }
+    return results;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generate-files.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+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;
+}
+
+// ../kos-codegen-core/src/lib/generate-files.ts
+function generateFilesFromTemplates(codegenFs, srcFolder, destFolder, substitutions) {
+  const logger = getCodegenLogger();
+  const templateFiles = walkTemplateDir(srcFolder);
+  for (const templateFile of templateFiles) {
+    const relPath = path2.relative(srcFolder, templateFile);
+    let destRelPath = interpolateFilename(relPath, substitutions);
+    if (destRelPath.endsWith(".template")) {
+      destRelPath = destRelPath.slice(0, -".template".length);
+    }
+    const destPath = path2.join(destFolder, destRelPath);
+    const rawContent = fs2.readFileSync(templateFile, "utf-8");
+    const rendered = ejs.render(rawContent, substitutions, {
+      filename: templateFile
+      // for EJS error messages and includes
+    });
+    logger.debug(`Generating ${destPath}`);
+    codegenFs.write(destPath, rendered);
+  }
+}
+function interpolateFilename(filePath, substitutions) {
+  return filePath.replace(/__([^_]+)__/g, (match, key) => {
+    if (key in substitutions) {
+      return String(substitutions[key]);
+    }
+    return match;
+  });
+}
+function walkTemplateDir(dir) {
+  const results = [];
+  const entries = fs2.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkTemplateDir(full));
+    } else {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+// ../kos-codegen-core/src/lib/project-discovery.ts
+import * as fs3 from "fs";
+import * as path3 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 = path3.join(workspaceRoot, relPath);
+    try {
+      const raw = fs3.readFileSync(absPath, "utf-8");
+      const json = JSON.parse(raw);
+      const projectRoot = path3.dirname(relPath);
+      const name = json.name ?? path3.basename(projectRoot);
+      const config = {
+        name,
+        root: projectRoot,
+        sourceRoot: json.sourceRoot ?? path3.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/json-utils.ts
+function readJson(codegenFs, filePath) {
+  const content = codegenFs.read(filePath);
+  if (content === null) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  return JSON.parse(content);
+}
+function writeJson(codegenFs, filePath, value) {
+  codegenFs.write(filePath, JSON.stringify(value, null, 2) + "\n");
+}
+function updateJson(codegenFs, filePath, updater) {
+  const current = readJson(codegenFs, filePath);
+  const updated = updater(current);
+  writeJson(codegenFs, filePath, updated);
+}
+
+// ../kos-codegen-core/src/lib/format-files.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import prettier from "prettier";
+var FORMATTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".json",
+  ".css",
+  ".scss",
+  ".md",
+  ".yaml",
+  ".yml",
+  ".html"
+]);
+async function formatFiles(workspaceRoot, filePaths) {
+  const logger = getCodegenLogger();
+  for (const filePath of filePaths) {
+    const ext = path4.extname(filePath);
+    if (!FORMATTABLE_EXTENSIONS.has(ext)) {
+      continue;
+    }
+    try {
+      const content = fs4.readFileSync(filePath, "utf-8");
+      const options = await prettier.resolveConfig(filePath, {
+        editorconfig: true
+      });
+      const formatted = await prettier.format(content, {
+        ...options,
+        filepath: filePath
+      });
+      fs4.writeFileSync(filePath, formatted, "utf-8");
+      logger.debug(`Formatted ${path4.relative(workspaceRoot, filePath)}`);
+    } catch (err) {
+      logger.warn(`Failed to format ${filePath}: ${err}`);
+    }
+  }
+}
+
+// ../kos-codegen-core/src/lib/name-utils.ts
+function dashCase(input) {
+  return input.replace(/\s+/g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function camelCase(input) {
+  if (input.length === 0)
+    return "";
+  const words = input.split(/-|\s+/);
+  if (words.length > 0 && words[0].length > 0) {
+    words[0] = words[0].charAt(0).toLowerCase() + words[0].slice(1);
+  }
+  for (let i = 1; i < words.length; i++) {
+    words[i] = words[i].charAt(0).toUpperCase() + words[i].slice(1);
+  }
+  return words.join("");
+}
+function pascalCase(input) {
+  if (input.length === 0)
+    return "";
+  const cc = camelCase(input);
+  return cc[0].toUpperCase() + cc.slice(1);
+}
+function properCase(input) {
+  const words = input.toLowerCase().replaceAll("-", " ").split(" ").filter(Boolean);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i][0].toUpperCase() + words[i].slice(1);
+  }
+  return words.join("");
+}
+function constantCase(input) {
+  if (input.length === 0)
+    return "";
+  return input.toUpperCase().split(/[\s-]+/).filter(Boolean).join("_");
+}
+
+// ../kos-codegen-core/src/lib/normalize-values.ts
+var normalizeValue = (optionsName, value) => ({
+  [`${camelCase(optionsName)}CamelCase`]: camelCase(value),
+  [`${camelCase(optionsName)}ConstantCase`]: constantCase(value),
+  [`${camelCase(optionsName)}DashCase`]: dashCase(value),
+  [`${camelCase(optionsName)}PascalCase`]: pascalCase(value),
+  [`${camelCase(optionsName)}ProperCase`]: properCase(value),
+  [`${camelCase(optionsName)}LowerCase`]: value.toLowerCase(),
+  [`${optionsName}`]: value
+});
+var normalizeAllValues = (options) => {
+  let normalizedValues = {};
+  for (const key in options) {
+    if (Object.prototype.hasOwnProperty.call(options, key)) {
+      const element = options[key];
+      const newOptions = typeof element !== "string" || element === "" ? { [key]: element } : normalizeValue(key, element);
+      normalizedValues = {
+        ...normalizedValues,
+        ...newOptions
+      };
+    }
+  }
+  return normalizedValues;
+};
+
+// ../kos-codegen-core/src/lib/kos-config.ts
+import * as path5 from "path";
+function getKosProjectConfiguration(codegenFs, projectName, projects) {
+  const project = findProjectByName(codegenFs.root, projectName, projects);
+  if (!project)
+    return void 0;
+  const configPath = path5.join(project.root, ".kos.json");
+  if (!codegenFs.exists(configPath)) {
+    const defaultConfig = {
+      name: `${dashCase(projectName)}-model`,
+      type: "kos.model",
+      version: "0.1.0",
+      models: {},
+      generator: { defaults: { model: { folder: "" } } }
+    };
+    codegenFs.write(configPath, JSON.stringify(defaultConfig, null, 2));
+  }
+  const content = codegenFs.read(configPath);
+  return content ? JSON.parse(content) : void 0;
+}
+
+// ../kos-codegen-core/src/lib/template-resolver.ts
+import * as path6 from "path";
+import * as fs5 from "fs";
+function findPackageRoot() {
+  if (process.env.KOS_TEMPLATE_BASE_DIR) {
+    return process.env.KOS_TEMPLATE_BASE_DIR;
+  }
+  let dir = __dirname;
+  while (dir !== path6.dirname(dir)) {
+    const pkgPath = path6.join(dir, "package.json");
+    if (fs5.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "@kosdev-code/kos-codegen-core") {
+          return dir;
+        }
+      } catch {
+      }
+    }
+    dir = path6.dirname(dir);
+  }
+  return path6.resolve(__dirname, "..", "..");
+}
+function getTemplateDir(generatorName) {
+  return path6.join(findPackageRoot(), "templates", generatorName);
+}
+
+// ../kos-codegen-core/src/lib/generators/normalize-options.ts
+import * as path7 from "path";
+function normalizeOptions(codegenFs, options, projects) {
+  const toNormalize = {
+    name: options.name
+  };
+  if (options.modelName) {
+    toNormalize.modelName = options.modelName;
+  }
+  if (options.companionModel) {
+    toNormalize.companionModel = options.companionModel;
+  }
+  const normalizedValues = normalizeAllValues(toNormalize);
+  const modelProject = options.modelProject;
+  const registrationProject = options.registrationProject || "";
+  const useModelProject = modelProject !== "__NONE__";
+  let importPath = "";
+  if (useModelProject) {
+    const modelProjectConfig = findProjectByName(
+      codegenFs.root,
+      modelProject,
+      projects
+    );
+    if (modelProjectConfig) {
+      const pkgJsonPath = path7.join(modelProjectConfig.root, "package.json");
+      try {
+        const pkgJson = readJson(codegenFs, pkgJsonPath);
+        importPath = pkgJson.name || "";
+      } catch {
+        importPath = "";
+      }
+    }
+  }
+  const booleanDefaults = {
+    companion: false,
+    skipRegistration: false
+  };
+  return {
+    ...booleanDefaults,
+    ...options,
+    ...normalizedValues,
+    modelProject,
+    importPath,
+    registrationProject,
+    template: ""
+  };
+}
+
+// ../kos-codegen-core/src/lib/generators/update-model-index.ts
+import * as ts from "typescript";
+
+// ../kos-codegen-core/src/lib/generators/component/generate-component.ts
+import * as path10 from "path";
+
+// ../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);
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/utils/file-generator.ts
+import * as path8 from "path";
+function generateComponentFiles(codegenFs, templateBaseDir, templateSubPath, targetPath, options) {
+  generateFilesFromTemplates(
+    codegenFs,
+    path8.join(templateBaseDir, templateSubPath),
+    targetPath,
+    options
+  );
+  if (options.useEmotionCss) {
+    deleteCssFile(codegenFs, targetPath, options);
+  }
+}
+function deleteCssFile(codegenFs, targetPath, options) {
+  const cssPath = path8.join(targetPath, `${options.nameDashCase}.css`);
+  if (codegenFs.exists(cssPath)) {
+    codegenFs.delete(cssPath);
+  }
+}
+
+// ../kos-codegen-core/src/lib/generators/component/utils/kos-config-builder.ts
+var KosConfigBuilder = class _KosConfigBuilder {
+  contributions = {};
+  experiences = {};
+  views = {};
+  /**
+   * Adds plugin configuration to the builder
+   */
+  addPluginConfiguration(config) {
+    Object.entries(config.contributions).forEach(([key, value]) => {
+      this.contributions[key] = [...this.contributions[key] || [], ...value];
+    });
+    Object.assign(this.experiences, config.experiences);
+    if (config.views) {
+      Object.entries(config.views).forEach(([key, value]) => {
+        this.views[key] = [...this.views[key] || [], ...value];
+      });
+    }
+    return this;
+  }
+  /**
+   * Applies the built configuration to the .kos.json file
+   */
+  applyToFile(codegenFs, kosConfigPath) {
+    updateJson(codegenFs, kosConfigPath, (json) => {
+      const structure = this.initializeStructure(json);
+      Object.entries(this.contributions).forEach(([key, value]) => {
+        structure.contributes[key] = [
+          ...structure.contributes[key] || [],
+          ...value
+        ];
+      });
+      structure.contributes.experiences = {
+        ...structure.contributes.experiences,
+        ...this.experiences
+      };
+      if (Object.keys(this.views).length > 0) {
+        structure.contributes.views = structure.contributes.views || {};
+        Object.entries(this.views).forEach(([key, value]) => {
+          structure.contributes.views[key] = [
+            ...structure.contributes.views[key] || [],
+            ...value
+          ];
+        });
+      }
+      return json;
+    });
+  }
+  /**
+   * Initializes the deep JSON structure
+   */
+  initializeStructure(json) {
+    json.kos ??= {};
+    json.kos.ui ??= {};
+    json.kos.ui.plugin ??= {};
+    json.kos.ui.plugin.contributes ??= {};
+    return json.kos.ui.plugin;
+  }
+  /**
+   * Creates a new builder instance
+   */
+  static create() {
+    return new _KosConfigBuilder();
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/utils/localization.ts
+import * as path9 from "path";
+function updateLocalization(codegenFs, projectRoot, options, pluginType) {
+  const localePath = path9.join(
+    projectRoot,
+    "assets",
+    "locales",
+    "en",
+    `${options.appProject}.json`
+  );
+  if (!codegenFs.exists(localePath)) {
+    console.warn(`Locale file not found: ${localePath}`);
+    return;
+  }
+  updateJson(codegenFs, localePath, (json) => {
+    json[options.appProject] = json[options.appProject] || {};
+    json[options.appProject][options.nameCamelCase] = json[options.appProject][options.nameCamelCase] || {};
+    json[options.appProject][options.nameCamelCase][pluginType] = {
+      ...json[options.appProject][options.nameCamelCase][pluginType],
+      title: options.nameCamelCase
+    };
+    return json;
+  });
+}
+
+// ../kos-codegen-core/src/lib/generators/component/utils/validation.ts
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+function validateOptions(codegenFs, options, projects) {
+  if (!options.name) {
+    throw new ValidationError("Component name is required");
+  }
+  if (!options.appProject) {
+    throw new ValidationError("App project is required");
+  }
+  const project = findProjectByName(codegenFs.root, options.appProject, projects);
+  if (!project) {
+    throw new ValidationError(
+      `Project "${options.appProject}" not found in workspace`
+    );
+  }
+  if (options.pluginType && !PluginHandlerFactory.isValidPluginType(options.pluginType)) {
+    console.warn(
+      `Unknown plugin type "${options.pluginType}". Component will be generated with default configuration.`
+    );
+  }
+  if (options.pluginType === "setting" && !options.group) {
+    throw new ValidationError(
+      "Settings group is required for setting plugin type"
+    );
+  }
+}
+
+// ../kos-codegen-core/src/lib/generators/component/generate-component.ts
+function generateComponent(codegenFs, templateDir, options, projects) {
+  validateOptions(codegenFs, options, projects);
+  const normalized = prepareOptions(codegenFs, options, projects);
+  const projectConfig = findProjectByName(
+    codegenFs.root,
+    normalized.appProject,
+    projects
+  );
+  if (!projectConfig) {
+    throw new Error(
+      `Project "${normalized.appProject}" not found in workspace`
+    );
+  }
+  const projectRoot = projectConfig.sourceRoot;
+  if (!projectRoot) {
+    throw new Error(
+      `No source root found for project ${normalized.appProject}`
+    );
+  }
+  generateFiles(codegenFs, templateDir, projectRoot, normalized);
+  if (options.pluginType) {
+    updatePluginConfiguration(codegenFs, projectConfig, normalized);
+  }
+}
+function prepareOptions(codegenFs, options, projects) {
+  const normalized = normalizeOptions(
+    codegenFs,
+    {
+      ...options,
+      modelProject: "__NONE__"
+    },
+    projects
+  );
+  const kosConfig = getKosProjectConfiguration(
+    codegenFs,
+    options.appProject,
+    projects
+  );
+  const componentLocation = kosConfig?.generator?.defaults?.component?.folder || "";
+  normalized.appDirectory = options.appDirectory || componentLocation;
+  normalized.type = CONTRIBUTION_TYPE_MAP[options.pluginType || ""] || options.type;
+  if (options.contributionKey) {
+    normalized.contributionKey = options.contributionKey;
+  }
+  return normalized;
+}
+function generateFiles(codegenFs, templateDir, projectRoot, options) {
+  const handler = PluginHandlerFactory.createHandler(options.pluginType);
+  const templatePath = handler.getTemplatePath();
+  const targetPath = path10.join(
+    projectRoot,
+    options.appDirectory,
+    options.type,
+    options.nameDashCase
+  );
+  generateComponentFiles(
+    codegenFs,
+    templateDir,
+    templatePath,
+    targetPath,
+    options
+  );
+}
+function updatePluginConfiguration(codegenFs, projectConfig, options) {
+  const kosConfigPath = path10.join(projectConfig.root, ".kos.json");
+  if (!codegenFs.exists(kosConfigPath)) {
+    console.warn(`No .kos.json found at ${kosConfigPath}`);
+    return;
+  }
+  const handler = PluginHandlerFactory.createHandler(options.pluginType);
+  const pluginConfig = handler.createConfiguration(options);
+  const builder = KosConfigBuilder.create();
+  builder.addPluginConfiguration(pluginConfig);
+  builder.applyToFile(codegenFs, kosConfigPath);
+  if (handler.requiresLocalization() && projectConfig.sourceRoot) {
+    updateLocalization(
+      codegenFs,
+      projectConfig.sourceRoot,
+      options,
+      handler.getContributionKey()
+    );
+  }
+}
+
+// src/lib/utils/nx-context.mjs
+import { existsSync as existsSync4, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync } from "fs";
+import path12 from "path";
+import { fileURLToPath } from "url";
+
+// src/lib/utils/cache.mjs
+import fs6 from "fs";
+import path11 from "path";
+var CACHE_PATH = path11.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 = path11.dirname(CACHE_PATH);
+  if (!fs6.existsSync(dir))
+    fs6.mkdirSync(dir, { recursive: true });
+}
+function loadCacheFromDisk() {
+  if (_loaded)
+    return;
+  _loaded = true;
+  try {
+    if (fs6.existsSync(CACHE_PATH)) {
+      const data = fs6.readFileSync(CACHE_PATH, "utf-8");
+      _cache = JSON.parse(data);
+    }
+  } catch (err) {
+    console.warn("Failed to load CLI cache:", err);
+    _cache = {};
+  }
+}
+function saveCacheToDisk() {
+  try {
+    ensureCacheDir();
+    fs6.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();
+}
+
+// src/lib/utils/nx-context.mjs
+var __dirname2 = path12.dirname(fileURLToPath(import.meta.url));
+function findKosJsonFiles(dir = process.cwd(), files = []) {
+  try {
+    const entries = readdirSync3(dir);
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry === ".git" || entry === ".nx" || entry === "dist" || entry === "coverage" || entry === ".vscode" || entry === ".idea" || entry.startsWith(".") && entry !== ".kos.json") {
+        continue;
+      }
+      const fullPath = path12.join(dir, entry);
+      try {
+        const stat = statSync(fullPath);
+        if (stat.isFile() && entry === ".kos.json") {
+          files.push(fullPath);
+        } else if (stat.isDirectory()) {
+          if (entry !== "tmp" && entry !== "temp" && entry !== "build") {
+            findKosJsonFiles(fullPath, files);
+          }
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+  } catch (error) {
+  }
+  return files;
+}
+async function getAllProjects() {
+  const cached = getCached("allProjects");
+  if (cached)
+    return cached;
+  const projectMap = discoverProjects(process.cwd());
+  const projects = Array.from(projectMap.keys());
+  setCached("allProjects", projects);
+  return projects;
+}
+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;
+}
+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...`);
+  }
+  const projectDirs = ["apps", "libs", "packages"];
+  const kosJsonFiles = [];
+  const workspaceRoot = process.cwd();
+  for (const dir of projectDirs) {
+    const dirPath = path12.join(workspaceRoot, dir);
+    if (existsSync4(dirPath)) {
+      findKosJsonFiles(dirPath, kosJsonFiles);
+    }
+  }
+  const rootKosJson = path12.join(workspaceRoot, ".kos.json");
+  if (existsSync4(rootKosJson)) {
+    kosJsonFiles.push(rootKosJson);
+  }
+  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(readFileSync6(kosJsonPath, "utf-8"));
+      const projectDir = path12.dirname(kosJsonPath);
+      let projectName = null;
+      const projectJsonPath = path12.join(projectDir, "project.json");
+      if (existsSync4(projectJsonPath)) {
+        try {
+          const projectJson = JSON.parse(readFileSync6(projectJsonPath, "utf-8"));
+          projectName = projectJson.name;
+        } catch (error) {
+          projectName = path12.basename(projectDir);
+        }
+      } else {
+        projectName = path12.basename(projectDir);
+      }
+      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;
+}
+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;
+    const hasTargetType = Array.isArray(projectType) ? projectType.includes(targetType) : projectType === targetType;
+    if (hasTargetType) {
+      filteredProjects.push(kosProject.name);
+    }
+  }
+  setCached(cacheKey, filteredProjects);
+  return filteredProjects;
+}
+async function getPluginProjectsWithFallback() {
+  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;
+  }
+  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;
+  }
+  console.warn(`[kos-cli] No plugin projects found, showing all projects`);
+  return await getAllProjects();
+}
+
+// src/lib/utils/validators.mjs
+function required(value) {
+  return value && value.trim() !== "" ? true : "This field is required.";
+}
+
+// src/lib/generators/plugin/index.mjs
+var metadata = [
+  {
+    key: "pluginComponent",
     name: "KOS UI Plugin Component",
     namedArguments: {
       name: "componentName",
@@ -15,8 +1219,8 @@ export const metadata = [
       extensionPoint: "extensionPoint"
     }
   },
-  { 
-    key: "plugin:cui", 
+  {
+    key: "plugin:cui",
     name: "KOS UI Plugin CUI Configuration",
     namedArguments: {
       name: "componentName",
@@ -25,8 +1229,8 @@ export const metadata = [
       componentProject: "componentProject"
     }
   },
-  { 
-    key: "plugin:setup", 
+  {
+    key: "plugin:setup",
     name: "KOS UI Plugin Setup Step",
     namedArguments: {
       name: "componentName",
@@ -35,8 +1239,8 @@ export const metadata = [
       componentProject: "componentProject"
     }
   },
-  { 
-    key: "plugin:utility", 
+  {
+    key: "plugin:utility",
     name: "KOS UI Plugin Utility",
     namedArguments: {
       name: "componentName",
@@ -45,8 +1249,8 @@ export const metadata = [
       componentProject: "componentProject"
     }
   },
-  { 
-    key: "plugin:setting", 
+  {
+    key: "plugin:setting",
     name: "KOS UI Plugin Setting",
     namedArguments: {
       name: "componentName",
@@ -56,8 +1260,8 @@ export const metadata = [
       group: "group"
     }
   },
-  { 
-    key: "plugin:nav", 
+  {
+    key: "plugin:nav",
     name: "KOS UI Plugin Navigation View",
     namedArguments: {
       name: "componentName",
@@ -86,28 +1290,31 @@ export const metadata = [
       componentProject: "componentProject",
       contributionKey: "contributionKey"
     }
-  },
+  }
 ];
-
-export default async function (plop) {
+async function plugin_default(plop) {
   const pluginProjects = await getPluginProjectsWithFallback();
-
-  plop.setActionType("createPluginComponent", async function (answers) {
+  plop.setActionType("createPluginComponent", async function(answers) {
+    const cwd = process.cwd();
+    const codegenFs = new TrackingFileSystem(new DirectFileSystem(cwd));
     const pluginType = answers.extensionPoint;
-
-    let command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-component --name=${answers.componentName} --group=${answers.group} --appProject=${answers.componentProject} --pluginType=${pluginType} --type=components --no-interactive`;
-
-    // Add contributionKey for custom plugin types
-    if (pluginType === 'custom' && answers.contributionKey) {
-      command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-component --name=${answers.componentName} --contributionKey=${answers.contributionKey} --appProject=${answers.componentProject} --pluginType=${pluginType} --type=components --no-interactive`;
+    const options = {
+      name: answers.componentName,
+      appProject: answers.componentProject,
+      type: "components",
+      pluginType,
+      useEmotionCss: false,
+      appDirectory: "",
+      modelDirectory: ""
+    };
+    if (answers.group) {
+      options.group = answers.group;
     }
-
-    try {
-      await execute(command);
-    } catch (error) {
-      throw new Error(error);
+    if (pluginType === "custom" && answers.contributionKey) {
+      options.contributionKey = answers.contributionKey;
     }
-
+    generateComponent(codegenFs, getTemplateDir("kos-component"), options);
+    await formatFiles(codegenFs.root, codegenFs.writtenPaths);
     return `Component ${answers.componentName} created in ${answers.componentProject}`;
   });
   const pluginPrompts = [
@@ -115,16 +1322,15 @@ export default async function (plop) {
       type: "input",
       name: "componentName",
       message: "Enter the name of the component",
-      validate: required,
+      validate: required
     },
     {
       type: "list",
       name: "componentProject",
       message: "Which project should the component be created in?",
-      choices: pluginProjects,
-    },
+      choices: pluginProjects
+    }
   ];
-
   const pluginTypes = [
     { key: "plugin:cui", name: "cui" },
     { key: "plugin:setup", name: "setup" },
@@ -132,10 +1338,8 @@ export default async function (plop) {
     { key: "plugin:setting", name: "setting" },
     { key: "plugin:nav", name: "nav" },
     { key: "plugin:cp", name: "controlPour" },
-    { key: "plugin:custom", name: "custom" },
+    { key: "plugin:custom", name: "custom" }
   ];
-
-  // Generic plugin component
   plop.setGenerator("pluginComponent", {
     description: "Create a new KOS Plugin Component",
     prompts: [
@@ -144,52 +1348,49 @@ export default async function (plop) {
         type: "list",
         name: "extensionPoint",
         message: "What type of extension point is the plugin supporting?",
-        choices: pluginTypes.map((pt) => pt.name),
-      },
+        choices: pluginTypes.map((pt) => pt.name)
+      }
     ],
-    actions: [{ type: "createPluginComponent" }],
+    actions: [{ type: "createPluginComponent" }]
   });
-
-  // Specific plugin type aliases
   for (const { key, name } of pluginTypes) {
     const prompts = [
       ...pluginPrompts,
-      ...(name === "setting"
-        ? [
-            {
-              type: "input",
-              name: "group",
-              message: "Which settings group should the setting be located?",
-            },
-          ]
-        : []),
-      ...(name === "custom"
-        ? [
-            {
-              type: "input",
-              name: "contributionKey",
-              message: "What contribution key should be used in .kos.json? (e.g., 'menus', 'panels', 'commands', etc.)",
-              validate: required,
-            },
-          ]
-        : []),
+      ...name === "setting" ? [
+        {
+          type: "input",
+          name: "group",
+          message: "Which settings group should the setting be located?"
+        }
+      ] : [],
+      ...name === "custom" ? [
+        {
+          type: "input",
+          name: "contributionKey",
+          message: "What contribution key should be used in .kos.json? (e.g., 'menus', 'panels', 'commands', etc.)",
+          validate: required
+        }
+      ] : [],
       {
         type: "input",
         name: "extensionPoint",
         message: "Hidden extensionPoint",
         default: name,
-        when: false, // hide from CLI
-      },
+        when: false
+        // hide from CLI
+      }
     ];
-
     plop.setGenerator(key, {
-      description: `Create a new KOS ${
-        name[0].toUpperCase() + name.slice(1)
-      } Plugin Component`,
+      description: `Create a new KOS ${name[0].toUpperCase() + name.slice(1)} Plugin Component`,
       prompts,
       actions: [
-        { type: "createPluginComponent", data: { extensionPoint: name } },
-      ],
+        { type: "createPluginComponent", data: { extensionPoint: name } }
+      ]
     });
   }
 }
+export {
+  plugin_default as default,
+  metadata
+};
+//# sourceMappingURL=index.mjs.map