fragment-ts 2.0.2 → 2.0.4

package/dist/web/platform/cli/web/index.mjs

@@ -0,0 +1,1998 @@
+// src/platform/cli/web/commands/web-sync.ts
+import fs3 from "fs";
+import path4 from "path";
+
+// src/platform/cli/web/utils/config.ts
+import fs from "fs";
+import path from "path";
+var WEB_CONFIG_FILE = "fragment.web.json";
+function resolveCwd(cwd) {
+  return cwd ? path.resolve(cwd) : process.cwd();
+}
+function webConfigPath(cwd) {
+  return path.join(resolveCwd(cwd), WEB_CONFIG_FILE);
+}
+function readJsonFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const raw = fs.readFileSync(filePath, "utf8");
+  return JSON.parse(raw);
+}
+function readWebConfig(cwd) {
+  return readJsonFile(webConfigPath(cwd));
+}
+function ensureWebConfig(cwd) {
+  const config2 = readWebConfig(cwd);
+  if (!config2) {
+    throw new Error("fragment.web.json was not found in the current project");
+  }
+  return config2;
+}
+
+// src/platform/cli/web/utils/header.ts
+function autoGeneratedSyncHeader(source) {
+  return `// \u26A0\uFE0F  AUTO-GENERATED by frg web:sync \u2014 do not edit manually
+// Source: ${source}
+// Synced at: ${(/* @__PURE__ */ new Date()).toISOString()}`;
+}
+
+// src/platform/cli/web/utils/logger.ts
+import pc from "picocolors";
+import path2 from "path";
+function line(symbol, label, message) {
+  return `  ${symbol}  ${label.padEnd(8, " ")} ${message}`;
+}
+function displayPath(value) {
+  if (!value) return value;
+  if (!path2.isAbsolute(value)) return value;
+  const rel = path2.relative(process.cwd(), value);
+  if (!rel) return ".";
+  if (rel.startsWith("..")) return value;
+  return rel;
+}
+var logger = {
+  section(title, subtitle) {
+    process.stdout.write(`
+  ${pc.bold(title)}${subtitle ? `  ${subtitle}` : ""}
+
+`);
+  },
+  created(path19) {
+    process.stdout.write(`${line(pc.green("\u2714"), "created", displayPath(path19))}
+`);
+  },
+  updated(path19, detail) {
+    process.stdout.write(
+      `${line(pc.cyan("\u2714"), "updated", `${displayPath(path19)}${detail ? `  (${detail})` : ""}`)}
+`
+    );
+  },
+  exists(path19, detail = "use --force to overwrite") {
+    process.stdout.write(`${line(pc.yellow("\u26A0"), "exists", `${displayPath(path19)}  (${detail})`)}
+`);
+  },
+  dryRun(path19) {
+    process.stdout.write(`${line(pc.blue("\u2139"), "dry-run", displayPath(path19))}
+`);
+  },
+  error(message) {
+    process.stderr.write(`${line(pc.red("\u2716"), "error", message)}
+`);
+  },
+  done(message) {
+    process.stdout.write(`
+  ${pc.bold("Done.")} ${message}
+`);
+  }
+};
+
+// src/platform/cli/web/utils/write-file.ts
+import fs2 from "fs";
+import path3 from "path";
+function writeFileIfAllowed(filePath, content, options = {}) {
+  const exists = fs2.existsSync(filePath);
+  if (options.dryRun) {
+    logger.dryRun(filePath);
+    return "dry-run";
+  }
+  if (exists && !options.force) {
+    logger.exists(filePath);
+    return "exists";
+  }
+  fs2.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs2.writeFileSync(filePath, content, "utf8");
+  const mode = options.mode ?? (exists ? "updated" : "created");
+  if (mode === "updated") {
+    logger.updated(filePath);
+  } else {
+    logger.created(filePath);
+  }
+  return mode;
+}
+
+// src/platform/cli/web/commands/web-sync.ts
+function toTypeName(raw) {
+  return raw.replace(/[^a-zA-Z0-9]+/g, " ").split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function toIdentifier(raw) {
+  const cleaned = raw.replace(/[^a-zA-Z0-9]+/g, " ").split(" ").filter(Boolean).map(
+    (part, idx) => idx === 0 ? part.charAt(0).toLowerCase() + part.slice(1) : part.charAt(0).toUpperCase() + part.slice(1)
+  ).join("");
+  return cleaned || "value";
+}
+function toConstKey(value) {
+  return value.replace(/[{}]/g, "").replace(/[^a-zA-Z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toUpperCase();
+}
+function toFileName(raw) {
+  const out = raw.trim().replace(/([a-z\d])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  return out || "default";
+}
+function resolveRefName(ref) {
+  const parts = ref.split("/");
+  return parts[parts.length - 1] || "UnknownRef";
+}
+function schemaToTs(schema) {
+  if (!schema) return "unknown";
+  if (schema.$ref) {
+    return toTypeName(resolveRefName(schema.$ref));
+  }
+  if (schema.oneOf?.length) {
+    return schema.oneOf.map((s) => schemaToTs(s)).join(" | ");
+  }
+  if (schema.anyOf?.length) {
+    return schema.anyOf.map((s) => schemaToTs(s)).join(" | ");
+  }
+  if (schema.allOf?.length) {
+    return schema.allOf.map((s) => schemaToTs(s)).join(" & ");
+  }
+  if (schema.enum?.length) {
+    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+  }
+  switch (schema.type) {
+    case "integer":
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return `${schemaToTs(schema.items)}[]`;
+    case "object": {
+      const properties = schema.properties || {};
+      const required = new Set(schema.required || []);
+      const fields = Object.entries(properties).map(
+        ([key, prop]) => `${key}${required.has(key) ? "" : "?"}: ${schemaToTs(prop)};`
+      );
+      if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+        fields.push(`[key: string]: ${schemaToTs(schema.additionalProperties)};`);
+      }
+      if (fields.length === 0) {
+        return "Record<string, unknown>";
+      }
+      return `{ ${fields.join(" ")} }`;
+    }
+    case "string":
+    default:
+      return "string";
+  }
+}
+function buildDtos(doc, source) {
+  const schemas = doc.components?.schemas || {};
+  const blocks = Object.entries(schemas).map(([rawName, schema]) => {
+    const name = toTypeName(rawName);
+    if (schema.type === "object" || schema.properties || schema.allOf?.length) {
+      const properties = schema.properties || {};
+      const required = new Set(schema.required || []);
+      const fields = Object.entries(properties).map(([key, prop]) => `  ${key}${required.has(key) ? "" : "?"}: ${schemaToTs(prop)};`).join("\n");
+      if (fields) {
+        return `export interface ${name} {
+${fields}
+}`;
+      }
+      return `export type ${name} = ${schemaToTs(schema)};`;
+    }
+    return `export type ${name} = ${schemaToTs(schema)};`;
+  });
+  return `${autoGeneratedSyncHeader(source)}
+
+${blocks.join("\n\n")}
+`;
+}
+function getPreferredSchema(response) {
+  if (!response?.content) return void 0;
+  const appJson = response.content["application/json"]?.schema;
+  if (appJson) return appJson;
+  const first = Object.values(response.content)[0];
+  return first?.schema;
+}
+function getSuccessResponseTypes(operation) {
+  const responses = operation.responses || {};
+  const types = [];
+  Object.entries(responses).forEach(([code, response]) => {
+    if (!/^2\d\d$/.test(code)) return;
+    const schema = getPreferredSchema(response);
+    types.push(schemaToTs(schema));
+  });
+  const unique = Array.from(new Set(types.filter(Boolean)));
+  return unique.length ? unique : ["unknown"];
+}
+function getRequestBodySchema(operation) {
+  const content = operation.requestBody?.content;
+  if (!content) return void 0;
+  const appJson = content["application/json"]?.schema;
+  if (appJson) return appJson;
+  const first = Object.values(content)[0];
+  return first?.schema;
+}
+function toFunctionName(route, method, operationId) {
+  if (operationId) return toIdentifier(operationId);
+  const routePart = route.replace(/[{}]/g, "").split("/").filter(Boolean).map((part) => toTypeName(part)).join("");
+  return toIdentifier(`${method}${routePart || "Root"}`);
+}
+function buildPathTemplate(route) {
+  return "`" + route.replace(/\{([^}]+)\}/g, (_, token) => `\${${toIdentifier(token)}}`) + "`";
+}
+function buildServiceFunction(descriptor) {
+  const { method, route, operation } = descriptor;
+  const fn = toFunctionName(route, method, operation.operationId);
+  const responseTypeName = `${toTypeName(fn)}Response`;
+  const responseUnion = getSuccessResponseTypes(operation).join(" | ");
+  const requestType = schemaToTs(getRequestBodySchema(operation));
+  const allParams = operation.parameters || [];
+  const pathParams = allParams.filter((p) => p.in === "path");
+  const queryParams = allParams.filter((p) => p.in === "query");
+  const args = [];
+  pathParams.forEach((param) => {
+    args.push(`${toIdentifier(param.name)}: ${schemaToTs(param.schema)}`);
+  });
+  if (requestType !== "unknown" && ["post", "put", "patch"].includes(method)) {
+    args.push(`payload${operation.requestBody?.required ? "" : "?"}: ${requestType}`);
+  }
+  if (queryParams.length) {
+    const queryType = `{ ${queryParams.map((p) => `${toIdentifier(p.name)}${p.required ? "" : "?"}: ${schemaToTs(p.schema)};`).join(" ")} }`;
+    args.push(`query?: ${queryType}`);
+  }
+  const pathExpr = buildPathTemplate(route);
+  if (method === "get") {
+    return `export type ${responseTypeName} = ${responseUnion};
+
+export async function ${fn}(${args.join(", ")}): Promise<${responseTypeName}> {
+  return FragmentFetch.get<${responseTypeName}>(${pathExpr}${queryParams.length ? ", { params: query }" : ""});
+}`;
+  }
+  if (method === "delete") {
+    return `export type ${responseTypeName} = ${responseUnion};
+
+export async function ${fn}(${args.join(", ")}): Promise<${responseTypeName}> {
+  return FragmentFetch.delete<${responseTypeName}>(${pathExpr}${queryParams.length ? ", { params: query }" : ""});
+}`;
+  }
+  const methodCall = method === "post" ? "post" : method === "put" ? "put" : "patch";
+  const bodyArg = requestType !== "unknown" ? "payload" : "undefined";
+  return `export type ${responseTypeName} = ${responseUnion};
+
+export async function ${fn}(${args.join(", ")}): Promise<${responseTypeName}> {
+  return FragmentFetch.${methodCall}<${responseTypeName}>(${pathExpr}, ${bodyArg}${queryParams.length ? ", { params: query }" : ""});
+}`;
+}
+function groupOperationsByTag(doc) {
+  const byTag = {};
+  Object.entries(doc.paths || {}).forEach(([route, methods]) => {
+    ["get", "post", "put", "patch", "delete"].forEach((method) => {
+      const operation = methods?.[method];
+      if (!operation) return;
+      const tags = operation.tags?.length ? operation.tags : ["default"];
+      tags.forEach((tag) => {
+        byTag[tag] = byTag[tag] || [];
+        byTag[tag].push({ route, method, operation });
+      });
+    });
+  });
+  return byTag;
+}
+function buildTagServiceFile(tag, operations, source) {
+  const fns = operations.map((op) => buildServiceFunction(op));
+  return `${autoGeneratedSyncHeader(source)}
+
+import { FragmentFetch } from 'fragment-web';
+
+${fns.join("\n\n")}
+`;
+}
+function buildRootServiceBarrel(tags, source) {
+  const exports = tags.map((tag) => `export * from './services/${toFileName(tag)}.service';`).join("\n");
+  return `${autoGeneratedSyncHeader(source)}
+
+${exports}
+`;
+}
+function buildServicesIndex(tags, source) {
+  const exports = tags.map((tag) => `export * from './${toFileName(tag)}.service';`).join("\n");
+  return `${autoGeneratedSyncHeader(source)}
+
+${exports}
+`;
+}
+function buildRoutes(doc, source) {
+  const lines = Object.keys(doc.paths || {}).map((route) => `  ${toConstKey(route)}: '${route}',`);
+  return `${autoGeneratedSyncHeader(source)}
+
+export const ApiRoutes = {
+${lines.join("\n")}
+} as const;
+`;
+}
+async function fetchOpenApi(source) {
+  const response = await fetch(source);
+  if (!response.ok) {
+    throw new Error(`Could not connect to ${source}`);
+  }
+  return await response.json();
+}
+async function syncOnce(options) {
+  const config2 = ensureWebConfig();
+  const base = (options.url || config2.fetch.baseUrl).replace(/\/$/, "");
+  const source = `${base}${config2.serverRoot}/docs/api-json`;
+  const generatedDir = path4.join(process.cwd(), "src/generated");
+  const servicesDir = path4.join(generatedDir, "services");
+  const doc = await fetchOpenApi(source);
+  writeFileIfAllowed(path4.join(generatedDir, "routes.ts"), buildRoutes(doc, source), {
+    dryRun: options.dryRun,
+    force: true
+  });
+  writeFileIfAllowed(path4.join(generatedDir, "dtos.ts"), buildDtos(doc, source), {
+    dryRun: options.dryRun,
+    force: true
+  });
+  const grouped = groupOperationsByTag(doc);
+  const tags = Object.keys(grouped).sort();
+  const expectedServiceFiles = new Set(tags.map((tag) => `${toFileName(tag)}.service.ts`));
+  if (fs3.existsSync(servicesDir)) {
+    const existing = fs3.readdirSync(servicesDir);
+    existing.filter((file) => file.endsWith(".service.ts")).filter((file) => !expectedServiceFiles.has(file)).forEach((staleFile) => {
+      const stalePath = path4.join(servicesDir, staleFile);
+      if (options.dryRun) {
+        logger.dryRun(stalePath);
+        return;
+      }
+      fs3.unlinkSync(stalePath);
+      logger.updated(stalePath, "removed stale generated file");
+    });
+  }
+  tags.forEach((tag) => {
+    writeFileIfAllowed(path4.join(servicesDir, `${toFileName(tag)}.service.ts`), buildTagServiceFile(tag, grouped[tag], source), {
+      dryRun: options.dryRun,
+      force: true
+    });
+  });
+  writeFileIfAllowed(path4.join(servicesDir, "index.ts"), buildServicesIndex(tags, source), {
+    dryRun: options.dryRun,
+    force: true
+  });
+  writeFileIfAllowed(path4.join(generatedDir, "services.ts"), buildRootServiceBarrel(tags, source), {
+    dryRun: options.dryRun,
+    force: true
+  });
+}
+async function runWebSync(options = {}) {
+  await syncOnce(options);
+  if (options.watch) {
+    logger.section("fragment-web", "web:sync --watch");
+    setInterval(() => {
+      syncOnce(options).catch((error) => {
+        logger.error(error instanceof Error ? error.message : "web:sync watch failed");
+      });
+    }, 5e3);
+  }
+}
+function registerWebSync(program) {
+  program.command("web:sync").description("Generate typed web API artifacts into src/generated").option("--url <url>", "Backend base URL").option("--watch", "Watch and resync").option("--dry-run", "Preview changes").action((opts) => {
+    runWebSync(opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "web:sync failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/commands/make/component.ts
+import path6 from "path";
+
+// src/platform/cli/web/utils/names.ts
+function normalizeName(input) {
+  return input.trim().replace(/([a-z\d])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function toKebabCase(input) {
+  const normalized = normalizeName(input);
+  return normalized || "app";
+}
+function toPascalCase(input) {
+  return toKebabCase(input).split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+
+// src/platform/cli/web/utils/resolve-paths.ts
+import path5 from "path";
+function domainOrName(input) {
+  return toKebabCase(input.domain || input.name);
+}
+function resolveOutputDir(input) {
+  const dom = domainOrName(input);
+  const leaf = toKebabCase(input.name);
+  switch (input.mode) {
+    case "layered":
+      switch (input.kind) {
+        case "component":
+          return path5.join("src", "components", leaf);
+        case "page":
+          return path5.join("src", "pages", leaf);
+        case "service":
+          return path5.join("src", "services");
+        case "store":
+          return path5.join("src", "stores");
+        case "guard":
+          return path5.join("src", "guards");
+        case "layout":
+          return path5.join("src", "layouts");
+        default:
+          throw new Error(`${input.kind} is not available in layered mode`);
+      }
+    case "module":
+      switch (input.kind) {
+        case "component":
+          return path5.join("src", "modules", dom, "components");
+        case "page":
+        case "service":
+        case "store":
+          return path5.join("src", "modules", dom);
+        case "guard":
+          return path5.join("src", "shared", "guards");
+        case "layout":
+          return path5.join("src", "shared", "layouts");
+        default:
+          throw new Error(`${input.kind} is not available in module mode`);
+      }
+    case "feature":
+      switch (input.kind) {
+        case "component":
+          return path5.join("src", "features", dom, "components");
+        case "page":
+          return path5.join("src", "features", dom, "pages");
+        case "service":
+          return path5.join("src", "features", dom, "services");
+        case "store":
+          return path5.join("src", "features", dom, "stores");
+        case "guard":
+          return path5.join("src", "shared", "guards");
+        case "layout":
+          return path5.join("src", "shared", "layouts");
+        default:
+          throw new Error(`${input.kind} is not available in feature mode`);
+      }
+    case "mvvm":
+      switch (input.kind) {
+        case "component":
+        case "page":
+          return path5.join("src", "app", dom, "view");
+        case "service":
+        case "store":
+        case "viewmodel":
+          return path5.join("src", "app", dom, "viewmodel");
+        case "model":
+          return path5.join("src", "app", dom, "model");
+        case "guard":
+          return path5.join("src", "shared", "guards");
+        case "layout":
+          return path5.join("src", "shared", "layouts");
+        default:
+          throw new Error(`${input.kind} is not available in mvvm mode`);
+      }
+    default:
+      return path5.join("src");
+  }
+}
+
+// src/platform/cli/web/commands/make/component.ts
+function parseState(state) {
+  if (!state) return [];
+  return state.split(",").map((it) => it.trim()).filter(Boolean).map((pair) => {
+    const [key, type] = pair.split(":").map((v) => v.trim());
+    return { key, type: type || "unknown" };
+  });
+}
+async function runMakeComponent(name, options = {}) {
+  const config2 = ensureWebConfig();
+  const mode = options.structure || config2.structure;
+  const domain = options.feature || options.module;
+  const outDir = resolveOutputDir({ mode, kind: "component", name, domain });
+  const fileName = `${toKebabCase(name)}.component.tsx`;
+  const className = `${toPascalCase(name)}Component`;
+  const stateFields = parseState(options.state);
+  const injected = (options.inject || "").split(",").map((v) => v.trim()).filter(Boolean);
+  const decoratorArgs = [
+    `tag: '${toKebabCase(name)}'`,
+    options.memo ? "memo: true" : "",
+    `displayName: '${className}'`
+  ].filter(Boolean).join(", ");
+  const stateDecl = stateFields.map((field) => `  @State(undefined as ${field.type})
+  ${field.key}!: ${field.type};`).join("\n\n");
+  const injectDecl = injected.map((token) => `  @Inject('${token}')
+  ${toKebabCase(token).replace(/-([a-z])/g, (_, c) => c.toUpperCase())}: unknown;`).join("\n\n");
+  const content = `// Generated by: frg make:component ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import React from 'react';
+import { Component, Inject, State } from 'fragment-web';
+
+@Component({ ${decoratorArgs} })
+export class ${className} {
+${injectDecl ? `${injectDecl}
+
+` : ""}${stateDecl ? `${stateDecl}
+
+` : ""}  render(): JSX.Element {
+    return <div>${toPascalCase(name)} component</div>;
+  }
+}
+`;
+  writeFileIfAllowed(path6.join(process.cwd(), outDir, fileName), content, options);
+}
+function registerMakeComponent(program) {
+  program.command("make:component <name>").description("Generate a frontend component").option("--memo", "Enable component memo hint").option("--state <fields>", "CSV field:type list").option("--inject <services>", "CSV of injected service tokens").option("--structure <mode>", "Override structure mode").option("--module <name>", "Module name").option("--feature <name>", "Feature name").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runMakeComponent(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "make:component failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/commands/make/page.ts
+import path7 from "path";
+function parseCsv(value) {
+  if (!value) return [];
+  return value.split(",").map((v) => v.trim()).filter(Boolean);
+}
+async function runMakePage(name, options = {}) {
+  const config2 = ensureWebConfig();
+  const mode = options.structure || config2.structure;
+  const domain = options.feature || options.module;
+  const outDir = resolveOutputDir({ mode, kind: "page", name, domain });
+  const fileName = `${toKebabCase(name)}.page.tsx`;
+  const className = `${toPascalCase(name)}Page`;
+  const route = options.path || `/${toKebabCase(name)}`;
+  const guard = options.guard?.trim();
+  const params = parseCsv(options.params);
+  const query = (options.query || "").split(",").map((v) => v.trim()).filter(Boolean);
+  const paramsDecl = params.map((p) => `  @Param('${p}')
+  ${p}!: string;`).join("\n\n");
+  const queryDecl = query.map((q) => {
+    const [key, def] = q.split(":").map((v) => v.trim());
+    return `  @Query('${key}'${def ? `, '${def}'` : ""})
+  ${key}!: string;`;
+  }).join("\n\n");
+  const content = `// Generated by: frg make:page ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import React from 'react';
+import { Guard, Page, Param, Query } from 'fragment-web';
+${guard ? `import { ${guard} } from '../guards/${toKebabCase(guard)}.guard';
+` : ""}
+@Page({ path: '${route}', title: '${toPascalCase(name)}' })
+${guard ? `@Guard(${guard})
+` : ""}export class ${className} {
+${paramsDecl ? `${paramsDecl}
+
+` : ""}${queryDecl ? `${queryDecl}
+
+` : ""}  render(): JSX.Element {
+    return <div>${toPascalCase(name)} page</div>;
+  }
+}
+`;
+  writeFileIfAllowed(path7.join(process.cwd(), outDir, fileName), content, options);
+}
+function registerMakePage(program) {
+  program.command("make:page <name>").description("Generate a frontend page").option("--path <path>", "Route path").option("--guard <guard>", "Guard class name").option("--params <keys>", "CSV route param names").option("--query <pairs>", "CSV queryKey[:default] list").option("--structure <mode>", "Override structure mode").option("--module <name>", "Module name").option("--feature <name>", "Feature name").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runMakePage(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "make:page failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/commands/make/service.ts
+import fs8 from "fs";
+import path12 from "path";
+
+// src/shared/config.utils.ts
+import * as fs6 from "fs";
+import * as path10 from "path";
+
+// src/shared/env.utils.ts
+import * as fs4 from "fs";
+import * as path8 from "path";
+import * as dotenv from "dotenv";
+var EnvUtils = class {
+  static loadEnvironment(cwd = process.cwd()) {
+    if (this.loaded) return;
+    const envPath = path8.join(cwd, ".env");
+    if (fs4.existsSync(envPath)) {
+      dotenv.config({ path: envPath, override: true });
+    }
+    this.loaded = true;
+  }
+  static resolveMode(cwd = process.cwd()) {
+    if (this.resolvedMode) return this.resolvedMode;
+    const projectRoot = path8.resolve(cwd).replace(/\\/g, "/");
+    const entryArg = process.argv[1] ? path8.resolve(process.argv[1]) : "";
+    const entryPath = entryArg.replace(/\\/g, "/");
+    const entryInsideProject = entryPath.length > 0 && (entryPath === projectRoot || entryPath.startsWith(`${projectRoot}/`));
+    if (entryInsideProject) {
+      if (entryPath.includes("/dist/")) {
+        this.resolvedMode = "production";
+        return this.resolvedMode;
+      }
+      if (entryPath.includes("/src/") || entryPath.endsWith(".ts")) {
+        this.resolvedMode = "development";
+        return this.resolvedMode;
+      }
+    }
+    const hasSrc = fs4.existsSync(path8.join(projectRoot, "src"));
+    const hasDist = fs4.existsSync(path8.join(projectRoot, "dist"));
+    if (hasSrc && !hasDist) {
+      this.resolvedMode = "development";
+      return this.resolvedMode;
+    }
+    if (!hasSrc && hasDist) {
+      this.resolvedMode = "production";
+      return this.resolvedMode;
+    }
+    if (hasSrc && hasDist) {
+      this.resolvedMode = "development";
+      return this.resolvedMode;
+    }
+    this.resolvedMode = "production";
+    return this.resolvedMode;
+  }
+  static getString(key, defaultValue) {
+    this.loadEnvironment();
+    const value = process.env[key];
+    return value !== void 0 ? value : defaultValue ?? "";
+  }
+  static getBoolean(key, defaultValue = false) {
+    this.loadEnvironment();
+    const value = process.env[key];
+    if (value === void 0) return defaultValue;
+    return ["true", "1", "yes", "on"].includes(value.toLowerCase());
+  }
+  static getNumber(key, defaultValue = 0) {
+    this.loadEnvironment();
+    const value = process.env[key];
+    if (value === void 0) return defaultValue;
+    const num = Number(value);
+    return isNaN(num) ? defaultValue : num;
+  }
+  static getJson(key, defaultValue) {
+    this.loadEnvironment();
+    const value = process.env[key];
+    if (value === void 0) return defaultValue;
+    try {
+      return JSON.parse(value);
+    } catch {
+      console.warn(`\u26A0\uFE0F Invalid JSON in env var ${key}, using default`);
+      return defaultValue;
+    }
+  }
+  /**
+   * Check if running in development mode.
+   * Mode is inferred from runtime/project layout, not from env file variants.
+   */
+  static isDevelopmentMode() {
+    this.loadEnvironment();
+    return this.resolveMode() === "development";
+  }
+  /**
+   * Get current environment mode ('development' or 'production')
+   */
+  static getEnvironmentMode() {
+    this.loadEnvironment();
+    return this.resolveMode();
+  }
+};
+EnvUtils.loaded = false;
+EnvUtils.resolvedMode = null;
+
+// src/shared/tsconfig.utils.ts
+import * as fs5 from "fs";
+import * as path9 from "path";
+var TsConfigUtils = class {
+  static loadConfig() {
+    if (this.configCache) return this.configCache;
+    for (const file of this.DEFAULT_PATHS) {
+      const fullPath = path9.join(process.cwd(), file);
+      if (fs5.existsSync(fullPath)) {
+        try {
+          this.configCache = JSON.parse(fs5.readFileSync(fullPath, "utf8"));
+          if (!this.configCache) return {};
+          return this.configCache;
+        } catch {
+        }
+      }
+    }
+    this.configCache = {};
+    return this.configCache;
+  }
+  static exists() {
+    return this.DEFAULT_PATHS.some(
+      (f) => fs5.existsSync(path9.join(process.cwd(), f))
+    );
+  }
+  static hasDecoratorSupport() {
+    const config2 = this.loadConfig();
+    const opts = config2.compilerOptions || {};
+    return !!opts.experimentalDecorators && !!opts.emitDecoratorMetadata;
+  }
+  static getRootDir() {
+    const config2 = this.loadConfig();
+    const rootDir = config2.compilerOptions?.rootDir || "src";
+    return path9.isAbsolute(rootDir) ? rootDir : path9.join(process.cwd(), rootDir);
+  }
+  static getOutDir() {
+    const config2 = this.loadConfig();
+    const outDir = config2.compilerOptions?.outDir || "dist";
+    return path9.isAbsolute(outDir) ? outDir : path9.join(process.cwd(), outDir);
+  }
+  static getIncludePatterns() {
+    const config2 = this.loadConfig();
+    return config2.include || ["src/**/*"];
+  }
+};
+TsConfigUtils.configCache = null;
+TsConfigUtils.DEFAULT_PATHS = ["tsconfig.json"];
+
+// src/shared/config.utils.ts
+var ConfigUtils = class {
+  static loadConfig() {
+    if (this.configCache) return this.configCache;
+    EnvUtils.loadEnvironment();
+    const configPath = path10.join(process.cwd(), "fragment.json");
+    const cachePath = path10.join(process.cwd(), "fragment.cache.json");
+    const sourcePath = fs6.existsSync(cachePath) ? cachePath : configPath;
+    if (!fs6.existsSync(sourcePath)) {
+      this.configCache = {};
+      return this.configCache;
+    }
+    try {
+      this.configCache = JSON.parse(fs6.readFileSync(sourcePath, "utf8")) || {};
+      if (!this.configCache) return {};
+      return this.configCache;
+    } catch (error) {
+      console.error("\u274C Error loading fragment config:", error);
+      this.configCache = {};
+      return this.configCache;
+    }
+  }
+  static interpolateEnvVars(value) {
+    if (typeof value === "string") {
+      return value.replace(
+        /\$\{([^}]+)\}/g,
+        (_match, expression) => {
+          const [rawKey, ...fallbackParts] = String(expression).split(":");
+          const key = rawKey.trim();
+          const fallback = fallbackParts.length > 0 ? fallbackParts.join(":").trim() : void 0;
+          return EnvUtils.getString(key, fallback) || "";
+        }
+      );
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.interpolateEnvVars(item));
+    }
+    if (value !== null && typeof value === "object") {
+      const result = {};
+      for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          result[key] = this.interpolateEnvVars(value[key]);
+        }
+      }
+      return result;
+    }
+    return value;
+  }
+  static getDatabaseConfig() {
+    const config2 = this.loadConfig();
+    if (!config2.database) return {};
+    let dbConfig = this.interpolateEnvVars(config2.database);
+    const isProduction = EnvUtils.getEnvironmentMode() === "production";
+    const rootDir = TsConfigUtils.getRootDir().replace(/\\/g, "/");
+    const outDir = TsConfigUtils.getOutDir().replace(/\\/g, "/");
+    if (Array.isArray(dbConfig.entities)) {
+      dbConfig.entities = dbConfig.entities.map(
+        (pattern) => this.toRuntimePathPattern(pattern, isProduction, rootDir, outDir)
+      );
+    }
+    if (Array.isArray(dbConfig.migrations)) {
+      dbConfig.migrations = dbConfig.migrations.map(
+        (pattern) => this.toRuntimePathPattern(pattern, isProduction, rootDir, outDir)
+      );
+    }
+    return dbConfig;
+  }
+  static toRuntimePathPattern(pattern, isProduction, rootDir, outDir) {
+    if (typeof pattern !== "string") return pattern;
+    const normalized = pattern.replace(/\\/g, "/");
+    if (!isProduction) return normalized;
+    const jsPattern = normalized.replace(/\.ts$/i, ".js");
+    const normalizedRoot = rootDir.replace(/\\/g, "/").replace(/\/+$/, "");
+    const normalizedOut = outDir.replace(/\\/g, "/").replace(/\/+$/, "");
+    const relativeRoot = path10.relative(process.cwd(), normalizedRoot).replace(/\\/g, "/").replace(/\/+$/, "");
+    const prefixCandidates = Array.from(
+      new Set(
+        [
+          `${normalizedRoot}/`,
+          relativeRoot ? `${relativeRoot}/` : "",
+          relativeRoot ? `./${relativeRoot}/` : "",
+          "src/",
+          "./src/"
+        ].filter(Boolean)
+      )
+    );
+    for (const prefix of prefixCandidates) {
+      if (jsPattern.startsWith(prefix)) {
+        return `${normalizedOut}/${jsPattern.slice(prefix.length)}`;
+      }
+    }
+    return jsPattern;
+  }
+  static getDatabaseProperty(property, defaultValue) {
+    const dbConfig = this.getDatabaseConfig();
+    return dbConfig[property] !== void 0 ? dbConfig[property] : defaultValue;
+  }
+  static getFullConfig() {
+    return this.loadConfig();
+  }
+  static getResolvedConfig() {
+    const config2 = this.getFullConfig();
+    return this.interpolateEnvVars(config2);
+  }
+  static isDatabaseEnabled() {
+    return !!this.getFullConfig().database;
+  }
+  static getVerbose() {
+    return this.getFullConfig().verbose === true;
+  }
+  static getLoggingConfig() {
+    return this.getFullConfig().logging || {};
+  }
+  static getMailConfig() {
+    return this.getResolvedConfig().mail || {};
+  }
+  static getNotificationsConfig() {
+    return this.getResolvedConfig().notifications || {};
+  }
+  static getDocsConfig() {
+    return this.getResolvedConfig().docs || {};
+  }
+  static getMailers() {
+    const mail = this.getMailConfig();
+    if (mail.mailers) {
+      if (Array.isArray(mail.mailers)) {
+        return mail.mailers.map((entry) => ({
+          ...entry,
+          name: entry.name || entry.qualifier
+        }));
+      }
+      return Object.entries(mail.mailers).map(([name, entry]) => ({
+        ...entry,
+        name
+      }));
+    }
+    const hasSingleConfig = mail.driver || mail.host || mail.port || mail.username || mail.password || mail.from || mail.apiKey;
+    if (hasSingleConfig) {
+      const { mailers, default: defaultName, ...single } = mail;
+      return [
+        {
+          name: defaultName || "default",
+          ...single
+        }
+      ];
+    }
+    return [];
+  }
+  static getDefaultMailer() {
+    const mail = this.getMailConfig();
+    if (mail.default) return mail.default;
+    const mailers = this.getMailers();
+    if (mailers.length === 1) return mailers[0].name || mailers[0].qualifier;
+    return void 0;
+  }
+  static getMailerConfig(name) {
+    const mailers = this.getMailers();
+    if (mailers.length === 0) return void 0;
+    if (name) {
+      return mailers.find(
+        (mailer) => mailer.name === name || mailer.qualifier === name
+      );
+    }
+    const defaultName = this.getDefaultMailer();
+    if (defaultName) {
+      return mailers.find(
+        (mailer) => mailer.name === defaultName || mailer.qualifier === defaultName
+      );
+    }
+    if (mailers.length === 1) return mailers[0];
+    return void 0;
+  }
+  static getPlugins() {
+    const config2 = this.getFullConfig();
+    const list = config2.plugins || [];
+    return list.map((entry) => {
+      if (typeof entry === "string") {
+        return { name: entry };
+      }
+      return entry;
+    }).filter((entry) => entry && entry.enabled !== false);
+  }
+  static getPluginAutoQualify() {
+    return this.getFullConfig().pluginAutoQualify === true;
+  }
+  static getStructureType() {
+    const config2 = this.loadConfig();
+    return config2.structure?.type || "layered";
+  }
+  static updateConfig(updates) {
+    const current = this.loadConfig();
+    const merged = this.mergeDeep(current, updates);
+    this.writeConfig(merged);
+    return merged;
+  }
+  static setVerbose(verbose) {
+    return this.updateConfig({ verbose });
+  }
+  static clearCache() {
+    this.configCache = null;
+  }
+  static clearCacheFile() {
+    const cachePath = path10.join(process.cwd(), "fragment.cache.json");
+    if (fs6.existsSync(cachePath)) {
+      fs6.unlinkSync(cachePath);
+    }
+  }
+  static writeConfig(config2) {
+    const configPath = path10.join(process.cwd(), "fragment.json");
+    const payload = JSON.stringify(config2, null, 2);
+    fs6.writeFileSync(configPath, payload, "utf8");
+    this.configCache = config2;
+  }
+  static mergeDeep(target, source) {
+    const output = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+      if (value === void 0) continue;
+      if (value && typeof value === "object" && !Array.isArray(value) && typeof target[key] === "object" && target[key] !== null) {
+        output[key] = this.mergeDeep(target[key], value);
+      } else {
+        output[key] = value;
+      }
+    }
+    return output;
+  }
+};
+ConfigUtils.configCache = null;
+
+// src/platform/cli/scaffold/generate/component-generator.ts
+import * as fs7 from "fs-extra";
+import * as path11 from "path";
+
+// src/shared/errors.ts
+var FragmentError = class extends Error {
+  constructor(message, statusCode, details) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    this.details = details;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+var GenerateTypeError = class extends FragmentError {
+  constructor(message = "Unknown generate type", details) {
+    super(message, 400, details);
+  }
+};
+
+// src/platform/cli/scaffold/naming.ts
+var NamingUtils = class {
+  static capitalize(value) {
+    if (!value) return value;
+    return value.charAt(0).toUpperCase() + value.slice(1);
+  }
+  static camelCase(value) {
+    if (!value) return value;
+    const normalized = this.normalize(value);
+    return normalized.charAt(0).toLowerCase() + normalized.slice(1);
+  }
+  static pascalCase(value) {
+    if (!value) return value;
+    const normalized = this.normalize(value);
+    return this.capitalize(normalized);
+  }
+  static kebabCase(value) {
+    if (!value) return value;
+    return value.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").replace(/-+/g, "-").toLowerCase();
+  }
+  static normalize(value) {
+    return value.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[\-_]+/g, " ").split(" ").filter(Boolean).map((part) => this.capitalize(part.toLowerCase())).join("");
+  }
+};
+
+// src/platform/cli/scaffold/generate/component-generator.ts
+var ComponentGenerator = class {
+  constructor(structureType = ConfigUtils.getStructureType()) {
+    this.structureType = structureType;
+  }
+  async generate(type, name, options) {
+    switch (type) {
+      case "controller":
+        await this.generateController(name, options);
+        break;
+      case "service":
+        await this.generateService(
+          name,
+          options?.withRepository ?? false,
+          options
+        );
+        break;
+      case "resource":
+        await this.generateResource(name, options);
+        break;
+      case "entity":
+        await this.generateEntity(name);
+        break;
+      case "dto":
+        await this.generateDto(name);
+        break;
+      case "repository":
+        await this.generateRepository(name, options);
+        break;
+      case "middleware":
+        await this.generateMiddleware(name);
+        break;
+      case "guard":
+        await this.generateGuard(name);
+        break;
+      case "interceptor":
+        await this.generateInterceptor(name);
+        break;
+      case "filter":
+        await this.generateFilter(name);
+        break;
+      case "module":
+        await this.generateModule(name);
+        break;
+      case "feature":
+        await this.generateFeature(name);
+        break;
+      case "job":
+        await this.generateJob(name, options);
+        break;
+      case "mail":
+        await this.generateMail(name, options);
+        break;
+      case "notification":
+        await this.generateNotification(name, options);
+        break;
+      default:
+        throw new GenerateTypeError(`Unknown generate type: ${type}`);
+    }
+  }
+  getBasePath(subdir, options) {
+    const srcDir = TsConfigUtils.getRootDir();
+    let basePath = srcDir;
+    switch (this.structureType) {
+      case "module": {
+        const moduleName = options?.module || "app";
+        if (subdir && ["controllers", "services", "repositories"].includes(subdir)) {
+          basePath = path11.join(
+            srcDir,
+            "modules",
+            NamingUtils.kebabCase(moduleName),
+            subdir
+          );
+        } else if (subdir && ["jobs", "mail", "notifications"].includes(subdir)) {
+          basePath = path11.join(srcDir, "modules", subdir);
+        } else if (subdir && ["guards", "interceptors", "filters", "middlewares"].includes(subdir)) {
+          basePath = path11.join(srcDir, "common", subdir);
+        } else if (subdir) {
+          basePath = path11.join(srcDir, subdir);
+        }
+        break;
+      }
+      case "feature": {
+        const featureName = options?.feature || "app";
+        if (subdir && ["controllers", "services", "repositories"].includes(subdir)) {
+          basePath = path11.join(
+            srcDir,
+            "features",
+            NamingUtils.kebabCase(featureName)
+          );
+        } else if (subdir && ["jobs", "mail", "notifications"].includes(subdir)) {
+          basePath = path11.join(srcDir, "features", subdir);
+        } else if (subdir && ["guards", "interceptors", "filters", "middlewares"].includes(subdir)) {
+          basePath = path11.join(srcDir, "shared", subdir);
+        } else if (subdir) {
+          basePath = path11.join(srcDir, subdir);
+        }
+        break;
+      }
+      case "layered":
+      default: {
+        if (subdir) {
+          basePath = path11.join(srcDir, subdir);
+        }
+        break;
+      }
+    }
+    return basePath;
+  }
+  async generateController(name, options) {
+    const className = `${NamingUtils.pascalCase(name)}Controller`;
+    const fileName = `${NamingUtils.kebabCase(name)}.controller.ts`;
+    let filePath;
+    let serviceImport = "";
+    if (this.structureType === "feature") {
+      filePath = path11.join(this.getBasePath("controllers", options), fileName);
+      serviceImport = `import { ${NamingUtils.pascalCase(name)}Service } from './${NamingUtils.kebabCase(name)}.service';`;
+    } else {
+      filePath = path11.join(this.getBasePath("controllers", options), fileName);
+      serviceImport = `import { ${NamingUtils.pascalCase(name)}Service } from '../services/${NamingUtils.kebabCase(name)}.service';`;
+    }
+    const content = `import { Controller, Get, Post, Put, Delete, Body, Param, Autowired } from 'fragment-ts';
+${serviceImport}
+
+@Controller('/${NamingUtils.kebabCase(name)}')
+export class ${className} {
+  // @Autowired()
+  // private ${NamingUtils.camelCase(name)}Service!: ${NamingUtils.pascalCase(name)}Service;
+
+  @Get()
+  findAll() {
+    return [];
+  }
+
+  @Get('/:id')
+  findOne(@Param('id') id: string) {
+    return { id };
+  }
+
+  @Post()
+  create(@Body() body: any) {
+    return body;
+  }
+
+  @Put('/:id')
+  update(@Param('id') id: string, @Body() body: any) {
+    return { id, ...body };
+  }
+
+  @Delete('/:id')
+  delete(@Param('id') id: string) {
+    return { deleted: true, id };
+  }
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+  async generateService(name, withRepository, options) {
+    const className = `${NamingUtils.pascalCase(name)}Service`;
+    const fileName = `${NamingUtils.kebabCase(name)}.service.ts`;
+    let filePath;
+    let imports = "import { Service, Autowired } from 'fragment-ts';\n";
+    let repositoryProp = "";
+    filePath = path11.join(this.getBasePath("services", options), fileName);
+    if (withRepository) {
+      const repoName = `${NamingUtils.pascalCase(name)}Repository`;
+      let repoPath;
+      if (this.structureType === "module") {
+        repoPath = `../repositories/${NamingUtils.kebabCase(name)}.repository`;
+      } else if (this.structureType === "feature") {
+        repoPath = `./${NamingUtils.kebabCase(name)}.repository`;
+      } else {
+        repoPath = `../repositories/${NamingUtils.kebabCase(name)}.repository`;
+      }
+      imports += `import { ${repoName} } from '${repoPath}';
+`;
+      repositoryProp = `
+  @Autowired()
+  private ${NamingUtils.camelCase(name)}Repository!: ${repoName};
+`;
+    }
+    const content = `${imports}
+@Service()
+export class ${className} {${repositoryProp}
+  async findAll() {
+    return [];
+  }
+
+  async findOne(id: string) {
+    return { id };
+  }
+
+  async create(data: any) {
+    return data;
+  }
+
+  async update(id: string, data: any) {
+    return { id, ...data };
+  }
+
+  async delete(id: string) {
+    return { deleted: true, id };
+  }
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+    if (withRepository) {
+      await this.generateRepository(name, options);
+    }
+  }
+  async generateResource(name, options) {
+    await this.generateController(name, options);
+    await this.generateService(name, true, options);
+    await this.generateEntity(name);
+    await this.generateDto(name);
+  }
+  async generateModule(name) {
+    const srcDir = TsConfigUtils.getRootDir();
+    const modulePath = path11.join(
+      srcDir,
+      "modules",
+      NamingUtils.kebabCase(name)
+    );
+    await fs7.ensureDir(path11.join(modulePath, "controllers"));
+    await fs7.ensureDir(path11.join(modulePath, "services"));
+    const controllerContent = `import { Controller, Get, Autowired } from 'fragment-ts';
+import { ${NamingUtils.pascalCase(name)}Service } from '../services/${NamingUtils.kebabCase(name)}.service';
+
+@Controller('/${NamingUtils.kebabCase(name)}')
+export class ${NamingUtils.pascalCase(name)}Controller {
+  @Autowired()
+  private ${NamingUtils.camelCase(name)}Service!: ${NamingUtils.pascalCase(name)}Service;
+
+  @Get()
+  findAll() {
+    return this.${NamingUtils.camelCase(name)}Service.findAll();
+  }
+}
+`;
+    const serviceContent = `import { Service } from 'fragment-ts';
+
+@Service()
+export class ${NamingUtils.pascalCase(name)}Service {
+  async findAll() {
+    return [];
+  }
+}
+`;
+    await fs7.writeFile(
+      path11.join(
+        modulePath,
+        "controllers",
+        `${NamingUtils.kebabCase(name)}.controller.ts`
+      ),
+      controllerContent
+    );
+    await fs7.writeFile(
+      path11.join(
+        modulePath,
+        "services",
+        `${NamingUtils.kebabCase(name)}.service.ts`
+      ),
+      serviceContent
+    );
+  }
+  async generateFeature(name) {
+    const srcDir = TsConfigUtils.getRootDir();
+    const featurePath = path11.join(
+      srcDir,
+      "features",
+      NamingUtils.kebabCase(name)
+    );
+    await fs7.ensureDir(featurePath);
+    const controllerContent = `import { Controller, Get, Autowired } from 'fragment-ts';
+import { ${NamingUtils.pascalCase(name)}Service } from './${NamingUtils.kebabCase(name)}.service';
+
+@Controller('/${NamingUtils.kebabCase(name)}')
+export class ${NamingUtils.pascalCase(name)}Controller {
+  @Autowired()
+  private ${NamingUtils.camelCase(name)}Service!: ${NamingUtils.pascalCase(name)}Service;
+
+  @Get()
+  findAll() {
+    return this.${NamingUtils.camelCase(name)}Service.findAll();
+  }
+}
+`;
+    const serviceContent = `import { Service } from 'fragment-ts';
+
+@Service()
+export class ${NamingUtils.pascalCase(name)}Service {
+  async findAll() {
+    return [];
+  }
+}
+`;
+    await fs7.writeFile(
+      path11.join(featurePath, `${NamingUtils.kebabCase(name)}.controller.ts`),
+      controllerContent
+    );
+    await fs7.writeFile(
+      path11.join(featurePath, `${NamingUtils.kebabCase(name)}.service.ts`),
+      serviceContent
+    );
+  }
+  async generateEntity(name) {
+    const className = NamingUtils.pascalCase(name);
+    const fileName = `${NamingUtils.kebabCase(name)}.entity.ts`;
+    const srcDir = TsConfigUtils.getRootDir();
+    const filePath = path11.join(srcDir, "entities", fileName);
+    const content = `import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from 'fragment-ts';
+
+@Entity()
+export class ${className} {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  name: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+  async generateDto(name) {
+    const className = `Create${NamingUtils.pascalCase(name)}Dto`;
+    const fileName = `create-${NamingUtils.kebabCase(name)}.dto.ts`;
+    const srcDir = TsConfigUtils.getRootDir();
+    const filePath = path11.join(srcDir, "dto", fileName);
+    const content = `export class ${className} {
+  name: string;
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+  async generateRepository(name, options) {
+    const className = `${NamingUtils.pascalCase(name)}Repository`;
+    const entityName = NamingUtils.pascalCase(name);
+    const fileName = `${NamingUtils.kebabCase(name)}.repository.ts`;
+    let filePath;
+    let entityImport;
+    if (this.structureType === "module") {
+      filePath = path11.join(this.getBasePath("repositories", options), fileName);
+      entityImport = `import { ${entityName} } from '../../../entities/${NamingUtils.kebabCase(name)}.entity';`;
+    } else if (this.structureType === "feature") {
+      filePath = path11.join(this.getBasePath("repositories", options), fileName);
+      entityImport = `import { ${entityName} } from '../../entities/${NamingUtils.kebabCase(name)}.entity';`;
+    } else {
+      filePath = path11.join(this.getBasePath("repositories", options), fileName);
+      entityImport = `import { ${entityName} } from '../entities/${NamingUtils.kebabCase(name)}.entity';`;
+    }
+    const content = `import { Repository, InjectRepository } from 'fragment-ts';
+${entityImport}
+import { Repository as TypeOrmRepository } from 'fragment-ts';
+
+@Repository()
+export class ${className} {
+  @InjectRepository(${entityName})
+  private repo!: TypeOrmRepository<${entityName}>;
+
+  async findAll(): Promise<${entityName}[]> {
+    return this.repo.find();
+  }
+
+  async findById(id: number): Promise<${entityName} | null> {
+    return this.repo.findOneBy({ id });
+  }
+
+  async create(data: Partial<${entityName}>): Promise<${entityName}> {
+    const entity = this.repo.create(data);
+    return this.repo.save(entity);
+  }
+
+  async update(id: number, data: Partial<${entityName}>): Promise<${entityName} | null> {
+    await this.repo.update(id, data);
+    return this.findById(id);
+  }
+
+  async delete(id: number): Promise<boolean> {
+    const result = await this.repo.delete(id);
+    return result.affected > 0;
+  }
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+  async generateMiddleware(name) {
+    const className = `${NamingUtils.pascalCase(name)}Middleware`;
+    const fileName = `${NamingUtils.kebabCase(name)}.middleware.ts`;
+    const filePath = path11.join(this.getBasePath("middlewares"), fileName);
+    const content = `import { Injectable, express } from 'fragment-ts';
+
+@Injectable()
+export class ${className} {
+  use(req: express.Request, res: express.Response, next: express.NextFunction): void {
+    // Add your middleware logic here
+    next();
+  }
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+  async generateGuard(name) {
+    const className = `${NamingUtils.pascalCase(name)}Guard`;
+    const fileName = `${NamingUtils.kebabCase(name)}.guard.ts`;
+    const filePath = path11.join(this.getBasePath("guards"), fileName);
+    const content = `import { Injectable, express } from 'fragment-ts';
+
+@Injectable()
+export class ${className} {
+  canActivate(req: express.Request): boolean {
+    // Add your authorization logic here
+    // Return true to allow access, false to deny
+    return true;
+  }
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+  async generateInterceptor(name) {
+    const className = `${NamingUtils.pascalCase(name)}Interceptor`;
+    const fileName = `${NamingUtils.kebabCase(name)}.interceptor.ts`;
+    const filePath = path11.join(this.getBasePath("interceptors"), fileName);
+    const content = `import { Injectable, express } from 'fragment-ts';
+
+@Injectable()
+export class ${className} {
+  intercept(req: express.Request, res: express.Response, result: any): any {
+    // Add your transformation logic here
+    return result;
+  }
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+  async generateFilter(name) {
+    const className = `${NamingUtils.pascalCase(name)}ExceptionFilter`;
+    const fileName = `${NamingUtils.kebabCase(name)}.exception.filter.ts`;
+    const filePath = path11.join(this.getBasePath("filters"), fileName);
+    const content = `import { Injectable, express } from 'fragment-ts';
+
+@Injectable()
+export class ${className} {
+  catch(exception: Error, req: express.Request, res: express.Response): void {
+    // Add your error handling logic here
+    res.status(500).json({
+      statusCode: 500,
+      error: 'Internal Server Error',
+      message: exception.message || 'Something went wrong'
+    });
+  }
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+  async generateJob(name, options) {
+    const className = `${NamingUtils.pascalCase(name)}Job`;
+    const fileName = `${NamingUtils.kebabCase(name)}.job.ts`;
+    const filePath = path11.join(this.getBasePath("jobs", options), fileName);
+    const content = `import { Job, ScheduledJob } from 'fragment-ts';
+import type { JobContext } from 'fragment-ts';
+
+@Job()
+export class ${className} extends ScheduledJob {
+  protected async handle(payload: any, context: JobContext): Promise<void> {
+    // Add your job logic here
+  }
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+  async generateMail(name, options) {
+    const className = `${NamingUtils.pascalCase(name)}Mailer`;
+    const fileName = `${NamingUtils.kebabCase(name)}.mail.ts`;
+    const filePath = path11.join(this.getBasePath("mail", options), fileName);
+    const qualifier = NamingUtils.kebabCase(name);
+    const content = `import { Mailer } from 'fragment-ts';
+import type { MailMessage, MailProvider, MailSendResult } from 'fragment-ts';
+
+@Mailer({ name: '${qualifier}' })
+export class ${className} implements MailProvider {
+  async send(message: MailMessage): Promise<MailSendResult | void> {
+    // Implement provider send logic here
+    return {
+      id: 'example',
+      accepted: Array.isArray(message.to) ? message.to.map(String) : [String(message.to)],
+      rejected: [],
+    };
+  }
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+  async generateNotification(name, options) {
+    const className = `${NamingUtils.pascalCase(name)}Notification`;
+    const fileName = `${NamingUtils.kebabCase(name)}.notification.ts`;
+    const filePath = path11.join(
+      this.getBasePath("notifications", options),
+      fileName
+    );
+    const content = `import type { MailMessage, MailNotification } from 'fragment-ts';
+
+export class ${className} implements MailNotification {
+  via(): string[] {
+    return ['mail'];
+  }
+
+  toMail(): MailMessage {
+    return {
+      subject: '${NamingUtils.pascalCase(name)} Notification',
+      html: '<p>Notification content</p>'
+    };
+  }
+}
+`;
+    await fs7.ensureDir(path11.dirname(filePath));
+    await fs7.writeFile(filePath, content);
+  }
+};
+
+// src/platform/cli/web/commands/make/service.ts
+async function resolveTarget(options) {
+  if (options.target) return options.target;
+  const hasApi = fs8.existsSync(path12.join(process.cwd(), "fragment.json"));
+  const hasWeb = fs8.existsSync(path12.join(process.cwd(), "fragment.web.json"));
+  if (!(hasApi && hasWeb)) return "web";
+  const inquirer = await import("inquirer");
+  const answer = await inquirer.default.prompt([
+    {
+      type: "list",
+      name: "target",
+      message: "Both backend and frontend configs were found. Which service do you want to generate?",
+      choices: [
+        { name: "Frontend (@FragmentService) in src/web", value: "web" },
+        { name: "Backend (@Service) in fragment-ts", value: "api" }
+      ],
+      default: "web"
+    }
+  ]);
+  return answer.target;
+}
+async function runBackendService(name, options) {
+  const structureType = ConfigUtils.getStructureType();
+  const generator = new ComponentGenerator(structureType);
+  await generator.generate("service", name, {
+    module: options.module,
+    feature: options.feature
+  });
+}
+async function runMakeService(name, options = {}) {
+  const target = await resolveTarget(options);
+  if (target === "api") {
+    await runBackendService(name, options);
+    return;
+  }
+  const config2 = ensureWebConfig();
+  const mode = options.structure || config2.structure;
+  const domain = options.feature || options.module;
+  const outDir = resolveOutputDir({ mode, kind: "service", name, domain });
+  const fileName = `${toKebabCase(name)}.service.ts`;
+  const className = `${toPascalCase(name)}Service`;
+  const baseUrl = (options.baseUrl || `/${toKebabCase(name)}`).replace(/\/$/, "");
+  const methods = (options.methods || "findAll,findById,create,update,delete").split(",").map((v) => v.trim()).filter(Boolean);
+  const body = methods.map((m) => {
+    switch (m) {
+      case "findAll":
+        return `  async findAll(): Promise<unknown> {
+    return FragmentFetch.get('${baseUrl}');
+  }`;
+      case "findById":
+        return `  async findById(id: string): Promise<unknown> {
+    return FragmentFetch.get(\`${baseUrl}/\${id}\`);
+  }`;
+      case "create":
+        return `  async create(payload: unknown): Promise<unknown> {
+    return FragmentFetch.post('${baseUrl}', payload);
+  }`;
+      case "update":
+        return `  async update(id: string, payload: unknown): Promise<unknown> {
+    return FragmentFetch.put(\`${baseUrl}/\${id}\`, payload);
+  }`;
+      case "delete":
+        return `  async delete(id: string): Promise<unknown> {
+    return FragmentFetch.delete(\`${baseUrl}/\${id}\`);
+  }`;
+      default:
+        return `  async ${m}(): Promise<unknown> {
+    return FragmentFetch.get('${baseUrl}');
+  }`;
+    }
+  }).join("\n\n");
+  const content = `// Generated by: frg make:service ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import { FragmentFetch, FragmentService } from 'fragment-web';
+
+@FragmentService()
+export class ${className} {
+${body}
+}
+`;
+  writeFileIfAllowed(path12.join(process.cwd(), outDir, fileName), content, options);
+}
+function registerMakeService(program) {
+  program.command("make:service <name>").description("Generate a service (frontend or backend when both contexts exist)").option("--base-url <path>", "Base URL path for FragmentFetch calls").option("--methods <list>", "CSV of service methods").option("--target <target>", "web|api").option("--structure <mode>", "Override structure mode").option("--module <name>", "Module name").option("--feature <name>", "Feature name").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runMakeService(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "make:service failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/commands/make/guard.ts
+import path13 from "path";
+async function runMakeGuard(name, options = {}) {
+  const config2 = ensureWebConfig();
+  const mode = options.structure || config2.structure;
+  const outDir = resolveOutputDir({ mode, kind: "guard", name });
+  const fileName = `${toKebabCase(name)}.guard.ts`;
+  const className = `${toPascalCase(name)}Guard`;
+  const redirect = options.redirect || "/login";
+  const bodyByType = {
+    auth: `  canActivate(): boolean {
+    return Boolean(FragmentFetch.getToken());
+  }`,
+    role: `  canActivate(): boolean {
+    // Replace with role claim checks from your auth provider
+    return Boolean(FragmentFetch.getToken());
+  }`,
+    custom: `  canActivate(): boolean {
+    return true;
+  }`
+  };
+  const type = options.type || "custom";
+  const content = `// Generated by: frg make:guard ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import { FragmentFetch } from 'fragment-web';
+
+export class ${className} {
+${bodyByType[type]}
+
+  redirectTo(): string {
+    return '${redirect}';
+  }
+}
+`;
+  writeFileIfAllowed(path13.join(process.cwd(), outDir, fileName), content, options);
+}
+function registerMakeGuard(program) {
+  program.command("make:guard <name>").description("Generate a frontend guard").option("--type <type>", "auth|role|custom").option("--redirect <path>", "Redirect path").option("--structure <mode>", "Override structure mode").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runMakeGuard(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "make:guard failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/commands/make/layout.ts
+import path14 from "path";
+async function runMakeLayout(name, options = {}) {
+  const config2 = ensureWebConfig();
+  const mode = options.structure || config2.structure;
+  const outDir = resolveOutputDir({ mode, kind: "layout", name });
+  const fileName = `${toKebabCase(name)}.layout.tsx`;
+  const className = `${toPascalCase(name)}Layout`;
+  const slots = (options.slots || "header,footer").split(",").map((v) => v.trim()).filter(Boolean);
+  const slotProps = slots.map((s) => `${s}?: React.ReactNode;`).join("\n  ");
+  const slotUsage = slots.map((s) => `{${s}}`).join("\n      ");
+  const content = `// Generated by: frg make:layout ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import React from 'react';
+
+interface ${className}Props {
+  children?: React.ReactNode;
+  ${slotProps}
+}
+
+export function ${className}({ children, ${slots.join(", ")} }: ${className}Props): JSX.Element {
+  return <section>
+      ${slotUsage}
+      {children}
+    </section>;
+}
+`;
+  writeFileIfAllowed(path14.join(process.cwd(), outDir, fileName), content, options);
+}
+function registerMakeLayout(program) {
+  program.command("make:layout <name>").description("Generate a frontend layout").option("--slots <slots>", "CSV slot names").option("--structure <mode>", "Override structure mode").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runMakeLayout(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "make:layout failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/commands/make/store.ts
+import path15 from "path";
+function parseFields(fields) {
+  const raw = (fields || "loading:boolean=false").split(",").map((v) => v.trim()).filter(Boolean);
+  return raw.map((item) => {
+    const [left, defaultValue] = item.split("=").map((v) => v.trim());
+    const [key, type] = left.split(":").map((v) => v.trim());
+    return {
+      key,
+      type: type || "unknown",
+      initial: defaultValue ?? (type === "number" ? "0" : type === "boolean" ? "false" : type === "string" ? "''" : "null")
+    };
+  });
+}
+async function runMakeStore(name, options = {}) {
+  const config2 = ensureWebConfig();
+  const mode = options.structure || config2.structure;
+  const adapter = options.adapter || config2.app.stateAdapter;
+  const domain = options.feature || options.module;
+  const outDir = resolveOutputDir({ mode, kind: "store", name, domain });
+  const fileName = `${toKebabCase(name)}.store.ts`;
+  const className = toPascalCase(name);
+  const fields = parseFields(options.fields);
+  const actions = (options.actions || "setState").split(",").map((v) => v.trim()).filter(Boolean);
+  const contentByAdapter = {
+    zustand: `// Generated by: frg make:store ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import { create } from 'zustand';
+
+interface ${className}State {
+${fields.map((f) => `  ${f.key}: ${f.type};`).join("\n")}
+${actions.map((a) => `  ${a}: (payload?: unknown) => void;`).join("\n")}
+}
+
+export const use${className}Store = create<${className}State>((set) => ({
+${fields.map((f) => `  ${f.key}: ${f.initial},`).join("\n")}
+${actions.map((a) => `  ${a}: (payload) => set((s) => ({ ...s })),`).join("\n")}
+}));
+`,
+    jotai: `// Generated by: frg make:store ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import { atom } from 'jotai';
+
+export const ${toKebabCase(name).replace(/-/g, "_")}Store = atom({
+${fields.map((f) => `  ${f.key}: ${f.initial},`).join("\n")}
+});
+`,
+    redux: `// Generated by: frg make:store ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+export interface ${className}State {
+${fields.map((f) => `  ${f.key}: ${f.type};`).join("\n")}
+}
+
+export const initial${className}State: ${className}State = {
+${fields.map((f) => `  ${f.key}: ${f.initial},`).join("\n")}
+};
+`,
+    mobx: `// Generated by: frg make:store ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import { makeAutoObservable } from 'mobx';
+
+export class ${className}Store {
+${fields.map((f) => `  ${f.key}: ${f.type} = ${f.initial};`).join("\n")}
+
+  constructor() {
+    makeAutoObservable(this);
+  }
+
+${actions.map((a) => `  ${a}(payload?: unknown): void {}`).join("\n\n")}
+}
+`
+  };
+  writeFileIfAllowed(path15.join(process.cwd(), outDir, fileName), contentByAdapter[adapter], options);
+}
+function registerMakeStore(program) {
+  program.command("make:store <name>").description("Generate a frontend store").option("--adapter <adapter>", "zustand|jotai|redux|mobx").option("--fields <fields>", "CSV key:type[=default] list").option("--actions <actions>", "CSV action names").option("--structure <mode>", "Override structure mode").option("--module <name>", "Module name").option("--feature <name>", "Feature name").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runMakeStore(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "make:store failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/commands/make/resource.ts
+async function runMakeResource(name, options = {}) {
+  await runMakeComponent(`${name}-card`, options);
+  await runMakePage(`${name}-list`, { ...options, path: options.path || `/${name}` });
+  await runMakeService(name, options);
+  await runMakeStore(name, options);
+}
+function registerMakeResource(program) {
+  program.command("make:resource <name>").description("Generate page + service + store + component in one shot").option("--path <path>", "List page route path").option("--methods <list>", "Service methods CSV").option("--adapter <adapter>", "Store adapter").option("--fields <fields>", "Store fields").option("--actions <actions>", "Store actions").option("--structure <mode>", "Override structure mode").option("--module <name>", "Module name").option("--feature <name>", "Feature name").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runMakeResource(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "make:resource failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/commands/create/module.ts
+import path16 from "path";
+async function runCreateModule(name, options = {}) {
+  const config2 = ensureWebConfig();
+  const mode = options.structure || config2.structure;
+  if (mode !== "module") {
+    throw new Error("create:module requires structure mode 'module' (or pass --structure module)");
+  }
+  await runMakePage(`${name}-list`, { ...options, structure: mode, module: name });
+  await runMakePage(`${name}-detail`, { ...options, structure: mode, module: name });
+  await runMakeService(name, { ...options, structure: mode, module: name });
+  await runMakeStore(name, { ...options, structure: mode, module: name });
+  await runMakeComponent(`${name}-card`, { ...options, structure: mode, module: name });
+  writeFileIfAllowed(
+    path16.join(process.cwd(), "src/modules", toKebabCase(name), "index.ts"),
+    `// Generated by: frg create:module ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+export * from './${toKebabCase(name)}-list.page';
+export * from './${toKebabCase(name)}-detail.page';
+export * from './${toKebabCase(name)}.service';
+export * from './${toKebabCase(name)}.store';
+export * from './components/${toKebabCase(name)}-card.component';
+`,
+    options
+  );
+}
+function registerCreateModule(program) {
+  program.command("create:module <name>").description("Generate a full module slice").option("--structure <mode>", "Override structure mode").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runCreateModule(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "create:module failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/commands/create/feature.ts
+import path17 from "path";
+async function runCreateFeature(name, options = {}) {
+  const config2 = ensureWebConfig();
+  const mode = options.structure || config2.structure;
+  if (mode !== "feature") {
+    throw new Error("create:feature requires structure mode 'feature' (or pass --structure feature)");
+  }
+  await runMakePage(`${name}-list`, { ...options, structure: mode, feature: name });
+  await runMakeService(name, { ...options, structure: mode, feature: name });
+  await runMakeStore(name, { ...options, structure: mode, feature: name });
+  await runMakeComponent(`${name}-card`, { ...options, structure: mode, feature: name });
+  writeFileIfAllowed(
+    path17.join(process.cwd(), "src/features", toKebabCase(name), "index.ts"),
+    `// Generated by: frg create:feature ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+export * from './pages/${toKebabCase(name)}-list.page';
+export * from './services/${toKebabCase(name)}.service';
+export * from './stores/${toKebabCase(name)}.store';
+export * from './components/${toKebabCase(name)}-card.component';
+`,
+    options
+  );
+}
+function registerCreateFeature(program) {
+  program.command("create:feature <name>").description("Generate a full feature slice").option("--structure <mode>", "Override structure mode").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runCreateFeature(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "create:feature failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/commands/create/mvvm.ts
+import path18 from "path";
+async function runCreateMvvm(name, options = {}) {
+  const config2 = ensureWebConfig();
+  const mode = options.structure || config2.structure;
+  if (mode !== "mvvm") {
+    throw new Error("create:mvvm requires structure mode 'mvvm' (or pass --structure mvvm)");
+  }
+  const dom = toKebabCase(name);
+  const className = toPascalCase(name);
+  await runMakePage(`${name}-list`, { ...options, structure: mode, feature: name });
+  await runMakeComponent(`${name}-card`, { ...options, structure: mode, feature: name });
+  writeFileIfAllowed(
+    path18.join(process.cwd(), "src/app", dom, "viewmodel", `${dom}.vm.ts`),
+    `// Generated by: frg create:mvvm ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import { FragmentFetch, FragmentService } from 'fragment-web';
+
+@FragmentService()
+export class ${className}Vm {
+  async load(): Promise<unknown> {
+    return FragmentFetch.get('/${dom}');
+  }
+}
+`,
+    options
+  );
+  writeFileIfAllowed(
+    path18.join(process.cwd(), "src/app", dom, "model", `${dom}.model.ts`),
+    `// Generated by: frg create:mvvm ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+export interface ${className}Model {
+  id: string;
+}
+`,
+    options
+  );
+  writeFileIfAllowed(
+    path18.join(process.cwd(), "src/app", dom, "index.ts"),
+    `// Generated by: frg create:mvvm ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+export * from './model/${dom}.model';
+export * from './viewmodel/${dom}.vm';
+export * from './view/${dom}-list.page';
+export * from './view/${dom}-card.component';
+`,
+    options
+  );
+}
+function registerCreateMvvm(program) {
+  program.command("create:mvvm <name>").description("Generate a full MVVM slice").option("--structure <mode>", "Override structure mode").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runCreateMvvm(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "create:mvvm failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/platform/cli/web/index.ts
+function removeCommandIfExists(registry, name) {
+  const commands = registry.commands;
+  if (!commands) return;
+  const idx = commands.findIndex((cmd) => cmd.name() === name);
+  if (idx >= 0) {
+    commands.splice(idx, 1);
+  }
+}
+function registerWebCommands(registry) {
+  removeCommandIfExists(registry, "make:service");
+  removeCommandIfExists(registry, "make:guard");
+  removeCommandIfExists(registry, "make:resource");
+  registerWebSync(registry);
+  registerMakeComponent(registry);
+  registerMakePage(registry);
+  registerMakeService(registry);
+  registerMakeGuard(registry);
+  registerMakeLayout(registry);
+  registerMakeStore(registry);
+  registerMakeResource(registry);
+  registerCreateModule(registry);
+  registerCreateFeature(registry);
+  registerCreateMvvm(registry);
+}
+export {
+  registerWebCommands
+};