flowdoc-gen 0.1.0

package/dist/chunk-XXW6UJOX.js

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+
+// src/generate.ts
+import { writeFileSync, mkdirSync, cpSync, existsSync as existsSync3 } from "fs";
+import { resolve as resolve3, join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import ora from "ora";
+
+// ../core/dist/index.js
+import { existsSync } from "fs";
+import { resolve, join } from "path";
+var CONFIG_FILES = [
+  "flowdoc.config.ts",
+  "flowdoc.config.js",
+  "flowdoc.config.mjs"
+];
+var findConfigFile = (cwd) => {
+  for (const file of CONFIG_FILES) {
+    const full = join(cwd, file);
+    if (existsSync(full)) return full;
+  }
+  return null;
+};
+var loadConfig = async (configPath) => {
+  const resolved = resolve(configPath);
+  const mod = await import(resolved);
+  const config = "default" in mod ? mod.default : mod;
+  if (!config) throw new Error(`No config exported from ${configPath}`);
+  return config;
+};
+var resolveConfig = (config, cwd) => ({
+  version: "1.0.0",
+  baseUrl: "http://localhost:3000",
+  ...config,
+  entry: resolve(cwd, config.entry),
+  output: resolve(cwd, config.output ?? "./docs-output")
+});
+
+// ../parser/dist/index.js
+import {
+  Project,
+  Node as Node2,
+  SyntaxKind as SyntaxKind2
+} from "ts-morph";
+import { glob } from "glob";
+import { resolve as resolve2, dirname, join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { Node } from "ts-morph";
+var zodNodeToJsonSchema = (node) => {
+  if (!Node.isCallExpression(node)) return {};
+  const expr = node.getExpression();
+  const callText = expr.getText();
+  if (callText === "z.string") return buildStringSchema(node);
+  if (callText === "z.number") return buildNumberSchema(node);
+  if (callText === "z.boolean") return { type: "boolean" };
+  if (callText === "z.null") return { type: "null" };
+  if (callText === "z.literal") return buildLiteralSchema(node);
+  if (callText === "z.enum") return buildEnumSchema(node);
+  if (callText === "z.nativeEnum") return { type: "string" };
+  if (callText === "z.object") return buildObjectSchema(node);
+  if (callText === "z.array") return buildArraySchema(node);
+  if (callText === "z.union") return buildUnionSchema(node);
+  if (callText === "z.optional") return buildOptionalSchema(node);
+  if (callText === "z.date") return { type: "string", format: "date-time" };
+  if (callText === "z.any") return {};
+  if (callText === "z.unknown") return {};
+  if (Node.isPropertyAccessExpression(expr)) {
+    return buildChainedSchema(node);
+  }
+  return {};
+};
+var buildStringSchema = (node) => {
+  const schema = { type: "string" };
+  applyChainedValidations(node, schema);
+  return schema;
+};
+var buildNumberSchema = (node) => {
+  const schema = { type: "number" };
+  applyChainedValidations(node, schema);
+  return schema;
+};
+var buildLiteralSchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg) return {};
+  const text = arg.getText().replace(/['"]/g, "");
+  return { type: "string", enum: [text] };
+};
+var buildEnumSchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg || !Node.isArrayLiteralExpression(arg)) return { type: "string" };
+  const values = arg.getElements().map((el) => el.getText().replace(/['"]/g, ""));
+  return { type: "string", enum: values };
+};
+var buildObjectSchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg || !Node.isObjectLiteralExpression(arg)) return { type: "object" };
+  const properties = {};
+  const required = [];
+  for (const prop of arg.getProperties()) {
+    if (!Node.isPropertyAssignment(prop)) continue;
+    const name = prop.getName();
+    const init = prop.getInitializer();
+    if (!init) continue;
+    const childSchema = zodNodeToJsonSchema(init);
+    properties[name] = childSchema;
+    if (!isOptionalZodExpr(init)) {
+      required.push(name);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+};
+var buildArraySchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg) return { type: "array" };
+  return { type: "array", items: zodNodeToJsonSchema(arg) };
+};
+var buildUnionSchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg || !Node.isArrayLiteralExpression(arg)) return {};
+  const schemas = arg.getElements().map((el) => zodNodeToJsonSchema(el));
+  return { anyOf: schemas };
+};
+var buildOptionalSchema = (node) => {
+  const arg = node.getArguments()[0];
+  if (!arg) return {};
+  return zodNodeToJsonSchema(arg);
+};
+var buildChainedSchema = (node) => {
+  const chain = unwrapChain(node);
+  if (!chain.root) return {};
+  const base = zodNodeToJsonSchema(chain.root);
+  applyChainedCallsToSchema(chain.methods, base);
+  return base;
+};
+var unwrapChain = (node) => {
+  const methods = [];
+  let current = node;
+  while (Node.isCallExpression(current)) {
+    const expr = current.getExpression();
+    if (Node.isPropertyAccessExpression(expr)) {
+      const obj = expr.getExpression();
+      if (Node.isIdentifier(obj)) {
+        return { root: current, methods };
+      }
+      const methodName = expr.getName();
+      const args = current.getArguments();
+      methods.unshift({ name: methodName, args });
+      current = obj;
+    } else {
+      return { root: current, methods };
+    }
+  }
+  return { root: null, methods };
+};
+var applyChainedValidations = (node, schema) => {
+  const chain = unwrapChain(node);
+  applyChainedCallsToSchema(chain.methods, schema);
+};
+var applyChainedCallsToSchema = (methods, schema) => {
+  for (const { name, args } of methods) {
+    switch (name) {
+      case "email":
+        schema.format = "email";
+        break;
+      case "url":
+        schema.format = "uri";
+        break;
+      case "uuid":
+        schema.format = "uuid";
+        break;
+      case "datetime":
+        schema.format = "date-time";
+        break;
+      case "min": {
+        const val = getNumericArg(args[0]);
+        if (val !== null) {
+          if (schema.type === "string") schema.minLength = val;
+          else schema.minimum = val;
+        }
+        break;
+      }
+      case "max": {
+        const val = getNumericArg(args[0]);
+        if (val !== null) {
+          if (schema.type === "string") schema.maxLength = val;
+          else schema.maximum = val;
+        }
+        break;
+      }
+      case "describe": {
+        const desc = getStringArg(args[0]);
+        if (desc) schema.description = desc;
+        break;
+      }
+      case "default": {
+        const arg = args[0];
+        if (arg) schema.default = tryParseValue(arg.getText());
+        break;
+      }
+      case "optional":
+      case "nullish":
+        schema.nullable = true;
+        break;
+      case "positive":
+        schema.minimum = 0;
+        break;
+      case "negative":
+        schema.maximum = 0;
+        break;
+      case "int":
+        schema.type = "integer";
+        break;
+      case "regex": {
+        const pattern = args[0]?.getText();
+        if (pattern) schema.pattern = pattern.replace(/^\/|\/[gimsuy]*$/g, "");
+        break;
+      }
+    }
+  }
+};
+var isOptionalZodExpr = (node) => {
+  const text = node.getText();
+  return text.includes(".optional()") || text.includes(".nullish()") || text.startsWith("z.optional(");
+};
+var getNumericArg = (node) => {
+  if (!node) return null;
+  const val = Number(node.getText());
+  return isNaN(val) ? null : val;
+};
+var getStringArg = (node) => {
+  if (!node) return null;
+  const text = node.getText();
+  const match = text.match(/^['"`](.*?)['"`]$/s);
+  return match?.[1] ?? null;
+};
+var tryParseValue = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text.replace(/['"]/g, "");
+  }
+};
+var extractZodSchemas = (sourceFile) => {
+  const schemas = {};
+  const varDeclarations = sourceFile.getVariableDeclarations();
+  for (const decl of varDeclarations) {
+    const init = decl.getInitializer();
+    if (!init) continue;
+    const text = init.getText();
+    if (!text.startsWith("z.")) continue;
+    const name = decl.getName();
+    try {
+      schemas[name] = zodNodeToJsonSchema(init);
+    } catch {
+    }
+  }
+  return schemas;
+};
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+var findTsConfig = (startDir) => {
+  let dir = startDir;
+  for (let i = 0; i < 5; i++) {
+    const candidate = join2(dir, "tsconfig.json");
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+};
+var extractExpressRoutes = async (config) => {
+  const cwd = existsSync2(config.entry) && !config.entry.endsWith(".ts") && !config.entry.endsWith(".js") ? config.entry : dirname(config.entry);
+  const tsConfigPath = findTsConfig(cwd);
+  const project = tsConfigPath ? new Project({ tsConfigFilePath: tsConfigPath, skipAddingFilesFromTsConfig: true }) : new Project({ compilerOptions: { allowJs: true, strict: false } });
+  const patterns = ["**/*.ts", "**/*.js"].map((p) => resolve2(cwd, "**", p));
+  const files = await glob(`${cwd}/**/*.{ts,js}`, {
+    ignore: ["**/node_modules/**", "**/dist/**", "**/*.d.ts", "**/*.spec.*", "**/*.test.*"]
+  });
+  for (const file of files) {
+    project.addSourceFileAtPath(file);
+  }
+  const globalZodSchemas = {};
+  for (const sourceFile of project.getSourceFiles()) {
+    Object.assign(globalZodSchemas, extractZodSchemas(sourceFile));
+  }
+  const allRoutes = [];
+  for (const sourceFile of project.getSourceFiles()) {
+    const ctx = { zodSchemas: globalZodSchemas, routerPrefix: "" };
+    const routes = extractRoutesFromFile(sourceFile, ctx);
+    allRoutes.push(...routes);
+  }
+  return deduplicateRoutes(allRoutes);
+};
+var extractRoutesFromFile = (sourceFile, ctx) => {
+  const routes = [];
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind2.CallExpression);
+  for (const call of callExpressions) {
+    const route = tryExtractRoute(call, ctx);
+    if (route) routes.push(route);
+  }
+  return routes;
+};
+var tryExtractRoute = (call, ctx) => {
+  const expr = call.getExpression();
+  if (!Node2.isPropertyAccessExpression(expr)) return null;
+  const methodName = expr.getName().toUpperCase();
+  if (!HTTP_METHODS.includes(methodName)) return null;
+  const args = call.getArguments();
+  if (args.length < 2) return null;
+  const firstArg = args[0];
+  if (!firstArg) return null;
+  if (!Node2.isStringLiteral(firstArg) && !Node2.isTemplateExpression(firstArg) && !Node2.isNoSubstitutionTemplateLiteral(firstArg)) {
+    return null;
+  }
+  const rawPath = firstArg.getText().replace(/['"'`]/g, "");
+  const path = normalizePath(ctx.routerPrefix, rawPath);
+  const method = methodName;
+  const middlewareArgs = args.slice(1, -1);
+  const handlerArg = args[args.length - 1];
+  const { requestBody, parameters } = extractFromMiddleware(middlewareArgs, ctx);
+  const pathParams = extractPathParameters(path);
+  const handlerInfo = extractHandlerInfo(handlerArg);
+  const allParameters = mergeParameters(parameters, pathParams);
+  const tags = inferTags(path);
+  const route = {
+    method,
+    path,
+    tags,
+    parameters: allParameters,
+    responses: buildDefaultResponses(method),
+    middleware: middlewareArgs.map((m) => m.getText())
+  };
+  if (handlerInfo.summary !== void 0) route.summary = handlerInfo.summary;
+  if (handlerInfo.description !== void 0) route.description = handlerInfo.description;
+  if (requestBody !== null) route.requestBody = requestBody;
+  return route;
+};
+var extractFromMiddleware = (middleware, ctx) => {
+  let requestBody = null;
+  const parameters = [];
+  for (const mw of middleware) {
+    const text = mw.getText();
+    const bodyMatch = text.match(/(?:validateBody|validate|zodValidate|bodyParser)\((\w+)\)/);
+    if (bodyMatch) {
+      const schemaName = bodyMatch[1];
+      const schema = schemaName ? ctx.zodSchemas[schemaName] : null;
+      if (schema) {
+        requestBody = {
+          required: true,
+          content: { "application/json": { schema } }
+        };
+      }
+    }
+    const queryMatch = text.match(/(?:validateQuery|queryValidator)\((\w+)\)/);
+    if (queryMatch) {
+      const schemaName = queryMatch[1];
+      const schema = schemaName ? ctx.zodSchemas[schemaName] : null;
+      if (schema?.type === "object" && schema.properties) {
+        for (const [name, propSchema] of Object.entries(schema.properties)) {
+          parameters.push({
+            name,
+            in: "query",
+            required: schema.required?.includes(name) ?? false,
+            schema: propSchema
+          });
+        }
+      }
+    }
+  }
+  return { requestBody, parameters };
+};
+var extractPathParameters = (path) => {
+  const paramRegex = /:(\w+)/g;
+  const params = [];
+  let match;
+  while ((match = paramRegex.exec(path)) !== null) {
+    const name = match[1];
+    if (name) {
+      params.push({
+        name,
+        in: "path",
+        required: true,
+        schema: { type: "string" }
+      });
+    }
+  }
+  return params;
+};
+var extractHandlerInfo = (handler) => {
+  const leadingComments = handler.getLeadingCommentRanges();
+  if (leadingComments.length === 0) return {};
+  const comment = leadingComments[leadingComments.length - 1];
+  if (!comment) return {};
+  const text = comment.getText();
+  const summary = extractJsDocTag(text, null);
+  const description = extractJsDocTag(text, "description");
+  const result = {};
+  if (summary !== null) result.summary = summary;
+  if (description !== null) result.description = description;
+  return result;
+};
+var extractJsDocTag = (comment, tag) => {
+  if (tag === null) {
+    const match2 = comment.match(/\/\*\*\s*\n?\s*\*\s*(.+)/);
+    return match2?.[1]?.trim() ?? null;
+  }
+  const match = comment.match(new RegExp(`@${tag}\\s+(.+)`));
+  return match?.[1]?.trim() ?? null;
+};
+var mergeParameters = (fromMiddleware, fromPath) => {
+  const existing = new Set(fromMiddleware.map((p) => `${p.in}:${p.name}`));
+  const merged = [...fromMiddleware];
+  for (const param of fromPath) {
+    if (!existing.has(`${param.in}:${param.name}`)) {
+      merged.push(param);
+    }
+  }
+  return merged;
+};
+var normalizePath = (prefix, path) => {
+  const combined = `${prefix}${path}`.replace(/\/+/g, "/");
+  return combined.startsWith("/") ? combined : `/${combined}`;
+};
+var inferTags = (path) => {
+  const segments = path.split("/").filter(Boolean);
+  const tag = segments.find((s) => !s.startsWith(":"));
+  return tag ? [tag] : ["default"];
+};
+var buildDefaultResponses = (method) => {
+  const responses = {
+    "200": { description: method === "DELETE" ? "Success" : "Successful response" },
+    "400": { description: "Bad request" },
+    "401": { description: "Unauthorized" },
+    "500": { description: "Internal server error" }
+  };
+  if (method === "POST") {
+    responses["201"] = { description: "Created" };
+  }
+  if (method === "DELETE") {
+    responses["204"] = { description: "No content" };
+  }
+  return responses;
+};
+var deduplicateRoutes = (routes) => {
+  const seen = /* @__PURE__ */ new Set();
+  return routes.filter((r) => {
+    const key = `${r.method}:${r.path}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+var buildSpec = (routes, config) => {
+  const groups = groupRoutes(routes, config.groups);
+  return {
+    info: {
+      title: config.name,
+      version: config.version ?? "1.0.0",
+      baseUrl: config.baseUrl ?? "http://localhost:3000",
+      ...config.description !== void 0 ? { description: config.description } : {}
+    },
+    ...config.auth !== void 0 ? { auth: config.auth } : {},
+    groups,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceFramework: config.framework
+  };
+};
+var groupRoutes = (routes, groupConfig) => {
+  if (!groupConfig) {
+    return groupByTag(routes);
+  }
+  const groups = [];
+  const assignedRoutes = /* @__PURE__ */ new Set();
+  for (const [groupName, patterns] of Object.entries(groupConfig)) {
+    const matched = routes.filter((r) => {
+      const key = `${r.method}:${r.path}`;
+      if (assignedRoutes.has(key)) return false;
+      const matches = patterns.some((pattern) => matchesGlob(r.path, pattern));
+      if (matches) assignedRoutes.add(key);
+      return matches;
+    });
+    if (matched.length > 0) {
+      groups.push({ name: groupName, routes: matched });
+    }
+  }
+  const unassigned = routes.filter(
+    (r) => !assignedRoutes.has(`${r.method}:${r.path}`)
+  );
+  if (unassigned.length > 0) {
+    groups.push({ name: "Other", routes: unassigned });
+  }
+  return groups;
+};
+var groupByTag = (routes) => {
+  const tagMap = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const tag = route.tags[0] ?? "default";
+    if (!tagMap.has(tag)) tagMap.set(tag, []);
+    tagMap.get(tag).push(route);
+  }
+  return Array.from(tagMap.entries()).map(([name, groupRoutes2]) => ({
+    name: capitalize(name),
+    routes: groupRoutes2
+  }));
+};
+var matchesGlob = (path, pattern) => {
+  const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\/\*\*$/, "(/.*)?").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+  return new RegExp(`^${regexStr}$`).test(path);
+};
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+
+// src/generate.ts
+var generate = async (opts = {}) => {
+  const cwd = process.cwd();
+  const spinner = opts.quiet ? null : ora();
+  spinner?.start("Loading flowdoc config...");
+  const configPath = opts.config ? resolve3(cwd, opts.config) : findConfigFile(cwd);
+  if (!configPath) {
+    spinner?.fail(chalk.red("No flowdoc.config.ts found. Run `flowdoc init` first."));
+    process.exit(1);
+  }
+  let rawConfig;
+  try {
+    rawConfig = await loadConfig(configPath);
+  } catch (err) {
+    spinner?.fail(chalk.red(`Failed to load config: ${String(err)}`));
+    process.exit(1);
+  }
+  const config = resolveConfig(rawConfig, cwd);
+  spinner?.succeed(`Config loaded \u2014 ${chalk.cyan(config.name)}`);
+  spinner?.start(`Scanning ${chalk.cyan(config.entry)} for routes...`);
+  let routes;
+  try {
+    routes = await extractExpressRoutes(config);
+  } catch (err) {
+    spinner?.fail(chalk.red(`Parse failed: ${String(err)}`));
+    process.exit(1);
+  }
+  spinner?.succeed(
+    `Found ${chalk.green(String(routes.length))} routes across ${chalk.cyan(config.framework)} app`
+  );
+  const spec = buildSpec(routes, config);
+  const outputDir = opts.output ? resolve3(cwd, opts.output) : config.output ?? resolve3(cwd, "docs-output");
+  mkdirSync(outputDir, { recursive: true });
+  const specPath = join3(outputDir, "flowdoc.json");
+  writeFileSync(specPath, JSON.stringify(spec, null, 2), "utf-8");
+  await writeUiHtml(outputDir, config);
+  if (!opts.quiet) {
+    console.log();
+    console.log(chalk.bold("  flowdoc generated successfully"));
+    console.log();
+    console.log(`  ${chalk.gray("Spec:")}   ${chalk.cyan(specPath)}`);
+    console.log(`  ${chalk.gray("UI:")}     ${chalk.cyan(join3(outputDir, "index.html"))}`);
+    console.log();
+    console.log(`  ${chalk.gray("Routes:")} ${chalk.green(String(routes.length))}`);
+    console.log(`  ${chalk.gray("Groups:")} ${chalk.green(String(spec.groups.length))}`);
+    console.log();
+  }
+  return spec;
+};
+var writeUiHtml = async (outputDir, config) => {
+  const brand = config.theme?.brand ?? "#6366f1";
+  const title = config.name;
+  const darkMode = config.theme?.darkMode !== false;
+  const cliRoot = dirname2(dirname2(fileURLToPath(import.meta.url)));
+  const uiAssetsSource = join3(cliRoot, "ui-assets");
+  const uiAssetsDest = join3(outputDir, "assets");
+  if (existsSync3(uiAssetsSource)) {
+    mkdirSync(uiAssetsDest, { recursive: true });
+    cpSync(uiAssetsSource, uiAssetsDest, { recursive: true });
+  }
+  const html = generateHtmlShell({ title, brand, darkMode });
+  writeFileSync(join3(outputDir, "index.html"), html, "utf-8");
+};
+var generateHtmlShell = ({ title, brand, darkMode }) => `<!DOCTYPE html>
+<html lang="en" class="${darkMode ? "dark" : ""}">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${title} \u2014 API Docs</title>
+    <meta name="description" content="API documentation generated by flowdoc" />
+    <script>
+      window.__FLOWDOC_BRAND__ = "${brand}";
+      window.__FLOWDOC_DARK__ = ${String(darkMode)};
+    </script>
+    <script type="module" crossorigin src="./assets/ui.js"></script>
+    <link rel="stylesheet" href="./assets/index.css" />
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>`;
+
+export {
+  findConfigFile,
+  loadConfig,
+  resolveConfig,
+  generate
+};

package/dist/generate-E4V2RQYB.js

@@ -0,0 +1,6 @@
+import {
+  generate
+} from "./chunk-SAMPAR3A.js";
+export {
+  generate
+};

package/dist/generate-J6FGBLQ4.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import {
+  generate
+} from "./chunk-3GGK6LWE.js";
+export {
+  generate
+};

package/dist/generate-MNQL7RGI.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import {
+  generate
+} from "./chunk-XXW6UJOX.js";
+export {
+  generate
+};

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { FlowDocSpec } from '@flowdoc/core';
+import { Request, Response, NextFunction } from 'express';
+
+interface GenerateOptions {
+    config?: string;
+    output?: string;
+    quiet?: boolean;
+}
+declare const generate: (opts?: GenerateOptions) => Promise<FlowDocSpec>;
+
+interface ServeOptions extends GenerateOptions {
+    port?: number;
+    noOpen?: boolean;
+    watch?: boolean;
+}
+declare const serve: (opts?: ServeOptions) => Promise<void>;
+
+declare const init: (cwd?: string) => void;
+
+interface FlowDocMiddlewareOptions {
+    /** Path to flowdoc.config.ts — defaults to auto-discovery from cwd */
+    config?: string;
+    /** Route prefix the middleware is mounted at — used only for the HTML shell */
+    path?: string;
+}
+/**
+ * Express middleware that serves flowdoc docs at whatever route you mount it on.
+ * baseUrl is auto-derived from each incoming request — no manual config needed.
+ *
+ * Usage:
+ *   import { flowdoc } from "flowdoc";
+ *   app.use("/docs", flowdoc());
+ */
+declare const flowdoc: (opts?: FlowDocMiddlewareOptions) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
+
+export { type FlowDocMiddlewareOptions, type GenerateOptions, type ServeOptions, flowdoc, generate, init, serve };