fragment-ts 2.0.3 → 2.0.4

package/dist/web/cli/index.mjs

@@ -0,0 +1,984 @@
+// src/web/cli/commands/install-web.ts
+import fs3 from "fs";
+import path3 from "path";
+import { spawnSync } from "child_process";
+
+// src/web/cli/utils/config.ts
+import fs from "fs";
+import path from "path";
+var WEB_CONFIG_FILE = "fragment.web.json";
+var API_CONFIG_FILE = "fragment.json";
+function resolveCwd(cwd) {
+  return cwd ? path.resolve(cwd) : process.cwd();
+}
+function webConfigPath(cwd) {
+  return path.join(resolveCwd(cwd), WEB_CONFIG_FILE);
+}
+function apiConfigPath(cwd) {
+  return path.join(resolveCwd(cwd), API_CONFIG_FILE);
+}
+function createDefaultWebConfig(partial) {
+  return {
+    webRoot: "/",
+    serverRoot: partial?.serverRoot ?? "/api",
+    publicRoutes: ["/", "/login", "/register"],
+    authenticatedRoutes: ["/dashboard", "/profile", "/settings"],
+    app: {
+      name: partial?.app?.name ?? "My App",
+      rootElement: "#root",
+      strict: true,
+      router: "react-router",
+      stateAdapter: partial?.app?.stateAdapter ?? "zustand"
+    },
+    fetch: {
+      baseUrl: partial?.fetch?.baseUrl ?? "${VITE_API_URL:http://localhost:3000}",
+      timeout: 1e4,
+      retries: 2,
+      retryDelay: 300,
+      tokenTransport: "cookie",
+      tokenKey: "fragment_token",
+      onUnauthorized: "redirect:/login",
+      onForbidden: "redirect:/403"
+    },
+    structure: partial?.structure ?? "layered",
+    di: {
+      autoScan: true,
+      scanPaths: ["src/components", "src/pages", "src/services"]
+    },
+    theme: {
+      mode: "system",
+      primaryColor: "#6366f1",
+      fontFamily: "Geist, system-ui"
+    },
+    devtools: {
+      enabled: true
+    }
+  };
+}
+function readJsonFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const raw = fs.readFileSync(filePath, "utf8");
+  return JSON.parse(raw);
+}
+function writeJsonFile(filePath, payload) {
+  fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+}
+function readWebConfig(cwd) {
+  return readJsonFile(webConfigPath(cwd));
+}
+function readApiConfig(cwd) {
+  return readJsonFile(apiConfigPath(cwd));
+}
+function ensureWebConfig(cwd) {
+  const config = readWebConfig(cwd);
+  if (!config) {
+    throw new Error("fragment.web.json was not found in the current project");
+  }
+  return config;
+}
+
+// src/web/cli/utils/logger.ts
+import pc from "picocolors";
+function line(symbol, label, message) {
+  return `  ${symbol}  ${label.padEnd(8, " ")} ${message}`;
+}
+var logger = {
+  section(title, subtitle) {
+    process.stdout.write(`
+  ${pc.bold(title)}${subtitle ? `  ${subtitle}` : ""}
+
+`);
+  },
+  created(path18) {
+    process.stdout.write(`${line(pc.green("\u2714"), "created", path18)}
+`);
+  },
+  updated(path18, detail) {
+    process.stdout.write(
+      `${line(pc.cyan("\u2714"), "updated", `${path18}${detail ? `  (${detail})` : ""}`)}
+`
+    );
+  },
+  exists(path18, detail = "use --force to overwrite") {
+    process.stdout.write(`${line(pc.yellow("\u26A0"), "exists", `${path18}  (${detail})`)}
+`);
+  },
+  dryRun(path18) {
+    process.stdout.write(`${line(pc.blue("\u2139"), "dry-run", path18)}
+`);
+  },
+  error(message) {
+    process.stderr.write(`${line(pc.red("\u2716"), "error", message)}
+`);
+  },
+  done(message) {
+    process.stdout.write(`
+  ${pc.bold("Done.")} ${message}
+`);
+  }
+};
+
+// src/web/cli/utils/write-file.ts
+import fs2 from "fs";
+import path2 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(path2.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/web/cli/commands/install-web.ts
+function detectPackageManager(cwd) {
+  if (fs3.existsSync(path3.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs3.existsSync(path3.join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function installDeps(cwd, manager, dryRun) {
+  if (dryRun) return;
+  const args = manager === "yarn" ? ["add", "fragment-web", "react", "react-dom", "react-router-dom", "reflect-metadata", "vite"] : manager === "pnpm" ? ["add", "fragment-web", "react", "react-dom", "react-router-dom", "reflect-metadata", "vite"] : ["install", "fragment-web", "react", "react-dom", "react-router-dom", "reflect-metadata", "vite"];
+  const result = spawnSync(manager, args, { cwd, stdio: "ignore" });
+  if (result.status !== 0) {
+    throw new Error(`Dependency install failed using ${manager}`);
+  }
+}
+function updatePackageScripts(cwd, dryRun) {
+  const pkgPath = path3.join(cwd, "package.json");
+  if (!fs3.existsSync(pkgPath)) return;
+  const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
+  pkg.scripts = pkg.scripts || {};
+  pkg.scripts["dev:web"] = "vite";
+  pkg.scripts["build:web"] = "vite build";
+  if (dryRun) {
+    logger.dryRun("package.json");
+    return;
+  }
+  fs3.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  logger.updated("package.json", "scripts: dev:web, build:web");
+}
+async function runInstallWeb(options = {}) {
+  const cwd = process.cwd();
+  logger.section("fragment-web", "install:web");
+  const apiConfig = readApiConfig(cwd);
+  const serverRoot = typeof apiConfig?.serverRoot === "string" ? apiConfig.serverRoot : "/api";
+  const webConfig = createDefaultWebConfig({
+    serverRoot,
+    structure: options.structure,
+    app: {
+      name: "My App",
+      rootElement: "#root",
+      strict: true,
+      router: "react-router",
+      stateAdapter: options.adapter || "zustand"
+    }
+  });
+  const configPath = webConfigPath(cwd);
+  if (options.dryRun) {
+    logger.dryRun(configPath);
+  } else if (fs3.existsSync(configPath) && !options.force) {
+    logger.exists(configPath);
+  } else {
+    writeJsonFile(configPath, webConfig);
+    logger.created("fragment.web.json");
+  }
+  writeFileIfAllowed(
+    path3.join(cwd, "index.html"),
+    '<!doctype html>\n<html><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>Fragment Web</title></head><body><div id="root"></div><script type="module" src="/src/web/main.tsx"></script></body></html>\n',
+    options
+  );
+  writeFileIfAllowed(
+    path3.join(cwd, "vite.config.ts"),
+    "import { defineConfig } from 'vite';\nimport webConfig from './fragment.web.json';\n\nexport default defineConfig({\n  server: {\n    proxy: {\n      [webConfig.serverRoot]: {\n        target: webConfig.fetch.baseUrl,\n        changeOrigin: true,\n      },\n    },\n  },\n});\n",
+    options
+  );
+  writeFileIfAllowed(
+    path3.join(cwd, "src/web/main.tsx"),
+    "import 'reflect-metadata';\nimport { FragmentWebApplication, FragmentWebUIApplication } from 'fragment-web';\n\n@FragmentWebApplication({ rootElement: '#root', strict: true })\nclass Application {}\n\nasync function bootstrap() {\n  const app = new FragmentWebUIApplication();\n  await app.bootstrap(Application);\n}\n\nbootstrap();\n",
+    options
+  );
+  writeFileIfAllowed(
+    path3.join(cwd, "src/web/app.component.tsx"),
+    "import React from 'react';\n\nexport function AppComponent(): JSX.Element {\n  return <div>Fragment Web App</div>;\n}\n",
+    options
+  );
+  writeFileIfAllowed(
+    path3.join(cwd, "src/web/pages/home.page.tsx"),
+    "import React from 'react';\nimport { Page } from 'fragment-web';\n\n@Page({ path: '/', title: 'Home' })\nexport class HomePage {\n  render(): JSX.Element {\n    return <div>Home</div>;\n  }\n}\n",
+    options
+  );
+  writeFileIfAllowed(
+    path3.join(cwd, "src/web/pages/login.page.tsx"),
+    "import React from 'react';\nimport { Page, RedirectIfAuthenticated } from 'fragment-web';\n\n@Page({ path: '/login', title: 'Login' })\n@RedirectIfAuthenticated('/')\nexport class LoginPage {\n  render(): JSX.Element {\n    return <div>Login</div>;\n  }\n}\n",
+    options
+  );
+  updatePackageScripts(cwd, options.dryRun);
+  installDeps(cwd, detectPackageManager(cwd), options.dryRun);
+  logger.done("Run: npm run dev:web");
+}
+function registerInstallWeb(program) {
+  program.command("install:web").description("Install fragment-web into an existing fragment-ts project").option("--structure <mode>", "Folder structure mode").option("--adapter <adapter>", "State adapter").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((opts) => {
+    runInstallWeb(opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "install:web failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/web/cli/commands/install-api.ts
+import fs4 from "fs";
+import path4 from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+function detectPackageManager2(cwd) {
+  if (fs4.existsSync(path4.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs4.existsSync(path4.join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function installDeps2(cwd, manager, dryRun) {
+  if (dryRun) return;
+  const args = manager === "yarn" ? ["add", "fragment-ts", "reflect-metadata"] : manager === "pnpm" ? ["add", "fragment-ts", "reflect-metadata"] : ["install", "fragment-ts", "reflect-metadata"];
+  const result = spawnSync2(manager, args, { cwd, stdio: "ignore" });
+  if (result.status !== 0) {
+    throw new Error(`Dependency install failed using ${manager}`);
+  }
+}
+function updatePackageScripts2(cwd, dryRun) {
+  const pkgPath = path4.join(cwd, "package.json");
+  if (!fs4.existsSync(pkgPath)) return;
+  const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf8"));
+  pkg.scripts = pkg.scripts || {};
+  pkg.scripts["dev:api"] = "frg serve";
+  pkg.scripts["build:api"] = "frg build";
+  if (dryRun) {
+    logger.dryRun("package.json");
+    return;
+  }
+  fs4.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+  logger.updated("package.json", "scripts: dev:api, build:api");
+}
+async function runInstallApi(options = {}) {
+  const cwd = process.cwd();
+  logger.section("fragment-web", "install:api");
+  const webConfig = ensureWebConfig(cwd);
+  const fragmentConfig = {
+    serverRoot: webConfig.serverRoot,
+    database: {
+      driver: options.db ?? "sqlite"
+    }
+  };
+  const fragmentPath = path4.join(cwd, "fragment.json");
+  if (options.dryRun) {
+    logger.dryRun(fragmentPath);
+  } else if (fs4.existsSync(fragmentPath) && !options.force) {
+    logger.exists(fragmentPath);
+  } else {
+    writeJsonFile(fragmentPath, fragmentConfig);
+    logger.created("fragment.json");
+  }
+  writeFileIfAllowed(
+    path4.join(cwd, "src/api/main.ts"),
+    "import 'reflect-metadata';\nimport { FragmentApplication } from 'fragment-ts';\n\n@FragmentApplication()\nclass App {}\n\nexport default App;\n",
+    options
+  );
+  writeFileIfAllowed(
+    path4.join(cwd, "src/api/modules/app/controllers/app.controller.ts"),
+    "import { Controller, Get } from 'fragment-ts';\nimport { AppService } from '../services/app.service';\n\n@Controller('/app')\nexport class AppController {\n  constructor(private readonly appService: AppService) {}\n\n  @Get('/')\n  getHello(): string {\n    return this.appService.getHello();\n  }\n}\n",
+    options
+  );
+  writeFileIfAllowed(
+    path4.join(cwd, "src/api/modules/app/services/app.service.ts"),
+    "import { Service } from 'fragment-ts';\n\n@Service()\nexport class AppService {\n  getHello(): string {\n    return 'Hello from fragment-ts';\n  }\n}\n",
+    options
+  );
+  updatePackageScripts2(cwd, options.dryRun);
+  installDeps2(cwd, detectPackageManager2(cwd), options.dryRun);
+  logger.done("Run: npm run dev:api");
+}
+function registerInstallApi(program) {
+  program.command("install:api").description("Install fragment-ts into an existing fragment-web project").option("--db <db>", "Database adapter").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((opts) => {
+    runInstallApi(opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "install:api failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/web/cli/commands/init-web.ts
+import fs5 from "fs";
+import path5 from "path";
+async function runInitWeb(name, options = {}) {
+  const root = path5.resolve(process.cwd(), name);
+  logger.section("fragment-web", `init:web ${name}`);
+  if (!options.dryRun) {
+    fs5.mkdirSync(root, { recursive: true });
+  }
+  const config = createDefaultWebConfig({
+    app: {
+      name,
+      rootElement: "#root",
+      strict: true,
+      router: "react-router",
+      stateAdapter: options.adapter || "zustand"
+    },
+    structure: options.structure
+  });
+  writeFileIfAllowed(path5.join(root, "fragment.web.json"), `${JSON.stringify(config, null, 2)}
+`, options);
+  writeFileIfAllowed(
+    path5.join(root, "package.json"),
+    `${JSON.stringify(
+      {
+        name,
+        version: "0.1.0",
+        private: true,
+        scripts: {
+          "dev:web": "vite",
+          "build:web": "vite build"
+        }
+      },
+      null,
+      2
+    )}
+`,
+    options
+  );
+  writeFileIfAllowed(
+    path5.join(root, "tsconfig.json"),
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2020",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          jsx: "react-jsx",
+          strict: true,
+          experimentalDecorators: true,
+          emitDecoratorMetadata: true
+        },
+        include: ["src/**/*"]
+      },
+      null,
+      2
+    ) + "\n",
+    options
+  );
+  writeFileIfAllowed(
+    path5.join(root, "vite.config.ts"),
+    "import { defineConfig } from 'vite';\nimport webConfig from './fragment.web.json';\n\nexport default defineConfig({\n  server: {\n    proxy: {\n      [webConfig.serverRoot]: {\n        target: webConfig.fetch.baseUrl,\n        changeOrigin: true,\n      },\n    },\n  },\n});\n",
+    options
+  );
+  writeFileIfAllowed(
+    path5.join(root, "src/web/main.tsx"),
+    "import 'reflect-metadata';\nimport { FragmentWebApplication, FragmentWebUIApplication } from 'fragment-web';\n\n@FragmentWebApplication({ rootElement: '#root', strict: true })\nclass Application {}\n\nnew FragmentWebUIApplication().bootstrap(Application);\n",
+    options
+  );
+  logger.done(`Created ${name}`);
+}
+function registerInitWeb(program) {
+  program.command("init:web <name>").description("Create a new fragment-web project").option("--structure <mode>", "Folder structure mode").option("--adapter <adapter>", "State adapter").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runInitWeb(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "init:web failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/web/cli/commands/init-fullstack.ts
+import path6 from "path";
+async function runInitFullstack(name, options = {}) {
+  await runInitWeb(name, options);
+  const root = path6.resolve(process.cwd(), name);
+  writeFileIfAllowed(
+    path6.join(root, "fragment.json"),
+    `${JSON.stringify(
+      {
+        serverRoot: "/api",
+        database: {
+          driver: options.db ?? "sqlite"
+        }
+      },
+      null,
+      2
+    )}
+`,
+    options
+  );
+  writeFileIfAllowed(
+    path6.join(root, "src/api/main.ts"),
+    "import 'reflect-metadata';\nimport { FragmentApplication } from 'fragment-ts';\n\n@FragmentApplication()\nclass App {}\n\nexport default App;\n",
+    options
+  );
+  writeFileIfAllowed(
+    path6.join(root, "src/api/modules/app/controllers/app.controller.ts"),
+    "import { Controller, Get } from 'fragment-ts';\n\n@Controller('/app')\nexport class AppController {\n  @Get('/')\n  hello(): string {\n    return 'Hello';\n  }\n}\n",
+    options
+  );
+  writeFileIfAllowed(
+    path6.join(root, "src/api/modules/app/services/app.service.ts"),
+    "import { Service } from 'fragment-ts';\n\n@Service()\nexport class AppService {}\n",
+    options
+  );
+  logger.done(`Created fullstack project ${name}`);
+}
+function registerInitFullstack(program) {
+  program.command("init:fullstack <name>").description("Create a new fullstack fragment project").option("--structure <mode>", "Folder structure mode").option("--adapter <adapter>", "State adapter").option("--db <db>", "Database adapter").option("--force", "Overwrite existing files").option("--dry-run", "Preview changes").action((name, opts) => {
+    runInitFullstack(name, opts).catch((error) => {
+      logger.error(error instanceof Error ? error.message : "init:fullstack failed");
+      process.exitCode = 1;
+    });
+  });
+}
+
+// src/web/cli/commands/web-sync.ts
+import path7 from "path";
+async function syncOnce(options) {
+  const config = ensureWebConfig();
+  const base = options.url || config.fetch.baseUrl;
+  const source = `${base}${config.serverRoot}/docs/api-json`;
+  const generatedDir = path7.join(process.cwd(), "src/generated");
+  const content = `// \u26A0\uFE0F  AUTO-GENERATED by frg web:sync \u2014 do not edit manually
+// Source: ${source}
+// Synced at: ${(/* @__PURE__ */ new Date()).toISOString()}
+export const API_BASE = '${config.serverRoot}';
+export const API_DOCS_URL = '${source}';
+`;
+  writeFileIfAllowed(path7.join(generatedDir, "routes.ts"), content, {
+    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/web/cli/commands/make/component.ts
+import path9 from "path";
+
+// src/web/cli/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/web/cli/utils/resolve-paths.ts
+import path8 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 path8.join("src", "components", leaf);
+        case "page":
+          return path8.join("src", "pages", leaf);
+        case "service":
+          return path8.join("src", "services");
+        case "store":
+          return path8.join("src", "stores");
+        case "guard":
+          return path8.join("src", "guards");
+        case "layout":
+          return path8.join("src", "layouts");
+        default:
+          throw new Error(`${input.kind} is not available in layered mode`);
+      }
+    case "module":
+      switch (input.kind) {
+        case "component":
+          return path8.join("src", "modules", dom, "components");
+        case "page":
+        case "service":
+        case "store":
+          return path8.join("src", "modules", dom);
+        case "guard":
+          return path8.join("src", "shared", "guards");
+        case "layout":
+          return path8.join("src", "shared", "layouts");
+        default:
+          throw new Error(`${input.kind} is not available in module mode`);
+      }
+    case "feature":
+      switch (input.kind) {
+        case "component":
+          return path8.join("src", "features", dom, "components");
+        case "page":
+          return path8.join("src", "features", dom, "pages");
+        case "service":
+          return path8.join("src", "features", dom, "services");
+        case "store":
+          return path8.join("src", "features", dom, "stores");
+        case "guard":
+          return path8.join("src", "shared", "guards");
+        case "layout":
+          return path8.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 path8.join("src", "app", dom, "view");
+        case "service":
+        case "store":
+        case "viewmodel":
+          return path8.join("src", "app", dom, "viewmodel");
+        case "model":
+          return path8.join("src", "app", dom, "model");
+        case "guard":
+          return path8.join("src", "shared", "guards");
+        case "layout":
+          return path8.join("src", "shared", "layouts");
+        default:
+          throw new Error(`${input.kind} is not available in mvvm mode`);
+      }
+    default:
+      return path8.join("src");
+  }
+}
+
+// src/web/cli/commands/make/component.ts
+async function runMakeComponent(name, options = {}) {
+  const config = ensureWebConfig();
+  const mode = options.structure || config.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 content = `// Generated by: frg make:component ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import React from 'react';
+
+export function ${className}(): JSX.Element {
+  return <div>${toPascalCase(name)} component</div>;
+}
+`;
+  writeFileIfAllowed(path9.join(process.cwd(), outDir, fileName), content, options);
+}
+function registerMakeComponent(program) {
+  program.command("make:component <name>").description("Generate a frontend component").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/web/cli/commands/make/page.ts
+import path10 from "path";
+async function runMakePage(name, options = {}) {
+  const config = ensureWebConfig();
+  const mode = options.structure || config.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 content = `// Generated by: frg make:page ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import React from 'react';
+import { Page } from 'fragment-web';
+
+@Page({ path: '${route}', title: '${toPascalCase(name)}' })
+export class ${className} {
+  render(): JSX.Element {
+    return <div>${toPascalCase(name)} page</div>;
+  }
+}
+`;
+  writeFileIfAllowed(path10.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("--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/web/cli/commands/make/service.ts
+import fs6 from "fs";
+import path11 from "path";
+async function runMakeService(name, options = {}) {
+  const hasApi = fs6.existsSync(path11.join(process.cwd(), "fragment.json"));
+  const hasWeb = fs6.existsSync(path11.join(process.cwd(), "fragment.web.json"));
+  if (hasApi && hasWeb) {
+    logger.error("Both fragment.json and fragment.web.json found. Use explicit backend generator for API services.");
+    process.exitCode = 1;
+    return;
+  }
+  const config = ensureWebConfig();
+  const mode = options.structure || config.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 methods = (options.methods || "findAll,findById,create,update,delete").split(",").map((v) => v.trim()).filter(Boolean);
+  const body = methods.map(
+    (m) => `  async ${m}(): Promise<unknown> {
+    return FragmentFetch.get('/${toKebabCase(name)}');
+  }`
+  ).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(path11.join(process.cwd(), outDir, fileName), content, options);
+}
+function registerMakeService(program) {
+  program.command("make:service <name>").description("Generate a frontend service").option("--methods <list>", "CSV of service methods").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/web/cli/commands/make/guard.ts
+import path12 from "path";
+async function runMakeGuard(name, options = {}) {
+  const config = ensureWebConfig();
+  const mode = options.structure || config.structure;
+  const outDir = resolveOutputDir({ mode, kind: "guard", name });
+  const fileName = `${toKebabCase(name)}.guard.ts`;
+  const className = `${toPascalCase(name)}Guard`;
+  const content = `// Generated by: frg make:guard ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+export class ${className} {
+  canActivate(): boolean {
+    return true;
+  }
+}
+`;
+  writeFileIfAllowed(path12.join(process.cwd(), outDir, fileName), content, options);
+}
+function registerMakeGuard(program) {
+  program.command("make:guard <name>").description("Generate a frontend guard").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/web/cli/commands/make/layout.ts
+import path13 from "path";
+async function runMakeLayout(name, options = {}) {
+  const config = ensureWebConfig();
+  const mode = options.structure || config.structure;
+  const outDir = resolveOutputDir({ mode, kind: "layout", name });
+  const fileName = `${toKebabCase(name)}.layout.tsx`;
+  const className = `${toPascalCase(name)}Layout`;
+  const content = `// Generated by: frg make:layout ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+import React from 'react';
+
+export function ${className}({ children }: { children?: React.ReactNode }): JSX.Element {
+  return <section>{children}</section>;
+}
+`;
+  writeFileIfAllowed(path13.join(process.cwd(), outDir, fileName), content, options);
+}
+function registerMakeLayout(program) {
+  program.command("make:layout <name>").description("Generate a frontend layout").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/web/cli/commands/make/store.ts
+import path14 from "path";
+async function runMakeStore(name, options = {}) {
+  const config = ensureWebConfig();
+  const mode = options.structure || config.structure;
+  const adapter = options.adapter || config.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 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 {
+  loading: boolean;
+  setLoading: (value: boolean) => void;
+}
+
+export const use${className}Store = create<${className}State>((set) => ({
+  loading: false,
+  setLoading: (value) => set({ loading: value }),
+}));
+`,
+    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({ loading: false });
+`,
+    redux: `// Generated by: frg make:store ${name}
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// fragment-web v0.1.0
+export interface ${className}State {
+  loading: boolean;
+}
+
+export const initial${className}State: ${className}State = { loading: false };
+`,
+    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 {
+  loading = false;
+
+  constructor() {
+    makeAutoObservable(this);
+  }
+
+  setLoading(value: boolean): void {
+    this.loading = value;
+  }
+}
+`
+  };
+  writeFileIfAllowed(path14.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("--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/web/cli/commands/make/resource.ts
+async function runMakeResource(name, options = {}) {
+  await runMakeComponent(`${name}-card`, options);
+  await runMakePage(`${name}-list`, options);
+  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("--structure <mode>", "Override structure mode").option("--module <name>", "Module name").option("--feature <name>", "Feature name").option("--adapter <adapter>", "Store adapter").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/web/cli/commands/create/module.ts
+import path15 from "path";
+async function runCreateModule(name, options = {}) {
+  const config = ensureWebConfig();
+  const mode = options.structure || config.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(
+    path15.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/web/cli/commands/create/feature.ts
+import path16 from "path";
+async function runCreateFeature(name, options = {}) {
+  const config = ensureWebConfig();
+  const mode = options.structure || config.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(
+    path16.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/web/cli/commands/create/mvvm.ts
+import path17 from "path";
+async function runCreateMvvm(name, options = {}) {
+  const config = ensureWebConfig();
+  const mode = options.structure || config.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(
+    path17.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(
+    path17.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(
+    path17.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/web/cli/index.ts
+function registerWebCommands(registry) {
+  registerInstallWeb(registry);
+  registerInstallApi(registry);
+  registerInitWeb(registry);
+  registerInitFullstack(registry);
+  registerWebSync(registry);
+  registerMakeComponent(registry);
+  registerMakePage(registry);
+  registerMakeService(registry);
+  registerMakeGuard(registry);
+  registerMakeLayout(registry);
+  registerMakeStore(registry);
+  registerMakeResource(registry);
+  registerCreateModule(registry);
+  registerCreateFeature(registry);
+  registerCreateMvvm(registry);
+}
+export {
+  registerWebCommands
+};