feat: create command (npm#18)

* feat: `create` command

* lint & format

* fix the test

* format

Author: yusukebe

README.md

@@ -1,4 +1,4 @@
-# @hono/cli
+# Hono CLI
 
 CLI for Hono
 
@@ -14,21 +14,77 @@ npm install -g @hono/cli
 # Show help
 hono --help
 
+# Create a new Hono project
+hono create
+
 # Say hello
 hono hello
 
-# Say hello to someone
-hono hello yusuke
-
-# Open documentation in browser
+# Open documentation
 hono docs
 ```
 
 ## Commands
 
+- `create [target]` - Create a new Hono project
 - `hello [name]` - Say hello (default: Hono)
 - `docs` - Open Hono documentation in browser
 
+### `create`
+
+Create a new Hono project using [create-hono](https://github.com/honojs/create-hono).
+
+```bash
+hono create [target] [options]
+```
+
+**Arguments:**
+
+- `target` - Target directory (optional)
+
+**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
+
+**Examples:**
+
+```bash
+# Interactive project creation
+hono create
+
+# Create project in specific directory
+hono create my-app
+
+# Create with Cloudflare Workers template
+hono create my-app --template cloudflare-workers
+
+# Create and install dependencies with Bun
+hono create my-app --pm bun --install
+```
+
+### `hello`
+
+Say hello command for testing purposes.
+
+```bash
+hono hello [name]
+```
+
+**Arguments:**
+
+- `name` - Name to greet (default: Hono)
+
+### `docs`
+
+Open Hono documentation in your default browser.
+
+```bash
+hono docs
+```
+
 ## Authors
 
 - Yusuke Wada https://github.com/yusukebe

src/cli.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander'
 import { readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { createCommand } from './commands/create/index.js'
 import { docsCommand } from './commands/docs/index.js'
 import { helloCommand } from './commands/hello/index.js'
 
@@ -19,6 +20,7 @@ program
   .version(packageJson.version, '-v, --version', 'display version number')
 
 // Register commands
+createCommand(program)
 helloCommand(program)
 docsCommand(program)
 

src/commands/create/index.test.ts

@@ -0,0 +1,99 @@
+import { Command } from 'commander'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+vi.mock('node:child_process', () => ({
+  spawn: vi.fn(),
+}))
+
+import { createCommand } from './index.js'
+
+describe('createCommand', () => {
+  let program: Command
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>
+
+  beforeEach(() => {
+    program = new Command()
+    createCommand(program)
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore()
+  })
+
+  it('should spawn npm create hono@latest with no arguments', async () => {
+    const { spawn } = await import('node:child_process')
+    const mockChildProcess = {
+      on: vi.fn((event, callback) => {
+        if (event === 'exit') {
+          callback(0)
+        }
+        return mockChildProcess
+      }),
+    }
+    vi.mocked(spawn).mockReturnValue(mockChildProcess as never)
+
+    await program.parseAsync(['node', 'test', 'create'])
+
+    // Currently, supporting only npm
+    expect(spawn).toHaveBeenCalledWith('npm', ['create', 'hono@latest'], {
+      stdio: 'inherit',
+    })
+  })
+
+  it('should spawn npm create hono@latest with target directory', async () => {
+    const { spawn } = await import('node:child_process')
+    const mockChildProcess = {
+      on: vi.fn((event, callback) => {
+        if (event === 'exit') {
+          callback(0)
+        }
+        return mockChildProcess
+      }),
+    }
+    vi.mocked(spawn).mockReturnValue(mockChildProcess as never)
+
+    await program.parseAsync(['node', 'test', 'create', 'my-app'])
+
+    expect(spawn).toHaveBeenCalledWith('npm', ['create', 'hono@latest', 'my-app'], {
+      stdio: 'inherit',
+    })
+  })
+
+  it('should handle spawn error gracefully', async () => {
+    const { spawn } = await import('node:child_process')
+    const mockChildProcess = {
+      on: vi.fn((event, callback) => {
+        if (event === 'error') {
+          callback(new Error('spawn ENOENT'))
+        }
+        return mockChildProcess
+      }),
+    }
+    vi.mocked(spawn).mockReturnValue(mockChildProcess as never)
+
+    await expect(program.parseAsync(['node', 'test', 'create'])).rejects.toThrow(
+      'Failed to execute npm: spawn ENOENT'
+    )
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith('Failed to execute npm: spawn ENOENT')
+  })
+
+  it('should throw error when npm exits with non-zero code', async () => {
+    const { spawn } = await import('node:child_process')
+    const mockChildProcess = {
+      on: vi.fn((event, callback) => {
+        if (event === 'exit') {
+          callback(1)
+        }
+        return mockChildProcess
+      }),
+    }
+    vi.mocked(spawn).mockReturnValue(mockChildProcess as never)
+
+    await expect(program.parseAsync(['node', 'test', 'create'])).rejects.toThrow(
+      'npm create hono@latest exited with code 1'
+    )
+  })
+})

src/commands/create/index.ts

@@ -0,0 +1,57 @@
+import type { Command } from 'commander'
+import { spawn } from 'node:child_process'
+
+export function createCommand(program: Command) {
+  program
+    .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: string,
+        options: { template?: string; install?: boolean; pm?: string; offline?: boolean }
+      ) => {
+        const args = ['create', 'hono@latest']
+
+        if (target) {
+          args.push(target)
+        }
+
+        // Add known options
+        if (options.template) {
+          args.push('--template', options.template)
+        }
+        if (options.install) {
+          args.push('--install')
+        }
+        if (options.pm) {
+          args.push('--pm', options.pm)
+        }
+        if (options.offline) {
+          args.push('--offline')
+        }
+
+        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}`)
+        })
+
+        npm.on('exit', (code) => {
+          if (code !== 0) {
+            throw new Error(`npm create hono@latest exited with code ${code}`)
+          }
+        })
+      }
+    )
+}