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

package/src/lib/generators/model/context.mjs

@@ -1,61 +1,1123 @@
-// generators/model/context.mjs
-import { actionFactory } from "../../utils/action-factory.mjs";
-import { execute } from "../../utils/exec.mjs";
-import { getAllModels, getAllProjects } from "../../utils/nx-context.mjs";
-export const metadata = {
+// ../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);
+}
+function findProjectForPath(workspaceRoot, filePath) {
+  const resolved = path3.resolve(workspaceRoot);
+  let dir = path3.dirname(path3.resolve(filePath));
+  while (dir.startsWith(resolved) && dir !== resolved) {
+    const projectJsonPath = path3.join(dir, "project.json");
+    if (fs3.existsSync(projectJsonPath)) {
+      try {
+        const raw = fs3.readFileSync(projectJsonPath, "utf-8");
+        const json = JSON.parse(raw);
+        const projectRoot = path3.relative(resolved, dir);
+        const name = json.name ?? path3.basename(dir);
+        return {
+          name,
+          root: projectRoot,
+          sourceRoot: json.sourceRoot ?? path3.join(projectRoot, "src"),
+          projectType: json.projectType,
+          targets: json.targets,
+          tags: json.tags
+        };
+      } catch {
+        return void 0;
+      }
+    }
+    dir = path3.dirname(dir);
+  }
+  return void 0;
+}
+
+// ../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);
+}
+
+// ../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 getCurrentDirectoryName(cwd) {
+  return cwd.split("/").pop();
+}
+function getProject(codegenFs, cwd) {
+  return findProjectForPath(codegenFs.root, cwd);
+}
+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;
+}
+function getKosModelConfiguration(codegenFs, projectName, modelName, projects) {
+  const kosConfig = getKosProjectConfiguration(
+    codegenFs,
+    projectName,
+    projects
+  );
+  return kosConfig?.models?.[modelName];
+}
+function getKosModelConfigProp(params) {
+  const config = getKosModelConfiguration(
+    params.codegenFs,
+    params.project,
+    params.modelName,
+    params.projects
+  );
+  return config ? config[params.prop] : 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/barrel-utils.ts
+function appendBarrelExport(codegenFs, indexPath, exportPath) {
+  const exportLine = `export * from '${exportPath}'`;
+  const content = codegenFs.read(indexPath) ?? "";
+  const lines = content.split("\n");
+  if (lines.some((line) => line.includes(exportLine))) {
+    return;
+  }
+  lines.push(exportLine);
+  codegenFs.write(indexPath, lines.join("\n"));
+}
+
+// ../kos-codegen-core/src/lib/generators/update-model-index.ts
+import * as ts from "typescript";
+
+// ../kos-codegen-core/src/lib/generators/generate-context.ts
+import * as path8 from "path";
+function generateContext(codegenFs, templateDir, options, cwd, projects) {
+  if (!options.appProject) {
+    throw new Error("No app project specified");
+  }
+  const currentProject = getProject(codegenFs, cwd);
+  const modelProjectName = options.modelProject || currentProject?.name;
+  if (!modelProjectName) {
+    throw new Error(
+      "No model project found. Please specify a model project with --modelProject."
+    );
+  }
+  const modelName = options.name || getCurrentDirectoryName(cwd);
+  if (!modelName) {
+    throw new Error(
+      "No model name found. Please specify a model name with --name."
+    );
+  }
+  const singletonProp = getKosModelConfigProp({
+    codegenFs,
+    project: modelProjectName,
+    modelName,
+    prop: "singleton",
+    projects
+  });
+  options.singleton = !!singletonProp;
+  options.name = modelName;
+  options.modelProject = modelProjectName;
+  const normalized = normalizeOptions(codegenFs, options, projects);
+  const appProject = findProjectByName(
+    codegenFs.root,
+    normalized.appProject,
+    projects
+  );
+  if (!appProject) {
+    throw new Error(`App project '${normalized.appProject}' not found`);
+  }
+  const projectRoot = appProject.sourceRoot;
+  if (projectRoot) {
+    const dir = appProject.projectType === "application" || options.internal ? options.appDirectory : options.appDirectory ?? "lib";
+    generateFilesFromTemplates(
+      codegenFs,
+      templateDir,
+      path8.join(projectRoot, dir, "contexts", normalized.nameDashCase),
+      normalized
+    );
+    appendBarrelExport(
+      codegenFs,
+      path8.join(projectRoot, dir, "contexts", "index.ts"),
+      `./${normalized.nameDashCase}`
+    );
+  }
+}
+
+// ../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/action-factory.mjs
+var actionFactory = (action, metadata2) => {
+  return () => {
+    const _actions = [{ type: action }];
+    if (metadata2.invalidateCache) {
+      _actions.push({ type: "clearCache" });
+    }
+    return _actions;
+  };
+};
+
+// src/lib/utils/nx-context.mjs
+import { existsSync as existsSync4, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync } from "fs";
+import path10 from "path";
+import { fileURLToPath } from "url";
+
+// src/lib/utils/cache.mjs
+import fs6 from "fs";
+import path9 from "path";
+var CACHE_PATH = path9.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 = path9.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 = path10.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 = path10.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 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 = path10.join(workspaceRoot, dir);
+    if (existsSync4(dirPath)) {
+      findKosJsonFiles(dirPath, kosJsonFiles);
+    }
+  }
+  const rootKosJson = path10.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 = path10.dirname(kosJsonPath);
+      let projectName = null;
+      const projectJsonPath = path10.join(projectDir, "project.json");
+      if (existsSync4(projectJsonPath)) {
+        try {
+          const projectJson = JSON.parse(readFileSync6(projectJsonPath, "utf-8"));
+          projectName = projectJson.name;
+        } catch (error) {
+          projectName = path10.basename(projectDir);
+        }
+      } else {
+        projectName = path10.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 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, project: kosProject.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;
+}
+
+// src/lib/generators/model/context.mjs
+var metadata = {
   key: "context",
   name: "KOS Model React Context",
   namedArguments: {
     modelName: "modelName",
     componentProject: "componentProject",
-    project: "componentProject",
-  },
+    project: "componentProject"
+  }
 };
