flowdoc-gen 0.1.1 → 0.1.3

package/dist/{chunk-3GGK6LWE.js → index.cjs}

@@ -1,15 +1,53 @@
-#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  defineConfig: () => defineConfig,
+  flowdoc: () => flowdoc,
+  generate: () => generate,
+  init: () => init,
+  serve: () => serve
+});
+module.exports = __toCommonJS(src_exports);
 
 // 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";
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_url = require("url");
+var import_chalk = __toESM(require("chalk"), 1);
+var import_ora = __toESM(require("ora"), 1);
 
 // ../core/dist/index.js
-import { existsSync } from "fs";
-import { resolve, join } from "path";
+var import_fs = require("fs");
+var import_path = require("path");
 var CONFIG_FILES = [
   "flowdoc.config.ts",
   "flowdoc.config.js",
@@ -17,13 +55,13 @@ var CONFIG_FILES = [
 ];
 var findConfigFile = (cwd) => {
   for (const file of CONFIG_FILES) {
-    const full = join(cwd, file);
-    if (existsSync(full)) return full;
+    const full = (0, import_path.join)(cwd, file);
+    if ((0, import_fs.existsSync)(full)) return full;
   }
   return null;
 };
 var loadConfig = async (configPath) => {
-  const resolved = resolve(configPath);
+  const resolved = (0, import_path.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}`);
@@ -33,25 +71,21 @@ 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")
+  entry: (0, import_path.resolve)(cwd, config.entry),
+  output: (0, import_path.resolve)(cwd, config.output ?? "./docs-output")
 });
 
 // ../parser/dist/index.js
-import {
-  Project,
-  Node as Node5,
-  SyntaxKind as SyntaxKind3
-} 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";
-import { Node as Node2 } from "ts-morph";
-import { Node as Node3 } from "ts-morph";
-import { Node as Node4 } from "ts-morph";
+var import_ts_morph = require("ts-morph");
+var import_glob = require("glob");
+var import_path2 = require("path");
+var import_fs2 = require("fs");
+var import_ts_morph2 = require("ts-morph");
+var import_ts_morph3 = require("ts-morph");
+var import_ts_morph4 = require("ts-morph");
+var import_ts_morph5 = require("ts-morph");
 var zodNodeToJsonSchema = (node) => {
-  if (!Node.isCallExpression(node)) return {};
+  if (!import_ts_morph2.Node.isCallExpression(node)) return {};
   const expr = node.getExpression();
   const callText = expr.getText();
   if (callText === "z.string") return buildStringSchema(node);
@@ -68,7 +102,7 @@ var zodNodeToJsonSchema = (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)) {
+  if (import_ts_morph2.Node.isPropertyAccessExpression(expr)) {
     return buildChainedSchema(node);
   }
   return {};
@@ -91,23 +125,23 @@ var buildLiteralSchema = (node) => {
 };
 var buildEnumSchema = (node) => {
   const arg = node.getArguments()[0];
-  if (!arg || !Node.isArrayLiteralExpression(arg)) return { type: "string" };
+  if (!arg || !import_ts_morph2.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" };
+  if (!arg || !import_ts_morph2.Node.isObjectLiteralExpression(arg)) return { type: "object" };
   const properties = {};
   const required = [];
   for (const prop of arg.getProperties()) {
-    if (!Node.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph2.Node.isPropertyAssignment(prop)) continue;
     const name = prop.getName();
-    const init = prop.getInitializer();
-    if (!init) continue;
-    const childSchema = zodNodeToJsonSchema(init);
+    const init2 = prop.getInitializer();
+    if (!init2) continue;
+    const childSchema = zodNodeToJsonSchema(init2);
     properties[name] = childSchema;
-    if (!isOptionalZodExpr(init)) {
+    if (!isOptionalZodExpr(init2)) {
       required.push(name);
     }
   }
@@ -124,7 +158,7 @@ var buildArraySchema = (node) => {
 };
 var buildUnionSchema = (node) => {
   const arg = node.getArguments()[0];
-  if (!arg || !Node.isArrayLiteralExpression(arg)) return {};
+  if (!arg || !import_ts_morph2.Node.isArrayLiteralExpression(arg)) return {};
   const schemas = arg.getElements().map((el) => zodNodeToJsonSchema(el));
   return { anyOf: schemas };
 };
@@ -143,11 +177,11 @@ var buildChainedSchema = (node) => {
 var unwrapChain = (node) => {
   const methods = [];
   let current = node;
-  while (Node.isCallExpression(current)) {
+  while (import_ts_morph2.Node.isCallExpression(current)) {
     const expr = current.getExpression();
-    if (Node.isPropertyAccessExpression(expr)) {
+    if (import_ts_morph2.Node.isPropertyAccessExpression(expr)) {
       const obj = expr.getExpression();
-      if (Node.isIdentifier(obj)) {
+      if (import_ts_morph2.Node.isIdentifier(obj)) {
         return { root: current, methods };
       }
       const methodName = expr.getName();
@@ -252,13 +286,13 @@ 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();
+    const init2 = decl.getInitializer();
+    if (!init2) continue;
+    const text = init2.getText();
     if (!text.startsWith("z.")) continue;
     const name = decl.getName();
     try {
-      schemas[name] = zodNodeToJsonSchema(init);
+      schemas[name] = zodNodeToJsonSchema(init2);
     } catch {
     }
   }
@@ -276,7 +310,7 @@ var YUP_ROOT_METHODS = /* @__PURE__ */ new Set([
   "lazy"
 ]);
 var yupNodeToJsonSchema = (node) => {
-  if (!Node2.isCallExpression(node)) return {};
+  if (!import_ts_morph3.Node.isCallExpression(node)) return {};
   const chain = unwrapYupChain(node);
   if (!chain.root) return {};
   const base = buildYupBase(chain.rootMethod);
@@ -286,17 +320,17 @@ var yupNodeToJsonSchema = (node) => {
 var unwrapYupChain = (node) => {
   const methods = [];
   let current = node;
-  while (Node2.isCallExpression(current)) {
+  while (import_ts_morph3.Node.isCallExpression(current)) {
     const expr = current.getExpression();
-    if (!Node2.isPropertyAccessExpression(expr)) {
-      if (Node2.isIdentifier(expr) && YUP_ROOT_METHODS.has(expr.getText())) {
+    if (!import_ts_morph3.Node.isPropertyAccessExpression(expr)) {
+      if (import_ts_morph3.Node.isIdentifier(expr) && YUP_ROOT_METHODS.has(expr.getText())) {
         return { root: current, rootMethod: expr.getText(), methods };
       }
       return { root: null, rootMethod: "", methods };
     }
     const obj = expr.getExpression();
     const methodName = expr.getName();
-    if (Node2.isIdentifier(obj) && obj.getText() === "yup" && YUP_ROOT_METHODS.has(methodName)) {
+    if (import_ts_morph3.Node.isIdentifier(obj) && obj.getText() === "yup" && YUP_ROOT_METHODS.has(methodName)) {
       return { root: current, rootMethod: methodName, methods };
     }
     methods.unshift({ name: methodName, args: current.getArguments() });
@@ -379,14 +413,14 @@ var applyYupChain = (methods, schema) => {
         break;
       case "oneOf": {
         const arg = args[0];
-        if (arg && Node2.isArrayLiteralExpression(arg)) {
+        if (arg && import_ts_morph3.Node.isArrayLiteralExpression(arg)) {
           schema.enum = arg.getElements().map((el) => el.getText().replace(/['"]/g, ""));
         }
         break;
       }
       case "shape": {
         const arg = args[0];
-        if (arg && Node2.isObjectLiteralExpression(arg)) {
+        if (arg && import_ts_morph3.Node.isObjectLiteralExpression(arg)) {
           const { properties, required: req } = parseYupShape(arg);
           schema.type = "object";
           schema.properties = properties;
@@ -406,9 +440,9 @@ var applyYupChain = (methods, schema) => {
       }
       case "meta": {
         const arg = args[0];
-        if (arg && Node2.isObjectLiteralExpression(arg)) {
+        if (arg && import_ts_morph3.Node.isObjectLiteralExpression(arg)) {
           for (const prop of arg.getProperties()) {
-            if (Node2.isPropertyAssignment(prop) && prop.getName() === "description") {
+            if (import_ts_morph3.Node.isPropertyAssignment(prop) && prop.getName() === "description") {
               const s = getStr(prop.getInitializer());
               if (s) schema.description = s;
             }
@@ -428,13 +462,13 @@ var applyYupChain = (methods, schema) => {
 var parseYupShape = (arg) => {
   const properties = {};
   const required = [];
-  if (!arg || !Node2.isObjectLiteralExpression(arg)) return { properties, required };
+  if (!arg || !import_ts_morph3.Node.isObjectLiteralExpression(arg)) return { properties, required };
   for (const prop of arg.getProperties()) {
-    if (!Node2.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph3.Node.isPropertyAssignment(prop)) continue;
     const name = prop.getName();
-    const init = prop.getInitializer();
-    if (!init) continue;
-    const childSchema = yupNodeToJsonSchema(init);
+    const init2 = prop.getInitializer();
+    if (!init2) continue;
+    const childSchema = yupNodeToJsonSchema(init2);
     const isReq = childSchema.__required === true;
     delete childSchema.__required;
     properties[name] = childSchema;
@@ -463,12 +497,12 @@ var isYupExpr = (text) => /^yup\.(?:string|number|boolean|object|array|date|mixe
 var extractYupSchemas = (sourceFile) => {
   const schemas = {};
   for (const decl of sourceFile.getVariableDeclarations()) {
-    const init = decl.getInitializer();
-    if (!init) continue;
-    const text = init.getText();
+    const init2 = decl.getInitializer();
+    if (!init2) continue;
+    const text = init2.getText();
     if (!isYupExpr(text)) continue;
     try {
-      const schema = yupNodeToJsonSchema(init);
+      const schema = yupNodeToJsonSchema(init2);
       if (Object.keys(schema).length > 0) schemas[decl.getName()] = schema;
     } catch {
     }
@@ -488,7 +522,7 @@ var JOI_PRIMITIVES = /* @__PURE__ */ new Set([
   "link"
 ]);
 var joiNodeToJsonSchema = (node, joiId = "Joi") => {
-  if (!Node3.isCallExpression(node)) return {};
+  if (!import_ts_morph4.Node.isCallExpression(node)) return {};
   const chain = unwrapJoiChain(node, joiId);
   if (!chain.root) return {};
   const base = buildJoiBase(chain.rootMethod);
@@ -498,14 +532,14 @@ var joiNodeToJsonSchema = (node, joiId = "Joi") => {
 var unwrapJoiChain = (node, joiId) => {
   const methods = [];
   let current = node;
-  while (Node3.isCallExpression(current)) {
+  while (import_ts_morph4.Node.isCallExpression(current)) {
     const expr = current.getExpression();
-    if (!Node3.isPropertyAccessExpression(expr)) {
+    if (!import_ts_morph4.Node.isPropertyAccessExpression(expr)) {
       return { root: null, rootMethod: "", methods };
     }
     const obj = expr.getExpression();
     const methodName = expr.getName();
-    if (Node3.isIdentifier(obj) && obj.getText() === joiId && JOI_PRIMITIVES.has(methodName)) {
+    if (import_ts_morph4.Node.isIdentifier(obj) && obj.getText() === joiId && JOI_PRIMITIVES.has(methodName)) {
       return { root: current, rootMethod: methodName, methods };
     }
     methods.unshift({ name: methodName, args: current.getArguments() });
@@ -603,7 +637,7 @@ var applyJoiChain = (methods, schema, joiId) => {
       }
       case "keys": {
         const arg = args[0];
-        if (arg && Node3.isObjectLiteralExpression(arg)) {
+        if (arg && import_ts_morph4.Node.isObjectLiteralExpression(arg)) {
           const { properties, required } = parseJoiKeys(arg, joiId);
           schema.type = "object";
           schema.properties = properties;
@@ -637,13 +671,13 @@ var applyJoiChain = (methods, schema, joiId) => {
 var parseJoiKeys = (arg, joiId) => {
   const properties = {};
   const required = [];
-  if (!arg || !Node3.isObjectLiteralExpression(arg)) return { properties, required };
+  if (!arg || !import_ts_morph4.Node.isObjectLiteralExpression(arg)) return { properties, required };
   for (const prop of arg.getProperties()) {
-    if (!Node3.isPropertyAssignment(prop)) continue;
+    if (!import_ts_morph4.Node.isPropertyAssignment(prop)) continue;
     const name = prop.getName();
-    const init = prop.getInitializer();
-    if (!init) continue;
-    const childSchema = joiNodeToJsonSchema(init, joiId);
+    const init2 = prop.getInitializer();
+    if (!init2) continue;
+    const childSchema = joiNodeToJsonSchema(init2, joiId);
     const isReq = childSchema.__required === true;
     delete childSchema.__required;
     properties[name] = childSchema;
@@ -683,11 +717,11 @@ var extractJoiSchemas = (sourceFile) => {
   const joiId = detectJoiId(sourceFile);
   if (!joiId) return schemas;
   for (const decl of sourceFile.getVariableDeclarations()) {
-    const init = decl.getInitializer();
-    if (!init) continue;
-    if (!isJoiExpr(init.getText(), joiId)) continue;
+    const init2 = decl.getInitializer();
+    if (!init2) continue;
+    if (!isJoiExpr(init2.getText(), joiId)) continue;
     try {
-      const schema = joiNodeToJsonSchema(init, joiId);
+      const schema = joiNodeToJsonSchema(init2, joiId);
       if (Object.keys(schema).length > 0) schemas[decl.getName()] = schema;
     } catch {
     }
@@ -777,7 +811,7 @@ var extractClassValidatorSchemas = (sourceFile) => {
           const firstArg = call?.getArguments()[0];
           if (firstArg) {
             const raw = firstArg.getText();
-            if (Node4.isArrayLiteralExpression(firstArg)) {
+            if (import_ts_morph5.Node.isArrayLiteralExpression(firstArg)) {
               const values = firstArg.getElements().map((el) => el.getText().replace(/['"]/g, ""));
               CONSTRAINED[name](propSchema, values);
             } else {
@@ -824,20 +858,20 @@ 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);
+    const candidate = (0, import_path2.join)(dir, "tsconfig.json");
+    if ((0, import_fs2.existsSync)(candidate)) return candidate;
+    const parent = (0, import_path2.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 cwd = (0, import_fs2.existsSync)(config.entry) && !config.entry.endsWith(".ts") && !config.entry.endsWith(".js") ? config.entry : (0, import_path2.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}`, {
+  const project = tsConfigPath ? new import_ts_morph.Project({ tsConfigFilePath: tsConfigPath, skipAddingFilesFromTsConfig: true }) : new import_ts_morph.Project({ compilerOptions: { allowJs: true, strict: false } });
+  const patterns = ["**/*.ts", "**/*.js"].map((p) => (0, import_path2.resolve)(cwd, "**", p));
+  const files = await (0, import_glob.glob)(`${cwd}/**/*.{ts,js}`, {
     ignore: ["**/node_modules/**", "**/dist/**", "**/*.d.ts", "**/*.spec.*", "**/*.test.*"]
   });
   for (const file of files) {
@@ -860,7 +894,7 @@ var extractExpressRoutes = async (config) => {
 };
 var extractRoutesFromFile = (sourceFile, ctx) => {
   const routes = [];
-  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind3.CallExpression);
+  const callExpressions = sourceFile.getDescendantsOfKind(import_ts_morph.SyntaxKind.CallExpression);
   for (const call of callExpressions) {
     const route = tryExtractRoute(call, ctx);
     if (route) routes.push(route);
@@ -869,14 +903,14 @@ var extractRoutesFromFile = (sourceFile, ctx) => {
 };
 var tryExtractRoute = (call, ctx) => {
   const expr = call.getExpression();
-  if (!Node5.isPropertyAccessExpression(expr)) return null;
+  if (!import_ts_morph.Node.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 (!Node5.isStringLiteral(firstArg) && !Node5.isTemplateExpression(firstArg) && !Node5.isNoSubstitutionTemplateLiteral(firstArg)) {
+  if (!import_ts_morph.Node.isStringLiteral(firstArg) && !import_ts_morph.Node.isTemplateExpression(firstArg) && !import_ts_morph.Node.isNoSubstitutionTemplateLiteral(firstArg)) {
     return null;
   }
   const rawPath = firstArg.getText().replace(/['"'`]/g, "");
@@ -1077,50 +1111,51 @@ var matchesGlob = (path, pattern) => {
 var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
 
 // src/generate.ts
+var import_meta = {};
 var generate = async (opts = {}) => {
   const cwd = process.cwd();
-  const spinner = opts.quiet ? null : ora();
+  const spinner = opts.quiet ? null : (0, import_ora.default)();
   spinner?.start("Loading flowdoc config...");
-  const configPath = opts.config ? resolve3(cwd, opts.config) : findConfigFile(cwd);
+  const configPath = opts.config ? (0, import_path3.resolve)(cwd, opts.config) : findConfigFile(cwd);
   if (!configPath) {
-    spinner?.fail(chalk.red("No flowdoc.config.ts found. Run `flowdoc init` first."));
+    spinner?.fail(import_chalk.default.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)}`));
+    spinner?.fail(import_chalk.default.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...`);
+  spinner?.succeed(`Config loaded \u2014 ${import_chalk.default.cyan(config.name)}`);
+  spinner?.start(`Scanning ${import_chalk.default.cyan(config.entry)} for routes...`);
   let routes;
   try {
     routes = await extractExpressRoutes(config);
   } catch (err) {
-    spinner?.fail(chalk.red(`Parse failed: ${String(err)}`));
+    spinner?.fail(import_chalk.default.red(`Parse failed: ${String(err)}`));
     process.exit(1);
   }
   spinner?.succeed(
-    `Found ${chalk.green(String(routes.length))} routes across ${chalk.cyan(config.framework)} app`
+    `Found ${import_chalk.default.green(String(routes.length))} routes across ${import_chalk.default.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");
+  const outputDir = opts.output ? (0, import_path3.resolve)(cwd, opts.output) : config.output ?? (0, import_path3.resolve)(cwd, "docs-output");
+  (0, import_fs3.mkdirSync)(outputDir, { recursive: true });
+  const specPath = (0, import_path3.join)(outputDir, "flowdoc.json");
+  (0, import_fs3.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(import_chalk.default.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(`  ${import_chalk.default.gray("Spec:")}   ${import_chalk.default.cyan(specPath)}`);
+    console.log(`  ${import_chalk.default.gray("UI:")}     ${import_chalk.default.cyan((0, import_path3.join)(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(`  ${import_chalk.default.gray("Routes:")} ${import_chalk.default.green(String(routes.length))}`);
+    console.log(`  ${import_chalk.default.gray("Groups:")} ${import_chalk.default.green(String(spec.groups.length))}`);
     console.log();
   }
   return spec;
@@ -1129,15 +1164,15 @@ 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 cliRoot = (0, import_path3.dirname)((0, import_path3.dirname)((0, import_url.fileURLToPath)(import_meta.url)));
+  const uiAssetsSource = (0, import_path3.join)(cliRoot, "ui-assets");
+  const uiAssetsDest = (0, import_path3.join)(outputDir, "assets");
+  if ((0, import_fs3.existsSync)(uiAssetsSource)) {
+    (0, import_fs3.mkdirSync)(uiAssetsDest, { recursive: true });
+    (0, import_fs3.cpSync)(uiAssetsSource, uiAssetsDest, { recursive: true });
   }
   const html = generateHtmlShell({ title, brand, darkMode });
-  writeFileSync(join3(outputDir, "index.html"), html, "utf-8");
+  (0, import_fs3.writeFileSync)((0, import_path3.join)(outputDir, "index.html"), html, "utf-8");
 };
 var generateHtmlShell = ({ title, brand, darkMode }) => `<!DOCTYPE html>
 <html lang="en" class="${darkMode ? "dark" : ""}">
@@ -1158,9 +1193,218 @@ var generateHtmlShell = ({ title, brand, darkMode }) => `<!DOCTYPE html>
   </body>
 </html>`;
 
-export {
-  findConfigFile,
-  loadConfig,
-  resolveConfig,
-  generate
+// src/serve.ts
+var import_http = require("http");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var import_chalk2 = __toESM(require("chalk"), 1);
+var import_open = __toESM(require("open"), 1);
+var import_chokidar = __toESM(require("chokidar"), 1);
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon"
 };
+var serve = async (opts = {}) => {
+  const cwd = process.cwd();
+  const outputDir = opts.output ?? (0, import_path4.join)(cwd, "docs-output");
+  const port = opts.port ?? 4e3;
+  await generate({ ...opts, quiet: false });
+  const server = (0, import_http.createServer)((req, res) => {
+    const url = req.url === "/" || req.url === "" ? "/index.html" : req.url ?? "/index.html";
+    const filePath = (0, import_path4.join)(outputDir, url);
+    if (!(0, import_fs4.existsSync)(filePath)) {
+      res.writeHead(404);
+      res.end("Not found");
+      return;
+    }
+    const ext = (0, import_path4.extname)(filePath);
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "Content-Type": contentType });
+    (0, import_fs4.createReadStream)(filePath).pipe(res);
+  });
+  server.listen(port, () => {
+    const url = `http://localhost:${port}`;
+    console.log();
+    console.log(`  ${import_chalk2.default.bold("flowdoc")} is running at ${import_chalk2.default.cyan(url)}`);
+    if (opts.watch) {
+      console.log(`  ${import_chalk2.default.dim("watching for changes\u2026")}`);
+    }
+    console.log();
+    if (!opts.noOpen) {
+      void (0, import_open.default)(url);
+    }
+  });
+  if (!opts.watch) return;
+  const configPath = opts.config ?? findConfigFile(cwd) ?? "";
+  let watchGlob = "src/**/*.ts";
+  if (configPath) {
+    try {
+      const raw = await loadConfig(configPath);
+      const config = resolveConfig(raw, cwd);
+      const entryDir = (0, import_path4.resolve)(cwd, config.entry).replace(/\/[^/]+$/, "");
+      watchGlob = `${entryDir}/**/*.ts`;
+    } catch {
+    }
+  }
+  let rebuilding = false;
+  const watcher = import_chokidar.default.watch(watchGlob, {
+    ignoreInitial: true,
+    ignored: ["**/node_modules/**", "**/dist/**", "**/docs-output/**"]
+  });
+  const rebuild = async (filePath) => {
+    if (rebuilding) return;
+    rebuilding = true;
+    console.log(`  ${import_chalk2.default.dim("\u2192")} ${import_chalk2.default.yellow(filePath.replace(cwd + "/", ""))} changed \u2014 regenerating\u2026`);
+    try {
+      await generate({ ...opts, quiet: true });
+      console.log(`  ${import_chalk2.default.green("\u2713")} docs updated`);
+    } catch (err) {
+      console.error(`  ${import_chalk2.default.red("\u2717")} regeneration failed:`, err instanceof Error ? err.message : err);
+    } finally {
+      rebuilding = false;
+    }
+  };
+  watcher.on("add", rebuild).on("change", rebuild).on("unlink", rebuild);
+  process.on("SIGINT", () => {
+    void watcher.close();
+    server.close();
+    process.exit(0);
+  });
+};
+
+// src/init.ts
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+var import_chalk3 = __toESM(require("chalk"), 1);
+var CONFIG_TEMPLATE = `import { defineConfig } from "flowdoc-gen";
+
+export default defineConfig({
+  name: "My API",
+  version: "1.0.0",
+  description: "API documentation generated by flowdoc",
+  framework: "express",
+  entry: "./src",
+  output: "./docs-output",
+  theme: {
+    brand: "#6366f1",
+    darkMode: true,
+  },
+  // groups: [
+  //   { name: "Auth",  match: "/auth/**" },
+  //   { name: "Users", match: "/users/**" },
+  // ],
+});
+`;
+var init = (cwd = process.cwd()) => {
+  const configPath = (0, import_path5.resolve)(cwd, "flowdoc.config.ts");
+  if ((0, import_fs5.existsSync)(configPath)) {
+    console.log(import_chalk3.default.yellow("  flowdoc.config.ts already exists \u2014 skipping."));
+    return;
+  }
+  (0, import_fs5.writeFileSync)(configPath, CONFIG_TEMPLATE, "utf-8");
+  console.log();
+  console.log(`  ${import_chalk3.default.bold("flowdoc")} initialized`);
+  console.log();
+  console.log(`  Created ${import_chalk3.default.cyan("flowdoc.config.ts")}`);
+  console.log();
+  console.log("  Next steps:");
+  console.log(`    1. Edit ${import_chalk3.default.cyan("flowdoc.config.ts")} \u2014 set your entry path`);
+  console.log(`    2. Run ${import_chalk3.default.cyan("flowdoc generate")} to build your docs`);
+  console.log(`    3. Run ${import_chalk3.default.cyan("flowdoc serve")} to preview locally`);
+  console.log();
+};
+
+// src/middleware.ts
+var import_fs6 = require("fs");
+var import_path6 = require("path");
+var import_url2 = require("url");
+var import_meta2 = {};
+var MIME = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json"
+};
+var flowdoc = (opts = {}) => {
+  const cwd = process.cwd();
+  let outputDir = null;
+  let ready = false;
+  let initError = null;
+  const init2 = (async () => {
+    try {
+      const configPath = opts.config ?? findConfigFile(cwd);
+      if (!configPath) throw new Error("No flowdoc.config.ts found. Run `flowdoc init` first.");
+      const rawConfig = await loadConfig(configPath);
+      const config = resolveConfig(rawConfig, cwd);
+      outputDir = config.output ?? (0, import_path6.join)(cwd, "docs-output");
+      const routes = await extractExpressRoutes(config);
+      const spec = buildSpec(routes, config);
+      (0, import_fs6.mkdirSync)(outputDir, { recursive: true });
+      (0, import_fs6.writeFileSync)((0, import_path6.join)(outputDir, "flowdoc.json"), JSON.stringify(spec, null, 2));
+      const cliRoot = (0, import_path6.dirname)((0, import_path6.dirname)((0, import_url2.fileURLToPath)(import_meta2.url)));
+      const uiAssetsSource = (0, import_path6.join)(cliRoot, "ui-assets");
+      if ((0, import_fs6.existsSync)(uiAssetsSource)) {
+        const dest = (0, import_path6.join)(outputDir, "assets");
+        (0, import_fs6.mkdirSync)(dest, { recursive: true });
+        (0, import_fs6.cpSync)(uiAssetsSource, dest, { recursive: true });
+      }
+      ready = true;
+    } catch (err) {
+      initError = err instanceof Error ? err.message : String(err);
+    }
+  })();
+  return async (req, res, next) => {
+    await init2;
+    if (initError || !outputDir) {
+      res.status(500).send(`flowdoc init failed: ${initError}`);
+      return;
+    }
+    const urlPath = req.path === "/" || req.path === "" ? "/index.html" : req.path;
+    if (urlPath === "/index.html") {
+      const brand = "#6366f1";
+      const baseUrl = `${req.protocol}://${req.get("host")}`;
+      res.setHeader("Content-Type", "text/html");
+      res.send(buildHtml({ baseUrl, brand }));
+      return;
+    }
+    const filePath = (0, import_path6.join)(outputDir, urlPath);
+    if (!(0, import_fs6.existsSync)(filePath)) {
+      next();
+      return;
+    }
+    const mime = MIME[(0, import_path6.extname)(filePath)] ?? "application/octet-stream";
+    res.setHeader("Content-Type", mime);
+    (0, import_fs6.createReadStream)(filePath).pipe(res);
+  };
+};
+var buildHtml = ({ baseUrl, brand }) => `<!DOCTYPE html>
+<html lang="en" class="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>API Docs</title>
+    <script>
+      window.__FLOWDOC_BRAND__ = "${brand}";
+      window.__FLOWDOC_BASE_URL__ = "${baseUrl}";
+    </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>`;
+
+// src/index.ts
+var defineConfig = (config) => config;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig,
+  flowdoc,
+  generate,
+  init,
+  serve
+});