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

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

@@ -1,19 +1,1425 @@
-// generators/model/companion.mjs
-import { actionFactory } from "../../utils/action-factory.mjs";
-import { execute } from "../../utils/exec.mjs";
-import {
-  getAllModels,
-  getModelProjectsWithFallback,
-  getProjectDetails,
-} from "../../utils/nx-context.mjs";
-import {
-  COMPANION_PROMPTS,
-  DEFAULT_PROMPTS,
-  MODEL_PROMPTS,
-} from "../../utils/prompts.mjs";
-import { required } from "../../utils/validators.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);
+}
+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 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 addKosModelConfiguration(params) {
+  const logger = getCodegenLogger();
+  const kosConfigPath = path5.join(params.projectRoot, ".kos.json");
+  if (!params.codegenFs.exists(kosConfigPath)) {
+    logger.info(`Creating .kos.json in ${params.projectRoot}`);
+    const defaultConfig = {
+      name: params.projectName,
+      type: "kos.model",
+      version: "0.1.0",
+      models: {},
+      generator: { defaults: { model: { folder: "" } } }
+    };
+    params.codegenFs.write(
+      kosConfigPath,
+      JSON.stringify(defaultConfig, null, 2) + "\n"
+    );
+  }
+  updateJson(params.codegenFs, kosConfigPath, (json) => {
+    json.models = {
+      ...json.models,
+      [params.modelName]: {
+        name: params.modelName,
+        type: `${params.modelName}-model`,
+        singleton: !!params.singleton,
+        container: !!params.container
+      }
+    };
+    return json;
+  });
+}
+
+// ../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";
+function updateModelIndex(codegenFs, indexPath, modelPath) {
+  const logger = getCodegenLogger();
+  if (!indexPath)
+    return;
+  const content = codegenFs.read(indexPath);
+  if (content === null) {
+    logger.warn(`Index file not found: ${indexPath}`);
+    return;
+  }
+  logger.info(`Updating ${indexPath} \u2014 adding export for ${modelPath}`);
+  const sourceFile = ts.createSourceFile(
+    indexPath,
+    content,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  const exportDeclaration = ts.factory.createExportDeclaration(
+    void 0,
+    false,
+    void 0,
+    ts.factory.createStringLiteral(`./${modelPath}`)
+  );
+  const updatedSourceFile = ts.factory.updateSourceFile(sourceFile, [
+    ...sourceFile.statements,
+    exportDeclaration
+  ]);
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  const newContents = printer.printFile(updatedSourceFile);
+  codegenFs.write(indexPath, newContents);
+}
+
+// ../kos-codegen-core/src/lib/generators/generate-container-model.ts
+import * as path8 from "path";
+function generateContainerModel(codegenFs, templateDir, options, cwd, projects) {
+  const logger = getCodegenLogger();
+  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.modelName || getCurrentDirectoryName(cwd);
+  if (!modelName) {
+    throw new Error(
+      "No model name found. Please specify a model name with --name."
+    );
+  }
+  options.modelName = modelName;
+  options.name = `${modelName}-container`;
+  const normalized = normalizeOptions(codegenFs, options, projects);
+  const projectConfig = findProjectByName(
+    codegenFs.root,
+    normalized.modelProject,
+    projects
+  );
+  if (!projectConfig) {
+    throw new Error(`Model project '${normalized.modelProject}' not found`);
+  }
+  addKosModelConfiguration({
+    codegenFs,
+    modelName: normalized.nameDashCase,
+    projectName: projectConfig.name,
+    projectRoot: projectConfig.root,
+    singleton: !!options.singleton,
+    container: true
+  });
+  const kosConfig = getKosProjectConfiguration(
+    codegenFs,
+    projectConfig.name,
+    projects
+  );
+  const modelLocation = kosConfig?.generator?.defaults?.model?.folder || "";
+  const internal = !!kosConfig?.generator?.internal;
+  options.modelDirectory = options.modelDirectory || modelLocation;
+  const projectRoot = projectConfig.sourceRoot;
+  if (projectRoot) {
+    logger.info(
+      `Generating container model ${normalized.nameDashCase} in ${projectRoot}`
+    );
+    const modelNameDashCase = normalized.modelNameDashCase || normalized.nameDashCase;
+    generateFilesFromTemplates(
+      codegenFs,
+      path8.join(templateDir, "model"),
+      path8.join(projectRoot, options.modelDirectory || "", modelNameDashCase),
+      { ...normalized, internal }
+    );
+    if (options.dataServices) {
+      logger.info(
+        `Generating data services for ${modelNameDashCase}`
+      );
+      generateFilesFromTemplates(
+        codegenFs,
+        path8.join(templateDir, "services"),
+        path8.join(
+          projectRoot,
+          options.modelDirectory,
+          modelNameDashCase,
+          "services"
+        ),
+        { ...normalized, internal }
+      );
+    }
+    const modelIndex = path8.join(projectRoot, "index.ts");
+    const modelPath = normalized.modelDirectory ? `${normalized.modelDirectory}/${modelNameDashCase}` : modelNameDashCase;
+    updateModelIndex(codegenFs, modelIndex, modelPath);
+  }
+}
+
+// ../kos-codegen-core/src/lib/generators/generate-companion-model.ts
+import * as path9 from "path";
+function generateCompanionModel(codegenFs, templateDir, options, projects) {
+  const logger = getCodegenLogger();
+  const normalized = normalizeAllValues({
+    companionModelName: options.companionModelName,
+    modelName: options.modelName
+  });
+  const companionChildKosConfig = getKosProjectConfiguration(
+    codegenFs,
+    options.companionModelProject,
+    projects
+  );
+  const parentProject = findProjectByName(
+    codegenFs.root,
+    options.modelProject,
+    projects
+  );
+  const childProject = findProjectByName(
+    codegenFs.root,
+    options.companionModelProject,
+    projects
+  );
+  const projectRoot = childProject?.sourceRoot;
+  if (!projectRoot) {
+    logger.warn(`Companion child project source root not found`);
+    return;
+  }
+  let importPath = "";
+  if (parentProject) {
+    const pkgJsonPath = path9.join(parentProject.root, "package.json");
+    try {
+      const pkgJson = readJson(codegenFs, pkgJsonPath);
+      importPath = pkgJson.name || "";
+    } catch {
+      importPath = "";
+    }
+  }
+  const modelLocation = companionChildKosConfig?.generator?.defaults?.model?.folder || "";
+  const filePath = path9.join(
+    projectRoot,
+    modelLocation,
+    normalized.companionModelNameDashCase
+  );
+  logger.info(`Generating companion model in ${filePath}`);
+  generateFilesFromTemplates(codegenFs, templateDir, filePath, {
+    ...options,
+    ...normalized,
+    importPath
+  });
+}
+
+// ../kos-codegen-core/src/lib/generators/generate-model.ts
+import * as path10 from "path";
+function generateModel(params) {
+  const {
+    codegenFs,
+    modelTemplateDir,
+    containerTemplateDir,
+    companionTemplateDir,
+    options,
+    cwd,
+    projects
+  } = params;
+  const logger = getCodegenLogger();
+  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."
+    );
+  }
+  options.modelProject = modelProjectName;
+  const normalized = normalizeOptions(codegenFs, options, projects);
+  const projectConfig = findProjectByName(
+    codegenFs.root,
+    normalized.modelProject,
+    projects
+  );
+  if (!projectConfig) {
+    throw new Error(`Model project '${normalized.modelProject}' not found`);
+  }
+  const projectRoot = projectConfig.sourceRoot;
+  if (!projectRoot)
+    return;
+  const kosConfigPath = path10.join(projectConfig.root, ".kos.json");
+  const kosConfig = getKosProjectConfiguration(
+    codegenFs,
+    projectConfig.name,
+    projects
+  );
+  const modelLocation = kosConfig?.generator?.defaults?.model?.folder || "";
+  const internal = !!kosConfig?.generator?.internal;
+  options.modelDirectory = options.modelDirectory || modelLocation;
+  logger.info(
+    `Generating model ${normalized.nameDashCase} in ${projectRoot}`
+  );
+  generateFilesFromTemplates(
+    codegenFs,
+    path10.join(modelTemplateDir, "model"),
+    path10.join(projectRoot, options.modelDirectory, normalized.nameDashCase),
+    { ...normalized, internal }
+  );
+  if (normalized.dataServices) {
+    generateFilesFromTemplates(
+      codegenFs,
+      path10.join(modelTemplateDir, "services"),
+      path10.join(
+        projectRoot,
+        options.modelDirectory,
+        normalized.nameDashCase,
+        "services"
+      ),
+      { ...normalized, internal }
+    );
+  }
+  const modelIndex = path10.join(projectRoot, "index.ts");
+  const modelPath = options.modelDirectory ? `${options.modelDirectory}/${normalized.nameDashCase}` : normalized.nameDashCase;
+  updateModelIndex(codegenFs, modelIndex, modelPath);
+  updateJson(codegenFs, kosConfigPath, (json) => {
+    json.models = {
+      ...json.models,
+      [normalized.name]: {
+        name: normalized.name,
+        type: `${normalized.nameDashCase}-model`,
+        singleton: !!normalized.singleton
+      }
+    };
+    return json;
+  });
+  if (normalized.container && containerTemplateDir) {
+    logger.info(`Generating container for ${normalized.name}`);
+    generateContainerModel(
+      codegenFs,
+      containerTemplateDir,
+      {
+        ...options,
+        name: `${normalized.name}-container`,
+        modelName: normalized.name,
+        singleton: normalized.isContainerSingleton,
+        dataServices: normalized.dataServices
+      },
+      cwd,
+      projects
+    );
+  }
+  if (normalized.companion && normalized.companionModel && normalized.companionModelProject && companionTemplateDir) {
+    generateCompanionModel(
+      codegenFs,
+      companionTemplateDir,
+      {
+        companionModelName: normalized.name,
+        companionModelProject: normalized.modelProject,
+        modelName: normalized.companionModel,
+        modelProject: normalized.companionModelProject,
+        companionPattern: normalized.companionPattern
+      },
+      projects
+    );
+  }
+}
+
+// ../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 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 getLibraryProjects() {
+  const cached = getCached("libraryProjects");
+  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;
+}
+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 getProjectsByTypeWithFallback(targetType, fallbackFunction = getLibraryProjects) {
+  const filteredProjects = await getProjectsByType(targetType);
+  if (filteredProjects.length > 0) {
+    if (process.env.KOS_CLI_QUIET !== "true") {
+      console.warn(`[kos-cli] Found ${filteredProjects.length} ${targetType} projects`);
+    }
+    return filteredProjects;
+  } else {
+    if (process.env.KOS_CLI_QUIET !== "true") {
+      console.warn(`[kos-cli] No ${targetType} projects found, showing fallback projects`);
+    }
+    return await fallbackFunction();
+  }
+}
+async function getModelProjectsWithFallback() {
+  return await getProjectsByTypeWithFallback("model", getLibraryProjects);
+}
+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;
+}
+async function getProjectDetails(projectName) {
+  const cacheKey = `projectDetails:${projectName}`;
+  const cached = getCached(cacheKey);
+  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;
+}
+
+// src/lib/utils/prompts.mjs
+var DEFAULT_PROMPTS = [
+  {
+    type: "confirm",
+    name: "interactive",
+    message: "Use interactive mode?",
+    default: false,
+    when: false
+  },
+  {
+    type: "confirm",
+    name: "dryRun",
+    message: "Dry run the command?",
+    default: false,
+    when: false
+  }
+];
+var MODEL_PROMPTS = [
+  {
+    type: "confirm",
+    name: "container",
+    message: "Requires container model?",
+    default: false
+  },
+  {
+    type: "confirm",
+    name: "parentAware",
+    message: "Aware of parent container?",
+    default: false
+  },
+  {
+    type: "confirm",
+    name: "singleton",
+    message: "Is singleton?",
+    default: false
+  },
+  {
+    type: "confirm",
+    name: "dataServices",
+    message: "Create data services?",
+    default: true
+  },
+  {
+    type: "list",
+    name: "futureAware",
+    message: "Include Future-aware capabilities?",
+    choices: [
+      { name: "No Future support", value: "none" },
+      { name: "Minimal (external access only)", value: "minimal" },
+      { name: "Complete (internal + external access)", value: "complete" }
+    ],
+    default: "none"
+  }
+];
+var COMPANION_PROMPTS = [
+  {
+    type: "list",
+    name: "companionPattern",
+    message: "Which companion pattern to use?",
+    choices: [
+      {
+        name: "Composition (recommended) - explicit parent access via this.parent",
+        value: "composition"
+      },
+      {
+        name: "Decorator - transparent parent access, drop-in replacement",
+        value: "decorator"
+      }
+    ],
+    default: "composition"
+  }
+];
+
+// src/lib/utils/validators.mjs
+function required(value) {
+  return value && value.trim() !== "" ? true : "This field is required.";
+}
+
+// src/lib/generators/model/companion.mjs
+var metadata = {
   key: "model:companion",
   name: "KOS Companion Model",
   namedArguments: {
@@ -29,63 +1435,61 @@ export const metadata = {
     dataServices: "dataServices",
     autoRegister: "autoRegister",
     dryRun: "dryRun",
-    interactive: "interactive",
-  },
+    interactive: "interactive"
+  }
 };
