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

package/src/lib/generators/model/add-future.mjs

@@ -1,10 +1,1425 @@
-// generators/model/add-future.mjs
-import { actionFactory } from "../../utils/action-factory.mjs";
-import { execute } from "../../utils/exec.mjs";
-import { getAllModels } from "../../utils/nx-context.mjs";
-import { DEFAULT_PROMPTS } from "../../utils/prompts.mjs";
+// 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 existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync } from "fs";
+import path6 from "path";
+import { fileURLToPath } from "url";
+
+// src/lib/utils/cache.mjs
+import fs from "fs";
+import path from "path";
+var CACHE_PATH = path.resolve(".nx/cli-cache.json");
+var CACHE_TTL = 600 * 1e3;
+var ARGS = process.argv;
+var DISABLE_CACHE = process.env.DISABLE_CACHE === "true" || process.env.REFRESH === "true";
+var _cache = {};
+var _loaded = false;
+function ensureCacheDir() {
+  const dir = path.dirname(CACHE_PATH);
+  if (!fs.existsSync(dir))
+    fs.mkdirSync(dir, { recursive: true });
+}
+function loadCacheFromDisk() {
+  if (_loaded)
+    return;
+  _loaded = true;
+  try {
+    if (fs.existsSync(CACHE_PATH)) {
+      const data = fs.readFileSync(CACHE_PATH, "utf-8");
+      _cache = JSON.parse(data);
+    }
+  } catch (err) {
+    console.warn("Failed to load CLI cache:", err);
+    _cache = {};
+  }
+}
+function saveCacheToDisk() {
+  try {
+    ensureCacheDir();
+    fs.writeFileSync(CACHE_PATH, JSON.stringify(_cache, null, 2));
+  } catch (err) {
+    console.warn("Failed to save CLI cache:", err);
+  }
+}
+function isFresh(entry, ttl = CACHE_TTL) {
+  if (!entry || !entry.timestamp)
+    return false;
+  return Date.now() - entry.timestamp < ttl;
+}
+function getCached(key, ttl = CACHE_TTL) {
+  if (DISABLE_CACHE)
+    return null;
+  loadCacheFromDisk();
+  const entry = _cache[key];
+  if (isFresh(entry, ttl))
+    return entry.data;
+  return null;
+}
+function setCached(key, data) {
+  loadCacheFromDisk();
+  _cache[key] = {
+    data,
+    timestamp: Date.now()
+  };
+  saveCacheToDisk();
+}
+
+// ../kos-codegen-core/src/lib/codegen-filesystem.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var DirectFileSystem = class {
+  root;
+  constructor(workspaceRoot) {
+    this.root = path2.resolve(workspaceRoot);
+  }
+  read(filePath) {
+    const abs = this.resolve(filePath);
+    try {
+      return fs2.readFileSync(abs, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  write(filePath, content) {
+    const abs = this.resolve(filePath);
+    fs2.mkdirSync(path2.dirname(abs), { recursive: true });
+    fs2.writeFileSync(abs, content, "utf-8");
+  }
+  exists(filePath) {
+    return fs2.existsSync(this.resolve(filePath));
+  }
+  delete(filePath) {
+    const abs = this.resolve(filePath);
+    try {
+      fs2.unlinkSync(abs);
+    } catch {
+    }
+  }
+  listFiles(dirPath) {
+    const abs = this.resolve(dirPath);
+    if (!fs2.existsSync(abs)) {
+      return [];
+    }
+    return this.walkDir(abs).map((file) => path2.relative(this.root, file));
+  }
+  resolve(filePath) {
+    if (path2.isAbsolute(filePath)) {
+      return filePath;
+    }
+    return path2.join(this.root, filePath);
+  }
+  walkDir(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(...this.walkDir(full));
+      } else {
+        results.push(full);
+      }
+    }
+    return results;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generate-files.ts
+import * as ejs from "ejs";
+
+// ../kos-codegen-core/src/lib/logger.ts
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var activeLogger = noopLogger;
+function getCodegenLogger() {
+  return activeLogger;
+}
+
+// ../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/format-files.ts
+import prettier from "prettier";
+
+// ../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 path4 from "path";
+function getKosProjectConfiguration(codegenFs, projectName, projects) {
+  const project = findProjectByName(codegenFs.root, projectName, projects);
+  if (!project)
+    return void 0;
+  const configPath = path4.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/generators/update-model-index.ts
+import * as ts from "typescript";
+
+// ../kos-codegen-core/src/lib/generators/add-future-to-model/normalize-options.ts
+import * as path5 from "path";
+function normalizeAddFutureOptions(codegenFs, options, projects) {
+  const projectConfiguration = findProjectByName(
+    codegenFs.root,
+    options.modelProject,
+    projects
+  );
+  if (!projectConfiguration) {
+    throw new Error(
+      `Project not found: ${options.modelProject}. Ensure a project.json exists for this project.`
+    );
+  }
+  const kosConfig = getKosProjectConfiguration(
+    codegenFs,
+    options.modelProject,
+    projects
+  );
+  const internal = !!kosConfig?.generator?.internal;
+  const normalizedValues = normalizeAllValues({
+    modelName: options.modelName
+  });
+  const nameDashCase = normalizedValues.modelNameDashCase;
+  const nameProperCase = normalizedValues.modelNameProperCase;
+  const nameCamelCase = normalizedValues.modelNameCamelCase;
+  const namePascalCase = normalizedValues.modelNamePascalCase;
+  const nameConstantCase = normalizedValues.modelNameConstantCase;
+  const nameLowerCase = normalizedValues.modelNameLowerCase;
+  const projectRoot = projectConfiguration.root;
+  const sourceRoot = projectConfiguration.sourceRoot || path5.join(projectRoot, "src");
+  const modelLocation = kosConfig?.generator?.defaults?.model?.folder || "";
+  const modelDirectory = path5.join(sourceRoot, modelLocation, nameDashCase);
+  const modelFilePath = path5.join(modelDirectory, `${nameDashCase}-model.ts`);
+  const servicesDirectory = path5.join(modelDirectory, "services");
+  const servicesFilePath = codegenFs.exists(servicesDirectory) ? path5.join(servicesDirectory, `${nameDashCase}-services.ts`) : void 0;
+  const registrationFilePath = path5.join(
+    modelDirectory,
+    `${nameDashCase}-registration.ts`
+  );
+  return {
+    ...options,
+    nameDashCase,
+    nameProperCase,
+    nameCamelCase,
+    namePascalCase,
+    nameConstantCase,
+    nameLowerCase,
+    projectRoot,
+    sourceRoot,
+    modelFilePath,
+    servicesFilePath,
+    registrationFilePath: codegenFs.exists(registrationFilePath) ? registrationFilePath : void 0,
+    internal
+  };
+}
 
-export const metadata = {
+// ../kos-codegen-core/src/lib/generators/add-future-to-model/model-transformer.ts
+var ModelFileTransformer = class {
+  constructor(codegenFs, options) {
+    this.codegenFs = codegenFs;
+    this.options = options;
+  }
+  transform() {
+    const { modelFilePath } = this.options;
+    if (!this.codegenFs.exists(modelFilePath)) {
+      throw new Error(`Model file not found: ${modelFilePath}`);
+    }
+    let content = this.codegenFs.read(modelFilePath);
+    content = this.addESLintDisable(content);
+    content = this.addImports(content);
+    content = this.addServiceImport(content);
+    content = this.addInterfaceMerging(content);
+    content = this.addDecorator(content);
+    content = this.updatePublicType(content);
+    content = this.removeLegacySetup(content);
+    content = this.addFutureMethod(content);
+    if (this.options.futureType === "complete") {
+      content = this.addOnFutureUpdateMethod(content);
+    }
+    this.codegenFs.write(modelFilePath, content);
+  }
+  addESLintDisable(content) {
+    if (content.includes("@typescript-eslint/no-unsafe-declaration-merging")) {
+      return content;
+    }
+    const eslintDisable = "/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */\n";
+    return eslintDisable + content;
+  }
+  addImports(content) {
+    const { internal, futureType } = this.options;
+    const isComplete = futureType === "complete";
+    const kosModelImportRegex = internal ? /import\s*{\s*([^}]*kosModel[^}]*)\s*}\s*from\s*"\.\.\/\.\.\/\.\.\/core\/core\/decorators"/ : /import\s*{\s*([^}]*kosModel[^}]*)\s*}\s*from\s*"@kosdev-code\/kos-ui-sdk"/;
+    const kosModelMatch = content.match(kosModelImportRegex);
+    if (kosModelMatch) {
+      const existingImportsStr = kosModelMatch[1] || "";
+      const newImports = [
+        "kosFuture",
+        "kosFutureAware",
+        isComplete ? "KosFutureAwareFull" : "KosFutureAwareMinimal"
+      ];
+      const existingImports = existingImportsStr.split(",").map((s) => s.trim()).filter(Boolean);
+      const importsToRemove = [
+        "setupCompleteFutureSupport",
+        "setupMinimalFutureSupport"
+      ];
+      const cleanedImports = existingImports.filter(
+        (imp) => !importsToRemove.includes(imp)
+      );
+      const importsToAdd = newImports.filter(
+        (imp) => !cleanedImports.includes(imp)
+      );
+      const allImports = [...cleanedImports, ...importsToAdd];
+      const newImportLine = internal ? `import { ${allImports.join(
+        ", "
+      )} } from "../../../core/core/decorators"` : `import { ${allImports.join(", ")} } from "@kosdev-code/kos-ui-sdk"`;
+      content = content.replace(kosModelImportRegex, newImportLine);
+    }
+    const typeImportsBase = internal ? "../../../models/types/future-interfaces" : "@kosdev-code/kos-ui-sdk";
+    const futureTypeImports = ["ExternalFutureInterface", "IFutureModel"];
+    const typeImportRegex = internal ? /import type {([^}]*)} from "\.\.\/\.\.\/\.\.\/models\/types\/future-interfaces"/ : /import type {([^}]*)} from "@kosdev-code\/kos-ui-sdk"/;
+    const typeImportMatch = content.match(typeImportRegex);
+    if (typeImportMatch) {
+      const existingTypes = typeImportMatch[1] || "";
+      const existingTypesList = existingTypes.split(",").map((s) => s.trim()).filter(Boolean);
+      const typesToRemove = [
+        "FutureAwareContainer",
+        "FutureHandlerContainer",
+        "FutureStateAccessor",
+        "FutureUpdateHandler"
+      ];
+      const cleanedTypes = existingTypesList.filter(
+        (type) => !typesToRemove.includes(type)
+      );
+      const typesToAdd = futureTypeImports.filter(
+        (type) => !cleanedTypes.includes(type)
+      );
+      const allTypes = [...cleanedTypes, ...typesToAdd].join(", ");
+      const newTypeImport = `import type { ${allTypes} } from "${typeImportsBase}"`;
+      content = content.replace(typeImportRegex, newTypeImport);
+    } else {
+      const importLines = content.split("\n");
+      const lastImportIndex = importLines.findLastIndex(
+        (line) => line.trim().startsWith("import")
+      );
+      if (lastImportIndex >= 0) {
+        const newTypeImport = `import type { ${futureTypeImports.join(
+          ", "
+        )} } from "${typeImportsBase}";`;
+        importLines.splice(lastImportIndex + 1, 0, newTypeImport);
+        content = importLines.join("\n");
+      }
+    }
+    return content;
+  }
+  addServiceImport(content) {
+    const { nameProperCase, updateServices } = this.options;
+    if (!updateServices) {
+      return content;
+    }
+    if (content.includes(`${nameProperCase}OperationProgress`)) {
+      return content;
+    }
+    const servicesImportRegex = /import\s*{([^}]*)}\s*from\s*["']\.\/services["'];?/s;
+    const servicesMatch = content.match(servicesImportRegex);
+    if (servicesMatch) {
+      const existingImports = servicesMatch[1];
+      const cleanedImports = existingImports.split(",").map((s) => s.trim()).filter(Boolean);
+      cleanedImports.push(`${nameProperCase}OperationProgress`);
+      const newImport = `import { ${cleanedImports.join(
+        ", "
+      )} } from "./services";`;
+      content = content.replace(servicesImportRegex, newImport);
+    } else {
+      const typesImportRegex = /import\s+type\s+{[^}]*}\s+from\s+["']\.\/types["'];?/;
+      const typesMatch = content.match(typesImportRegex);
+      if (typesMatch) {
+        const newImport = `
+import type { ${nameProperCase}OperationProgress } from "./services";`;
+        content = content.replace(typesMatch[0], typesMatch[0] + newImport);
+      }
+    }
+    return content;
+  }
+  addInterfaceMerging(content) {
+    const { nameProperCase, futureType } = this.options;
+    const isComplete = futureType === "complete";
+    const interfaceType = isComplete ? "KosFutureAwareFull" : "KosFutureAwareMinimal";
+    const progressType = this.options.updateServices ? `${nameProperCase}OperationProgress` : "Record<string, unknown>";
+    const classRegex = new RegExp(
+      `(@kosModel[^\\n]*\\n)([^\\n]*export\\s+class\\s+${nameProperCase}ModelImpl)`,
+      "m"
+    );
+    const classMatch = content.match(classRegex);
+    if (classMatch) {
+      const interfaceRegex = new RegExp(
+        `interface\\s+${nameProperCase}ModelImpl\\s+extends`
+      );
+      if (!content.match(interfaceRegex)) {
+        const interfaceMerging = `
+// Interface merging for Future Container type safety
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ${nameProperCase}ModelImpl extends ${interfaceType}<${progressType}> {}
+
+`;
+        content = content.replace(
+          classMatch[0],
+          interfaceMerging + classMatch[0]
+        );
+      }
+    }
+    return content;
+  }
+  addDecorator(content) {
+    const { nameProperCase, futureType } = this.options;
+    const isComplete = futureType === "complete";
+    const classRegex = new RegExp(
+      `(@kosModel[^\\n]*\\n)((?:@[^\\n]*\\n)*)([^\\n]*export\\s+class\\s+${nameProperCase}ModelImpl)`,
+      "m"
+    );
+    const classMatch = content.match(classRegex);
+    if (classMatch) {
+      if (!classMatch[2].includes("@kosFutureAware")) {
+        const decoratorOptions = isComplete ? "" : "{ mode: 'minimal' }";
+        const futureDecorator = `@kosFutureAware(${decoratorOptions})
+`;
+        content = content.replace(
+          classMatch[0],
+          classMatch[1] + classMatch[2] + futureDecorator + classMatch[3]
+        );
+      }
+    }
+    return content;
+  }
+  updatePublicType(content) {
+    const { nameProperCase, updateServices } = this.options;
+    const progressType = updateServices ? `${nameProperCase}OperationProgress` : "Record<string, unknown>";
+    const typeRegex = new RegExp(
+      `export\\s+type\\s+${nameProperCase}Model\\s*=\\s*PublicModelInterface<${nameProperCase}ModelImpl>([^;]*);`,
+      "s"
+    );
+    const typeMatch = content.match(typeRegex);
+    if (typeMatch) {
+      if (!typeMatch[1].includes("ExternalFutureInterface")) {
+        const newType = `export type ${nameProperCase}Model = PublicModelInterface<${nameProperCase}ModelImpl> & ExternalFutureInterface<${progressType}>;`;
+        content = content.replace(typeMatch[0], newType);
+      }
+    }
+    return content;
+  }
+  removeLegacySetup(content) {
+    const setupRegex = /\s*setup(Complete|Minimal)FutureSupport\(this\);?\s*/g;
+    content = content.replace(setupRegex, "");
+    const propertyRegex = /\s*(public|private|protected)?\s*(declare\s+)?futureHandler[!?]?:\s*FutureAwareContainer[^;]*;\s*/g;
+    content = content.replace(propertyRegex, "");
+    const futurePropertyRegex = /\s*(public|private|protected)?\s*(declare\s+)?future\??:\s*IFutureModel[^;]*;\s*/g;
+    content = content.replace(futurePropertyRegex, "");
+    const implementsRegex = new RegExp(
+      `(implements\\s+[^{]*?)\\s*,?\\s*(FutureUpdateHandler|FutureHandlerContainer|FutureStateAccessor)`,
+      "g"
+    );
+    content = content.replace(implementsRegex, "$1");
+    content = content.replace(/,\s*,/g, ",");
+    content = content.replace(/implements\s*,/g, "implements");
+    return content;
+  }
+  addFutureMethod(content) {
+    const { nameProperCase } = this.options;
+    if (content.includes("@kosFuture()")) {
+      return content;
+    }
+    const classRegex = new RegExp(
+      `class\\s+${nameProperCase}ModelImpl[^{]*{([\\s\\S]*)}\\s*$`,
+      "m"
+    );
+    const classMatch = content.match(classRegex);
+    if (classMatch) {
+      const methodCode = `
+  /**
+   * Placeholder method for Future operations
+   * Replace this with your actual long-running operation
+   */
+  @kosFuture()
+  async performLongRunningOperation(): Promise<void> {
+    // TODO: Implement your long-running operation here
+    // This method should use a service that returns a Future for progress tracking
+
+    this.logger.debug(\`Starting long-running operation for \${this.id}\`);
+
+    // Example implementation pattern using services:
+    // import { perform${nameProperCase}Operation } from './services';
+    //
+    // const future = await perform${nameProperCase}Operation();
+    // return this.futureHandler.setFuture(future);
+
+    // Placeholder that doesn't actually do anything
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    this.logger.debug(\`Completed long-running operation for \${this.id}\`);
+  }
+`;
+      const classContent = classMatch[1];
+      const lastBraceIndex = classContent.lastIndexOf("}");
+      if (lastBraceIndex >= 0) {
+        const updatedContent = classContent.slice(0, lastBraceIndex) + methodCode + classContent.slice(lastBraceIndex);
+        content = content.replace(
+          classMatch[0],
+          `class ${nameProperCase}ModelImpl${classMatch[0].match(/[^{]*/)?.[0]}{${updatedContent}}`
+        );
+      }
+    }
+    return content;
+  }
+  addOnFutureUpdateMethod(content) {
+    const { nameProperCase, updateServices } = this.options;
+    const progressType = updateServices ? `${nameProperCase}OperationProgress` : "Record<string, unknown>";
+    if (content.includes("onFutureUpdate")) {
+      return content;
+    }
+    const futureMethodRegex = /@kosFuture\(\)[^}]*}/s;
+    const futureMethodMatch = content.match(futureMethodRegex);
+    if (futureMethodMatch) {
+      const methodCode = `
+
+  /**
+   * Optional: Custom Future update handling
+   * Called whenever the Future state changes (progress, status, completion, etc.)
+   */
+  onFutureUpdate?(update: IFutureModel<${progressType}>): void {
+    // Add custom Future update logic here
+    // Examples:
+    // - Log progress milestones
+    // - Update derived state based on progress
+    // - Handle specific error conditions
+    // - Trigger notifications at certain thresholds
+
+    this.logger.debug(\`Future update for \${this.id}:\`, {
+      progress: update.progress,
+      status: update.status,
+      endState: update.endState,
+      clientData: update.clientData
+    });
+  }`;
+      content = content.replace(
+        futureMethodMatch[0],
+        futureMethodMatch[0] + methodCode
+      );
+    }
+    return content;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/add-future-to-model/service-transformer.ts
+var ServiceFileTransformer = class {
+  constructor(codegenFs, options) {
+    this.codegenFs = codegenFs;
+    this.options = options;
+  }
+  transform() {
+    const { servicesFilePath } = this.options;
+    if (!servicesFilePath || !this.codegenFs.exists(servicesFilePath)) {
+      this.createServicesFile();
+      return;
+    }
+    let content = this.codegenFs.read(servicesFilePath);
+    content = this.addFutureImports(content);
+    content = this.addFutureService(content);
+    content = this.addProgressTypes(content);
+    this.codegenFs.write(servicesFilePath, content);
+  }
+  createServicesFile() {
+    const { servicesFilePath, nameProperCase, nameDashCase, nameLowerCase } = this.options;
+    if (!servicesFilePath) {
+      return;
+    }
+    const content = `import {
+  KosLog,
+  type ClientResponse,
+  type DeepRequired,
+  type ElementType,
+  type ServiceResponse,
+  type FutureResponse
+} from '@kosdev-code/kos-ui-sdk';
+
+import API, { type KosApi, type ApiPath } from '../../../utils/service';
+
+const log = KosLog.createLogger({name: "${nameDashCase}-service", group: "Services"});
+
+const SERVICE_PATH: ApiPath = "ENTER_SERVICE_PATH"
+export type ${nameProperCase}ClientResponse = ClientResponse<
+  KosApi,
+  typeof SERVICE_PATH,
+  'get'
+>;
+export type ${nameProperCase}Response = DeepRequired<${nameProperCase}ClientResponse>;
+
+/**
+ * @category Service
+ * Retrieves the initial ${nameLowerCase} data.
+ */
+export const get${nameProperCase} = async (): Promise<ServiceResponse<${nameProperCase}Response>> => {
+  log.debug('sending GET for ${nameLowerCase}');
+  return await API.get(SERVICE_PATH);
+};
+
+/**
+ * @category Service - Future Operation
+ * Placeholder for a long-running operation that returns a Future for progress tracking
+ *
+ * Replace this with your actual long-running service operation
+ */
+export const perform${nameProperCase}Operation = async (): Promise<FutureResponse> => {
+  // TODO: Implement your long-running service operation here
+  // This should return a Future that can be tracked for progress
+
+  log.debug('starting long-running ${nameLowerCase} operation');
+
+  // Example pattern:
+  // return API.post(OPERATION_SERVICE_PATH, {
+  //   // operation parameters
+  // });
+
+  // Placeholder - replace with actual implementation
+  throw new Error('perform${nameProperCase}Operation not yet implemented');
+};
+
+// Additional Future-aware service types (add as needed)
+export type ${nameProperCase}OperationProgress = {
+  // Define your progress data structure here
+  stage: string;
+  percentComplete: number;
+  currentItem?: string;
+  totalItems?: number;
+};
+
+export type ${nameProperCase}OperationResult = {
+  // Define your operation result structure here
+  success: boolean;
+  message?: string;
+  data?: any;
+};
+`;
+    this.codegenFs.write(servicesFilePath, content);
+  }
+  addFutureImports(content) {
+    if (content.includes("FutureResponse")) {
+      return content;
+    }
+    const importRegex = /import {\s*([^}]*)\s*} from '@kosdev-code\/kos-ui-sdk';/;
+    const importMatch = content.match(importRegex);
+    if (importMatch) {
+      const existingImports = importMatch[1];
+      if (existingImports.includes("FutureResponse")) {
+        return content;
+      }
+      const cleanedImports = existingImports.trim().replace(/,\s*$/, "");
+      const newImports = cleanedImports ? `${cleanedImports},
+  type FutureResponse` : `type FutureResponse`;
+      const newImportStatement = `import {
+  ${newImports}
+} from '@kosdev-code/kos-ui-sdk';`;
+      return content.replace(importMatch[0], newImportStatement);
+    }
+    return content;
+  }
+  addFutureService(content) {
+    const { nameProperCase, nameLowerCase } = this.options;
+    if (content.includes(`perform${nameProperCase}Operation`)) {
+      return content;
+    }
+    const futureService = `
+/**
+ * @category Service - Future Operation
+ * Placeholder for a long-running operation that returns a Future for progress tracking
+ *
+ * Replace this with your actual long-running service operation
+ */
+export const perform${nameProperCase}Operation = async (): Promise<FutureResponse> => {
+  // TODO: Implement your long-running service operation here
+  // This should return a Future that can be tracked for progress
+
+  log.debug('starting long-running ${nameLowerCase} operation');
+
+  // Example pattern:
+  // return API.post(OPERATION_SERVICE_PATH, {
+  //   // operation parameters
+  // });
+
+  // Placeholder - replace with actual implementation
+  throw new Error('perform${nameProperCase}Operation not yet implemented');
+};`;
+    return content + "\n" + futureService;
+  }
+  addProgressTypes(content) {
+    const { nameProperCase } = this.options;
+    if (content.includes(`${nameProperCase}OperationProgress`)) {
+      return content;
+    }
+    const progressTypes = `
+// Additional Future-aware service types (add as needed)
+export type ${nameProperCase}OperationProgress = {
+  // Define your progress data structure here
+  stage: string;
+  percentComplete: number;
+  currentItem?: string;
+  totalItems?: number;
+};
+
+export type ${nameProperCase}OperationResult = {
+  // Define your operation result structure here
+  success: boolean;
+  message?: string;
+  data?: any;
+};`;
+    return content + "\n" + progressTypes;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/add-future-to-model/registration-transformer.ts
+var RegistrationFileTransformer = class {
+  constructor(codegenFs, options) {
+    this.codegenFs = codegenFs;
+    this.options = options;
+  }
+  transform() {
+    const logger = getCodegenLogger();
+    const { registrationFilePath } = this.options;
+    if (!registrationFilePath || !this.codegenFs.exists(registrationFilePath)) {
+      logger.warn(
+        "Registration file not found, skipping registration updates"
+      );
+      return;
+    }
+    let content = this.codegenFs.read(registrationFilePath);
+    content = this.addTypeCast(content);
+    content = this.updateDocumentation(content);
+    this.codegenFs.write(registrationFilePath, content);
+  }
+  addTypeCast(content) {
+    const { nameProperCase } = this.options;
+    const factoryRegex = new RegExp(`class: ${nameProperCase}ModelImpl,`);
+    const replacement = `class: ${nameProperCase}ModelImpl as any,  // Type cast needed for Future intersection`;
+    return content.replace(factoryRegex, replacement);
+  }
+  updateDocumentation(content) {
+    const { nameProperCase, futureType } = this.options;
+    const descriptionRegex = new RegExp(
+      `(\\* The registration bean includes convenience methods for creating and working with ${nameProperCase}Model instances\\.)`
+    );
+    const futureDocumentation = `$1
+ *
+ * ## Future Support
+ * This model includes ${futureType} Future support for tracking long-running operations with:
+ * - Progress tracking (0-1) with reactive updates
+ * - Status messages during operation
+ * - Cancellation support with bi-directional AbortController integration
+ * - Reactive integration for UI updates${futureType === "complete" ? "\n * - Internal access to Future state for custom logic and computed properties" : ""}`;
+    if (content.match(descriptionRegex)) {
+      content = content.replace(descriptionRegex, futureDocumentation);
+    }
+    const factoryExampleRegex = /(\*\s+\}\);?\s*\*\s+```)/;
+    const futureExample = `$1
+ *
+ * // Example: Accessing Future state (when a Future is active)
+ * const isRunning = model.futureIsRunning;
+ * const progress = model.futureProgress;  // 0-1
+ * const status = model.futureStatus;      // Current status message
+ * \`\`\``;
+    if (content.match(factoryExampleRegex)) {
+      content = content.replace(factoryExampleRegex, futureExample);
+    }
+    const predicateExampleRegex = /(\*\s+model\.updateAvailability\(false\);?\s*\*\s+\})/;
+    const predicateFutureExample = `$1
+ *
+ *    // Future capabilities are also available
+ *    const isRunning = model.futureIsRunning;
+ *    const progress = model.futureProgress;
+ * }`;
+    if (content.match(predicateExampleRegex)) {
+      content = content.replace(predicateExampleRegex, predicateFutureExample);
+    }
+    return content;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/add-future-to-model/generate-add-future-to-model.ts
+function addFutureToModel(codegenFs, options, projects) {
+  const logger = getCodegenLogger();
+  const normalized = normalizeAddFutureOptions(codegenFs, options, projects);
+  logger.info(
+    `Adding ${normalized.futureType} Future support to model: ${normalized.modelName}`
+  );
+  if (!codegenFs.exists(normalized.modelFilePath)) {
+    throw new Error(`Model file not found: ${normalized.modelFilePath}`);
+  }
+  if (options.dryRun) {
+    logger.info("DRY RUN - No files will be modified");
+    logger.info(`Would modify model file: ${normalized.modelFilePath}`);
+    if (normalized.servicesFilePath) {
+      logger.info(
+        `Would modify/create services file: ${normalized.servicesFilePath}`
+      );
+    }
+    if (normalized.registrationFilePath) {
+      logger.info(
+        `Would modify registration file: ${normalized.registrationFilePath}`
+      );
+    }
+    return;
+  }
+  try {
+    logger.info(`Transforming model file: ${normalized.modelFilePath}`);
+    const modelTransformer = new ModelFileTransformer(codegenFs, normalized);
+    modelTransformer.transform();
+    if (normalized.updateServices) {
+      logger.info(
+        `Transforming services file: ${normalized.servicesFilePath || "creating new"}`
+      );
+      const serviceTransformer = new ServiceFileTransformer(
+        codegenFs,
+        normalized
+      );
+      serviceTransformer.transform();
+    }
+    if (normalized.registrationFilePath) {
+      logger.info(
+        `Transforming registration file: ${normalized.registrationFilePath}`
+      );
+      const registrationTransformer = new RegistrationFileTransformer(
+        codegenFs,
+        normalized
+      );
+      registrationTransformer.transform();
+    }
+    logger.info(
+      `Successfully added ${normalized.futureType} Future support to ${normalized.modelName}`
+    );
+    logger.info("");
+    logger.info("Next steps:");
+    logger.info(
+      "1. Review the generated @kosFuture method and implement your actual operation"
+    );
+    logger.info(
+      "2. Update the service method to return a proper FutureResponse"
+    );
+    logger.info("3. Define your specific progress and result types");
+    if (normalized.futureType === "complete") {
+      logger.info(
+        "4. Customize the onFutureUpdate method for your specific needs"
+      );
+    }
+  } catch (error) {
+    logger.error(`Failed to add Future support: ${error}`);
+    throw error;
+  }
+}
+
+// ../kos-codegen-core/src/lib/generators/component/types.ts
+var PLUGIN_TYPES = {
+  CUI: "cui",
+  UTILITY: "utility",
+  TROUBLE_ACTION: "troubleAction",
+  SETUP: "setup",
+  SETTING: "setting",
+  NAV: "nav",
+  CONTROL_POUR: "controlPour",
+  CUSTOM: "custom"
+};
+var CONTRIBUTION_TYPE_MAP = {
+  [PLUGIN_TYPES.SETUP]: "setup",
+  [PLUGIN_TYPES.CUI]: "cui",
+  [PLUGIN_TYPES.UTILITY]: "utility",
+  [PLUGIN_TYPES.SETTING]: "setting",
+  [PLUGIN_TYPES.NAV]: "nav",
+  [PLUGIN_TYPES.TROUBLE_ACTION]: "trouble-action",
+  [PLUGIN_TYPES.CONTROL_POUR]: "control-pour",
+  [PLUGIN_TYPES.CUSTOM]: "custom"
+};
+var LOCALIZED_PLUGIN_TYPES = /* @__PURE__ */ new Set([
+  PLUGIN_TYPES.CUI,
+  PLUGIN_TYPES.UTILITY,
+  PLUGIN_TYPES.SETUP,
+  PLUGIN_TYPES.SETTING,
+  PLUGIN_TYPES.NAV,
+  PLUGIN_TYPES.CONTROL_POUR,
+  PLUGIN_TYPES.TROUBLE_ACTION,
+  PLUGIN_TYPES.CUSTOM
+]);
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/base.ts
+var BasePluginHandler = class {
+  getContributionKey() {
+    return this.contributionKey;
+  }
+  requiresLocalization() {
+    return this.requiresI18n;
+  }
+  getTemplatePath() {
+    return this.contributionKey;
+  }
+  /**
+   * Helper to create experience configuration
+   */
+  createExperience(options, experienceId) {
+    const compPath = this.getComponentPath(options);
+    return {
+      id: experienceId,
+      component: options.namePascalCase,
+      location: `./src/${compPath}`
+    };
+  }
+  /**
+   * Helper to get component path
+   */
+  getComponentPath(options) {
+    return `${options.appDirectory}/${this.contributionKey}/${options.nameDashCase}/${options.nameDashCase}.tsx`;
+  }
+  /**
+   * Helper to create config prefix
+   */
+  getConfigPrefix(options) {
+    return `${options.appProject}.${options.nameCamelCase}`;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/control-pour-handler.ts
+var ControlPourPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.CONTROL_POUR;
+  contributionKey = "control-pour";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.controlPour.experience`;
+    const contribution = {
+      id: `${configPrefix}.controlPour`,
+      title: `${configPrefix}.controlPour.title`,
+      namespace: options.appProject,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        controlPour: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/cui-handler.ts
+var CuiPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.CUI;
+  contributionKey = "cui";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.cui.experience`;
+    const contribution = {
+      id: configPrefix,
+      title: `${configPrefix}.cui.title`,
+      namespace: options.appProject,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        cui: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/custom-handler.ts
+var CustomPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.CUSTOM;
+  contributionKey = "custom";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.${options.contributionKey || "custom"}.experience`;
+    const userContributionKey = options.contributionKey || "custom";
+    const contribution = {
+      id: configPrefix,
+      title: `${configPrefix}.${userContributionKey}.title`,
+      namespace: options.appProject,
+      experienceId
+      // TODO: Add additional fields as required by the plugin-explorer specification
+      // Refer to the plugin-explorer documentation for your specific contribution type
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        [userContributionKey]: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+  getTemplatePath() {
+    return this.contributionKey || "custom";
+  }
+  getComponentPath(options) {
+    const pathKey = options.contributionKey || "custom";
+    return `${options.appDirectory}/${pathKey}/${options.nameDashCase}/${options.nameDashCase}.tsx`;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/default-handler.ts
+var DefaultComponentHandler = class extends BasePluginHandler {
+  pluginType = "component";
+  contributionKey = "components";
+  requiresI18n = false;
+  createConfiguration(options) {
+    const compPath = this.getComponentPath(options);
+    const viewConfig = {
+      id: `${options.appProject}.${options.nameCamelCase}`,
+      title: "ddk.ncui.config.title",
+      namespace: options.appProject,
+      component: options.namePascalCase,
+      location: `./src/${compPath}`
+    };
+    return {
+      contributions: {},
+      experiences: {},
+      views: {
+        [this.getTabViewKey()]: [viewConfig]
+      }
+    };
+  }
+  getTabViewKey() {
+    return "ddk.ncui.settings.tabView";
+  }
+  getTemplatePath() {
+    return "files";
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/nav-handler.ts
+var NavPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.NAV;
+  contributionKey = "nav";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.nav.experience`;
+    const contribution = {
+      id: `${configPrefix}.nav`,
+      title: `${configPrefix}.nav.title`,
+      namespace: options.appProject,
+      navDescriptor: options.nameLowerCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        navViews: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/setting-handler.ts
+var SettingPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.SETTING;
+  contributionKey = "setting";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.settings.experience`;
+    const contribution = {
+      id: `${configPrefix}.setting`,
+      title: `${configPrefix}.setting.title`,
+      namespace: options.appProject,
+      settingsGroup: options.group || "general",
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        settings: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/setup-handler.ts
+var SetupPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.SETUP;
+  contributionKey = "setup";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.setup.experience`;
+    const contribution = {
+      id: `${configPrefix}.setup`,
+      title: `${configPrefix}.setup.title`,
+      namespace: options.appProject,
+      setupDescriptor: options.nameCamelCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        setupStep: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/trouble-action-handler.ts
+var TroubleActionPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.TROUBLE_ACTION;
+  contributionKey = "trouble-action";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.troubleAction.experience`;
+    const contribution = {
+      id: `${configPrefix}.troubleAction`,
+      title: `${configPrefix}.troubleAction.title`,
+      namespace: options.appProject,
+      troubleType: options.nameCamelCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        troubleActions: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/utility-handler.ts
+var UtilityPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.UTILITY;
+  contributionKey = "utility";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.util.experience`;
+    const contribution = {
+      id: `${configPrefix}.util`,
+      title: `${configPrefix}.utility.title`,
+      namespace: options.appProject,
+      utilDescriptor: options.nameCamelCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        utilities: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/factory.ts
+var PluginHandlerFactory = class {
+  static handlers = /* @__PURE__ */ new Map([
+    [PLUGIN_TYPES.CUI, CuiPluginHandler],
+    [PLUGIN_TYPES.UTILITY, UtilityPluginHandler],
+    [PLUGIN_TYPES.SETTING, SettingPluginHandler],
+    [PLUGIN_TYPES.SETUP, SetupPluginHandler],
+    [PLUGIN_TYPES.NAV, NavPluginHandler],
+    [PLUGIN_TYPES.CONTROL_POUR, ControlPourPluginHandler],
+    [PLUGIN_TYPES.TROUBLE_ACTION, TroubleActionPluginHandler],
+    [PLUGIN_TYPES.CUSTOM, CustomPluginHandler]
+  ]);
+  static createHandler(pluginType) {
+    if (!pluginType) {
+      return new DefaultComponentHandler();
+    }
+    const HandlerClass = this.handlers.get(pluginType);
+    if (!HandlerClass) {
+      console.warn(
+        `No handler found for plugin type: ${pluginType}. Using default handler.`
+      );
+      return new DefaultComponentHandler();
+    }
+    return new HandlerClass();
+  }
+  static isValidPluginType(type) {
+    return this.handlers.has(type);
+  }
+};
+
+// src/lib/utils/nx-context.mjs
+var __dirname2 = path6.dirname(fileURLToPath(import.meta.url));
+function findKosJsonFiles(dir = process.cwd(), files = []) {
+  try {
+    const entries = readdirSync2(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 = path6.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 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 = path6.join(workspaceRoot, dir);
+    if (existsSync3(dirPath)) {
+      findKosJsonFiles(dirPath, kosJsonFiles);
+    }
+  }
+  const rootKosJson = path6.join(workspaceRoot, ".kos.json");
+  if (existsSync3(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(readFileSync3(kosJsonPath, "utf-8"));
+      const projectDir = path6.dirname(kosJsonPath);
+      let projectName = null;
+      const projectJsonPath = path6.join(projectDir, "project.json");
+      if (existsSync3(projectJsonPath)) {
+        try {
+          const projectJson = JSON.parse(readFileSync3(projectJsonPath, "utf-8"));
+          projectName = projectJson.name;
+        } catch (error) {
+          projectName = path6.basename(projectDir);
+        }
+      } else {
+        projectName = path6.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/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
+  }
+];
+
+// src/lib/generators/model/add-future.mjs
+var metadata = {
   key: "add-future",
   name: "Add Future Support to Model",
   invalidateCache: true,
@@ -15,54 +1430,41 @@ export const metadata = {
     futureType: "futureType",
     updateServices: "updateServices",
     dryRun: "dryRun",
-    interactive: "interactive",
-  },
+    interactive: "interactive"
+  }
 };
-
-export default async function (plop) {
-  // 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.
+async function add_future_default(plop) {
+  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("addFutureToModel", async function (answers) {
+  plop.setActionType("addFutureToModel", async function(answers) {
+    const cwd = process.cwd();
+    const codegenFs = 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-add-future-to-model \\
-      --modelName=${answers.modelName} \\
-      --modelProject=${modelProject} \\
-      --futureType=${answers.futureType} \\
-      --updateServices=${!!answers.updateServices} \\
-      --no-interactive ${answers.dryRun ? "--dryRun" : ""} --verbose`;
-
-    try {
-      await execute(command);
-    } catch (error) {
-      throw new Error(error);
-    }
-
+    const modelProject = allModels.find((m) => m.model === answers.modelName)?.project;
+    addFutureToModel(codegenFs, {
+      modelName: answers.modelName,
+      modelProject,
+      futureType: answers.futureType,
+      updateServices: !!answers.updateServices,
+      dryRun: !!answers.dryRun
+    });
     return `Future support (${answers.futureType}) added to model ${answers.modelName} in ${modelProject}`;
   });
-
   plop.setGenerator("add-future", {
     description: "Add Future support to an existing KOS Model",
     prompts: [
@@ -71,7 +1473,7 @@ export default async function (plop) {
         type: "list",
         name: "modelName",
         message: "Which model do you want to add Future support to?",
-        choices: modelChoices,
+        choices: modelChoices
       },
       {
         type: "list",
@@ -79,18 +1481,22 @@ export default async function (plop) {
         message: "What type of Future support?",
         choices: [
           { name: "Minimal (external access only)", value: "minimal" },
-          { name: "Complete (internal + external access)", value: "complete" },
+          { name: "Complete (internal + external access)", value: "complete" }
         ],
-        default: "minimal",
+        default: "minimal"
       },
       {
         type: "confirm",
         name: "updateServices",
         message: "Update/create services file with Future operations?",
-        default: true,
-      },
+        default: true
+      }
     ],
-
-    actions: actionFactory("addFutureToModel", metadata),
+    actions: actionFactory("addFutureToModel", metadata)
   });
 }
+export {
+  add_future_default as default,
+  metadata
+};
+//# sourceMappingURL=add-future.mjs.map