@hyperfixi/server-bridge 2.0.0

package/dist/cli.cjs

@@ -0,0 +1,1853 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli/scan-command.ts
+var import_node_path2 = require("path");
+
+// src/scanner/route-scanner.ts
+var import_promises = require("fs/promises");
+var import_glob = require("glob");
+
+// src/conventions/url-patterns.ts
+function extractPathParams(url) {
+  const params = [];
+  for (const match of url.matchAll(/:(\w+)/g)) {
+    params.push(match[1]);
+  }
+  for (const match of url.matchAll(/\{(\w+)\}/g)) {
+    if (!params.includes(match[1])) {
+      params.push(match[1]);
+    }
+  }
+  return params;
+}
+function normalizeUrl(url) {
+  let normalized = url.split("?")[0].split("#")[0];
+  normalized = normalized.replace(/\{(\w+)\}/g, ":$1");
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function urlToHandlerName(url, method) {
+  const prefix = method.toLowerCase();
+  const segments = url.replace(/^\//, "").split("/").map((segment) => {
+    if (segment.startsWith(":")) {
+      const param = segment.slice(1);
+      return "By" + capitalize(param);
+    }
+    return segment.split(/[-_]/).map(capitalize).join("");
+  });
+  return prefix + segments.join("");
+}
+function extractQueryParams(url) {
+  const queryIndex = url.indexOf("?");
+  if (queryIndex === -1) return [];
+  const queryString = url.slice(queryIndex + 1).split("#")[0];
+  if (!queryString) return [];
+  const params = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pair of queryString.split("&")) {
+    const eqIndex = pair.indexOf("=");
+    const rawName = eqIndex === -1 ? pair : pair.slice(0, eqIndex);
+    if (!rawName) continue;
+    let name;
+    try {
+      name = decodeURIComponent(rawName);
+    } catch {
+      name = rawName;
+    }
+    if (seen.has(name)) continue;
+    seen.add(name);
+    params.push({ name, type: "string", required: true });
+  }
+  return params;
+}
+function capitalize(s) {
+  if (!s) return "";
+  return s[0].toUpperCase() + s.slice(1);
+}
+
+// src/conventions/convention-engine.ts
+function inferConventions(url, context = {}) {
+  const notes = [];
+  let method;
+  if (context.explicitMethod) {
+    method = context.explicitMethod.toUpperCase();
+  } else if (context.elementTag === "form") {
+    method = "POST";
+    notes.push("Inferred POST from <form> context");
+  } else {
+    method = "GET";
+  }
+  let responseFormat;
+  if (context.fetchResponseType) {
+    const fmt = context.fetchResponseType.toLowerCase();
+    if (fmt === "json" || fmt === "html" || fmt === "text") {
+      responseFormat = fmt;
+    } else {
+      responseFormat = "json";
+      notes.push(`Unknown response type "${context.fetchResponseType}", defaulting to json`);
+    }
+  } else if (url.endsWith(".html") || url.includes("/pages/") || url.includes("/partials/")) {
+    responseFormat = "html";
+    notes.push("Inferred html response from URL pattern");
+  } else {
+    responseFormat = "json";
+  }
+  const handlerName = urlToHandlerName(url, method);
+  return { method, responseFormat, handlerName, notes };
+}
+
+// src/scanner/hyperscript-extractor.ts
+var ATTR_PATTERNS = [
+  /_\s*=\s*"([^"]+)"/g,
+  /_\s*=\s*'([^']+)'/g,
+  /_\s*=\s*`([^`]+)`/g,
+  /_=\{`([^`]+)`\}/g,
+  // JSX template literal
+  /_=\{['"]([^'"]+)['"]\}/g
+  // JSX string
+];
+var SCRIPT_PATTERN = /<script[^>]*type=["']?text\/hyperscript["']?[^>]*>([\s\S]*?)<\/script>/gi;
+var FETCH_COMMAND = /\bfetch\s+['"]?([^\s'"]+)['"]?(?:\s+as\s+(\w+))?(?:\s+via\s+(\w+))?/gi;
+var SEND_FORM = /\bsend\s+(?:the\s+)?form\s+to\s+['"]?([^\s'"]+)['"]?(?:\s+as\s+(\w+))?/gi;
+function extractHyperscriptRoutes(content, options) {
+  const routes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const regions = extractHyperscriptRegions(content);
+  for (const region of regions) {
+    for (const match of region.code.matchAll(FETCH_COMMAND)) {
+      const rawUrl = match[1];
+      const responseType = match[2];
+      const method = match[3];
+      addRoute(routes, seen, rawUrl, {
+        file: options.file,
+        line: region.line,
+        kind: "fetch",
+        raw: match[0],
+        explicitMethod: method,
+        fetchResponseType: responseType
+      });
+    }
+    for (const match of region.code.matchAll(SEND_FORM)) {
+      const rawUrl = match[1];
+      const responseType = match[2];
+      addRoute(routes, seen, rawUrl, {
+        file: options.file,
+        line: region.line,
+        kind: "fetch",
+        raw: match[0],
+        explicitMethod: "POST",
+        fetchResponseType: responseType
+      });
+    }
+  }
+  return routes;
+}
+function extractHyperscriptRegions(content) {
+  const regions = [];
+  const lines = content.split("\n");
+  for (const pattern of ATTR_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match2;
+    while ((match2 = pattern.exec(content)) !== null) {
+      const line = lineNumberAt(content, match2.index);
+      regions.push({ code: match2[1], line });
+    }
+  }
+  SCRIPT_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = SCRIPT_PATTERN.exec(content)) !== null) {
+    const line = lineNumberAt(content, match.index);
+    regions.push({ code: match[1], line });
+  }
+  return regions;
+}
+function lineNumberAt(content, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < content.length; i++) {
+    if (content[i] === "\n") line++;
+  }
+  return line;
+}
+function addRoute(routes, seen, rawUrl, options) {
+  if (rawUrl.startsWith("http://") || rawUrl.startsWith("https://")) {
+    return;
+  }
+  if (rawUrl.startsWith("{{") || rawUrl.startsWith("${")) {
+    return;
+  }
+  if (!rawUrl.startsWith("/") && !rawUrl.includes("/")) {
+    return;
+  }
+  const queryParams = extractQueryParams(rawUrl);
+  const path = normalizeUrl(rawUrl);
+  const conventions = inferConventions(path, {
+    explicitMethod: options.explicitMethod,
+    fetchResponseType: options.fetchResponseType
+  });
+  const key = `${conventions.method}:${path}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  routes.push({
+    path,
+    method: conventions.method,
+    responseFormat: conventions.responseFormat,
+    source: {
+      file: options.file,
+      line: options.line,
+      kind: options.kind,
+      raw: options.raw
+    },
+    pathParams: extractPathParams(path),
+    ...queryParams.length > 0 ? { queryParams } : {},
+    handlerName: conventions.handlerName,
+    notes: conventions.notes
+  });
+}
+
+// src/scanner/htmx-extractor.ts
+var HTMX_REQUEST_PATTERN = /\b(hx-get|hx-post|hx-put|hx-patch|hx-delete)\s*=\s*["']([^"']+)["']/gi;
+var FIXI_ACTION_PATTERN = /\bfx-action\s*=\s*["']([^"']+)["']/gi;
+var FIXI_METHOD_PATTERN = /\bfx-method\s*=\s*["'](GET|POST|PUT|PATCH|DELETE)["']/gi;
+var HTMX_METHOD_MAP = {
+  "hx-get": "GET",
+  "hx-post": "POST",
+  "hx-put": "PUT",
+  "hx-patch": "PATCH",
+  "hx-delete": "DELETE"
+};
+function extractHtmxRoutes(content, options) {
+  const routes = [];
+  const seen = /* @__PURE__ */ new Set();
+  HTMX_REQUEST_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = HTMX_REQUEST_PATTERN.exec(content)) !== null) {
+    const attrName = match[1].toLowerCase();
+    const rawUrl = match[2];
+    const method = HTMX_METHOD_MAP[attrName];
+    if (!method) continue;
+    addRoute2(routes, seen, rawUrl, {
+      file: options.file,
+      line: lineNumberAt2(content, match.index),
+      kind: "hx-attr",
+      raw: `${match[1]}="${match[2]}"`,
+      explicitMethod: method,
+      // htmx default response is html (server-rendered partials)
+      fetchResponseType: "html"
+    });
+  }
+  const fxMethods = collectFxMethods(content);
+  FIXI_ACTION_PATTERN.lastIndex = 0;
+  while ((match = FIXI_ACTION_PATTERN.exec(content)) !== null) {
+    const rawUrl = match[1];
+    const line = lineNumberAt2(content, match.index);
+    const nearbyMethod = findNearbyFxMethod(content, match.index, fxMethods);
+    addRoute2(routes, seen, rawUrl, {
+      file: options.file,
+      line,
+      kind: "fx-attr",
+      raw: `fx-action="${match[1]}"`,
+      explicitMethod: nearbyMethod
+    });
+  }
+  return routes;
+}
+function lineNumberAt2(content, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < content.length; i++) {
+    if (content[i] === "\n") line++;
+  }
+  return line;
+}
+function collectFxMethods(content) {
+  const methods = [];
+  FIXI_METHOD_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = FIXI_METHOD_PATTERN.exec(content)) !== null) {
+    methods.push({ method: match[1], index: match.index });
+  }
+  return methods;
+}
+function findNearbyFxMethod(content, actionIndex, fxMethods) {
+  for (const fm of fxMethods) {
+    if (Math.abs(fm.index - actionIndex) < 300) {
+      return fm.method;
+    }
+  }
+  return void 0;
+}
+function addRoute2(routes, seen, rawUrl, options) {
+  if (rawUrl.startsWith("http://") || rawUrl.startsWith("https://")) {
+    return;
+  }
+  const queryParams = extractQueryParams(rawUrl);
+  const path = normalizeUrl(rawUrl);
+  const conventions = inferConventions(path, {
+    explicitMethod: options.explicitMethod,
+    fetchResponseType: options.fetchResponseType
+  });
+  const key = `${conventions.method}:${path}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  routes.push({
+    path,
+    method: conventions.method,
+    responseFormat: conventions.responseFormat,
+    source: {
+      file: options.file,
+      line: options.line,
+      kind: options.kind,
+      raw: options.raw
+    },
+    pathParams: extractPathParams(path),
+    ...queryParams.length > 0 ? { queryParams } : {},
+    handlerName: conventions.handlerName,
+    notes: conventions.notes
+  });
+}
+
+// src/scanner/form-scanner.ts
+var FORM_BLOCK = /<form\b[^>]*>([\s\S]*?)<\/form>/gi;
+var NAMED_FIELD = /<(input|select|textarea)\b([^>]*)\bname\s*=\s*["']([^"']+)["']([^>]*)>/gi;
+var TYPE_ATTR = /\btype\s*=\s*["']([^"']+)["']/i;
+var REQUIRED_ATTR = /\brequired\b/i;
+var TYPE_MAP = {
+  text: "string",
+  email: "string",
+  password: "string",
+  tel: "string",
+  url: "string",
+  search: "string",
+  hidden: "string",
+  color: "string",
+  date: "string",
+  "datetime-local": "string",
+  month: "string",
+  week: "string",
+  time: "string",
+  number: "number",
+  range: "number",
+  checkbox: "boolean",
+  file: "file"
+};
+function extractFormFields(formInnerHtml) {
+  const fields = [];
+  const seen = /* @__PURE__ */ new Set();
+  NAMED_FIELD.lastIndex = 0;
+  let match;
+  while ((match = NAMED_FIELD.exec(formInnerHtml)) !== null) {
+    const tag = match[1].toLowerCase();
+    const attrsBefore = match[2];
+    const name = match[3];
+    const attrsAfter = match[4];
+    const allAttrs = attrsBefore + " " + attrsAfter;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    let type = "string";
+    if (tag === "select" || tag === "textarea") {
+      type = "string";
+    } else {
+      const typeMatch = allAttrs.match(TYPE_ATTR);
+      const inputType = typeMatch ? typeMatch[1].toLowerCase() : "text";
+      type = TYPE_MAP[inputType] ?? "unknown";
+    }
+    const required = REQUIRED_ATTR.test(allAttrs);
+    fields.push({ name, type, required });
+  }
+  return fields;
+}
+function extractFormBodies(content) {
+  const result = /* @__PURE__ */ new Map();
+  FORM_BLOCK.lastIndex = 0;
+  let match;
+  while ((match = FORM_BLOCK.exec(content)) !== null) {
+    const formTag = content.slice(
+      match.index,
+      match.index + content.slice(match.index).indexOf(">") + 1
+    );
+    const formBody = match[1];
+    const url = extractFormUrl(formTag);
+    if (!url) continue;
+    const fields = extractFormFields(formBody);
+    if (fields.length > 0) {
+      result.set(url, fields);
+    }
+  }
+  return result;
+}
+function extractFormUrl(formTag) {
+  const hxMatch = formTag.match(/\bhx-(?:post|put|patch)\s*=\s*["']([^"']+)["']/i);
+  if (hxMatch) return hxMatch[1];
+  const fxMatch = formTag.match(/\bfx-action\s*=\s*["']([^"']+)["']/i);
+  if (fxMatch) return fxMatch[1];
+  const hsMatch = formTag.match(/\bsend\s+(?:the\s+)?form\s+to\s+['"]?([^\s'"]+)['"]?/i);
+  if (hsMatch) return hsMatch[1];
+  return void 0;
+}
+
+// src/scanner/conflict-detector.ts
+function detectConflicts(routes) {
+  const warnings = [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = `${route.method}:${route.path}`;
+    const existing = groups.get(key) ?? [];
+    existing.push(route);
+    groups.set(key, existing);
+  }
+  for (const [key, groupRoutes] of groups) {
+    if (groupRoutes.length < 2) continue;
+    const conflicts = [];
+    const formats = [...new Set(groupRoutes.map((r) => r.responseFormat))];
+    if (formats.length > 1) {
+      conflicts.push({
+        field: "responseFormat",
+        values: formats,
+        message: `Conflicting response formats: ${formats.join(" vs ")}`
+      });
+    }
+    if (["POST", "PUT", "PATCH"].includes(groupRoutes[0].method)) {
+      const bodySignatures = groupRoutes.map(
+        (r) => JSON.stringify((r.requestBody ?? []).map((f) => f.name).sort())
+      );
+      const uniqueSignatures = [...new Set(bodySignatures)];
+      if (uniqueSignatures.length > 1) {
+        conflicts.push({
+          field: "requestBody",
+          values: uniqueSignatures,
+          message: "Request body fields differ across declarations"
+        });
+      }
+    }
+    const querySignatures = groupRoutes.map(
+      (r) => JSON.stringify((r.queryParams ?? []).map((p) => p.name).sort())
+    );
+    const uniqueQuerySigs = [...new Set(querySignatures)];
+    if (uniqueQuerySigs.length > 1) {
+      conflicts.push({
+        field: "queryParams",
+        values: uniqueQuerySigs,
+        message: "Query parameters differ across declarations"
+      });
+    }
+    if (conflicts.length > 0) {
+      warnings.push({
+        routeKey: key,
+        conflicts,
+        sources: groupRoutes.map((r) => r.source)
+      });
+    }
+  }
+  return warnings;
+}
+function formatConflicts(warnings) {
+  const lines = [];
+  for (const warning of warnings) {
+    lines.push(`  ${warning.routeKey}:`);
+    for (const conflict of warning.conflicts) {
+      lines.push(`    - ${conflict.message}`);
+    }
+    lines.push(`    Sources:`);
+    for (const source of warning.sources) {
+      lines.push(`      ${source.file}:${source.line ?? "?"} (${source.kind})`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/scanner/route-scanner.ts
+var DEFAULT_INCLUDE = ["**/*.html", "**/*.htm"];
+var DEFAULT_EXCLUDE = ["**/node_modules/**", "**/dist/**", "**/.git/**"];
+function scanRoutes(content, file) {
+  const hsRoutes = extractHyperscriptRoutes(content, { file });
+  const htmxRoutes = extractHtmxRoutes(content, { file });
+  const all = [...hsRoutes, ...htmxRoutes];
+  const deduped = deduplicateRoutes(all);
+  const formBodies = extractFormBodies(content);
+  for (const route of deduped) {
+    if (["POST", "PUT", "PATCH"].includes(route.method)) {
+      const rawUrl = route.path;
+      const fields = formBodies.get(rawUrl);
+      if (fields && fields.length > 0) {
+        route.requestBody = fields;
+      }
+    }
+  }
+  return deduped;
+}
+async function scanDirectory(dir, options = {}) {
+  const include = options.include ?? DEFAULT_INCLUDE;
+  const exclude = options.exclude ?? DEFAULT_EXCLUDE;
+  const files = [];
+  for (const pattern of include) {
+    const matches = await (0, import_glob.glob)(pattern, {
+      cwd: dir,
+      absolute: true,
+      ignore: exclude
+    });
+    files.push(...matches);
+  }
+  const uniqueFiles = [...new Set(files)];
+  const allRoutes = [];
+  const errors = [];
+  for (const file of uniqueFiles) {
+    try {
+      const content = await (0, import_promises.readFile)(file, "utf-8");
+      const routes = scanRoutes(content, file);
+      allRoutes.push(...routes);
+    } catch (err) {
+      errors.push({
+        file,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const conflicts = detectConflicts(allRoutes);
+  const deduped = deduplicateRoutes(allRoutes);
+  const ignored = options.ignore ?? [];
+  const filtered = deduped.filter(
+    (route) => !ignored.some((pattern) => matchIgnorePattern(route.path, pattern))
+  );
+  return {
+    routes: filtered,
+    filesScanned: uniqueFiles,
+    errors,
+    conflicts
+  };
+}
+function deduplicateRoutes(routes) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = `${route.method}:${route.path}`;
+    if (!seen.has(key)) {
+      seen.set(key, route);
+    }
+  }
+  return [...seen.values()];
+}
+function matchIgnorePattern(path, pattern) {
+  if (pattern.endsWith("/**")) {
+    const prefix = pattern.slice(0, -3);
+    return path.startsWith(prefix);
+  }
+  return path === pattern;
+}
+
+// src/cli/config.ts
+var import_promises2 = require("fs/promises");
+var import_node_path = require("path");
+var CONFIG_FILENAMES = [".serverbridgerc.json", ".serverbridgerc", "serverbridge.config.json"];
+async function loadConfig(cwd, overrides = {}) {
+  let fileConfig = {};
+  for (const filename of CONFIG_FILENAMES) {
+    try {
+      const content = await (0, import_promises2.readFile)((0, import_node_path.join)(cwd, filename), "utf-8");
+      fileConfig = JSON.parse(content);
+      break;
+    } catch {
+    }
+  }
+  return {
+    framework: overrides.framework ?? fileConfig.framework ?? "express",
+    output: overrides.output ?? fileConfig.output ?? "./server/routes",
+    typescript: overrides.typescript ?? fileConfig.typescript ?? true,
+    include: overrides.include ?? fileConfig.include ?? ["**/*.{html,htm}"],
+    exclude: overrides.exclude ?? fileConfig.exclude ?? ["node_modules/**", "dist/**"],
+    basePath: overrides.basePath ?? fileConfig.basePath,
+    ignore: overrides.ignore ?? fileConfig.ignore
+  };
+}
+
+// src/cli/scan-command.ts
+async function runScan(options) {
+  const cwd = (0, import_node_path2.resolve)(options.dir);
+  const config = await loadConfig(cwd, {
+    include: options.include,
+    exclude: options.exclude,
+    ignore: options.ignore
+  });
+  const result = await scanDirectory(cwd, {
+    include: config.include,
+    exclude: config.exclude,
+    ignore: config.ignore
+  });
+  if (result.errors.length > 0) {
+    for (const err of result.errors) {
+      console.error(`Error in ${err.file}: ${err.message}`);
+    }
+  }
+  if (result.conflicts.length > 0) {
+    console.error(
+      `
+Warning: ${result.conflicts.length} route conflict(s) detected:
+${formatConflicts(result.conflicts)}
+`
+    );
+  }
+  if (options.format === "table") {
+    printTable(result.routes);
+  } else {
+    console.log(JSON.stringify(result, null, 2));
+  }
+}
+function printTable(routes) {
+  if (routes.length === 0) {
+    console.log("No routes found.");
+    return;
+  }
+  console.log(`Found ${routes.length} route(s):
+`);
+  console.log("  METHOD  PATH                          FORMAT  SOURCE");
+  console.log("  ------  ----------------------------  ------  ------");
+  for (const route of routes) {
+    const method = route.method.padEnd(6);
+    const path = route.path.padEnd(28);
+    const format = route.responseFormat.padEnd(6);
+    const source = route.source.kind;
+    console.log(`  ${method}  ${path}  ${format}  ${source}`);
+  }
+}
+
+// src/cli/generate-command.ts
+var import_node_path4 = require("path");
+var import_promises4 = require("fs/promises");
+
+// src/generators/template-helpers.ts
+var ROUTE_MARKER = "// @serverbridge-route:";
+var USER_START = "// @serverbridge-user-start";
+var USER_END = "// @serverbridge-user-end";
+function routeMarker(route) {
+  return `${ROUTE_MARKER} ${route.method} ${route.path}`;
+}
+function todoBlock(route, indent = "  ") {
+  const lines = [];
+  lines.push(`${indent}// TODO: Implement ${route.method} ${route.path}`);
+  if (route.pathParams.length > 0) {
+    lines.push(`${indent}// Path params: ${route.pathParams.join(", ")}`);
+  }
+  if (route.queryParams && route.queryParams.length > 0) {
+    lines.push(`${indent}// Query params: ${route.queryParams.map((p) => p.name).join(", ")}`);
+  }
+  if (route.requestBody && route.requestBody.length > 0) {
+    const fields = route.requestBody.map((f) => `${f.name}: ${f.type}${f.required ? "" : "?"}`).join(", ");
+    lines.push(`${indent}// Expected body: { ${fields} }`);
+  }
+  if (route.notes.length > 0) {
+    for (const note of route.notes) {
+      lines.push(`${indent}// Note: ${note}`);
+    }
+  }
+  return lines.join("\n");
+}
+function groupRoutesByPrefix(routes) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const segments = route.path.replace(/^\//, "").split("/");
+    const groupKey = segments.slice(0, Math.min(2, segments.length)).filter((s) => !s.startsWith(":")).join("-") || "root";
+    const group = groups.get(groupKey) ?? [];
+    group.push(route);
+    groups.set(groupKey, group);
+  }
+  return groups;
+}
+function groupToFilename(groupKey, typescript) {
+  return `${groupKey}.${typescript ? "ts" : "js"}`;
+}
+
+// src/generators/express-generator.ts
+var ExpressGenerator = class {
+  framework = "express";
+  generate(routes, options) {
+    const ts = options.typescript !== false;
+    const files = [];
+    const warnings = [];
+    if (routes.length === 0) {
+      warnings.push("No routes to generate");
+      return { files, preserved: [], warnings };
+    }
+    const groups = groupRoutesByPrefix(routes);
+    for (const [groupKey, groupRoutes] of groups) {
+      const filename = groupToFilename(groupKey, ts);
+      const content = this.generateRouterFile(groupRoutes, groupKey, ts);
+      files.push({ path: `routes/${filename}`, content, isNew: true });
+    }
+    const indexContent = this.generateIndex(groups, ts);
+    files.push({ path: `routes/index.${ts ? "ts" : "js"}`, content: indexContent, isNew: true });
+    return { files, preserved: [], warnings };
+  }
+  generateRouterFile(routes, groupKey, ts) {
+    const lines = [];
+    lines.push(`// Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT scaffold markers`);
+    lines.push(`import { Router${ts ? ", Request, Response" : ""} } from 'express';`);
+    lines.push("");
+    lines.push("const router = Router();");
+    lines.push("");
+    for (const route of routes) {
+      lines.push(routeMarker(route));
+      lines.push(this.generateHandler(route, ts));
+      lines.push("");
+    }
+    lines.push("export default router;");
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateHandler(route, ts) {
+    const method = route.method.toLowerCase();
+    const params = ts ? "(req: Request, res: Response)" : "(req, res)";
+    const lines = [];
+    lines.push(`router.${method}('${route.path}', async ${params} => {`);
+    lines.push(`  ${USER_START}`);
+    lines.push(todoBlock(route, "  "));
+    if (route.pathParams.length > 0) {
+      const paramList = route.pathParams.join(", ");
+      lines.push(`  const { ${paramList} } = req.params;`);
+    }
+    if (route.queryParams && route.queryParams.length > 0) {
+      const paramList = route.queryParams.map((p) => p.name).join(", ");
+      lines.push(`  const { ${paramList} } = req.query;`);
+    }
+    if (route.requestBody && route.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(route.method)) {
+      const fieldList = route.requestBody.map((f) => f.name).join(", ");
+      lines.push(`  const { ${fieldList} } = req.body;`);
+    }
+    if (route.responseFormat === "json") {
+      lines.push(`  res.json({ message: 'Not implemented' });`);
+    } else if (route.responseFormat === "html") {
+      lines.push(`  res.send('<div>Not implemented</div>');`);
+    } else {
+      lines.push(`  res.send('Not implemented');`);
+    }
+    lines.push(`  ${USER_END}`);
+    lines.push(`});`);
+    return lines.join("\n");
+  }
+  generateIndex(groups, ts) {
+    const lines = [];
+    lines.push(`// Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`import { Router } from 'express';`);
+    for (const groupKey of groups.keys()) {
+      const filename = groupKey;
+      lines.push(`import ${toCamelCase(groupKey)}Router from './${filename}.js';`);
+    }
+    lines.push("");
+    lines.push("const router = Router();");
+    lines.push("");
+    for (const groupKey of groups.keys()) {
+      lines.push(`router.use(${toCamelCase(groupKey)}Router);`);
+    }
+    lines.push("");
+    lines.push("export default router;");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+function toCamelCase(str) {
+  return str.replace(/-(\w)/g, (_, c) => c.toUpperCase());
+}
+
+// src/generators/hono-generator.ts
+var HonoGenerator = class {
+  framework = "hono";
+  generate(routes, options) {
+    const ts = options.typescript !== false;
+    const files = [];
+    const warnings = [];
+    if (routes.length === 0) {
+      warnings.push("No routes to generate");
+      return { files, preserved: [], warnings };
+    }
+    const groups = groupRoutesByPrefix(routes);
+    for (const [groupKey, groupRoutes] of groups) {
+      const filename = groupToFilename(groupKey, ts);
+      const content = this.generateRouteFile(groupRoutes, groupKey, ts);
+      files.push({ path: `routes/${filename}`, content, isNew: true });
+    }
+    const indexContent = this.generateIndex(groups, ts);
+    files.push({ path: `routes/index.${ts ? "ts" : "js"}`, content: indexContent, isNew: true });
+    return { files, preserved: [], warnings };
+  }
+  generateRouteFile(routes, groupKey, ts) {
+    const lines = [];
+    lines.push(`// Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT scaffold markers`);
+    lines.push(`import { Hono } from 'hono';`);
+    lines.push("");
+    lines.push("const app = new Hono();");
+    lines.push("");
+    for (const route of routes) {
+      lines.push(routeMarker(route));
+      lines.push(this.generateHandler(route, ts));
+      lines.push("");
+    }
+    lines.push("export default app;");
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateHandler(route, ts) {
+    const method = route.method.toLowerCase();
+    const lines = [];
+    lines.push(`app.${method}('${route.path}', async (c) => {`);
+    lines.push(`  ${USER_START}`);
+    lines.push(todoBlock(route, "  "));
+    if (route.pathParams.length > 0) {
+      for (const param of route.pathParams) {
+        lines.push(`  const ${param} = c.req.param('${param}');`);
+      }
+    }
+    if (route.queryParams && route.queryParams.length > 0) {
+      for (const param of route.queryParams) {
+        lines.push(`  const ${param.name} = c.req.query('${param.name}');`);
+      }
+    }
+    if (route.requestBody && route.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(route.method)) {
+      lines.push(`  const body = await c.req.json();`);
+      const fieldList = route.requestBody.map((f) => f.name).join(", ");
+      lines.push(`  const { ${fieldList} } = body;`);
+    }
+    if (route.responseFormat === "json") {
+      lines.push(`  return c.json({ message: 'Not implemented' });`);
+    } else if (route.responseFormat === "html") {
+      lines.push(`  return c.html('<div>Not implemented</div>');`);
+    } else {
+      lines.push(`  return c.text('Not implemented');`);
+    }
+    lines.push(`  ${USER_END}`);
+    lines.push(`});`);
+    return lines.join("\n");
+  }
+  generateIndex(groups, ts) {
+    const lines = [];
+    lines.push(`// Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`import { Hono } from 'hono';`);
+    for (const groupKey of groups.keys()) {
+      const filename = groupKey;
+      lines.push(`import ${toCamelCase2(groupKey)}Routes from './${filename}.js';`);
+    }
+    lines.push("");
+    lines.push("const app = new Hono();");
+    lines.push("");
+    for (const groupKey of groups.keys()) {
+      lines.push(`app.route('/', ${toCamelCase2(groupKey)}Routes);`);
+    }
+    lines.push("");
+    lines.push("export default app;");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+function toCamelCase2(str) {
+  return str.replace(/-(\w)/g, (_, c) => c.toUpperCase());
+}
+
+// src/generators/openapi-generator.ts
+var OpenAPIGenerator = class {
+  framework = "openapi";
+  generate(routes, options) {
+    const files = [];
+    const warnings = [];
+    if (routes.length === 0) {
+      warnings.push("No routes to generate");
+      return { files, preserved: [], warnings };
+    }
+    const spec = this.buildSpec(routes);
+    const yaml = this.toYaml(spec);
+    files.push({
+      path: "openapi.yaml",
+      content: yaml,
+      isNew: true
+    });
+    return { files, preserved: [], warnings };
+  }
+  buildSpec(routes) {
+    const paths = {};
+    for (const route of routes) {
+      const oaPath = route.path.replace(/:(\w+)/g, "{$1}");
+      const method = route.method.toLowerCase();
+      if (!paths[oaPath]) {
+        paths[oaPath] = {};
+      }
+      paths[oaPath][method] = this.buildOperation(route);
+    }
+    return {
+      openapi: "3.1.0",
+      info: {
+        title: "ServerBridge Generated API",
+        version: "0.1.0",
+        description: "Auto-extracted from hyperscript/htmx attributes"
+      },
+      paths
+    };
+  }
+  buildOperation(route) {
+    const op = {
+      operationId: route.handlerName,
+      summary: `Source: ${route.source.file}${route.source.line ? ":" + route.source.line : ""} (${route.source.kind})`,
+      responses: {
+        "200": this.buildResponse(route)
+      }
+    };
+    if (route.pathParams.length > 0) {
+      op.parameters = route.pathParams.map((name) => ({
+        name,
+        in: "path",
+        required: true,
+        schema: { type: inferParamType(name) }
+      }));
+    }
+    if (route.queryParams && route.queryParams.length > 0) {
+      const queryParamSpecs = route.queryParams.map((param) => ({
+        name: param.name,
+        in: "query",
+        required: param.required,
+        schema: { type: "string" }
+      }));
+      if (op.parameters) {
+        op.parameters.push(...queryParamSpecs);
+      } else {
+        op.parameters = queryParamSpecs;
+      }
+    }
+    if (route.requestBody && route.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(route.method)) {
+      const required = route.requestBody.filter((f) => f.required).map((f) => f.name);
+      const properties = {};
+      for (const field of route.requestBody) {
+        properties[field.name] = fieldToSchema(field.type);
+      }
+      op.requestBody = {
+        required: required.length > 0,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              ...required.length > 0 ? { required } : {},
+              properties
+            }
+          }
+        }
+      };
+    }
+    return op;
+  }
+  buildResponse(route) {
+    const contentType = route.responseFormat === "json" ? "application/json" : route.responseFormat === "html" ? "text/html" : "text/plain";
+    return {
+      description: "Success",
+      content: {
+        [contentType]: {
+          schema: route.responseFormat === "json" ? { type: "object" } : { type: "string" }
+        }
+      }
+    };
+  }
+  /**
+   * Minimal YAML serializer — avoids adding a yaml dependency.
+   * Handles the specific nested structure of OpenAPI specs.
+   */
+  toYaml(obj, indent = 0) {
+    const pad = "  ".repeat(indent);
+    if (obj === null || obj === void 0) {
+      return "null";
+    }
+    if (typeof obj === "string") {
+      if (obj === "" || obj.includes(":") || obj.includes("#") || obj.includes("'") || /^\d/.test(obj) || obj === "true" || obj === "false") {
+        return `'${obj.replace(/'/g, "''")}'`;
+      }
+      return obj;
+    }
+    if (typeof obj === "number" || typeof obj === "boolean") {
+      return String(obj);
+    }
+    if (Array.isArray(obj)) {
+      if (obj.length === 0) return "[]";
+      if (obj.every((item) => typeof item === "string" || typeof item === "number")) {
+        return `[${obj.map((item) => typeof item === "string" ? `'${item}'` : String(item)).join(", ")}]`;
+      }
+      return obj.map((item) => {
+        if (typeof item === "object" && item !== null) {
+          const inner = this.toYaml(item, indent + 1).trimStart();
+          return `${pad}- ${inner}`;
+        }
+        return `${pad}- ${this.toYaml(item)}`;
+      }).join("\n");
+    }
+    if (typeof obj === "object") {
+      const entries = Object.entries(obj);
+      if (entries.length === 0) return "{}";
+      return entries.map(([key, value]) => {
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+          const inner = this.toYaml(value, indent + 1);
+          return `${pad}${key}:
+${inner}`;
+        }
+        if (Array.isArray(value) && value.length > 0 && value.some((v) => typeof v === "object")) {
+          const inner = this.toYaml(value, indent + 1);
+          return `${pad}${key}:
+${inner}`;
+        }
+        return `${pad}${key}: ${this.toYaml(value, indent + 1)}`;
+      }).join("\n");
+    }
+    return String(obj);
+  }
+};
+function inferParamType(name) {
+  if (name === "id" || name.endsWith("Id")) return "string";
+  if (name === "page" || name === "limit" || name === "offset") return "integer";
+  return "string";
+}
+function fieldToSchema(type) {
+  switch (type) {
+    case "number":
+      return { type: "number" };
+    case "boolean":
+      return { type: "boolean" };
+    case "file":
+      return { type: "string", format: "binary" };
+    default:
+      return { type: "string" };
+  }
+}
+
+// src/generators/django-generator.ts
+var PY_ROUTE_MARKER = "# @serverbridge-route:";
+var PY_USER_START = "# @serverbridge-user-start";
+var PY_USER_END = "# @serverbridge-user-end";
+var DjangoGenerator = class {
+  framework = "django";
+  generate(routes, options) {
+    const files = [];
+    const warnings = [];
+    if (routes.length === 0) {
+      warnings.push("No routes to generate");
+      return { files, preserved: [], warnings };
+    }
+    const groups = groupRoutesByPrefix(routes);
+    for (const [groupKey, groupRoutes] of groups) {
+      const views = this.generateViews(groupRoutes, groupKey);
+      files.push({ path: `${groupKey}/views.py`, content: views, isNew: true });
+      const urls = this.generateUrls(groupRoutes, groupKey);
+      files.push({ path: `${groupKey}/urls.py`, content: urls, isNew: true });
+      files.push({ path: `${groupKey}/__init__.py`, content: "", isNew: true });
+    }
+    const rootUrls = this.generateRootUrls(groups);
+    files.push({ path: "urls.py", content: rootUrls, isNew: true });
+    return { files, preserved: [], warnings };
+  }
+  generateViews(routes, groupKey) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT scaffold markers`);
+    lines.push(`from django.http import JsonResponse, HttpResponse`);
+    const needsJson = routes.some(
+      (r) => r.requestBody && r.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(r.method)
+    );
+    if (needsJson) {
+      lines.push(`import json`);
+    }
+    const hasNonGet = routes.some((r) => r.method !== "GET");
+    if (hasNonGet) {
+      lines.push(`from django.views.decorators.http import require_http_methods`);
+    }
+    lines.push("");
+    for (const route of routes) {
+      lines.push("");
+      lines.push(`${PY_ROUTE_MARKER} ${route.method} ${route.path}`);
+      lines.push(this.generateView(route));
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateView(route) {
+    const lines = [];
+    const funcName = toSnakeCase(route.handlerName);
+    if (route.method !== "GET") {
+      lines.push(`@require_http_methods(["${route.method}"])`);
+    }
+    const params = ["request", ...route.pathParams];
+    lines.push(`def ${funcName}(${params.join(", ")}):`);
+    lines.push(`    ${PY_USER_START}`);
+    lines.push(`    # TODO: Implement ${route.method} ${route.path}`);
+    if (route.pathParams.length > 0) {
+      lines.push(`    # Path params: ${route.pathParams.join(", ")}`);
+    }
+    if (route.requestBody && route.requestBody.length > 0) {
+      const fields = route.requestBody.map((f) => `${f.name}: ${pythonType(f.type)}${f.required ? "" : " (optional)"}`).join(", ");
+      lines.push(`    # Expected body: { ${fields} }`);
+    }
+    for (const note of route.notes) {
+      lines.push(`    # Note: ${note}`);
+    }
+    if (route.queryParams && route.queryParams.length > 0) {
+      for (const param of route.queryParams) {
+        lines.push(`    ${param.name} = request.GET.get('${param.name}')`);
+      }
+    }
+    if (route.requestBody && route.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(route.method)) {
+      lines.push(`    data = json.loads(request.body)`);
+      for (const field of route.requestBody) {
+        const default_ = field.required ? "" : ", None";
+        lines.push(`    ${field.name} = data.get('${field.name}'${default_})`);
+      }
+    }
+    if (route.responseFormat === "json") {
+      lines.push(`    return JsonResponse({'message': 'Not implemented'})`);
+    } else if (route.responseFormat === "html") {
+      lines.push(`    return HttpResponse('<div>Not implemented</div>')`);
+    } else {
+      lines.push(`    return HttpResponse('Not implemented', content_type='text/plain')`);
+    }
+    lines.push(`    ${PY_USER_END}`);
+    return lines.join("\n");
+  }
+  generateUrls(routes, groupKey) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`from django.urls import path`);
+    lines.push(`from . import views`);
+    lines.push("");
+    lines.push("urlpatterns = [");
+    for (const route of routes) {
+      const djangoPath = toDjangoPath(route.path);
+      const funcName = toSnakeCase(route.handlerName);
+      lines.push(`    path('${djangoPath}', views.${funcName}, name='${funcName}'),`);
+    }
+    lines.push("]");
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateRootUrls(groups) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`from django.urls import path, include`);
+    lines.push("");
+    lines.push("urlpatterns = [");
+    for (const groupKey of groups.keys()) {
+      lines.push(`    path('', include('${groupKey}.urls')),`);
+    }
+    lines.push("]");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function toDjangoPath(path) {
+  return path.replace(/^\//, "").replace(/:(\w+)/g, "<str:$1>");
+}
+function pythonType(type) {
+  switch (type) {
+    case "number":
+      return "int";
+    case "boolean":
+      return "bool";
+    case "file":
+      return "UploadedFile";
+    default:
+      return "str";
+  }
+}
+
+// src/generators/fastapi-generator.ts
+var PY_ROUTE_MARKER2 = "# @serverbridge-route:";
+var PY_USER_START2 = "# @serverbridge-user-start";
+var PY_USER_END2 = "# @serverbridge-user-end";
+var FastAPIGenerator = class {
+  framework = "fastapi";
+  generate(routes, options) {
+    const files = [];
+    const warnings = [];
+    if (routes.length === 0) {
+      warnings.push("No routes to generate");
+      return { files, preserved: [], warnings };
+    }
+    const groups = groupRoutesByPrefix(routes);
+    for (const [groupKey, groupRoutes] of groups) {
+      const content = this.generateRouterFile(groupRoutes, groupKey);
+      const pyFilename = groupKey.replace(/-/g, "_");
+      files.push({ path: `routers/${pyFilename}.py`, content, isNew: true });
+    }
+    const mainContent = this.generateMain(groups);
+    files.push({ path: "main.py", content: mainContent, isNew: true });
+    const allRoutes = [...groups.values()].flat();
+    const routesWithBodies = allRoutes.filter(
+      (r) => r.requestBody && r.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(r.method)
+    );
+    if (routesWithBodies.length > 0) {
+      const models = this.generateModels(routesWithBodies);
+      files.push({ path: "models.py", content: models, isNew: true });
+    }
+    return { files, preserved: [], warnings };
+  }
+  generateRouterFile(routes, groupKey) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT scaffold markers`);
+    const needsQuery = routes.some((r) => r.queryParams && r.queryParams.length > 0);
+    if (needsQuery) {
+      lines.push(`from fastapi import APIRouter, Query`);
+    } else {
+      lines.push(`from fastapi import APIRouter`);
+    }
+    const routesWithBodies = routes.filter(
+      (r) => r.requestBody && r.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(r.method)
+    );
+    if (routesWithBodies.length > 0) {
+      const modelNames = routesWithBodies.map((r) => modelName(r.handlerName));
+      lines.push(`from ..models import ${modelNames.join(", ")}`);
+    }
+    const needsHtml = routes.some((r) => r.responseFormat === "html");
+    const needsPlaintext = routes.some((r) => r.responseFormat === "text");
+    if (needsHtml || needsPlaintext) {
+      lines.push(`from fastapi.responses import HTMLResponse, PlainTextResponse`);
+    }
+    lines.push("");
+    lines.push(`router = APIRouter()`);
+    lines.push("");
+    for (const route of routes) {
+      lines.push("");
+      lines.push(`${PY_ROUTE_MARKER2} ${route.method} ${route.path}`);
+      lines.push(this.generateEndpoint(route));
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateEndpoint(route) {
+    const lines = [];
+    const method = route.method.toLowerCase();
+    const funcName = toSnakeCase2(route.handlerName);
+    const fastapiPath = toFastAPIPath(route.path);
+    const extraArgs = [];
+    if (route.responseFormat === "html") {
+      extraArgs.push("response_class=HTMLResponse");
+    } else if (route.responseFormat === "text") {
+      extraArgs.push("response_class=PlainTextResponse");
+    }
+    const argsStr = extraArgs.length > 0 ? `, ${extraArgs.join(", ")}` : "";
+    lines.push(`@router.${method}('${fastapiPath}'${argsStr})`);
+    const params = [];
+    for (const param of route.pathParams) {
+      params.push(`${param}: str`);
+    }
+    if (route.queryParams && route.queryParams.length > 0) {
+      for (const qp of route.queryParams) {
+        params.push(`${qp.name}: str = Query(...)`);
+      }
+    }
+    if (route.requestBody && route.requestBody.length > 0 && ["POST", "PUT", "PATCH"].includes(route.method)) {
+      params.push(`body: ${modelName(route.handlerName)}`);
+    }
+    lines.push(`async def ${funcName}(${params.join(", ")}):`);
+    lines.push(`    ${PY_USER_START2}`);
+    lines.push(`    # TODO: Implement ${route.method} ${route.path}`);
+    if (route.pathParams.length > 0) {
+      lines.push(`    # Path params: ${route.pathParams.join(", ")}`);
+    }
+    if (route.requestBody && route.requestBody.length > 0) {
+      const fields = route.requestBody.map((f) => `${f.name}: ${pythonType2(f.type)}${f.required ? "" : " (optional)"}`).join(", ");
+      lines.push(`    # Expected body: { ${fields} }`);
+    }
+    for (const note of route.notes) {
+      lines.push(`    # Note: ${note}`);
+    }
+    if (route.responseFormat === "json") {
+      lines.push(`    return {'message': 'Not implemented'}`);
+    } else if (route.responseFormat === "html") {
+      lines.push(`    return '<div>Not implemented</div>'`);
+    } else {
+      lines.push(`    return 'Not implemented'`);
+    }
+    lines.push(`    ${PY_USER_END2}`);
+    return lines.join("\n");
+  }
+  generateMain(groups) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`from fastapi import FastAPI`);
+    for (const groupKey of groups.keys()) {
+      const pyName = groupKey.replace(/-/g, "_");
+      lines.push(`from .routers.${pyName} import router as ${pyName}_router`);
+    }
+    lines.push("");
+    lines.push("app = FastAPI()");
+    lines.push("");
+    for (const groupKey of groups.keys()) {
+      const pyName = groupKey.replace(/-/g, "_");
+      lines.push(`app.include_router(${pyName}_router)`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  generateModels(routes) {
+    const lines = [];
+    lines.push(`# Generated by @hyperfixi/server-bridge \u2014 DO NOT EDIT`);
+    lines.push(`from pydantic import BaseModel`);
+    lines.push(`from typing import Optional`);
+    lines.push("");
+    for (const route of routes) {
+      if (!route.requestBody || route.requestBody.length === 0) continue;
+      lines.push("");
+      lines.push(`class ${modelName(route.handlerName)}(BaseModel):`);
+      for (const field of route.requestBody) {
+        const pyType = pythonType2(field.type);
+        if (field.required) {
+          lines.push(`    ${field.name}: ${pyType}`);
+        } else {
+          lines.push(`    ${field.name}: Optional[${pyType}] = None`);
+        }
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+function toSnakeCase2(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function toFastAPIPath(path) {
+  return path.replace(/:(\w+)/g, "{$1}");
+}
+function modelName(handlerName) {
+  return handlerName.charAt(0).toUpperCase() + handlerName.slice(1) + "Body";
+}
+function pythonType2(type) {
+  switch (type) {
+    case "number":
+      return "int";
+    case "boolean":
+      return "bool";
+    case "file":
+      return "bytes";
+    default:
+      return "str";
+  }
+}
+
+// src/generators/index.ts
+function selectGenerator(framework) {
+  switch (framework) {
+    case "hono":
+      return new HonoGenerator();
+    case "openapi":
+      return new OpenAPIGenerator();
+    case "django":
+      return new DjangoGenerator();
+    case "fastapi":
+      return new FastAPIGenerator();
+    default:
+      return new ExpressGenerator();
+  }
+}
+
+// src/generators/manifest.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
+var import_node_crypto = require("crypto");
+var MANIFEST_FILENAME = "server-bridge.manifest.json";
+function hashRoute(route) {
+  const data = JSON.stringify({
+    path: route.path,
+    method: route.method,
+    responseFormat: route.responseFormat,
+    pathParams: route.pathParams,
+    queryParams: route.queryParams,
+    requestBody: route.requestBody
+  });
+  return (0, import_node_crypto.createHash)("md5").update(data).digest("hex").slice(0, 8);
+}
+function manifestKey(method, path) {
+  return `${method}:${path}`;
+}
+function createManifest(routes) {
+  const manifest = {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    routes: {}
+  };
+  for (const route of routes) {
+    const key = manifestKey(route.method, route.path);
+    manifest.routes[key] = {
+      method: route.method,
+      path: route.path,
+      handlerName: route.handlerName,
+      hash: hashRoute(route)
+    };
+  }
+  return manifest;
+}
+async function loadManifest(outputDir) {
+  try {
+    const content = await (0, import_promises3.readFile)((0, import_node_path3.join)(outputDir, MANIFEST_FILENAME), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveManifest(outputDir, manifest) {
+  await (0, import_promises3.writeFile)(
+    (0, import_node_path3.join)(outputDir, MANIFEST_FILENAME),
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function diffRoutes(oldManifest, newRoutes) {
+  const oldRoutes = oldManifest?.routes ?? {};
+  const added = [];
+  const changed = [];
+  const unchanged = [];
+  for (const route of newRoutes) {
+    const key = manifestKey(route.method, route.path);
+    const existing = oldRoutes[key];
+    if (!existing) {
+      added.push(route);
+    } else if (existing.hash !== hashRoute(route)) {
+      changed.push(route);
+    } else {
+      unchanged.push(route);
+    }
+  }
+  const newKeys = new Set(newRoutes.map((r) => manifestKey(r.method, r.path)));
+  const removed = Object.values(oldRoutes).filter(
+    (entry) => !newKeys.has(manifestKey(entry.method, entry.path))
+  );
+  return { added, removed, changed, unchanged };
+}
+
+// src/cli/generate-command.ts
+async function runGenerate(options) {
+  const cwd = (0, import_node_path4.resolve)(options.dir);
+  const config = await loadConfig(cwd, {
+    framework: options.framework,
+    output: options.output,
+    typescript: options.typescript,
+    include: options.include,
+    exclude: options.exclude,
+    ignore: options.ignore
+  });
+  const result = await scanDirectory(cwd, {
+    include: config.include,
+    exclude: config.exclude,
+    ignore: config.ignore
+  });
+  if (result.errors.length > 0) {
+    for (const err of result.errors) {
+      console.error(`Warning: ${err.file}: ${err.message}`);
+    }
+  }
+  if (result.conflicts.length > 0) {
+    console.error(
+      `
+Warning: ${result.conflicts.length} route conflict(s) detected:
+${formatConflicts(result.conflicts)}
+First occurrence used for generation.
+`
+    );
+  }
+  if (result.routes.length === 0) {
+    console.log("No routes found. Nothing to generate.");
+    return;
+  }
+  const generator = selectGenerator(config.framework ?? "express");
+  const outputDir = (0, import_node_path4.resolve)(cwd, config.output ?? "./server/routes");
+  const oldManifest = options.overwrite ? null : await loadManifest(outputDir);
+  const diff = diffRoutes(oldManifest, result.routes);
+  const generated = generator.generate(result.routes, {
+    outputDir,
+    typescript: config.typescript,
+    overwrite: options.overwrite
+  });
+  await (0, import_promises4.mkdir)(outputDir, { recursive: true });
+  for (const file of generated.files) {
+    const filePath = (0, import_node_path4.join)(outputDir, file.path);
+    const fileDir = (0, import_node_path4.join)(filePath, "..");
+    await (0, import_promises4.mkdir)(fileDir, { recursive: true });
+    await (0, import_promises4.writeFile)(filePath, file.content, "utf-8");
+  }
+  const manifest = createManifest(result.routes);
+  await saveManifest(outputDir, manifest);
+  console.log(`Generated ${generated.files.length} file(s) in ${outputDir}/`);
+  console.log(`  Framework: ${generator.framework}`);
+  console.log(`  Routes: ${result.routes.length}`);
+  if (diff.added.length > 0) {
+    console.log(`  New: ${diff.added.length}`);
+  }
+  if (diff.changed.length > 0) {
+    console.log(`  Changed: ${diff.changed.length}`);
+  }
+  if (diff.removed.length > 0) {
+    console.log(`  Removed: ${diff.removed.length} (routes no longer in source)`);
+  }
+  for (const warning of generated.warnings) {
+    console.log(`  Warning: ${warning}`);
+  }
+}
+
+// src/cli/diff-command.ts
+var import_node_path5 = require("path");
+async function runDiff(options) {
+  const cwd = (0, import_node_path5.resolve)(options.dir);
+  const config = await loadConfig(cwd, {
+    include: options.include,
+    exclude: options.exclude,
+    ignore: options.ignore
+  });
+  const outputDir = (0, import_node_path5.resolve)(cwd, config.output ?? "./server/routes");
+  const manifest = await loadManifest(outputDir);
+  if (!manifest) {
+    console.log('No manifest found. Run "serverbridge generate" first.');
+    return;
+  }
+  const result = await scanDirectory(cwd, {
+    include: config.include,
+    exclude: config.exclude,
+    ignore: config.ignore
+  });
+  if (result.errors.length > 0) {
+    for (const err of result.errors) {
+      console.error(`Warning: ${err.file}: ${err.message}`);
+    }
+  }
+  if (result.conflicts.length > 0) {
+    console.error(
+      `
+Warning: ${result.conflicts.length} route conflict(s) detected:
+${formatConflicts(result.conflicts)}
+`
+    );
+  }
+  const diff = diffRoutes(manifest, result.routes);
+  const hasChanges = diff.added.length > 0 || diff.changed.length > 0 || diff.removed.length > 0;
+  const total = diff.added.length + diff.changed.length + diff.removed.length + diff.unchanged.length;
+  console.log(`
+Route Diff Summary:`);
+  console.log(`  Total:     ${total}`);
+  console.log(`  Unchanged: ${diff.unchanged.length}`);
+  console.log(`  Added:     ${diff.added.length}`);
+  console.log(`  Changed:   ${diff.changed.length}`);
+  console.log(`  Removed:   ${diff.removed.length}`);
+  if (options.format === "detailed" && hasChanges) {
+    console.log("");
+    if (diff.added.length > 0) {
+      console.log("Added:");
+      for (const route of diff.added) {
+        console.log(
+          `  + ${route.method} ${route.path}  (${route.source.file}:${route.source.line ?? "?"})`
+        );
+      }
+    }
+    if (diff.changed.length > 0) {
+      console.log("Changed:");
+      for (const route of diff.changed) {
+        console.log(
+          `  ~ ${route.method} ${route.path}  (${route.source.file}:${route.source.line ?? "?"})`
+        );
+      }
+    }
+    if (diff.removed.length > 0) {
+      console.log("Removed:");
+      for (const entry of diff.removed) {
+        console.log(`  - ${entry.method} ${entry.path}`);
+      }
+    }
+  }
+  if (hasChanges) {
+    console.log('\nChanges detected. Run "serverbridge generate" to update.');
+    process.exitCode = 1;
+  } else {
+    console.log("\nNo changes detected.");
+  }
+}
+
+// src/cli/watch-command.ts
+var import_node_fs = require("fs");
+var import_promises5 = require("fs/promises");
+var import_node_path6 = require("path");
+function patternToRegex(pattern) {
+  const escaped = pattern.replace(/\./g, "\\.").replace(/\*\*\//g, "\0/").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0\//g, "(.+/)?").replace(/\0/g, ".*");
+  return new RegExp("^" + escaped + "$");
+}
+function shouldScan(filename, includePatterns) {
+  return includePatterns.some((p) => patternToRegex(p).test(filename));
+}
+function shouldSkip(relPath, excludePatterns) {
+  return excludePatterns.some((p) => patternToRegex(p).test(relPath));
+}
+function createDebouncedRunner(fn, ms) {
+  let timer = null;
+  let running = false;
+  let queued = false;
+  function trigger() {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(run, ms);
+  }
+  async function run() {
+    timer = null;
+    if (running) {
+      queued = true;
+      return;
+    }
+    running = true;
+    try {
+      await fn();
+    } finally {
+      running = false;
+      if (queued) {
+        queued = false;
+        trigger();
+      }
+    }
+  }
+  return { trigger };
+}
+function computeRouteHash(routes) {
+  return routes.map((r) => `${r.method}:${r.path}`).sort().join("\n");
+}
+async function runWatch(options) {
+  const cwd = (0, import_node_path6.resolve)(options.dir);
+  const config = await loadConfig(cwd, {
+    framework: options.framework,
+    output: options.output,
+    typescript: options.typescript,
+    include: options.include,
+    exclude: options.exclude,
+    ignore: options.ignore
+  });
+  const includePatterns = config.include ?? ["**/*.html", "**/*.htm"];
+  const excludePatterns = config.exclude ?? ["node_modules/**", "dist/**"];
+  const ignorePatterns = config.ignore ?? [];
+  const debounceMs = options.debounce ?? 300;
+  const outputDir = (0, import_node_path6.resolve)(cwd, config.output ?? "./server/routes");
+  const framework = config.framework ?? "express";
+  console.log(`
+Watching for changes in ${cwd}/`);
+  console.log(`  Output: ${outputDir}/`);
+  console.log(`  Framework: ${framework}`);
+  console.log(`  Press Ctrl+C to stop.
+`);
+  const routesByFile = /* @__PURE__ */ new Map();
+  let currentRouteHash = "";
+  const initialScan = await scanDirectory(cwd, {
+    include: config.include,
+    exclude: config.exclude,
+    ignore: config.ignore
+  });
+  for (const route of initialScan.routes) {
+    const file = route.source.file;
+    const existing = routesByFile.get(file) ?? [];
+    existing.push(route);
+    routesByFile.set(file, existing);
+  }
+  await generateFromCache();
+  const changedFiles = /* @__PURE__ */ new Set();
+  const debounced = createDebouncedRunner(async () => {
+    const files = [...changedFiles];
+    changedFiles.clear();
+    await incrementalUpdate(files);
+  }, debounceMs);
+  const watcher = (0, import_node_fs.watch)(cwd, { recursive: true }, (_eventType, filename) => {
+    if (!filename) return;
+    const relPath = (0, import_node_path6.relative)(cwd, (0, import_node_path6.resolve)(cwd, filename));
+    if (shouldSkip(relPath, excludePatterns)) return;
+    if (!shouldScan(filename, includePatterns)) return;
+    console.log(`  Changed: ${relPath}`);
+    changedFiles.add((0, import_node_path6.resolve)(cwd, filename));
+    debounced.trigger();
+  });
+  process.on("SIGINT", () => {
+    console.log("\nStopping watch mode...");
+    watcher.close();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+  async function incrementalUpdate(files) {
+    try {
+      for (const file of files) {
+        try {
+          const content = await (0, import_promises5.readFile)(file, "utf-8");
+          const routes = scanRoutes(content, file);
+          routesByFile.set(file, routes);
+        } catch {
+          routesByFile.delete(file);
+        }
+      }
+      await generateFromCache();
+    } catch (err) {
+      console.error("Generation failed:", err instanceof Error ? err.message : err);
+    }
+  }
+  async function generateFromCache() {
+    let allRoutes = [];
+    for (const routes2 of routesByFile.values()) {
+      allRoutes.push(...routes2);
+    }
+    if (ignorePatterns.length > 0) {
+      allRoutes = allRoutes.filter(
+        (route) => !ignorePatterns.some((p) => matchIgnorePattern(route.path, p))
+      );
+    }
+    const seen = /* @__PURE__ */ new Map();
+    for (const route of allRoutes) {
+      const key = `${route.method}:${route.path}`;
+      if (!seen.has(key)) seen.set(key, route);
+    }
+    const routes = [...seen.values()];
+    const newHash = computeRouteHash(routes);
+    if (newHash === currentRouteHash) {
+      console.log("  No route changes detected, skipping generation.");
+      return;
+    }
+    currentRouteHash = newHash;
+    const conflicts = detectConflicts(allRoutes);
+    if (conflicts.length > 0) {
+      console.error(
+        `
+  Warning: ${conflicts.length} route conflict(s):
+${formatConflicts(conflicts)}`
+      );
+    }
+    const generator = selectGenerator(framework);
+    const generated = generator.generate(routes, {
+      outputDir,
+      typescript: config.typescript
+    });
+    await (0, import_promises5.mkdir)(outputDir, { recursive: true });
+    for (const file of generated.files) {
+      const filePath = (0, import_node_path6.join)(outputDir, file.path);
+      const fileDir = (0, import_node_path6.join)(filePath, "..");
+      await (0, import_promises5.mkdir)(fileDir, { recursive: true });
+      await (0, import_promises5.writeFile)(filePath, file.content, "utf-8");
+    }
+    const manifest = createManifest(routes);
+    await saveManifest(outputDir, manifest);
+    console.log(`  Generated ${generated.files.length} file(s) for ${routes.length} route(s)`);
+  }
+}
+
+// src/cli/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function parseFlags(args2) {
+  const flags = {};
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg.startsWith("--")) {
+      const [key, ...valueParts] = arg.slice(2).split("=");
+      const value = valueParts.join("=");
+      if (value) {
+        flags[key] = value;
+      } else if (key.startsWith("no-")) {
+        flags[key.slice(3)] = false;
+      } else {
+        const next = args2[i + 1];
+        if (next && !next.startsWith("--")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = true;
+        }
+      }
+    }
+  }
+  return flags;
+}
+function getPositionalArgs(args2) {
+  return args2.filter((a) => !a.startsWith("--"));
+}
+function parseFramework(flags) {
+  return ["hono", "openapi", "django", "fastapi"].includes(flags.framework) ? flags.framework : "express";
+}
+async function main() {
+  if (!command || command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  const flagArgs = args.slice(1);
+  const flags = parseFlags(flagArgs);
+  const positional = getPositionalArgs(flagArgs);
+  const dir = positional[0] || ".";
+  if (command === "scan") {
+    await runScan({
+      dir,
+      format: flags.format === "table" ? "table" : "json",
+      include: typeof flags.include === "string" ? flags.include.split(",") : void 0,
+      exclude: typeof flags.exclude === "string" ? flags.exclude.split(",") : void 0,
+      ignore: typeof flags.ignore === "string" ? flags.ignore.split(",") : void 0
+    });
+  } else if (command === "generate") {
+    await runGenerate({
+      dir,
+      framework: parseFramework(flags),
+      output: typeof flags.output === "string" ? flags.output : void 0,
+      typescript: flags.typescript !== false,
+      overwrite: flags.overwrite === true,
+      include: typeof flags.include === "string" ? flags.include.split(",") : void 0,
+      exclude: typeof flags.exclude === "string" ? flags.exclude.split(",") : void 0
+    });
+  } else if (command === "diff") {
+    await runDiff({
+      dir,
+      format: flags.format === "detailed" ? "detailed" : "summary",
+      include: typeof flags.include === "string" ? flags.include.split(",") : void 0,
+      exclude: typeof flags.exclude === "string" ? flags.exclude.split(",") : void 0,
+      ignore: typeof flags.ignore === "string" ? flags.ignore.split(",") : void 0
+    });
+  } else if (command === "watch") {
+    await runWatch({
+      dir,
+      framework: parseFramework(flags),
+      output: typeof flags.output === "string" ? flags.output : void 0,
+      typescript: flags.typescript !== false,
+      include: typeof flags.include === "string" ? flags.include.split(",") : void 0,
+      exclude: typeof flags.exclude === "string" ? flags.exclude.split(",") : void 0,
+      ignore: typeof flags.ignore === "string" ? flags.ignore.split(",") : void 0,
+      debounce: typeof flags.debounce === "string" ? parseInt(flags.debounce, 10) : void 0
+    });
+  } else {
+    console.error(`Unknown command: ${command}`);
+    console.error('Run "serverbridge --help" for usage.');
+    process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`
+serverbridge - Extract routes from hyperscript/htmx HTML and generate server stubs
+
+Usage:
+  serverbridge scan [dir] [options]      Scan files and print extracted routes
+  serverbridge generate [dir] [options]  Scan + generate server route stubs
+  serverbridge diff [dir] [options]      Show changes since last generation
+  serverbridge watch [dir] [options]     Watch files and auto-regenerate
+
+Scan options:
+  --format=json|table    Output format (default: json)
+  --include=PATTERNS     Comma-separated glob patterns (default: **/*.{html,htm})
+  --exclude=PATTERNS     Comma-separated exclusion patterns
+  --ignore=URLS          Comma-separated URL patterns to ignore
+
+Generate options:
+  --framework=express|hono|openapi|django|fastapi  Target framework (default: express)
+  --output=DIR              Output directory (default: ./server/routes)
+  --typescript              Generate TypeScript (default: true)
+  --no-typescript           Generate JavaScript
+  --overwrite               Overwrite existing user code
+
+Diff options:
+  --format=summary|detailed  Output format (default: summary)
+
+Watch options:
+  --framework=...         Same as generate
+  --output=DIR            Same as generate
+  --debounce=MS           Debounce delay in ms (default: 300)
+
+Config file:
+  Place .serverbridgerc.json in your project root to set defaults.
+`);
+}
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.cjs.map