-
-export default async function (plop) {
+async function companion_default(plop) {
   const libraryProjects = await getModelProjectsWithFallback();
-  
-  // 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("createCompanionModel", async function (answers) {
+  plop.setActionType("createCompanionModel", async function(answers) {
+    const cwd = process.cwd();
+    const codegenFs = new TrackingFileSystem(new DirectFileSystem(cwd));
     const modelProject = await getProjectDetails(answers.modelProject);
     const allModels = await getAllModels();
     const companionProject = allModels.find(
       (m) => m.model === answers.companionParent
     )?.project;
-
-    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-model \
-      --name=${answers.modelName} \
-      --modelProject=${modelProject.name} \
-      --skipRegistration=true \
-      --container=${!!answers.container} \
-      --dataServices=${!!answers.dataServices} \
-      --singleton=${!!answers.singleton} \
-      --parentAware=${!!answers.parentAware} \
-      --autoRegister=${!!answers.autoRegister} \
-      --companion=true \
-      --companionModel=${answers.companionParent} \
-      --companionModelProject=${companionProject} \
-      --companionPattern=${answers.companionPattern} \
-      --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
-
-    try {
-      await execute(command);
-    } catch (error) {
-      throw new Error(error);
-    }
+    generateModel({
+      codegenFs,
+      modelTemplateDir: getTemplateDir("kos-model"),
+      containerTemplateDir: getTemplateDir("kos-container-model"),
+      companionTemplateDir: getTemplateDir("kos-companion-model"),
+      options: {
+        name: answers.modelName,
+        modelProject: modelProject.name,
+        modelDirectory: "",
+        skipRegistration: true,
+        container: !!answers.container,
+        dataServices: !!answers.dataServices,
+        singleton: !!answers.singleton,
+        parentAware: !!answers.parentAware,
+        autoRegister: !!answers.autoRegister,
+        companion: true,
+        companionModel: answers.companionParent,
+        companionModelProject: companionProject,
+        companionPattern: answers.companionPattern
+      },
+      cwd
+    });
+    await formatFiles(codegenFs.root, codegenFs.writtenPaths);
+    return `Companion model ${answers.modelName} created in ${answers.modelProject}`;
   });
-
   plop.setGenerator("model:companion", {
     description: "Create a new KOS Companion Model",
     prompts: [
@@ -94,24 +1498,29 @@ export default async function (plop) {
         type: "input",
         name: "modelName",
         message: "Enter the name of the model",
-        validate: required,
+        validate: required
       },
       {
         type: "list",
         name: "modelProject",
         message: "Which model project to use?",
         validate: required,
-        choices: libraryProjects,
+        choices: libraryProjects
       },
       {
         type: "list",
         name: "companionParent",
         message: "Select the companion parent model",
-        choices: modelChoices,
+        choices: modelChoices
       },
       ...COMPANION_PROMPTS,
-      ...MODEL_PROMPTS,
+      ...MODEL_PROMPTS
     ],
-    actions: actionFactory("createCompanionModel", metadata),
+    actions: actionFactory("createCompanionModel", metadata)
   });
 }
+export {
+  companion_default as default,
+  metadata
+};
+//# sourceMappingURL=companion.mjs.map