gorsee 0.2.3 → 0.2.5

package/dist-pkg/cli/cmd-deploy.js

@@ -0,0 +1,381 @@
+import { writeFile, access, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createProjectContext } from "../runtime/project.js";
+import { runArtifactLifecycleStep, writeArtifactFailurePack } from "../ai/index.js";
+import { assertDeployArtifactConformance } from "../deploy/conformance.js";
+import { isProcessDeployRuntime } from "../deploy/runtime.js";
+const TARGETS = ["vercel", "fly", "cloudflare", "netlify", "docker"], DETECT_FILES = {
+  "vercel.json": "vercel",
+  "fly.toml": "fly",
+  "wrangler.toml": "cloudflare",
+  "netlify.toml": "netlify",
+  Dockerfile: "docker"
+};
+async function fileExists(path) {
+  try {
+    await access(path);
+    return !0;
+  } catch {
+    return !1;
+  }
+}
+async function detectTarget(cwd) {
+  for (const [file, target] of Object.entries(DETECT_FILES))
+    if (await fileExists(join(cwd, file)))
+      return target;
+  return null;
+}
+async function writeAndLog(filePath, content) {
+  await writeFile(filePath, content, "utf-8");
+  console.log(`  created ${filePath}`);
+}
+function parseDeployFlags(args) {
+  const flags = {};
+  for (let index = 0;index < args.length; index++)
+    if (args[index] === "--runtime" && isProcessDeployRuntime(args[index + 1]))
+      flags.runtime = args[++index];
+  return flags;
+}
+function parseDeployTargetArg(args) {
+  for (let index = 0;index < args.length; index++) {
+    const arg = args[index];
+    if (!arg)
+      continue;
+    if (arg === "--runtime") {
+      index += 1;
+      continue;
+    }
+    if (!arg.startsWith("-"))
+      return arg;
+  }
+  return;
+}
+function resolveDeployRuntime(target, requestedRuntime) {
+  if (target === "vercel") {
+    if (requestedRuntime && requestedRuntime !== "node")
+      throw Error("Vercel deploy generation requires the Node runtime profile.");
+    return "node";
+  }
+  if (target === "docker" || target === "fly")
+    return requestedRuntime ?? "bun";
+  if (requestedRuntime && requestedRuntime !== "bun")
+    throw Error(`${target} deploy generation does not support a Node process runtime profile.`);
+  return "bun";
+}
+async function validateGeneratedDeployConfig(cwd, target, runtime) {
+  const expectations = [];
+  switch (target) {
+    case "vercel":
+      assertDeployArtifactConformance({
+        name: "vercel.json",
+        format: "json",
+        content: await readFile(join(cwd, "vercel.json"), "utf-8"),
+        requiredTokens: ["/_gorsee/(.*)", "Cache-Control"],
+        requiredPaths: ["routes"],
+        requiredValues: [
+          { path: "version", value: 2 },
+          { path: "buildCommand", value: "bun run build" },
+          { path: "outputDirectory", value: ".vercel/output" }
+        ]
+      });
+      expectations.push({
+        file: "vercel.json",
+        pattern: /"\/_gorsee\/\(\.\*\)"/,
+        message: "Vercel config must route immutable client assets through /_gorsee/*"
+      });
+      expectations.push({
+        file: "vercel.json",
+        pattern: /"Cache-Control":\s*"public, max-age=31536000, immutable"/,
+        message: "Vercel config must keep immutable caching for /_gorsee/*"
+      });
+      expectations.push({
+        file: "api/index.ts",
+        pattern: /APP_ORIGIN/,
+        message: "Vercel handler must reference APP_ORIGIN"
+      });
+      expectations.push({
+        file: "api/index.ts",
+        pattern: /\.\.\/dist\/server-handler-node\.js/,
+        message: "Vercel handler must reference the Node-compatible built server handler"
+      });
+      expectations.push({
+        file: "api/index.ts",
+        pattern: /handleRequest\(request, \{ vercel: true \}, \{ rpcPolicy \}\)/,
+        message: "Vercel handler must forward the explicit RPC policy to the built server handler"
+      });
+      break;
+    case "fly":
+      assertDeployArtifactConformance({
+        name: "fly.toml",
+        format: "toml",
+        content: await readFile(join(cwd, "fly.toml"), "utf-8"),
+        requiredTokens: ["/api/health"],
+        requiredValues: [
+          { path: "primary_region", value: "iad" },
+          { path: "env.APP_ORIGIN", value: "REPLACE_WITH_APP_ORIGIN" }
+        ]
+      });
+      expectations.push({
+        file: "fly.toml",
+        pattern: /path = "\/api\/health"/,
+        message: "Fly config must expose the /api/health readiness check"
+      });
+      expectations.push({
+        file: "fly.toml",
+        pattern: /APP_ORIGIN\s*=\s*"REPLACE_WITH_APP_ORIGIN"/,
+        message: "Fly config must contain APP_ORIGIN placeholder"
+      });
+      expectations.push({
+        file: "Dockerfile",
+        pattern: /ENV APP_ORIGIN=REPLACE_WITH_APP_ORIGIN/,
+        message: "Fly Dockerfile must export APP_ORIGIN placeholder"
+      });
+      expectations.push({
+        file: "Dockerfile",
+        pattern: /bun install --frozen-lockfile/,
+        message: "Fly Dockerfile must install with a frozen Bun lockfile"
+      });
+      expectations.push({
+        file: "Dockerfile",
+        pattern: runtime === "node" ? /FROM node:20-bookworm-slim/ : /FROM oven\/bun:1-slim/,
+        message: `Fly Dockerfile must use the ${runtime} runtime image`
+      });
+      expectations.push({
+        file: "Dockerfile",
+        pattern: runtime === "node" ? /CMD \["node", "dist\/prod-node\.js"\]/ : /CMD \["bun", "run", "start"\]/,
+        message: `Fly Dockerfile must start through the ${runtime} production runtime entrypoint`
+      });
+      break;
+    case "cloudflare":
+      assertDeployArtifactConformance({
+        name: "wrangler.toml",
+        format: "toml",
+        content: await readFile(join(cwd, "wrangler.toml"), "utf-8"),
+        requiredTokens: ['compatibility_flags = ["nodejs_compat"]'],
+        requiredValues: [
+          { path: "main", value: "dist/worker.js" },
+          { path: "build.command", value: "bun run build" },
+          { path: "vars.APP_ORIGIN", value: "REPLACE_WITH_APP_ORIGIN" }
+        ]
+      });
+      expectations.push({
+        file: "wrangler.toml",
+        pattern: /main = "dist\/worker\.js"/,
+        message: "Cloudflare config must target dist/worker.js as the worker entry"
+      });
+      expectations.push({
+        file: "wrangler.toml",
+        pattern: /bucket = "\.\/dist\/client"/,
+        message: "Cloudflare config must publish dist/client as the static bucket"
+      });
+      expectations.push({
+        file: "wrangler.toml",
+        pattern: /APP_ORIGIN\s*=\s*"REPLACE_WITH_APP_ORIGIN"/,
+        message: "Cloudflare config must contain APP_ORIGIN placeholder"
+      });
+      expectations.push({
+        file: "wrangler.toml",
+        pattern: /compatibility_flags\s*=\s*\["nodejs_compat"\]/,
+        message: "Cloudflare config must enable nodejs_compat"
+      });
+      expectations.push({
+        file: "worker.ts",
+        pattern: /handleRequest\(request, env, \{ rpcPolicy \}\)/,
+        message: "Cloudflare worker must forward explicit RPC policy to the server handler"
+      });
+      expectations.push({
+        file: "_routes.json",
+        pattern: /_gorsee\/\*/,
+        message: "Cloudflare routes config must exclude /_gorsee/* from edge routing"
+      });
+      break;
+    case "netlify":
+      assertDeployArtifactConformance({
+        name: "netlify.toml",
+        format: "toml",
+        content: await readFile(join(cwd, "netlify.toml"), "utf-8"),
+        requiredTokens: ["excludedPath = true", 'Cache-Control = "public, max-age=31536000, immutable"'],
+        requiredValues: [
+          { path: "build.command", value: "bun run build" },
+          { path: "build.publish", value: "dist/client" },
+          { path: "build.environment.APP_ORIGIN", value: "REPLACE_WITH_APP_ORIGIN" }
+        ]
+      });
+      expectations.push({
+        file: "netlify.toml",
+        pattern: /publish = "dist\/client"/,
+        message: "Netlify config must publish dist/client"
+      });
+      expectations.push({
+        file: "netlify.toml",
+        pattern: /excludedPath = true/,
+        message: "Netlify config must bypass edge handling for /_gorsee/*"
+      });
+      expectations.push({
+        file: "netlify.toml",
+        pattern: /APP_ORIGIN\s*=\s*"REPLACE_WITH_APP_ORIGIN"/,
+        message: "Netlify config must contain APP_ORIGIN placeholder"
+      });
+      expectations.push({
+        file: "netlify.toml",
+        pattern: /Cache-Control = "public, max-age=31536000, immutable"/,
+        message: "Netlify config must keep immutable caching for /_gorsee/*"
+      });
+      expectations.push({
+        file: "netlify/edge-functions/gorsee-handler.ts",
+        pattern: /handleRequest\(request, \{ netlifyContext: context \}, \{ rpcPolicy \}\)/,
+        message: "Netlify edge function must forward explicit RPC policy to the server handler"
+      });
+      break;
+    case "docker":
+      expectations.push({
+        file: "Dockerfile",
+        pattern: runtime === "node" ? /CMD \["node", "dist\/prod-node\.js"\]/ : /CMD \["bun", "run", "start"\]/,
+        message: `Dockerfile must start through the ${runtime} production entrypoint`
+      });
+      expectations.push({
+        file: "Dockerfile",
+        pattern: /ENV APP_ORIGIN=REPLACE_WITH_APP_ORIGIN/,
+        message: "Dockerfile must export APP_ORIGIN placeholder"
+      });
+      expectations.push({
+        file: "Dockerfile",
+        pattern: /bun install --frozen-lockfile/,
+        message: "Dockerfile must install with a frozen Bun lockfile"
+      });
+      expectations.push({
+        file: "Dockerfile",
+        pattern: runtime === "node" ? /FROM node:20-bookworm-slim/ : /FROM oven\/bun:1-slim/,
+        message: `Dockerfile must use the ${runtime} runtime image`
+      });
+      break;
+  }
+  for (const expectation of expectations) {
+    const content = await readFile(join(cwd, expectation.file), "utf-8");
+    if (!expectation.pattern.test(content))
+      throw Error(expectation.message);
+  }
+}
+async function deployVercel(cwd) {
+  const { generateVercelConfig, generateVercelServerlessEntry } = await import("../deploy/vercel.js");
+  await writeAndLog(join(cwd, "vercel.json"), JSON.stringify(generateVercelConfig(), null, 2));
+  await mkdir(join(cwd, "api"), { recursive: !0 });
+  await writeAndLog(join(cwd, "api/index.ts"), generateVercelServerlessEntry());
+  console.log(`
+  Next steps:`);
+  console.log("    1. Install Vercel CLI: npm i -g vercel");
+  console.log("    2. Run: vercel");
+  console.log("    3. Follow prompts to link your project");
+}
+async function deployFly(cwd, appName, runtime) {
+  const { generateFlyConfig, generateFlyDockerfile } = await import("../deploy/fly.js");
+  await writeAndLog(join(cwd, "fly.toml"), generateFlyConfig(appName));
+  await writeAndLog(join(cwd, "Dockerfile"), generateFlyDockerfile(runtime));
+  console.log(`
+  Next steps:`);
+  console.log("    1. Install Fly CLI: curl -L https://fly.io/install.sh | sh");
+  console.log(`    2. Run: fly launch --name ${appName}`);
+  console.log("    3. Deploy: fly deploy");
+}
+async function deployCloudflare(cwd, name) {
+  const { generateWranglerConfig, generateCloudflareEntry, generateCloudflareStaticAssets } = await import("../deploy/cloudflare.js");
+  await writeAndLog(join(cwd, "wrangler.toml"), generateWranglerConfig(name));
+  await writeAndLog(join(cwd, "worker.ts"), generateCloudflareEntry());
+  await writeAndLog(join(cwd, "_routes.json"), JSON.stringify(generateCloudflareStaticAssets(), null, 2));
+  console.log(`
+  Next steps:`);
+  console.log("    1. Install Wrangler: npm i -g wrangler");
+  console.log("    2. Authenticate: wrangler login");
+  console.log("    3. Deploy: wrangler deploy");
+}
+async function deployNetlify(cwd) {
+  const { generateNetlifyConfig, generateNetlifyFunction } = await import("../deploy/netlify.js");
+  await writeAndLog(join(cwd, "netlify.toml"), generateNetlifyConfig());
+  const edgeFnDir = join(cwd, "netlify/edge-functions");
+  await mkdir(edgeFnDir, { recursive: !0 });
+  await writeAndLog(join(edgeFnDir, "gorsee-handler.ts"), generateNetlifyFunction());
+  console.log(`
+  Next steps:`);
+  console.log("    1. Install Netlify CLI: npm i -g netlify-cli");
+  console.log("    2. Run: netlify init");
+  console.log("    3. Deploy: netlify deploy --prod");
+}
+async function deployDocker(cwd, runtime) {
+  const { generateDockerfile, generateDockerignore } = await import("../deploy/dockerfile.js");
+  await writeAndLog(join(cwd, "Dockerfile"), generateDockerfile(runtime));
+  await writeAndLog(join(cwd, ".dockerignore"), generateDockerignore());
+  console.log(`
+  Next steps:`);
+  console.log("    1. Build image: docker build -t gorsee-app .");
+  console.log("    2. Run: docker run -p 3000:3000 gorsee-app");
+}
+export async function generateDeployConfig(args, options = {}) {
+  const { cwd } = createProjectContext(options), initOnly = args.includes("--init"), flags = parseDeployFlags(args);
+  let target = parseDeployTargetArg(args) ?? null;
+  if (!target) {
+    target = await detectTarget(cwd);
+    if (!target) {
+      await writeDeployFailurePack(cwd, "DEPLOY_TARGET", "No deploy target specified and none detected.");
+      console.error("  No deploy target specified and none detected.");
+      console.error(`  Usage: gorsee deploy <${TARGETS.join("|")}> [--init]`);
+      process.exit(1);
+    }
+    console.log(`  Auto-detected target: ${target}`);
+  }
+  if (!TARGETS.includes(target)) {
+    await writeDeployFailurePack(cwd, "DEPLOY_TARGET", `Unknown target: ${target}`);
+    console.error(`  Unknown target: ${target}`);
+    console.error(`  Available: ${TARGETS.join(", ")}`);
+    process.exit(1);
+  }
+  const projectName = cwd.split("/").pop() ?? "gorsee-app", runtime = resolveDeployRuntime(target, flags.runtime);
+  console.log(`
+  Generating ${target} deploy config...
+`);
+  await runArtifactLifecycleStep({
+    cwd,
+    source: "deploy",
+    phase: "deploy",
+    step: "deploy",
+    code: "DEPLOY_GENERATE",
+    startMessage: `generating deploy config for ${target}`,
+    finishMessage: `deploy config generated for ${target}`,
+    data: {
+      target,
+      runtime,
+      initOnly,
+      projectName,
+      artifact: target === "docker" ? "Dockerfile" : target === "vercel" ? "vercel.json" : target === "cloudflare" ? "wrangler.toml" : target === "netlify" ? "netlify.toml" : "fly.toml"
+    },
+    run: async () => {
+      switch (target) {
+        case "vercel":
+          await deployVercel(cwd);
+          break;
+        case "fly":
+          await deployFly(cwd, projectName, runtime);
+          break;
+        case "cloudflare":
+          await deployCloudflare(cwd, projectName);
+          break;
+        case "netlify":
+          await deployNetlify(cwd);
+          break;
+        case "docker":
+          await deployDocker(cwd, runtime);
+          break;
+      }
+      await validateGeneratedDeployConfig(cwd, target, runtime);
+    }
+  });
+  if (initOnly)
+    console.log(`
+  Config generated (--init mode). Deploy manually when ready.`);
+  console.log();
+}
+export async function runDeploy(args, options = {}) {
+  return generateDeployConfig(args, options);
+}
+async function writeDeployFailurePack(cwd, code, message) {
+  await writeArtifactFailurePack(cwd, "deploy", "deploy.failure", code, message);
+}