-
-export default async function (plop) {
+async function context_default(plop) {
   const allProjects = await getAllProjects();
-  
-  // Check if we're in interactive mode by looking at process args
-  const isInteractive = process.argv.includes('-i') || process.argv.includes('--interactive');
-  
-  // For interactive mode, use lazy loading. For non-interactive, load immediately.
+  const isInteractive = process.argv.includes("-i") || process.argv.includes("--interactive");
   let modelChoices;
   if (isInteractive) {
     modelChoices = async () => {
       const allModels = await getAllModels();
       return allModels.map((m) => ({
         name: `${m.model} (${m.project})`,
-        value: m.model,
+        value: m.model
       }));
     };
   } else {
     const allModels = await getAllModels();
     modelChoices = allModels.map((m) => ({
       name: `${m.model} (${m.project})`,
-      value: m.model,
+      value: m.model
     }));
   }
-
-  plop.setActionType("createContext", async function (answers) {
+  plop.setActionType("createContext", async function(answers) {
+    const cwd = process.cwd();
+    const codegenFs = new TrackingFileSystem(new DirectFileSystem(cwd));
     const allModels = await getAllModels();
     const modelProject = allModels.find(
       (m) => m.model === answers.modelName
     )?.project;
-    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-context \
-      --appProject=${answers.componentProject} \
-      --modelProject=${modelProject} \
-      --name=${answers.modelName} \
-      --no-interactive ${answers.dryRun ? "--dryRun" : ""}`;
-
-    try {
-      await execute(command);
-    } catch (error) {
-      throw new Error(error);
-    }
-
+    generateContext(
+      codegenFs,
+      getTemplateDir("kos-context"),
+      {
+        name: answers.modelName,
+        appProject: answers.componentProject,
+        modelProject,
+        modelDirectory: "",
+        appDirectory: ""
+      },
+      cwd
+    );
+    await formatFiles(codegenFs.root, codegenFs.writtenPaths);
     return `Context created for ${answers.modelName} in ${answers.componentProject}`;
   });
-
   plop.setGenerator("context", {
     description: "Create a context for a KOS Model",
     prompts: [
@@ -63,15 +1125,20 @@ export default async function (plop) {
         type: "list",
         name: "modelName",
         message: "Which model to use?",
-        choices: modelChoices,
+        choices: modelChoices
       },
       {
         type: "list",
         name: "componentProject",
         message: "Which project should the context be created in?",
-        choices: allProjects,
-      },
+        choices: allProjects
+      }
     ],
-    actions: actionFactory("createContext", metadata),
+    actions: actionFactory("createContext", metadata)
   });
 }
+export {
+  context_default as default,
+  metadata
+};
+//# sourceMappingURL=context.mjs.map