@hono/cli 0.0.1 → 0.1.1

package/README.md

@@ -1,6 +1,10 @@
 # Hono CLI
 
-CLI for Hono
+Hono CLI is a CLI for Humans and AI who use Hono.
+
+It's not a `create-*` command, not only for dev, build, and deploy, but also not a Vite wrapper. Built on an entirely new concept.
+
+Hono CLI will give you the `hono` command. For Humans, you can use sub-commands specialized for Hono for simple usages. For AI, providing sub-commands to build your Hono application efficiently with AI coding.
 
 ## Installation
 
@@ -14,59 +18,304 @@ npm install -g @hono/cli
 # Show help
 hono --help
 
-# Create a new Hono project
-hono create
-
-# Open documentation
+# Display documentation
 hono docs
+
+# Search documentation
+hono search middleware
+
+# Send request to Hono app
+hono request
+
+# Start server
+hono serve
+
+# Generate an optimized Hono app
+hono optimize
 ```
 
 ## Commands
 
-- `create [target]` - Create a new Hono project
-- `docs` - Open Hono documentation in browser
+- `docs [path]` - Display Hono documentation
+- `search <query>` - Search Hono documentation
+- `request [file]` - Send request to Hono app using `app.request()`
+- `serve [entry]` - Start server for Hono app
+- `optimize [entry]` - Generate an optimized Hono app
 
-### `create`
+### `docs`
 
-Create a new Hono project using [create-hono](https://github.com/honojs/create-hono).
+Display Hono documentation content directly in your terminal.
 
 ```bash
-hono create [target] [options]
+hono docs [path]
 ```
 
 **Arguments:**
 
-- `target` - Target directory (optional)
+- `path` - Documentation path (optional)
+
+**Examples:**
+
+```bash
+# Display main documentation summary (llms.txt)
+hono docs
+
+# Display specific documentation pages
+hono docs /docs/concepts/motivation
+hono docs /docs/guides/best-practices
+hono docs /docs/api/context
+
+# Display examples and tutorials
+hono docs /examples/stytch-auth
+hono docs /examples/basic
+```
+
+### `search`
+
+Search through Hono documentation using fuzzy search powered by Algolia.
+
+```bash
+hono search <query> [options]
+```
+
+**Arguments:**
+
+- `query` - Search query (required)
 
 **Options:**
 
-- `-t, --template <template>` - Template to use (aws-lambda, bun, cloudflare-workers, cloudflare-workers+vite, deno, fastly, lambda-edge, netlify, nextjs, nodejs, vercel, cloudflare-pages, x-basic)
-- `-i, --install` - Install dependencies
-- `-p, --pm <pm>` - Package manager to use (npm, bun, deno, pnpm, yarn)
-- `-o, --offline` - Use offline mode
+- `-l, --limit <number>` - Number of results to show (default: 5, max: 20)
+- `-p, --pretty` - Display results in human-readable format (default: JSON output)
 
 **Examples:**
 
 ```bash
-# Interactive project creation
-hono create
+# Search for middleware documentation (JSON output by default)
+hono search middleware
 
-# Create project in specific directory
-hono create my-app
+# Search with pretty formatting for human-readable output
+hono search middleware --pretty
+
+# Search with custom result limit
+hono search "getting started" --limit 10
+```
 
-# Create with Cloudflare Workers template
-hono create my-app --template cloudflare-workers
+**Output Format:**
 
-# Create and install dependencies with Bun
-hono create my-app --pm bun --install
+By default, the command outputs JSON for easy integration with other tools:
+
+```json
+{
+  "query": "middleware",
+  "total": 5,
+  "results": [
+    {
+      "title": "Middleware ​",
+      "category": "",
+      "url": "https://hono.dev/docs/guides/middleware#middleware",
+      "path": "/docs/guides/middleware"
+    },
+    {
+      "title": "Third-party Middleware - Hono",
+      "category": "Middleware",
+      "url": "https://hono.dev/docs/middleware/third-party#VPSidebarNav",
+      "path": "/docs/middleware/third-party"
+    }
+  ]
+}
 ```
 
-### `docs`
+With the `--pretty` flag, results are displayed in a human-readable format:
 
-Open Hono documentation in your default browser.
+```
+1. Middleware ​
+   URL: https://hono.dev/docs/guides/middleware#middleware
+   Command: hono docs /docs/guides/middleware
+
+2. Third-party Middleware - Hono
+   Category: Middleware
+   URL: https://hono.dev/docs/middleware/third-party#VPSidebarNav
+   Command: hono docs /docs/middleware/third-party
+```
+
+### `request`
+
+Send HTTP requests to your Hono application using the built-in `app.request()` method. This is particularly useful for testing and development.
 
 ```bash