package/dist-pkg/cli/cmd-dev.d.ts

@@ -0,0 +1,5 @@
+import { type RuntimeOptions } from "../runtime/project.js";
+export interface DevCommandOptions extends RuntimeOptions {
+    port?: number;
+}
+export declare function runDev(_args: string[], options?: DevCommandOptions): Promise<void>;

package/dist-pkg/cli/cmd-dev.js

@@ -0,0 +1,5 @@
+import { createProjectContext } from "../runtime/project.js";
+export async function runDev(_args, options = {}) {
+  const { cwd } = createProjectContext(options), { startDevServer } = await import("../dev.js");
+  await startDevServer({ cwd, port: options.port });
+}

package/dist-pkg/cli/cmd-docs.d.ts

@@ -0,0 +1,50 @@
+import { type Route } from "../router/scanner.js";
+import { type RuntimeOptions } from "../runtime/project.js";
+import { type RouteCompilerFacts } from "../compiler/route-facts.js";
+interface DocFlags {
+    output: string;
+    format: "md" | "json" | "html";
+    routesOnly: boolean;
+    contracts: boolean;
+}
+interface RouteDoc {
+    path: string;
+    methods: string[];
+    hasLoader: boolean;
+    isApi: boolean;
+    hasMiddleware: boolean;
+    title: string;
+    meta: Record<string, unknown> | null;
+}
+export declare const DOCS_ARTIFACT_SCHEMA_VERSION: 1;
+export interface DocsArtifactSummary {
+    totalRoutes: number;
+    pageRoutes: number;
+    apiRoutes: number;
+    loaderRoutes: number;
+    middlewareRoutes: number;
+    prerenderedRoutes: number;
+}
+export interface DocsArtifact {
+    schemaVersion: typeof DOCS_ARTIFACT_SCHEMA_VERSION;
+    generatedAt: string;
+    summary: DocsArtifactSummary;
+    routes: RouteCompilerFacts[];
+    docs: RouteDoc[];
+}
+export declare function parseDocsFlags(args: string[]): DocFlags;
+declare function extractRouteInfo(route: Route): Promise<RouteDoc>;
+declare function extractRouteInfoFromFacts(routeFacts: RouteCompilerFacts): RouteDoc;
+declare function generateMarkdown(docs: RouteDoc[]): string;
+declare function generateJson(docs: RouteDoc[]): string;
+export declare function summarizeRouteFacts(routeFacts: RouteCompilerFacts[]): DocsArtifactSummary;
+export declare function createDocsArtifact(routeFacts: RouteCompilerFacts[]): DocsArtifact;
+export declare function generateJsonArtifact(artifact: DocsArtifact): string;
+declare function generateHtml(docs: RouteDoc[]): string;
+export interface DocsCommandOptions extends RuntimeOptions {
+}
+export declare function generateDocs(args: string[], options?: DocsCommandOptions): Promise<void>;
+/** @deprecated Use generateDocs() for programmatic access. */
+export declare function runDocs(args: string[], options?: DocsCommandOptions): Promise<void>;
+export { extractRouteInfo, extractRouteInfoFromFacts, generateMarkdown, generateJson, generateHtml };
+export type { RouteDoc, DocFlags };

