@solid-stack/mason 1.0.11

package/dist/index.js

@@ -0,0 +1,3444 @@
+import fs3 from 'fs';
+import path7 from 'path';
+import * as p4 from '@clack/prompts';
+import pc13 from 'picocolors';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import Handlebars from 'handlebars';
+import { cac } from 'cac';
+
+// src/utils/formatting.ts
+function toPascalCase(str) {
+  if (!str) return "";
+  return str.replace(/[^\w\s-]/g, "").replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[a-z]/, (c) => c.toUpperCase());
+}
+function toCamelCase(str) {
+  if (!str) return "";
+  let s = str;
+  if (/^I[A-Z]/.test(s)) {
+    s = s.slice(1);
+  }
+  const pascal = toPascalCase(s);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toKebabCase(str) {
+  if (!str) return "";
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[-_\s]+/g, "-").toLowerCase();
+}
+function toSingular(str) {
+  if (!str) return "";
+  const lower = str.toLowerCase();
+  if (lower.endsWith("ies")) {
+    return str.slice(0, -3) + (str.endsWith("IES") ? "Y" : "y");
+  }
+  if (lower.endsWith("ses") && !lower.endsWith("sses")) {
+    return str.slice(0, -2);
+  }
+  if (lower.endsWith("s") && !lower.endsWith("ss")) {
+    return str.slice(0, -1);
+  }
+  return str;
+}
+function toPlural(str) {
+  if (!str) return "";
+  const lower = str.toLowerCase();
+  if (lower.endsWith("y") && !/[aeiou]y$/i.test(lower)) {
+    return str.slice(0, -1) + (str.endsWith("Y") ? "IES" : "ies");
+  }
+  if (lower.endsWith("s") || lower.endsWith("x") || lower.endsWith("z") || lower.endsWith("ch") || lower.endsWith("sh")) {
+    return str + (str === str.toUpperCase() ? "ES" : "es");
+  }
+  return str + (str === str.toUpperCase() ? "S" : "s");
+}
+function ensureInterfacePrefix(name) {
+  const pascal = toPascalCase(name);
+  if (/^I[A-Z]/.test(pascal)) {
+    return pascal;
+  }
+  return `I${pascal}`;
+}
+function removeInterfacePrefix(name) {
+  if (/^I[A-Z]/.test(name)) {
+    return name.slice(1);
+  }
+  return name;
+}
+function toStubName(ifaceName) {
+  const base = removeInterfacePrefix(ifaceName);
+  if (base.startsWith("Stub")) {
+    return base;
+  }
+  return `Stub${base}`;
+}
+function isValidIdentifier(str) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(str);
+}
+function writeFileSafely(absolutePath, content, options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const relPath = path7.relative(projectRoot, absolutePath).replace(/\\/g, "/");
+  const existedBefore = fs3.existsSync(absolutePath);
+  if (options.dryRun) {
+    return {
+      relativePath: relPath,
+      absolutePath,
+      content,
+      action: "preview",
+      existedBefore
+    };
+  }
+  if (existedBefore && !options.overwrite) {
+    return {
+      relativePath: relPath,
+      absolutePath,
+      content,
+      action: "skipped",
+      existedBefore: true
+    };
+  }
+  const dir = path7.dirname(absolutePath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  fs3.writeFileSync(absolutePath, content, "utf-8");
+  return {
+    relativePath: relPath,
+    absolutePath,
+    content,
+    action: existedBefore ? "overwritten" : "created",
+    existedBefore
+  };
+}
+function printGeneratedFiles(files, isDryRun = false) {
+  console.log("");
+  if (isDryRun) {
+    p4.log.warn(pc13.yellow(pc13.bold("[DRY RUN PREVIEW] No files were written to disk.")));
+  }
+  for (const f of files) {
+    if (f.action === "created") {
+      p4.log.success(`${pc13.bold(f.relativePath)} ${pc13.dim("(created)")}`);
+    } else if (f.action === "overwritten") {
+      p4.log.warn(`${pc13.bold(f.relativePath)} ${pc13.dim("(overwritten)")}`);
+    } else if (f.action === "skipped") {
+      p4.log.info(`${pc13.dim(f.relativePath)} ${pc13.dim("(skipped - already exists, pass -o to overwrite)")}`);
+    } else {
+      p4.log.info(`${pc13.bold(f.relativePath)} ${pc13.dim("(preview)")}`);
+    }
+  }
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let current = path7.resolve(startDir);
+  while (true) {
+    if (fs3.existsSync(path7.join(current, "package.json"))) {
+      return current;
+    }
+    const parent = path7.dirname(current);
+    if (parent === current) {
+      return path7.resolve(startDir);
+    }
+    current = parent;
+  }
+}
+function resolveFeaturesDir(projectRoot) {
+  return path7.join(projectRoot, "features");
+}
+function listExistingFeatures(projectRoot) {
+  const featuresDir = resolveFeaturesDir(projectRoot);
+  if (!fs3.existsSync(featuresDir)) return [];
+  try {
+    const entries = fs3.readdirSync(featuresDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+function listDomainInterfaces(projectRoot, featureName) {
+  const results = [];
+  const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
+  for (const feat of features) {
+    const domainDir = path7.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs3.existsSync(domainDir)) continue;
+    try {
+      const files = fs3.readdirSync(domainDir);
+      for (const file of files) {
+        if (file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".d.ts")) {
+          const name = file.replace(/\.ts$/, "");
+          const fullPath = path7.join(domainDir, file);
+          if (/^I[A-Z]/.test(name)) {
+            results.push({
+              name,
+              fullPath,
+              feature: feat
+            });
+          } else {
+            try {
+              const content = fs3.readFileSync(fullPath, "utf-8");
+              if (/export\s+(?:abstract\s+class|interface)\s+(\w+)/.test(content)) {
+                results.push({
+                  name,
+                  fullPath,
+                  feature: feat
+                });
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function listDomainEntities(projectRoot, featureName) {
+  const results = [];
+  const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
+  for (const feat of features) {
+    const domainDir = path7.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs3.existsSync(domainDir)) continue;
+    try {
+      const files = fs3.readdirSync(domainDir);
+      for (const file of files) {
+        if (file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".d.ts")) {
+          const name = file.replace(/\.ts$/, "");
+          if (!/^I[A-Z]/.test(name)) {
+            results.push({
+              name,
+              fullPath: path7.join(domainDir, file),
+              feature: feat
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function listUseCases(projectRoot, featureName) {
+  const results = [];
+  const features = featureName ? [featureName] : listExistingFeatures(projectRoot);
+  for (const feat of features) {
+    const useCasesDir = path7.join(resolveFeaturesDir(projectRoot), feat, "useCases");
+    if (!fs3.existsSync(useCasesDir)) continue;
+    try {
+      const files = fs3.readdirSync(useCasesDir);
+      for (const file of files) {
+        if (file.endsWith(".ts") && !file.endsWith(".test.ts") && !file.endsWith(".d.ts")) {
+          const name = file.replace(/\.ts$/, "");
+          results.push({
+            name,
+            fullPath: path7.join(useCasesDir, file),
+            feature: feat
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+var PromptCancelledError = class extends Error {
+  constructor(message = "Operation cancelled.") {
+    super(message);
+    this.name = "PromptCancelledError";
+  }
+};
+function handleCancel(result) {
+  if (p4.isCancel(result)) {
+    p4.cancel("Operation cancelled.");
+    throw new PromptCancelledError();
+  }
+  return result;
+}
+function printBanner() {
+  console.log("");
+  p4.intro(pc13.bgCyan(pc13.black(" @solid-stack/mason ")));
+}
+async function promptProperties(options = {}) {
+  const properties = options.defaults ? [...options.defaults] : [];
+  if (properties.length > 0) {
+    const summary = properties.map((p15) => `${p15.name}: ${p15.type}${p15.optional ? "?" : ""}`).join(", ");
+    p4.log.info(pc13.dim(`Pre-configured fields: ${summary}`));
+    const addMore = handleCancel(
+      await p4.confirm({
+        message: "Would you like to add custom fields/properties?",
+        initialValue: false
+      })
+    );
+    if (!addMore) {
+      return properties;
+    }
+  }
+  p4.log.info(pc13.cyan("Enter properties (leave name blank when finished):"));
+  while (true) {
+    const name = handleCancel(
+      await p4.text({
+        message: "Property name (or press Enter to finish):",
+        placeholder: "e.g. title, email, status"
+      })
+    );
+    if (!name || !name.trim()) {
+      break;
+    }
+    const type = handleCancel(
+      await p4.select({
+        message: `Type for property "${name.trim()}":`,
+        options: [
+          { value: "string", label: "string" },
+          { value: "number", label: "number" },
+          { value: "boolean", label: "boolean" },
+          { value: "Date", label: "Date" },
+          { value: "string[]", label: "string[]" },
+          { value: "Record<string, unknown>", label: "Record<string, unknown>" },
+          { value: "custom", label: "Custom type..." }
+        ],
+        initialValue: "string"
+      })
+    );
+    let finalType = type;
+    if (type === "custom") {
+      finalType = handleCancel(
+        await p4.text({
+          message: `Enter custom type for "${name.trim()}":`,
+          placeholder: "e.g. UserRole, string | null",
+          validate: (val) => val && val.trim() ? void 0 : "Type cannot be empty"
+        })
+      );
+    }
+    const optional = handleCancel(
+      await p4.confirm({
+        message: `Is "${name.trim()}" optional?`,
+        initialValue: false
+      })
+    );
+    properties.push({
+      name: name.trim(),
+      type: finalType.trim(),
+      optional
+    });
+    p4.log.success(
+      pc13.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
+    );
+  }
+  return properties;
+}
+var DEFAULT_REGISTRY_BASE = "https://raw.githubusercontent.com/solid-stack-digital/mason-registry/main";
+function getRegistryBase(projectRoot, override) {
+  if (override && override.trim()) {
+    return override.trim();
+  }
+  if (process.env.MASON_REGISTRY_URL && process.env.MASON_REGISTRY_URL.trim()) {
+    return process.env.MASON_REGISTRY_URL.trim();
+  }
+  if (projectRoot) {
+    const configPath = path7.join(projectRoot, "mason.config.json");
+    if (fs3.existsSync(configPath)) {
+      try {
+        const config = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+        if (config.registry && typeof config.registry === "string") {
+          return config.registry.trim();
+        }
+      } catch {
+      }
+    }
+  }
+  if (projectRoot) {
+    const siblingRegistry = path7.resolve(projectRoot, "../mason-registry");
+    if (fs3.existsSync(siblingRegistry) && fs3.existsSync(path7.join(siblingRegistry, "index.json"))) {
+      return siblingRegistry;
+    }
+  }
+  return DEFAULT_REGISTRY_BASE;
+}
+async function fetchRegistryFile(registryBase, relPath) {
+  const cleanRelPath = relPath.replace(/^\/+/, "");
+  if (registryBase.startsWith("http://") || registryBase.startsWith("https://")) {
+    const url = `${registryBase.replace(/\/+$/, "")}/${cleanRelPath}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`Failed to fetch ${cleanRelPath} from ${url} (HTTP ${res.status}: ${res.statusText})`);
+    }
+    return await res.text();
+  }
+  let baseDir = registryBase;
+  if (baseDir.startsWith("file://")) {
+    baseDir = fileURLToPath(baseDir);
+  }
+  const filePath = path7.resolve(baseDir, cleanRelPath);
+  if (!fs3.existsSync(filePath)) {
+    throw new Error(`Registry file not found at ${filePath}`);
+  }
+  return fs3.promises.readFile(filePath, "utf-8");
+}
+async function fetchRegistryIndex(registryBase) {
+  const content = await fetchRegistryFile(registryBase, "index.json");
+  return JSON.parse(content);
+}
+async function fetchModuleManifest(registryBase, type, name) {
+  const folder = type === "shared" ? "shared" : "features";
+  const manifestPath = `${folder}/${name}/registry.json`;
+  const content = await fetchRegistryFile(registryBase, manifestPath);
+  return JSON.parse(content);
+}
+function levenshteinDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) {
+    dp[i][0] = i;
+  }
+  for (let j = 0; j <= n; j++) {
+    dp[0][j] = j;
+  }
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1];
+      } else {
+        dp[i][j] = Math.min(
+          dp[i - 1][j] + 1,
+          // deletion
+          dp[i][j - 1] + 1,
+          // insertion
+          dp[i - 1][j - 1] + 1
+          // substitution
+        );
+      }
+    }
+  }
+  return dp[m][n];
+}
+function findClosestMatch(target, candidates) {
+  if (candidates.length === 0) return null;
+  const lower = target.toLowerCase();
+  let closest = null;
+  let minDistance = Infinity;
+  for (const candidate of candidates) {
+    const candLower = candidate.toLowerCase();
+    if (candLower.includes(lower) || lower.includes(candLower)) {
+      return candidate;
+    }
+    const dist = levenshteinDistance(lower, candLower);
+    if (dist < minDistance) {
+      minDistance = dist;
+      closest = candidate;
+    }
+  }
+  if (minDistance <= 3) {
+    return closest;
+  }
+  return null;
+}
+function detectPackageManager(projectRoot) {
+  if (fs3.existsSync(path7.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs3.existsSync(path7.join(projectRoot, "yarn.lock"))) return "yarn";
+  if (fs3.existsSync(path7.join(projectRoot, "bun.lockb")) || fs3.existsSync(path7.join(projectRoot, "bun.lock"))) return "bun";
+  return "npm";
+}
+function getMissingNpmPackages(projectRoot, requiredPackages) {
+  if (!requiredPackages || requiredPackages.length === 0) return [];
+  const pkgJsonPath = path7.join(projectRoot, "package.json");
+  if (!fs3.existsSync(pkgJsonPath)) {
+    return requiredPackages;
+  }
+  try {
+    const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+    const installed = /* @__PURE__ */ new Set([
+      ...Object.keys(pkg.dependencies || {}),
+      ...Object.keys(pkg.devDependencies || {}),
+      ...Object.keys(pkg.peerDependencies || {})
+    ]);
+    return requiredPackages.filter((p15) => {
+      const nameOnly = p15.startsWith("@") ? `@${p15.slice(1).split("@")[0] || ""}` : p15.split("@")[0] || p15;
+      return !installed.has(nameOnly);
+    });
+  } catch {
+    return requiredPackages;
+  }
+}
+function installNpmPackages(projectRoot, packages, pm) {
+  if (!packages || packages.length === 0) return;
+  const manager = pm || detectPackageManager(projectRoot);
+  let installCmd;
+  switch (manager) {
+    case "pnpm":
+      installCmd = `pnpm add ${packages.join(" ")}`;
+      break;
+    case "yarn":
+      installCmd = `yarn add ${packages.join(" ")}`;
+      break;
+    case "bun":
+      installCmd = `bun add ${packages.join(" ")}`;
+      break;
+    default:
+      installCmd = `npm install ${packages.join(" ")}`;
+      break;
+  }
+  p4.log.info(`Installing missing dependencies with ${manager}: ${pc13.cyan(packages.join(", "))}`);
+  execSync(installCmd, {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+}
+var hbs = Handlebars.create();
+hbs.registerHelper("eq", (a, b) => a === b);
+hbs.registerHelper("ne", (a, b) => a !== b);
+hbs.registerHelper("not", (a) => !a);
+hbs.registerHelper("and", (...args) => args.slice(0, -1).every(Boolean));
+hbs.registerHelper("or", (...args) => args.slice(0, -1).some(Boolean));
+hbs.registerHelper("pascalCase", (str) => toPascalCase(str));
+hbs.registerHelper("camelCase", (str) => toCamelCase(str));
+hbs.registerHelper("kebabCase", (str) => toKebabCase(str));
+hbs.registerHelper("join", (arr, sep) => {
+  if (!Array.isArray(arr)) return "";
+  const delimiter = typeof sep === "string" ? sep : ", ";
+  return arr.join(delimiter);
+});
+var cachedTemplatesDir = null;
+function getTemplatesDir() {
+  if (cachedTemplatesDir && fs3.existsSync(cachedTemplatesDir)) {
+    return cachedTemplatesDir;
+  }
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path7.dirname(fileURLToPath(import.meta.url));
+  const cand1 = path7.resolve(currentDir, "../../templates");
+  if (fs3.existsSync(cand1)) {
+    cachedTemplatesDir = cand1;
+    return cand1;
+  }
+  const cand2 = path7.resolve(currentDir, "../templates");
+  if (fs3.existsSync(cand2)) {
+    cachedTemplatesDir = cand2;
+    return cand2;
+  }
+  const cand3 = path7.resolve(currentDir, "templates");
+  if (fs3.existsSync(cand3)) {
+    cachedTemplatesDir = cand3;
+    return cand3;
+  }
+  let curr = currentDir;
+  while (true) {
+    const candTemplates = path7.join(curr, "templates");
+    if (fs3.existsSync(candTemplates)) {
+      cachedTemplatesDir = candTemplates;
+      return candTemplates;
+    }
+    const parent = path7.dirname(curr);
+    if (parent === curr) break;
+    curr = parent;
+  }
+  throw new Error("Could not locate templates directory for @solid-stack/create");
+}
+var templateCache = /* @__PURE__ */ new Map();
+function loadTemplate(relativePath) {
+  const fullPath = path7.isAbsolute(relativePath) ? relativePath : path7.join(getTemplatesDir(), relativePath);
+  return fs3.readFileSync(fullPath, "utf-8");
+}
+function renderTemplateFile(relativePath, context) {
+  let compiled = templateCache.get(relativePath);
+  if (!compiled) {
+    const source = loadTemplate(relativePath);
+    compiled = hbs.compile(source.trim(), { noEscape: true });
+    templateCache.set(relativePath, compiled);
+  }
+  const result = compiled(context);
+  return result.endsWith("\n") ? result : result + "\n";
+}
+function renderTemplate(sourceOrPath, context) {
+  if (sourceOrPath.endsWith(".hbs")) {
+    return renderTemplateFile(sourceOrPath, context);
+  }
+  let compiled = templateCache.get(sourceOrPath);
+  if (!compiled) {
+    compiled = hbs.compile(sourceOrPath.trim(), { noEscape: true });
+    templateCache.set(sourceOrPath, compiled);
+  }
+  const result = compiled(context);
+  return result.endsWith("\n") ? result : result + "\n";
+}
+
+// src/templates/domain.template.ts
+var domainInterfaceTemplate = loadTemplate("domain/interface.hbs");
+var domainClassTemplate = loadTemplate("domain/class.hbs");
+var domainValueObjectTemplate = loadTemplate("domain/valueObject.hbs");
+
+// src/templates/interface.template.ts
+var interfaceTemplate = loadTemplate("interface/interface.hbs");
+
+// src/templates/useCase.template.ts
+var useCaseTemplate = loadTemplate("useCase/useCase.hbs");
+var useCaseTestTemplate = loadTemplate("useCase/useCaseTest.hbs");
+
+// src/templates/infra.template.ts
+var concreteInfraTemplate = loadTemplate("infra/concrete.hbs");
+var stubInfraTemplate = loadTemplate("infra/stub.hbs");
+
+// src/templates/httpHandler.template.ts
+var httpHandlerTemplate = loadTemplate("httpHandler/handler.hbs");
+
+// src/templates/injectable.template.ts
+var injectableTemplate = loadTemplate("injectable/injectable.hbs");
+var injectableInterfaceTemplate = loadTemplate("injectable/interface.hbs");
+
+// src/templates/provider.template.ts
+var diProviderTemplate = loadTemplate("provider/provider.hbs");
+
+// src/templates/expressIndex.template.ts
+var expressIndexTemplate = loadTemplate("express/index.hbs");
+function generateDomainEntityCode(name, kind = "interface", properties = []) {
+  const entityName = toPascalCase(name);
+  const defaultProps = [
+    { name: "id", type: "string" },
+    { name: "createdAt", type: "Date" },
+    { name: "updatedAt", type: "Date" }
+  ];
+  const effectiveProps = properties.length > 0 ? properties : defaultProps;
+  if (kind === "interface") {
+    return renderTemplate(domainInterfaceTemplate, {
+      name: entityName,
+      properties: effectiveProps
+    });
+  }
+  if (kind === "class") {
+    return renderTemplate(domainClassTemplate, {
+      name: entityName,
+      properties: effectiveProps
+    });
+  }
+  if (kind === "valueObject") {
+    const valueProp = effectiveProps[0] || { name: "value", type: "string" };
+    return renderTemplate(domainValueObjectTemplate, {
+      name: entityName,
+      valueProp
+    });
+  }
+  return "";
+}
+function generateDomain(options) {
+  const projectRoot = options.projectRoot || findProjectRoot();
+  const entityName = toPascalCase(options.name);
+  const targetDir = options.targetDir || path7.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
+  const filePath = path7.join(targetDir, `${entityName}.ts`);
+  const code = generateDomainEntityCode(
+    entityName,
+    options.kind || "interface",
+    options.properties || []
+  );
+  return writeFileSafely(filePath, code, {
+    projectRoot,
+    dryRun: options.dryRun,
+    overwrite: options.overwrite
+  });
+}
+function generateInterfaceCode(ifaceName, kind = "abstractClass", entityName, methodsPreset = "crud", customMethods = []) {
+  const validIfaceName = ensureInterfacePrefix(ifaceName);
+  const baseEntity = entityName ? toPascalCase(entityName) : toPascalCase(removeInterfacePrefix(validIfaceName).replace(/Repository$|Service$|Client$/, ""));
+  const isCrud = methodsPreset === "crud" && Boolean(baseEntity);
+  const isCustom = methodsPreset === "custom" && customMethods.length > 0;
+  const isAbstractClass = kind === "abstractClass";
+  const methodPrefix = isAbstractClass ? "abstract " : "";
+  const domainImport = isCrud ? baseEntity : void 0;
+  const entityKey = baseEntity ? baseEntity.charAt(0).toLowerCase() + baseEntity.slice(1) : "";
+  const idKey = `${entityKey}Id`;
+  const listKey = `${entityKey}s`;
+  const formattedCustomMethods = customMethods.map((m) => {
+    const params = m.params && m.params.length > 0 ? m.params.map((p15) => `${p15.name}: ${p15.type}`).join("; ") : "";
+    const returnType = m.returnType ? `Promise<${m.returnType}>` : "Promise<void>";
+    return {
+      name: m.name,
+      params,
+      returnType
+    };
+  });
+  return renderTemplate(interfaceTemplate, {
+    ifaceName: validIfaceName,
+    isAbstractClass,
+    domainImport,
+    isCrud,
+    baseEntity,
+    idKey,
+    entityKey,
+    listKey,
+    methodPrefix,
+    isCustom,
+    customMethods: formattedCustomMethods
+  });
+}
+function generateInterface(options) {
+  const projectRoot = options.projectRoot || findProjectRoot();
+  const ifaceName = ensureInterfacePrefix(options.name);
+  const targetDir = options.targetDir || path7.join(resolveFeaturesDir(projectRoot), options.feature, "domain");
+  const filePath = path7.join(targetDir, `${ifaceName}.ts`);
+  const code = generateInterfaceCode(
+    ifaceName,
+    options.kind || "abstractClass",
+    options.entityName,
+    options.methodsPreset || "crud",
+    options.customMethods || []
+  );
+  return writeFileSafely(filePath, code, {
+    projectRoot,
+    dryRun: options.dryRun,
+    overwrite: options.overwrite
+  });
+}
+function parseInterfaceMethodsAndImports(content, targetIfaceName) {
+  const imports = [];
+  const methods = [];
+  let extendsClass;
+  const importRegex = /import\s+(type\s+)?(?:(\w+)|\{([^}]+)\}|\*\s+as\s+(\w+))\s+from\s+["']([^"']+)["'];?/g;
+  let impMatch;
+  while ((impMatch = importRegex.exec(content)) !== null) {
+    const isGlobalType = Boolean(impMatch[1]);
+    const defaultImport = impMatch[2];
+    const namedImports = impMatch[3];
+    const namespaceImport = impMatch[4];
+    const specifier = impMatch[5];
+    const items = [];
+    if (defaultImport) {
+      items.push({ name: defaultImport, isTypeOnly: isGlobalType ? true : void 0 });
+    } else if (namespaceImport) {
+      items.push({ name: namespaceImport, isTypeOnly: isGlobalType ? true : void 0 });
+    } else if (namedImports) {
+      const parts = namedImports.split(",");
+      for (const part of parts) {
+        const trimmed = part.trim();
+        if (!trimmed) continue;
+        const typeMatch = trimmed.match(/^type\s+(\w+)(?:\s+as\s+\w+)?$/);
+        const normalMatch = trimmed.match(/^(\w+)(?:\s+as\s+\w+)?$/);
+        if (typeMatch) {
+          items.push({ name: typeMatch[1], isTypeOnly: true });
+        } else if (normalMatch) {
+          items.push({ name: normalMatch[1], isTypeOnly: isGlobalType ? true : void 0 });
+        }
+      }
+    }
+    if (items.length > 0) {
+      imports.push({
+        specifier,
+        items,
+        isTypeOnly: isGlobalType
+      });
+    }
+  }
+  let classRegex;
+  if (targetIfaceName) {
+    classRegex = new RegExp(
+      `(?:export\\s+)?(?:abstract\\s+class|interface)\\s+(${targetIfaceName})\\b([^{]*)\\{`,
+      "g"
+    );
+  } else {
+    classRegex = /(?:export\\s+)?(?:abstract\\s+class|interface)\\s+([A-Za-z0-9_$]+)\b([^{]*)\{/g;
+  }
+  const declMatch = classRegex.exec(content);
+  if (!declMatch) {
+    return {
+      className: targetIfaceName || "",
+      methods: [],
+      imports
+    };
+  }
+  const className = declMatch[1];
+  const headerRemainder = declMatch[2] || "";
+  const headerEnd = declMatch.index + declMatch[0].length;
+  const extMatch = headerRemainder.match(/\bextends\s+([A-Za-z0-9_$]+)\b/);
+  if (extMatch) {
+    extendsClass = extMatch[1];
+  }
+  let depth = 1;
+  let bodyEnd = -1;
+  for (let i = headerEnd; i < content.length; i++) {
+    const ch = content[i];
+    if (ch === "/" && content[i + 1] === "/") {
+      const nl = content.indexOf("\n", i);
+      i = nl === -1 ? content.length : nl;
+      continue;
+    }
+    if (ch === "/" && content[i + 1] === "*") {
+      const closeComment = content.indexOf("*/", i + 2);
+      i = closeComment === -1 ? content.length : closeComment + 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      i++;
+      while (i < content.length && content[i] !== quote) {
+        if (content[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        bodyEnd = i;
+        break;
+      }
+    }
+  }
+  if (bodyEnd === -1) {
+    bodyEnd = content.length;
+  }
+  const body = content.slice(headerEnd, bodyEnd);
+  const statements = [];
+  let currentStmt = "";
+  let pDepth = 0;
+  let bDepth = 0;
+  let sDepth = 0;
+  let aDepth = 0;
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (ch === "/" && body[i + 1] === "/") {
+      const nl = body.indexOf("\n", i);
+      i = nl === -1 ? body.length : nl;
+      continue;
+    }
+    if (ch === "/" && body[i + 1] === "*") {
+      const closeComment = body.indexOf("*/", i + 2);
+      i = closeComment === -1 ? body.length : closeComment + 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      currentStmt += ch;
+      i++;
+      while (i < body.length && body[i] !== quote) {
+        if (body[i] === "\\") {
+          currentStmt += body[i];
+          i++;
+        }
+        if (i < body.length) currentStmt += body[i];
+        i++;
+      }
+      if (i < body.length) currentStmt += body[i];
+      continue;
+    }
+    if (ch === "(") pDepth++;
+    else if (ch === ")") pDepth = Math.max(0, pDepth - 1);
+    else if (ch === "{") bDepth++;
+    else if (ch === "}") bDepth = Math.max(0, bDepth - 1);
+    else if (ch === "[") sDepth++;
+    else if (ch === "]") sDepth = Math.max(0, sDepth - 1);
+    else if (ch === "<") aDepth++;
+    else if (ch === ">") aDepth = Math.max(0, aDepth - 1);
+    if (ch === ";" && pDepth === 0 && bDepth === 0 && sDepth === 0 && aDepth === 0) {
+      if (currentStmt.trim()) {
+        statements.push(currentStmt.trim());
+      }
+      currentStmt = "";
+    } else {
+      currentStmt += ch;
+    }
+  }
+  if (currentStmt.trim()) {
+    statements.push(currentStmt.trim());
+  }
+  for (let stmt of statements) {
+    stmt = stmt.replace(/\/\*[\s\S]*?\*\//g, "").trim();
+    stmt = stmt.replace(/^(?:public\s+|protected\s+|private\s+)?(?:abstract\s+)?(?:readonly\s+)?/, "").trim();
+    const firstParen = stmt.indexOf("(");
+    if (firstParen === -1) continue;
+    let methodName = "";
+    let typeParams;
+    const firstAngle = stmt.indexOf("<");
+    if (firstAngle !== -1 && firstAngle < firstParen) {
+      methodName = stmt.slice(0, firstAngle).trim().replace(/^(?:async\s+)/, "");
+      let angDepth = 0;
+      let angClose = -1;
+      for (let j = firstAngle; j < firstParen; j++) {
+        if (stmt[j] === "<") angDepth++;
+        else if (stmt[j] === ">") {
+          angDepth--;
+          if (angDepth === 0) {
+            angClose = j;
+            break;
+          }
+        }
+      }
+      if (angClose !== -1) {
+        typeParams = stmt.slice(firstAngle, angClose + 1).trim();
+      }
+    } else {
+      methodName = stmt.slice(0, firstParen).trim().replace(/^(?:async\s+)/, "");
+    }
+    if (!methodName || !/^[A-Za-z0-9_$]+$/.test(methodName)) {
+      continue;
+    }
+    let parenDepth = 0;
+    let parenClose = -1;
+    for (let j = firstParen; j < stmt.length; j++) {
+      if (stmt[j] === "(") parenDepth++;
+      else if (stmt[j] === ")") {
+        parenDepth--;
+        if (parenDepth === 0) {
+          parenClose = j;
+          break;
+        }
+      }
+    }
+    if (parenClose === -1) continue;
+    const rawParams = stmt.slice(firstParen + 1, parenClose).trim();
+    const params = rawParams.replace(/\s+/g, " ");
+    const afterParen = stmt.slice(parenClose + 1).trim();
+    let returnType = "void";
+    if (afterParen.startsWith(":")) {
+      returnType = afterParen.slice(1).trim().replace(/\s+/g, " ");
+    }
+    const isAsync = returnType.startsWith("Promise<") || returnType === "Promise";
+    methods.push({
+      name: methodName,
+      typeParams,
+      params,
+      returnType,
+      isAsync
+    });
+  }
+  return {
+    className,
+    methods,
+    imports,
+    extendsClass
+  };
+}
+function findInterfaceFile(projectRoot, ifaceName, featureName, customPath) {
+  if (customPath && fs3.existsSync(customPath)) {
+    return { filePath: customPath, ifaceName };
+  }
+  const candidateNames = [
+    ifaceName,
+    ensureInterfacePrefix(ifaceName),
+    removeInterfacePrefix(ifaceName)
+  ];
+  const features = featureName ? [featureName, ...listExistingFeatures(projectRoot).filter((f) => f !== featureName)] : listExistingFeatures(projectRoot);
+  for (const feat of features) {
+    const domainDir = path7.join(resolveFeaturesDir(projectRoot), feat, "domain");
+    if (!fs3.existsSync(domainDir)) continue;
+    for (const cand of candidateNames) {
+      const p1 = path7.join(domainDir, `${cand}.ts`);
+      if (fs3.existsSync(p1)) {
+        return { filePath: p1, ifaceName: cand, feature: feat };
+      }
+    }
+  }
+  for (const cand of candidateNames) {
+    const p1 = path7.join(projectRoot, "domain", `${cand}.ts`);
+    if (fs3.existsSync(p1)) return { filePath: p1, ifaceName: cand };
+    const p22 = path7.join(projectRoot, "src", "domain", `${cand}.ts`);
+    if (fs3.existsSync(p22)) return { filePath: p22, ifaceName: cand };
+    const p32 = path7.join(projectRoot, "interfaces", `${cand}.ts`);
+    if (fs3.existsSync(p32)) return { filePath: p32, ifaceName: cand };
+  }
+  return null;
+}
+function loadInterfaceHierarchy(projectRoot, initialIfaceName, featureName, customPath) {
+  const found = findInterfaceFile(projectRoot, initialIfaceName, featureName, customPath);
+  if (!found) {
+    return {
+      resolvedIfaceName: initialIfaceName,
+      methods: [],
+      imports: []
+    };
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const allMethods = [];
+  const allImports = [];
+  let currentFile = found.filePath;
+  let currentName = found.ifaceName;
+  const primaryResolvedName = found.ifaceName;
+  const primaryFilePath = found.filePath;
+  while (currentFile && !visited.has(currentFile)) {
+    visited.add(currentFile);
+    try {
+      const content = fs3.readFileSync(currentFile, "utf-8");
+      const parsed = parseInterfaceMethodsAndImports(content, currentName);
+      for (const m of parsed.methods) {
+        if (!allMethods.some((existing) => existing.name === m.name)) {
+          allMethods.push(m);
+        }
+      }
+      for (const imp of parsed.imports) {
+        allImports.push(imp);
+      }
+      if (parsed.extendsClass) {
+        const nextFound = findInterfaceFile(projectRoot, parsed.extendsClass, featureName);
+        if (nextFound) {
+          currentFile = nextFound.filePath;
+          currentName = nextFound.ifaceName;
+        } else {
+          currentFile = void 0;
+        }
+      } else {
+        currentFile = void 0;
+      }
+    } catch {
+      break;
+    }
+  }
+  return {
+    resolvedIfaceName: primaryResolvedName,
+    ifaceFilePath: primaryFilePath,
+    methods: allMethods,
+    imports: allImports
+  };
+}
+function synthesizeCrudMethods(entityName) {
+  const baseEntity = toPascalCase(entityName);
+  const entityVar = baseEntity.charAt(0).toLowerCase() + baseEntity.slice(1);
+  const entitiesVar = `${entityVar}s`;
+  const idKey = `${entityVar}Id`;
+  return [
+    {
+      name: `Get${baseEntity}ById`,
+      params: `input: { ${idKey}: string }`,
+      returnType: `Promise<{ ${entityVar}: ${baseEntity} }>`,
+      isAsync: true
+    },
+    {
+      name: `List${baseEntity}s`,
+      params: `input?: { page?: number | undefined; limit?: number | undefined }`,
+      returnType: `Promise<{ ${entitiesVar}: ${baseEntity}[]; total?: number | undefined; page?: number | undefined; limit?: number | undefined }>`,
+      isAsync: true
+    },
+    {
+      name: `Create${baseEntity}`,
+      params: `input: { ${entityVar}: ${baseEntity} }`,
+      returnType: `Promise<{ ${entityVar}: ${baseEntity} }>`,
+      isAsync: true
+    },
+    {
+      name: `Update${baseEntity}`,
+      params: `input: { ${entityVar}: ${baseEntity} }`,
+      returnType: `Promise<{ ${entityVar}: ${baseEntity} }>`,
+      isAsync: true
+    },
+    {
+      name: `Delete${baseEntity}`,
+      params: `input: { ${idKey}: string }`,
+      returnType: `Promise<{ success: boolean }>`,
+      isAsync: true
+    }
+  ];
+}
+function generateStubCode(stubClassName, ifaceName, entityName, featureName, methods = [], domainImports = [], ifaceImportPath) {
+  const baseEntity = entityName ? toPascalCase(entityName) : toPascalCase(removeInterfacePrefix(ifaceName).replace(/Repository$|Service$|Client$/, ""));
+  const entityVar = baseEntity ? baseEntity.charAt(0).toLowerCase() + baseEntity.slice(1) : "";
+  const entitiesVar = `${entityVar}s`;
+  const idKey = `${entityVar}Id`;
+  const impPath = ifaceImportPath || `../domain/${ifaceName}.js`;
+  const entityImportPath = ifaceImportPath ? `${path7.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
+  const importsByFrom = /* @__PURE__ */ new Map();
+  for (const imp of domainImports) {
+    if (imp.name === ifaceName || imp.name === baseEntity) continue;
+    if (!importsByFrom.has(imp.from)) {
+      importsByFrom.set(imp.from, { typeOnly: imp.isTypeOnly ?? true, names: /* @__PURE__ */ new Set() });
+    }
+    const group = importsByFrom.get(imp.from);
+    group.names.add(imp.name);
+    if (imp.isTypeOnly === false) {
+      group.typeOnly = false;
+    }
+  }
+  const formattedDomainImports = Array.from(importsByFrom.entries()).map(([from, group]) => ({
+    from,
+    names: Array.from(group.names).sort().join(", "),
+    isTypeOnly: group.typeOnly
+  }));
+  const standardNames = /* @__PURE__ */ new Set([
+    `Get${baseEntity}ById`,
+    `List${baseEntity}s`,
+    `Create${baseEntity}`,
+    `Update${baseEntity}`,
+    `Delete${baseEntity}`
+  ]);
+  const extraMethods = methods.filter((m) => !standardNames.has(m.name));
+  return renderTemplate(stubInfraTemplate, {
+    stubClassName,
+    ifaceName,
+    ifaceImportPath: impPath,
+    baseEntity: baseEntity || void 0,
+    entityImportPath,
+    domainImports: formattedDomainImports,
+    entitiesVar,
+    entityVar,
+    idKey,
+    extraMethods,
+    hasMethods: methods.length > 0,
+    methods
+  });
+}
+function generateConcreteInfraCode(className, ifaceName, dependencies = [], methods = [], domainImports = [], ifaceImportPath) {
+  let finalMethods = [...methods];
+  const finalDomainImports = [...domainImports];
+  if (finalMethods.length === 0 && ifaceName) {
+    const baseEntity = toPascalCase(removeInterfacePrefix(ifaceName).replace(/Repository$|Service$|Client$/, ""));
+    if (baseEntity) {
+      finalMethods = synthesizeCrudMethods(baseEntity);
+      if (!finalDomainImports.some((imp) => imp.name === baseEntity)) {
+        const importPath = ifaceImportPath ? `${path7.dirname(ifaceImportPath)}/${baseEntity}.js` : `../domain/${baseEntity}.js`;
+        finalDomainImports.push({
+          name: baseEntity,
+          from: importPath,
+          isTypeOnly: true
+        });
+      }
+    }
+  }
+  const impPath = ifaceName ? ifaceImportPath || `../domain/${ifaceName}.js` : "";
+  const importsByFrom = /* @__PURE__ */ new Map();
+  for (const imp of finalDomainImports) {
+    if (imp.name === ifaceName) continue;
+    if (!importsByFrom.has(imp.from)) {
+      importsByFrom.set(imp.from, { typeOnly: imp.isTypeOnly ?? true, names: /* @__PURE__ */ new Set() });
+    }
+    const group = importsByFrom.get(imp.from);
+    group.names.add(imp.name);
+    if (imp.isTypeOnly === false) {
+      group.typeOnly = false;
+    }
+  }
+  const formattedDomainImports = Array.from(importsByFrom.entries()).map(([from, group]) => ({
+    from,
+    names: Array.from(group.names).sort().join(", "),
+    isTypeOnly: group.typeOnly
+  }));
+  const formattedDeps = dependencies.map((dep) => ({
+    key: dep.charAt(0).toLowerCase() + dep.slice(1),
+    name: dep
+  }));
+  return renderTemplate(concreteInfraTemplate, {
+    className,
+    ifaceName,
+    ifaceImportPath: impPath,
+    domainImports: formattedDomainImports,
+    dependencies: formattedDeps,
+    hasMethods: finalMethods.length > 0,
+    methods: finalMethods
+  });
+}
+function generateInfrastructure(options) {
+  const projectRoot = options.projectRoot || findProjectRoot();
+  const className = toPascalCase(options.name);
+  const isFeatureScope = options.scope !== "global" && Boolean(options.feature);
+  const targetDir = options.targetDir || (isFeatureScope ? path7.join(resolveFeaturesDir(projectRoot), options.feature, "infrastructure") : path7.join(projectRoot, "infrastructure"));
+  const filePath = path7.join(targetDir, `${className}.ts`);
+  let code;
+  if (options.implementsInterface) {
+    const rawIfaceName = options.implementsInterface;
+    const hierarchy = loadInterfaceHierarchy(
+      projectRoot,
+      rawIfaceName,
+      options.feature,
+      options.interfacePath
+    );
+    const ifaceName = hierarchy.resolvedIfaceName;
+    const ifaceFilePath = hierarchy.ifaceFilePath;
+    let ifaceImportPath;
+    if (ifaceFilePath) {
+      let rel = path7.relative(targetDir, ifaceFilePath).replace(/\\/g, "/").replace(/\.ts$/, ".js");
+      if (!rel.startsWith(".")) rel = "./" + rel;
+      ifaceImportPath = rel;
+    } else if (isFeatureScope) {
+      ifaceImportPath = `../domain/${ifaceName}.js`;
+    }
+    const allSignatures = hierarchy.methods.map((m) => `${m.params} ${m.returnType}`).join(" ");
+    const domainImports = [];
+    for (const imp of hierarchy.imports) {
+      for (const item of imp.items) {
+        if (new RegExp(`\\b${item.name}\\b`).test(allSignatures)) {
+          let fromPath;
+          if (imp.specifier.startsWith(".") && ifaceFilePath) {
+            const absTarget = path7.resolve(path7.dirname(ifaceFilePath), imp.specifier);
+            let rel = path7.relative(targetDir, absTarget).replace(/\\/g, "/");
+            if (!rel.startsWith(".")) rel = "./" + rel;
+            fromPath = rel;
+          } else {
+            fromPath = imp.specifier;
+          }
+          domainImports.push({
+            name: item.name,
+            from: fromPath,
+            isTypeOnly: item.isTypeOnly ?? imp.isTypeOnly ?? true
+          });
+        }
+      }
+    }
+    if (options.kind === "stub") {
+      code = generateStubCode(
+        className,
+        ifaceName,
+        options.entityName,
+        options.feature,
+        hierarchy.methods,
+        domainImports,
+        ifaceImportPath
+      );
+    } else {
+      code = generateConcreteInfraCode(
+        className,
+        ifaceName,
+        options.dependencies || [],
+        hierarchy.methods,
+        domainImports,
+        ifaceImportPath
+      );
+    }
+  } else {
+    code = generateConcreteInfraCode(
+      className,
+      void 0,
+      options.dependencies || []
+    );
+  }
+  return writeFileSafely(filePath, code, {
+    projectRoot,
+    dryRun: options.dryRun,
+    overwrite: options.overwrite
+  });
+}
+var primitiveTypes = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "symbol",
+  "undefined",
+  "null",
+  "any",
+  "unknown",
+  "never",
+  "void",
+  "Date",
+  "Record<string, any>",
+  "Record<string, unknown>",
+  "Record<string, never>"
+]);
+function generateUseCaseCode(useCaseName, dependencies = [], inputProps = [], outputProps = [], domainImports = []) {
+  const ucName = toPascalCase(useCaseName);
+  const inputTypeName = `${ucName}Input`;
+  const outputTypeName = `${ucName}Output`;
+  const dependencyImports = dependencies.map((dep) => ({
+    name: dep,
+    from: /^I[A-Z]/.test(dep) ? `../domain/${dep}.js` : `./${dep}.js`
+  }));
+  const domainTypesToImport = new Set(domainImports);
+  for (const p15 of [...inputProps, ...outputProps]) {
+    const rawType = p15.type.trim();
+    const baseType = rawType.replace(/\[\]$/, "").trim();
+    if (!primitiveTypes.has(baseType) && /^[A-Z][A-Za-z0-9_]*$/.test(baseType) && !dependencies.includes(baseType)) {
+      domainTypesToImport.add(baseType);
+    }
+  }
+  const formattedInputProps = inputProps.map((p15) => ({
+    name: p15.name,
+    optional: p15.optional,
+    type: p15.optional && !p15.type.includes("undefined") ? `${p15.type} | undefined` : p15.type
+  }));
+  const formattedOutputProps = outputProps.map((p15) => ({
+    name: p15.name,
+    optional: p15.optional,
+    type: p15.optional && !p15.type.includes("undefined") ? `${p15.type} | undefined` : p15.type
+  }));
+  const formattedDeps = dependencies.map((dep) => ({
+    key: toCamelCase(dep),
+    name: dep
+  }));
+  const getMatch = ucName.match(/^Get([A-Z][A-Za-z0-9]*)$/);
+  const listMatch = ucName.match(/^List([A-Z][A-Za-z0-9]*)$/);
+  const createMatch = ucName.match(/^Create([A-Z][A-Za-z0-9]*)$/);
+  const updateMatch = ucName.match(/^Update([A-Z][A-Za-z0-9]*)$/);
+  const deleteMatch = ucName.match(/^Delete([A-Z][A-Za-z0-9]*)$/);
+  let callWired = null;
+  if (getMatch && getMatch[1]) {
+    const entity = getMatch[1];
+    const matchingRepo = dependencies.find((d) => d === `I${entity}Repository`);
+    if (matchingRepo && inputProps.length === 1 && outputProps.length === 1) {
+      const repoKey = toCamelCase(matchingRepo);
+      const idKey = inputProps[0].name;
+      callWired = `    return await this.deps.${repoKey}.Get${entity}ById({
+      ${idKey}: props.${idKey},
+    });`;
+    }
+  } else if (listMatch && listMatch[1]) {
+    const pluralEntity = listMatch[1];
+    const singularEntity = toSingular(pluralEntity);
+    const matchingRepo = dependencies.find(
+      (d) => d === `I${singularEntity}Repository` || d === `I${pluralEntity}Repository`
+    );
+    if (matchingRepo) {
+      const repoKey = toCamelCase(matchingRepo);
+      const passProps = inputProps.length > 0 ? "props" : "";
+      callWired = `    return await this.deps.${repoKey}.List${pluralEntity}(${passProps});`;
+    }
+  } else if (createMatch && createMatch[1]) {
+    const entity = createMatch[1];
+    const matchingRepo = dependencies.find((d) => d === `I${entity}Repository`);
+    if (matchingRepo && inputProps.length === 1 && outputProps.length === 1) {
+      const repoKey = toCamelCase(matchingRepo);
+      const entityKey = inputProps[0].name;
+      callWired = `    return await this.deps.${repoKey}.Create${entity}({
+      ${entityKey}: props.${entityKey},
+    });`;
+    }
+  } else if (updateMatch && updateMatch[1]) {
+    const entity = updateMatch[1];
+    const matchingRepo = dependencies.find((d) => d === `I${entity}Repository`);
+    if (matchingRepo && inputProps.length === 1 && outputProps.length === 1) {
+      const repoKey = toCamelCase(matchingRepo);
+      const entityKey = inputProps[0].name;
+      callWired = `    return await this.deps.${repoKey}.Update${entity}({
+      ${entityKey}: props.${entityKey},
+    });`;
+    }
+  } else if (deleteMatch && deleteMatch[1]) {
+    const entity = deleteMatch[1];
+    const matchingRepo = dependencies.find((d) => d === `I${entity}Repository`);
+    if (matchingRepo && inputProps.length === 1) {
+      const repoKey = toCamelCase(matchingRepo);
+      const idKey = inputProps[0].name;
+      callWired = `    return await this.deps.${repoKey}.Delete${entity}({
+      ${idKey}: props.${idKey},
+    });`;
+    }
+  }
+  const paramStr = inputProps.length > 0 ? `props: ${inputTypeName}` : `_props?: ${inputTypeName}`;
+  return renderTemplate(useCaseTemplate, {
+    ucName,
+    inputTypeName,
+    outputTypeName,
+    dependencyImports,
+    domainImports: Array.from(domainTypesToImport),
+    hasInputProps: inputProps.length > 0,
+    inputProperties: formattedInputProps,
+    hasOutputProps: outputProps.length > 0,
+    outputProperties: formattedOutputProps,
+    dependencies: formattedDeps,
+    hasDependencies: dependencies.length > 0,
+    paramStr,
+    callWired
+  });
+}
+function generateUseCaseTestCode(useCaseName, dependencies = []) {
+  const ucName = toPascalCase(useCaseName);
+  const stubBindings = [];
+  for (const dep of dependencies) {
+    if (/^I[A-Z]/.test(dep)) {
+      const stub = toStubName(dep);
+      stubBindings.push({ iface: dep, stub });
+    }
+  }
+  return renderTemplate(useCaseTestTemplate, {
+    ucName,
+    stubBindings
+  });
+}
+function generateUseCase(options) {
+  const files = [];
+  const projectRoot = options.projectRoot || findProjectRoot();
+  const ucName = toPascalCase(options.name);
+  const targetDir = options.targetDir || path7.join(resolveFeaturesDir(projectRoot), options.feature, "useCases");
+  const filePath = path7.join(targetDir, `${ucName}.ts`);
+  const code = generateUseCaseCode(
+    ucName,
+    options.dependencies || [],
+    options.inputProperties || [],
+    options.outputProperties || [],
+    options.domainImports || []
+  );
+  files.push(
+    writeFileSafely(filePath, code, {
+      projectRoot,
+      dryRun: options.dryRun,
+      overwrite: options.overwrite
+    })
+  );
+  if (options.includeTest) {
+    const testPath = path7.join(targetDir, `${ucName}.test.ts`);
+    const testCode = generateUseCaseTestCode(ucName, options.dependencies || []);
+    files.push(
+      writeFileSafely(testPath, testCode, {
+        projectRoot,
+        dryRun: options.dryRun,
+        overwrite: options.overwrite
+      })
+    );
+  }
+  return files;
+}
+function deriveSuccessMessage(handlerName, useCaseName, method = "get") {
+  const baseName = useCaseName ? toPascalCase(useCaseName) : toPascalCase(handlerName).replace(/Http$/, "");
+  const createMatch = baseName.match(/^Create([A-Z].*)$/);
+  if (createMatch) return `${createMatch[1]} created successfully`;
+  const getMatch = baseName.match(/^(?:Get|Find)([A-Z].*)$/);
+  if (getMatch) return `${getMatch[1]} retrieved successfully`;
+  const listMatch = baseName.match(/^List([A-Z].*)$/);
+  if (listMatch) return `${listMatch[1]} retrieved successfully`;
+  const updateMatch = baseName.match(/^(?:Update|Modify|Patch)([A-Z].*)$/);
+  if (updateMatch) return `${updateMatch[1]} updated successfully`;
+  const deleteMatch = baseName.match(/^(?:Delete|Remove)([A-Z].*)$/);
+  if (deleteMatch) return `${deleteMatch[1]} deleted successfully`;
+  if (method === "post") return `${baseName} created successfully`;
+  if (method === "delete") return `${baseName} deleted successfully`;
+  return `${baseName} executed successfully`;
+}
+function generateHttpHandlerCode(handlerName, method = "get", routeSubPath = "/", useCaseName, includeValidation = false, validationSource = "body", validationFields = [], customSuccessMessage) {
+  const className = toPascalCase(handlerName);
+  const ucName = useCaseName ? toPascalCase(useCaseName) : void 0;
+  const ucDepKey = ucName ? toCamelCase(ucName) : void 0;
+  const schemaName = `${toCamelCase(className)}Schema`;
+  const formattedFields = validationFields.map((f) => {
+    let zodType = "z.string()";
+    if (f.type === "number") zodType = validationSource === "query" ? "z.coerce.number()" : "z.number()";
+    else if (f.type === "boolean") zodType = validationSource === "query" ? "z.coerce.boolean()" : "z.boolean()";
+    else if (f.type === "Date") zodType = "z.coerce.date()";
+    else if (f.type === "any") zodType = "z.any()";
+    else if (f.type === "unknown") zodType = "z.unknown()";
+    else if (f.type.endsWith("[]")) zodType = "z.array(z.any())";
+    else if (/^[A-Z]/.test(f.type)) zodType = "z.record(z.any()) as any";
+    if (f.optional) zodType += ".optional()";
+    return { name: f.name, zodType };
+  });
+  const callArg = includeValidation ? "parsed.data" : "{}";
+  const statusCode = method === "post" ? 201 : 200;
+  const successMessage = customSuccessMessage || deriveSuccessMessage(className, ucName, method);
+  return renderTemplate(httpHandlerTemplate, {
+    className,
+    ucName,
+    ucDepKey,
+    includeValidation,
+    schemaName,
+    hasValidationFields: formattedFields.length > 0,
+    validationFields: formattedFields,
+    method,
+    routeSubPath,
+    validationSource,
+    callArg,
+    statusCode,
+    successMessage
+  });
+}
+function generateHttpHandler(options) {
+  const files = [];
+  const projectRoot = options.projectRoot || findProjectRoot();
+  const className = toPascalCase(options.name);
+  const pxDir = path7.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress");
+  const handlersDir = path7.join(pxDir, "handlers");
+  const pxIndexPath = path7.join(pxDir, "index.ts");
+  if (!fs3.existsSync(pxIndexPath)) {
+    const featurePath = options.routePrefix || `/${options.feature.toLowerCase()}`;
+    const pxIndexContent = renderTemplate(expressIndexTemplate, {
+      routePath: featurePath
+    });
+    files.push(
+      writeFileSafely(pxIndexPath, pxIndexContent, {
+        projectRoot,
+        dryRun: options.dryRun,
+        overwrite: false
+      })
+    );
+  }
+  const handlerFilePath = path7.join(handlersDir, `${className}.ts`);
+  const code = generateHttpHandlerCode(
+    className,
+    options.method || "get",
+    options.path || "/",
+    options.useCaseName,
+    Boolean(options.includeValidation),
+    options.validationSource || "body",
+    options.validationFields || [],
+    options.successMessage
+  );
+  files.push(
+    writeFileSafely(handlerFilePath, code, {
+      projectRoot,
+      dryRun: options.dryRun,
+      overwrite: options.overwrite
+    })
+  );
+  return files;
+}
+function updateOrGenerateDiProvider(featureDir, featureName, bindings = [], options = {}) {
+  const providerPath = path7.join(featureDir, "diProvider.ts");
+  const pascalFeature = toPascalCase(featureName);
+  const providerModuleName = `${pascalFeature}Provider`;
+  if (fs3.existsSync(providerPath) && !options.overwrite) {
+    let content = fs3.readFileSync(providerPath, "utf-8");
+    content = content.replace(/\n*export\s+const\s+ScaffoldProvider\s*=[^;]+;?/g, "");
+    for (const b of bindings) {
+      const ifaceImp = b.ifaceImportPath || `./domain/${b.ifaceName}.js`;
+      const implImp = b.implImportPath || `./infrastructure/${b.implName}.js`;
+      if (!content.includes(b.ifaceName)) {
+        content = `import { ${b.ifaceName} } from "${ifaceImp}";
+` + content;
+      }
+      if (!content.includes(b.implName)) {
+        content = `import { ${b.implName} } from "${implImp}";
+` + content;
+      }
+      const provideCall = `c.provide(${b.ifaceName}, ${b.implName});`;
+      if (!content.includes(b.ifaceName) || !content.includes(b.implName) || !content.includes(`c.provide(${b.ifaceName}`)) {
+        const match = content.match(/(const\s+\w+Provider\s*:\s*DIModule\s*=\s*\((?:c|container)[^)]*\)\s*=>\s*\{)([\s\S]*?)(\}\;?)/);
+        if (match) {
+          const prefix = match[1];
+          const body = match[2];
+          const suffix = match[3];
+          const updatedBody = `${body}
+  ${provideCall}
+`;
+          content = content.replace(match[0], `${prefix}${updatedBody}${suffix}`);
+        } else {
+          content = content.replace(
+            /export default/g,
+            `// Register ${b.ifaceName}
+// c.provide(${b.ifaceName}, ${b.implName});
+
+export default`
+          );
+        }
+      }
+    }
+    return writeFileSafely(providerPath, content, {
+      ...options,
+      overwrite: true
+    });
+  }
+  const formattedBindings = bindings.map((b) => ({
+    ifaceName: b.ifaceName,
+    implName: b.implName,
+    ifaceImportPath: b.ifaceImportPath || `./domain/${b.ifaceName}.js`,
+    implImportPath: b.implImportPath || `./infrastructure/${b.implName}.js`
+  }));
+  const code = renderTemplate(diProviderTemplate, {
+    providerModuleName,
+    bindings: formattedBindings
+  });
+  return writeFileSafely(providerPath, code, options);
+}
+
+// src/core/featureGenerator.ts
+function generateFeature(options) {
+  const files = [];
+  const projectRoot = options.projectRoot || findProjectRoot();
+  const rawName = options.name.trim();
+  const featureName = toCamelCase(rawName);
+  const targetDir = options.targetDir || path7.join(resolveFeaturesDir(projectRoot), featureName);
+  const routePath = options.routePath || `/${featureName}`;
+  const rawEntities = [];
+  if (options.entityNames && options.entityNames.length > 0) {
+    rawEntities.push(...options.entityNames);
+  } else if (options.entityName) {
+    rawEntities.push(options.entityName);
+  } else {
+    rawEntities.push(toSingular(rawName));
+  }
+  const entities = Array.from(
+    new Set(rawEntities.map((e) => toPascalCase(e.trim())).filter(Boolean))
+  );
+  if (entities.length === 0) {
+    entities.push(toPascalCase(toSingular(rawName)));
+  }
+  if (options.includeDomain !== false) {
+    for (const ent of entities) {
+      const domainFile = generateDomain({
+        name: ent,
+        feature: featureName,
+        targetDir: path7.join(targetDir, "domain"),
+        projectRoot,
+        dryRun: options.dryRun,
+        overwrite: options.overwrite,
+        kind: "interface",
+        properties: [
+          { name: "id", type: "string" },
+          { name: "createdAt", type: "Date" },
+          { name: "updatedAt", type: "Date" }
+        ]
+      });
+      files.push(domainFile);
+    }
+  }
+  if (options.includeInterface !== false) {
+    for (const ent of entities) {
+      const ifaceName = options.interfaceName && entities.length === 1 ? toPascalCase(options.interfaceName) : `I${ent}Repository`;
+      const ifaceFile = generateInterface({
+        name: ifaceName,
+        feature: featureName,
+        targetDir: path7.join(targetDir, "domain"),
+        entityName: ent,
+        projectRoot,
+        dryRun: options.dryRun,
+        overwrite: options.overwrite,
+        methodsPreset: "crud"
+      });
+      files.push(ifaceFile);
+    }
+  }
+  if (options.includeInfra !== false && options.includeInterface !== false) {
+    for (const ent of entities) {
+      const ifaceName = options.interfaceName && entities.length === 1 ? toPascalCase(options.interfaceName) : `I${ent}Repository`;
+      const stubName = options.stubName && entities.length === 1 ? toPascalCase(options.stubName) : `Stub${ent}Repository`;
+      const stubFile = generateInfrastructure({
+        name: stubName,
+        feature: featureName,
+        targetDir: path7.join(targetDir, "infrastructure"),
+        kind: "stub",
+        implementsInterface: ifaceName,
+        entityName: ent,
+        projectRoot,
+        dryRun: options.dryRun,
+        overwrite: options.overwrite
+      });
+      files.push(stubFile);
+    }
+  }
+  if (options.includeDiProvider !== false && options.includeInterface !== false && options.includeInfra !== false) {
+    const bindings = entities.map((ent) => {
+      const ifaceName = options.interfaceName && entities.length === 1 ? toPascalCase(options.interfaceName) : `I${ent}Repository`;
+      const stubName = options.stubName && entities.length === 1 ? toPascalCase(options.stubName) : `Stub${ent}Repository`;
+      return { ifaceName, implName: stubName };
+    });
+    const providerFile = updateOrGenerateDiProvider(targetDir, featureName, bindings, {
+      projectRoot,
+      dryRun: options.dryRun,
+      overwrite: options.overwrite
+    });
+    files.push(providerFile);
+  }
+  if (options.includeUseCase !== false) {
+    let ops = [];
+    if (options.crudOperations) {
+      ops = options.crudOperations;
+    } else if (options.useCaseName) {
+      ops = [];
+    } else {
+      ops = ["create", "read", "list", "update", "delete"];
+    }
+    if (options.useCaseName && ops.length === 0) {
+      const primaryEntity = entities[0];
+      const entVar = primaryEntity.charAt(0).toLowerCase() + primaryEntity.slice(1);
+      const idParam = `${entVar}Id`;
+      const ifaceName = options.interfaceName && entities.length === 1 ? toPascalCase(options.interfaceName) : `I${primaryEntity}Repository`;
+      const ucName = toPascalCase(options.useCaseName);
+      const ucFiles = generateUseCase({
+        name: ucName,
+        feature: featureName,
+        targetDir: path7.join(targetDir, "useCases"),
+        dependencies: options.includeInterface !== false ? [ifaceName] : [],
+        inputProperties: [{ name: idParam, type: "string" }],
+        outputProperties: [{ name: entVar, type: primaryEntity }],
+        domainImports: options.includeDomain !== false ? [primaryEntity] : [],
+        includeTest: options.includeTests !== false,
+        projectRoot,
+        dryRun: options.dryRun,
+        overwrite: options.overwrite
+      });
+      files.push(...ucFiles);
+      if (options.includeExpress !== false) {
+        const httpName = options.httpHandlerName ? toPascalCase(options.httpHandlerName) : `${ucName}Http`;
+        const httpFiles = generateHttpHandler({
+          name: httpName,
+          feature: featureName,
+          routePrefix: routePath,
+          method: "get",
+          path: `/:${idParam}`,
+          useCaseName: ucName,
+          includeValidation: true,
+          validationSource: "params",
+          validationFields: [{ name: idParam, type: "string" }],
+          projectRoot,
+          dryRun: options.dryRun,
+          overwrite: options.overwrite
+        });
+        files.push(...httpFiles);
+      }
+    }
+    for (let i = 0; i < entities.length; i++) {
+      const ent = entities[i];
+      const entVar = ent.charAt(0).toLowerCase() + ent.slice(1);
+      const idParam = `${entVar}Id`;
+      const listVar = toPlural(entVar);
+      const pluralEntity = toPlural(ent);
+      const ifaceName = options.interfaceName && entities.length === 1 ? toPascalCase(options.interfaceName) : `I${ent}Repository`;
+      const deps = options.includeInterface !== false ? [ifaceName] : [];
+      const entitySubRoute = i === 0 ? "" : `/${toKebabCase(listVar)}`;
+      for (const op of ops) {
+        if (op === "create") {
+          const ucName = `Create${ent}`;
+          const ucFiles = generateUseCase({
+            name: ucName,
+            feature: featureName,
+            targetDir: path7.join(targetDir, "useCases"),
+            dependencies: deps,
+            inputProperties: [{ name: entVar, type: ent }],
+            outputProperties: [{ name: entVar, type: ent }],
+            domainImports: options.includeDomain !== false ? [ent] : [],
+            includeTest: options.includeTests !== false,
+            projectRoot,
+            dryRun: options.dryRun,
+            overwrite: options.overwrite
+          });
+          files.push(...ucFiles);
+          if (options.includeExpress !== false) {
+            const httpFiles = generateHttpHandler({
+              name: `${ucName}Http`,
+              feature: featureName,
+              routePrefix: routePath,
+              method: "post",
+              path: entitySubRoute || "/",
+              useCaseName: ucName,
+              includeValidation: true,
+              validationSource: "body",
+              validationFields: [{ name: entVar, type: "any" }],
+              projectRoot,
+              dryRun: options.dryRun,
+              overwrite: options.overwrite
+            });
+            files.push(...httpFiles);
+          }
+        } else if (op === "read") {
+          const ucName = `Get${ent}`;
+          const ucFiles = generateUseCase({
+            name: ucName,
+            feature: featureName,
+            targetDir: path7.join(targetDir, "useCases"),
+            dependencies: deps,
+            inputProperties: [{ name: idParam, type: "string" }],
+            outputProperties: [{ name: entVar, type: ent }],
+            domainImports: options.includeDomain !== false ? [ent] : [],
+            includeTest: options.includeTests !== false,
+            projectRoot,
+            dryRun: options.dryRun,
+            overwrite: options.overwrite
+          });
+          files.push(...ucFiles);
+          if (options.includeExpress !== false) {
+            const httpFiles = generateHttpHandler({
+              name: `${ucName}Http`,
+              feature: featureName,
+              routePrefix: routePath,
+              method: "get",
+              path: entitySubRoute ? `${entitySubRoute}/:${idParam}` : `/:${idParam}`,
+              useCaseName: ucName,
+              includeValidation: true,
+              validationSource: "params",
+              validationFields: [{ name: idParam, type: "string" }],
+              projectRoot,
+              dryRun: options.dryRun,
+              overwrite: options.overwrite
+            });
+            files.push(...httpFiles);
+          }
+        } else if (op === "list") {
+          const ucName = `List${pluralEntity}`;
+          const ucFiles = generateUseCase({
+            name: ucName,
+            feature: featureName,
+            targetDir: path7.join(targetDir, "useCases"),
+            dependencies: deps,
+            inputProperties: [
+              { name: "page", type: "number", optional: true },
+              { name: "limit", type: "number", optional: true }
+            ],
+            outputProperties: [
+              { name: listVar, type: `${ent}[]` },
+              { name: "total", type: "number", optional: true },
+              { name: "page", type: "number", optional: true },
+              { name: "limit", type: "number", optional: true }
+            ],
+            domainImports: options.includeDomain !== false ? [ent] : [],
+            includeTest: options.includeTests !== false,
+            projectRoot,
+            dryRun: options.dryRun,
+            overwrite: options.overwrite
+          });
+          files.push(...ucFiles);
+          if (options.includeExpress !== false) {
+            const httpFiles = generateHttpHandler({
+              name: `${ucName}Http`,
+              feature: featureName,
+              routePrefix: routePath,
+              method: "get",
+              path: entitySubRoute || "/",
+              useCaseName: ucName,
+              includeValidation: true,
+              validationSource: "query",
+              validationFields: [
+                { name: "page", type: "number", optional: true },
+                { name: "limit", type: "number", optional: true }
+              ],
+              projectRoot,
+              dryRun: options.dryRun,
+              overwrite: options.overwrite
+            });
+            files.push(...httpFiles);
+          }
+        } else if (op === "update") {
+          const ucName = `Update${ent}`;
+          const ucFiles = generateUseCase({
+            name: ucName,
+            feature: featureName,
+            targetDir: path7.join(targetDir, "useCases"),
+            dependencies: deps,
+            inputProperties: [{ name: entVar, type: ent }],
+            outputProperties: [{ name: entVar, type: ent }],
+            domainImports: options.includeDomain !== false ? [ent] : [],
+            includeTest: options.includeTests !== false,
+            projectRoot,
+            dryRun: options.dryRun,
+            overwrite: options.overwrite
+          });
+          files.push(...ucFiles);
+          if (options.includeExpress !== false) {
+            const httpFiles = generateHttpHandler({
+              name: `${ucName}Http`,
+              feature: featureName,
+              routePrefix: routePath,
+              method: "put",
+              path: entitySubRoute ? `${entitySubRoute}/:${idParam}` : `/:${idParam}`,
+              useCaseName: ucName,
+              includeValidation: true,
+              validationSource: "body",
+              validationFields: [{ name: entVar, type: "any" }],
+              projectRoot,
+              dryRun: options.dryRun,
+              overwrite: options.overwrite
+            });
+            files.push(...httpFiles);
+          }
+        } else if (op === "delete") {
+          const ucName = `Delete${ent}`;
+          const ucFiles = generateUseCase({
+            name: ucName,
+            feature: featureName,
+            targetDir: path7.join(targetDir, "useCases"),
+            dependencies: deps,
+            inputProperties: [{ name: idParam, type: "string" }],
+            outputProperties: [{ name: "success", type: "boolean" }],
+            includeTest: options.includeTests !== false,
+            projectRoot,
+            dryRun: options.dryRun,
+            overwrite: options.overwrite
+          });
+          files.push(...ucFiles);
+          if (options.includeExpress !== false) {
+            const httpFiles = generateHttpHandler({
+              name: `${ucName}Http`,
+              feature: featureName,
+              routePrefix: routePath,
+              method: "delete",
+              path: entitySubRoute ? `${entitySubRoute}/:${idParam}` : `/:${idParam}`,
+              useCaseName: ucName,
+              includeValidation: true,
+              validationSource: "params",
+              validationFields: [{ name: idParam, type: "string" }],
+              projectRoot,
+              dryRun: options.dryRun,
+              overwrite: options.overwrite
+            });
+            files.push(...httpFiles);
+          }
+        }
+      }
+    }
+  }
+  if (options.customUseCases && options.customUseCases.length > 0) {
+    for (const customUc of options.customUseCases) {
+      const ucName = toPascalCase(customUc.name);
+      const ucFiles = generateUseCase({
+        name: ucName,
+        feature: featureName,
+        targetDir: path7.join(targetDir, "useCases"),
+        dependencies: customUc.dependencies || [],
+        inputProperties: customUc.inputProperties || [],
+        outputProperties: customUc.outputProperties || [],
+        domainImports: customUc.domainImports || [],
+        includeTest: customUc.includeTest !== false && options.includeTests !== false,
+        projectRoot,
+        dryRun: options.dryRun,
+        overwrite: options.overwrite
+      });
+      files.push(...ucFiles);
+      if (options.includeExpress !== false && customUc.createHttpHandler) {
+        const handlerName = `${ucName}Http`;
+        const httpFiles = generateHttpHandler({
+          name: handlerName,
+          feature: featureName,
+          routePrefix: routePath,
+          method: customUc.httpMethod || "post",
+          path: customUc.httpPath || `/${toKebabCase(ucName)}`,
+          useCaseName: ucName,
+          includeValidation: customUc.inputProperties && customUc.inputProperties.length > 0 || false,
+          validationSource: customUc.validationSource || (customUc.httpMethod === "get" ? "query" : "body"),
+          validationFields: customUc.validationFields || customUc.inputProperties || [],
+          projectRoot,
+          dryRun: options.dryRun,
+          overwrite: options.overwrite
+        });
+        files.push(...httpFiles);
+      }
+    }
+  }
+  if (options.includeExpress !== false) {
+    const pxDir = path7.join(targetDir, "pxExpress");
+    const pxIndexPath = path7.join(pxDir, "index.ts");
+    if (!files.some((f) => f.absolutePath === pxIndexPath)) {
+      const pxIndexContent = renderTemplate(expressIndexTemplate, { routePath });
+      files.push(
+        writeFileSafely(pxIndexPath, pxIndexContent, {
+          projectRoot,
+          dryRun: options.dryRun,
+          overwrite: false
+        })
+      );
+    }
+  }
+  const uniqueFiles = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    if (!seen.has(f.absolutePath)) {
+      seen.add(f.absolutePath);
+      uniqueFiles.push(f);
+    }
+  }
+  return uniqueFiles;
+}
+
+// src/commands/feature.ts
+async function runFeatureCommand(featureNameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  let name = featureNameArg?.trim();
+  if (!name && flags.yes) {
+    name = "feature";
+  }
+  if (!name) {
+    name = handleCancel(
+      await p4.text({
+        message: "What is the feature name?",
+        placeholder: "e.g. users, auth, orders, billing",
+        validate: (val) => {
+          if (!val || !val.trim()) return "Feature name cannot be empty.";
+          return void 0;
+        }
+      })
+    ).trim();
+  }
+  const normalizedName = toCamelCase(name);
+  const defaultDir = path7.relative(projectRoot, path7.join(resolveFeaturesDir(projectRoot), normalizedName));
+  let targetDirRel = defaultDir;
+  if (!flags.yes && !flags.target) {
+    targetDirRel = handleCancel(
+      await p4.text({
+        message: "Target directory for the feature:",
+        initialValue: defaultDir,
+        defaultValue: defaultDir
+      })
+    ).trim();
+  }
+  const targetDir = flags.target ? path7.resolve(projectRoot, flags.target) : path7.resolve(projectRoot, targetDirRel);
+  let includeExpress = flags.express !== void 0 ? Boolean(flags.express) : true;
+  let routePath = `/${normalizedName}`;
+  let includeDomain = true;
+  let includeInterface = true;
+  let includeInfra = true;
+  let includeUseCase = true;
+  let includeTests = true;
+  let includeDiProvider = true;
+  const defaultEntity = toPascalCase(toSingular(normalizedName));
+  let entityNames = [defaultEntity];
+  let crudOperations = ["create", "read", "list", "update", "delete"];
+  const customUseCases = [];
+  if (!flags.yes) {
+    includeExpress = handleCancel(
+      await p4.confirm({
+        message: "Include Express Presentation layer (pxExpress routes & handlers)?",
+        initialValue: true
+      })
+    );
+    if (includeExpress) {
+      routePath = handleCancel(
+        await p4.text({
+          message: "Express route prefix:",
+          initialValue: `/${normalizedName}`,
+          defaultValue: `/${normalizedName}`
+        })
+      ).trim();
+    }
+    includeDomain = handleCancel(
+      await p4.confirm({
+        message: "Include Domain Entity/Entities?",
+        initialValue: true
+      })
+    );
+    if (includeDomain) {
+      const domainInput = handleCancel(
+        await p4.text({
+          message: "Domain entity name(s) (comma-separated):",
+          initialValue: defaultEntity,
+          defaultValue: defaultEntity,
+          placeholder: `e.g. ${defaultEntity}, ${defaultEntity}Item`,
+          validate: (val) => {
+            if (!val || !val.trim()) return "Please enter at least one domain entity name.";
+            return void 0;
+          }
+        })
+      ).trim();
+      entityNames = domainInput.split(",").map((s2) => toPascalCase(s2.trim())).filter(Boolean);
+      if (entityNames.length === 0) {
+        entityNames = [defaultEntity];
+      }
+    } else {
+      entityNames = [defaultEntity];
+    }
+    includeInterface = handleCancel(
+      await p4.confirm({
+        message: `Include Domain Repository interface(s) for ${entityNames.join(", ")}?`,
+        initialValue: true
+      })
+    );
+    if (includeInterface) {
+      includeInfra = handleCancel(
+        await p4.confirm({
+          message: `Include Infrastructure Stub implementation(s) for ${entityNames.join(", ")}?`,
+          initialValue: true
+        })
+      );
+    }
+    includeUseCase = handleCancel(
+      await p4.confirm({
+        message: "Include Domain Use Cases?",
+        initialValue: true
+      })
+    );
+    if (includeUseCase) {
+      const crudChoices = [
+        { value: "create", label: "Create (Create<Entity>)", hint: "POST" },
+        { value: "read", label: "Read One (Get<Entity>)", hint: "GET /:id" },
+        { value: "list", label: "List with Pagination (List<Entity>s)", hint: "GET / (query: page, limit)" },
+        { value: "update", label: "Update (Update<Entity>)", hint: "PUT /:id" },
+        { value: "delete", label: "Delete (Delete<Entity>)", hint: "DELETE /:id" }
+      ];
+      crudOperations = handleCancel(
+        await p4.multiselect({
+          message: "Select standard CRUD use cases to generate:",
+          options: crudChoices,
+          initialValues: ["create", "read", "list", "update", "delete"],
+          required: false
+        })
+      );
+      includeTests = handleCancel(
+        await p4.confirm({
+          message: "Generate Vitest unit tests for use cases?",
+          initialValue: true
+        })
+      );
+      const wantCustom = handleCancel(
+        await p4.confirm({
+          message: "Do you want to add any custom use cases to this feature?",
+          initialValue: false
+        })
+      );
+      if (wantCustom) {
+        let addMore = true;
+        const availableIfaces = entityNames.map((e) => `I${e}Repository`);
+        while (addMore) {
+          const customName = handleCancel(
+            await p4.text({
+              message: "Custom Use Case name:",
+              placeholder: "e.g. ResetPassword, VerifyEmail, AssignRole",
+              validate: (v) => v && v.trim() ? void 0 : "Use Case name cannot be empty"
+            })
+          ).trim();
+          const customUcName = toPascalCase(customName);
+          let selectedDeps = [];
+          if (availableIfaces.length > 0) {
+            selectedDeps = handleCancel(
+              await p4.multiselect({
+                message: `Select domain interfaces to inject into ${customUcName}:`,
+                options: availableIfaces.map((i) => ({ value: i, label: i })),
+                required: false
+              })
+            );
+          }
+          let customInputProps = [];
+          const hasInput = handleCancel(
+            await p4.confirm({
+              message: `Does ${customUcName} accept input arguments?`,
+              initialValue: true
+            })
+          );
+          if (hasInput) {
+            customInputProps = await promptProperties({
+              });
+          }
+          let customOutputProps = [];
+          const hasCustomOutput = handleCancel(
+            await p4.confirm({
+              message: `Does ${customUcName} return custom output data?`,
+              initialValue: false
+            })
+          );
+          if (hasCustomOutput) {
+            customOutputProps = await promptProperties({
+              });
+          }
+          const customIncludeTest = handleCancel(
+            await p4.confirm({
+              message: `Generate Vitest unit test for ${customUcName}?`,
+              initialValue: true
+            })
+          );
+          let customCreateHttp = false;
+          let customHttpMethod = "post";
+          let customHttpPath = `/${toKebabCase(customUcName)}`;
+          if (includeExpress) {
+            customCreateHttp = handleCancel(
+              await p4.confirm({
+                message: `Generate a matching ExpressRoute HTTP handler for ${customUcName}?`,
+                initialValue: true
+              })
+            );
+            if (customCreateHttp) {
+              customHttpMethod = handleCancel(
+                await p4.select({
+                  message: "HTTP method for route:",
+                  options: [
+                    { value: "post", label: "POST" },
+                    { value: "get", label: "GET" },
+                    { value: "put", label: "PUT" },
+                    { value: "patch", label: "PATCH" },
+                    { value: "delete", label: "DELETE" }
+                  ],
+                  initialValue: "post"
+                })
+              );
+              customHttpPath = handleCancel(
+                await p4.text({
+                  message: "Route subpath (relative to feature prefix):",
+                  initialValue: `/${toKebabCase(customUcName)}`,
+                  defaultValue: `/${toKebabCase(customUcName)}`
+                })
+              ).trim();
+            }
+          }
+          customUseCases.push({
+            name: customUcName,
+            dependencies: selectedDeps,
+            inputProperties: customInputProps,
+            outputProperties: customOutputProps,
+            includeTest: customIncludeTest,
+            createHttpHandler: customCreateHttp,
+            httpMethod: customHttpMethod,
+            httpPath: customHttpPath,
+            validationSource: customHttpMethod === "get" ? "query" : "body",
+            validationFields: customInputProps
+          });
+          addMore = handleCancel(
+            await p4.confirm({
+              message: "Add another custom use case?",
+              initialValue: false
+            })
+          );
+        }
+      }
+    }
+    includeDiProvider = handleCancel(
+      await p4.confirm({
+        message: "Generate / update feature DI provider (diProvider.ts)?",
+        initialValue: true
+      })
+    );
+  } else {
+    if (flags.domainNames) {
+      entityNames = String(flags.domainNames).split(",").map((s2) => toPascalCase(s2.trim())).filter(Boolean);
+    } else {
+      entityNames = [defaultEntity];
+    }
+  }
+  const s = p4.spinner();
+  s.start(`Generating feature '${pc13.cyan(normalizedName)}'...`);
+  const options = {
+    name: normalizedName,
+    projectRoot,
+    targetDir,
+    dryRun: Boolean(flags.dryRun),
+    overwrite: Boolean(flags.overwrite),
+    includeExpress,
+    routePath,
+    includeDomain,
+    entityNames,
+    includeInterface,
+    includeInfra,
+    includeUseCase,
+    crudOperations,
+    customUseCases,
+    includeTests,
+    includeDiProvider
+  };
+  const files = generateFeature(options);
+  s.stop("Feature scaffolded successfully!");
+  printGeneratedFiles(files, options.dryRun);
+  p4.outro(pc13.green(`Feature '${normalizedName}' ready to use!`));
+}
+async function runUseCaseCommand(useCaseNameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  const existingFeatures = listExistingFeatures(projectRoot);
+  let feature = flags.feature?.trim();
+  if (!feature) {
+    if (existingFeatures.length > 0) {
+      const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
+      featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
+      const selected = handleCancel(
+        await p4.select({
+          message: "Select target feature:",
+          options: featureOptions
+        })
+      );
+      if (selected === "__custom__") {
+        feature = handleCancel(
+          await p4.text({
+            message: "Enter feature name:",
+            validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+          })
+        ).trim();
+      } else {
+        feature = selected;
+      }
+    } else {
+      feature = handleCancel(
+        await p4.text({
+          message: "Enter target feature name:",
+          validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+        })
+      ).trim();
+    }
+  }
+  feature = toCamelCase(feature);
+  let name = useCaseNameArg?.trim();
+  if (!name) {
+    name = handleCancel(
+      await p4.text({
+        message: "Use Case name:",
+        placeholder: "e.g. CreateUser, GetUser, CancelOrder",
+        validate: (v) => v && v.trim() ? void 0 : "Use Case name cannot be empty"
+      })
+    ).trim();
+  }
+  const ucName = toPascalCase(name);
+  const availableInterfaces = listDomainInterfaces(projectRoot, feature);
+  let selectedDeps = [];
+  if (!flags.yes && availableInterfaces.length > 0) {
+    const multiOptions = availableInterfaces.map((i) => ({
+      value: i.name,
+      label: i.name
+    }));
+    selectedDeps = handleCancel(
+      await p4.multiselect({
+        message: "Select domain interfaces to inject into use case:",
+        options: multiOptions,
+        required: false
+      })
+    );
+  }
+  let inputProps = [];
+  let outputProps = [];
+  let includeTest = true;
+  let createHttp = false;
+  let httpMethod = "post";
+  let httpPath = "/";
+  if (!flags.yes) {
+    const hasInput = handleCancel(
+      await p4.confirm({
+        message: "Does this use case accept input arguments?",
+        initialValue: true
+      })
+    );
+    if (hasInput) {
+      inputProps = await promptProperties({
+        });
+    }
+    const hasCustomOutput = handleCancel(
+      await p4.confirm({
+        message: "Does this use case return custom output data?",
+        initialValue: false
+      })
+    );
+    if (hasCustomOutput) {
+      outputProps = await promptProperties({
+        });
+    }
+    includeTest = handleCancel(
+      await p4.confirm({
+        message: "Generate Vitest unit test skeleton (.test.ts)?",
+        initialValue: true
+      })
+    );
+    createHttp = handleCancel(
+      await p4.confirm({
+        message: "Generate a matching ExpressRoute HTTP handler?",
+        initialValue: false
+      })
+    );
+    if (createHttp) {
+      httpMethod = handleCancel(
+        await p4.select({
+          message: "HTTP method for route:",
+          options: [
+            { value: "post", label: "POST" },
+            { value: "get", label: "GET" },
+            { value: "put", label: "PUT" },
+            { value: "patch", label: "PATCH" },
+            { value: "delete", label: "DELETE" }
+          ],
+          initialValue: "post"
+        })
+      );
+      httpPath = handleCancel(
+        await p4.text({
+          message: "Route subpath (relative to feature prefix):",
+          initialValue: "/",
+          defaultValue: "/"
+        })
+      ).trim();
+    }
+  }
+  const s = p4.spinner();
+  s.start(`Generating use case '${pc13.cyan(ucName)}'...`);
+  const options = {
+    name: ucName,
+    feature,
+    dependencies: selectedDeps,
+    inputProperties: inputProps,
+    outputProperties: outputProps,
+    includeTest,
+    projectRoot,
+    dryRun: Boolean(flags.dryRun),
+    overwrite: Boolean(flags.overwrite)
+  };
+  const files = generateUseCase(options);
+  if (createHttp) {
+    const handlerName = `${ucName}Http`;
+    const httpFiles = generateHttpHandler({
+      name: handlerName,
+      feature,
+      method: httpMethod,
+      path: httpPath,
+      useCaseName: ucName,
+      includeValidation: inputProps.length > 0,
+      validationSource: httpMethod === "get" ? "query" : "body",
+      validationFields: inputProps,
+      projectRoot,
+      dryRun: Boolean(flags.dryRun),
+      overwrite: Boolean(flags.overwrite)
+    });
+    files.push(...httpFiles);
+  }
+  s.stop("Use case generated successfully!");
+  printGeneratedFiles(files, options.dryRun);
+  p4.outro(pc13.green(`Use case '${ucName}' created in feature '${feature}'!`));
+}
+async function runDomainCommand(domainNameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  const existingFeatures = listExistingFeatures(projectRoot);
+  let feature = flags.feature?.trim();
+  if (!feature) {
+    if (existingFeatures.length > 0) {
+      const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
+      featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
+      const selected = handleCancel(
+        await p4.select({
+          message: "Select target feature:",
+          options: featureOptions
+        })
+      );
+      if (selected === "__custom__") {
+        feature = handleCancel(
+          await p4.text({
+            message: "Enter feature name:",
+            validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+          })
+        ).trim();
+      } else {
+        feature = selected;
+      }
+    } else {
+      feature = handleCancel(
+        await p4.text({
+          message: "Enter target feature name:",
+          validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+        })
+      ).trim();
+    }
+  }
+  feature = toCamelCase(feature);
+  let name = domainNameArg?.trim();
+  if (!name) {
+    name = handleCancel(
+      await p4.text({
+        message: "Domain model / entity name:",
+        placeholder: "e.g. User, Order, Product, Address",
+        validate: (v) => v && v.trim() ? void 0 : "Domain name cannot be empty"
+      })
+    ).trim();
+  }
+  const entityName = toPascalCase(name);
+  let kind = "interface";
+  let properties = [];
+  if (!flags.yes) {
+    kind = handleCancel(
+      await p4.select({
+        message: "Select domain model type:",
+        options: [
+          { value: "interface", label: "TypeScript Interface (pure data structure)" },
+          { value: "class", label: "Entity Class (with constructor & properties)" },
+          { value: "valueObject", label: "Value Object (immutable domain object with equals)" }
+        ],
+        initialValue: "interface"
+      })
+    );
+    const defaultProps = [
+      { name: "id", type: "string" },
+      { name: "createdAt", type: "Date" },
+      { name: "updatedAt", type: "Date" }
+    ];
+    properties = await promptProperties({
+      defaults: kind === "valueObject" ? [{ name: "value", type: "string" }] : defaultProps
+    });
+  }
+  const s = p4.spinner();
+  s.start(`Generating domain model '${pc13.cyan(entityName)}'...`);
+  const options = {
+    name: entityName,
+    feature,
+    kind,
+    properties,
+    projectRoot,
+    dryRun: Boolean(flags.dryRun),
+    overwrite: Boolean(flags.overwrite)
+  };
+  const file = generateDomain(options);
+  s.stop("Domain model generated successfully!");
+  printGeneratedFiles([file], options.dryRun);
+  p4.outro(pc13.green(`Domain model '${entityName}' created in feature '${feature}'!`));
+}
+async function runInfrastructureCommand(classNameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  const existingFeatures = listExistingFeatures(projectRoot);
+  let scope = flags.global ? "global" : "feature";
+  let feature = flags.feature?.trim();
+  if (!flags.yes && !flags.global && !flags.feature) {
+    scope = handleCancel(
+      await p4.select({
+        message: "Where should this infrastructure implementation be placed?",
+        options: [
+          { value: "feature", label: "Feature-level (features/<feature>/infrastructure)" },
+          { value: "global", label: "Global / Core (infrastructure/)" }
+        ],
+        initialValue: "feature"
+      })
+    );
+  }
+  if (scope === "feature" && !feature) {
+    if (existingFeatures.length > 0) {
+      const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
+      featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
+      const selected = handleCancel(
+        await p4.select({
+          message: "Select target feature:",
+          options: featureOptions
+        })
+      );
+      if (selected === "__custom__") {
+        feature = handleCancel(
+          await p4.text({
+            message: "Enter feature name:",
+            validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+          })
+        ).trim();
+      } else {
+        feature = selected;
+      }
+    } else {
+      feature = handleCancel(
+        await p4.text({
+          message: "Enter target feature name:",
+          validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+        })
+      ).trim();
+    }
+  }
+  if (feature) {
+    feature = toCamelCase(feature);
+  }
+  let name = classNameArg?.trim();
+  if (!name) {
+    name = handleCancel(
+      await p4.text({
+        message: "Infrastructure class name:",
+        placeholder: "e.g. StubUserRepository, PostgresUserRepository, S3FileStorage",
+        validate: (v) => v && v.trim() ? void 0 : "Class name cannot be empty"
+      })
+    ).trim();
+  }
+  const className = toPascalCase(name);
+  let kind = flags.kind ? flags.kind === "stub" ? "stub" : "concrete" : className.startsWith("Stub") ? "stub" : "concrete";
+  let implementsInterface = flags.interface?.trim() || void 0;
+  let registerInProvider = false;
+  if (scope === "feature" && feature && !implementsInterface) {
+    const interfaces = listDomainInterfaces(projectRoot, feature);
+    if (!flags.yes) {
+      if (interfaces.length > 0) {
+        const match = interfaces.find(
+          (i) => className.toLowerCase().includes(removeInterfacePrefix(i.name).toLowerCase())
+        );
+        const ifaceChoice = handleCancel(
+          await p4.select({
+            message: "Does this class implement a domain interface or abstract class?",
+            options: [
+              ...interfaces.map((i) => ({ value: i.name, label: i.name })),
+              { value: "__custom__", label: "\u270F\uFE0F  Enter custom interface or abstract class..." },
+              { value: "__none__", label: "None / Standalone" }
+            ],
+            initialValue: match?.name || interfaces[0]?.name
+          })
+        );
+        if (ifaceChoice === "__custom__") {
+          implementsInterface = handleCancel(
+            await p4.text({
+              message: "Enter interface or abstract class name:",
+              placeholder: "e.g. IUserRepository, BaseStorageAdapter",
+              validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
+            })
+          ).trim();
+        } else if (ifaceChoice !== "__none__") {
+          implementsInterface = ifaceChoice;
+        }
+      } else {
+        const wantImpl = handleCancel(
+          await p4.confirm({
+            message: "Does this class implement a domain interface or abstract class?",
+            initialValue: false
+          })
+        );
+        if (wantImpl) {
+          implementsInterface = handleCancel(
+            await p4.text({
+              message: "Enter interface or abstract class name:",
+              placeholder: "e.g. IUserRepository, BaseStorageAdapter",
+              validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
+            })
+          ).trim();
+        }
+      }
+    } else if (flags.yes && interfaces.length > 0) {
+      const match = interfaces.find(
+        (i) => className.toLowerCase().includes(removeInterfacePrefix(i.name).toLowerCase())
+      );
+      if (match) {
+        implementsInterface = match.name;
+      }
+    }
+  } else if (scope === "global" && !implementsInterface && !flags.yes) {
+    const allInterfaces = listDomainInterfaces(projectRoot);
+    if (allInterfaces.length > 0) {
+      const ifaceChoice = handleCancel(
+        await p4.select({
+          message: "Does this class implement an interface or abstract class?",
+          options: [
+            ...allInterfaces.map((i) => ({ value: i.name, label: `${i.name} (${i.feature})` })),
+            { value: "__custom__", label: "\u270F\uFE0F  Enter custom interface or abstract class..." },
+            { value: "__none__", label: "None / Standalone" }
+          ],
+          initialValue: "__none__"
+        })
+      );
+      if (ifaceChoice === "__custom__") {
+        implementsInterface = handleCancel(
+          await p4.text({
+            message: "Enter interface or abstract class name:",
+            placeholder: "e.g. IAuthRepository",
+            validate: (v) => v && v.trim() ? void 0 : "Name cannot be empty"
+          })
+        ).trim();
+      } else if (ifaceChoice !== "__none__") {
+        implementsInterface = ifaceChoice;
+      }
+    }
+  }
+  if (!flags.yes && !flags.kind) {
+    kind = handleCancel(
+      await p4.select({
+        message: "Select implementation kind:",
+        options: [
+          { value: "stub", label: "In-Memory Stub (with in-memory store and test helper methods)" },
+          { value: "concrete", label: "Concrete Adapter / Service Skeleton (@MakeInjectable)" }
+        ],
+        initialValue: kind
+      })
+    );
+    if (scope === "feature" && feature && implementsInterface) {
+      registerInProvider = handleCancel(
+        await p4.confirm({
+          message: "Register this implementation in feature diProvider.ts?",
+          initialValue: true
+        })
+      );
+    }
+  } else if (flags.yes && scope === "feature" && feature && implementsInterface) {
+    registerInProvider = !flags.noProvider;
+  }
+  const s = p4.spinner();
+  s.start(`Generating infrastructure class '${pc13.cyan(className)}'...`);
+  const files = [];
+  const options = {
+    name: className,
+    feature,
+    scope,
+    kind,
+    implementsInterface,
+    projectRoot,
+    dryRun: Boolean(flags.dryRun),
+    overwrite: Boolean(flags.overwrite)
+  };
+  const infraFile = generateInfrastructure(options);
+  files.push(infraFile);
+  if (registerInProvider && scope === "feature" && feature && implementsInterface) {
+    const featureDir = path7.join(resolveFeaturesDir(projectRoot), feature);
+    const providerFile = updateOrGenerateDiProvider(
+      featureDir,
+      feature,
+      [
+        {
+          ifaceName: implementsInterface,
+          implName: className
+        }
+      ],
+      {
+        projectRoot,
+        dryRun: Boolean(flags.dryRun),
+        overwrite: Boolean(flags.overwrite)
+      }
+    );
+    files.push(providerFile);
+  }
+  s.stop("Infrastructure class generated successfully!");
+  printGeneratedFiles(files, options.dryRun);
+  p4.outro(pc13.green(`Infrastructure class '${className}' created!`));
+}
+async function runInterfaceCommand(interfaceNameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  const existingFeatures = listExistingFeatures(projectRoot);
+  let feature = flags.feature?.trim();
+  if (!feature) {
+    if (existingFeatures.length > 0) {
+      const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
+      featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
+      const selected = handleCancel(
+        await p4.select({
+          message: "Select target feature:",
+          options: featureOptions
+        })
+      );
+      if (selected === "__custom__") {
+        feature = handleCancel(
+          await p4.text({
+            message: "Enter feature name:",
+            validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+          })
+        ).trim();
+      } else {
+        feature = selected;
+      }
+    } else {
+      feature = handleCancel(
+        await p4.text({
+          message: "Enter target feature name:",
+          validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+        })
+      ).trim();
+    }
+  }
+  feature = toCamelCase(feature);
+  let name = interfaceNameArg?.trim();
+  if (!name) {
+    name = handleCancel(
+      await p4.text({
+        message: "Domain interface name:",
+        placeholder: "e.g. IUserRepository, IPaymentService",
+        validate: (v) => v && v.trim() ? void 0 : "Interface name cannot be empty"
+      })
+    ).trim();
+  }
+  const ifaceName = ensureInterfacePrefix(name);
+  const existingEntities = listDomainEntities(projectRoot, feature);
+  const fallbackEntity = existingEntities.length > 0 ? existingEntities.find((e) => ifaceName.toLowerCase().includes(e.name.toLowerCase()))?.name || existingEntities[0]?.name : removeInterfacePrefix(ifaceName).replace(/Repository$|Service$/, "");
+  let entityName = flags.entity || fallbackEntity;
+  let kind = "abstractClass";
+  let methodsPreset = "crud";
+  let generateStub = true;
+  let registerInProvider = true;
+  if (!flags.yes) {
+    if (existingEntities.length > 0) {
+      const selectedEntity = handleCancel(
+        await p4.select({
+          message: "Select domain entity associated with this interface:",
+          options: [
+            ...existingEntities.map((e) => ({ value: e.name, label: e.name })),
+            { value: "__custom__", label: "\u270F\uFE0F  Enter custom entity name..." }
+          ],
+          initialValue: fallbackEntity
+        })
+      );
+      if (selectedEntity === "__custom__") {
+        entityName = handleCancel(
+          await p4.text({
+            message: "Enter entity name:",
+            defaultValue: removeInterfacePrefix(ifaceName).replace(/Repository$|Service$/, "")
+          })
+        ).trim();
+      } else {
+        entityName = selectedEntity;
+      }
+    }
+    kind = handleCancel(
+      await p4.select({
+        message: "Interface definition style:",
+        options: [
+          { value: "abstractClass", label: "Abstract Class (Recommended - acts as DI token & type)" },
+          { value: "interface", label: "TypeScript Interface (type-only)" }
+        ],
+        initialValue: "abstractClass"
+      })
+    );
+    methodsPreset = handleCancel(
+      await p4.select({
+        message: "Method signature preset:",
+        options: [
+          { value: "crud", label: "Standard CRUD (GetById, List, Create, Update, Delete)" },
+          { value: "empty", label: "Empty / Minimal skeleton" }
+        ],
+        initialValue: "crud"
+      })
+    );
+    generateStub = handleCancel(
+      await p4.confirm({
+        message: "Auto-generate Infrastructure Stub implementation?",
+        initialValue: true
+      })
+    );
+    if (generateStub) {
+      registerInProvider = handleCancel(
+        await p4.confirm({
+          message: "Auto-register interface & stub in feature diProvider.ts?",
+          initialValue: true
+        })
+      );
+    }
+  }
+  const s = p4.spinner();
+  s.start(`Generating interface '${pc13.cyan(ifaceName)}'...`);
+  const files = [];
+  const options = {
+    name: ifaceName,
+    feature,
+    kind,
+    entityName,
+    methodsPreset,
+    projectRoot,
+    dryRun: Boolean(flags.dryRun),
+    overwrite: Boolean(flags.overwrite)
+  };
+  const ifaceFile = generateInterface(options);
+  files.push(ifaceFile);
+  const stubClassName = toStubName(ifaceName);
+  if (generateStub) {
+    const stubFile = generateInfrastructure({
+      name: stubClassName,
+      feature,
+      kind: "stub",
+      implementsInterface: ifaceName,
+      entityName,
+      projectRoot,
+      dryRun: Boolean(flags.dryRun),
+      overwrite: Boolean(flags.overwrite)
+    });
+    files.push(stubFile);
+  }
+  if (registerInProvider && generateStub) {
+    const featureDir = path7.join(resolveFeaturesDir(projectRoot), feature);
+    const providerFile = updateOrGenerateDiProvider(
+      featureDir,
+      feature,
+      [
+        {
+          ifaceName,
+          implName: stubClassName
+        }
+      ],
+      {
+        projectRoot,
+        dryRun: Boolean(flags.dryRun),
+        overwrite: Boolean(flags.overwrite)
+      }
+    );
+    files.push(providerFile);
+  }
+  s.stop("Interface generated successfully!");
+  printGeneratedFiles(files, options.dryRun);
+  p4.outro(pc13.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
+}
+async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  const existingFeatures = listExistingFeatures(projectRoot);
+  let feature = flags.feature?.trim();
+  if (!feature) {
+    if (existingFeatures.length > 0) {
+      const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
+      featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
+      const selected = handleCancel(
+        await p4.select({
+          message: "Select target feature:",
+          options: featureOptions
+        })
+      );
+      if (selected === "__custom__") {
+        feature = handleCancel(
+          await p4.text({
+            message: "Enter feature name:",
+            validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+          })
+        ).trim();
+      } else {
+        feature = selected;
+      }
+    } else {
+      feature = handleCancel(
+        await p4.text({
+          message: "Enter target feature name:",
+          validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+        })
+      ).trim();
+    }
+  }
+  feature = toCamelCase(feature);
+  let name = handlerNameArg?.trim();
+  if (!name) {
+    name = handleCancel(
+      await p4.text({
+        message: "HTTP Route Handler class name:",
+        placeholder: "e.g. CreateUserHttp, GetUserHttp, HealthHttp",
+        validate: (v) => v && v.trim() ? void 0 : "Handler name cannot be empty"
+      })
+    ).trim();
+  }
+  let className = toPascalCase(name);
+  if (!className.endsWith("Http") && !className.endsWith("Route")) {
+    className = `${className}Http`;
+  }
+  let method = flags.method || "get";
+  let subPath = flags.path || "/";
+  let useCaseName = flags.usecase;
+  let includeValidation = true;
+  let validationSource = "body";
+  let validationFields = [];
+  if (!flags.yes) {
+    method = handleCancel(
+      await p4.select({
+        message: "HTTP Method:",
+        options: [
+          { value: "get", label: "GET" },
+          { value: "post", label: "POST" },
+          { value: "put", label: "PUT" },
+          { value: "patch", label: "PATCH" },
+          { value: "delete", label: "DELETE" }
+        ],
+        initialValue: method
+      })
+    );
+    const defaultPath = method === "get" ? "/" : "/";
+    subPath = handleCancel(
+      await p4.text({
+        message: "Route subpath (relative to feature prefix):",
+        initialValue: defaultPath,
+        defaultValue: defaultPath
+      })
+    ).trim();
+    const useCases = listUseCases(projectRoot, feature);
+    if (useCases.length > 0) {
+      const ucOptions = useCases.map((u) => ({ value: u.name, label: u.name }));
+      ucOptions.push({ value: "__none__", label: "None / Standalone Handler" });
+      const chosenUc = handleCancel(
+        await p4.select({
+          message: "Connect this handler to a domain Use Case?",
+          options: ucOptions,
+          initialValue: ucOptions[0]?.value
+        })
+      );
+      if (chosenUc !== "__none__") {
+        useCaseName = chosenUc;
+      }
+    }
+    includeValidation = handleCancel(
+      await p4.confirm({
+        message: "Include Zod inbound request validation?",
+        initialValue: method !== "delete"
+      })
+    );
+    if (includeValidation) {
+      const defaultSource = method === "get" ? "query" : "body";
+      validationSource = handleCancel(
+        await p4.select({
+          message: "Validation data source:",
+          options: [
+            { value: "body", label: "req.body (for POST / PUT / PATCH payloads)" },
+            { value: "query", label: "req.query (for GET search/filter queries)" },
+            { value: "params", label: "req.params (for route parameters e.g. :id)" }
+          ],
+          initialValue: defaultSource
+        })
+      );
+      validationFields = await promptProperties({
+        });
+    }
+  }
+  const s = p4.spinner();
+  s.start(`Generating HTTP handler '${pc13.cyan(className)}'...`);
+  const options = {
+    name: className,
+    feature,
+    method,
+    path: subPath,
+    useCaseName,
+    includeValidation,
+    validationSource,
+    validationFields,
+    successMessage: flags.message,
+    projectRoot,
+    dryRun: Boolean(flags.dryRun),
+    overwrite: Boolean(flags.overwrite)
+  };
+  const files = generateHttpHandler(options);
+  s.stop("HTTP handler generated successfully!");
+  printGeneratedFiles(files, options.dryRun);
+  p4.outro(pc13.green(`HTTP handler '${className}' created in feature '${feature}'!`));
+}
+function generateInjectableCode(className, dependencies = [], methods = [], implementsInterface) {
+  const formattedDeps = dependencies.map((dep) => ({
+    key: toCamelCase(dep),
+    name: dep
+  }));
+  const formattedMethods = methods.map((m) => {
+    const isAsync = m.async !== false;
+    const retType = m.returnType ? isAsync ? `Promise<${m.returnType}>` : m.returnType : isAsync ? "Promise<void>" : "void";
+    const params = m.params && m.params.length > 0 ? m.params.map((p15) => `${p15.name}: ${p15.type}`).join(", ") : "";
+    return {
+      name: m.name,
+      isAsync,
+      params,
+      returnType: retType
+    };
+  });
+  return renderTemplate(injectableTemplate, {
+    className,
+    implementsInterface,
+    dependencies: formattedDeps,
+    hasDependencies: dependencies.length > 0,
+    hasMethods: formattedMethods.length > 0,
+    methods: formattedMethods
+  });
+}
+function generateInjectable(options) {
+  const files = [];
+  const projectRoot = options.projectRoot || findProjectRoot();
+  const className = toPascalCase(options.name);
+  let targetDir = "";
+  if (options.customPath) {
+    targetDir = path7.isAbsolute(options.customPath) ? options.customPath : path7.join(projectRoot, options.customPath);
+  } else if (options.location === "feature-service" && options.feature) {
+    targetDir = path7.join(resolveFeaturesDir(projectRoot), options.feature, "services");
+  } else if (options.location === "feature-transformer" && options.feature) {
+    targetDir = path7.join(resolveFeaturesDir(projectRoot), options.feature, "pxExpress", "transformers");
+  } else if (options.location === "module") {
+    targetDir = path7.join(projectRoot, "modules", className);
+  } else {
+    targetDir = options.feature ? path7.join(resolveFeaturesDir(projectRoot), options.feature, "services") : path7.join(projectRoot, "shared", className.toLowerCase());
+  }
+  const filePath = path7.join(targetDir, `${className}.ts`);
+  let ifaceName;
+  if (options.generateInterface) {
+    ifaceName = `I${className}`;
+    const ifacePath = path7.join(targetDir, `${ifaceName}.ts`);
+    const ifaceContent = renderTemplate(injectableInterfaceTemplate, { ifaceName });
+    files.push(
+      writeFileSafely(ifacePath, ifaceContent, {
+        projectRoot,
+        dryRun: options.dryRun,
+        overwrite: options.overwrite
+      })
+    );
+  }
+  const code = generateInjectableCode(
+    className,
+    options.dependencies || [],
+    options.methods || [],
+    ifaceName
+  );
+  files.push(
+    writeFileSafely(filePath, code, {
+      projectRoot,
+      dryRun: options.dryRun,
+      overwrite: options.overwrite
+    })
+  );
+  return files;
+}
+
+// src/commands/injectable.ts
+async function runInjectableCommand(classNameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  const existingFeatures = listExistingFeatures(projectRoot);
+  let name = classNameArg?.trim();
+  if (!name) {
+    name = handleCancel(
+      await p4.text({
+        message: "Injectable class name:",
+        placeholder: "e.g. PasswordHasher, TokenService, UserTransformer",
+        validate: (v) => v && v.trim() ? void 0 : "Class name cannot be empty"
+      })
+    ).trim();
+  }
+  const className = toPascalCase(name);
+  let location = "feature-service";
+  let feature = flags.feature?.trim();
+  let customPath;
+  if (!flags.yes) {
+    location = handleCancel(
+      await p4.select({
+        message: "Select target architectural location:",
+        options: [
+          { value: "feature-service", label: "Feature Service (features/<feature>/services/)" },
+          { value: "feature-transformer", label: "Feature Transformer (features/<feature>/pxExpress/transformers/)" },
+          { value: "shared", label: "Shared Module (shared/<name>/)" },
+          { value: "module", label: "Core Module (modules/<Name>/)" },
+          { value: "custom", label: "Custom directory path..." }
+        ],
+        initialValue: "feature-service"
+      })
+    );
+    if (location === "feature-service" || location === "feature-transformer") {
+      if (!feature) {
+        if (existingFeatures.length > 0) {
+          const featureOptions = existingFeatures.map((f) => ({ value: f, label: f }));
+          featureOptions.push({ value: "__custom__", label: "\u270F\uFE0F  Enter custom feature name..." });
+          const selected = handleCancel(
+            await p4.select({
+              message: "Select target feature:",
+              options: featureOptions
+            })
+          );
+          if (selected === "__custom__") {
+            feature = handleCancel(
+              await p4.text({
+                message: "Enter feature name:",
+                validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+              })
+            ).trim();
+          } else {
+            feature = selected;
+          }
+        } else {
+          feature = handleCancel(
+            await p4.text({
+              message: "Enter target feature name:",
+              validate: (v) => v && v.trim() ? void 0 : "Feature name cannot be empty"
+            })
+          ).trim();
+        }
+      }
+      feature = toCamelCase(feature);
+    } else if (location === "custom") {
+      customPath = handleCancel(
+        await p4.text({
+          message: "Enter destination directory path:",
+          placeholder: "e.g. src/services or lib/utils",
+          validate: (v) => v && v.trim() ? void 0 : "Path cannot be empty"
+        })
+      ).trim();
+    }
+  }
+  let generateInterface2 = false;
+  if (!flags.yes) {
+    generateInterface2 = handleCancel(
+      await p4.confirm({
+        message: `Generate abstract class interface (I${className}) as runtime DI token?`,
+        initialValue: false
+      })
+    );
+  }
+  const s = p4.spinner();
+  s.start(`Generating injectable '${pc13.cyan(className)}'...`);
+  const options = {
+    name: className,
+    feature,
+    location,
+    customPath,
+    generateInterface: generateInterface2,
+    projectRoot,
+    dryRun: Boolean(flags.dryRun),
+    overwrite: Boolean(flags.overwrite)
+  };
+  const files = generateInjectable(options);
+  s.stop("Injectable class generated successfully!");
+  printGeneratedFiles(files, options.dryRun);
+  p4.outro(pc13.green(`Injectable '${className}' created successfully!`));
+}
+async function runInteractiveMenu(flags = {}) {
+  printBanner();
+  const choice = handleCancel(
+    await p4.select({
+      message: "What would you like to create in your architecture?",
+      options: [
+        {
+          value: "feature",
+          label: "Feature",
+          hint: "Complete vertical slice (domain, infra, usecase, pxExpress, diProvider)"
+        },
+        {
+          value: "usecase",
+          label: "Use Case",
+          hint: "Domain usecase with @MakeInjectable, DTOs & Vitest tests"
+        },
+        {
+          value: "domain",
+          label: "Domain Entity / Model",
+          hint: "Zero-dependency pure TypeScript interface, class, or value object"
+        },
+        {
+          value: "interface",
+          label: "Domain Interface",
+          hint: "Abstract class repository/service interface serving as DI token"
+        },
+        {
+          value: "infrastructure",
+          label: "Infrastructure",
+          hint: "In-memory stub or concrete repository/client adapter"
+        },
+        {
+          value: "httpHandler",
+          label: "HTTP Handler",
+          hint: "ExpressRoute endpoint with @MakeInjectable & Zod validation"
+        },
+        {
+          value: "injectable",
+          label: "Injectable Service",
+          hint: "Generic @MakeInjectable class for services, transformers, or modules"
+        }
+      ]
+    })
+  );
+  switch (choice) {
+    case "feature":
+      await runFeatureCommand(void 0, flags);
+      break;
+    case "usecase":
+      await runUseCaseCommand(void 0, flags);
+      break;
+    case "domain":
+      await runDomainCommand(void 0, flags);
+      break;
+    case "interface":
+      await runInterfaceCommand(void 0, flags);
+      break;
+    case "infrastructure":
+      await runInfrastructureCommand(void 0, flags);
+      break;
+    case "httpHandler":
+      await runHttpHandlerCommand(void 0, flags);
+      break;
+    case "injectable":
+      await runInjectableCommand(void 0, flags);
+      break;
+  }
+}
+
+// src/commands/create.ts
+async function handleCreate(type, name, flags = {}) {
+  if (!type) {
+    await runInteractiveMenu(flags);
+    return;
+  }
+  const normalizedType = type.trim();
+  switch (normalizedType) {
+    case "feature":
+      await runFeatureCommand(name, flags);
+      break;
+    case "usecase":
+      await runUseCaseCommand(name, flags);
+      break;
+    case "domain":
+      await runDomainCommand(name, flags);
+      break;
+    case "infrastructure":
+      await runInfrastructureCommand(name, flags);
+      break;
+    case "interface":
+      await runInterfaceCommand(name, flags);
+      break;
+    case "httpHandler":
+    case "httphandler":
+      await runHttpHandlerCommand(name, flags);
+      break;
+    case "injectable":
+      await runInjectableCommand(name, flags);
+      break;
+    default:
+      p4.log.error(
+        pc13.red(
+          `Unknown component type: "${type}". Allowed types: feature, usecase, domain, infrastructure, interface, httpHandler, injectable.`
+        )
+      );
+      process.exit(1);
+  }
+}
+async function handleImport(typeArg, nameArg, flags = {}) {
+  const projectRoot = findProjectRoot();
+  let type = typeArg?.trim().toLowerCase();
+  if (type === "features") type = "feature";
+  if (!type) {
+    type = handleCancel(
+      await p4.select({
+        message: "What kind of module would you like to import?",
+        options: [
+          {
+            value: "shared",
+            label: "Shared Module",
+            hint: "Foundational utility or port placed in src/shared"
+          },
+          {
+            value: "feature",
+            label: "Feature",
+            hint: "Complete Clean Architecture vertical slice placed in src/features"
+          }
+        ]
+      })
+    );
+  }
+  if (type !== "shared" && type !== "feature") {
+    p4.log.error(pc13.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
+    process.exit(1);
+  }
+  const registryBase = getRegistryBase(projectRoot, flags.registry);
+  const s = p4.spinner();
+  s.start(`Connecting to registry at ${pc13.dim(registryBase)}...`);
+  let index;
+  try {
+    index = await fetchRegistryIndex(registryBase);
+    s.stop("Registry index loaded.");
+  } catch (err) {
+    s.stop(pc13.red("Failed to load registry index."));
+    p4.log.error(pc13.red(err.message || String(err)));
+    process.exit(1);
+  }
+  const availableList = type === "shared" ? index.shared : index.features;
+  const candidateNames = availableList.map((m) => m.name);
+  let name = nameArg?.trim();
+  if (!name) {
+    if (availableList.length === 0) {
+      p4.log.warn(`No ${type} modules available in the registry.`);
+      return;
+    }
+    name = handleCancel(
+      await p4.select({
+        message: `Select a ${type} to import:`,
+        options: availableList.map((item) => ({
+          value: item.name,
+          label: item.name,
+          hint: item.description
+        }))
+      })
+    );
+  }
+  if (!candidateNames.includes(name)) {
+    const closest = findClosestMatch(name, candidateNames);
+    p4.log.error(pc13.red(`\u274C Module '${name}' not found in the ${type} registry.`));
+    if (closest) {
+      p4.log.info(pc13.yellow(`Did you mean '${pc13.cyan(closest)}'?`));
+    }
+    process.exit(1);
+  }
+  const importedModules = /* @__PURE__ */ new Set();
+  const totalWrittenFiles = [];
+  const requiredNpmPackages = /* @__PURE__ */ new Set();
+  async function importModuleRecursive(modType, modName) {
+    const modKey = `${modType}:${modName}`;
+    if (importedModules.has(modKey)) return;
+    p4.log.step(`Importing ${modType}: ${pc13.cyan(modName)}...`);
+    let manifest;
+    try {
+      manifest = await fetchModuleManifest(registryBase, modType, modName);
+    } catch (err) {
+      p4.log.error(pc13.red(`Failed to fetch manifest for ${modType} '${modName}': ${err.message}`));
+      process.exit(1);
+    }
+    const sharedDeps = manifest.dependencies?.shared || [];
+    for (const dep of sharedDeps) {
+      const depPath = path7.join(projectRoot, "src", "shared", dep);
+      if (!fs3.existsSync(depPath) && !importedModules.has(`shared:${dep}`)) {
+        p4.log.info(`  \u21B3 Resolving required shared dependency: ${pc13.cyan(dep)}`);
+        await importModuleRecursive("shared", dep);
+      }
+    }
+    const featureDeps = manifest.dependencies?.features || [];
+    for (const dep of featureDeps) {
+      const depPath = path7.join(projectRoot, "src", "features", dep);
+      if (!fs3.existsSync(depPath) && !importedModules.has(`feature:${dep}`)) {
+        p4.log.info(`  \u21B3 Resolving required feature dependency: ${pc13.cyan(dep)}`);
+        await importModuleRecursive("feature", dep);
+      }
+    }
+    for (const pkg of manifest.dependencies?.npm || []) {
+      requiredNpmPackages.add(pkg);
+    }
+    const folder = modType === "shared" ? "shared" : "features";
+    const targetDir = path7.join(projectRoot, "src", folder, modName);
+    for (const file of manifest.files || []) {
+      if (file === "registry.json") continue;
+      const remoteFilePath = `${folder}/${modName}/${file}`;
+      const localFilePath = path7.join(targetDir, file);
+      if (fs3.existsSync(localFilePath) && !flags.overwrite) {
+        p4.log.warn(`  \u21B3 Skipping existing file: ${pc13.dim(path7.relative(projectRoot, localFilePath))} (use --overwrite to replace)`);
+        continue;
+      }
+      const content = await fetchRegistryFile(registryBase, remoteFilePath);
+      if (!flags.dryRun) {
+        fs3.mkdirSync(path7.dirname(localFilePath), { recursive: true });
+        fs3.writeFileSync(localFilePath, content, "utf-8");
+      }
+      const displayPath = path7.relative(projectRoot, localFilePath);
+      totalWrittenFiles.push(displayPath);
+      p4.log.message(`  ${pc13.green("+")} ${displayPath}`);
+    }
+    importedModules.add(modKey);
+  }
+  await importModuleRecursive(type, name);
+  const missingNpm = getMissingNpmPackages(projectRoot, Array.from(requiredNpmPackages));
+  if (missingNpm.length > 0) {
+    if (flags.skipInstall || flags.dryRun) {
+      p4.log.info(`Required npm dependencies to install: ${pc13.cyan(missingNpm.join(", "))}`);
+    } else {
+      try {
+        installNpmPackages(projectRoot, missingNpm);
+      } catch (err) {
+        p4.log.warn(`Could not automatically install packages (${err.message}). Please run: npm install ${missingNpm.join(" ")}`);
+      }
+    }
+  }
+  if (flags.dryRun) {
+    p4.log.info(pc13.yellow("Dry run complete: No files were written to disk."));
+  } else {
+    p4.log.success(
+      pc13.green(
+        `Successfully imported ${type} '${name}' (${totalWrittenFiles.length} file${totalWrittenFiles.length === 1 ? "" : "s"} placed in src/${type === "shared" ? "shared" : "features"}/${name})`
+      )
+    );
+  }
+}
+
+// src/cli.ts
+function createCli() {
+  const cli = cac("mason");
+  cli.command("[...args]", "Interactive scaffolding and import wizard").option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").option("-y, --yes", "Accept defaults and skip interactive prompts").action(async (args, flags) => {
+    if (args && args.length > 0) {
+      p4.log.error(
+        pc13.red(
+          `Unknown command: "${args.join(" ")}". Use --help to list available commands.`
+        )
+      );
+      process.exit(1);
+    }
+    try {
+      const choice = handleCancel(
+        await p4.select({
+          message: "\u{1F9F1} Mason: What would you like to do?",
+          options: [
+            {
+              value: "create",
+              label: "Create local component",
+              hint: "Scaffold a new feature, use case, domain entity, interface, etc."
+            },
+            {
+              value: "import",
+              label: "Import from registry",
+              hint: "Download and link pre-built shared modules or features from the registry"
+            }
+          ]
+        })
+      );
+      if (choice === "create") {
+        await handleCreate(void 0, void 0, flags);
+      } else {
+        await handleImport(void 0, void 0, flags);
+      }
+    } catch (err) {
+      handleCliError(err);
+    }
+  });
+  cli.command(
+    "create [type] [name]",
+    "Scaffold local Clean Architecture components (feature, usecase, domain, etc.)"
+  ).option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").option("-y, --yes", "Accept defaults and skip interactive prompts").option("-f, --feature <feature>", "Target feature name").option("-t, --target <dir>", "Override target directory").option("--express", "Include Express presentation layer (pxExpress)").option("--no-express", "Skip Express presentation layer").option("-i, --interface <interface>", "Interface or abstract class to implement").option("-k, --kind <kind>", "Implementation kind ('stub' or 'concrete')").option("-g, --global", "Place in global infrastructure/ instead of feature").option("-m, --method <method>", "HTTP method (get, post, put, patch, delete)").option("-p, --path <path>", "Route subpath (e.g. /:id)").option("-u, --usecase <usecase>", "Connected use case name").option("--message <message>", "Custom success message").option("--domainNames <names>", "Comma-separated domain entity names").example("mason create").example("mason create feature users").example("mason create usecase PlaceOrder -f orders").example("mason create domain User -f users").example("mason create infrastructure PostgresUserRepository -f users -i IUserRepository").example("mason create interface IUserRepository -f users").example("mason create httpHandler GetUserHttp -f users -m get -p /:id").example("mason create injectable PasswordHasher").action(async (type, name, flags = {}) => {
+    try {
+      await handleCreate(type, name, flags);
+    } catch (err) {
+      handleCliError(err);
+    }
+  });
+  cli.command(
+    "import [type] [name]",
+    "Import pre-built shared modules or features from the Solid Stack Registry"
+  ).option("-o, --overwrite", "Overwrite existing files").option("-d, --dry-run", "Preview changes without writing to disk").option("-y, --yes", "Accept defaults and skip interactive prompts").option("--registry <url>", "Registry base URL or local directory").option("--skip-install", "Skip automatic package manager dependency installation").example("mason import shared hasher").example("mason import feature authn").example("mason import shared").example("mason import feature").action(async (type, name, flags = {}) => {
+    try {
+      await handleImport(type, name, flags);
+    } catch (err) {
+      handleCliError(err);
+    }
+  });
+  const createSubtypes = [
+    "feature",
+    "usecase",
+    "domain",
+    "infrastructure",
+    "interface",
+    "httpHandler",
+    "injectable"
+  ];
+  for (const subtype of createSubtypes) {
+    cli.command(
+      `${subtype} [name]`,
+      `Shorthand for 'mason create ${subtype} [name]'`
+    ).allowUnknownOptions().action(async (name, flags = {}) => {
+      try {
+        await handleCreate(subtype, name, flags);
+      } catch (err) {
+        handleCliError(err);
+      }
+    });
+  }
+  cli.help();
+  cli.version("1.0.10");
+  return cli;
+}
+function handleCliError(err) {
+  if (err instanceof PromptCancelledError) {
+    process.exit(0);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  p4.log.error(pc13.red(`Error: ${message}`));
+  process.exit(1);
+}
+async function runCli(argv = process.argv) {
+  const cli = createCli();
+  cli.parse(argv, { run: true });
+}
+
+export { DEFAULT_REGISTRY_BASE, PromptCancelledError, concreteInfraTemplate, createCli, detectPackageManager, diProviderTemplate, domainClassTemplate, domainInterfaceTemplate, domainValueObjectTemplate, ensureInterfacePrefix, expressIndexTemplate, fetchModuleManifest, fetchRegistryFile, fetchRegistryIndex, findClosestMatch, findInterfaceFile, findProjectRoot, generateConcreteInfraCode, generateDomain, generateDomainEntityCode, generateFeature, generateHttpHandler, generateHttpHandlerCode, generateInfrastructure, generateInjectable, generateInjectableCode, generateInterface, generateInterfaceCode, generateStubCode, generateUseCase, generateUseCaseCode, generateUseCaseTestCode, getMissingNpmPackages, getRegistryBase, getTemplatesDir, handleCancel, handleCreate, handleImport, hbs, httpHandlerTemplate, injectableInterfaceTemplate, injectableTemplate, installNpmPackages, interfaceTemplate, isValidIdentifier, levenshteinDistance, listDomainEntities, listDomainInterfaces, listExistingFeatures, listUseCases, loadInterfaceHierarchy, loadTemplate, parseInterfaceMethodsAndImports, printBanner, printGeneratedFiles, promptProperties, removeInterfacePrefix, renderTemplate, renderTemplateFile, resolveFeaturesDir, runCli, stubInfraTemplate, synthesizeCrudMethods, toCamelCase, toKebabCase, toPascalCase, toPlural, toSingular, toStubName, updateOrGenerateDiProvider, useCaseTemplate, useCaseTestTemplate, writeFileSafely };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map