-hono docs
+hono request [file] [options]
+```
+
+**Arguments:**
+
+- `file` - Path to the Hono app file (TypeScript/JSX supported, optional)
+
+**Options:**
+
+- `-P, --path <path>` - Request path (default: "/")
+- `-X, --method <method>` - HTTP method (default: GET)
+- `-d, --data <data>` - Request body data
+- `-H, --header <header>` - Custom headers (can be used multiple times)
+- `-w, --watch` - Watch for changes and resend request
+
+**Examples:**
+
+```bash
+# GET request to default app root (uses src/index.ts or src/index.tsx)
+hono request
+
+# GET request to specific path
+hono request -P /users/123
+
+# POST request with data
+hono request -P /api/users -X POST -d '{"name":"Alice"}'
+
+# Request to specific file
+hono request -P /api src/your-app.ts
+
+# Request with custom headers
+hono request -P /api/protected \
+  -H 'Authorization: Bearer token' \
+  -H 'User-Agent: MyApp' \
+  src/your-app.ts
+```
+
+**Response Format:**
+
+The command returns a JSON object with the following structure:
+
+```json
+{
+  "status": 200,
+  "body": "{\"message\":\"Hello World\"}",
+  "headers": {
+    "content-type": "application/json",
+    "x-custom-header": "value"
+  }
+}
+```
+
+### `serve`
+
+Start a server for your Hono application. This is a simple server specialized for Hono applications with built-in TypeScript and JSX support.
+
+```bash
+hono serve [entry] [options]
+```
+
+**Arguments:**
+
+- `entry` - Entry file for your Hono app (TypeScript/JSX supported, optional)
+
+**Options:**
+
+- `-p, --port <port>` - Port number (default: 7070)
+- `--show-routes` - Show registered routes
+- `--use <middleware>` - Use middleware (can be used multiple times)
+
+**Examples:**
+
+```bash
+# Start server with default empty app (no entry file needed)
+hono serve
+
+# Start server on specific port
+hono serve -p 3000 src/app.ts
+
+# Start server with specific entry file
+hono serve src/app.ts
+
+# Start server and show routes
+hono serve --show-routes src/app.ts
+
+# Start server with middleware
+hono serve --use 'cors()' src/app.ts
+
+# Start server with multiple middleware
+hono serve --use 'cors()' --use 'logger()' src/app.ts
+
+# Start server with authentication and static file serving
+hono serve \
+  --use 'basicAuth({ username: "foo", password: "bar" })' \
+  --use "serveStatic({ root: './' })"
+```
+
+### `optimize`
+
+Generate an optimized Hono class and export bundled file.
+
+```bash
+hono optimize [entry] [options]
+```
+
+**Arguments:**
+
+- `entry` - Entry file for your Hono app (TypeScript/JSX supported, optional)
+
+**Options:**
+
+- `-o, --outfile <outfile>` - Output file
+
+**Examples:**
+
+```bash
+# Generate an optimized Hono class and export bundled file to dist/index.js
+hono optimize
+
+# Specify entry file and output file
+hono optimize -o dist/app.js src/app.ts
+
+# Export bundled file with minification
+hono optimize -m
+```
+
+## Tips
+
+### Using Hono CLI with AI Code Agents
+
+When working with AI code agents like Claude Code, you can configure them to use the `hono` CLI for efficient documentation access and testing. Add the following to your project's `CLAUDE.md` or similar configuration:
+
+````markdown
+## Hono Development
+
+Use the `hono` CLI for efficient development. View all commands with `hono --help`.
+
+### Core Commands
+
+- **`hono docs [path]`** - Browse Hono documentation
+- **`hono search <query>`** - Search documentation
+- **`hono request [file]`** - Test app requests without starting a server
+
+### Quick Examples
+
+```bash
+# Search for topics
+hono search middleware
+hono search "getting started"
+
+# View documentation
+hono docs /docs/api/context
+hono docs /docs/guides/middleware
+
+# Test your app
+hono request -P /api/users src/index.ts
+hono request -P /api/users -X POST -d '{"name":"Alice"}' src/index.ts
+```
+
+### Workflow
+
+1. Search documentation: `hono search <query>`
+2. Read relevant docs: `hono docs [path]`
+3. Test implementation: `hono request [file]`
+````
+
+### Pipeline Integration with jq
+
+The `search` command outputs JSON by default, making it easy to pipe results to other commands:
+
+```bash
+# Search and view documentation in one command
+hono search "middleware" | jq '.results[0].path' | hono docs
 ```
 
 ## Authors

package/dist/cli.js

@@ -3,84 +3,578 @@
 // src/cli.ts
 import { Command } from "commander";
 import { readFileSync } from "fs";
-import { dirname, join } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 import { fileURLToPath } from "url";
 
-// src/commands/create/index.ts
-import { spawn } from "child_process";
-function createCommand(program2) {
-  program2.command("create").description("Create a new Hono project").argument("[target]", "target directory").option(
-    "-t, --template <template>",
-    "Template to use (aws-lambda, bun, cloudflare-workers, cloudflare-workers+vite, deno, fastly, lambda-edge, netlify, nextjs, nodejs, vercel, cloudflare-pages, x-basic)"
-  ).option("-i, --install", "Install dependencies").option("-p, --pm <pm>", "Package manager to use (npm, bun, deno, pnpm, yarn)").option("-o, --offline", "Use offline mode").action(
-    (target, options) => {
-      const args = ["create", "hono@latest"];
-      if (target) {
-        args.push(target);
+// src/commands/docs/index.ts
+async function fetchAndDisplayContent(url, fallbackUrl) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch documentation: ${response.status} ${response.statusText}`);
+    }
+    const content = await response.text();
+    console.log("\n" + content);
+  } catch (error) {
+    console.error(
+      "Error fetching documentation:",
+      error instanceof Error ? error.message : String(error)
+    );
+    console.log(`
+Please visit: ${fallbackUrl || "https://hono.dev/docs"}`);
+  }
+}
+function docsCommand(program2) {
+  program2.command("docs").argument(
+    "[path]",
+    "Documentation path (e.g., /docs/concepts/motivation, /examples/stytch-auth)",
+    ""
+  ).description("Display Hono documentation").action(async (path) => {
+    let finalPath = path;
+    if (!path) {
+      if (!process.stdin.isTTY) {
+        try {
+          const chunks = [];
+          for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+          }
+          const stdinInput = Buffer.concat(chunks).toString().trim();
+          if (stdinInput) {
+            finalPath = stdinInput.replace(/^["'](.*)["']$/, "$1");
+          }
+        } catch (error) {
+          console.error("Error reading from stdin:", error);
+        }
       }
-      if (options.template) {
-        args.push("--template", options.template);
+      if (!finalPath) {
+        console.log("Fetching Hono documentation...");
+        await fetchAndDisplayContent("https://hono.dev/llms.txt");
+        return;
       }
-      if (options.install) {
-        args.push("--install");
+    }
+    const normalizedPath = finalPath.startsWith("/") ? finalPath : `/${finalPath}`;
+    const basePath = normalizedPath.slice(1);
+    const markdownUrl = `https://raw.githubusercontent.com/honojs/website/refs/heads/main/${basePath}.md`;
+    const webUrl = `https://hono.dev${normalizedPath}`;
+    console.log(`Fetching Hono documentation for ${finalPath}...`);
+    await fetchAndDisplayContent(markdownUrl, webUrl);
+  });
+}
+
+// src/commands/optimize/index.ts
+import * as esbuild2 from "esbuild";
+import { buildInitParams, serializeInitParams } from "hono/router/reg-exp-router";
+import { execFile } from "child_process";
+import { existsSync, realpathSync, statSync } from "fs";
+import { dirname, join, resolve } from "path";
+
+// src/utils/build.ts
+import * as esbuild from "esbuild";
+async function* buildAndImportApp(filePath, options = {}) {
+  let resolveApp;
+  let appPromise;
+  const preparePromise = () => {
+    appPromise = new Promise((resolve4) => {
+      resolveApp = resolve4;
+    });
+  };
+  preparePromise();
+  const context2 = await esbuild.context({
+    entryPoints: [filePath],
+    bundle: true,
+    write: false,
+    format: "esm",
+    target: "node20",
+    jsx: "automatic",
+    jsxImportSource: "hono/jsx",
+    platform: "node",
+    external: options.external || [],
+    plugins: [
+      {
+        name: "watch",
+        setup(build2) {
+          build2.onEnd(async (result) => {
+            try {
+              const code = result.outputFiles?.[0]?.text || "";
+              const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+              const module = await import(dataUrl);
+              const app = module.default;
+              if (!app) {
+                throw new Error("Failed to build app");
+              }
+              if (!app || typeof app.request !== "function") {
+                throw new Error("No valid Hono app exported from the file");
+              }
+              try {
+                resolveApp(app);
+              } catch {
+              }
+            } catch (error) {
+              console.error("Error building app", error);
+            }
+          });
+        }
       }
-      if (options.pm) {
-        args.push("--pm", options.pm);
+    ]
+  });
+  await context2.watch();
+  if (!options.watch) {
+    await context2.dispose();
+  }
+  do {
+    yield await appPromise;
+    preparePromise();
+  } while (options.watch);
+}
+
+// src/commands/optimize/index.ts
+var DEFAULT_ENTRY_CANDIDATES = ["src/index.ts", "src/index.tsx", "src/index.js", "src/index.jsx"];
+function optimizeCommand(program2) {
+  program2.command("optimize").description("Build optimized Hono class").argument("[entry]", "entry file").option("-o, --outfile [outfile]", "output file", "dist/index.js").option("-m, --minify", "minify output file").action(async (entry, options) => {
+    if (!entry) {
+      entry = DEFAULT_ENTRY_CANDIDATES.find((entry2) => existsSync(entry2)) ?? DEFAULT_ENTRY_CANDIDATES[0];
+    }
+    const appPath = resolve(process.cwd(), entry);
+    if (!existsSync(appPath)) {
+      throw new Error(`Entry file ${entry} does not exist`);
+    }
+    const appFilePath = realpathSync(appPath);
+    const buildIterator = buildAndImportApp(appFilePath, {
+      external: ["@hono/node-server"]
+    });
+    const app = (await buildIterator.next()).value;
+    let routerName;
+    let importStatement;
+    let assignRouterStatement;
+    try {
+      const serialized = serializeInitParams(
+        buildInitParams({
+          paths: app.routes.map(({ path }) => path)
+        })
+      );
+      const hasPreparedRegExpRouter = await new Promise((resolve4) => {
+        const child = execFile(process.execPath, [
+          "--input-type=module",
+          "-e",
+          "try { (await import('hono/router/reg-exp-router')).PreparedRegExpRouter && process.exit(0) } finally { process.exit(1) }"
+        ]);
+        child.on("exit", (code) => {
+          resolve4(code === 0);
+        });
+      });
+      if (hasPreparedRegExpRouter) {
+        routerName = "PreparedRegExpRouter";
+        importStatement = "import { PreparedRegExpRouter } from 'hono/router/reg-exp-router'";
+        assignRouterStatement = `const routerParams = ${serialized}
+    this.router = new PreparedRegExpRouter(...routerParams)`;
+      } else {
+        routerName = "RegExpRouter";
+        importStatement = "import { RegExpRouter } from 'hono/router/reg-exp-router'";
+        assignRouterStatement = "this.router = new RegExpRouter()";
       }
-      if (options.offline) {
-        args.push("--offline");
+    } catch {
+      routerName = "TrieRouter";
+      importStatement = "import { TrieRouter } from 'hono/router/trie-router'";
+      assignRouterStatement = "this.router = new TrieRouter()";
+    }
+    console.log("[Optimized]");
+    console.log(`  Router: ${routerName}`);
+    const outfile = resolve(process.cwd(), options.outfile);
+    await esbuild2.build({
+      entryPoints: [appFilePath],
+      outfile,
+      bundle: true,
+      minify: options.minify,
+      format: "esm",
+      target: "node20",
+      platform: "node",
+      jsx: "automatic",
+      jsxImportSource: "hono/jsx",
+      plugins: [
+        {
+          name: "hono-optimize",
+          setup(build2) {
+            const honoPseudoImportPath = "hono-optimized-pseudo-import-path";
+            build2.onResolve({ filter: /^hono$/ }, async (args) => {
+              if (!args.importer) {
+                return void 0;
+              }
+              const resolved = await build2.resolve(args.path, {
+                kind: "import-statement",
+                resolveDir: args.resolveDir
+              });
+              return {
+                path: join(dirname(resolved.path), honoPseudoImportPath)
+              };
+            });
+            build2.onLoad({ filter: new RegExp(`/${honoPseudoImportPath}$`) }, async () => {
+              return {
+                contents: `
+import { HonoBase } from 'hono/hono-base'
+${importStatement}
+export class Hono extends HonoBase {
+  constructor(options = {}) {
+    super(options)
+    ${assignRouterStatement}
+  }
+}
+`
+              };
+            });
+          }
+        }
+      ]
+    });
+    const outfileStat = statSync(outfile);
+    console.log(`  Output: ${options.outfile} (${(outfileStat.size / 1024).toFixed(2)} KB)`);
+  });
+}
+
+// src/commands/request/index.ts
+import { existsSync as existsSync2, realpathSync as realpathSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+var DEFAULT_ENTRY_CANDIDATES2 = ["src/index.ts", "src/index.tsx", "src/index.js", "src/index.jsx"];
+function requestCommand(program2) {
+  program2.command("request").description("Send request to Hono app using app.request()").argument("[file]", "Path to the Hono app file").option("-P, --path <path>", "Request path", "/").option("-X, --method <method>", "HTTP method", "GET").option("-d, --data <data>", "Request body data").option("-w, --watch", "Watch for changes and re-run the request", false).option(
+    "-H, --header <header>",
+    "Custom headers",
+    (value, previous) => {
+      return previous ? [...previous, value] : [value];
+    },
+    []
+  ).action(async (file, options) => {
+    const path = options.path || "/";
+    const watch = options.watch;
+    const buildIterator = getBuildIterator(file, watch);
+    for await (const app of buildIterator) {
+      const result = await executeRequest(app, path, options);
+      console.log(JSON.stringify(result, null, 2));
+    }
+  });
+}
+function getBuildIterator(appPath, watch) {
+  let entry;
+  let resolvedAppPath;
+  if (appPath) {
+    entry = appPath;
+    resolvedAppPath = resolve2(process.cwd(), entry);
+  } else {
+    entry = DEFAULT_ENTRY_CANDIDATES2.find((candidate) => existsSync2(resolve2(process.cwd(), candidate))) ?? DEFAULT_ENTRY_CANDIDATES2[0];
+    resolvedAppPath = resolve2(process.cwd(), entry);
+  }
+  if (!existsSync2(resolvedAppPath)) {
+    throw new Error(`Entry file ${entry} does not exist`);
+  }
+  const appFilePath = realpathSync2(resolvedAppPath);
+  return buildAndImportApp(appFilePath, {
+    external: ["@hono/node-server"],
+    watch
+  });
+}
+async function executeRequest(app, requestPath, options) {
+  const url = new URL(requestPath, "http://localhost");
+  const requestInit = {
+    method: options.method || "GET"
+  };
+  if (options.data) {
+    requestInit.body = options.data;
+  }
+  if (options.header && options.header.length > 0) {
+    const headers = new Headers();
+    for (const header of options.header) {
+      const [key, value] = header.split(":", 2);
+      if (key && value) {
+        headers.set(key.trim(), value.trim());
       }
-      const npm = spawn("npm", args, {
-        stdio: "inherit"
-      });
-      npm.on("error", (error) => {
-        console.error(`Failed to execute npm: ${error.message}`);
-        throw new Error(`Failed to execute npm: ${error.message}`);
+    }
+    requestInit.headers = headers;
+  }
+  const request = new Request(url.href, requestInit);
+  const response = await app.request(request);
+  const responseHeaders = {};
+  response.headers.forEach((value, key) => {
+    responseHeaders[key] = value;
+  });
+  const body = await response.text();
+  return {
+    status: response.status,
+    body,
+    headers: responseHeaders
+  };
+}
+
+// src/commands/search/index.ts
+function searchCommand(program2) {
+  program2.command("search").argument("<query>", "Search query for Hono documentation").option("-l, --limit <number>", "Number of results to show (default: 5)", (value) => {
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed) || parsed < 1 || parsed > 20) {
+      console.warn("Limit must be a number between 1 and 20\n");
+      return 5;
+    }
+    return parsed;
+  }).option("-p, --pretty", "Display results in human-readable format").description("Search Hono documentation").action(async (query, options) => {
+    const ALGOLIA_APP_ID = "1GIFSU1REV";
+    const ALGOLIA_API_KEY = "c6a0f86b9a9f8551654600f28317a9e9";
+    const ALGOLIA_INDEX = "hono";
+    const searchUrl = `https://${ALGOLIA_APP_ID}-dsn.algolia.net/1/indexes/${ALGOLIA_INDEX}/query`;
+    try {
+      if (options.pretty) {
+        console.log(`Searching for "${query}"...`);
+      }
+      const response = await fetch(searchUrl, {
+        method: "POST",
+        headers: {
+          "X-Algolia-API-Key": ALGOLIA_API_KEY,
+          "X-Algolia-Application-Id": ALGOLIA_APP_ID,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          query,
+          hitsPerPage: options.limit || 5
+        })
       });
-      npm.on("exit", (code) => {
-        if (code !== 0) {
-          throw new Error(`npm create hono@latest exited with code ${code}`);
+      if (!response.ok) {
+        throw new Error(`Search failed: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.hits.length === 0) {
+        if (options.pretty) {
+          console.log("\nNo results found.");
+        } else {
+          console.log(JSON.stringify({ query, total: 0, results: [] }, null, 2));
+        }
+        return;
+      }
+      const cleanHighlight = (text) => text.replace(/<[^>]*>/g, "");
+      const results = data.hits.map((hit) => {
+        let title = hit.title;
+        let highlightedTitle = title;
+        if (!title && hit._highlightResult?.hierarchy?.lvl1) {
+          title = cleanHighlight(hit._highlightResult.hierarchy.lvl1.value);
+          highlightedTitle = hit._highlightResult.hierarchy.lvl1.value;
+        }
+        if (!title) {
+          title = hit.hierarchy?.lvl1 || hit.hierarchy?.lvl0 || "Untitled";
+          highlightedTitle = title;
+        }
+        const hierarchyParts = [];
+        if (hit.hierarchy?.lvl0 && hit.hierarchy.lvl0 !== "Documentation") {
+          hierarchyParts.push(hit.hierarchy.lvl0);
+        }
+        if (hit.hierarchy?.lvl1 && hit.hierarchy.lvl1 !== title) {
+          hierarchyParts.push(cleanHighlight(hit.hierarchy.lvl1));
         }
+        if (hit.hierarchy?.lvl2) {
+          hierarchyParts.push(cleanHighlight(hit.hierarchy.lvl2));
+        }
+        const category = hierarchyParts.length > 0 ? hierarchyParts.join(" > ") : "";
+        const url = hit.url;
+        const urlPath = new URL(url).pathname;
+        return {
+          title,
+          highlightedTitle,
+          category,
+          url,
+          path: urlPath
+        };
       });
+      if (options.pretty) {
+        console.log(`
+Found ${data.hits.length} results:
+`);
+        const formatHighlight = (text) => {
+          return text.replace(/<span class="algolia-docsearch-suggestion--highlight">/g, "\x1B[33m").replace(/<\/span>/g, "\x1B[0m");
+        };
+        results.forEach((result, index) => {
+          console.log(`${index + 1}. ${formatHighlight(result.highlightedTitle || result.title)}`);
+          if (result.category) {
+            console.log(`   Category: ${result.category}`);
+          }
+          console.log(`   URL: ${result.url}`);
+          console.log(`   Command: hono docs ${result.path}`);
+          console.log("");
+        });
+      } else {
+        const jsonResults = results.map(({ highlightedTitle, ...result }) => result);
+        console.log(
+          JSON.stringify(
+            {
+              query,
+              total: data.hits.length,
+              results: jsonResults
+            },
+            null,
+            2
+          )
+        );
+      }
+    } catch (error) {
+      console.error(
+        "Error searching documentation:",
+        error instanceof Error ? error.message : String(error)
+      );
+      console.log("\nPlease visit: https://hono.dev/docs");
     }
-  );
+  });
 }
 
-// src/commands/docs/index.ts
-import { exec } from "child_process";
-import { platform } from "os";
-function docsCommand(program2) {
-  program2.command("docs").description("Open Hono documentation in browser").action(() => {
-    const url = "https://hono.dev";
-    let openCommand;
-    switch (platform()) {
-      case "darwin":
-        openCommand = "open";
-        break;
-      case "win32":
-        openCommand = "start";
-        break;
-      default:
-        openCommand = "xdg-open";
-        break;
-    }
-    exec(`${openCommand} ${url}`, (error) => {
-      if (error) {
-        console.error(`Failed to open browser: ${error.message}`);
-        console.log(`Please visit: ${url}`);
+// src/commands/serve/index.ts
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+import { showRoutes } from "hono/dev";
+import { existsSync as existsSync3, realpathSync as realpathSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/commands/serve/builtin-map.ts
+var builtinMap = {
+  // Authentication
+  basicAuth: "hono/basic-auth",
+  bearerAuth: "hono/bearer-auth",
+  // Security & Validation
+  csrf: "hono/csrf",
+  secureHeaders: "hono/secure-headers",
+  jwt: "hono/jwt",
+  jwk: "hono/jwk",
+  // Request/Response Processing
+  cors: "hono/cors",
+  etag: "hono/etag",
+  compress: "hono/compress",
+  prettyJSON: "hono/pretty-json",
+  bodyLimit: "hono/body-limit",
+  combine: "hono/combine",
+  contextStorage: "hono/context-storage",
+  methodOverride: "hono/method-override",
+  trailingSlash: "hono/trailing-slash",
+  // Utilities & Performance
+  cache: "hono/cache",
+  timeout: "hono/timeout",
+  poweredBy: "hono/powered-by",
+  // Logging & Monitoring
+  logger: "hono/logger",
+  timing: "hono/timing",
+  requestId: "hono/request-id",
+  // Internationalization
+  language: "hono/language",
+  // Access Control
+  ipRestriction: "hono/ip-restriction",
+  // Rendering
+  jsxRenderer: "hono/jsx-renderer",
+  // Static Files (Node.js specific)
+  serveStatic: "@hono/node-server/serve-static",
+  // Helpers - Accepts
+  accepts: "hono/accepts",
+  // Helpers - Adapter
+  env: "hono/adapter",
+  getRuntimeKey: "hono/adapter",
+  // Helpers - Connection Info (Node.js specific)
+  getConnInfo: "@hono/node-server/conninfo",
+  // Helpers - Cookie
+  getCookie: "hono/cookie",
+  getSignedCookie: "hono/cookie",
+  setCookie: "hono/cookie",
+  setSignedCookie: "hono/cookie",
+  deleteCookie: "hono/cookie",
+  // Helpers - CSS
+  css: "hono/css",
+  rawCssString: "hono/css",
+  viewTransition: "hono/css",
+  createCssContext: "hono/css",
+  createCssMiddleware: "hono/css",
+  // Helpers - HTML
+  html: "hono/html",
+  raw: "hono/html",
+  // Helpers - JWT (different from middleware)
+  sign: "hono/jwt",
+  verify: "hono/jwt",
+  decode: "hono/jwt",
+  // Helpers - Proxy
+  proxy: "hono/proxy",
+  // Helpers - Streaming
+  stream: "hono/streaming",
+  streamText: "hono/streaming",
+  streamSSE: "hono/streaming"
+};
+
+// src/commands/serve/index.ts
+[serveStatic].forEach((f) => {
+  if (typeof f === "function") {
+  }
+});
+function serveCommand(program2) {
+  program2.command("serve").description("Start server").argument("[entry]", "entry file").option("-p, --port <port>", "port number").option("--show-routes", "show registered routes").option(
+    "--use <middleware>",
+    "use middleware",
+    (value, previous) => {
+      return previous ? [...previous, value] : [value];
+    },
+    []
+  ).action(
+    async (entry, options) => {
+      let app;
+      if (!entry) {
+        app = new Hono();
       } else {
-        console.log(`Opening ${url} in your browser...`);
+        const appPath = resolve3(process.cwd(), entry);
+        if (!existsSync3(appPath)) {
+          app = new Hono();
+        } else {
+          const appFilePath = realpathSync3(appPath);
+          const buildIterator = buildAndImportApp(appFilePath, {
+            external: ["@hono/node-server"]
+          });
+          app = (await buildIterator.next()).value;
+        }
       }
-    });
-  });
+      const allFunctions = {};
+      const uniqueModules = [...new Set(Object.values(builtinMap))];
+      for (const modulePath of uniqueModules) {
+        try {
+          const module = await import(modulePath);
+          for (const [funcName, modulePathInMap] of Object.entries(builtinMap)) {
+            if (modulePathInMap === modulePath && module[funcName]) {
+              allFunctions[funcName] = module[funcName];
+            }
+          }
+        } catch (error) {
+        }
+      }
+      const baseApp = new Hono();
+      for (const use of options.use || []) {
+        const functionNames = Object.keys(allFunctions);
+        const functionValues = Object.values(allFunctions);
+        const func = new Function("c", "next", ...functionNames, `return (${use})`);
+        baseApp.use(async (c, next) => {
+          const middleware = func(c, next, ...functionValues);
+          return typeof middleware === "function" ? middleware(c, next) : middleware;
+        });
+      }
+      baseApp.route("/", app);
+      if (options.showRoutes) {
+        showRoutes(baseApp);
+      }
+      serve(
+        {
+          fetch: baseApp.fetch,
+          port: options.port ? Number.parseInt(options.port) : 7070
+        },
+        (info) => {
+          console.log(`Listening on http://localhost:${info.port}`);
+        }
+      );
+    }
+  );
 }
 
 // src/cli.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
+var __dirname = dirname2(__filename);
+var packageJson = JSON.parse(readFileSync(join2(__dirname, "../package.json"), "utf-8"));
 var program = new Command();
 program.name("hono").description("CLI for Hono").version(packageJson.version, "-v, --version", "display version number");
-createCommand(program);
 docsCommand(program);
+optimizeCommand(program);
+searchCommand(program);
+requestCommand(program);
+serveCommand(program);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/cli",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "type": "module",
   "bin": {
     "hono": "dist/cli.js"
@@ -33,13 +33,15 @@
   },
   "homepage": "https://hono.dev",
   "dependencies": {
-    "commander": "^14.0.1"
+    "@hono/node-server": "^1.19.5",
+    "commander": "^14.0.1",
+    "esbuild": "^0.25.10",
+    "hono": "^4.9.12"
   },
   "devDependencies": {
     "@hono/eslint-config": "^1.1.1",
     "@types/node": "^24.7.0",
     "eslint": "^9.37.0",
-    "hono": "4.4.13",
     "np": "^10.2.0",
     "prettier": "^3.6.2",
     "publint": "^0.3.14",