package/dist-pkg/cli/cmd-docs.js

@@ -0,0 +1,122 @@
+import { dirname, join } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { createRouter } from "../router/scanner.js";
+import { createProjectContext } from "../runtime/project.js";
+import { initializeCompilerBackends } from "../compiler/init.js";
+import {
+  createRouteFactsArtifact,
+  inspectRouteFacts,
+  toRouteDocSurface
+} from "../compiler/route-facts.js";
+export const DOCS_ARTIFACT_SCHEMA_VERSION = 1;
+export function parseDocsFlags(args) {
+  const flags = { output: "docs/api.md", format: "md", routesOnly: !1, contracts: !1 };
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--output" && args[i + 1])
+      flags.output = args[++i];
+    else if (arg === "--format" && args[i + 1]) {
+      const fmt = args[++i];
+      if (fmt === "md" || fmt === "json" || fmt === "html")
+        flags.format = fmt;
+    } else if (arg === "--routes-only")
+      flags.routesOnly = !0;
+    else if (arg === "--contracts")
+      flags.contracts = !0;
+  }
+  return flags;
+}
+async function extractRouteInfo(route) {
+  const routeFacts = await inspectRouteFacts(route);
+  return extractRouteInfoFromFacts(routeFacts);
+}
+function extractRouteInfoFromFacts(routeFacts) {
+  return toRouteDocSurface(routeFacts);
+}
+function generateMarkdown(docs) {
+  const lines = ["# API Documentation", "", "| Path | Methods | Type | Loader | Middleware |", "| --- | --- | --- | --- | --- |"];
+  for (const doc of docs) {
+    const type = doc.isApi ? "API" : "Page", mw = doc.hasMiddleware ? "Yes" : "-";
+    lines.push(`| ${doc.path} | ${doc.methods.join(", ")} | ${type} | ${doc.hasLoader ? "Yes" : "-"} | ${mw} |`);
+  }
+  return lines.join(`
+`) + `
+`;
+}
+function generateJson(docs) {
+  return JSON.stringify(docs, null, 2) + `
+`;
+}
+export function summarizeRouteFacts(routeFacts) {
+  return {
+    totalRoutes: routeFacts.length,
+    pageRoutes: routeFacts.filter((route) => !route.isApi).length,
+    apiRoutes: routeFacts.filter((route) => route.isApi).length,
+    loaderRoutes: routeFacts.filter((route) => route.hasLoader).length,
+    middlewareRoutes: routeFacts.filter((route) => route.hasMiddleware).length,
+    prerenderedRoutes: routeFacts.filter((route) => route.declaresPrerender).length
+  };
+}
+export function createDocsArtifact(routeFacts) {
+  return {
+    schemaVersion: DOCS_ARTIFACT_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    summary: summarizeRouteFacts(routeFacts),
+    routes: routeFacts,
+    docs: routeFacts.map(extractRouteInfoFromFacts)
+  };
+}
+export function generateJsonArtifact(artifact) {
+  return JSON.stringify(artifact, null, 2) + `
+`;
+}
+function generateHtml(docs) {
+  return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>API Docs</title>
+<style>body{font-family:sans-serif;margin:2rem}table{border-collapse:collapse;width:100%}
+th,td{border:1px solid #ddd;padding:8px;text-align:left}th{background:#f5f5f5}</style>
+</head><body><h1>API Documentation</h1>
+<table><thead><tr><th>Path</th><th>Methods</th><th>Type</th><th>Loader</th><th>Middleware</th></tr></thead>
+  <tbody>${docs.map((d) => {
+    const type = d.isApi ? "API" : "Page", mw = d.hasMiddleware ? "Yes" : "-";
+    return `<tr><td>${d.path}</td><td>${d.methods.join(", ")}</td><td>${type}</td><td>${d.hasLoader ? "Yes" : "-"}</td><td>${mw}</td></tr>`;
+  }).join(`
+      `)}</tbody></table></body></html>
+`;
+}
+const GENERATORS = {
+  md: generateMarkdown,
+  json: generateJson,
+  html: generateHtml
+};
+export async function generateDocs(args, options = {}) {
+  const { cwd, paths } = createProjectContext(options);
+  initializeCompilerBackends(options.env ?? process.env);
+  const flags = parseDocsFlags(args), routes = await createRouter(paths.routesDir);
+  if (routes.length === 0) {
+    console.log(`
+  No routes found in routes/
+`);
+    return;
+  }
+  const routeFacts = await createRouteFactsArtifact(routes), docs = [];
+  for (const info of routeFacts.routes.map(extractRouteInfoFromFacts)) {
+    if (flags.routesOnly && info.isApi)
+      continue;
+    docs.push(info);
+  }
+  const generate = GENERATORS[flags.format], filteredRouteFacts = routeFacts.routes.filter((route) => {
+    const info = extractRouteInfoFromFacts(route);
+    return !(flags.routesOnly && info.isApi);
+  }), content = flags.format === "json" && flags.contracts ? generateJsonArtifact(createDocsArtifact(filteredRouteFacts)) : generate(docs), outputPath = join(cwd, flags.output);
+  await mkdir(dirname(outputPath), { recursive: !0 });
+  await writeFile(outputPath, content, "utf-8");
+  console.log(`
+  Generated docs for ${docs.length} routes -> ${flags.output}
+`);
+}
+export async function runDocs(args, options = {}) {
+  return generateDocs(args, options);
+}
+
+export { extractRouteInfo, extractRouteInfoFromFacts, generateMarkdown, generateJson, generateHtml };

package/dist-pkg/cli/cmd-generate.d.ts

@@ -0,0 +1,12 @@
+import { type RuntimeOptions } from "../runtime/project.js";
+export type GenerateDataMode = "memory" | "sqlite" | "postgres";
+export interface GenerateFlags {
+    entity: string | null;
+    data: GenerateDataMode | null;
+}
+export declare function parseGenerateFlags(args: string[]): GenerateFlags;
+export interface GenerateCommandOptions extends RuntimeOptions {
+}
+export declare function generateCrudScaffold(args: string[], options?: GenerateCommandOptions): Promise<void>;
+/** @deprecated Use generateCrudScaffold() for programmatic access. */
+export declare function runGenerate(args: string[], options?: GenerateCommandOptions): Promise<void>;